libX11 pixman mesa git update 12 Mar 2011

46 files changed, 27819 insertions, 27786 deletions

diff --git a/libX11/modules/im/ximcp/imThaiFlt.c b/libX11/modules/im/ximcp/imThaiFlt.c
index e0b3988e3..d22b13038 100644
--- a/libX11/modules/im/ximcp/imThaiFlt.c
+++ b/libX11/modules/im/ximcp/imThaiFlt.c
@@ -1,1414 +1,1421 @@
-/***********************************************************
-
-Copyright 1993, 1998  The Open Group
-
-Permission to use, copy, modify, distribute, and sell this software and its
-documentation for any purpose is hereby granted without fee, provided that
-the above copyright notice appear in all copies and that both that
-copyright notice and this permission notice appear in supporting
-documentation.
-
-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 THE
-OPEN GROUP 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.
-
-Except as contained in this notice, the name of The Open Group shall not be
-used in advertising or otherwise to promote the sale, use or other dealings
-in this Software without prior written authorization from The Open Group.
-
-
-Copyright 1993 by Digital Equipment Corporation, Maynard, Massachusetts.
-
-                        All Rights Reserved
-
-Permission to use, copy, modify, and distribute this software and its
-documentation for any purpose and without fee is hereby granted,
-provided that the above copyright notice appear in all copies and that
-both that copyright notice and this permission notice appear in
-supporting documentation, and that the name of Digital not be
-used in advertising or publicity pertaining to distribution of the
-software without specific, written prior permission.
-
-DIGITAL DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE, INCLUDING
-ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS, IN NO EVENT SHALL
-DIGITAL BE LIABLE FOR ANY SPECIAL, INDIRECT OR CONSEQUENTIAL DAMAGES OR
-ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS,
-WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION,
-ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS
-SOFTWARE.
-
-******************************************************************/
-
-/*
-**++
-**  FACILITY:
-**
-**      Xlib
-**
-**  ABSTRACT:
-**
-**	Thai specific functions.
-**	Handles character classifications, composibility checking,
-**	Input sequence check and other Thai specific requirements
-**	according to WTT specification and DEC extensions.
-**
-**  MODIFICATION HISTORY:
-**
-**/
-
-#ifdef HAVE_CONFIG_H
-#include <config.h>
-#endif
-#include <stdio.h>
-#include <X11/Xlib.h>
-#include <X11/Xmd.h>
-#include <X11/keysym.h>
-#include <X11/Xutil.h>
-#include "Xlibint.h"
-#include "Xlcint.h"
-#include "Ximint.h"
-#include "XimThai.h"
-#include "XlcPubI.h"
-
-
-#define SPACE   32
-
-/* character classification table */
-#define TACTIS_CHARS 256
-Private
-char const tactis_chtype[TACTIS_CHARS] = {
-    CTRL, CTRL, CTRL, CTRL, CTRL, CTRL, CTRL, CTRL,  /*  0 -  7 */
-    CTRL, CTRL, CTRL, CTRL, CTRL, CTRL, CTRL, CTRL,  /*  8 - 15 */
-    CTRL, CTRL, CTRL, CTRL, CTRL, CTRL, CTRL, CTRL,  /* 16 - 23 */
-    CTRL, CTRL, CTRL, CTRL, CTRL, CTRL, CTRL, CTRL,  /* 24 - 31 */
-    NON,  NON,  NON,  NON,  NON,  NON,  NON,  NON,   /* 32 - 39 */
-    NON,  NON,  NON,  NON,  NON,  NON,  NON,  NON,   /* 40 - 47 */
-    NON,  NON,  NON,  NON,  NON,  NON,  NON,  NON,   /* 48 - 55 */
-    NON,  NON,  NON,  NON,  NON,  NON,  NON,  NON,   /* 56 - 63 */
-    NON,  NON,  NON,  NON,  NON,  NON,  NON,  NON,   /* 64 - 71 */
-    NON,  NON,  NON,  NON,  NON,  NON,  NON,  NON,   /* 72 - 79 */
-    NON,  NON,  NON,  NON,  NON,  NON,  NON,  NON,   /* 80 - 87 */
-    NON,  NON,  NON,  NON,  NON,  NON,  NON,  NON,   /* 88 - 95 */
-    NON,  NON,  NON,  NON,  NON,  NON,  NON,  NON,   /* 96 - 103 */
-    NON,  NON,  NON,  NON,  NON,  NON,  NON,  NON,   /* 104 - 111 */
-    NON,  NON,  NON,  NON,  NON,  NON,  NON,  NON,   /* 112 - 119 */
-    NON,  NON,  NON,  NON,  NON,  NON,  NON,  CTRL,  /* 120 - 127 */
-    CTRL, CTRL, CTRL, CTRL, CTRL, CTRL, CTRL, CTRL,  /* 128 - 135 */
-    CTRL, CTRL, CTRL, CTRL, CTRL, CTRL, CTRL, CTRL,  /* 136 - 143 */
-    CTRL, CTRL, CTRL, CTRL, CTRL, CTRL, CTRL, CTRL,  /* 144 - 151 */
-    CTRL, CTRL, CTRL, CTRL, CTRL, CTRL, CTRL, CTRL,  /* 152 - 159 */
-    NON,  CONS, CONS, CONS, CONS, CONS, CONS, CONS,  /* 160 - 167 */
-    CONS, CONS, CONS, CONS, CONS, CONS, CONS, CONS,  /* 168 - 175 */
-    CONS, CONS, CONS, CONS, CONS, CONS, CONS, CONS,  /* 176 - 183 */
-    CONS, CONS, CONS, CONS, CONS, CONS, CONS, CONS,  /* 184 - 191 */
-    CONS, CONS, CONS, CONS,  FV3, CONS,  FV3, CONS,  /* 192 - 199 */
-    CONS, CONS, CONS, CONS, CONS, CONS, CONS, NON,   /* 200 - 207 */
-    FV1,  AV2,  FV1,  FV1,  AV1,  AV3,  AV2,  AV3,   /* 208 - 215 */
-    BV1,  BV2,  BD,   NON,  NON,  NON,  NON,  NON,   /* 216 - 223 */
-    LV,   LV,   LV,   LV,   LV,   FV2,  NON,  AD2,   /* 224 - 231 */
-    TONE, TONE, TONE, TONE, AD1,  AD1,  AD3,  NON,   /* 232 - 239 */
-    NON,  NON,  NON,  NON,  NON,  NON,  NON,  NON,   /* 240 - 247 */
-    NON,  NON,  NON,  NON,  NON,  NON,  NON,  CTRL   /* 248 - 255 */
-};
-
-/* Composibility checking tables */
-#define NC  0   /* NOT COMPOSIBLE - following char displays in next cell */
-#define CP  1   /* COMPOSIBLE - following char is displayed in the same cell
-                                as leading char, also implies ACCEPT */
-#define XC  3   /* Non-display */
-#define AC  4   /* ACCEPT - display the following char in the next cell */
-#define RJ  5   /* REJECT - discard that following char, ignore it */
-
-#define CH_CLASSES      17  /* 17 classes of chars */
-
-Private
-char const write_rules_lookup[CH_CLASSES][CH_CLASSES] = {
-        /* Table 0: writing/outputing rules */
-        /* row: leading char,  column: following char */
-/* CTRL NON CONS LV FV1 FV2 FV3 BV1 BV2 BD TONE AD1 AD2 AD3 AV1 AV2 AV3 */
-   {XC, NC, NC, NC, NC, NC, NC, NC, NC, NC, NC, NC, NC, NC, NC, NC, NC}/*CTRL*/
-  ,{XC, NC, NC, NC, NC, NC, NC, NC, NC, NC, NC, NC, NC, NC, NC, NC, NC}/*NON*/
-  ,{XC, NC, NC, NC, NC, NC, NC, CP, CP, CP, CP, CP, CP, CP, CP, CP, CP}/*CONS*/
-  ,{XC, NC, NC, NC, NC, NC, NC, NC, NC, NC, NC, NC, NC, NC, NC, NC, NC}/*LV*/
-  ,{XC, NC, NC, NC, NC, NC, NC, NC, NC, NC, NC, NC, NC, NC, NC, NC, NC}/*FV1*/
-  ,{XC, NC, NC, NC, NC, NC, NC, NC, NC, NC, NC, NC, NC, NC, NC, NC, NC}/*FV2*/
-  ,{XC, NC, NC, NC, NC, NC, NC, NC, NC, NC, NC, NC, NC, NC, NC, NC, NC}/*FV3*/
-  ,{XC, NC, NC, NC, NC, NC, NC, NC, NC, NC, CP, CP, NC, NC, NC, NC, NC}/*BV1*/
-  ,{XC, NC, NC, NC, NC, NC, NC, NC, NC, NC, CP, NC, NC, NC, NC, NC, NC}/*BV2*/
-  ,{XC, NC, NC, NC, NC, NC, NC, NC, NC, NC, NC, NC, NC, NC, NC, NC, NC}/*BD*/
-  ,{XC, NC, NC, NC, NC, NC, NC, NC, NC, NC, NC, NC, NC, NC, NC, NC, NC}/*TONE*/
-  ,{XC, NC, NC, NC, NC, NC, NC, NC, NC, NC, NC, NC, NC, NC, NC, NC, NC}/*AD1*/
-  ,{XC, NC, NC, NC, NC, NC, NC, NC, NC, NC, NC, NC, NC, NC, NC, NC, NC}/*AD2*/
-  ,{XC, NC, NC, NC, NC, NC, NC, NC, NC, NC, NC, NC, NC, NC, NC, NC, NC}/*AD3*/
-  ,{XC, NC, NC, NC, NC, NC, NC, NC, NC, NC, CP, CP, NC, NC, NC, NC, NC}/*AV1*/
-  ,{XC, NC, NC, NC, NC, NC, NC, NC, NC, NC, CP, NC, NC, NC, NC, NC, NC}/*AV2*/
-  ,{XC, NC, NC, NC, NC, NC, NC, NC, NC, NC, CP, NC, CP, NC, NC, NC, NC}/*AV3*/
-};
-
-Private
-char const wtt_isc1_lookup[CH_CLASSES][CH_CLASSES] = {
-      /* Table 1: WTT default input sequence check rules */
-      /* row: leading char,  column: following char */
-/* CTRL NON CONS LV FV1 FV2 FV3 BV1 BV2 BD TONE AD1 AD2 AD3 AV1 AV2 AV3 */
-   {XC, AC, AC, AC, AC, AC, AC, RJ, RJ, RJ, RJ, RJ, RJ, RJ, RJ, RJ, RJ}/*CTRL*/
-  ,{XC, AC, AC, AC, AC, AC, AC, RJ, RJ, RJ, RJ, RJ, RJ, RJ, RJ, RJ, RJ}/*NON*/
-  ,{XC, AC, AC, AC, AC, AC, AC, CP, CP, CP, CP, CP, CP, CP, CP, CP, CP}/*CONS*/
-  ,{XC, AC, AC, AC, AC, AC, AC, RJ, RJ, RJ, RJ, RJ, RJ, RJ, RJ, RJ, RJ}/*LV*/
-  ,{XC, AC, AC, AC, AC, AC, AC, RJ, RJ, RJ, RJ, RJ, RJ, RJ, RJ, RJ, RJ}/*FV1*/
-  ,{XC, AC, AC, AC, AC, AC, AC, RJ, RJ, RJ, RJ, RJ, RJ, RJ, RJ, RJ, RJ}/*FV2*/
-  ,{XC, AC, AC, AC, AC, AC, AC, RJ, RJ, RJ, RJ, RJ, RJ, RJ, RJ, RJ, RJ}/*FV3*/
-  ,{XC, AC, AC, AC, AC, AC, AC, RJ, RJ, RJ, CP, CP, RJ, RJ, RJ, RJ, RJ}/*BV1*/
-  ,{XC, AC, AC, AC, AC, AC, AC, RJ, RJ, RJ, CP, RJ, RJ, RJ, RJ, RJ, RJ}/*BV2*/
-  ,{XC, AC, AC, AC, AC, AC, AC, RJ, RJ, RJ, RJ, RJ, RJ, RJ, RJ, RJ, RJ}/*BD*/
-  ,{XC, AC, AC, AC, AC, AC, AC, RJ, RJ, RJ, RJ, RJ, RJ, RJ, RJ, RJ, RJ}/*TONE*/
-  ,{XC, AC, AC, AC, AC, AC, AC, RJ, RJ, RJ, RJ, RJ, RJ, RJ, RJ, RJ, RJ}/*AD1*/
-  ,{XC, AC, AC, AC, AC, AC, AC, RJ, RJ, RJ, RJ, RJ, RJ, RJ, RJ, RJ, RJ}/*AD2*/
-  ,{XC, AC, AC, AC, AC, AC, AC, RJ, RJ, RJ, RJ, RJ, RJ, RJ, RJ, RJ, RJ}/*AD3*/
-  ,{XC, AC, AC, AC, AC, AC, AC, RJ, RJ, RJ, CP, CP, RJ, RJ, RJ, RJ, RJ}/*AV1*/
-  ,{XC, AC, AC, AC, AC, AC, AC, RJ, RJ, RJ, CP, RJ, RJ, RJ, RJ, RJ, RJ}/*AV2*/
-  ,{XC, AC, AC, AC, AC, AC, AC, RJ, RJ, RJ, CP, RJ, CP, RJ, RJ, RJ, RJ}/*AV3*/
-};
-
-Private
-char const wtt_isc2_lookup[CH_CLASSES][CH_CLASSES] = {
-      /* Table 2: WTT strict input sequence check rules */
-      /* row: leading char,  column: following char */
-/* CTRL NON CONS LV FV1 FV2 FV3 BV1 BV2 BD TONE AD1 AD2 AD3 AV1 AV2 AV3 */
-   {XC, AC, AC, AC, AC, AC, AC, RJ, RJ, RJ, RJ, RJ, RJ, RJ, RJ, RJ, RJ}/*CTRL*/
-  ,{XC, AC, AC, AC, RJ, RJ, AC, RJ, RJ, RJ, RJ, RJ, RJ, RJ, RJ, RJ, RJ}/*NON*/
-  ,{XC, AC, AC, AC, AC, RJ, AC, CP, CP, CP, CP, CP, CP, CP, CP, CP, CP}/*CONS*/
-  ,{XC, RJ, AC, RJ, RJ, RJ, RJ, RJ, RJ, RJ, RJ, RJ, RJ, RJ, RJ, RJ, RJ}/*LV*/
-  ,{XC, AC, AC, AC, AC, RJ, AC, RJ, RJ, RJ, RJ, RJ, RJ, RJ, RJ, RJ, RJ}/*FV1*/
-  ,{XC, AC, AC, AC, AC, RJ, AC, RJ, RJ, RJ, RJ, RJ, RJ, RJ, RJ, RJ, RJ}/*FV2*/
-  ,{XC, AC, AC, AC, RJ, AC, RJ, RJ, RJ, RJ, RJ, RJ, RJ, RJ, RJ, RJ, RJ}/*FV3*/
-  ,{XC, AC, AC, AC, AC, RJ, AC, RJ, RJ, RJ, CP, CP, RJ, RJ, RJ, RJ, RJ}/*BV1*/
-  ,{XC, AC, AC, AC, RJ, RJ, AC, RJ, RJ, RJ, CP, RJ, RJ, RJ, RJ, RJ, RJ}/*BV2*/
-  ,{XC, AC, AC, AC, RJ, RJ, AC, RJ, RJ, RJ, RJ, RJ, RJ, RJ, RJ, RJ, RJ}/*BD*/
-  ,{XC, AC, AC, AC, AC, AC, AC, RJ, RJ, RJ, RJ, RJ, RJ, RJ, RJ, RJ, RJ}/*TONE*/
-  ,{XC, AC, AC, AC, RJ, RJ, AC, RJ, RJ, RJ, RJ, RJ, RJ, RJ, RJ, RJ, RJ}/*AD1*/
-  ,{XC, AC, AC, AC, RJ, RJ, AC, RJ, RJ, RJ, RJ, RJ, RJ, RJ, RJ, RJ, RJ}/*AD2*/
-  ,{XC, AC, AC, AC, RJ, RJ, AC, RJ, RJ, RJ, RJ, RJ, RJ, RJ, RJ, RJ, RJ}/*AD3*/
-  ,{XC, AC, AC, AC, RJ, RJ, AC, RJ, RJ, RJ, CP, CP, RJ, RJ, RJ, RJ, RJ}/*AV1*/
-  ,{XC, AC, AC, AC, RJ, RJ, AC, RJ, RJ, RJ, CP, RJ, RJ, RJ, RJ, RJ, RJ}/*AV2*/
-  ,{XC, AC, AC, AC, RJ, RJ, AC, RJ, RJ, RJ, CP, RJ, CP, RJ, RJ, RJ, RJ}/*AV3*/
-};
-
-Private
-char const thaicat_isc_lookup[CH_CLASSES][CH_CLASSES] = {
-      /* Table 3: Thaicat input sequence check rules */
-      /* row: leading char,  column: following char */
-/* CTRL NON CONS LV FV1 FV2 FV3 BV1 BV2 BD TONE AD1 AD2 AD3 AV1 AV2 AV3 */
-   {XC, AC, AC, AC, AC, AC, AC, RJ, RJ, RJ, RJ, RJ, RJ, RJ, RJ, RJ, RJ}/*CTRL*/
-  ,{XC, AC, AC, AC, AC, AC, AC, RJ, RJ, RJ, RJ, RJ, RJ, RJ, RJ, RJ, RJ}/*NON*/
-  ,{XC, AC, AC, AC, AC, AC, AC, CP, CP, CP, CP, CP, CP, CP, CP, CP, CP}/*CONS*/
-  ,{XC, AC, AC, AC, AC, AC, AC, RJ, RJ, RJ, RJ, RJ, RJ, RJ, RJ, RJ, RJ}/*LV*/
-  ,{XC, AC, AC, AC, AC, AC, AC, RJ, RJ, RJ, RJ, RJ, RJ, RJ, RJ, RJ, RJ}/*FV1*/
-  ,{XC, AC, AC, AC, AC, AC, AC, RJ, RJ, RJ, RJ, RJ, RJ, RJ, RJ, RJ, RJ}/*FV2*/
-  ,{XC, AC, AC, AC, AC, AC, AC, RJ, RJ, RJ, RJ, RJ, RJ, RJ, RJ, RJ, RJ} /*FV3*/
-  ,{XC, AC, AC, AC, AC, AC, AC, RJ, RJ, RJ, CP, CP, RJ, RJ, RJ, RJ, RJ}/*BV1*/
-  ,{XC, AC, AC, AC, AC, AC, AC, RJ, RJ, RJ, CP, RJ, RJ, RJ, RJ, RJ, RJ}/*BV2*/
-  ,{XC, AC, AC, AC, AC, AC, AC, RJ, RJ, RJ, RJ, RJ, RJ, RJ, RJ, RJ, RJ}/*BD*/
-  ,{XC, AC, AC, AC, AC, AC, AC, CP, CP, RJ, RJ, RJ, RJ, RJ, CP, CP, CP}/*TONE*/
-  ,{XC, AC, AC, AC, AC, AC, AC, CP, RJ, RJ, RJ, RJ, RJ, RJ, CP, RJ, RJ}/*AD1*/
-  ,{XC, AC, AC, AC, AC, AC, AC, RJ, RJ, RJ, RJ, RJ, RJ, RJ, RJ, RJ, CP}/*AD2*/
-  ,{XC, AC, AC, AC, AC, AC, AC, RJ, RJ, RJ, RJ, RJ, RJ, RJ, RJ, RJ, RJ}/*AD3*/
-  ,{XC, AC, AC, AC, AC, AC, AC, RJ, RJ, RJ, CP, CP, RJ, RJ, RJ, RJ, RJ}/*AV1*/
-  ,{XC, AC, AC, AC, AC, AC, AC, RJ, RJ, RJ, CP, RJ, RJ, RJ, RJ, RJ, RJ}/*AV2*/
-  ,{XC, AC, AC, AC, AC, AC, AC, RJ, RJ, RJ, CP, RJ, CP, RJ, RJ, RJ, RJ}/*AV3*/
-};
-
-
-/* returns classification of a char */
-Private int
-THAI_chtype (unsigned char	ch)
-{
-    return tactis_chtype[ch];
-}
-
-#ifdef UNUSED
-/* returns the display level */
-Private int
-THAI_chlevel (unsigned char	ch)
-{
-    int     chlevel;
-
-    switch (tactis_chtype[ch])
-    {
-        case CTRL:
-            chlevel = NON;
-            break;
-        case BV1:
-        case BV2:
-        case BD:
-            chlevel = BELOW;
-            break;
-        case TONE:
-        case AD1:
-        case AD2:
-            chlevel = TOP;
-            break;
-        case AV1:
-        case AV2:
-        case AV3:
-        case AD3:
-            chlevel = ABOVE;
-            break;
-        case NON:
-        case CONS:
-        case LV:
-        case FV1:
-        case FV2:
-        case FV3:
-        default: /* if tactis_chtype is invalid */
-            chlevel = BASE;
-            break;
-    }
-    return chlevel;
-}
-
-
-/* return True if char is non-spacing */
-Private Bool
-THAI_isdead (unsigned char	ch)
-{
-    return ((tactis_chtype[ch] == CTRL) || (tactis_chtype[ch] == BV1) ||
-            (tactis_chtype[ch] == BV2)  || (tactis_chtype[ch] == BD)  ||
-            (tactis_chtype[ch] == TONE) || (tactis_chtype[ch] == AD1) ||
-            (tactis_chtype[ch] == AD2)  || (tactis_chtype[ch] == AD3) ||
-            (tactis_chtype[ch] == AV1)  || (tactis_chtype[ch] == AV2) ||
-            (tactis_chtype[ch] == AV3));
-}
-
-
-/* return True if char is consonant */
-Private Bool
-THAI_iscons (unsigned char	ch)
-{
-    return (tactis_chtype[ch] == CONS);
-}
-
-
-/* return True if char is vowel */
-Private Bool
-THAI_isvowel (unsigned char	ch)
-{
-    return ((tactis_chtype[ch] == LV)  || (tactis_chtype[ch] == FV1) ||
-            (tactis_chtype[ch] == FV2) || (tactis_chtype[ch] == FV3) ||
-            (tactis_chtype[ch] == BV1) || (tactis_chtype[ch] == BV2) ||
-            (tactis_chtype[ch] == AV1) || (tactis_chtype[ch] == AV2) ||
-            (tactis_chtype[ch] == AV3));
-}
-
-
-/* return True if char is tonemark */
-Private Bool
-THAI_istone (unsigned char	ch)
-{
-    return (tactis_chtype[ch] == TONE);
-}
-#endif
-
-Private Bool
-THAI_iscomposible (
-    unsigned char	follow_ch,
-    unsigned char	lead_ch)
-{/* "Can follow_ch be put in the same display cell as lead_ch?" */
-
-    return (write_rules_lookup[THAI_chtype(lead_ch)][THAI_chtype(follow_ch)]
-            == CP);
-}
-
-Private Bool
-THAI_isaccepted (
-    unsigned char	follow_ch,
-    unsigned char	lead_ch,
-    unsigned char	mode)
-{
-    Bool iskeyvalid; /*  means "Can follow_ch be keyed in after lead_ch?" */
-
-    switch (mode)
-    {
-        case WTT_ISC1:
-            iskeyvalid =
-          (wtt_isc1_lookup[THAI_chtype(lead_ch)][THAI_chtype(follow_ch)] != RJ);
-            break;
-        case WTT_ISC2:
-            iskeyvalid =
-          (wtt_isc2_lookup[THAI_chtype(lead_ch)][THAI_chtype(follow_ch)] != RJ);
-            break;
-        case THAICAT_ISC:
-            iskeyvalid =
-       (thaicat_isc_lookup[THAI_chtype(lead_ch)][THAI_chtype(follow_ch)] != RJ);
-            break;
-        default:
-            iskeyvalid = True;
-            break;
-    }
-
-    return iskeyvalid;
-}
-
-#ifdef UNUSED
-Private void
-THAI_apply_write_rules(
-    unsigned char	*instr,
-    unsigned char	*outstr,
-    unsigned char	insert_ch,
-    int 		*num_insert_ch)
-{
-/*
-Input parameters:
-    instr - input string
-    insert_ch specify what char to be added when invalid composition is found
-Output parameters:
-    outstr - output string after input string has been applied the rules
-    num_insert_ch - number of insert_ch added to outstr.
-*/
-    unsigned char   *lead_ch = NULL, *follow_ch = NULL, *out_ch = NULL;
-
-    *num_insert_ch = 0;
-    lead_ch = follow_ch = instr;
-    out_ch = outstr;
-    if ((*lead_ch == '\0') || !(THAI_find_chtype(instr,DEAD)))
-    {   /* Empty string or can't find any non-spacing char*/
-        strcpy((char *)outstr, (char *)instr);
-    } else { /* String of length >= 1, keep looking */
-        follow_ch++;
-        if (THAI_isdead(*lead_ch)) { /* is first char non-spacing? */
-            *out_ch++ = SPACE;
-            (*num_insert_ch)++;
-        }
-        *out_ch++ = *lead_ch;
-        while (*follow_ch != '\0')  /* more char in string to check */
-        {
-            if (THAI_isdead(*follow_ch) &&
-                 !THAI_iscomposible(*follow_ch,*lead_ch))
-            {
-                *out_ch++ = SPACE;
-                (*num_insert_ch)++;
-            }
-            *out_ch++ = *follow_ch;
-            lead_ch = follow_ch;
-            follow_ch++;
-        }
-        *out_ch = '\0';
-    }
-}
-
-Private int
-THAI_find_chtype (
-    unsigned char	*instr,
-    int		chtype)
-{
-/*
-Input parameters:
-    instr - input string
-    chtype - type of character to look for
-Output parameters:
-    function returns first position of character with matched chtype
-    function returns -1 if it does not find.
-*/
-    int i = 0, position = -1;
-
-    switch (chtype)
-    {
-        case DEAD:
-            for (i = 0; *instr != '\0' && THAI_isdead(*instr); i++, instr++)
-		;
-            if (*instr != '\0') position = i;
-            break;
-        default:
-            break;
-    }
-    return position;
-}
-
-
-Private int
-THAI_apply_scm(
-    unsigned char	*instr,
-    unsigned char	*outstr,
-    unsigned char	spec_ch,
-    int		num_sp,
-    unsigned char	insert_ch)
-{
-    unsigned char   *scan, *outch;
-    int             i, dead_count, found_count;
-    Bool            isconsecutive;
-
-    scan = instr;
-    outch = outstr;
-    dead_count = found_count = 0;
-    isconsecutive = False;
-    while (*scan != '\0') {
-        if (THAI_isdead(*scan))
-            dead_count++;       /* count number of non-spacing char */
-        if (*scan == spec_ch)
-            if (!isconsecutive)
-                found_count++;      /* count number consecutive spec char found */
-        *outch++ = *scan++;
-        if (found_count == num_sp) {
-            for (i = 0; i < dead_count; i++)
-                *outch++ = insert_ch;
-            dead_count = found_count = 0;
-        }
-    }
-    /* what to return? */
-    return 0; /* probably not right but better than returning garbage */
-}
-
-
-/* The following functions are copied from XKeyBind.c */
-
-Private void ComputeMaskFromKeytrans();
-Private int IsCancelComposeKey(KeySym *symbol, XKeyEvent *event);
-Private void SetLed(Display *dpy, int num, int state);
-Private CARD8 FindKeyCode();
-
-
-/* The following functions are specific to this module */
-
-Private int XThaiTranslateKey();
-Private int XThaiTranslateKeySym();
-
-
-Private KeySym HexIMNormalKey(
-    XicThaiPart *thai_part,
-    KeySym symbol,
-    XKeyEvent *event);
-Private KeySym HexIMFirstComposeKey(
-    XicThaiPart *thai_part,
-    KeySym symbol,
-    XKeyEvent *event);
-Private KeySym HexIMSecondComposeKey(
-    XicThaiPart *thai_part,
-    KeySym symbol
-    XKeyEvent *event);
-Private KeySym HexIMComposeSequence(KeySym ks1, KeySym ks2);
-Private void InitIscMode(Xic ic);
-Private Bool ThaiComposeConvert(
-    Display *dpy,
-    KeySym insym,
-    KeySym *outsym, KeySym *lower, KeySym *upper);
-#endif
-
-/*
- * Definitions
- */
-
-#define BellVolume 		0
-
-#define ucs2tis(wc)  \
- (unsigned char) ( \
-   (0<=(wc)&&(wc)<=0x7F) ? \
-     (wc) : \
-     ((0x0E01<=(wc)&&(wc)<=0x0E5F) ? ((wc)-0x0E00+0xA0) : 0))
-/* "c" is an unsigned char */
-#define tis2ucs(c)  \
-  ( \
-   ((c)<=0x7F) ? \
-     (wchar_t)(c) : \
-     ((0x0A1<=(c)) ? ((wchar_t)(c)-0xA0+0x0E00) : 0))
-
-/*
- * Macros to save and recall last input character in XIC
- */
-#define IC_SavePreviousChar(ic,ch) \
-                ((ic)->private.local.base.mb[(ic)->private.local.base.tree[(ic)->private.local.context].mb] = (char) (ch))
-#define IC_ClearPreviousChar(ic) \
-                ((ic)->private.local.base.mb[(ic)->private.local.base.tree[(ic)->private.local.context].mb] = 0)
-#define IC_GetPreviousChar(ic) \
-		(IC_RealGetPreviousChar(ic,1))
-#define IC_GetContextChar(ic) \
-		(IC_RealGetPreviousChar(ic,2))
-#define IC_DeletePreviousChar(ic) \
-		(IC_RealDeletePreviousChar(ic))
-
-Private unsigned char
-IC_RealGetPreviousChar(Xic ic, unsigned short pos)
-{
-    XICCallback* cb = &ic->core.string_conversion_callback;
-    DefTreeBase *b = &ic->private.local.base;
-
-    if (cb && cb->callback) {
-        XIMStringConversionCallbackStruct screc;
-        unsigned char c;
-
-        /* Use a safe value of position = 0 and stretch the range to desired
-         * place, as XIM protocol is unclear here whether it could be negative
-         */
-        screc.position = 0;
-        screc.direction = XIMBackwardChar;
-        screc.operation = XIMStringConversionRetrieval;
-        screc.factor = pos;
-        screc.text = 0;
-
-        (cb->callback)((XIC)ic, cb->client_data, (XPointer)&screc);
-        if (!screc.text)
-            return (unsigned char) b->mb[b->tree[(ic)->private.local.context].mb];
-        if ((screc.text->feedback &&
-             *screc.text->feedback == XIMStringConversionLeftEdge) ||
-            screc.text->length < 1)
-        {
-            c = 0;
-        } else {
-            Xim     im;
-            XlcConv conv;
-            int     from_left;
-            int     to_left;
-            char   *from_buf;
-            char   *to_buf;
-
-            im = (Xim) XIMOfIC((XIC)ic);
-            if (screc.text->encoding_is_wchar) {
-                conv = _XlcOpenConverter(im->core.lcd, XlcNWideChar,
-                                         im->core.lcd, XlcNCharSet);
-                from_buf = (char *) screc.text->string.wcs;
-                from_left = screc.text->length * sizeof(wchar_t);
-            } else {
-                conv = _XlcOpenConverter(im->core.lcd, XlcNMultiByte,
-                                         im->core.lcd, XlcNCharSet);
-                from_buf = screc.text->string.mbs;
-                from_left = screc.text->length;
-            }
-            to_buf = (char *)&c;
-            to_left = 1;
-
-            _XlcResetConverter(conv);
-            if (_XlcConvert(conv, (XPointer *)&from_buf, &from_left,
-                            (XPointer *)&to_buf, &to_left, NULL, 0) < 0)
-            {
-                c = (unsigned char) b->mb[b->tree[(ic)->private.local.context].mb];
-            }
-            _XlcCloseConverter(conv);
-
-            XFree(screc.text->string.mbs);
-        }
-        XFree(screc.text);
-        return c;
-    } else {
-        return (unsigned char) b->mb[b->tree[(ic)->private.local.context].mb];
-    }
-}
-
-Private unsigned char
-IC_RealDeletePreviousChar(Xic ic)
-{
-    XICCallback* cb = &ic->core.string_conversion_callback;
-
-    if (cb && cb->callback) {
-        XIMStringConversionCallbackStruct screc;
-        unsigned char c;
-
-        screc.position = 0;
-        screc.direction = XIMBackwardChar;
-        screc.operation = XIMStringConversionSubstitution;
-        screc.factor = 1;
-        screc.text = 0;
-
-        (cb->callback)((XIC)ic, cb->client_data, (XPointer)&screc);
-        if (!screc.text) { return 0; }
-        if ((screc.text->feedback &&
-             *screc.text->feedback == XIMStringConversionLeftEdge) ||
-            screc.text->length < 1)
-        {
-            c = 0;
-        } else {
-            if (screc.text->encoding_is_wchar) {
-                c = ucs2tis(screc.text->string.wcs[0]);
-                XFree(screc.text->string.wcs);
-            } else {
-                c = screc.text->string.mbs[0];
-                XFree(screc.text->string.mbs);
-            }
-        }
-        XFree(screc.text);
-        return c;
-    } else {
-        return 0;
-    }
-}
-/*
- * Input sequence check mode in XIC
- */
-#define IC_IscMode(ic)		((ic)->private.local.thai.input_mode)
-
-/*
- * Max. size of string handled by the two String Lookup functions.
- */
-#define STR_LKUP_BUF_SIZE	256
-
-/*
- * Size of buffer to contain previous locale name.
- */
-#define SAV_LOCALE_NAME_SIZE	256
-
-/*
- * Size of buffer to contain the IM modifier.
- */
-#define MAXTHAIIMMODLEN 20
-
-#define AllMods (ShiftMask|LockMask|ControlMask| \
-		 Mod1Mask|Mod2Mask|Mod3Mask|Mod4Mask|Mod5Mask)
-
-
-#define IsISOControlKey(ks) ((ks) >= XK_2 && (ks) <= XK_8)
-
-#define IsValidControlKey(ks)   (((((ks)>=XK_A && (ks)<=XK_asciitilde) || \
-                (ks)==XK_space || (ks)==XK_Delete) && \
-                ((ks)!=0)))
-
-#define COMPOSE_LED 2
-
-#ifdef UNUSED
-typedef KeySym (*StateProc)(
-    XicThaiPart *thai_part,
-    KeySym symbol,
-    XKeyEvent *event);
-
-
-/*
- * macros to classify XKeyEvent state field
- */
-
-#define IsShift(state) (((state) & ShiftMask) != 0)
-#define IsLock(state) (((state) & LockMask) != 0)
-#define IsControl(state) (((state) & ControlMask) != 0)
-#define IsMod1(state) (((state) & Mod1Mask) != 0)
-#define IsMod2(state) (((state) & Mod2Mask) != 0)
-#define IsMod3(state) (((state) & Mod3Mask) != 0)
-#define IsMod4(state) (((state) & Mod4Mask) != 0)
-#define IsMod5(state) (((state) & Mod5Mask) != 0)
-
-/*
- * key starts Thai compose sequence (Hex input method) if :
- */
-
-#define IsComposeKey(ks, event)  \
-	(( ks==XK_Alt_L && 	\
-	   IsControl((event)->state) &&	\
-	   !IsShift((event)->state))	\
-	 ? True : False)
-
-
-/*
- *  State handler to implement the Thai hex input method.
- */
-
-Private int const nstate_handlers = 3;
-Private StateProc state_handler[] = {
-	HexIMNormalKey,
-	HexIMFirstComposeKey,
-	HexIMSecondComposeKey
-};
-
-
-/*
- *  Table for 'Thai Compose' character input.
- *  The current implementation uses latin-1 keysyms.
- */
-struct _XMapThaiKey {
-	KeySym from;
-	KeySym to;
-};
-
-Private struct _XMapThaiKey const ThaiComposeTable[] = {
-	{ /* 0xa4 */ XK_currency,	/* 0xa5 */ XK_yen },
-	{ /* 0xa2 */ XK_cent,		/* 0xa3 */ XK_sterling },
-	{ /* 0xe6 */ XK_ae,		/* 0xef */ XK_idiaeresis },
-	{ /* 0xd3 */ XK_Oacute,		/* 0xee */ XK_icircumflex },
-	{ /* 0xb9 */ XK_onesuperior,	/* 0xfa */ XK_uacute },
-	{ /* 0xd2 */ XK_Ograve,		/* 0xe5 */ XK_aring },
-	{ /* 0xbc */ XK_onequarter,	/* 0xfb */ XK_ucircumflex },
-	{	     XK_VoidSymbol,		   XK_VoidSymbol }
-};
-
-struct _XKeytrans {
-	struct _XKeytrans *next;/* next on list */
-	char *string;		/* string to return when the time comes */
-	int len;		/* length of string (since NULL is legit)*/
-	KeySym key;		/* keysym rebound */
-	unsigned int state;	/* modifier state */
-	KeySym *modifiers;	/* modifier keysyms you want */
-	int mlen;		/* length of modifier list */
-};
-
-
-/* Convert keysym to 'Thai Compose' keysym */
-/* The current implementation use latin-1 keysyms */
-Private Bool
-ThaiComposeConvert(
-    Display *dpy,
-    KeySym insym,
-    KeySym *outsym, KeySym *lower, KeySym *upper)
-{
-    struct _XMapThaiKey const *table_entry = ThaiComposeTable;
-
-    while (table_entry->from != XK_VoidSymbol) {
-	if (table_entry->from == insym) {
-	    *outsym = table_entry->to;
-	    *lower = *outsym;
-	    *upper = *outsym;
-	    return True;
-	}
-	table_entry++;
-    }
-    return False;
-}
-
-Private int
-XThaiTranslateKey(
-    register Display *dpy,
-    KeyCode keycode,
-    register unsigned int modifiers,
-    unsigned int *modifiers_return,
-    KeySym *keysym_return,
-    KeySym *lsym_return,
-    KeySym *usym_return)
-{
-    int per;
-    register KeySym *syms;
-    KeySym sym = 0, lsym = 0, usym = 0;
-
-    if ((! dpy->keysyms) && (! _XKeyInitialize(dpy)))
-	return 0;
-    *modifiers_return = (ShiftMask|LockMask) | dpy->mode_switch;
-    if (((int)keycode < dpy->min_keycode) || ((int)keycode > dpy->max_keycode))
-    {
-	*keysym_return = NoSymbol;
-	return 1;
-    }
-    per = dpy->keysyms_per_keycode;
-    syms = &dpy->keysyms[(keycode - dpy->min_keycode) * per];
-    while ((per > 2) && (syms[per - 1] == NoSymbol))
-	per--;
-    if ((per > 2) && (modifiers & dpy->mode_switch)) {
-	syms += 2;
-	per -= 2;
-    }
-    if (!(modifiers & ShiftMask) &&
-	(!(modifiers & LockMask) || (dpy->lock_meaning == NoSymbol))) {
-	if ((per == 1) || (syms[1] == NoSymbol))
-	    XConvertCase(syms[0], keysym_return, &usym);
-	else {
-	    XConvertCase(syms[0], &lsym, &usym);
-	    *keysym_return = syms[0];
-	}
-    } else if (!(modifiers & LockMask) ||
-	       (dpy->lock_meaning != XK_Caps_Lock)) {
-	if ((per == 1) || ((usym = syms[1]) == NoSymbol))
-	    XConvertCase(syms[0], &lsym, &usym);
-	*keysym_return = usym;
-    } else {
-	if ((per == 1) || ((sym = syms[1]) == NoSymbol))
-	    sym = syms[0];
-	XConvertCase(sym, &lsym, &usym);
-	if (!(modifiers & ShiftMask) && (sym != syms[0]) &&
-	    ((sym != usym) || (lsym == usym)))
-	    XConvertCase(syms[0], &lsym, &usym);
-	*keysym_return = usym;
-    }
-    /*
-     * ThaiCat keyboard support :
-     * When the Shift and Thai keys are hold for some keys a 'Thai Compose'
-     * character code is generated which is different from column 3 and
-     * 4 of the keymap.
-     * Since we don't know whether ThaiCat keyboard or WTT keyboard is
-     * in use, the same mapping is done for all Thai input.
-     * We just arbitary choose to use column 3 keysyms as the indices of
-     * this mapping.
-     * When the control key is also hold, this mapping has no effect.
-     */
-    if ((modifiers & Mod1Mask) &&
-	(modifiers & ShiftMask) &&
-	!(modifiers & ControlMask)) {
-	if (ThaiComposeConvert(dpy, syms[0], &sym, &lsym, &usym))
-	    *keysym_return = sym;
-    }
-
-    if (*keysym_return == XK_VoidSymbol)
-	*keysym_return = NoSymbol;
-    *lsym_return = lsym;
-    *usym_return = usym;
-    return 1;
-}
-
-/*
- * XThaiTranslateKeySym
- *
- * Translate KeySym to TACTIS code output.
- * The current implementation uses ISO latin-1 keysym.
- * Should be changed to TACTIS keysyms when they are defined by the
- * standard.
- */
-Private int
-XThaiTranslateKeySym(
-    Display *dpy,
-    register KeySym symbol,
-    register KeySym lsym,
-    register KeySym usym,
-    unsigned int modifiers,
-    unsigned char *buffer,
-    int nbytes)
-{
-    KeySym ckey = 0;
-    register struct _XKeytrans *p;
-    int length;
-    unsigned long hiBytes;
-    register unsigned char c;
-
-    /*
-     * initialize length = 1 ;
-     */
-    length = 1;
-
-    if (!symbol)
-	return 0;
-    /* see if symbol rebound, if so, return that string. */
-    for (p = dpy->key_bindings; p; p = p->next) {
-	if (((modifiers & AllMods) == p->state) && (symbol == p->key)) {
-	    length = p->len;
-	    if (length > nbytes) length = nbytes;
-	    memcpy (buffer, p->string, length);
-	    return length;
-	}
-    }
-    /* try to convert to TACTIS, handling control */
-    hiBytes = symbol >> 8;
-    if (!(nbytes &&
-	  ((hiBytes == 0) ||
-	   ((hiBytes == 0xFF) &&
-	    (((symbol >= XK_BackSpace) && (symbol <= XK_Clear)) ||
-	     (symbol == XK_Return) ||
-	     (symbol == XK_Escape) ||
-	     (symbol == XK_KP_Space) ||
-	     (symbol == XK_KP_Tab) ||
-	     (symbol == XK_KP_Enter) ||
-	     ((symbol >= XK_KP_Multiply) && (symbol <= XK_KP_9)) ||
-	     (symbol == XK_KP_Equal) ||
-             (symbol == XK_Scroll_Lock) ||
-#ifdef DXK_PRIVATE /* DEC private keysyms */
-             (symbol == DXK_Remove) ||
-#endif
-             (symbol == NoSymbol) ||
-	     (symbol == XK_Delete))))))
-	return 0;
-
-    /* if X keysym, convert to ascii by grabbing low 7 bits */
-    if (symbol == XK_KP_Space)
-	c = XK_space & 0x7F; /* patch encoding botch */
-/* not for Thai
-    else if (symbol == XK_hyphen)
-	c = XK_minus & 0xFF; */ /* map to equiv character */
-    else if (hiBytes == 0xFF)
-	c = symbol & 0x7F;
-    else
-	c = symbol & 0xFF;
-    /* only apply Control key if it makes sense, else ignore it */
-    if (modifiers & ControlMask) {
-    if (!(IsKeypadKey(lsym) || lsym==XK_Return || lsym==XK_Tab)) {
-        if (IsISOControlKey(lsym)) ckey = lsym;
-        else if (IsISOControlKey(usym)) ckey = usym;
-        else if (lsym == XK_question) ckey = lsym;
-        else if (usym == XK_question) ckey = usym;
-        else if (IsValidControlKey(lsym)) ckey = lsym;
-        else if (IsValidControlKey(usym)) ckey = usym;
-        else length = 0;
-
-        if (length != 0) {
-        if (ckey == XK_2) c = '\000';
-        else if (ckey >= XK_3 && ckey <= XK_7)
-            c = (char)(ckey-('3'-'\033'));
-        else if (ckey == XK_8) c = '\177';
-        else if (ckey == XK_Delete) c = '\030';
-        else if (ckey == XK_question) c = '\037';
-        else if (ckey == XK_quoteleft) c = '\036';  /* KLee 1/24/91 */
-        else c = (char)(ckey & 0x1f);
-        }
-    }
-    }
-    /*
-     *  ThaiCat has a key that generates two TACTIS codes D1 & E9.
-     *  It is represented by the latin-1 keysym XK_thorn (0xfe).
-     *  If c is XK_thorn, this key is pressed and it is converted to
-     *  0xd1 0xe9.
-     */
-    if (c == XK_thorn) {
-	buffer[0] = 0xd1;
-	buffer[1] = 0xe9;
-	buffer[2] = '\0';
-	return 2;
-    }
-    else {
-	/* Normal case */
-        buffer[0] = c;
-	buffer[1] = '\0';
-        return 1;
-    }
-}
-
-/*
- * given a KeySym, returns the first keycode containing it, if any.
- */
-Private CARD8
-FindKeyCode(
-    register Display *dpy,
-    register KeySym code)
-{
-
-    register KeySym *kmax = dpy->keysyms +
-	(dpy->max_keycode - dpy->min_keycode + 1) * dpy->keysyms_per_keycode;
-    register KeySym *k = dpy->keysyms;
-    while (k < kmax) {
-	if (*k == code)
-	    return (((k - dpy->keysyms) / dpy->keysyms_per_keycode) +
-		    dpy->min_keycode);
-	k += 1;
-	}
-    return 0;
-}
-
-/*
- * given a list of modifiers, computes the mask necessary for later matching.
- * This routine must lookup the key in the Keymap and then search to see
- * what modifier it is bound to, if any.  Sets the AnyModifier bit if it
- * can't map some keysym to a modifier.
- */
-Private void
-ComputeMaskFromKeytrans(
-    Display *dpy,
-    register struct _XKeytrans *p)
-{
-    register int i;
-    register CARD8 code;
-    register XModifierKeymap *m = dpy->modifiermap;
-
-    p->state = AnyModifier;
-    for (i = 0; i < p->mlen; i++) {
-	/* if not found, then not on current keyboard */
-	if ((code = FindKeyCode(dpy, p->modifiers[i])) == 0)
-		return;
-	/* code is now the keycode for the modifier you want */
-	{
-	    register int j = m->max_keypermod<<3;
-
-	    while ((--j >= 0) && (code != m->modifiermap[j]))
-		;
-	    if (j < 0)
-		return;
-	    p->state |= (1<<(j/m->max_keypermod));
-	}
-    }
-    p->state &= AllMods;
-}
-
-/************************************************************************
- *
- *
- * Compose handling routines - compose handlers 0,1,2
- *
- *
- ************************************************************************/
-
-#define NORMAL_KEY_STATE 0
-#define FIRST_COMPOSE_KEY_STATE 1
-#define SECOND_COMPOSE_KEY_STATE 2
-
-Private
-KeySym HexIMNormalKey(
-    XicThaiPart *thai_part,
-    KeySym symbol,
-    XKeyEvent *event)
-{
-    if (IsComposeKey (symbol, event))	/* start compose sequence	*/
-	{
-	SetLed (event->display,COMPOSE_LED, LedModeOn);
-	thai_part->comp_state = FIRST_COMPOSE_KEY_STATE;
-	return NoSymbol;
-	}
-    return symbol;
-}
-
-
-Private
-KeySym HexIMFirstComposeKey(
-    XicThaiPart *thai_part,
-    KeySym symbol,
-    XKeyEvent *event)
-{
-    if (IsModifierKey (symbol)) return symbol; /* ignore shift etc. */
-    if (IsCancelComposeKey (&symbol, event))	/* cancel sequence */
-	{
-	SetLed (event->display,COMPOSE_LED, LedModeOff);
-	thai_part->comp_state = NORMAL_KEY_STATE;
-	return symbol;
-	}
-    if (IsComposeKey (symbol, event))		/* restart sequence ?? */
-	{
-	return NoSymbol;			/* no state change necessary */
-	}
-
-    thai_part->keysym = symbol;		/* save key pressed */
-    thai_part->comp_state = SECOND_COMPOSE_KEY_STATE;
-    return NoSymbol;
-}
-
-Private
-KeySym HexIMSecondComposeKey(
-    XicThaiPart *thai_part,
-    KeySym symbol,
-    XKeyEvent *event)
-{
-    if (IsModifierKey (symbol)) return symbol;	/* ignore shift etc. */
-    if (IsComposeKey (symbol, event))		/* restart sequence ? */
-	{
-	thai_part->comp_state =FIRST_COMPOSE_KEY_STATE;
-	return NoSymbol;
-	}
-    SetLed (event->display,COMPOSE_LED, LedModeOff);
-    if (IsCancelComposeKey (&symbol, event))	/* cancel sequence ? */
-	{
-	thai_part->comp_state = NORMAL_KEY_STATE;
-	return symbol;
-	}
-
-    if ((symbol = HexIMComposeSequence (thai_part->keysym, symbol))
-								==NoSymbol)
-	{ /* invalid compose sequence */
-	XBell(event->display, BellVolume);
-	}
-    thai_part->comp_state = NORMAL_KEY_STATE; /* reset to normal state */
-    return symbol;
-}
-
-
-/*
- * Interprets two keysyms entered as hex digits and return the Thai keysym
- * correspond to the TACTIS code formed.
- * The current implementation of this routine returns ISO Latin Keysyms.
- */
-
-Private
-KeySym HexIMComposeSequence(KeySym ks1, KeySym ks2)
-{
-int	hi_digit;
-int	lo_digit;
-int	tactis_code;
-
-    if ((ks1 >= XK_0) && (ks1 <= XK_9))
-	hi_digit = ks1 - XK_0;
-    else if ((ks1 >= XK_A) && (ks1 <= XK_F))
-	hi_digit = ks1 - XK_A + 10;
-    else if ((ks1 >= XK_a) && (ks1 <= XK_f))
-	hi_digit = ks1 - XK_a + 10;
-    else	/* out of range */
-	return NoSymbol;
-
-    if ((ks2 >= XK_0) && (ks2 <= XK_9))
-	lo_digit = ks2 - XK_0;
-    else if ((ks2 >= XK_A) && (ks2 <= XK_F))
-	lo_digit = ks2 - XK_A + 10;
-    else if ((ks2 >= XK_a) && (ks2 <= XK_f))
-	lo_digit = ks2 - XK_a + 10;
-    else	/* out of range */
-	return NoSymbol;
-
-    tactis_code = hi_digit * 0x10 + lo_digit ;
-
-    return (KeySym)tactis_code;
-
-}
-
-/*
- * routine determines
- *	1) whether key event should cancel a compose sequence
- *	2) whether cancelling key event should be processed or ignored
- */
-
-Private
-int IsCancelComposeKey(
-    KeySym *symbol,
-    XKeyEvent *event)
-{
-    if (*symbol==XK_Delete && !IsControl(event->state) &&
-						!IsMod1(event->state)) {
-	*symbol=NoSymbol;  /* cancel compose sequence, and ignore key */
-	return True;
-    }
-    if (IsComposeKey(*symbol, event)) return False;
-    return (
-	IsControl (event->state) ||
-	IsMod1(event->state) ||
-	IsKeypadKey (*symbol) ||
-	IsFunctionKey (*symbol) ||
-	IsMiscFunctionKey (*symbol) ||
-#ifdef DXK_PRIVATE /* DEC private keysyms */
-	*symbol == DXK_Remove ||
-#endif
-	IsPFKey (*symbol) ||
-	IsCursorKey (*symbol) ||
-	(*symbol >= XK_Tab && *symbol < XK_Multi_key)
-		? True : False);	/* cancel compose sequence and pass */
-					/* cancelling key through	    */
-}
-
-
-/*
- *	set specified keyboard LED on or off
- */
-
-Private
-void SetLed(
-    Display *dpy,
-    int num,
-    int state)
-{
-    XKeyboardControl led_control;
-
-    led_control.led_mode = state;
-    led_control.led = num;
-    XChangeKeyboardControl (dpy, KBLed | KBLedMode,	&led_control);
-}
-#endif
-
-/*
- * Initialize ISC mode from im modifier
- */
-Private void InitIscMode(Xic ic)
-{
-    Xim im;
-    char *im_modifier_name;
-
-    /* If already defined, just return */
-
-    if (IC_IscMode(ic)) return;
-
-    /* Get IM modifier */
-
-    im = (Xim) XIMOfIC((XIC)ic);
-    im_modifier_name = im->core.im_name;
-
-    /* Match with predefined value, default is Basic Check */
-
-    if (!strncmp(im_modifier_name,"BasicCheck",MAXTHAIIMMODLEN+1))
-	IC_IscMode(ic) = WTT_ISC1;
-    else if (!strncmp(im_modifier_name,"Strict",MAXTHAIIMMODLEN+1))
-	IC_IscMode(ic) = WTT_ISC2;
-    else if (!strncmp(im_modifier_name,"Thaicat",MAXTHAIIMMODLEN+1))
-	IC_IscMode(ic) = THAICAT_ISC;
-    else if (!strncmp(im_modifier_name,"Passthrough",MAXTHAIIMMODLEN+1))
-	IC_IscMode(ic) = NOISC;
-    else
-	IC_IscMode(ic) = WTT_ISC1;
-
-    return;
-}
-
-/*
- * Helper functions for _XimThaiFilter()
- */
-Private Bool
-ThaiFltAcceptInput(Xic ic, unsigned char new_char, KeySym symbol)
-{
-    DefTreeBase *b = &ic->private.local.base;
-    b->wc[b->tree[ic->private.local.composed].wc+0] = tis2ucs(new_char);
-    b->wc[b->tree[ic->private.local.composed].wc+1] = '\0';
-
-    if ((new_char <= 0x1f) || (new_char == 0x7f))
-        b->tree[ic->private.local.composed].keysym = symbol;
-    else
-        b->tree[ic->private.local.composed].keysym = NoSymbol;
-
-    return True;
-}
-
-Private Bool
-ThaiFltReorderInput(Xic ic, unsigned char previous_char, unsigned char new_char)
-{
-    DefTreeBase *b = &ic->private.local.base;
-    if (!IC_DeletePreviousChar(ic)) return False;
-    b->wc[b->tree[ic->private.local.composed].wc+0] = tis2ucs(new_char);
-    b->wc[b->tree[ic->private.local.composed].wc+1] = tis2ucs(previous_char);
-    b->wc[b->tree[ic->private.local.composed].wc+2] = '\0';
-
-    b->tree[ic->private.local.composed].keysym = NoSymbol;
-
-    return True;
-}
-
-Private Bool
-ThaiFltReplaceInput(Xic ic, unsigned char new_char, KeySym symbol)
-{
-    DefTreeBase *b = &ic->private.local.base;
-    if (!IC_DeletePreviousChar(ic)) return False;
-    b->wc[b->tree[ic->private.local.composed].wc+0] = tis2ucs(new_char);
-    b->wc[b->tree[ic->private.local.composed].wc+1] = '\0';
-
-    if ((new_char <= 0x1f) || (new_char == 0x7f))
-        b->tree[ic->private.local.composed].keysym = symbol;
-    else
-        b->tree[ic->private.local.composed].keysym = NoSymbol;
-
-    return True;
-}
-
-Private unsigned
-NumLockMask(Display *d)
-{
-    int i;
-    XModifierKeymap *map = XGetModifierMapping (d);
-    KeyCode numlock_keycode = XKeysymToKeycode (d, XK_Num_Lock);
-    if (numlock_keycode == NoSymbol)
-        return 0;
-
-    for (i = 0; i < 8; i++) {
-        if (map->modifiermap[map->max_keypermod * i] == numlock_keycode)
-            return 1 << i;
-    }
-    return 0;
-}
-
-/*
- * Filter function for TACTIS
- */
-Bool
-_XimThaiFilter(Display *d, Window w, XEvent *ev, XPointer client_data)
-{
-    Xic		    ic = (Xic)client_data;
-    KeySym 	    symbol;
-    int 	    isc_mode; /* Thai Input Sequence Check mode */
-    unsigned char   previous_char; /* Last inputted Thai char */
-    unsigned char   new_char;
-#ifdef UNUSED
-    unsigned int    modifiers;
-    KeySym	    lsym,usym;
-    int		    state;
-    XicThaiPart     *thai_part;
-    char	    buf[10];
-#endif
-    wchar_t	    wbuf[10];
-    Bool            isReject;
-    DefTreeBase    *b = &ic->private.local.base;
-
-    if ((ev->type != KeyPress)
-        || (ev->xkey.keycode == 0))
-        return False;
-
-    if (!IC_IscMode(ic)) InitIscMode(ic);
-
-    XwcLookupString((XIC)ic, &ev->xkey, wbuf, sizeof(wbuf) / sizeof(wbuf[0]),
-		    &symbol, NULL);
-
-    if ((ev->xkey.state & (AllMods & ~(ShiftMask|LockMask|NumLockMask(d)))) ||
-         ((symbol >> 8 == 0xFF) &&
-         ((XK_BackSpace <= symbol && symbol <= XK_Clear) ||
-           (symbol == XK_Return) ||
-           (symbol == XK_Pause) ||
-           (symbol == XK_Scroll_Lock) ||
-           (symbol == XK_Sys_Req) ||
-           (symbol == XK_Escape) ||
-           (symbol == XK_Delete) ||
-           IsCursorKey(symbol) ||
-           IsKeypadKey(symbol) ||
-           IsMiscFunctionKey(symbol) ||
-           IsFunctionKey(symbol))))
-        {
-            IC_ClearPreviousChar(ic);
-            return False;
-        }
-    if (((symbol >> 8 == 0xFF) &&
-         IsModifierKey(symbol)) ||
-#ifdef XK_XKB_KEYS
-        ((symbol >> 8 == 0xFE) &&
-         (XK_ISO_Lock <= symbol && symbol <= XK_ISO_Last_Group_Lock)) ||
-#endif
-        (symbol == NoSymbol))
-    {
-        return False;
-    }
-#ifdef UNUSED
-    if (! XThaiTranslateKey(ev->xkey.display, ev->xkey.keycode, ev->xkey.state,
-	 		&modifiers, &symbol, &lsym, &usym))
-	return False;
-
-    /*
-     *  Hex input method processing
-     */
-
-    thai_part = &ic->private.local.thai;
-    state = thai_part->comp_state;
-    if (state >= 0 && state < nstate_handlers) /* call handler for state */
-    {
-        symbol = (* state_handler[state])(thai_part, symbol, (XKeyEvent *)ev);
-    }
-
-    /*
-     *  Translate KeySym into mb.
-     */
-    count = XThaiTranslateKeySym(ev->xkey.display, symbol, lsym,
-				usym, ev->xkey.state, buf, 10);
-
-    if (!symbol && !count)
-	return True;
-
-    /* Return symbol if cannot convert to character */
-    if (!count)
-	return False;
-#endif
-
-    /*
-     *  Thai Input sequence check
-     */
-    isc_mode = IC_IscMode(ic);
-    if (!(previous_char = IC_GetPreviousChar(ic))) previous_char = ' ';
-    new_char = ucs2tis(wbuf[0]);
-    isReject = True;
-    if (THAI_isaccepted(new_char, previous_char, isc_mode)) {
-        ThaiFltAcceptInput(ic, new_char, symbol);
-        isReject = False;
-    } else {
-        unsigned char context_char;
-
-        context_char = IC_GetContextChar(ic);
-        if (context_char) {
-            if (THAI_iscomposible(new_char, context_char)) {
-                if (THAI_iscomposible(previous_char, new_char)) {
-                    isReject = !ThaiFltReorderInput(ic, previous_char, new_char);
-                } else if (THAI_iscomposible(previous_char, context_char)) {
-                    isReject = !ThaiFltReplaceInput(ic, new_char, symbol);
-                } else if (THAI_chtype(previous_char) == FV1
-                           && THAI_chtype(new_char) == TONE) {
-                    isReject = !ThaiFltReorderInput(ic, previous_char, new_char);
-                }
-            } else if (THAI_isaccepted(new_char, context_char, isc_mode)) {
-                isReject = !ThaiFltReplaceInput(ic, new_char, symbol);
-            }
-        }
-    }
-    if (isReject) {
-        /* reject character */
-        XBell(ev->xkey.display, BellVolume);
-        return True;
-    }
-
-    _Xlcwcstombs(ic->core.im->core.lcd, &b->mb[b->tree[ic->private.local.composed].mb],
-		 &b->wc[b->tree[ic->private.local.composed].wc], 10);
-
-    _Xlcmbstoutf8(ic->core.im->core.lcd, &b->utf8[b->tree[ic->private.local.composed].utf8],
-		  &b->mb[b->tree[ic->private.local.composed].mb], 10);
-
-    /* Remember the last character inputted
-     * (as fallback in case StringConversionCallback is not provided)
-     */
-    IC_SavePreviousChar(ic, new_char);
-
-    ev->xkey.keycode = 0;
-    XPutBackEvent(d, ev);
-    return True;
-}
+/***********************************************************

+

+Copyright 1993, 1998  The Open Group

+

+Permission to use, copy, modify, distribute, and sell this software and its

+documentation for any purpose is hereby granted without fee, provided that

+the above copyright notice appear in all copies and that both that

+copyright notice and this permission notice appear in supporting

+documentation.

+

+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 THE

+OPEN GROUP 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.

+

+Except as contained in this notice, the name of The Open Group shall not be

+used in advertising or otherwise to promote the sale, use or other dealings

+in this Software without prior written authorization from The Open Group.

+

+

+Copyright 1993 by Digital Equipment Corporation, Maynard, Massachusetts.

+

+                        All Rights Reserved

+

+Permission to use, copy, modify, and distribute this software and its

+documentation for any purpose and without fee is hereby granted,

+provided that the above copyright notice appear in all copies and that

+both that copyright notice and this permission notice appear in

+supporting documentation, and that the name of Digital not be

+used in advertising or publicity pertaining to distribution of the

+software without specific, written prior permission.

+

+DIGITAL DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE, INCLUDING

+ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS, IN NO EVENT SHALL

+DIGITAL BE LIABLE FOR ANY SPECIAL, INDIRECT OR CONSEQUENTIAL DAMAGES OR

+ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS,

+WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION,

+ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS

+SOFTWARE.

+

+******************************************************************/

+

+/*

+**++

+**  FACILITY:

+**

+**      Xlib

+**

+**  ABSTRACT:

+**

+**	Thai specific functions.

+**	Handles character classifications, composibility checking,

+**	Input sequence check and other Thai specific requirements

+**	according to WTT specification and DEC extensions.

+**

+**  MODIFICATION HISTORY:

+**

+**/

+

+#ifdef HAVE_CONFIG_H

+#include <config.h>

+#endif

+#include <stdio.h>

+#include <X11/Xlib.h>

+#include <X11/Xmd.h>

+#include <X11/keysym.h>

+#include <X11/Xutil.h>

+#include "Xlibint.h"

+#include "Xlcint.h"

+#include "Ximint.h"

+#include "XimThai.h"

+#include "XlcPubI.h"

+

+

+#define SPACE   32

+

+/* character classification table */

+#define TACTIS_CHARS 256

+Private

+char const tactis_chtype[TACTIS_CHARS] = {

+    CTRL, CTRL, CTRL, CTRL, CTRL, CTRL, CTRL, CTRL,  /*  0 -  7 */

+    CTRL, CTRL, CTRL, CTRL, CTRL, CTRL, CTRL, CTRL,  /*  8 - 15 */

+    CTRL, CTRL, CTRL, CTRL, CTRL, CTRL, CTRL, CTRL,  /* 16 - 23 */

+    CTRL, CTRL, CTRL, CTRL, CTRL, CTRL, CTRL, CTRL,  /* 24 - 31 */

+    NON,  NON,  NON,  NON,  NON,  NON,  NON,  NON,   /* 32 - 39 */

+    NON,  NON,  NON,  NON,  NON,  NON,  NON,  NON,   /* 40 - 47 */

+    NON,  NON,  NON,  NON,  NON,  NON,  NON,  NON,   /* 48 - 55 */

+    NON,  NON,  NON,  NON,  NON,  NON,  NON,  NON,   /* 56 - 63 */

+    NON,  NON,  NON,  NON,  NON,  NON,  NON,  NON,   /* 64 - 71 */

+    NON,  NON,  NON,  NON,  NON,  NON,  NON,  NON,   /* 72 - 79 */

+    NON,  NON,  NON,  NON,  NON,  NON,  NON,  NON,   /* 80 - 87 */

+    NON,  NON,  NON,  NON,  NON,  NON,  NON,  NON,   /* 88 - 95 */

+    NON,  NON,  NON,  NON,  NON,  NON,  NON,  NON,   /* 96 - 103 */

+    NON,  NON,  NON,  NON,  NON,  NON,  NON,  NON,   /* 104 - 111 */

+    NON,  NON,  NON,  NON,  NON,  NON,  NON,  NON,   /* 112 - 119 */

+    NON,  NON,  NON,  NON,  NON,  NON,  NON,  CTRL,  /* 120 - 127 */

+    CTRL, CTRL, CTRL, CTRL, CTRL, CTRL, CTRL, CTRL,  /* 128 - 135 */

+    CTRL, CTRL, CTRL, CTRL, CTRL, CTRL, CTRL, CTRL,  /* 136 - 143 */

+    CTRL, CTRL, CTRL, CTRL, CTRL, CTRL, CTRL, CTRL,  /* 144 - 151 */

+    CTRL, CTRL, CTRL, CTRL, CTRL, CTRL, CTRL, CTRL,  /* 152 - 159 */

+    NON,  CONS, CONS, CONS, CONS, CONS, CONS, CONS,  /* 160 - 167 */

+    CONS, CONS, CONS, CONS, CONS, CONS, CONS, CONS,  /* 168 - 175 */

+    CONS, CONS, CONS, CONS, CONS, CONS, CONS, CONS,  /* 176 - 183 */

+    CONS, CONS, CONS, CONS, CONS, CONS, CONS, CONS,  /* 184 - 191 */

+    CONS, CONS, CONS, CONS,  FV3, CONS,  FV3, CONS,  /* 192 - 199 */

+    CONS, CONS, CONS, CONS, CONS, CONS, CONS, NON,   /* 200 - 207 */

+    FV1,  AV2,  FV1,  FV1,  AV1,  AV3,  AV2,  AV3,   /* 208 - 215 */

+    BV1,  BV2,  BD,   NON,  NON,  NON,  NON,  NON,   /* 216 - 223 */

+    LV,   LV,   LV,   LV,   LV,   FV2,  NON,  AD2,   /* 224 - 231 */

+    TONE, TONE, TONE, TONE, AD1,  AD1,  AD3,  NON,   /* 232 - 239 */

+    NON,  NON,  NON,  NON,  NON,  NON,  NON,  NON,   /* 240 - 247 */

+    NON,  NON,  NON,  NON,  NON,  NON,  NON,  CTRL   /* 248 - 255 */

+};

+

+/* Composibility checking tables */

+#define NC  0   /* NOT COMPOSIBLE - following char displays in next cell */

+#define CP  1   /* COMPOSIBLE - following char is displayed in the same cell

+                                as leading char, also implies ACCEPT */

+#define XC  3   /* Non-display */

+#define AC  4   /* ACCEPT - display the following char in the next cell */

+#define RJ  5   /* REJECT - discard that following char, ignore it */

+

+#define CH_CLASSES      17  /* 17 classes of chars */

+

+Private

+char const write_rules_lookup[CH_CLASSES][CH_CLASSES] = {

+        /* Table 0: writing/outputing rules */

+        /* row: leading char,  column: following char */

+/* CTRL NON CONS LV FV1 FV2 FV3 BV1 BV2 BD TONE AD1 AD2 AD3 AV1 AV2 AV3 */

+   {XC, NC, NC, NC, NC, NC, NC, NC, NC, NC, NC, NC, NC, NC, NC, NC, NC}/*CTRL*/

+  ,{XC, NC, NC, NC, NC, NC, NC, NC, NC, NC, NC, NC, NC, NC, NC, NC, NC}/*NON*/

+  ,{XC, NC, NC, NC, NC, NC, NC, CP, CP, CP, CP, CP, CP, CP, CP, CP, CP}/*CONS*/

+  ,{XC, NC, NC, NC, NC, NC, NC, NC, NC, NC, NC, NC, NC, NC, NC, NC, NC}/*LV*/

+  ,{XC, NC, NC, NC, NC, NC, NC, NC, NC, NC, NC, NC, NC, NC, NC, NC, NC}/*FV1*/

+  ,{XC, NC, NC, NC, NC, NC, NC, NC, NC, NC, NC, NC, NC, NC, NC, NC, NC}/*FV2*/

+  ,{XC, NC, NC, NC, NC, NC, NC, NC, NC, NC, NC, NC, NC, NC, NC, NC, NC}/*FV3*/

+  ,{XC, NC, NC, NC, NC, NC, NC, NC, NC, NC, CP, CP, NC, NC, NC, NC, NC}/*BV1*/

+  ,{XC, NC, NC, NC, NC, NC, NC, NC, NC, NC, CP, NC, NC, NC, NC, NC, NC}/*BV2*/

+  ,{XC, NC, NC, NC, NC, NC, NC, NC, NC, NC, NC, NC, NC, NC, NC, NC, NC}/*BD*/

+  ,{XC, NC, NC, NC, NC, NC, NC, NC, NC, NC, NC, NC, NC, NC, NC, NC, NC}/*TONE*/

+  ,{XC, NC, NC, NC, NC, NC, NC, NC, NC, NC, NC, NC, NC, NC, NC, NC, NC}/*AD1*/

+  ,{XC, NC, NC, NC, NC, NC, NC, NC, NC, NC, NC, NC, NC, NC, NC, NC, NC}/*AD2*/

+  ,{XC, NC, NC, NC, NC, NC, NC, NC, NC, NC, NC, NC, NC, NC, NC, NC, NC}/*AD3*/

+  ,{XC, NC, NC, NC, NC, NC, NC, NC, NC, NC, CP, CP, NC, NC, NC, NC, NC}/*AV1*/

+  ,{XC, NC, NC, NC, NC, NC, NC, NC, NC, NC, CP, NC, NC, NC, NC, NC, NC}/*AV2*/

+  ,{XC, NC, NC, NC, NC, NC, NC, NC, NC, NC, CP, NC, CP, NC, NC, NC, NC}/*AV3*/

+};

+

+Private

+char const wtt_isc1_lookup[CH_CLASSES][CH_CLASSES] = {

+      /* Table 1: WTT default input sequence check rules */

+      /* row: leading char,  column: following char */

+/* CTRL NON CONS LV FV1 FV2 FV3 BV1 BV2 BD TONE AD1 AD2 AD3 AV1 AV2 AV3 */

+   {XC, AC, AC, AC, AC, AC, AC, RJ, RJ, RJ, RJ, RJ, RJ, RJ, RJ, RJ, RJ}/*CTRL*/

+  ,{XC, AC, AC, AC, AC, AC, AC, RJ, RJ, RJ, RJ, RJ, RJ, RJ, RJ, RJ, RJ}/*NON*/

+  ,{XC, AC, AC, AC, AC, AC, AC, CP, CP, CP, CP, CP, CP, CP, CP, CP, CP}/*CONS*/

+  ,{XC, AC, AC, AC, AC, AC, AC, RJ, RJ, RJ, RJ, RJ, RJ, RJ, RJ, RJ, RJ}/*LV*/

+  ,{XC, AC, AC, AC, AC, AC, AC, RJ, RJ, RJ, RJ, RJ, RJ, RJ, RJ, RJ, RJ}/*FV1*/

+  ,{XC, AC, AC, AC, AC, AC, AC, RJ, RJ, RJ, RJ, RJ, RJ, RJ, RJ, RJ, RJ}/*FV2*/

+  ,{XC, AC, AC, AC, AC, AC, AC, RJ, RJ, RJ, RJ, RJ, RJ, RJ, RJ, RJ, RJ}/*FV3*/

+  ,{XC, AC, AC, AC, AC, AC, AC, RJ, RJ, RJ, CP, CP, RJ, RJ, RJ, RJ, RJ}/*BV1*/

+  ,{XC, AC, AC, AC, AC, AC, AC, RJ, RJ, RJ, CP, RJ, RJ, RJ, RJ, RJ, RJ}/*BV2*/

+  ,{XC, AC, AC, AC, AC, AC, AC, RJ, RJ, RJ, RJ, RJ, RJ, RJ, RJ, RJ, RJ}/*BD*/

+  ,{XC, AC, AC, AC, AC, AC, AC, RJ, RJ, RJ, RJ, RJ, RJ, RJ, RJ, RJ, RJ}/*TONE*/

+  ,{XC, AC, AC, AC, AC, AC, AC, RJ, RJ, RJ, RJ, RJ, RJ, RJ, RJ, RJ, RJ}/*AD1*/

+  ,{XC, AC, AC, AC, AC, AC, AC, RJ, RJ, RJ, RJ, RJ, RJ, RJ, RJ, RJ, RJ}/*AD2*/

+  ,{XC, AC, AC, AC, AC, AC, AC, RJ, RJ, RJ, RJ, RJ, RJ, RJ, RJ, RJ, RJ}/*AD3*/

+  ,{XC, AC, AC, AC, AC, AC, AC, RJ, RJ, RJ, CP, CP, RJ, RJ, RJ, RJ, RJ}/*AV1*/

+  ,{XC, AC, AC, AC, AC, AC, AC, RJ, RJ, RJ, CP, RJ, RJ, RJ, RJ, RJ, RJ}/*AV2*/

+  ,{XC, AC, AC, AC, AC, AC, AC, RJ, RJ, RJ, CP, RJ, CP, RJ, RJ, RJ, RJ}/*AV3*/

+};

+

+Private

+char const wtt_isc2_lookup[CH_CLASSES][CH_CLASSES] = {

+      /* Table 2: WTT strict input sequence check rules */

+      /* row: leading char,  column: following char */

+/* CTRL NON CONS LV FV1 FV2 FV3 BV1 BV2 BD TONE AD1 AD2 AD3 AV1 AV2 AV3 */

+   {XC, AC, AC, AC, AC, AC, AC, RJ, RJ, RJ, RJ, RJ, RJ, RJ, RJ, RJ, RJ}/*CTRL*/

+  ,{XC, AC, AC, AC, RJ, RJ, AC, RJ, RJ, RJ, RJ, RJ, RJ, RJ, RJ, RJ, RJ}/*NON*/

+  ,{XC, AC, AC, AC, AC, RJ, AC, CP, CP, CP, CP, CP, CP, CP, CP, CP, CP}/*CONS*/

+  ,{XC, RJ, AC, RJ, RJ, RJ, RJ, RJ, RJ, RJ, RJ, RJ, RJ, RJ, RJ, RJ, RJ}/*LV*/

+  ,{XC, AC, AC, AC, AC, RJ, AC, RJ, RJ, RJ, RJ, RJ, RJ, RJ, RJ, RJ, RJ}/*FV1*/

+  ,{XC, AC, AC, AC, AC, RJ, AC, RJ, RJ, RJ, RJ, RJ, RJ, RJ, RJ, RJ, RJ}/*FV2*/

+  ,{XC, AC, AC, AC, RJ, AC, RJ, RJ, RJ, RJ, RJ, RJ, RJ, RJ, RJ, RJ, RJ}/*FV3*/

+  ,{XC, AC, AC, AC, AC, RJ, AC, RJ, RJ, RJ, CP, CP, RJ, RJ, RJ, RJ, RJ}/*BV1*/

+  ,{XC, AC, AC, AC, RJ, RJ, AC, RJ, RJ, RJ, CP, RJ, RJ, RJ, RJ, RJ, RJ}/*BV2*/

+  ,{XC, AC, AC, AC, RJ, RJ, AC, RJ, RJ, RJ, RJ, RJ, RJ, RJ, RJ, RJ, RJ}/*BD*/

+  ,{XC, AC, AC, AC, AC, AC, AC, RJ, RJ, RJ, RJ, RJ, RJ, RJ, RJ, RJ, RJ}/*TONE*/

+  ,{XC, AC, AC, AC, RJ, RJ, AC, RJ, RJ, RJ, RJ, RJ, RJ, RJ, RJ, RJ, RJ}/*AD1*/

+  ,{XC, AC, AC, AC, RJ, RJ, AC, RJ, RJ, RJ, RJ, RJ, RJ, RJ, RJ, RJ, RJ}/*AD2*/

+  ,{XC, AC, AC, AC, RJ, RJ, AC, RJ, RJ, RJ, RJ, RJ, RJ, RJ, RJ, RJ, RJ}/*AD3*/

+  ,{XC, AC, AC, AC, RJ, RJ, AC, RJ, RJ, RJ, CP, CP, RJ, RJ, RJ, RJ, RJ}/*AV1*/

+  ,{XC, AC, AC, AC, RJ, RJ, AC, RJ, RJ, RJ, CP, RJ, RJ, RJ, RJ, RJ, RJ}/*AV2*/

+  ,{XC, AC, AC, AC, RJ, RJ, AC, RJ, RJ, RJ, CP, RJ, CP, RJ, RJ, RJ, RJ}/*AV3*/

+};

+

+Private

+char const thaicat_isc_lookup[CH_CLASSES][CH_CLASSES] = {

+      /* Table 3: Thaicat input sequence check rules */

+      /* row: leading char,  column: following char */

+/* CTRL NON CONS LV FV1 FV2 FV3 BV1 BV2 BD TONE AD1 AD2 AD3 AV1 AV2 AV3 */

+   {XC, AC, AC, AC, AC, AC, AC, RJ, RJ, RJ, RJ, RJ, RJ, RJ, RJ, RJ, RJ}/*CTRL*/

+  ,{XC, AC, AC, AC, AC, AC, AC, RJ, RJ, RJ, RJ, RJ, RJ, RJ, RJ, RJ, RJ}/*NON*/

+  ,{XC, AC, AC, AC, AC, AC, AC, CP, CP, CP, CP, CP, CP, CP, CP, CP, CP}/*CONS*/

+  ,{XC, AC, AC, AC, AC, AC, AC, RJ, RJ, RJ, RJ, RJ, RJ, RJ, RJ, RJ, RJ}/*LV*/

+  ,{XC, AC, AC, AC, AC, AC, AC, RJ, RJ, RJ, RJ, RJ, RJ, RJ, RJ, RJ, RJ}/*FV1*/

+  ,{XC, AC, AC, AC, AC, AC, AC, RJ, RJ, RJ, RJ, RJ, RJ, RJ, RJ, RJ, RJ}/*FV2*/

+  ,{XC, AC, AC, AC, AC, AC, AC, RJ, RJ, RJ, RJ, RJ, RJ, RJ, RJ, RJ, RJ} /*FV3*/

+  ,{XC, AC, AC, AC, AC, AC, AC, RJ, RJ, RJ, CP, CP, RJ, RJ, RJ, RJ, RJ}/*BV1*/

+  ,{XC, AC, AC, AC, AC, AC, AC, RJ, RJ, RJ, CP, RJ, RJ, RJ, RJ, RJ, RJ}/*BV2*/

+  ,{XC, AC, AC, AC, AC, AC, AC, RJ, RJ, RJ, RJ, RJ, RJ, RJ, RJ, RJ, RJ}/*BD*/

+  ,{XC, AC, AC, AC, AC, AC, AC, CP, CP, RJ, RJ, RJ, RJ, RJ, CP, CP, CP}/*TONE*/

+  ,{XC, AC, AC, AC, AC, AC, AC, CP, RJ, RJ, RJ, RJ, RJ, RJ, CP, RJ, RJ}/*AD1*/

+  ,{XC, AC, AC, AC, AC, AC, AC, RJ, RJ, RJ, RJ, RJ, RJ, RJ, RJ, RJ, CP}/*AD2*/

+  ,{XC, AC, AC, AC, AC, AC, AC, RJ, RJ, RJ, RJ, RJ, RJ, RJ, RJ, RJ, RJ}/*AD3*/

+  ,{XC, AC, AC, AC, AC, AC, AC, RJ, RJ, RJ, CP, CP, RJ, RJ, RJ, RJ, RJ}/*AV1*/

+  ,{XC, AC, AC, AC, AC, AC, AC, RJ, RJ, RJ, CP, RJ, RJ, RJ, RJ, RJ, RJ}/*AV2*/

+  ,{XC, AC, AC, AC, AC, AC, AC, RJ, RJ, RJ, CP, RJ, CP, RJ, RJ, RJ, RJ}/*AV3*/

+};

+

+

+/* returns classification of a char */

+Private int

+THAI_chtype (unsigned char	ch)

+{

+    return tactis_chtype[ch];

+}

+

+#ifdef UNUSED

+/* returns the display level */

+Private int

+THAI_chlevel (unsigned char	ch)

+{

+    int     chlevel;

+

+    switch (tactis_chtype[ch])

+    {

+        case CTRL:

+            chlevel = NON;

+            break;

+        case BV1:

+        case BV2:

+        case BD:

+            chlevel = BELOW;

+            break;

+        case TONE:

+        case AD1:

+        case AD2:

+            chlevel = TOP;

+            break;

+        case AV1:

+        case AV2:

+        case AV3:

+        case AD3:

+            chlevel = ABOVE;

+            break;

+        case NON:

+        case CONS:

+        case LV:

+        case FV1:

+        case FV2:

+        case FV3:

+        default: /* if tactis_chtype is invalid */

+            chlevel = BASE;

+            break;

+    }

+    return chlevel;

+}

+

+

+/* return True if char is non-spacing */

+Private Bool

+THAI_isdead (unsigned char	ch)

+{

+    return ((tactis_chtype[ch] == CTRL) || (tactis_chtype[ch] == BV1) ||

+            (tactis_chtype[ch] == BV2)  || (tactis_chtype[ch] == BD)  ||

+            (tactis_chtype[ch] == TONE) || (tactis_chtype[ch] == AD1) ||

+            (tactis_chtype[ch] == AD2)  || (tactis_chtype[ch] == AD3) ||

+            (tactis_chtype[ch] == AV1)  || (tactis_chtype[ch] == AV2) ||

+            (tactis_chtype[ch] == AV3));

+}

+

+

+/* return True if char is consonant */

+Private Bool

+THAI_iscons (unsigned char	ch)

+{

+    return (tactis_chtype[ch] == CONS);

+}

+

+

+/* return True if char is vowel */

+Private Bool

+THAI_isvowel (unsigned char	ch)

+{

+    return ((tactis_chtype[ch] == LV)  || (tactis_chtype[ch] == FV1) ||

+            (tactis_chtype[ch] == FV2) || (tactis_chtype[ch] == FV3) ||

+            (tactis_chtype[ch] == BV1) || (tactis_chtype[ch] == BV2) ||

+            (tactis_chtype[ch] == AV1) || (tactis_chtype[ch] == AV2) ||

+            (tactis_chtype[ch] == AV3));

+}

+

+

+/* return True if char is tonemark */

+Private Bool

+THAI_istone (unsigned char	ch)

+{

+    return (tactis_chtype[ch] == TONE);

+}

+#endif

+

+Private Bool

+THAI_iscomposible (

+    unsigned char	follow_ch,

+    unsigned char	lead_ch)

+{/* "Can follow_ch be put in the same display cell as lead_ch?" */

+

+    return (write_rules_lookup[THAI_chtype(lead_ch)][THAI_chtype(follow_ch)]

+            == CP);

+}

+

+Private Bool

+THAI_isaccepted (

+    unsigned char	follow_ch,

+    unsigned char	lead_ch,

+    unsigned char	mode)

+{

+    Bool iskeyvalid; /*  means "Can follow_ch be keyed in after lead_ch?" */

+

+    switch (mode)

+    {

+        case WTT_ISC1:

+            iskeyvalid =

+          (wtt_isc1_lookup[THAI_chtype(lead_ch)][THAI_chtype(follow_ch)] != RJ);

+            break;

+        case WTT_ISC2:

+            iskeyvalid =

+          (wtt_isc2_lookup[THAI_chtype(lead_ch)][THAI_chtype(follow_ch)] != RJ);

+            break;

+        case THAICAT_ISC:

+            iskeyvalid =

+       (thaicat_isc_lookup[THAI_chtype(lead_ch)][THAI_chtype(follow_ch)] != RJ);

+            break;

+        default:

+            iskeyvalid = True;

+            break;

+    }

+

+    return iskeyvalid;

+}

+

+#ifdef UNUSED

+Private void

+THAI_apply_write_rules(

+    unsigned char	*instr,

+    unsigned char	*outstr,

+    unsigned char	insert_ch,

+    int 		*num_insert_ch)

+{

+/*

+Input parameters:

+    instr - input string

+    insert_ch specify what char to be added when invalid composition is found

+Output parameters:

+    outstr - output string after input string has been applied the rules

+    num_insert_ch - number of insert_ch added to outstr.

+*/

+    unsigned char   *lead_ch = NULL, *follow_ch = NULL, *out_ch = NULL;

+

+    *num_insert_ch = 0;

+    lead_ch = follow_ch = instr;

+    out_ch = outstr;

+    if ((*lead_ch == '\0') || !(THAI_find_chtype(instr,DEAD)))

+    {   /* Empty string or can't find any non-spacing char*/

+        strcpy((char *)outstr, (char *)instr);

+    } else { /* String of length >= 1, keep looking */

+        follow_ch++;

+        if (THAI_isdead(*lead_ch)) { /* is first char non-spacing? */

+            *out_ch++ = SPACE;

+            (*num_insert_ch)++;

+        }

+        *out_ch++ = *lead_ch;

+        while (*follow_ch != '\0')  /* more char in string to check */

+        {

+            if (THAI_isdead(*follow_ch) &&

+                 !THAI_iscomposible(*follow_ch,*lead_ch))

+            {

+                *out_ch++ = SPACE;

+                (*num_insert_ch)++;

+            }

+            *out_ch++ = *follow_ch;

+            lead_ch = follow_ch;

+            follow_ch++;

+        }

+        *out_ch = '\0';

+    }

+}

+

+Private int

+THAI_find_chtype (

+    unsigned char	*instr,

+    int		chtype)

+{

+/*

+Input parameters:

+    instr - input string

+    chtype - type of character to look for

+Output parameters:

+    function returns first position of character with matched chtype

+    function returns -1 if it does not find.

+*/

+    int i = 0, position = -1;

+

+    switch (chtype)

+    {

+        case DEAD:

+            for (i = 0; *instr != '\0' && THAI_isdead(*instr); i++, instr++)

+		;

+            if (*instr != '\0') position = i;

+            break;

+        default:

+            break;

+    }

+    return position;

+}

+

+

+Private int

+THAI_apply_scm(

+    unsigned char	*instr,

+    unsigned char	*outstr,

+    unsigned char	spec_ch,

+    int		num_sp,

+    unsigned char	insert_ch)

+{

+    unsigned char   *scan, *outch;

+    int             i, dead_count, found_count;

+    Bool            isconsecutive;

+

+    scan = instr;

+    outch = outstr;

+    dead_count = found_count = 0;

+    isconsecutive = False;

+    while (*scan != '\0') {

+        if (THAI_isdead(*scan))

+            dead_count++;       /* count number of non-spacing char */

+        if (*scan == spec_ch)

+            if (!isconsecutive)

+                found_count++;      /* count number consecutive spec char found */

+        *outch++ = *scan++;

+        if (found_count == num_sp) {

+            for (i = 0; i < dead_count; i++)

+                *outch++ = insert_ch;

+            dead_count = found_count = 0;

+        }

+    }

+    /* what to return? */

+    return 0; /* probably not right but better than returning garbage */

+}

+

+

+/* The following functions are copied from XKeyBind.c */

+

+Private void ComputeMaskFromKeytrans();

+Private int IsCancelComposeKey(KeySym *symbol, XKeyEvent *event);

+Private void SetLed(Display *dpy, int num, int state);

+Private CARD8 FindKeyCode();

+

+

+/* The following functions are specific to this module */

+

+Private int XThaiTranslateKey();

+Private int XThaiTranslateKeySym();

+

+

+Private KeySym HexIMNormalKey(

+    XicThaiPart *thai_part,

+    KeySym symbol,

+    XKeyEvent *event);

+Private KeySym HexIMFirstComposeKey(

+    XicThaiPart *thai_part,

+    KeySym symbol,

+    XKeyEvent *event);

+Private KeySym HexIMSecondComposeKey(

+    XicThaiPart *thai_part,

+    KeySym symbol

+    XKeyEvent *event);

+Private KeySym HexIMComposeSequence(KeySym ks1, KeySym ks2);

+Private void InitIscMode(Xic ic);

+Private Bool ThaiComposeConvert(

+    Display *dpy,

+    KeySym insym,

+    KeySym *outsym, KeySym *lower, KeySym *upper);

+#endif

+

+/*

+ * Definitions

+ */

+

+#define BellVolume 		0

+

+#define ucs2tis(wc)  \

+ (unsigned char) ( \

+   (0<=(wc)&&(wc)<=0x7F) ? \

+     (wc) : \

+     ((0x0E01<=(wc)&&(wc)<=0x0E5F) ? ((wc)-0x0E00+0xA0) : 0))

+/* "c" is an unsigned char */

+#define tis2ucs(c)  \

+  ( \

+   ((c)<=0x7F) ? \

+     (wchar_t)(c) : \

+     ((0x0A1<=(c)) ? ((wchar_t)(c)-0xA0+0x0E00) : 0))

+

+/*

+ * Macros to save and recall last input character in XIC

+ */

+#define IC_SavePreviousChar(ic,ch) \

+                ((ic)->private.local.base.mb[(ic)->private.local.base.tree[(ic)->private.local.context].mb] = (char) (ch))

+#define IC_ClearPreviousChar(ic) \

+                ((ic)->private.local.base.mb[(ic)->private.local.base.tree[(ic)->private.local.context].mb] = 0)

+#define IC_GetPreviousChar(ic) \

+		(IC_RealGetPreviousChar(ic,1))

+#define IC_GetContextChar(ic) \

+		(IC_RealGetPreviousChar(ic,2))

+#define IC_DeletePreviousChar(ic) \

+		(IC_RealDeletePreviousChar(ic))

+

+Private unsigned char

+IC_RealGetPreviousChar(Xic ic, unsigned short pos)

+{

+    XICCallback* cb = &ic->core.string_conversion_callback;

+    DefTreeBase *b = &ic->private.local.base;

+

+    if (cb && cb->callback) {

+        XIMStringConversionCallbackStruct screc;

+        unsigned char c;

+

+        /* Use a safe value of position = 0 and stretch the range to desired

+         * place, as XIM protocol is unclear here whether it could be negative

+         */

+        screc.position = 0;

+        screc.direction = XIMBackwardChar;

+        screc.operation = XIMStringConversionRetrieval;

+        screc.factor = pos;

+        screc.text = 0;

+

+        (cb->callback)((XIC)ic, cb->client_data, (XPointer)&screc);

+        if (!screc.text)

+            return (unsigned char) b->mb[b->tree[(ic)->private.local.context].mb];

+        if ((screc.text->feedback &&

+             *screc.text->feedback == XIMStringConversionLeftEdge) ||

+            screc.text->length < 1)

+        {

+            c = 0;

+        } else {

+            Xim     im;

+            XlcConv conv;

+            int     from_left;

+            int     to_left;

+            char   *from_buf;

+            char   *to_buf;

+

+            im = (Xim) XIMOfIC((XIC)ic);

+            if (screc.text->encoding_is_wchar) {

+                conv = _XlcOpenConverter(im->core.lcd, XlcNWideChar,

+                                         im->core.lcd, XlcNCharSet);

+                from_buf = (char *) screc.text->string.wcs;

+                from_left = screc.text->length * sizeof(wchar_t);

+            } else {

+                conv = _XlcOpenConverter(im->core.lcd, XlcNMultiByte,

+                                         im->core.lcd, XlcNCharSet);

+                from_buf = screc.text->string.mbs;

+                from_left = screc.text->length;

+            }

+            to_buf = (char *)&c;

+            to_left = 1;

+

+            _XlcResetConverter(conv);

+            if (_XlcConvert(conv, (XPointer *)&from_buf, &from_left,

+                            (XPointer *)&to_buf, &to_left, NULL, 0) < 0)

+            {

+                c = (unsigned char) b->mb[b->tree[(ic)->private.local.context].mb];

+            }

+            _XlcCloseConverter(conv);

+

+            XFree(screc.text->string.mbs);

+        }

+        XFree(screc.text);

+        return c;

+    } else {

+        return (unsigned char) b->mb[b->tree[(ic)->private.local.context].mb];

+    }

+}

+

+Private unsigned char

+IC_RealDeletePreviousChar(Xic ic)

+{

+    XICCallback* cb = &ic->core.string_conversion_callback;

+

+    if (cb && cb->callback) {

+        XIMStringConversionCallbackStruct screc;

+        unsigned char c;

+

+        screc.position = 0;

+        screc.direction = XIMBackwardChar;

+        screc.operation = XIMStringConversionSubstitution;

+        screc.factor = 1;

+        screc.text = 0;

+

+        (cb->callback)((XIC)ic, cb->client_data, (XPointer)&screc);

+        if (!screc.text) { return 0; }

+        if ((screc.text->feedback &&

+             *screc.text->feedback == XIMStringConversionLeftEdge) ||

+            screc.text->length < 1)

+        {

+            c = 0;

+        } else {

+            if (screc.text->encoding_is_wchar) {

+                c = ucs2tis(screc.text->string.wcs[0]);

+                XFree(screc.text->string.wcs);

+            } else {

+                c = screc.text->string.mbs[0];

+                XFree(screc.text->string.mbs);

+            }

+        }

+        XFree(screc.text);

+        return c;

+    } else {

+        return 0;

+    }

+}

+/*

+ * Input sequence check mode in XIC

+ */

+#define IC_IscMode(ic)		((ic)->private.local.thai.input_mode)

+

+/*

+ * Max. size of string handled by the two String Lookup functions.

+ */

+#define STR_LKUP_BUF_SIZE	256

+

+/*

+ * Size of buffer to contain previous locale name.

+ */

+#define SAV_LOCALE_NAME_SIZE	256

+

+/*

+ * Size of buffer to contain the IM modifier.

+ */

+#define MAXTHAIIMMODLEN 20

+

+#define AllMods (ShiftMask|LockMask|ControlMask| \

+		 Mod1Mask|Mod2Mask|Mod3Mask|Mod4Mask|Mod5Mask)

+

+

+#define IsISOControlKey(ks) ((ks) >= XK_2 && (ks) <= XK_8)

+

+#define IsValidControlKey(ks)   (((((ks)>=XK_A && (ks)<=XK_asciitilde) || \

+                (ks)==XK_space || (ks)==XK_Delete) && \

+                ((ks)!=0)))

+

+#define COMPOSE_LED 2

+

+#ifdef UNUSED

+typedef KeySym (*StateProc)(

+    XicThaiPart *thai_part,

+    KeySym symbol,

+    XKeyEvent *event);

+

+

+/*

+ * macros to classify XKeyEvent state field

+ */

+

+#define IsShift(state) (((state) & ShiftMask) != 0)

+#define IsLock(state) (((state) & LockMask) != 0)

+#define IsControl(state) (((state) & ControlMask) != 0)

+#define IsMod1(state) (((state) & Mod1Mask) != 0)

+#define IsMod2(state) (((state) & Mod2Mask) != 0)

+#define IsMod3(state) (((state) & Mod3Mask) != 0)

+#define IsMod4(state) (((state) & Mod4Mask) != 0)

+#define IsMod5(state) (((state) & Mod5Mask) != 0)

+

+/*

+ * key starts Thai compose sequence (Hex input method) if :

+ */

+

+#define IsComposeKey(ks, event)  \

+	(( ks==XK_Alt_L && 	\

+	   IsControl((event)->state) &&	\

+	   !IsShift((event)->state))	\

+	 ? True : False)

+

+

+/*

+ *  State handler to implement the Thai hex input method.

+ */

+

+Private int const nstate_handlers = 3;

+Private StateProc state_handler[] = {

+	HexIMNormalKey,

+	HexIMFirstComposeKey,

+	HexIMSecondComposeKey

+};

+

+

+/*

+ *  Table for 'Thai Compose' character input.

+ *  The current implementation uses latin-1 keysyms.

+ */

+struct _XMapThaiKey {

+	KeySym from;

+	KeySym to;

+};

+

+Private struct _XMapThaiKey const ThaiComposeTable[] = {

+	{ /* 0xa4 */ XK_currency,	/* 0xa5 */ XK_yen },

+	{ /* 0xa2 */ XK_cent,		/* 0xa3 */ XK_sterling },

+	{ /* 0xe6 */ XK_ae,		/* 0xef */ XK_idiaeresis },

+	{ /* 0xd3 */ XK_Oacute,		/* 0xee */ XK_icircumflex },

+	{ /* 0xb9 */ XK_onesuperior,	/* 0xfa */ XK_uacute },

+	{ /* 0xd2 */ XK_Ograve,		/* 0xe5 */ XK_aring },

+	{ /* 0xbc */ XK_onequarter,	/* 0xfb */ XK_ucircumflex },

+	{	     XK_VoidSymbol,		   XK_VoidSymbol }

+};

+

+struct _XKeytrans {

+	struct _XKeytrans *next;/* next on list */

+	char *string;		/* string to return when the time comes */

+	int len;		/* length of string (since NULL is legit)*/

+	KeySym key;		/* keysym rebound */

+	unsigned int state;	/* modifier state */

+	KeySym *modifiers;	/* modifier keysyms you want */

+	int mlen;		/* length of modifier list */

+};

+

+

+/* Convert keysym to 'Thai Compose' keysym */

+/* The current implementation use latin-1 keysyms */

+Private Bool

+ThaiComposeConvert(

+    Display *dpy,

+    KeySym insym,

+    KeySym *outsym, KeySym *lower, KeySym *upper)

+{

+    struct _XMapThaiKey const *table_entry = ThaiComposeTable;

+

+    while (table_entry->from != XK_VoidSymbol) {

+	if (table_entry->from == insym) {

+	    *outsym = table_entry->to;

+	    *lower = *outsym;

+	    *upper = *outsym;

+	    return True;

+	}

+	table_entry++;

+    }

+    return False;

+}

+

+Private int

+XThaiTranslateKey(

+    register Display *dpy,

+    KeyCode keycode,

+    register unsigned int modifiers,

+    unsigned int *modifiers_return,

+    KeySym *keysym_return,

+    KeySym *lsym_return,

+    KeySym *usym_return)

+{

+    int per;

+    register KeySym *syms;

+    KeySym sym = 0, lsym = 0, usym = 0;

+

+    if ((! dpy->keysyms) && (! _XKeyInitialize(dpy)))

+	return 0;

+    *modifiers_return = (ShiftMask|LockMask) | dpy->mode_switch;

+    if (((int)keycode < dpy->min_keycode) || ((int)keycode > dpy->max_keycode))

+    {

+	*keysym_return = NoSymbol;

+	return 1;

+    }

+    per = dpy->keysyms_per_keycode;

+    syms = &dpy->keysyms[(keycode - dpy->min_keycode) * per];

+    while ((per > 2) && (syms[per - 1] == NoSymbol))

+	per--;

+    if ((per > 2) && (modifiers & dpy->mode_switch)) {

+	syms += 2;

+	per -= 2;

+    }

+    if (!(modifiers & ShiftMask) &&

+	(!(modifiers & LockMask) || (dpy->lock_meaning == NoSymbol))) {

+	if ((per == 1) || (syms[1] == NoSymbol))

+	    XConvertCase(syms[0], keysym_return, &usym);

+	else {

+	    XConvertCase(syms[0], &lsym, &usym);

+	    *keysym_return = syms[0];

+	}

+    } else if (!(modifiers & LockMask) ||

+	       (dpy->lock_meaning != XK_Caps_Lock)) {

+	if ((per == 1) || ((usym = syms[1]) == NoSymbol))

+	    XConvertCase(syms[0], &lsym, &usym);

+	*keysym_return = usym;

+    } else {

+	if ((per == 1) || ((sym = syms[1]) == NoSymbol))

+	    sym = syms[0];

+	XConvertCase(sym, &lsym, &usym);

+	if (!(modifiers & ShiftMask) && (sym != syms[0]) &&

+	    ((sym != usym) || (lsym == usym)))

+	    XConvertCase(syms[0], &lsym, &usym);

+	*keysym_return = usym;

+    }

+    /*

+     * ThaiCat keyboard support :

+     * When the Shift and Thai keys are hold for some keys a 'Thai Compose'

+     * character code is generated which is different from column 3 and

+     * 4 of the keymap.

+     * Since we don't know whether ThaiCat keyboard or WTT keyboard is

+     * in use, the same mapping is done for all Thai input.

+     * We just arbitary choose to use column 3 keysyms as the indices of

+     * this mapping.

+     * When the control key is also hold, this mapping has no effect.

+     */

+    if ((modifiers & Mod1Mask) &&

+	(modifiers & ShiftMask) &&

+	!(modifiers & ControlMask)) {

+	if (ThaiComposeConvert(dpy, syms[0], &sym, &lsym, &usym))

+	    *keysym_return = sym;

+    }

+

+    if (*keysym_return == XK_VoidSymbol)

+	*keysym_return = NoSymbol;

+    *lsym_return = lsym;

+    *usym_return = usym;

+    return 1;

+}

+

+/*

+ * XThaiTranslateKeySym

+ *

+ * Translate KeySym to TACTIS code output.

+ * The current implementation uses ISO latin-1 keysym.

+ * Should be changed to TACTIS keysyms when they are defined by the

+ * standard.

+ */

+Private int

+XThaiTranslateKeySym(

+    Display *dpy,

+    register KeySym symbol,

+    register KeySym lsym,

+    register KeySym usym,

+    unsigned int modifiers,

+    unsigned char *buffer,

+    int nbytes)

+{

+    KeySym ckey = 0;

+    register struct _XKeytrans *p;

+    int length;

+    unsigned long hiBytes;

+    register unsigned char c;

+

+    /*

+     * initialize length = 1 ;

+     */

+    length = 1;

+

+    if (!symbol)

+	return 0;

+    /* see if symbol rebound, if so, return that string. */

+    for (p = dpy->key_bindings; p; p = p->next) {

+	if (((modifiers & AllMods) == p->state) && (symbol == p->key)) {

+	    length = p->len;

+	    if (length > nbytes) length = nbytes;

+	    memcpy (buffer, p->string, length);

+	    return length;

+	}

+    }

+    /* try to convert to TACTIS, handling control */

+    hiBytes = symbol >> 8;

+    if (!(nbytes &&

+	  ((hiBytes == 0) ||

+	   ((hiBytes == 0xFF) &&

+	    (((symbol >= XK_BackSpace) && (symbol <= XK_Clear)) ||

+	     (symbol == XK_Return) ||

+	     (symbol == XK_Escape) ||

+	     (symbol == XK_KP_Space) ||

+	     (symbol == XK_KP_Tab) ||

+	     (symbol == XK_KP_Enter) ||

+	     ((symbol >= XK_KP_Multiply) && (symbol <= XK_KP_9)) ||

+	     (symbol == XK_KP_Equal) ||

+             (symbol == XK_Scroll_Lock) ||

+#ifdef DXK_PRIVATE /* DEC private keysyms */

+             (symbol == DXK_Remove) ||

+#endif

+             (symbol == NoSymbol) ||

+	     (symbol == XK_Delete))))))

+	return 0;

+

+    /* if X keysym, convert to ascii by grabbing low 7 bits */

+    if (symbol == XK_KP_Space)

+	c = XK_space & 0x7F; /* patch encoding botch */

+/* not for Thai

+    else if (symbol == XK_hyphen)

+	c = XK_minus & 0xFF; */ /* map to equiv character */

+    else if (hiBytes == 0xFF)

+	c = symbol & 0x7F;

+    else

+	c = symbol & 0xFF;

+    /* only apply Control key if it makes sense, else ignore it */

+    if (modifiers & ControlMask) {

+    if (!(IsKeypadKey(lsym) || lsym==XK_Return || lsym==XK_Tab)) {

+        if (IsISOControlKey(lsym)) ckey = lsym;

+        else if (IsISOControlKey(usym)) ckey = usym;

+        else if (lsym == XK_question) ckey = lsym;

+        else if (usym == XK_question) ckey = usym;

+        else if (IsValidControlKey(lsym)) ckey = lsym;

+        else if (IsValidControlKey(usym)) ckey = usym;

+        else length = 0;

+

+        if (length != 0) {

+        if (ckey == XK_2) c = '\000';

+        else if (ckey >= XK_3 && ckey <= XK_7)

+            c = (char)(ckey-('3'-'\033'));

+        else if (ckey == XK_8) c = '\177';

+        else if (ckey == XK_Delete) c = '\030';

+        else if (ckey == XK_question) c = '\037';

+        else if (ckey == XK_quoteleft) c = '\036';  /* KLee 1/24/91 */

+        else c = (char)(ckey & 0x1f);

+        }

+    }

+    }

+    /*

+     *  ThaiCat has a key that generates two TACTIS codes D1 & E9.

+     *  It is represented by the latin-1 keysym XK_thorn (0xfe).

+     *  If c is XK_thorn, this key is pressed and it is converted to

+     *  0xd1 0xe9.

+     */

+    if (c == XK_thorn) {

+	buffer[0] = 0xd1;

+	buffer[1] = 0xe9;

+	buffer[2] = '\0';

+	return 2;

+    }

+    else {

+	/* Normal case */

+        buffer[0] = c;

+	buffer[1] = '\0';

+        return 1;

+    }

+}

+

+/*

+ * given a KeySym, returns the first keycode containing it, if any.

+ */

+Private CARD8

+FindKeyCode(

+    register Display *dpy,

+    register KeySym code)

+{

+

+    register KeySym *kmax = dpy->keysyms +

+	(dpy->max_keycode - dpy->min_keycode + 1) * dpy->keysyms_per_keycode;

+    register KeySym *k = dpy->keysyms;

+    while (k < kmax) {

+	if (*k == code)

+	    return (((k - dpy->keysyms) / dpy->keysyms_per_keycode) +

+		    dpy->min_keycode);

+	k += 1;

+	}

+    return 0;

+}

+

+/*

+ * given a list of modifiers, computes the mask necessary for later matching.

+ * This routine must lookup the key in the Keymap and then search to see

+ * what modifier it is bound to, if any.  Sets the AnyModifier bit if it

+ * can't map some keysym to a modifier.

+ */

+Private void

+ComputeMaskFromKeytrans(

+    Display *dpy,

+    register struct _XKeytrans *p)

+{

+    register int i;

+    register CARD8 code;

+    register XModifierKeymap *m = dpy->modifiermap;

+

+    p->state = AnyModifier;

+    for (i = 0; i < p->mlen; i++) {

+	/* if not found, then not on current keyboard */

+	if ((code = FindKeyCode(dpy, p->modifiers[i])) == 0)

+		return;

+	/* code is now the keycode for the modifier you want */

+	{

+	    register int j = m->max_keypermod<<3;

+

+	    while ((--j >= 0) && (code != m->modifiermap[j]))

+		;

+	    if (j < 0)

+		return;

+	    p->state |= (1<<(j/m->max_keypermod));

+	}

+    }

+    p->state &= AllMods;

+}

+

+/************************************************************************

+ *

+ *

+ * Compose handling routines - compose handlers 0,1,2

+ *

+ *

+ ************************************************************************/

+

+#define NORMAL_KEY_STATE 0

+#define FIRST_COMPOSE_KEY_STATE 1

+#define SECOND_COMPOSE_KEY_STATE 2

+

+Private

+KeySym HexIMNormalKey(

+    XicThaiPart *thai_part,

+    KeySym symbol,

+    XKeyEvent *event)

+{

+    if (IsComposeKey (symbol, event))	/* start compose sequence	*/

+	{

+	SetLed (event->display,COMPOSE_LED, LedModeOn);

+	thai_part->comp_state = FIRST_COMPOSE_KEY_STATE;

+	return NoSymbol;

+	}

+    return symbol;

+}

+

+

+Private

+KeySym HexIMFirstComposeKey(

+    XicThaiPart *thai_part,

+    KeySym symbol,

+    XKeyEvent *event)

+{

+    if (IsModifierKey (symbol)) return symbol; /* ignore shift etc. */

+    if (IsCancelComposeKey (&symbol, event))	/* cancel sequence */

+	{

+	SetLed (event->display,COMPOSE_LED, LedModeOff);

+	thai_part->comp_state = NORMAL_KEY_STATE;

+	return symbol;

+	}

+    if (IsComposeKey (symbol, event))		/* restart sequence ?? */

+	{

+	return NoSymbol;			/* no state change necessary */

+	}

+

+    thai_part->keysym = symbol;		/* save key pressed */

+    thai_part->comp_state = SECOND_COMPOSE_KEY_STATE;

+    return NoSymbol;

+}

+

+Private

+KeySym HexIMSecondComposeKey(

+    XicThaiPart *thai_part,

+    KeySym symbol,

+    XKeyEvent *event)

+{

+    if (IsModifierKey (symbol)) return symbol;	/* ignore shift etc. */

+    if (IsComposeKey (symbol, event))		/* restart sequence ? */

+	{

+	thai_part->comp_state =FIRST_COMPOSE_KEY_STATE;

+	return NoSymbol;

+	}

+    SetLed (event->display,COMPOSE_LED, LedModeOff);

+    if (IsCancelComposeKey (&symbol, event))	/* cancel sequence ? */

+	{

+	thai_part->comp_state = NORMAL_KEY_STATE;

+	return symbol;

+	}

+

+    if ((symbol = HexIMComposeSequence (thai_part->keysym, symbol))

+								==NoSymbol)

+	{ /* invalid compose sequence */

+	XBell(event->display, BellVolume);

+	}

+    thai_part->comp_state = NORMAL_KEY_STATE; /* reset to normal state */

+    return symbol;

+}

+

+

+/*

+ * Interprets two keysyms entered as hex digits and return the Thai keysym

+ * correspond to the TACTIS code formed.

+ * The current implementation of this routine returns ISO Latin Keysyms.

+ */

+

+Private

+KeySym HexIMComposeSequence(KeySym ks1, KeySym ks2)

+{

+int	hi_digit;

+int	lo_digit;

+int	tactis_code;

+

+    if ((ks1 >= XK_0) && (ks1 <= XK_9))

+	hi_digit = ks1 - XK_0;

+    else if ((ks1 >= XK_A) && (ks1 <= XK_F))

+	hi_digit = ks1 - XK_A + 10;

+    else if ((ks1 >= XK_a) && (ks1 <= XK_f))

+	hi_digit = ks1 - XK_a + 10;

+    else	/* out of range */

+	return NoSymbol;

+

+    if ((ks2 >= XK_0) && (ks2 <= XK_9))

+	lo_digit = ks2 - XK_0;

+    else if ((ks2 >= XK_A) && (ks2 <= XK_F))

+	lo_digit = ks2 - XK_A + 10;

+    else if ((ks2 >= XK_a) && (ks2 <= XK_f))

+	lo_digit = ks2 - XK_a + 10;

+    else	/* out of range */

+	return NoSymbol;

+

+    tactis_code = hi_digit * 0x10 + lo_digit ;

+

+    return (KeySym)tactis_code;

+

+}

+

+/*

+ * routine determines

+ *	1) whether key event should cancel a compose sequence

+ *	2) whether cancelling key event should be processed or ignored

+ */

+

+Private

+int IsCancelComposeKey(

+    KeySym *symbol,

+    XKeyEvent *event)

+{

+    if (*symbol==XK_Delete && !IsControl(event->state) &&

+						!IsMod1(event->state)) {

+	*symbol=NoSymbol;  /* cancel compose sequence, and ignore key */

+	return True;

+    }

+    if (IsComposeKey(*symbol, event)) return False;

+    return (

+	IsControl (event->state) ||

+	IsMod1(event->state) ||

+	IsKeypadKey (*symbol) ||

+	IsFunctionKey (*symbol) ||

+	IsMiscFunctionKey (*symbol) ||

+#ifdef DXK_PRIVATE /* DEC private keysyms */

+	*symbol == DXK_Remove ||

+#endif

+	IsPFKey (*symbol) ||

+	IsCursorKey (*symbol) ||

+	(*symbol >= XK_Tab && *symbol < XK_Multi_key)

+		? True : False);	/* cancel compose sequence and pass */

+					/* cancelling key through	    */

+}

+

+

+/*

+ *	set specified keyboard LED on or off

+ */

+

+Private

+void SetLed(

+    Display *dpy,

+    int num,

+    int state)

+{

+    XKeyboardControl led_control;

+

+    led_control.led_mode = state;

+    led_control.led = num;

+    XChangeKeyboardControl (dpy, KBLed | KBLedMode,	&led_control);

+}

+#endif

+

+/*

+ * Initialize ISC mode from im modifier

+ */

+Private void InitIscMode(Xic ic)

+{

+    Xim im;

+    char *im_modifier_name;

+

+    /* If already defined, just return */

+

+    if (IC_IscMode(ic)) return;

+

+    /* Get IM modifier */

+

+    im = (Xim) XIMOfIC((XIC)ic);

+    im_modifier_name = im->core.im_name;

+

+    /* Match with predefined value, default is Basic Check */

+

+    if (!strncmp(im_modifier_name,"BasicCheck",MAXTHAIIMMODLEN+1))

+	IC_IscMode(ic) = WTT_ISC1;

+    else if (!strncmp(im_modifier_name,"Strict",MAXTHAIIMMODLEN+1))

+	IC_IscMode(ic) = WTT_ISC2;

+    else if (!strncmp(im_modifier_name,"Thaicat",MAXTHAIIMMODLEN+1))

+	IC_IscMode(ic) = THAICAT_ISC;

+    else if (!strncmp(im_modifier_name,"Passthrough",MAXTHAIIMMODLEN+1))

+	IC_IscMode(ic) = NOISC;

+    else

+	IC_IscMode(ic) = WTT_ISC1;

+

+    return;

+}

+

+/*

+ * Helper functions for _XimThaiFilter()

+ */

+Private Bool

+ThaiFltAcceptInput(Xic ic, unsigned char new_char, KeySym symbol)

+{

+    DefTreeBase *b = &ic->private.local.base;

+    b->wc[b->tree[ic->private.local.composed].wc+0] = tis2ucs(new_char);

+    b->wc[b->tree[ic->private.local.composed].wc+1] = '\0';

+

+    if ((new_char <= 0x1f) || (new_char == 0x7f))

+        b->tree[ic->private.local.composed].keysym = symbol;

+    else

+        b->tree[ic->private.local.composed].keysym = NoSymbol;

+

+    return True;

+}

+

+Private Bool

+ThaiFltReorderInput(Xic ic, unsigned char previous_char, unsigned char new_char)

+{

+    DefTreeBase *b = &ic->private.local.base;

+    if (!IC_DeletePreviousChar(ic)) return False;

+    b->wc[b->tree[ic->private.local.composed].wc+0] = tis2ucs(new_char);

+    b->wc[b->tree[ic->private.local.composed].wc+1] = tis2ucs(previous_char);

+    b->wc[b->tree[ic->private.local.composed].wc+2] = '\0';

+

+    b->tree[ic->private.local.composed].keysym = NoSymbol;

+

+    return True;

+}

+

+Private Bool

+ThaiFltReplaceInput(Xic ic, unsigned char new_char, KeySym symbol)

+{

+    DefTreeBase *b = &ic->private.local.base;

+    if (!IC_DeletePreviousChar(ic)) return False;

+    b->wc[b->tree[ic->private.local.composed].wc+0] = tis2ucs(new_char);

+    b->wc[b->tree[ic->private.local.composed].wc+1] = '\0';

+

+    if ((new_char <= 0x1f) || (new_char == 0x7f))

+        b->tree[ic->private.local.composed].keysym = symbol;

+    else

+        b->tree[ic->private.local.composed].keysym = NoSymbol;

+

+    return True;

+}

+

+Private unsigned

+NumLockMask(Display *d)

+{

+    int i;

+    XModifierKeymap *map;

+    KeyCode numlock_keycode = XKeysymToKeycode (d, XK_Num_Lock);

+    if (numlock_keycode == NoSymbol)

+        return 0;

+

+    map = XGetModifierMapping (d);

+    if (!map)

+        return 0;

+

+    for (i = 0; i < 8; i++) {

+        if (map->modifiermap[map->max_keypermod * i] == numlock_keycode) {

+            XFreeModifiermap(map);

+            return 1 << i;

+        }

+    }

+    XFreeModifiermap(map);

+    return 0;

+}

+

+/*

+ * Filter function for TACTIS

+ */

+Bool

+_XimThaiFilter(Display *d, Window w, XEvent *ev, XPointer client_data)

+{

+    Xic		    ic = (Xic)client_data;

+    KeySym 	    symbol;

+    int 	    isc_mode; /* Thai Input Sequence Check mode */

+    unsigned char   previous_char; /* Last inputted Thai char */

+    unsigned char   new_char;

+#ifdef UNUSED

+    unsigned int    modifiers;

+    KeySym	    lsym,usym;

+    int		    state;

+    XicThaiPart     *thai_part;

+    char	    buf[10];

+#endif

+    wchar_t	    wbuf[10];

+    Bool            isReject;

+    DefTreeBase    *b = &ic->private.local.base;

+

+    if ((ev->type != KeyPress)

+        || (ev->xkey.keycode == 0))

+        return False;

+

+    if (!IC_IscMode(ic)) InitIscMode(ic);

+

+    XwcLookupString((XIC)ic, &ev->xkey, wbuf, sizeof(wbuf) / sizeof(wbuf[0]),

+		    &symbol, NULL);

+

+    if ((ev->xkey.state & (AllMods & ~(ShiftMask|LockMask|NumLockMask(d)))) ||

+         ((symbol >> 8 == 0xFF) &&

+         ((XK_BackSpace <= symbol && symbol <= XK_Clear) ||

+           (symbol == XK_Return) ||

+           (symbol == XK_Pause) ||

+           (symbol == XK_Scroll_Lock) ||

+           (symbol == XK_Sys_Req) ||

+           (symbol == XK_Escape) ||

+           (symbol == XK_Delete) ||

+           IsCursorKey(symbol) ||

+           IsKeypadKey(symbol) ||

+           IsMiscFunctionKey(symbol) ||

+           IsFunctionKey(symbol))))

+        {

+            IC_ClearPreviousChar(ic);

+            return False;

+        }

+    if (((symbol >> 8 == 0xFF) &&

+         IsModifierKey(symbol)) ||

+#ifdef XK_XKB_KEYS

+        ((symbol >> 8 == 0xFE) &&

+         (XK_ISO_Lock <= symbol && symbol <= XK_ISO_Last_Group_Lock)) ||

+#endif

+        (symbol == NoSymbol))

+    {

+        return False;

+    }

+#ifdef UNUSED

+    if (! XThaiTranslateKey(ev->xkey.display, ev->xkey.keycode, ev->xkey.state,

+	 		&modifiers, &symbol, &lsym, &usym))

+	return False;

+

+    /*

+     *  Hex input method processing

+     */

+

+    thai_part = &ic->private.local.thai;

+    state = thai_part->comp_state;

+    if (state >= 0 && state < nstate_handlers) /* call handler for state */

+    {

+        symbol = (* state_handler[state])(thai_part, symbol, (XKeyEvent *)ev);

+    }

+

+    /*

+     *  Translate KeySym into mb.

+     */

+    count = XThaiTranslateKeySym(ev->xkey.display, symbol, lsym,

+				usym, ev->xkey.state, buf, 10);

+

+    if (!symbol && !count)

+	return True;

+

+    /* Return symbol if cannot convert to character */

+    if (!count)

+	return False;

+#endif

+

+    /*

+     *  Thai Input sequence check

+     */

+    isc_mode = IC_IscMode(ic);

+    if (!(previous_char = IC_GetPreviousChar(ic))) previous_char = ' ';

+    new_char = ucs2tis(wbuf[0]);

+    isReject = True;

+    if (THAI_isaccepted(new_char, previous_char, isc_mode)) {

+        ThaiFltAcceptInput(ic, new_char, symbol);

+        isReject = False;

+    } else {

+        unsigned char context_char;

+

+        context_char = IC_GetContextChar(ic);

+        if (context_char) {

+            if (THAI_iscomposible(new_char, context_char)) {

+                if (THAI_iscomposible(previous_char, new_char)) {

+                    isReject = !ThaiFltReorderInput(ic, previous_char, new_char);

+                } else if (THAI_iscomposible(previous_char, context_char)) {

+                    isReject = !ThaiFltReplaceInput(ic, new_char, symbol);

+                } else if (THAI_chtype(previous_char) == FV1

+                           && THAI_chtype(new_char) == TONE) {

+                    isReject = !ThaiFltReorderInput(ic, previous_char, new_char);

+                }

+            } else if (THAI_isaccepted(new_char, context_char, isc_mode)) {

+                isReject = !ThaiFltReplaceInput(ic, new_char, symbol);

+            }

+        }

+    }

+    if (isReject) {

+        /* reject character */

+        XBell(ev->xkey.display, BellVolume);

+        return True;

+    }

+

+    _Xlcwcstombs(ic->core.im->core.lcd, &b->mb[b->tree[ic->private.local.composed].mb],

+		 &b->wc[b->tree[ic->private.local.composed].wc], 10);

+

+    _Xlcmbstoutf8(ic->core.im->core.lcd, &b->utf8[b->tree[ic->private.local.composed].utf8],

+		  &b->mb[b->tree[ic->private.local.composed].mb], 10);

+

+    /* Remember the last character inputted

+     * (as fallback in case StringConversionCallback is not provided)

+     */

+    IC_SavePreviousChar(ic, new_char);

+

+    ev->xkey.keycode = 0;

+    XPutBackEvent(d, ev);

+    return True;

+}

diff --git a/libX11/src/KeyBind.c b/libX11/src/KeyBind.c
index cc1906fad..6eb84328c 100644
--- a/libX11/src/KeyBind.c
+++ b/libX11/src/KeyBind.c
@@ -996,7 +996,7 @@ XRebindKeysym (
     tmp = dpy->key_bindings;

     nb = sizeof(KeySym) * nm;

 

-    if ((! (p = (struct _XKeytrans *) Xmalloc( sizeof(struct _XKeytrans)))) ||

+    if ((! (p = (struct _XKeytrans *) Xcalloc( 1, sizeof(struct _XKeytrans)))) ||

 	((! (p->string = (char *) Xmalloc( (unsigned) nbytes))) &&

 	 (nbytes > 0)) ||

 	((! (p->modifiers = (KeySym *) Xmalloc( (unsigned) nb))) &&

diff --git a/libX11/src/xkb/XKBGAlloc.c b/libX11/src/xkb/XKBGAlloc.c
index 4cd40016b..832d28530 100644
--- a/libX11/src/xkb/XKBGAlloc.c
+++ b/libX11/src/xkb/XKBGAlloc.c
@@ -696,11 +696,11 @@ register XkbPropertyPtr prop;
     }

     prop= &geom->properties[geom->num_properties];

     prop->name= (char *)_XkbAlloc(strlen(name)+1);

-    if (!name)

+    if (!prop->name)

 	return NULL;

     strcpy(prop->name,name);

     prop->value= (char *)_XkbAlloc(strlen(value)+1);

-    if (!value) {

+    if (!prop->value) {

 	_XkbFree(prop->name);

 	prop->name= NULL;

 	return NULL;

diff --git a/mesalib/src/glsl/builtin_variables.h b/mesalib/src/glsl/builtin_variables.h
index a34c67e34..f3531a370 100644
--- a/mesalib/src/glsl/builtin_variables.h
+++ b/mesalib/src/glsl/builtin_variables.h
@@ -1,105 +1,110 @@
-/*
- * Copyright © 2010 Intel Corporation
- *
- * 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 (including the next
- * paragraph) 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
- * THE AUTHORS OR COPYRIGHT HOLDERS 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.
- */
-
-#include "main/core.h" /* for slot numbers */
-
-struct builtin_variable {
-   enum ir_variable_mode mode;
-   int slot;
-   const char *type;
-   const char *name;
-};
-
-static const builtin_variable builtin_core_vs_variables[] = {
-   { ir_var_out, VERT_RESULT_HPOS, "vec4",  "gl_Position" },
-   { ir_var_out, VERT_RESULT_PSIZ, "float", "gl_PointSize" },
-};
-
-static const builtin_variable builtin_core_fs_variables[] = {
-   { ir_var_in,  FRAG_ATTRIB_WPOS,  "vec4",  "gl_FragCoord" },
-   { ir_var_in,  FRAG_ATTRIB_FACE,  "bool",  "gl_FrontFacing" },
-   { ir_var_out, FRAG_RESULT_COLOR, "vec4",  "gl_FragColor" },
-};
-
-static const builtin_variable builtin_100ES_fs_variables[] = {
-   { ir_var_in,  FRAG_ATTRIB_PNTC,   "vec2",   "gl_PointCoord" },
-};
-
-static const builtin_variable builtin_110_fs_variables[] = {
-   { ir_var_out, FRAG_RESULT_DEPTH, "float", "gl_FragDepth" },
-};
-
-static const builtin_variable builtin_110_deprecated_fs_variables[] = {
-   { ir_var_in,  FRAG_ATTRIB_COL0,  "vec4",  "gl_Color" },
-   { ir_var_in,  FRAG_ATTRIB_COL1,  "vec4",  "gl_SecondaryColor" },
-   { ir_var_in,  FRAG_ATTRIB_FOGC,  "float", "gl_FogFragCoord" },
-};
-
-static const builtin_variable builtin_110_deprecated_vs_variables[] = {
-   { ir_var_in,  VERT_ATTRIB_POS,    "vec4",  "gl_Vertex" },
-   { ir_var_in,  VERT_ATTRIB_NORMAL, "vec3",  "gl_Normal" },
-   { ir_var_in,  VERT_ATTRIB_COLOR0, "vec4",  "gl_Color" },
-   { ir_var_in,  VERT_ATTRIB_COLOR1, "vec4",  "gl_SecondaryColor" },
-   { ir_var_in,  VERT_ATTRIB_TEX0,   "vec4",  "gl_MultiTexCoord0" },
-   { ir_var_in,  VERT_ATTRIB_TEX1,   "vec4",  "gl_MultiTexCoord1" },
-   { ir_var_in,  VERT_ATTRIB_TEX2,   "vec4",  "gl_MultiTexCoord2" },
-   { ir_var_in,  VERT_ATTRIB_TEX3,   "vec4",  "gl_MultiTexCoord3" },
-   { ir_var_in,  VERT_ATTRIB_TEX4,   "vec4",  "gl_MultiTexCoord4" },
-   { ir_var_in,  VERT_ATTRIB_TEX5,   "vec4",  "gl_MultiTexCoord5" },
-   { ir_var_in,  VERT_ATTRIB_TEX6,   "vec4",  "gl_MultiTexCoord6" },
-   { ir_var_in,  VERT_ATTRIB_TEX7,   "vec4",  "gl_MultiTexCoord7" },
-   { ir_var_in,  VERT_ATTRIB_FOG,    "float", "gl_FogCoord" },
-   { ir_var_out, VERT_RESULT_HPOS,   "vec4",  "gl_ClipVertex" },
-   { ir_var_out, VERT_RESULT_COL0,   "vec4",  "gl_FrontColor" },
-   { ir_var_out, VERT_RESULT_BFC0,   "vec4",  "gl_BackColor" },
-   { ir_var_out, VERT_RESULT_COL1,   "vec4",  "gl_FrontSecondaryColor" },
-   { ir_var_out, VERT_RESULT_BFC1,   "vec4",  "gl_BackSecondaryColor" },
-   { ir_var_out, VERT_RESULT_FOGC,   "float", "gl_FogFragCoord" },
-};
-
-static const builtin_variable builtin_120_fs_variables[] = {
-   { ir_var_in,  FRAG_ATTRIB_PNTC,   "vec2",   "gl_PointCoord" },
-};
-
-static const builtin_variable builtin_130_vs_variables[] = {
-   { ir_var_in,  -1,                 "int",   "gl_VertexID" },
-};
-
-static const builtin_variable builtin_110_deprecated_uniforms[] = {
-   { ir_var_uniform, -1, "mat4", "gl_ModelViewMatrix" },
-   { ir_var_uniform, -1, "mat4", "gl_ProjectionMatrix" },
-   { ir_var_uniform, -1, "mat4", "gl_ModelViewProjectionMatrix" },
-   { ir_var_uniform, -1, "mat3", "gl_NormalMatrix" },
-   { ir_var_uniform, -1, "mat4", "gl_ModelViewMatrixInverse" },
-   { ir_var_uniform, -1, "mat4", "gl_ProjectionMatrixInverse" },
-   { ir_var_uniform, -1, "mat4", "gl_ModelViewProjectionMatrixInverse" },
-   { ir_var_uniform, -1, "mat4", "gl_ModelViewMatrixTranspose" },
-   { ir_var_uniform, -1, "mat4", "gl_ProjectionMatrixTranspose" },
-   { ir_var_uniform, -1, "mat4", "gl_ModelViewProjectionMatrixTranspose" },
-   { ir_var_uniform, -1, "mat4", "gl_ModelViewMatrixInverseTranspose" },
-   { ir_var_uniform, -1, "mat4", "gl_ProjectionMatrixInverseTranspose" },
-   { ir_var_uniform, -1, "mat4", "gl_ModelViewProjectionMatrixInverseTranspose" },
-   { ir_var_uniform, -1, "float", "gl_NormalScale" },
-   { ir_var_uniform, -1, "gl_LightModelParameters", "gl_LightModel"},
-};
-
+/*

+ * Copyright © 2010 Intel Corporation

+ *

+ * 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 (including the next

+ * paragraph) 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

+ * THE AUTHORS OR COPYRIGHT HOLDERS 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.

+ */

+

+#include "main/core.h" /* for slot numbers */

+

+struct builtin_variable {

+   enum ir_variable_mode mode;

+   int slot;

+   const char *type;

+   const char *name;

+};

+

+static const builtin_variable builtin_core_vs_variables[] = {

+   { ir_var_out, VERT_RESULT_HPOS, "vec4",  "gl_Position" },

+   { ir_var_out, VERT_RESULT_PSIZ, "float", "gl_PointSize" },

+};

+

+static const builtin_variable builtin_core_fs_variables[] = {

+   { ir_var_in,  FRAG_ATTRIB_WPOS,  "vec4",  "gl_FragCoord" },

+   { ir_var_in,  FRAG_ATTRIB_FACE,  "bool",  "gl_FrontFacing" },

+   { ir_var_out, FRAG_RESULT_COLOR, "vec4",  "gl_FragColor" },

+};

+

+static const builtin_variable builtin_100ES_fs_variables[] = {

+   { ir_var_in,  FRAG_ATTRIB_PNTC,   "vec2",   "gl_PointCoord" },

+};

+

+static const builtin_variable builtin_110_fs_variables[] = {

+   { ir_var_out, FRAG_RESULT_DEPTH, "float", "gl_FragDepth" },

+};

+

+static const builtin_variable builtin_110_deprecated_fs_variables[] = {

+   { ir_var_in,  FRAG_ATTRIB_COL0,  "vec4",  "gl_Color" },

+   { ir_var_in,  FRAG_ATTRIB_COL1,  "vec4",  "gl_SecondaryColor" },

+   { ir_var_in,  FRAG_ATTRIB_FOGC,  "float", "gl_FogFragCoord" },

+};

+

+static const builtin_variable builtin_110_deprecated_vs_variables[] = {

+   { ir_var_in,  VERT_ATTRIB_POS,    "vec4",  "gl_Vertex" },

+   { ir_var_in,  VERT_ATTRIB_NORMAL, "vec3",  "gl_Normal" },

+   { ir_var_in,  VERT_ATTRIB_COLOR0, "vec4",  "gl_Color" },

+   { ir_var_in,  VERT_ATTRIB_COLOR1, "vec4",  "gl_SecondaryColor" },

+   { ir_var_in,  VERT_ATTRIB_TEX0,   "vec4",  "gl_MultiTexCoord0" },

+   { ir_var_in,  VERT_ATTRIB_TEX1,   "vec4",  "gl_MultiTexCoord1" },

+   { ir_var_in,  VERT_ATTRIB_TEX2,   "vec4",  "gl_MultiTexCoord2" },

+   { ir_var_in,  VERT_ATTRIB_TEX3,   "vec4",  "gl_MultiTexCoord3" },

+   { ir_var_in,  VERT_ATTRIB_TEX4,   "vec4",  "gl_MultiTexCoord4" },

+   { ir_var_in,  VERT_ATTRIB_TEX5,   "vec4",  "gl_MultiTexCoord5" },

+   { ir_var_in,  VERT_ATTRIB_TEX6,   "vec4",  "gl_MultiTexCoord6" },

+   { ir_var_in,  VERT_ATTRIB_TEX7,   "vec4",  "gl_MultiTexCoord7" },

+   { ir_var_in,  VERT_ATTRIB_FOG,    "float", "gl_FogCoord" },

+   { ir_var_out, VERT_RESULT_HPOS,   "vec4",  "gl_ClipVertex" },

+   { ir_var_out, VERT_RESULT_COL0,   "vec4",  "gl_FrontColor" },

+   { ir_var_out, VERT_RESULT_BFC0,   "vec4",  "gl_BackColor" },

+   { ir_var_out, VERT_RESULT_COL1,   "vec4",  "gl_FrontSecondaryColor" },

+   { ir_var_out, VERT_RESULT_BFC1,   "vec4",  "gl_BackSecondaryColor" },

+   { ir_var_out, VERT_RESULT_FOGC,   "float", "gl_FogFragCoord" },

+};

+

+static const builtin_variable builtin_120_fs_variables[] = {

+   { ir_var_in,  FRAG_ATTRIB_PNTC,   "vec2",   "gl_PointCoord" },

+};

+

+static const builtin_variable builtin_130_vs_variables[] = {

+   { ir_var_in,  -1,                 "int",   "gl_VertexID" },

+};

+

+static const builtin_variable builtin_110_deprecated_uniforms[] = {

+   { ir_var_uniform, -1, "mat4", "gl_ModelViewMatrix" },

+   { ir_var_uniform, -1, "mat4", "gl_ProjectionMatrix" },

+   { ir_var_uniform, -1, "mat4", "gl_ModelViewProjectionMatrix" },

+   { ir_var_uniform, -1, "mat3", "gl_NormalMatrix" },

+   { ir_var_uniform, -1, "mat4", "gl_ModelViewMatrixInverse" },

+   { ir_var_uniform, -1, "mat4", "gl_ProjectionMatrixInverse" },

+   { ir_var_uniform, -1, "mat4", "gl_ModelViewProjectionMatrixInverse" },

+   { ir_var_uniform, -1, "mat4", "gl_ModelViewMatrixTranspose" },

+   { ir_var_uniform, -1, "mat4", "gl_ProjectionMatrixTranspose" },

+   { ir_var_uniform, -1, "mat4", "gl_ModelViewProjectionMatrixTranspose" },

+   { ir_var_uniform, -1, "mat4", "gl_ModelViewMatrixInverseTranspose" },

+   { ir_var_uniform, -1, "mat4", "gl_ProjectionMatrixInverseTranspose" },

+   { ir_var_uniform, -1, "mat4", "gl_ModelViewProjectionMatrixInverseTranspose" },

+   { ir_var_uniform, -1, "float", "gl_NormalScale" },

+   { ir_var_uniform, -1, "gl_LightModelParameters", "gl_LightModel"},

+

+   /* Mesa-internal ATI_envmap_bumpmap state. */

+   { ir_var_uniform, -1, "vec2", "gl_MESABumpRotMatrix0"},

+   { ir_var_uniform, -1, "vec2", "gl_MESABumpRotMatrix1"},

+   { ir_var_uniform, -1, "vec4", "gl_MESAFogParamsOptimized"},

+};

+

diff --git a/mesalib/src/glsl/ir_validate.cpp b/mesalib/src/glsl/ir_validate.cpp
index b2ae08f37..fe6ef8145 100644
--- a/mesalib/src/glsl/ir_validate.cpp
+++ b/mesalib/src/glsl/ir_validate.cpp
@@ -1,562 +1,562 @@
-/*
- * Copyright © 2010 Intel Corporation
- *
- * 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 (including the next
- * paragraph) 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
- * THE AUTHORS OR COPYRIGHT HOLDERS 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 ir_validate.cpp
- *
- * Attempts to verify that various invariants of the IR tree are true.
- *
- * In particular, at the moment it makes sure that no single
- * ir_instruction node except for ir_variable appears multiple times
- * in the ir tree.  ir_variable does appear multiple times: Once as a
- * declaration in an exec_list, and multiple times as the endpoint of
- * a dereference chain.
- */
-
-#include <inttypes.h>
-#include "ir.h"
-#include "ir_hierarchical_visitor.h"
-#include "program/hash_table.h"
-#include "glsl_types.h"
-
-class ir_validate : public ir_hierarchical_visitor {
-public:
-   ir_validate()
-   {
-      this->ht = hash_table_ctor(0, hash_table_pointer_hash,
-				 hash_table_pointer_compare);
-
-      this->current_function = NULL;
-
-      this->callback = ir_validate::validate_ir;
-      this->data = ht;
-   }
-
-   ~ir_validate()
-   {
-      hash_table_dtor(this->ht);
-   }
-
-   virtual ir_visitor_status visit(ir_variable *v);
-   virtual ir_visitor_status visit(ir_dereference_variable *ir);
-   virtual ir_visitor_status visit(ir_if *ir);
-
-   virtual ir_visitor_status visit_leave(ir_loop *ir);
-   virtual ir_visitor_status visit_enter(ir_function *ir);
-   virtual ir_visitor_status visit_leave(ir_function *ir);
-   virtual ir_visitor_status visit_enter(ir_function_signature *ir);
-
-   virtual ir_visitor_status visit_leave(ir_expression *ir);
-   virtual ir_visitor_status visit_leave(ir_swizzle *ir);
-
-   virtual ir_visitor_status visit_enter(ir_assignment *ir);
-   virtual ir_visitor_status visit_enter(ir_call *ir);
-
-   static void validate_ir(ir_instruction *ir, void *data);
-
-   ir_function *current_function;
-
-   struct hash_table *ht;
-};
-
-
-ir_visitor_status
-ir_validate::visit(ir_dereference_variable *ir)
-{
-   if ((ir->var == NULL) || (ir->var->as_variable() == NULL)) {
-      printf("ir_dereference_variable @ %p does not specify a variable %p\n",
-	     (void *) ir, (void *) ir->var);
-      abort();
-   }
-
-   if (hash_table_find(ht, ir->var) == NULL) {
-      printf("ir_dereference_variable @ %p specifies undeclared variable "
-	     "`%s' @ %p\n",
-	     (void *) ir, ir->var->name, (void *) ir->var);
-      abort();
-   }
-
-   this->validate_ir(ir, this->data);
-
-   return visit_continue;
-}
-
-ir_visitor_status
-ir_validate::visit(ir_if *ir)
-{
-   if (ir->condition->type != glsl_type::bool_type) {
-      printf("ir_if condition %s type instead of bool.\n",
-	     ir->condition->type->name);
-      ir->print();
-      printf("\n");
-      abort();
-   }
-
-   return visit_continue;
-}
-
-
-ir_visitor_status
-ir_validate::visit_leave(ir_loop *ir)
-{
-   if (ir->counter != NULL) {
-      if ((ir->from == NULL) || (ir->from == NULL) || (ir->increment == NULL)) {
-	 printf("ir_loop has invalid loop controls:\n"
-		"    counter:   %p\n"
-		"    from:      %p\n"
-		"    to:        %p\n"
-		"    increment: %p\n",
-		(void *) ir->counter, (void *) ir->from, (void *) ir->to,
-                (void *) ir->increment);
-	 abort();
-      }
-
-      if ((ir->cmp < ir_binop_less) || (ir->cmp > ir_binop_nequal)) {
-	 printf("ir_loop has invalid comparitor %d\n", ir->cmp);
-	 abort();
-      }
-   } else {
-      if ((ir->from != NULL) || (ir->from != NULL) || (ir->increment != NULL)) {
-	 printf("ir_loop has invalid loop controls:\n"
-		"    counter:   %p\n"
-		"    from:      %p\n"
-		"    to:        %p\n"
-		"    increment: %p\n",
-		(void *) ir->counter, (void *) ir->from, (void *) ir->to,
-                (void *) ir->increment);
-	 abort();
-      }
-   }
-
-   return visit_continue;
-}
-
-
-ir_visitor_status
-ir_validate::visit_enter(ir_function *ir)
-{
-   /* Function definitions cannot be nested.
-    */
-   if (this->current_function != NULL) {
-      printf("Function definition nested inside another function "
-	     "definition:\n");
-      printf("%s %p inside %s %p\n",
-	     ir->name, (void *) ir,
-	     this->current_function->name, (void *) this->current_function);
-      abort();
-   }
-
-   /* Store the current function hierarchy being traversed.  This is used
-    * by the function signature visitor to ensure that the signatures are
-    * linked with the correct functions.
-    */
-   this->current_function = ir;
-
-   this->validate_ir(ir, this->data);
-
-   /* Verify that all of the things stored in the list of signatures are,
-    * in fact, function signatures.
-    */
-   foreach_list(node, &ir->signatures) {
-      ir_instruction *sig = (ir_instruction *) node;
-
-      if (sig->ir_type != ir_type_function_signature) {
-	 printf("Non-signature in signature list of function `%s'\n",
-		ir->name);
-	 abort();
-      }
-   }
-
-   return visit_continue;
-}
-
-ir_visitor_status
-ir_validate::visit_leave(ir_function *ir)
-{
-   assert(ralloc_parent(ir->name) == ir);
-
-   this->current_function = NULL;
-   return visit_continue;
-}
-
-ir_visitor_status
-ir_validate::visit_enter(ir_function_signature *ir)
-{
-   if (this->current_function != ir->function()) {
-      printf("Function signature nested inside wrong function "
-	     "definition:\n");
-      printf("%p inside %s %p instead of %s %p\n",
-	     (void *) ir,
-	     this->current_function->name, (void *) this->current_function,
-	     ir->function_name(), (void *) ir->function());
-      abort();
-   }
-
-   if (ir->return_type == NULL) {
-      printf("Function signature %p for function %s has NULL return type.\n",
-	     ir, ir->function_name());
-      abort();
-   }
-
-   this->validate_ir(ir, this->data);
-
-   return visit_continue;
-}
-
-ir_visitor_status
-ir_validate::visit_leave(ir_expression *ir)
-{
-   switch (ir->operation) {
-   case ir_unop_bit_not:
-      assert(ir->operands[0]->type == ir->type);
-      break;
-   case ir_unop_logic_not:
-      assert(ir->type->base_type == GLSL_TYPE_BOOL);
-      assert(ir->operands[0]->type->base_type == GLSL_TYPE_BOOL);
-      break;
-
-   case ir_unop_neg:
-   case ir_unop_abs:
-   case ir_unop_sign:
-   case ir_unop_rcp:
-   case ir_unop_rsq:
-   case ir_unop_sqrt:
-      assert(ir->type == ir->operands[0]->type);
-      break;
-
-   case ir_unop_exp:
-   case ir_unop_log:
-   case ir_unop_exp2:
-   case ir_unop_log2:
-      assert(ir->operands[0]->type->base_type == GLSL_TYPE_FLOAT);
-      assert(ir->type == ir->operands[0]->type);
-      break;
-
-   case ir_unop_f2i:
-      assert(ir->operands[0]->type->base_type == GLSL_TYPE_FLOAT);
-      assert(ir->type->base_type == GLSL_TYPE_INT);
-      break;
-   case ir_unop_i2f:
-      assert(ir->operands[0]->type->base_type == GLSL_TYPE_INT);
-      assert(ir->type->base_type == GLSL_TYPE_FLOAT);
-      break;
-   case ir_unop_f2b:
-      assert(ir->operands[0]->type->base_type == GLSL_TYPE_FLOAT);
-      assert(ir->type->base_type == GLSL_TYPE_BOOL);
-      break;
-   case ir_unop_b2f:
-      assert(ir->operands[0]->type->base_type == GLSL_TYPE_BOOL);
-      assert(ir->type->base_type == GLSL_TYPE_FLOAT);
-      break;
-   case ir_unop_i2b:
-      assert(ir->operands[0]->type->base_type == GLSL_TYPE_INT);
-      assert(ir->type->base_type == GLSL_TYPE_BOOL);
-      break;
-   case ir_unop_b2i:
-      assert(ir->operands[0]->type->base_type == GLSL_TYPE_BOOL);
-      assert(ir->type->base_type == GLSL_TYPE_INT);
-      break;
-   case ir_unop_u2f:
-      assert(ir->operands[0]->type->base_type == GLSL_TYPE_UINT);
-      assert(ir->type->base_type == GLSL_TYPE_FLOAT);
-      break;
-
-   case ir_unop_any:
-      assert(ir->operands[0]->type->base_type == GLSL_TYPE_BOOL);
-      assert(ir->type == glsl_type::bool_type);
-      break;
-
-   case ir_unop_trunc:
-   case ir_unop_round_even:
-   case ir_unop_ceil:
-   case ir_unop_floor:
-   case ir_unop_fract:
-   case ir_unop_sin:
-   case ir_unop_cos:
-   case ir_unop_sin_reduced:
-   case ir_unop_cos_reduced:
-   case ir_unop_dFdx:
-   case ir_unop_dFdy:
-      assert(ir->operands[0]->type->base_type == GLSL_TYPE_FLOAT);
-      assert(ir->operands[0]->type == ir->type);
-      break;
-
-   case ir_unop_noise:
-      /* XXX what can we assert here? */
-      break;
-
-   case ir_binop_add:
-   case ir_binop_sub:
-   case ir_binop_mul:
-   case ir_binop_div:
-   case ir_binop_mod:
-   case ir_binop_min:
-   case ir_binop_max:
-   case ir_binop_pow:
-      if (ir->operands[0]->type->is_scalar())
-	 assert(ir->operands[1]->type == ir->type);
-      else if (ir->operands[1]->type->is_scalar())
-	 assert(ir->operands[0]->type == ir->type);
-      else if (ir->operands[0]->type->is_vector() &&
-	       ir->operands[1]->type->is_vector()) {
-	 assert(ir->operands[0]->type == ir->operands[1]->type);
-	 assert(ir->operands[0]->type == ir->type);
-      }
-      break;
-
-   case ir_binop_less:
-   case ir_binop_greater:
-   case ir_binop_lequal:
-   case ir_binop_gequal:
-   case ir_binop_equal:
-   case ir_binop_nequal:
-      /* The semantics of the IR operators differ from the GLSL <, >, <=, >=,
-       * ==, and != operators.  The IR operators perform a component-wise
-       * comparison on scalar or vector types and return a boolean scalar or
-       * vector type of the same size.
-       */
-      assert(ir->type->base_type == GLSL_TYPE_BOOL);
-      assert(ir->operands[0]->type == ir->operands[1]->type);
-      assert(ir->operands[0]->type->is_vector()
-	     || ir->operands[0]->type->is_scalar());
-      assert(ir->operands[0]->type->vector_elements
-	     == ir->type->vector_elements);
-      break;
-
-   case ir_binop_all_equal:
-   case ir_binop_any_nequal:
-      /* GLSL == and != operate on scalars, vectors, matrices and arrays, and
-       * return a scalar boolean.  The IR matches that.
-       */
-      assert(ir->type == glsl_type::bool_type);
-      assert(ir->operands[0]->type == ir->operands[1]->type);
-      break;
-
-   case ir_binop_lshift:
-   case ir_binop_rshift:
-      assert(ir->operands[0]->type->is_integer() &&
-             ir->operands[1]->type->is_integer());
-      if (ir->operands[0]->type->is_scalar()) {
-          assert(ir->operands[1]->type->is_scalar());
-      }
-      if (ir->operands[0]->type->is_vector() &&
-          ir->operands[1]->type->is_vector()) {
-          assert(ir->operands[0]->type->components() ==
-                 ir->operands[1]->type->components());
-      }
-      assert(ir->type == ir->operands[0]->type);
-      break;
-
-   case ir_binop_bit_and:
-   case ir_binop_bit_xor:
-   case ir_binop_bit_or:
-       assert(ir->operands[0]->type->base_type ==
-              ir->operands[1]->type->base_type);
-       assert(ir->type->is_integer());
-       if (ir->operands[0]->type->is_vector() &&
-           ir->operands[1]->type->is_vector()) {
-           assert(ir->operands[0]->type->vector_elements ==
-                  ir->operands[1]->type->vector_elements);
-       }
-       break;
-
-   case ir_binop_logic_and:
-   case ir_binop_logic_xor:
-   case ir_binop_logic_or:
-      assert(ir->type == glsl_type::bool_type);
-      assert(ir->operands[0]->type == glsl_type::bool_type);
-      assert(ir->operands[1]->type == glsl_type::bool_type);
-      break;
-
-   case ir_binop_dot:
-      assert(ir->type == glsl_type::float_type);
-      assert(ir->operands[0]->type->base_type == GLSL_TYPE_FLOAT);
-      assert(ir->operands[0]->type->is_vector());
-      assert(ir->operands[0]->type == ir->operands[1]->type);
-      break;
-
-   case ir_quadop_vector:
-      /* The vector operator collects some number of scalars and generates a
-       * vector from them.
-       *
-       *  - All of the operands must be scalar.
-       *  - Number of operands must matche the size of the resulting vector.
-       *  - Base type of the operands must match the base type of the result.
-       */
-      assert(ir->type->is_vector());
-      switch (ir->type->vector_elements) {
-      case 2:
-	 assert(ir->operands[0]->type->is_scalar());
-	 assert(ir->operands[0]->type->base_type == ir->type->base_type);
-	 assert(ir->operands[1]->type->is_scalar());
-	 assert(ir->operands[1]->type->base_type == ir->type->base_type);
-	 assert(ir->operands[2] == NULL);
-	 assert(ir->operands[3] == NULL);
-	 break;
-      case 3:
-	 assert(ir->operands[0]->type->is_scalar());
-	 assert(ir->operands[0]->type->base_type == ir->type->base_type);
-	 assert(ir->operands[1]->type->is_scalar());
-	 assert(ir->operands[1]->type->base_type == ir->type->base_type);
-	 assert(ir->operands[2]->type->is_scalar());
-	 assert(ir->operands[2]->type->base_type == ir->type->base_type);
-	 assert(ir->operands[3] == NULL);
-	 break;
-      case 4:
-	 assert(ir->operands[0]->type->is_scalar());
-	 assert(ir->operands[0]->type->base_type == ir->type->base_type);
-	 assert(ir->operands[1]->type->is_scalar());
-	 assert(ir->operands[1]->type->base_type == ir->type->base_type);
-	 assert(ir->operands[2]->type->is_scalar());
-	 assert(ir->operands[2]->type->base_type == ir->type->base_type);
-	 assert(ir->operands[3]->type->is_scalar());
-	 assert(ir->operands[3]->type->base_type == ir->type->base_type);
-	 break;
-      default:
-	 /* The is_vector assertion above should prevent execution from ever
-	  * getting here.
-	  */
-	 assert(!"Should not get here.");
-	 break;
-      }
-   }
-
-   return visit_continue;
-}
-
-ir_visitor_status
-ir_validate::visit_leave(ir_swizzle *ir)
-{
-   int chans[4] = {ir->mask.x, ir->mask.y, ir->mask.z, ir->mask.w};
-
-   for (unsigned int i = 0; i < ir->type->vector_elements; i++) {
-      if (chans[i] >= ir->val->type->vector_elements) {
-	 printf("ir_swizzle @ %p specifies a channel not present "
-		"in the value.\n", (void *) ir);
-	 ir->print();
-	 abort();
-      }
-   }
-
-   return visit_continue;
-}
-
-ir_visitor_status
-ir_validate::visit(ir_variable *ir)
-{
-   /* An ir_variable is the one thing that can (and will) appear multiple times
-    * in an IR tree.  It is added to the hashtable so that it can be used
-    * in the ir_dereference_variable handler to ensure that a variable is
-    * declared before it is dereferenced.
-    */
-   if (ir->name)
-      assert(ralloc_parent(ir->name) == ir);
-
-   hash_table_insert(ht, ir, ir);
-   return visit_continue;
-}
-
-ir_visitor_status
-ir_validate::visit_enter(ir_assignment *ir)
-{
-   const ir_dereference *const lhs = ir->lhs;
-   if (lhs->type->is_scalar() || lhs->type->is_vector()) {
-      if (ir->write_mask == 0) {
-	 printf("Assignment LHS is %s, but write mask is 0:\n",
-		lhs->type->is_scalar() ? "scalar" : "vector");
-	 ir->print();
-	 abort();
-      }
-
-      int lhs_components = 0;
-      for (int i = 0; i < 4; i++) {
-	 if (ir->write_mask & (1 << i))
-	    lhs_components++;
-      }
-
-      if (lhs_components != ir->rhs->type->vector_elements) {
-	 printf("Assignment count of LHS write mask channels enabled not\n"
-		"matching RHS vector size (%d LHS, %d RHS).\n",
-		lhs_components, ir->rhs->type->vector_elements);
-	 ir->print();
-	 abort();
-      }
-   }
-
-   this->validate_ir(ir, this->data);
-
-   return visit_continue;
-}
-
-ir_visitor_status
-ir_validate::visit_enter(ir_call *ir)
-{
-   ir_function_signature *const callee = ir->get_callee();
-
-   if (callee->ir_type != ir_type_function_signature) {
-      printf("IR called by ir_call is not ir_function_signature!\n");
-      abort();
-   }
-
-   return visit_continue;
-}
-
-void
-ir_validate::validate_ir(ir_instruction *ir, void *data)
-{
-   struct hash_table *ht = (struct hash_table *) data;
-
-   if (hash_table_find(ht, ir)) {
-      printf("Instruction node present twice in ir tree:\n");
-      ir->print();
-      printf("\n");
-      abort();
-   }
-   hash_table_insert(ht, ir, ir);
-}
-
-void
-check_node_type(ir_instruction *ir, void *data)
-{
-   (void) data;
-
-   if (ir->ir_type <= ir_type_unset || ir->ir_type >= ir_type_max) {
-      printf("Instruction node with unset type\n");
-      ir->print(); printf("\n");
-   }
-   assert(ir->type != glsl_type::error_type);
-}
-
-void
-validate_ir_tree(exec_list *instructions)
-{
-   ir_validate v;
-
-   v.run(instructions);
-
-   foreach_iter(exec_list_iterator, iter, *instructions) {
-      ir_instruction *ir = (ir_instruction *)iter.get();
-
-      visit_tree(ir, check_node_type, NULL);
-   }
-}
+/*

+ * Copyright © 2010 Intel Corporation

+ *

+ * 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 (including the next

+ * paragraph) 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

+ * THE AUTHORS OR COPYRIGHT HOLDERS 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 ir_validate.cpp

+ *

+ * Attempts to verify that various invariants of the IR tree are true.

+ *

+ * In particular, at the moment it makes sure that no single

+ * ir_instruction node except for ir_variable appears multiple times

+ * in the ir tree.  ir_variable does appear multiple times: Once as a

+ * declaration in an exec_list, and multiple times as the endpoint of

+ * a dereference chain.

+ */

+

+#include <inttypes.h>

+#include "ir.h"

+#include "ir_hierarchical_visitor.h"

+#include "program/hash_table.h"

+#include "glsl_types.h"

+

+class ir_validate : public ir_hierarchical_visitor {

+public:

+   ir_validate()

+   {

+      this->ht = hash_table_ctor(0, hash_table_pointer_hash,

+				 hash_table_pointer_compare);

+

+      this->current_function = NULL;

+

+      this->callback = ir_validate::validate_ir;

+      this->data = ht;

+   }

+

+   ~ir_validate()

+   {

+      hash_table_dtor(this->ht);

+   }

+

+   virtual ir_visitor_status visit(ir_variable *v);

+   virtual ir_visitor_status visit(ir_dereference_variable *ir);

+   virtual ir_visitor_status visit(ir_if *ir);

+

+   virtual ir_visitor_status visit_leave(ir_loop *ir);

+   virtual ir_visitor_status visit_enter(ir_function *ir);

+   virtual ir_visitor_status visit_leave(ir_function *ir);

+   virtual ir_visitor_status visit_enter(ir_function_signature *ir);

+

+   virtual ir_visitor_status visit_leave(ir_expression *ir);

+   virtual ir_visitor_status visit_leave(ir_swizzle *ir);

+

+   virtual ir_visitor_status visit_enter(ir_assignment *ir);

+   virtual ir_visitor_status visit_enter(ir_call *ir);

+

+   static void validate_ir(ir_instruction *ir, void *data);

+

+   ir_function *current_function;

+

+   struct hash_table *ht;

+};

+

+

+ir_visitor_status

+ir_validate::visit(ir_dereference_variable *ir)

+{

+   if ((ir->var == NULL) || (ir->var->as_variable() == NULL)) {

+      printf("ir_dereference_variable @ %p does not specify a variable %p\n",

+	     (void *) ir, (void *) ir->var);

+      abort();

+   }

+

+   if (hash_table_find(ht, ir->var) == NULL) {

+      printf("ir_dereference_variable @ %p specifies undeclared variable "

+	     "`%s' @ %p\n",

+	     (void *) ir, ir->var->name, (void *) ir->var);

+      abort();

+   }

+

+   this->validate_ir(ir, this->data);

+

+   return visit_continue;

+}

+

+ir_visitor_status

+ir_validate::visit(ir_if *ir)

+{

+   if (ir->condition->type != glsl_type::bool_type) {

+      printf("ir_if condition %s type instead of bool.\n",

+	     ir->condition->type->name);

+      ir->print();

+      printf("\n");

+      abort();

+   }

+

+   return visit_continue;

+}

+

+

+ir_visitor_status

+ir_validate::visit_leave(ir_loop *ir)

+{

+   if (ir->counter != NULL) {

+      if ((ir->from == NULL) || (ir->from == NULL) || (ir->increment == NULL)) {

+	 printf("ir_loop has invalid loop controls:\n"

+		"    counter:   %p\n"

+		"    from:      %p\n"

+		"    to:        %p\n"

+		"    increment: %p\n",

+		(void *) ir->counter, (void *) ir->from, (void *) ir->to,

+                (void *) ir->increment);

+	 abort();

+      }

+

+      if ((ir->cmp < ir_binop_less) || (ir->cmp > ir_binop_nequal)) {

+	 printf("ir_loop has invalid comparitor %d\n", ir->cmp);

+	 abort();

+      }

+   } else {

+      if ((ir->from != NULL) || (ir->from != NULL) || (ir->increment != NULL)) {

+	 printf("ir_loop has invalid loop controls:\n"

+		"    counter:   %p\n"

+		"    from:      %p\n"

+		"    to:        %p\n"

+		"    increment: %p\n",

+		(void *) ir->counter, (void *) ir->from, (void *) ir->to,

+                (void *) ir->increment);

+	 abort();

+      }

+   }

+

+   return visit_continue;

+}

+

+

+ir_visitor_status

+ir_validate::visit_enter(ir_function *ir)

+{

+   /* Function definitions cannot be nested.

+    */

+   if (this->current_function != NULL) {

+      printf("Function definition nested inside another function "

+	     "definition:\n");

+      printf("%s %p inside %s %p\n",

+	     ir->name, (void *) ir,

+	     this->current_function->name, (void *) this->current_function);

+      abort();

+   }

+

+   /* Store the current function hierarchy being traversed.  This is used

+    * by the function signature visitor to ensure that the signatures are

+    * linked with the correct functions.

+    */

+   this->current_function = ir;

+

+   this->validate_ir(ir, this->data);

+

+   /* Verify that all of the things stored in the list of signatures are,

+    * in fact, function signatures.

+    */

+   foreach_list(node, &ir->signatures) {

+      ir_instruction *sig = (ir_instruction *) node;

+

+      if (sig->ir_type != ir_type_function_signature) {

+	 printf("Non-signature in signature list of function `%s'\n",

+		ir->name);

+	 abort();

+      }

+   }

+

+   return visit_continue;

+}

+

+ir_visitor_status

+ir_validate::visit_leave(ir_function *ir)

+{

+   assert(ralloc_parent(ir->name) == ir);

+

+   this->current_function = NULL;

+   return visit_continue;

+}

+

+ir_visitor_status

+ir_validate::visit_enter(ir_function_signature *ir)

+{

+   if (this->current_function != ir->function()) {

+      printf("Function signature nested inside wrong function "

+	     "definition:\n");

+      printf("%p inside %s %p instead of %s %p\n",

+	     (void *) ir,

+	     this->current_function->name, (void *) this->current_function,

+	     ir->function_name(), (void *) ir->function());

+      abort();

+   }

+

+   if (ir->return_type == NULL) {

+      printf("Function signature %p for function %s has NULL return type.\n",

+	     (void *) ir, ir->function_name());

+      abort();

+   }

+

+   this->validate_ir(ir, this->data);

+

+   return visit_continue;

+}

+

+ir_visitor_status

+ir_validate::visit_leave(ir_expression *ir)

+{

+   switch (ir->operation) {

+   case ir_unop_bit_not:

+      assert(ir->operands[0]->type == ir->type);

+      break;

+   case ir_unop_logic_not:

+      assert(ir->type->base_type == GLSL_TYPE_BOOL);

+      assert(ir->operands[0]->type->base_type == GLSL_TYPE_BOOL);

+      break;

+

+   case ir_unop_neg:

+   case ir_unop_abs:

+   case ir_unop_sign:

+   case ir_unop_rcp:

+   case ir_unop_rsq:

+   case ir_unop_sqrt:

+      assert(ir->type == ir->operands[0]->type);

+      break;

+

+   case ir_unop_exp:

+   case ir_unop_log:

+   case ir_unop_exp2:

+   case ir_unop_log2:

+      assert(ir->operands[0]->type->base_type == GLSL_TYPE_FLOAT);

+      assert(ir->type == ir->operands[0]->type);

+      break;

+

+   case ir_unop_f2i:

+      assert(ir->operands[0]->type->base_type == GLSL_TYPE_FLOAT);

+      assert(ir->type->base_type == GLSL_TYPE_INT);

+      break;

+   case ir_unop_i2f:

+      assert(ir->operands[0]->type->base_type == GLSL_TYPE_INT);

+      assert(ir->type->base_type == GLSL_TYPE_FLOAT);

+      break;

+   case ir_unop_f2b:

+      assert(ir->operands[0]->type->base_type == GLSL_TYPE_FLOAT);

+      assert(ir->type->base_type == GLSL_TYPE_BOOL);

+      break;

+   case ir_unop_b2f:

+      assert(ir->operands[0]->type->base_type == GLSL_TYPE_BOOL);

+      assert(ir->type->base_type == GLSL_TYPE_FLOAT);

+      break;

+   case ir_unop_i2b:

+      assert(ir->operands[0]->type->base_type == GLSL_TYPE_INT);

+      assert(ir->type->base_type == GLSL_TYPE_BOOL);

+      break;

+   case ir_unop_b2i:

+      assert(ir->operands[0]->type->base_type == GLSL_TYPE_BOOL);

+      assert(ir->type->base_type == GLSL_TYPE_INT);

+      break;

+   case ir_unop_u2f:

+      assert(ir->operands[0]->type->base_type == GLSL_TYPE_UINT);

+      assert(ir->type->base_type == GLSL_TYPE_FLOAT);

+      break;

+

+   case ir_unop_any:

+      assert(ir->operands[0]->type->base_type == GLSL_TYPE_BOOL);

+      assert(ir->type == glsl_type::bool_type);

+      break;

+

+   case ir_unop_trunc:

+   case ir_unop_round_even:

+   case ir_unop_ceil:

+   case ir_unop_floor:

+   case ir_unop_fract:

+   case ir_unop_sin:

+   case ir_unop_cos:

+   case ir_unop_sin_reduced:

+   case ir_unop_cos_reduced:

+   case ir_unop_dFdx:

+   case ir_unop_dFdy:

+      assert(ir->operands[0]->type->base_type == GLSL_TYPE_FLOAT);

+      assert(ir->operands[0]->type == ir->type);

+      break;

+

+   case ir_unop_noise:

+      /* XXX what can we assert here? */

+      break;

+

+   case ir_binop_add:

+   case ir_binop_sub:

+   case ir_binop_mul:

+   case ir_binop_div:

+   case ir_binop_mod:

+   case ir_binop_min:

+   case ir_binop_max:

+   case ir_binop_pow:

+      if (ir->operands[0]->type->is_scalar())

+	 assert(ir->operands[1]->type == ir->type);

+      else if (ir->operands[1]->type->is_scalar())

+	 assert(ir->operands[0]->type == ir->type);

+      else if (ir->operands[0]->type->is_vector() &&

+	       ir->operands[1]->type->is_vector()) {

+	 assert(ir->operands[0]->type == ir->operands[1]->type);

+	 assert(ir->operands[0]->type == ir->type);

+      }

+      break;

+

+   case ir_binop_less:

+   case ir_binop_greater:

+   case ir_binop_lequal:

+   case ir_binop_gequal:

+   case ir_binop_equal:

+   case ir_binop_nequal:

+      /* The semantics of the IR operators differ from the GLSL <, >, <=, >=,

+       * ==, and != operators.  The IR operators perform a component-wise

+       * comparison on scalar or vector types and return a boolean scalar or

+       * vector type of the same size.

+       */

+      assert(ir->type->base_type == GLSL_TYPE_BOOL);

+      assert(ir->operands[0]->type == ir->operands[1]->type);

+      assert(ir->operands[0]->type->is_vector()

+	     || ir->operands[0]->type->is_scalar());

+      assert(ir->operands[0]->type->vector_elements

+	     == ir->type->vector_elements);

+      break;

+

+   case ir_binop_all_equal:

+   case ir_binop_any_nequal:

+      /* GLSL == and != operate on scalars, vectors, matrices and arrays, and

+       * return a scalar boolean.  The IR matches that.

+       */

+      assert(ir->type == glsl_type::bool_type);

+      assert(ir->operands[0]->type == ir->operands[1]->type);

+      break;

+

+   case ir_binop_lshift:

+   case ir_binop_rshift:

+      assert(ir->operands[0]->type->is_integer() &&

+             ir->operands[1]->type->is_integer());

+      if (ir->operands[0]->type->is_scalar()) {

+          assert(ir->operands[1]->type->is_scalar());

+      }

+      if (ir->operands[0]->type->is_vector() &&

+          ir->operands[1]->type->is_vector()) {

+          assert(ir->operands[0]->type->components() ==

+                 ir->operands[1]->type->components());

+      }

+      assert(ir->type == ir->operands[0]->type);

+      break;

+

+   case ir_binop_bit_and:

+   case ir_binop_bit_xor:

+   case ir_binop_bit_or:

+       assert(ir->operands[0]->type->base_type ==

+              ir->operands[1]->type->base_type);

+       assert(ir->type->is_integer());

+       if (ir->operands[0]->type->is_vector() &&

+           ir->operands[1]->type->is_vector()) {

+           assert(ir->operands[0]->type->vector_elements ==

+                  ir->operands[1]->type->vector_elements);

+       }

+       break;

+

+   case ir_binop_logic_and:

+   case ir_binop_logic_xor:

+   case ir_binop_logic_or:

+      assert(ir->type == glsl_type::bool_type);

+      assert(ir->operands[0]->type == glsl_type::bool_type);

+      assert(ir->operands[1]->type == glsl_type::bool_type);

+      break;

+

+   case ir_binop_dot:

+      assert(ir->type == glsl_type::float_type);

+      assert(ir->operands[0]->type->base_type == GLSL_TYPE_FLOAT);

+      assert(ir->operands[0]->type->is_vector());

+      assert(ir->operands[0]->type == ir->operands[1]->type);

+      break;

+

+   case ir_quadop_vector:

+      /* The vector operator collects some number of scalars and generates a

+       * vector from them.

+       *

+       *  - All of the operands must be scalar.

+       *  - Number of operands must matche the size of the resulting vector.

+       *  - Base type of the operands must match the base type of the result.

+       */

+      assert(ir->type->is_vector());

+      switch (ir->type->vector_elements) {

+      case 2:

+	 assert(ir->operands[0]->type->is_scalar());

+	 assert(ir->operands[0]->type->base_type == ir->type->base_type);

+	 assert(ir->operands[1]->type->is_scalar());

+	 assert(ir->operands[1]->type->base_type == ir->type->base_type);

+	 assert(ir->operands[2] == NULL);

+	 assert(ir->operands[3] == NULL);

+	 break;

+      case 3:

+	 assert(ir->operands[0]->type->is_scalar());

+	 assert(ir->operands[0]->type->base_type == ir->type->base_type);

+	 assert(ir->operands[1]->type->is_scalar());

+	 assert(ir->operands[1]->type->base_type == ir->type->base_type);

+	 assert(ir->operands[2]->type->is_scalar());

+	 assert(ir->operands[2]->type->base_type == ir->type->base_type);

+	 assert(ir->operands[3] == NULL);

+	 break;

+      case 4:

+	 assert(ir->operands[0]->type->is_scalar());

+	 assert(ir->operands[0]->type->base_type == ir->type->base_type);

+	 assert(ir->operands[1]->type->is_scalar());

+	 assert(ir->operands[1]->type->base_type == ir->type->base_type);

+	 assert(ir->operands[2]->type->is_scalar());

+	 assert(ir->operands[2]->type->base_type == ir->type->base_type);

+	 assert(ir->operands[3]->type->is_scalar());

+	 assert(ir->operands[3]->type->base_type == ir->type->base_type);

+	 break;

+      default:

+	 /* The is_vector assertion above should prevent execution from ever

+	  * getting here.

+	  */

+	 assert(!"Should not get here.");

+	 break;

+      }

+   }

+

+   return visit_continue;

+}

+

+ir_visitor_status

+ir_validate::visit_leave(ir_swizzle *ir)

+{

+   int chans[4] = {ir->mask.x, ir->mask.y, ir->mask.z, ir->mask.w};

+

+   for (unsigned int i = 0; i < ir->type->vector_elements; i++) {

+      if (chans[i] >= ir->val->type->vector_elements) {

+	 printf("ir_swizzle @ %p specifies a channel not present "

+		"in the value.\n", (void *) ir);

+	 ir->print();

+	 abort();

+      }

+   }

+

+   return visit_continue;

+}

+

+ir_visitor_status

+ir_validate::visit(ir_variable *ir)

+{

+   /* An ir_variable is the one thing that can (and will) appear multiple times

+    * in an IR tree.  It is added to the hashtable so that it can be used

+    * in the ir_dereference_variable handler to ensure that a variable is

+    * declared before it is dereferenced.

+    */

+   if (ir->name)

+      assert(ralloc_parent(ir->name) == ir);

+

+   hash_table_insert(ht, ir, ir);

+   return visit_continue;

+}

+

+ir_visitor_status

+ir_validate::visit_enter(ir_assignment *ir)

+{

+   const ir_dereference *const lhs = ir->lhs;

+   if (lhs->type->is_scalar() || lhs->type->is_vector()) {

+      if (ir->write_mask == 0) {

+	 printf("Assignment LHS is %s, but write mask is 0:\n",

+		lhs->type->is_scalar() ? "scalar" : "vector");

+	 ir->print();

+	 abort();

+      }

+

+      int lhs_components = 0;

+      for (int i = 0; i < 4; i++) {

+	 if (ir->write_mask & (1 << i))

+	    lhs_components++;

+      }

+

+      if (lhs_components != ir->rhs->type->vector_elements) {

+	 printf("Assignment count of LHS write mask channels enabled not\n"

+		"matching RHS vector size (%d LHS, %d RHS).\n",

+		lhs_components, ir->rhs->type->vector_elements);

+	 ir->print();

+	 abort();

+      }

+   }

+

+   this->validate_ir(ir, this->data);

+

+   return visit_continue;

+}

+

+ir_visitor_status

+ir_validate::visit_enter(ir_call *ir)

+{

+   ir_function_signature *const callee = ir->get_callee();

+

+   if (callee->ir_type != ir_type_function_signature) {

+      printf("IR called by ir_call is not ir_function_signature!\n");

+      abort();

+   }

+

+   return visit_continue;

+}

+

+void

+ir_validate::validate_ir(ir_instruction *ir, void *data)

+{

+   struct hash_table *ht = (struct hash_table *) data;

+

+   if (hash_table_find(ht, ir)) {

+      printf("Instruction node present twice in ir tree:\n");

+      ir->print();

+      printf("\n");

+      abort();

+   }

+   hash_table_insert(ht, ir, ir);

+}

+

+void

+check_node_type(ir_instruction *ir, void *data)

+{

+   (void) data;

+

+   if (ir->ir_type <= ir_type_unset || ir->ir_type >= ir_type_max) {

+      printf("Instruction node with unset type\n");

+      ir->print(); printf("\n");

+   }

+   assert(ir->type != glsl_type::error_type);

+}

+

+void

+validate_ir_tree(exec_list *instructions)

+{

+   ir_validate v;

+

+   v.run(instructions);

+

+   foreach_iter(exec_list_iterator, iter, *instructions) {

+      ir_instruction *ir = (ir_instruction *)iter.get();

+

+      visit_tree(ir, check_node_type, NULL);

+   }

+}

diff --git a/mesalib/src/mesa/SConscript b/mesalib/src/mesa/SConscript
index f797d62dc..a093469ec 100644
--- a/mesalib/src/mesa/SConscript
+++ b/mesalib/src/mesa/SConscript
@@ -1,402 +1,402 @@
-#######################################################################
-# SConscript for Mesa
-
-
-Import('*')
-
-env = env.Clone()
-
-env.Append(CPPPATH = [
-    '#/src/mapi',
-    '#/src/glsl',
-    '#/src/mesa',
-])
-
-env.Append(CPPDEFINES = [
-    'FEATURE_GL=1',
-])
-
-if env['platform'] == 'windows':
-    env.Append(CPPDEFINES = [
-        '_GDI32_', # prevent gl* being declared __declspec(dllimport) in MS headers
-        'BUILD_GL32', # declare gl* as __declspec(dllexport) in Mesa headers
-    ])
-    if not env['gles']:
-        # prevent _glapi_* from being declared __declspec(dllimport)
-        env.Append(CPPDEFINES = ['_GLAPI_NO_EXPORTS'])
-else:
-    env.Append(CPPDEFINES = [
-        'IN_DRI_DRIVER', # enable the remap table (for DRI drivers)
-    ])
-
-#
-# Source files
-#
-
-main_sources = [
-    'main/api_arrayelt.c',
-    'main/api_exec.c',
-    'main/api_loopback.c',
-    'main/api_noop.c',
-    'main/api_validate.c',
-    'main/accum.c',
-    'main/arbprogram.c',
-    'main/atifragshader.c',
-    'main/attrib.c',
-    'main/arrayobj.c',
-    'main/blend.c',
-    'main/bufferobj.c',
-    'main/buffers.c',
-    'main/clear.c',
-    'main/clip.c',
-    'main/colortab.c',
-    'main/condrender.c',
-    'main/context.c',
-    'main/convolve.c',
-    'main/cpuinfo.c',
-    'main/debug.c',
-    'main/depth.c',
-    'main/depthstencil.c',
-    'main/dlist.c',
-    'main/dlopen.c',
-    'main/drawpix.c',
-    'main/drawtex.c',
-    'main/enable.c',
-    'main/enums.c',
-    'main/eval.c',
-    'main/execmem.c',
-    'main/extensions.c',
-    'main/fbobject.c',
-    'main/feedback.c',
-    'main/ffvertex_prog.c',
-    'main/fog.c',
-    'main/formats.c',
-    'main/framebuffer.c',
-    'main/get.c',
-    'main/getstring.c',
-    'main/hash.c',
-    'main/hint.c',
-    'main/histogram.c',
-    'main/image.c',
-    'main/imports.c',
-    'main/light.c',
-    'main/lines.c',
-    'main/matrix.c',
-    'main/mipmap.c',
-    'main/mm.c',
-    'main/multisample.c',
-    'main/nvprogram.c',
-    'main/pack.c',
-    'main/pbo.c',
-    'main/pixel.c',
-    'main/pixelstore.c',
-    'main/pixeltransfer.c',
-    'main/points.c',
-    'main/polygon.c',
-    'main/querymatrix.c',
-    'main/queryobj.c',
-    'main/rastpos.c',
-    'main/readpix.c',
-    'main/remap.c',
-    'main/renderbuffer.c',
-    'main/scissor.c',
-    'main/shaderapi.c',
-    'main/shaderobj.c',
-    'main/shared.c',
-    'main/state.c',
-    'main/stencil.c',
-    'main/syncobj.c',
-    'main/texcompress.c',
-    'main/texcompress_rgtc.c',
-    'main/texcompress_s3tc.c',
-    'main/texcompress_fxt1.c',
-    'main/texenv.c',
-    'main/texenvprogram.c',
-    'main/texfetch.c',
-    'main/texformat.c',
-    'main/texgen.c',
-    'main/texgetimage.c',
-    'main/teximage.c',
-    'main/texobj.c',
-    'main/texpal.c',
-    'main/texparam.c',
-    'main/texrender.c',
-    'main/texstate.c',
-    'main/texstore.c',
-    'main/transformfeedback.c',
-    'main/uniforms.c',
-    'main/varray.c',
-    'main/version.c',
-    'main/viewport.c',
-    'main/vtxfmt.c',
-]
-
-math_sources = [
-    'math/m_debug_clip.c',
-    'math/m_debug_norm.c',
-    'math/m_debug_xform.c',
-    'math/m_eval.c',
-    'math/m_matrix.c',
-    'math/m_translate.c',
-    'math/m_vector.c',
-    'math/m_xform.c',
-]
-
-vbo_sources = [
-    'vbo/vbo_context.c',
-    'vbo/vbo_exec.c',
-    'vbo/vbo_exec_api.c',
-    'vbo/vbo_exec_array.c',
-    'vbo/vbo_exec_draw.c',
-    'vbo/vbo_exec_eval.c',
-    'vbo/vbo_rebase.c',
-    'vbo/vbo_split.c',
-    'vbo/vbo_split_copy.c',
-    'vbo/vbo_split_inplace.c',
-    'vbo/vbo_save.c',
-    'vbo/vbo_save_api.c',
-    'vbo/vbo_save_draw.c',
-    'vbo/vbo_save_loopback.c',
-]
-
-vf_sources = [
-    'vf/vf.c',
-    'vf/vf_generic.c',
-    'vf/vf_sse.c',
-]
-
-statetracker_sources = [
-    'state_tracker/st_atom.c',
-    'state_tracker/st_atom_blend.c',
-    'state_tracker/st_atom_clip.c',
-    'state_tracker/st_atom_constbuf.c',
-    'state_tracker/st_atom_depth.c',
-    'state_tracker/st_atom_framebuffer.c',
-    'state_tracker/st_atom_msaa.c',
-    'state_tracker/st_atom_pixeltransfer.c',
-    'state_tracker/st_atom_sampler.c',
-    'state_tracker/st_atom_scissor.c',
-    'state_tracker/st_atom_shader.c',
-    'state_tracker/st_atom_rasterizer.c',
-    'state_tracker/st_atom_stipple.c',
-    'state_tracker/st_atom_texture.c',
-    'state_tracker/st_atom_viewport.c',
-    'state_tracker/st_cb_accum.c',
-    'state_tracker/st_cb_bitmap.c',
-    'state_tracker/st_cb_blit.c',
-    'state_tracker/st_cb_bufferobjects.c',
-    'state_tracker/st_cb_clear.c',
-    'state_tracker/st_cb_condrender.c',
-    'state_tracker/st_cb_flush.c',
-    'state_tracker/st_cb_drawpixels.c',
-    'state_tracker/st_cb_drawtex.c',
-    'state_tracker/st_cb_eglimage.c',
-    'state_tracker/st_cb_fbo.c',
-    'state_tracker/st_cb_feedback.c',
-    'state_tracker/st_cb_program.c',
-    'state_tracker/st_cb_queryobj.c',
-    'state_tracker/st_cb_rasterpos.c',
-    'state_tracker/st_cb_readpixels.c',
-    'state_tracker/st_cb_syncobj.c',
-    'state_tracker/st_cb_strings.c',
-    'state_tracker/st_cb_texture.c',
-    'state_tracker/st_cb_viewport.c',
-    'state_tracker/st_cb_xformfb.c',
-    'state_tracker/st_context.c',
-    'state_tracker/st_debug.c',
-    'state_tracker/st_draw.c',
-    'state_tracker/st_draw_feedback.c',
-    'state_tracker/st_extensions.c',
-    'state_tracker/st_format.c',
-    'state_tracker/st_gen_mipmap.c',
-    'state_tracker/st_manager.c',
-    'state_tracker/st_mesa_to_tgsi.c',
-    'state_tracker/st_program.c',
-    'state_tracker/st_texture.c',
-]
-
-env.Append(YACCFLAGS = '-d')
-program_lex = env.CFile('program/lex.yy.c', 'program/program_lexer.l')
-program_parse = env.CFile('program/program_parse.tab.c',
-                          'program/program_parse.y')
-
-# Make program/program_parse.tab.h reacheable from the include path
-env.Append(CPPPATH = [Dir('.').abspath])
-
-program_sources = [
-    'program/arbprogparse.c',
-    'program/hash_table.c',
-    'program/ir_to_mesa.cpp',
-    'program/nvfragparse.c',
-    'program/nvvertparse.c',
-    'program/program.c',
-    'program/program_parse_extra.c',
-    'program/prog_cache.c',
-    'program/prog_execute.c',
-    'program/prog_instruction.c',
-    'program/prog_noise.c',
-    'program/prog_optimize.c',
-    'program/prog_parameter.c',
-    'program/prog_parameter_layout.c',
-    'program/prog_print.c',
-    'program/prog_statevars.c',
-    'program/prog_uniform.c',
-    'program/programopt.c',
-    'program/sampler.cpp',
-    'program/symbol_table.c',
-    program_lex,
-    program_parse[0],
-]
-
-mesa_sources = (
-    main_sources +
-    math_sources +
-    program_sources +
-    vbo_sources +
-    vf_sources +
-    statetracker_sources
-)
-
-if env['gles']:
-    from sys import executable as python_cmd
-
-    env.Append(CPPDEFINES = ['FEATURE_ES1=1', 'FEATURE_ES2=1'])
-
-    # generate GLES sources
-    gles_sources = []
-    gles_sources += env.CodeGenerate(
-        target = 'main/api_exec_es1.c',
-        script = 'main/es_generator.py',
-        source = 'main/APIspec.xml',
-        command = python_cmd + ' $SCRIPT -S $SOURCE -V GLES1.1 > $TARGET'
-    )
-    gles_sources += env.CodeGenerate(
-        target = 'main/api_exec_es2.c',
-        script = 'main/es_generator.py',
-        source = 'main/APIspec.xml',
-        command = python_cmd + ' $SCRIPT -S $SOURCE -V GLES2.0 > $TARGET'
-    )
-
-    # generate GLES headers
-    GLAPI = '#src/mapi/glapi/'
-    gles_headers = []
-    gles_headers += env.CodeGenerate(
-        target = 'es1api/main/glapidispatch.h',
-        script = GLAPI + 'gen/gl_table.py',
-        source = GLAPI + 'gen-es/es1_API.xml',
-        command = python_cmd + ' $SCRIPT -c -m remap_table -f $SOURCE > $TARGET',
-    )
-    gles_headers += env.CodeGenerate(
-        target = 'es1api/main/remap_helper.h',
-        script = GLAPI + 'gen/remap_helper.py',
-        source = GLAPI + 'gen-es/es1_API.xml',
-        command = python_cmd + ' $SCRIPT -f $SOURCE > $TARGET',
-    )
-    gles_headers += env.CodeGenerate(
-        target = 'es2api/main/glapidispatch.h',
-        script = GLAPI + 'gen/gl_table.py',
-        source = GLAPI + 'gen-es/es2_API.xml',
-        command = python_cmd + ' $SCRIPT -c -m remap_table -f $SOURCE > $TARGET',
-    )
-    gles_headers += env.CodeGenerate(
-        target = 'es2api/main/remap_helper.h',
-        script = GLAPI + 'gen/remap_helper.py',
-        source = GLAPI + 'gen-es/es2_API.xml',
-        command = python_cmd + ' $SCRIPT -f $SOURCE > $TARGET',
-    )
-
-    env.Depends(gles_sources, gles_headers)
-
-    # gles_sources #include gles_headers with full path
-    env.Append(CPPPATH = [gles_headers[0].dir.up().up()])
-
-    mesa_sources += gles_sources
-
-#
-# Assembly sources
-#
-if env['gcc'] and env['platform'] != 'windows':
-    if env['machine'] == 'x86':
-        env.Append(CPPDEFINES = [
-            'USE_X86_ASM',
-            'USE_MMX_ASM',
-            'USE_3DNOW_ASM',
-            'USE_SSE_ASM',
-        ])
-        mesa_sources += [
-            'x86/common_x86.c',
-            'x86/x86_xform.c',
-            'x86/3dnow.c',
-            'x86/sse.c',
-            'x86/common_x86_asm.S',
-            'x86/x86_xform2.S',
-            'x86/x86_xform3.S',
-            'x86/x86_xform4.S',
-            'x86/x86_cliptest.S',
-            'x86/mmx_blend.S',
-            'x86/3dnow_xform1.S',
-            'x86/3dnow_xform2.S',
-            'x86/3dnow_xform3.S',
-            'x86/3dnow_xform4.S',
-            'x86/3dnow_normal.S',
-            'x86/sse_xform1.S',
-            'x86/sse_xform2.S',
-            'x86/sse_xform3.S',
-            'x86/sse_xform4.S',
-            'x86/sse_normal.S',
-            'x86/read_rgba_span_x86.S',
-        ]
-    elif env['machine'] == 'x86_64':
-        env.Append(CPPDEFINES = [
-            'USE_X86_64_ASM',
-        ])
-        mesa_sources += [
-            'x86-64/x86-64.c',
-            'x86-64/xform4.S',
-        ]
-    elif env['machine'] == 'ppc':
-        env.Append(CPPDEFINES = [
-            'USE_PPC_ASM',
-            'USE_VMX_ASM',
-        ])
-        mesa_sources += [
-            'ppc/common_ppc.c',
-        ]
-    elif env['machine'] == 'sparc':
-        mesa_sources += [
-            'sparc/sparc.c',
-            'sparc/clip.S',
-            'sparc/norm.S',
-            'sparc/xform.S',
-        ]
-    else:
-        pass
-
-    # Generate matypes.h
-    if env['machine'] in ('x86', 'x86_64'):
-        # See http://www.scons.org/wiki/UsingCodeGenerators
-        gen_matypes = env.Program(
-            target = 'gen_matypes',
-            source = 'x86/gen_matypes.c',
-        )
-        matypes = env.Command(
-            'matypes.h',
-            gen_matypes,
-            gen_matypes[0].abspath + ' > $TARGET',
-        )
-        # Add the dir containing the generated header (somewhere inside  the
-        # build dir) to the include path
-        env.Append(CPPPATH = [matypes[0].dir])
-
-#
-# Libraries
-#
-
-mesa = env.ConvenienceLibrary(
-    target = 'mesa',
-    source = mesa_sources,
-)
-
-env.Alias('mesa', mesa)
-
-Export('mesa')
+#######################################################################

+# SConscript for Mesa

+

+

+Import('*')

+

+env = env.Clone()

+

+env.Append(CPPPATH = [

+    '#/src/mapi',

+    '#/src/glsl',

+    '#/src/mesa',

+])

+

+env.Append(CPPDEFINES = [

+    'FEATURE_GL=1',

+])

+

+if env['platform'] == 'windows':

+    env.Append(CPPDEFINES = [

+        '_GDI32_', # prevent gl* being declared __declspec(dllimport) in MS headers

+        'BUILD_GL32', # declare gl* as __declspec(dllexport) in Mesa headers

+    ])

+    if not env['gles']:

+        # prevent _glapi_* from being declared __declspec(dllimport)

+        env.Append(CPPDEFINES = ['_GLAPI_NO_EXPORTS'])

+else:

+    env.Append(CPPDEFINES = [

+        'IN_DRI_DRIVER', # enable the remap table (for DRI drivers)

+    ])

+

+#

+# Source files

+#

+

+main_sources = [

+    'main/api_arrayelt.c',

+    'main/api_exec.c',

+    'main/api_loopback.c',

+    'main/api_noop.c',

+    'main/api_validate.c',

+    'main/accum.c',

+    'main/arbprogram.c',

+    'main/atifragshader.c',

+    'main/attrib.c',

+    'main/arrayobj.c',

+    'main/blend.c',

+    'main/bufferobj.c',

+    'main/buffers.c',

+    'main/clear.c',

+    'main/clip.c',

+    'main/colortab.c',

+    'main/condrender.c',

+    'main/context.c',

+    'main/convolve.c',

+    'main/cpuinfo.c',

+    'main/debug.c',

+    'main/depth.c',

+    'main/depthstencil.c',

+    'main/dlist.c',

+    'main/dlopen.c',

+    'main/drawpix.c',

+    'main/drawtex.c',

+    'main/enable.c',

+    'main/enums.c',

+    'main/eval.c',

+    'main/execmem.c',

+    'main/extensions.c',

+    'main/fbobject.c',

+    'main/feedback.c',

+    'main/ff_fragment_shader.cpp',

+    'main/ffvertex_prog.c',

+    'main/fog.c',

+    'main/formats.c',

+    'main/framebuffer.c',

+    'main/get.c',

+    'main/getstring.c',

+    'main/hash.c',

+    'main/hint.c',

+    'main/histogram.c',

+    'main/image.c',

+    'main/imports.c',

+    'main/light.c',

+    'main/lines.c',

+    'main/matrix.c',

+    'main/mipmap.c',

+    'main/mm.c',

+    'main/multisample.c',

+    'main/nvprogram.c',

+    'main/pack.c',

+    'main/pbo.c',

+    'main/pixel.c',

+    'main/pixelstore.c',

+    'main/pixeltransfer.c',

+    'main/points.c',

+    'main/polygon.c',

+    'main/querymatrix.c',

+    'main/queryobj.c',

+    'main/rastpos.c',

+    'main/readpix.c',

+    'main/remap.c',

+    'main/renderbuffer.c',

+    'main/scissor.c',

+    'main/shaderapi.c',

+    'main/shaderobj.c',

+    'main/shared.c',

+    'main/state.c',

+    'main/stencil.c',

+    'main/syncobj.c',

+    'main/texcompress.c',

+    'main/texcompress_rgtc.c',

+    'main/texcompress_s3tc.c',

+    'main/texcompress_fxt1.c',

+    'main/texenv.c',

+    'main/texfetch.c',

+    'main/texformat.c',

+    'main/texgen.c',

+    'main/texgetimage.c',

+    'main/teximage.c',

+    'main/texobj.c',

+    'main/texpal.c',

+    'main/texparam.c',

+    'main/texrender.c',

+    'main/texstate.c',

+    'main/texstore.c',

+    'main/transformfeedback.c',

+    'main/uniforms.c',

+    'main/varray.c',

+    'main/version.c',

+    'main/viewport.c',

+    'main/vtxfmt.c',

+]

+

+math_sources = [

+    'math/m_debug_clip.c',

+    'math/m_debug_norm.c',

+    'math/m_debug_xform.c',

+    'math/m_eval.c',

+    'math/m_matrix.c',

+    'math/m_translate.c',

+    'math/m_vector.c',

+    'math/m_xform.c',

+]

+

+vbo_sources = [

+    'vbo/vbo_context.c',

+    'vbo/vbo_exec.c',

+    'vbo/vbo_exec_api.c',

+    'vbo/vbo_exec_array.c',

+    'vbo/vbo_exec_draw.c',

+    'vbo/vbo_exec_eval.c',

+    'vbo/vbo_rebase.c',

+    'vbo/vbo_split.c',

+    'vbo/vbo_split_copy.c',

+    'vbo/vbo_split_inplace.c',

+    'vbo/vbo_save.c',

+    'vbo/vbo_save_api.c',

+    'vbo/vbo_save_draw.c',

+    'vbo/vbo_save_loopback.c',

+]

+

+vf_sources = [

+    'vf/vf.c',

+    'vf/vf_generic.c',

+    'vf/vf_sse.c',

+]

+

+statetracker_sources = [

+    'state_tracker/st_atom.c',

+    'state_tracker/st_atom_blend.c',

+    'state_tracker/st_atom_clip.c',

+    'state_tracker/st_atom_constbuf.c',

+    'state_tracker/st_atom_depth.c',

+    'state_tracker/st_atom_framebuffer.c',

+    'state_tracker/st_atom_msaa.c',

+    'state_tracker/st_atom_pixeltransfer.c',

+    'state_tracker/st_atom_sampler.c',

+    'state_tracker/st_atom_scissor.c',

+    'state_tracker/st_atom_shader.c',

+    'state_tracker/st_atom_rasterizer.c',

+    'state_tracker/st_atom_stipple.c',

+    'state_tracker/st_atom_texture.c',

+    'state_tracker/st_atom_viewport.c',

+    'state_tracker/st_cb_accum.c',

+    'state_tracker/st_cb_bitmap.c',

+    'state_tracker/st_cb_blit.c',

+    'state_tracker/st_cb_bufferobjects.c',

+    'state_tracker/st_cb_clear.c',

+    'state_tracker/st_cb_condrender.c',

+    'state_tracker/st_cb_flush.c',

+    'state_tracker/st_cb_drawpixels.c',

+    'state_tracker/st_cb_drawtex.c',

+    'state_tracker/st_cb_eglimage.c',

+    'state_tracker/st_cb_fbo.c',

+    'state_tracker/st_cb_feedback.c',

+    'state_tracker/st_cb_program.c',

+    'state_tracker/st_cb_queryobj.c',

+    'state_tracker/st_cb_rasterpos.c',

+    'state_tracker/st_cb_readpixels.c',

+    'state_tracker/st_cb_syncobj.c',

+    'state_tracker/st_cb_strings.c',

+    'state_tracker/st_cb_texture.c',

+    'state_tracker/st_cb_viewport.c',

+    'state_tracker/st_cb_xformfb.c',

+    'state_tracker/st_context.c',

+    'state_tracker/st_debug.c',

+    'state_tracker/st_draw.c',

+    'state_tracker/st_draw_feedback.c',

+    'state_tracker/st_extensions.c',

+    'state_tracker/st_format.c',

+    'state_tracker/st_gen_mipmap.c',

+    'state_tracker/st_manager.c',

+    'state_tracker/st_mesa_to_tgsi.c',

+    'state_tracker/st_program.c',

+    'state_tracker/st_texture.c',

+]

+

+env.Append(YACCFLAGS = '-d')

+program_lex = env.CFile('program/lex.yy.c', 'program/program_lexer.l')

+program_parse = env.CFile('program/program_parse.tab.c',

+                          'program/program_parse.y')

+

+# Make program/program_parse.tab.h reacheable from the include path

+env.Append(CPPPATH = [Dir('.').abspath])

+

+program_sources = [

+    'program/arbprogparse.c',

+    'program/hash_table.c',

+    'program/ir_to_mesa.cpp',

+    'program/nvfragparse.c',

+    'program/nvvertparse.c',

+    'program/program.c',

+    'program/program_parse_extra.c',

+    'program/prog_cache.c',

+    'program/prog_execute.c',

+    'program/prog_instruction.c',

+    'program/prog_noise.c',

+    'program/prog_optimize.c',

+    'program/prog_parameter.c',

+    'program/prog_parameter_layout.c',

+    'program/prog_print.c',

+    'program/prog_statevars.c',

+    'program/prog_uniform.c',

+    'program/programopt.c',

+    'program/sampler.cpp',

+    'program/symbol_table.c',

+    program_lex,

+    program_parse[0],

+]

+

+mesa_sources = (

+    main_sources +

+    math_sources +

+    program_sources +

+    vbo_sources +

+    vf_sources +

+    statetracker_sources

+)

+

+if env['gles']:

+    from sys import executable as python_cmd

+

+    env.Append(CPPDEFINES = ['FEATURE_ES1=1', 'FEATURE_ES2=1'])

+

+    # generate GLES sources

+    gles_sources = []

+    gles_sources += env.CodeGenerate(

+        target = 'main/api_exec_es1.c',

+        script = 'main/es_generator.py',

+        source = 'main/APIspec.xml',

+        command = python_cmd + ' $SCRIPT -S $SOURCE -V GLES1.1 > $TARGET'

+    )

+    gles_sources += env.CodeGenerate(

+        target = 'main/api_exec_es2.c',

+        script = 'main/es_generator.py',

+        source = 'main/APIspec.xml',

+        command = python_cmd + ' $SCRIPT -S $SOURCE -V GLES2.0 > $TARGET'

+    )

+

+    # generate GLES headers

+    GLAPI = '#src/mapi/glapi/'

+    gles_headers = []

+    gles_headers += env.CodeGenerate(

+        target = 'es1api/main/glapidispatch.h',

+        script = GLAPI + 'gen/gl_table.py',

+        source = GLAPI + 'gen-es/es1_API.xml',

+        command = python_cmd + ' $SCRIPT -c -m remap_table -f $SOURCE > $TARGET',

+    )

+    gles_headers += env.CodeGenerate(

+        target = 'es1api/main/remap_helper.h',

+        script = GLAPI + 'gen/remap_helper.py',

+        source = GLAPI + 'gen-es/es1_API.xml',

+        command = python_cmd + ' $SCRIPT -f $SOURCE > $TARGET',

+    )

+    gles_headers += env.CodeGenerate(

+        target = 'es2api/main/glapidispatch.h',

+        script = GLAPI + 'gen/gl_table.py',

+        source = GLAPI + 'gen-es/es2_API.xml',

+        command = python_cmd + ' $SCRIPT -c -m remap_table -f $SOURCE > $TARGET',

+    )

+    gles_headers += env.CodeGenerate(

+        target = 'es2api/main/remap_helper.h',

+        script = GLAPI + 'gen/remap_helper.py',

+        source = GLAPI + 'gen-es/es2_API.xml',

+        command = python_cmd + ' $SCRIPT -f $SOURCE > $TARGET',

+    )

+

+    env.Depends(gles_sources, gles_headers)

+

+    # gles_sources #include gles_headers with full path

+    env.Append(CPPPATH = [gles_headers[0].dir.up().up()])

+

+    mesa_sources += gles_sources

+

+#

+# Assembly sources

+#

+if env['gcc'] and env['platform'] != 'windows':

+    if env['machine'] == 'x86':

+        env.Append(CPPDEFINES = [

+            'USE_X86_ASM',

+            'USE_MMX_ASM',

+            'USE_3DNOW_ASM',

+            'USE_SSE_ASM',

+        ])

+        mesa_sources += [

+            'x86/common_x86.c',

+            'x86/x86_xform.c',

+            'x86/3dnow.c',

+            'x86/sse.c',

+            'x86/common_x86_asm.S',

+            'x86/x86_xform2.S',

+            'x86/x86_xform3.S',

+            'x86/x86_xform4.S',

+            'x86/x86_cliptest.S',

+            'x86/mmx_blend.S',

+            'x86/3dnow_xform1.S',

+            'x86/3dnow_xform2.S',

+            'x86/3dnow_xform3.S',

+            'x86/3dnow_xform4.S',

+            'x86/3dnow_normal.S',

+            'x86/sse_xform1.S',

+            'x86/sse_xform2.S',

+            'x86/sse_xform3.S',

+            'x86/sse_xform4.S',

+            'x86/sse_normal.S',

+            'x86/read_rgba_span_x86.S',

+        ]

+    elif env['machine'] == 'x86_64':

+        env.Append(CPPDEFINES = [

+            'USE_X86_64_ASM',

+        ])

+        mesa_sources += [

+            'x86-64/x86-64.c',

+            'x86-64/xform4.S',

+        ]

+    elif env['machine'] == 'ppc':

+        env.Append(CPPDEFINES = [

+            'USE_PPC_ASM',

+            'USE_VMX_ASM',

+        ])

+        mesa_sources += [

+            'ppc/common_ppc.c',

+        ]

+    elif env['machine'] == 'sparc':

+        mesa_sources += [

+            'sparc/sparc.c',

+            'sparc/clip.S',

+            'sparc/norm.S',

+            'sparc/xform.S',

+        ]

+    else:

+        pass

+

+    # Generate matypes.h

+    if env['machine'] in ('x86', 'x86_64'):

+        # See http://www.scons.org/wiki/UsingCodeGenerators

+        gen_matypes = env.Program(

+            target = 'gen_matypes',

+            source = 'x86/gen_matypes.c',

+        )

+        matypes = env.Command(

+            'matypes.h',

+            gen_matypes,

+            gen_matypes[0].abspath + ' > $TARGET',

+        )

+        # Add the dir containing the generated header (somewhere inside  the

+        # build dir) to the include path

+        env.Append(CPPPATH = [matypes[0].dir])

+

+#

+# Libraries

+#

+

+mesa = env.ConvenienceLibrary(

+    target = 'mesa',

+    source = mesa_sources,

+)

+

+env.Alias('mesa', mesa)

+

+Export('mesa')

diff --git a/mesalib/src/mesa/main/bufferobj.c b/mesalib/src/mesa/main/bufferobj.c
index 44072fbc5..d5d0c9072 100644
--- a/mesalib/src/mesa/main/bufferobj.c
+++ b/mesalib/src/mesa/main/bufferobj.c
@@ -1,1917 +1,1918 @@
-/*
- * Mesa 3-D graphics library
- * Version:  7.6
- *
- * 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 bufferobj.c
- * \brief Functions for the GL_ARB_vertex/pixel_buffer_object extensions.
- * \author Brian Paul, Ian Romanick
- */
-
-
-#include "glheader.h"
-#include "enums.h"
-#include "hash.h"
-#include "imports.h"
-#include "image.h"
-#include "context.h"
-#include "bufferobj.h"
-#include "fbobject.h"
-#include "mfeatures.h"
-#include "mtypes.h"
-#include "texobj.h"
-
-
-/* Debug flags */
-/*#define VBO_DEBUG*/
-/*#define BOUNDS_CHECK*/
-
-
-#if FEATURE_OES_mapbuffer
-#define DEFAULT_ACCESS GL_MAP_WRITE_BIT
-#else
-#define DEFAULT_ACCESS (GL_MAP_READ_BIT | GL_MAP_WRITE_BIT)
-#endif
-
-
-/**
- * Used as a placeholder for buffer objects between glGenBuffers() and
- * glBindBuffer() so that glIsBuffer() can work correctly.
- */
-static struct gl_buffer_object DummyBufferObject;
-
-
-/**
- * Return pointer to address of a buffer object target.
- * \param ctx  the GL context
- * \param target  the buffer object target to be retrieved.
- * \return   pointer to pointer to the buffer object bound to \c target in the
- *           specified context or \c NULL if \c target is invalid.
- */
-static INLINE struct gl_buffer_object **
-get_buffer_target(struct gl_context *ctx, GLenum target)
-{
-   switch (target) {
-   case GL_ARRAY_BUFFER_ARB:
-      return &ctx->Array.ArrayBufferObj;
-   case GL_ELEMENT_ARRAY_BUFFER_ARB:
-      return &ctx->Array.ElementArrayBufferObj;
-   case GL_PIXEL_PACK_BUFFER_EXT:
-      return &ctx->Pack.BufferObj;
-   case GL_PIXEL_UNPACK_BUFFER_EXT:
-      return &ctx->Unpack.BufferObj;
-   case GL_COPY_READ_BUFFER:
-      return &ctx->CopyReadBuffer;
-   case GL_COPY_WRITE_BUFFER:
-      return &ctx->CopyWriteBuffer;
-#if FEATURE_EXT_transform_feedback
-   case GL_TRANSFORM_FEEDBACK_BUFFER:
-      if (ctx->Extensions.EXT_transform_feedback) {
-         return &ctx->TransformFeedback.CurrentBuffer;
-      }
-      break;
-#endif
-   default:
-      return NULL;
-   }
-   return NULL;
-}
-
-
-/**
- * Get the buffer object bound to the specified target in a GL context.
- * \param ctx  the GL context
- * \param target  the buffer object target to be retrieved.
- * \return   pointer to the buffer object bound to \c target in the
- *           specified context or \c NULL if \c target is invalid.
- */
-static INLINE struct gl_buffer_object *
-get_buffer(struct gl_context *ctx, GLenum target)
-{
-   struct gl_buffer_object **bufObj = get_buffer_target(ctx, target);
-   if (bufObj)
-      return *bufObj;
-   return NULL;
-}
-
-
-/**
- * Convert a GLbitfield describing the mapped buffer access flags
- * into one of GL_READ_WRITE, GL_READ_ONLY, or GL_WRITE_ONLY.
- */
-static GLenum
-simplified_access_mode(GLbitfield access)
-{
-   const GLbitfield rwFlags = GL_MAP_READ_BIT | GL_MAP_WRITE_BIT;
-   if ((access & rwFlags) == rwFlags)
-      return GL_READ_WRITE;
-   if ((access & GL_MAP_READ_BIT) == GL_MAP_READ_BIT)
-      return GL_READ_ONLY;
-   if ((access & GL_MAP_WRITE_BIT) == GL_MAP_WRITE_BIT)
-      return GL_WRITE_ONLY;
-   return GL_READ_WRITE; /* this should never happen, but no big deal */
-}
-
-
-/**
- * Tests the subdata range parameters and sets the GL error code for
- * \c glBufferSubDataARB and \c glGetBufferSubDataARB.
- *
- * \param ctx     GL context.
- * \param target  Buffer object target on which to operate.
- * \param offset  Offset of the first byte of the subdata range.
- * \param size    Size, in bytes, of the subdata range.
- * \param caller  Name of calling function for recording errors.
- * \return   A pointer to the buffer object bound to \c target in the
- *           specified context or \c NULL if any of the parameter or state
- *           conditions for \c glBufferSubDataARB or \c glGetBufferSubDataARB
- *           are invalid.
- *
- * \sa glBufferSubDataARB, glGetBufferSubDataARB
- */
-static struct gl_buffer_object *
-buffer_object_subdata_range_good( struct gl_context * ctx, GLenum target, 
-                                  GLintptrARB offset, GLsizeiptrARB size,
-                                  const char *caller )
-{
-   struct gl_buffer_object *bufObj;
-
-   if (size < 0) {
-      _mesa_error(ctx, GL_INVALID_VALUE, "%s(size < 0)", caller);
-      return NULL;
-   }
-
-   if (offset < 0) {
-      _mesa_error(ctx, GL_INVALID_VALUE, "%s(offset < 0)", caller);
-      return NULL;
-   }
-
-   bufObj = get_buffer(ctx, target);
-   if (!bufObj) {
-      _mesa_error(ctx, GL_INVALID_ENUM, "%s(target)", caller);
-      return NULL;
-   }
-   if (!_mesa_is_bufferobj(bufObj)) {
-      _mesa_error(ctx, GL_INVALID_OPERATION, "%s", caller);
-      return NULL;
-   }
-   if (offset + size > bufObj->Size) {
-      _mesa_error(ctx, GL_INVALID_VALUE,
-		  "%s(size + offset > buffer size)", caller);
-      return NULL;
-   }
-   if (_mesa_bufferobj_mapped(bufObj)) {
-      /* Buffer is currently mapped */
-      _mesa_error(ctx, GL_INVALID_OPERATION, "%s", caller);
-      return NULL;
-   }
-
-   return bufObj;
-}
-
-
-/**
- * Allocate and initialize a new buffer object.
- * 
- * Default callback for the \c dd_function_table::NewBufferObject() hook.
- */
-static struct gl_buffer_object *
-_mesa_new_buffer_object( struct gl_context *ctx, GLuint name, GLenum target )
-{
-   struct gl_buffer_object *obj;
-
-   (void) ctx;
-
-   obj = MALLOC_STRUCT(gl_buffer_object);
-   _mesa_initialize_buffer_object(obj, name, target);
-   return obj;
-}
-
-
-/**
- * Delete a buffer object.
- * 
- * Default callback for the \c dd_function_table::DeleteBuffer() hook.
- */
-static void
-_mesa_delete_buffer_object( struct gl_context *ctx, struct gl_buffer_object *bufObj )
-{
-   (void) ctx;
-
-   if (bufObj->Data)
-      free(bufObj->Data);
-
-   /* assign strange values here to help w/ debugging */
-   bufObj->RefCount = -1000;
-   bufObj->Name = ~0;
-
-   _glthread_DESTROY_MUTEX(bufObj->Mutex);
-   free(bufObj);
-}
-
-
-
-/**
- * Set ptr to bufObj w/ reference counting.
- */
-void
-_mesa_reference_buffer_object(struct gl_context *ctx,
-                              struct gl_buffer_object **ptr,
-                              struct gl_buffer_object *bufObj)
-{
-   if (*ptr == bufObj)
-      return;
-
-   if (*ptr) {
-      /* Unreference the old buffer */
-      GLboolean deleteFlag = GL_FALSE;
-      struct gl_buffer_object *oldObj = *ptr;
-
-      _glthread_LOCK_MUTEX(oldObj->Mutex);
-      ASSERT(oldObj->RefCount > 0);
-      oldObj->RefCount--;
-#if 0
-      printf("BufferObj %p %d DECR to %d\n",
-             (void *) oldObj, oldObj->Name, oldObj->RefCount);
-#endif
-      deleteFlag = (oldObj->RefCount == 0);
-      _glthread_UNLOCK_MUTEX(oldObj->Mutex);
-
-      if (deleteFlag) {
-
-         /* some sanity checking: don't delete a buffer still in use */
-#if 0
-         /* unfortunately, these tests are invalid during context tear-down */
-	 ASSERT(ctx->Array.ArrayBufferObj != bufObj);
-	 ASSERT(ctx->Array.ElementArrayBufferObj != bufObj);
-	 ASSERT(ctx->Array.ArrayObj->Vertex.BufferObj != bufObj);
-#endif
-
-	 ASSERT(ctx->Driver.DeleteBuffer);
-         ctx->Driver.DeleteBuffer(ctx, oldObj);
-      }
-
-      *ptr = NULL;
-   }
-   ASSERT(!*ptr);
-
-   if (bufObj) {
-      /* reference new buffer */
-      _glthread_LOCK_MUTEX(bufObj->Mutex);
-      if (bufObj->RefCount == 0) {
-         /* this buffer's being deleted (look just above) */
-         /* Not sure this can every really happen.  Warn if it does. */
-         _mesa_problem(NULL, "referencing deleted buffer object");
-         *ptr = NULL;
-      }
-      else {
-         bufObj->RefCount++;
-#if 0
-         printf("BufferObj %p %d INCR to %d\n",
-                (void *) bufObj, bufObj->Name, bufObj->RefCount);
-#endif
-         *ptr = bufObj;
-      }
-      _glthread_UNLOCK_MUTEX(bufObj->Mutex);
-   }
-}
-
-
-/**
- * Initialize a buffer object to default values.
- */
-void
-_mesa_initialize_buffer_object( struct gl_buffer_object *obj,
-				GLuint name, GLenum target )
-{
-   (void) target;
-
-   memset(obj, 0, sizeof(struct gl_buffer_object));
-   _glthread_INIT_MUTEX(obj->Mutex);
-   obj->RefCount = 1;
-   obj->Name = name;
-   obj->Usage = GL_STATIC_DRAW_ARB;
-   obj->AccessFlags = DEFAULT_ACCESS;
-}
-
-
-/**
- * Allocate space for and store data in a buffer object.  Any data that was
- * previously stored in the buffer object is lost.  If \c data is \c NULL,
- * memory will be allocated, but no copy will occur.
- *
- * This is the default callback for \c dd_function_table::BufferData()
- * Note that all GL error checking will have been done already.
- *
- * \param ctx     GL context.
- * \param target  Buffer object target on which to operate.
- * \param size    Size, in bytes, of the new data store.
- * \param data    Pointer to the data to store in the buffer object.  This
- *                pointer may be \c NULL.
- * \param usage   Hints about how the data will be used.
- * \param bufObj  Object to be used.
- *
- * \return GL_TRUE for success, GL_FALSE for failure
- * \sa glBufferDataARB, dd_function_table::BufferData.
- */
-static GLboolean
-_mesa_buffer_data( struct gl_context *ctx, GLenum target, GLsizeiptrARB size,
-		   const GLvoid * data, GLenum usage,
-		   struct gl_buffer_object * bufObj )
-{
-   void * new_data;
-
-   (void) ctx; (void) target;
-
-   new_data = _mesa_realloc( bufObj->Data, bufObj->Size, size );
-   if (new_data) {
-      bufObj->Data = (GLubyte *) new_data;
-      bufObj->Size = size;
-      bufObj->Usage = usage;
-
-      if (data) {
-	 memcpy( bufObj->Data, data, size );
-      }
-
-      return GL_TRUE;
-   }
-   else {
-      return GL_FALSE;
-   }
-}
-
-
-/**
- * Replace data in a subrange of buffer object.  If the data range
- * specified by \c size + \c offset extends beyond the end of the buffer or
- * if \c data is \c NULL, no copy is performed.
- *
- * This is the default callback for \c dd_function_table::BufferSubData()
- * Note that all GL error checking will have been done already.
- *
- * \param ctx     GL context.
- * \param target  Buffer object target on which to operate.
- * \param offset  Offset of the first byte to be modified.
- * \param size    Size, in bytes, of the data range.
- * \param data    Pointer to the data to store in the buffer object.
- * \param bufObj  Object to be used.
- *
- * \sa glBufferSubDataARB, dd_function_table::BufferSubData.
- */
-static void
-_mesa_buffer_subdata( struct gl_context *ctx, GLenum target, GLintptrARB offset,
-		      GLsizeiptrARB size, const GLvoid * data,
-		      struct gl_buffer_object * bufObj )
-{
-   (void) ctx; (void) target;
-
-   /* this should have been caught in _mesa_BufferSubData() */
-   ASSERT(size + offset <= bufObj->Size);
-
-   if (bufObj->Data) {
-      memcpy( (GLubyte *) bufObj->Data + offset, data, size );
-   }
-}
-
-
-/**
- * Retrieve data from a subrange of buffer object.  If the data range
- * specified by \c size + \c offset extends beyond the end of the buffer or
- * if \c data is \c NULL, no copy is performed.
- *
- * This is the default callback for \c dd_function_table::GetBufferSubData()
- * Note that all GL error checking will have been done already.
- *
- * \param ctx     GL context.
- * \param target  Buffer object target on which to operate.
- * \param offset  Offset of the first byte to be fetched.
- * \param size    Size, in bytes, of the data range.
- * \param data    Destination for data
- * \param bufObj  Object to be used.
- *
- * \sa glBufferGetSubDataARB, dd_function_table::GetBufferSubData.
- */
-static void
-_mesa_buffer_get_subdata( struct gl_context *ctx, GLenum target, GLintptrARB offset,
-			  GLsizeiptrARB size, GLvoid * data,
-			  struct gl_buffer_object * bufObj )
-{
-   (void) ctx; (void) target;
-
-   if (bufObj->Data && ((GLsizeiptrARB) (size + offset) <= bufObj->Size)) {
-      memcpy( data, (GLubyte *) bufObj->Data + offset, size );
-   }
-}
-
-
-/**
- * Default callback for \c dd_function_tabel::MapBuffer().
- *
- * The function parameters will have been already tested for errors.
- *
- * \param ctx     GL context.
- * \param target  Buffer object target on which to operate.
- * \param access  Information about how the buffer will be accessed.
- * \param bufObj  Object to be mapped.
- * \return  A pointer to the object's internal data store that can be accessed
- *          by the processor
- *
- * \sa glMapBufferARB, dd_function_table::MapBuffer
- */
-static void *
-_mesa_buffer_map( struct gl_context *ctx, GLenum target, GLenum access,
-		  struct gl_buffer_object *bufObj )
-{
-   (void) ctx;
-   (void) target;
-   (void) access;
-   /* Just return a direct pointer to the data */
-   if (_mesa_bufferobj_mapped(bufObj)) {
-      /* already mapped! */
-      return NULL;
-   }
-   bufObj->Pointer = bufObj->Data;
-   bufObj->Length = bufObj->Size;
-   bufObj->Offset = 0;
-   return bufObj->Pointer;
-}
-
-
-/**
- * Default fallback for \c dd_function_table::MapBufferRange().
- * Called via glMapBufferRange().
- */
-static void *
-_mesa_buffer_map_range( struct gl_context *ctx, GLenum target, GLintptr offset,
-                        GLsizeiptr length, GLbitfield access,
-                        struct gl_buffer_object *bufObj )
-{
-   (void) ctx;
-   (void) target;
-   assert(!_mesa_bufferobj_mapped(bufObj));
-   /* Just return a direct pointer to the data */
-   bufObj->Pointer = bufObj->Data + offset;
-   bufObj->Length = length;
-   bufObj->Offset = offset;
-   bufObj->AccessFlags = access;
-   return bufObj->Pointer;
-}
-
-
-/**
- * Default fallback for \c dd_function_table::FlushMappedBufferRange().
- * Called via glFlushMappedBufferRange().
- */
-static void
-_mesa_buffer_flush_mapped_range( struct gl_context *ctx, GLenum target, 
-                                 GLintptr offset, GLsizeiptr length,
-                                 struct gl_buffer_object *obj )
-{
-   (void) ctx;
-   (void) target;
-   (void) offset;
-   (void) length;
-   (void) obj;
-   /* no-op */
-}
-
-
-/**
- * Default callback for \c dd_function_table::MapBuffer().
- *
- * The input parameters will have been already tested for errors.
- *
- * \sa glUnmapBufferARB, dd_function_table::UnmapBuffer
- */
-static GLboolean
-_mesa_buffer_unmap( struct gl_context *ctx, GLenum target,
-                    struct gl_buffer_object *bufObj )
-{
-   (void) ctx;
-   (void) target;
-   /* XXX we might assert here that bufObj->Pointer is non-null */
-   bufObj->Pointer = NULL;
-   bufObj->Length = 0;
-   bufObj->Offset = 0;
-   bufObj->AccessFlags = 0x0;
-   return GL_TRUE;
-}
-
-
-/**
- * Default fallback for \c dd_function_table::CopyBufferSubData().
- * Called via glCopyBuffserSubData().
- */
-static void
-_mesa_copy_buffer_subdata(struct gl_context *ctx,
-                          struct gl_buffer_object *src,
-                          struct gl_buffer_object *dst,
-                          GLintptr readOffset, GLintptr writeOffset,
-                          GLsizeiptr size)
-{
-   GLubyte *srcPtr, *dstPtr;
-
-   /* buffer should not already be mapped */
-   assert(!_mesa_bufferobj_mapped(src));
-   assert(!_mesa_bufferobj_mapped(dst));
-
-   srcPtr = (GLubyte *) ctx->Driver.MapBuffer(ctx, GL_COPY_READ_BUFFER,
-                                              GL_READ_ONLY, src);
-   dstPtr = (GLubyte *) ctx->Driver.MapBuffer(ctx, GL_COPY_WRITE_BUFFER,
-                                              GL_WRITE_ONLY, dst);
-
-   if (srcPtr && dstPtr)
-      memcpy(dstPtr + writeOffset, srcPtr + readOffset, size);
-
-   ctx->Driver.UnmapBuffer(ctx, GL_COPY_READ_BUFFER, src);
-   ctx->Driver.UnmapBuffer(ctx, GL_COPY_WRITE_BUFFER, dst);
-}
-
-
-
-/**
- * Initialize the state associated with buffer objects
- */
-void
-_mesa_init_buffer_objects( struct gl_context *ctx )
-{
-   memset(&DummyBufferObject, 0, sizeof(DummyBufferObject));
-   _glthread_INIT_MUTEX(DummyBufferObject.Mutex);
-   DummyBufferObject.RefCount = 1000*1000*1000; /* never delete */
-
-   _mesa_reference_buffer_object(ctx, &ctx->Array.ArrayBufferObj,
-                                 ctx->Shared->NullBufferObj);
-   _mesa_reference_buffer_object(ctx, &ctx->Array.ElementArrayBufferObj,
-                                 ctx->Shared->NullBufferObj);
-
-   _mesa_reference_buffer_object(ctx, &ctx->CopyReadBuffer,
-                                 ctx->Shared->NullBufferObj);
-   _mesa_reference_buffer_object(ctx, &ctx->CopyWriteBuffer,
-                                 ctx->Shared->NullBufferObj);
-}
-
-
-void
-_mesa_free_buffer_objects( struct gl_context *ctx )
-{
-   _mesa_reference_buffer_object(ctx, &ctx->Array.ArrayBufferObj, NULL);
-   _mesa_reference_buffer_object(ctx, &ctx->Array.ElementArrayBufferObj, NULL);
-
-   _mesa_reference_buffer_object(ctx, &ctx->CopyReadBuffer, NULL);
-   _mesa_reference_buffer_object(ctx, &ctx->CopyWriteBuffer, NULL);
-}
-
-
-/**
- * Bind the specified target to buffer for the specified context.
- * Called by glBindBuffer() and other functions.
- */
-static void
-bind_buffer_object(struct gl_context *ctx, GLenum target, GLuint buffer)
-{
-   struct gl_buffer_object *oldBufObj;
-   struct gl_buffer_object *newBufObj = NULL;
-   struct gl_buffer_object **bindTarget = NULL;
-
-   bindTarget = get_buffer_target(ctx, target);
-   if (!bindTarget) {
-      _mesa_error(ctx, GL_INVALID_ENUM, "glBindBufferARB(target 0x%x)", target);
-      return;
-   }
-
-   /* Get pointer to old buffer object (to be unbound) */
-   oldBufObj = *bindTarget;
-   if (oldBufObj && oldBufObj->Name == buffer)
-      return;   /* rebinding the same buffer object- no change */
-
-   /*
-    * Get pointer to new buffer object (newBufObj)
-    */
-   if (buffer == 0) {
-      /* The spec says there's not a buffer object named 0, but we use
-       * one internally because it simplifies things.
-       */
-      newBufObj = ctx->Shared->NullBufferObj;
-   }
-   else {
-      /* non-default buffer object */
-      newBufObj = _mesa_lookup_bufferobj(ctx, buffer);
-      if (!newBufObj || newBufObj == &DummyBufferObject) {
-         /* If this is a new buffer object id, or one which was generated but
-          * never used before, allocate a buffer object now.
-          */
-         ASSERT(ctx->Driver.NewBufferObject);
-         newBufObj = ctx->Driver.NewBufferObject(ctx, buffer, target);
-         if (!newBufObj) {
-            _mesa_error(ctx, GL_OUT_OF_MEMORY, "glBindBufferARB");
-            return;
-         }
-         _mesa_HashInsert(ctx->Shared->BufferObjects, buffer, newBufObj);
-      }
-   }
-   
-   /* bind new buffer */
-   _mesa_reference_buffer_object(ctx, bindTarget, newBufObj);
-
-   /* Pass BindBuffer call to device driver */
-   if (ctx->Driver.BindBuffer)
-      ctx->Driver.BindBuffer( ctx, target, newBufObj );
-}
-
-
-/**
- * Update the default buffer objects in the given context to reference those
- * specified in the shared state and release those referencing the old 
- * shared state.
- */
-void
-_mesa_update_default_objects_buffer_objects(struct gl_context *ctx)
-{
-   /* Bind the NullBufferObj to remove references to those
-    * in the shared context hash table.
-    */
-   bind_buffer_object( ctx, GL_ARRAY_BUFFER_ARB, 0);
-   bind_buffer_object( ctx, GL_ELEMENT_ARRAY_BUFFER_ARB, 0);
-   bind_buffer_object( ctx, GL_PIXEL_PACK_BUFFER_ARB, 0);
-   bind_buffer_object( ctx, GL_PIXEL_UNPACK_BUFFER_ARB, 0);
-}
-
-
-
-/**
- * Return the gl_buffer_object for the given ID.
- * Always return NULL for ID 0.
- */
-struct gl_buffer_object *
-_mesa_lookup_bufferobj(struct gl_context *ctx, GLuint buffer)
-{
-   if (buffer == 0)
-      return NULL;
-   else
-      return (struct gl_buffer_object *)
-         _mesa_HashLookup(ctx->Shared->BufferObjects, buffer);
-}
-
-
-/**
- * If *ptr points to obj, set ptr = the Null/default buffer object.
- * This is a helper for buffer object deletion.
- * The GL spec says that deleting a buffer object causes it to get
- * unbound from all arrays in the current context.
- */
-static void
-unbind(struct gl_context *ctx,
-       struct gl_buffer_object **ptr,
-       struct gl_buffer_object *obj)
-{
-   if (*ptr == obj) {
-      _mesa_reference_buffer_object(ctx, ptr, ctx->Shared->NullBufferObj);
-   }
-}
-
-
-/**
- * Plug default/fallback buffer object functions into the device
- * driver hooks.
- */
-void
-_mesa_init_buffer_object_functions(struct dd_function_table *driver)
-{
-   /* GL_ARB_vertex/pixel_buffer_object */
-   driver->NewBufferObject = _mesa_new_buffer_object;
-   driver->DeleteBuffer = _mesa_delete_buffer_object;
-   driver->BindBuffer = NULL;
-   driver->BufferData = _mesa_buffer_data;
-   driver->BufferSubData = _mesa_buffer_subdata;
-   driver->GetBufferSubData = _mesa_buffer_get_subdata;
-   driver->MapBuffer = _mesa_buffer_map;
-   driver->UnmapBuffer = _mesa_buffer_unmap;
-
-   /* GL_ARB_map_buffer_range */
-   driver->MapBufferRange = _mesa_buffer_map_range;
-   driver->FlushMappedBufferRange = _mesa_buffer_flush_mapped_range;
-
-   /* GL_ARB_copy_buffer */
-   driver->CopyBufferSubData = _mesa_copy_buffer_subdata;
-}
-
-
-
-/**********************************************************************/
-/* API Functions                                                      */
-/**********************************************************************/
-
-void GLAPIENTRY
-_mesa_BindBufferARB(GLenum target, GLuint buffer)
-{
-   GET_CURRENT_CONTEXT(ctx);
-   ASSERT_OUTSIDE_BEGIN_END(ctx);
-
-   if (MESA_VERBOSE & VERBOSE_API)
-      _mesa_debug(ctx, "glBindBuffer(%s, %u)\n",
-                  _mesa_lookup_enum_by_nr(target), buffer);
-
-   bind_buffer_object(ctx, target, buffer);
-}
-
-
-/**
- * Delete a set of buffer objects.
- * 
- * \param n      Number of buffer objects to delete.
- * \param ids    Array of \c n buffer object IDs.
- */
-void GLAPIENTRY
-_mesa_DeleteBuffersARB(GLsizei n, const GLuint *ids)
-{
-   GET_CURRENT_CONTEXT(ctx);
-   GLsizei i;
-   ASSERT_OUTSIDE_BEGIN_END(ctx);
-
-   if (n < 0) {
-      _mesa_error(ctx, GL_INVALID_VALUE, "glDeleteBuffersARB(n)");
-      return;
-   }
-
-   _glthread_LOCK_MUTEX(ctx->Shared->Mutex);
-
-   for (i = 0; i < n; i++) {
-      struct gl_buffer_object *bufObj = _mesa_lookup_bufferobj(ctx, ids[i]);
-      if (bufObj) {
-         struct gl_array_object *arrayObj = ctx->Array.ArrayObj;
-         GLuint j;
-
-         ASSERT(bufObj->Name == ids[i] || bufObj == &DummyBufferObject);
-
-         if (_mesa_bufferobj_mapped(bufObj)) {
-            /* if mapped, unmap it now */
-            ctx->Driver.UnmapBuffer(ctx, 0, bufObj);
-            bufObj->AccessFlags = DEFAULT_ACCESS;
-            bufObj->Pointer = NULL;
-         }
-
-         /* unbind any vertex pointers bound to this buffer */
-         unbind(ctx, &arrayObj->Vertex.BufferObj, bufObj);
-         unbind(ctx, &arrayObj->Weight.BufferObj, bufObj);
-         unbind(ctx, &arrayObj->Normal.BufferObj, bufObj);
-         unbind(ctx, &arrayObj->Color.BufferObj, bufObj);
-         unbind(ctx, &arrayObj->SecondaryColor.BufferObj, bufObj);
-         unbind(ctx, &arrayObj->FogCoord.BufferObj, bufObj);
-         unbind(ctx, &arrayObj->Index.BufferObj, bufObj);
-         unbind(ctx, &arrayObj->EdgeFlag.BufferObj, bufObj);
-         for (j = 0; j < Elements(arrayObj->TexCoord); j++) {
-            unbind(ctx, &arrayObj->TexCoord[j].BufferObj, bufObj);
-         }
-         for (j = 0; j < Elements(arrayObj->VertexAttrib); j++) {
-            unbind(ctx, &arrayObj->VertexAttrib[j].BufferObj, bufObj);
-         }
-
-         if (ctx->Array.ArrayBufferObj == bufObj) {
-            _mesa_BindBufferARB( GL_ARRAY_BUFFER_ARB, 0 );
-         }
-         if (ctx->Array.ElementArrayBufferObj == bufObj) {
-            _mesa_BindBufferARB( GL_ELEMENT_ARRAY_BUFFER_ARB, 0 );
-         }
-
-         /* unbind any pixel pack/unpack pointers bound to this buffer */
-         if (ctx->Pack.BufferObj == bufObj) {
-            _mesa_BindBufferARB( GL_PIXEL_PACK_BUFFER_EXT, 0 );
-         }
-         if (ctx->Unpack.BufferObj == bufObj) {
-            _mesa_BindBufferARB( GL_PIXEL_UNPACK_BUFFER_EXT, 0 );
-         }
-
-         /* The ID is immediately freed for re-use */
-         _mesa_HashRemove(ctx->Shared->BufferObjects, ids[i]);
-         _mesa_reference_buffer_object(ctx, &bufObj, NULL);
-      }
-   }
-
-   _glthread_UNLOCK_MUTEX(ctx->Shared->Mutex);
-}
-
-
-/**
- * Generate a set of unique buffer object IDs and store them in \c buffer.
- * 
- * \param n       Number of IDs to generate.
- * \param buffer  Array of \c n locations to store the IDs.
- */
-void GLAPIENTRY
-_mesa_GenBuffersARB(GLsizei n, GLuint *buffer)
-{
-   GET_CURRENT_CONTEXT(ctx);
-   GLuint first;
-   GLint i;
-   ASSERT_OUTSIDE_BEGIN_END(ctx);
-
-   if (MESA_VERBOSE & VERBOSE_API)
-      _mesa_debug(ctx, "glGenBuffers(%d)\n", n);
-
-   if (n < 0) {
-      _mesa_error(ctx, GL_INVALID_VALUE, "glGenBuffersARB");
-      return;
-   }
-
-   if (!buffer) {
-      return;
-   }
-
-   /*
-    * This must be atomic (generation and allocation of buffer object IDs)
-    */
-   _glthread_LOCK_MUTEX(ctx->Shared->Mutex);
-
-   first = _mesa_HashFindFreeKeyBlock(ctx->Shared->BufferObjects, n);
-
-   /* Insert the ID and pointer to dummy buffer object into hash table */
-   for (i = 0; i < n; i++) {
-      _mesa_HashInsert(ctx->Shared->BufferObjects, first + i,
-                       &DummyBufferObject);
-      buffer[i] = first + i;
-   }
-
-   _glthread_UNLOCK_MUTEX(ctx->Shared->Mutex);
-}
-
-
-/**
- * Determine if ID is the name of a buffer object.
- * 
- * \param id  ID of the potential buffer object.
- * \return  \c GL_TRUE if \c id is the name of a buffer object, 
- *          \c GL_FALSE otherwise.
- */
-GLboolean GLAPIENTRY
-_mesa_IsBufferARB(GLuint id)
-{
-   struct gl_buffer_object *bufObj;
-   GET_CURRENT_CONTEXT(ctx);
-   ASSERT_OUTSIDE_BEGIN_END_WITH_RETVAL(ctx, GL_FALSE);
-
-   _glthread_LOCK_MUTEX(ctx->Shared->Mutex);
-   bufObj = _mesa_lookup_bufferobj(ctx, id);
-   _glthread_UNLOCK_MUTEX(ctx->Shared->Mutex);
-
-   return bufObj && bufObj != &DummyBufferObject;
-}
-
-
-void GLAPIENTRY
-_mesa_BufferDataARB(GLenum target, GLsizeiptrARB size,
-                    const GLvoid * data, GLenum usage)
-{
-   GET_CURRENT_CONTEXT(ctx);
-   struct gl_buffer_object *bufObj;
-   ASSERT_OUTSIDE_BEGIN_END(ctx);
-
-   if (MESA_VERBOSE & VERBOSE_API)
-      _mesa_debug(ctx, "glBufferData(%s, %ld, %p, %s)\n",
-                  _mesa_lookup_enum_by_nr(target),
-                  (long int) size, data,
-                  _mesa_lookup_enum_by_nr(usage));
-
-   if (size < 0) {
-      _mesa_error(ctx, GL_INVALID_VALUE, "glBufferDataARB(size < 0)");
-      return;
-   }
-
-   switch (usage) {
-   case GL_STREAM_DRAW_ARB:
-   case GL_STREAM_READ_ARB:
-   case GL_STREAM_COPY_ARB:
-   case GL_STATIC_DRAW_ARB:
-   case GL_STATIC_READ_ARB:
-   case GL_STATIC_COPY_ARB:
-   case GL_DYNAMIC_DRAW_ARB:
-   case GL_DYNAMIC_READ_ARB:
-   case GL_DYNAMIC_COPY_ARB:
-      /* OK */
-      break;
-   default:
-      _mesa_error(ctx, GL_INVALID_ENUM, "glBufferDataARB(usage)");
-      return;
-   }
-
-   bufObj = get_buffer(ctx, target);
-   if (!bufObj) {
-      _mesa_error(ctx, GL_INVALID_ENUM, "glBufferDataARB(target)" );
-      return;
-   }
-   if (!_mesa_is_bufferobj(bufObj)) {
-      _mesa_error(ctx, GL_INVALID_OPERATION, "glBufferDataARB(buffer 0)" );
-      return;
-   }
-   
-   if (_mesa_bufferobj_mapped(bufObj)) {
-      /* Unmap the existing buffer.  We'll replace it now.  Not an error. */
-      ctx->Driver.UnmapBuffer(ctx, target, bufObj);
-      bufObj->AccessFlags = DEFAULT_ACCESS;
-      ASSERT(bufObj->Pointer == NULL);
-   }  
-
-   FLUSH_VERTICES(ctx, _NEW_BUFFER_OBJECT);
-
-   bufObj->Written = GL_TRUE;
-
-#ifdef VBO_DEBUG
-   printf("glBufferDataARB(%u, sz %ld, from %p, usage 0x%x)\n",
-                bufObj->Name, size, data, usage);
-#endif
-
-#ifdef BOUNDS_CHECK
-   size += 100;
-#endif
-
-   ASSERT(ctx->Driver.BufferData);
-   if (!ctx->Driver.BufferData( ctx, target, size, data, usage, bufObj )) {
-      _mesa_error(ctx, GL_OUT_OF_MEMORY, "glBufferDataARB()");
-   }
-}
-
-
-void GLAPIENTRY
-_mesa_BufferSubDataARB(GLenum target, GLintptrARB offset,
-                       GLsizeiptrARB size, const GLvoid * data)
-{
-   GET_CURRENT_CONTEXT(ctx);
-   struct gl_buffer_object *bufObj;
-   ASSERT_OUTSIDE_BEGIN_END(ctx);
-
-   bufObj = buffer_object_subdata_range_good( ctx, target, offset, size,
-                                              "glBufferSubDataARB" );
-   if (!bufObj) {
-      /* error already recorded */
-      return;
-   }
-
-   if (size == 0)
-      return;
-
-   bufObj->Written = GL_TRUE;
-
-   ASSERT(ctx->Driver.BufferSubData);
-   ctx->Driver.BufferSubData( ctx, target, offset, size, data, bufObj );
-}
-
-
-void GLAPIENTRY
-_mesa_GetBufferSubDataARB(GLenum target, GLintptrARB offset,
-                          GLsizeiptrARB size, void * data)
-{
-   GET_CURRENT_CONTEXT(ctx);
-   struct gl_buffer_object *bufObj;
-   ASSERT_OUTSIDE_BEGIN_END(ctx);
-
-   bufObj = buffer_object_subdata_range_good( ctx, target, offset, size,
-                                              "glGetBufferSubDataARB" );
-   if (!bufObj) {
-      /* error already recorded */
-      return;
-   }
-
-   ASSERT(ctx->Driver.GetBufferSubData);
-   ctx->Driver.GetBufferSubData( ctx, target, offset, size, data, bufObj );
-}
-
-
-void * GLAPIENTRY
-_mesa_MapBufferARB(GLenum target, GLenum access)
-{
-   GET_CURRENT_CONTEXT(ctx);
-   struct gl_buffer_object * bufObj;
-   GLbitfield accessFlags;
-   void *map;
-
-   ASSERT_OUTSIDE_BEGIN_END_WITH_RETVAL(ctx, NULL);
-
-   switch (access) {
-   case GL_READ_ONLY_ARB:
-      accessFlags = GL_MAP_READ_BIT;
-      break;
-   case GL_WRITE_ONLY_ARB:
-      accessFlags = GL_MAP_WRITE_BIT;
-      break;
-   case GL_READ_WRITE_ARB:
-      accessFlags = GL_MAP_READ_BIT | GL_MAP_WRITE_BIT;
-      break;
-   default:
-      _mesa_error(ctx, GL_INVALID_ENUM, "glMapBufferARB(access)");
-      return NULL;
-   }
-
-   bufObj = get_buffer(ctx, target);
-   if (!bufObj) {
-      _mesa_error(ctx, GL_INVALID_ENUM, "glMapBufferARB(target)" );
-      return NULL;
-   }
-   if (!_mesa_is_bufferobj(bufObj)) {
-      _mesa_error(ctx, GL_INVALID_OPERATION, "glMapBufferARB(buffer 0)" );
-      return NULL;
-   }
-   if (_mesa_bufferobj_mapped(bufObj)) {
-      _mesa_error(ctx, GL_INVALID_OPERATION, "glMapBufferARB(already mapped)");
-      return NULL;
-   }
-
-   ASSERT(ctx->Driver.MapBuffer);
-   map = ctx->Driver.MapBuffer( ctx, target, access, bufObj );
-   if (!map) {
-      _mesa_error(ctx, GL_OUT_OF_MEMORY, "glMapBufferARB(map failed)");
-      return NULL;
-   }
-   else {
-      /* The driver callback should have set these fields.
-       * This is important because other modules (like VBO) might call
-       * the driver function directly.
-       */
-      ASSERT(bufObj->Pointer == map);
-      ASSERT(bufObj->Length == bufObj->Size);
-      ASSERT(bufObj->Offset == 0);
-      bufObj->AccessFlags = accessFlags;
-   }
-
-   if (access == GL_WRITE_ONLY_ARB || access == GL_READ_WRITE_ARB)
-      bufObj->Written = GL_TRUE;
-
-#ifdef VBO_DEBUG
-   printf("glMapBufferARB(%u, sz %ld, access 0x%x)\n",
-	  bufObj->Name, bufObj->Size, access);
-   if (access == GL_WRITE_ONLY_ARB) {
-      GLuint i;
-      GLubyte *b = (GLubyte *) bufObj->Pointer;
-      for (i = 0; i < bufObj->Size; i++)
-         b[i] = i & 0xff;
-   }
-#endif
-
-#ifdef BOUNDS_CHECK
-   {
-      GLubyte *buf = (GLubyte *) bufObj->Pointer;
-      GLuint i;
-      /* buffer is 100 bytes larger than requested, fill with magic value */
-      for (i = 0; i < 100; i++) {
-         buf[bufObj->Size - i - 1] = 123;
-      }
-   }
-#endif
-
-   return bufObj->Pointer;
-}
-
-
-GLboolean GLAPIENTRY
-_mesa_UnmapBufferARB(GLenum target)
-{
-   GET_CURRENT_CONTEXT(ctx);
-   struct gl_buffer_object *bufObj;
-   GLboolean status = GL_TRUE;
-   ASSERT_OUTSIDE_BEGIN_END_WITH_RETVAL(ctx, GL_FALSE);
-
-   bufObj = get_buffer(ctx, target);
-   if (!bufObj) {
-      _mesa_error(ctx, GL_INVALID_ENUM, "glUnmapBufferARB(target)" );
-      return GL_FALSE;
-   }
-   if (!_mesa_is_bufferobj(bufObj)) {
-      _mesa_error(ctx, GL_INVALID_OPERATION, "glUnmapBufferARB" );
-      return GL_FALSE;
-   }
-   if (!_mesa_bufferobj_mapped(bufObj)) {
-      _mesa_error(ctx, GL_INVALID_OPERATION, "glUnmapBufferARB");
-      return GL_FALSE;
-   }
-
-#ifdef BOUNDS_CHECK
-   if (bufObj->Access != GL_READ_ONLY_ARB) {
-      GLubyte *buf = (GLubyte *) bufObj->Pointer;
-      GLuint i;
-      /* check that last 100 bytes are still = magic value */
-      for (i = 0; i < 100; i++) {
-         GLuint pos = bufObj->Size - i - 1;
-         if (buf[pos] != 123) {
-            _mesa_warning(ctx, "Out of bounds buffer object write detected"
-                          " at position %d (value = %u)\n",
-                          pos, buf[pos]);
-         }
-      }
-   }
-#endif
-
-#ifdef VBO_DEBUG
-   if (bufObj->AccessFlags & GL_MAP_WRITE_BIT) {
-      GLuint i, unchanged = 0;
-      GLubyte *b = (GLubyte *) bufObj->Pointer;
-      GLint pos = -1;
-      /* check which bytes changed */
-      for (i = 0; i < bufObj->Size - 1; i++) {
-         if (b[i] == (i & 0xff) && b[i+1] == ((i+1) & 0xff)) {
-            unchanged++;
-            if (pos == -1)
-               pos = i;
-         }
-      }
-      if (unchanged) {
-         printf("glUnmapBufferARB(%u): %u of %ld unchanged, starting at %d\n",
-                      bufObj->Name, unchanged, bufObj->Size, pos);
-      }
-   }
-#endif
-
-   status = ctx->Driver.UnmapBuffer( ctx, target, bufObj );
-   bufObj->AccessFlags = DEFAULT_ACCESS;
-   ASSERT(bufObj->Pointer == NULL);
-   ASSERT(bufObj->Offset == 0);
-   ASSERT(bufObj->Length == 0);
-
-   return status;
-}
-
-
-void GLAPIENTRY
-_mesa_GetBufferParameterivARB(GLenum target, GLenum pname, GLint *params)
-{
-   GET_CURRENT_CONTEXT(ctx);
-   struct gl_buffer_object *bufObj;
-   ASSERT_OUTSIDE_BEGIN_END(ctx);
-
-   bufObj = get_buffer(ctx, target);
-   if (!bufObj) {
-      _mesa_error(ctx, GL_INVALID_ENUM, "glGetBufferParameterivARB(target)" );
-      return;
-   }
-   if (!_mesa_is_bufferobj(bufObj)) {
-      _mesa_error(ctx, GL_INVALID_OPERATION, "glGetBufferParameterivARB" );
-      return;
-   }
-
-   switch (pname) {
-   case GL_BUFFER_SIZE_ARB:
-      *params = (GLint) bufObj->Size;
-      return;
-   case GL_BUFFER_USAGE_ARB:
-      *params = bufObj->Usage;
-      return;
-   case GL_BUFFER_ACCESS_ARB:
-      *params = simplified_access_mode(bufObj->AccessFlags);
-      return;
-   case GL_BUFFER_MAPPED_ARB:
-      *params = _mesa_bufferobj_mapped(bufObj);
-      return;
-   case GL_BUFFER_ACCESS_FLAGS:
-      if (ctx->VersionMajor < 3)
-         goto invalid_pname;
-      *params = bufObj->AccessFlags;
-      return;
-   case GL_BUFFER_MAP_OFFSET:
-      if (ctx->VersionMajor < 3)
-         goto invalid_pname;
-      *params = (GLint) bufObj->Offset;
-      return;
-   case GL_BUFFER_MAP_LENGTH:
-      if (ctx->VersionMajor < 3)
-         goto invalid_pname;
-      *params = (GLint) bufObj->Length;
-      return;
-   default:
-      ; /* fall-through */
-   }
-
-invalid_pname:
-   _mesa_error(ctx, GL_INVALID_ENUM, "glGetBufferParameterivARB(pname=%s)",
-               _mesa_lookup_enum_by_nr(pname));
-}
-
-
-/**
- * New in GL 3.2
- * This is pretty much a duplicate of GetBufferParameteriv() but the
- * GL_BUFFER_SIZE_ARB attribute will be 64-bits on a 64-bit system.
- */
-void GLAPIENTRY
-_mesa_GetBufferParameteri64v(GLenum target, GLenum pname, GLint64 *params)
-{
-   GET_CURRENT_CONTEXT(ctx);
-   struct gl_buffer_object *bufObj;
-   ASSERT_OUTSIDE_BEGIN_END(ctx);
-
-   bufObj = get_buffer(ctx, target);
-   if (!bufObj) {
-      _mesa_error(ctx, GL_INVALID_ENUM, "glGetBufferParameteri64v(target)" );
-      return;
-   }
-   if (!_mesa_is_bufferobj(bufObj)) {
-      _mesa_error(ctx, GL_INVALID_OPERATION, "glGetBufferParameteri64v" );
-      return;
-   }
-
-   switch (pname) {
-   case GL_BUFFER_SIZE_ARB:
-      *params = bufObj->Size;
-      return;
-   case GL_BUFFER_USAGE_ARB:
-      *params = bufObj->Usage;
-      return;
-   case GL_BUFFER_ACCESS_ARB:
-      *params = simplified_access_mode(bufObj->AccessFlags);
-      return;
-   case GL_BUFFER_ACCESS_FLAGS:
-      if (ctx->VersionMajor < 3)
-         goto invalid_pname;
-      *params = bufObj->AccessFlags;
-      return;
-   case GL_BUFFER_MAPPED_ARB:
-      *params = _mesa_bufferobj_mapped(bufObj);
-      return;
-   case GL_BUFFER_MAP_OFFSET:
-      if (ctx->VersionMajor < 3)
-         goto invalid_pname;
-      *params = bufObj->Offset;
-      return;
-   case GL_BUFFER_MAP_LENGTH:
-      if (ctx->VersionMajor < 3)
-         goto invalid_pname;
-      *params = bufObj->Length;
-      return;
-   default:
-      ; /* fall-through */
-   }
-
-invalid_pname:
-   _mesa_error(ctx, GL_INVALID_ENUM, "glGetBufferParameteri64v(pname=%s)",
-               _mesa_lookup_enum_by_nr(pname));
-}
-
-
-void GLAPIENTRY
-_mesa_GetBufferPointervARB(GLenum target, GLenum pname, GLvoid **params)
-{
-   GET_CURRENT_CONTEXT(ctx);
-   struct gl_buffer_object * bufObj;
-   ASSERT_OUTSIDE_BEGIN_END(ctx);
-
-   if (pname != GL_BUFFER_MAP_POINTER_ARB) {
-      _mesa_error(ctx, GL_INVALID_ENUM, "glGetBufferPointervARB(pname)");
-      return;
-   }
-
-   bufObj = get_buffer(ctx, target);
-   if (!bufObj) {
-      _mesa_error(ctx, GL_INVALID_ENUM, "glGetBufferPointervARB(target)" );
-      return;
-   }
-   if (!_mesa_is_bufferobj(bufObj)) {
-      _mesa_error(ctx, GL_INVALID_OPERATION, "glGetBufferPointervARB" );
-      return;
-   }
-
-   *params = bufObj->Pointer;
-}
-
-
-void GLAPIENTRY
-_mesa_CopyBufferSubData(GLenum readTarget, GLenum writeTarget,
-                        GLintptr readOffset, GLintptr writeOffset,
-                        GLsizeiptr size)
-{
-   GET_CURRENT_CONTEXT(ctx);
-   struct gl_buffer_object *src, *dst;
-   ASSERT_OUTSIDE_BEGIN_END(ctx);
-
-   src = get_buffer(ctx, readTarget);
-   if (!src || !_mesa_is_bufferobj(src)) {
-      _mesa_error(ctx, GL_INVALID_ENUM,
-                  "glCopyBuffserSubData(readTarget = 0x%x)", readTarget);
-      return;
-   }
-
-   dst = get_buffer(ctx, writeTarget);
-   if (!dst || !_mesa_is_bufferobj(dst)) {
-      _mesa_error(ctx, GL_INVALID_ENUM,
-                  "glCopyBuffserSubData(writeTarget = 0x%x)", writeTarget);
-      return;
-   }
-
-   if (_mesa_bufferobj_mapped(src)) {
-      _mesa_error(ctx, GL_INVALID_OPERATION,
-                  "glCopyBuffserSubData(readBuffer is mapped)");
-      return;
-   }
-
-   if (_mesa_bufferobj_mapped(dst)) {
-      _mesa_error(ctx, GL_INVALID_OPERATION,
-                  "glCopyBuffserSubData(writeBuffer is mapped)");
-      return;
-   }
-
-   if (readOffset < 0) {
-      _mesa_error(ctx, GL_INVALID_VALUE,
-                  "glCopyBuffserSubData(readOffset = %d)", (int) readOffset);
-      return;
-   }
-
-   if (writeOffset < 0) {
-      _mesa_error(ctx, GL_INVALID_VALUE,
-                  "glCopyBuffserSubData(writeOffset = %d)", (int) writeOffset);
-      return;
-   }
-
-   if (readOffset + size > src->Size) {
-      _mesa_error(ctx, GL_INVALID_VALUE,
-                  "glCopyBuffserSubData(readOffset + size = %d)",
-                  (int) (readOffset + size));
-      return;
-   }
-
-   if (writeOffset + size > dst->Size) {
-      _mesa_error(ctx, GL_INVALID_VALUE,
-                  "glCopyBuffserSubData(writeOffset + size = %d)",
-                  (int) (writeOffset + size));
-      return;
-   }
-
-   if (src == dst) {
-      if (readOffset + size <= writeOffset) {
-         /* OK */
-      }
-      else if (writeOffset + size <= readOffset) {
-         /* OK */
-      }
-      else {
-         /* overlapping src/dst is illegal */
-         _mesa_error(ctx, GL_INVALID_VALUE,
-                     "glCopyBuffserSubData(overlapping src/dst)");
-         return;
-      }
-   }
-
-   ctx->Driver.CopyBufferSubData(ctx, src, dst, readOffset, writeOffset, size);
-}
-
-
-/**
- * See GL_ARB_map_buffer_range spec
- */
-void * GLAPIENTRY
-_mesa_MapBufferRange(GLenum target, GLintptr offset, GLsizeiptr length,
-                     GLbitfield access)
-{
-   GET_CURRENT_CONTEXT(ctx);
-   struct gl_buffer_object *bufObj;
-   void *map;
-
-   ASSERT_OUTSIDE_BEGIN_END_WITH_RETVAL(ctx, NULL);
-
-   if (!ctx->Extensions.ARB_map_buffer_range) {
-      _mesa_error(ctx, GL_INVALID_OPERATION,
-                  "glMapBufferRange(extension not supported)");
-      return NULL;
-   }
-
-   if (offset < 0) {
-      _mesa_error(ctx, GL_INVALID_VALUE,
-                  "glMapBufferRange(offset = %ld)", (long)offset);
-      return NULL;
-   }
-
-   if (length < 0) {
-      _mesa_error(ctx, GL_INVALID_VALUE,
-                  "glMapBufferRange(length = %ld)", (long)length);
-      return NULL;
-   }
-
-   if ((access & (GL_MAP_READ_BIT | GL_MAP_WRITE_BIT)) == 0) {
-      _mesa_error(ctx, GL_INVALID_OPERATION,
-                  "glMapBufferRange(access indicates neither read or write)");
-      return NULL;
-   }
-
-   if (access & GL_MAP_READ_BIT) {
-      if ((access & GL_MAP_INVALIDATE_RANGE_BIT) ||
-          (access & GL_MAP_INVALIDATE_BUFFER_BIT) ||
-          (access & GL_MAP_UNSYNCHRONIZED_BIT)) {
-         _mesa_error(ctx, GL_INVALID_OPERATION,
-                     "glMapBufferRange(invalid access flags)");
-         return NULL;
-      }
-   }
-
-   if ((access & GL_MAP_FLUSH_EXPLICIT_BIT) &&
-       ((access & GL_MAP_WRITE_BIT) == 0)) {
-      _mesa_error(ctx, GL_INVALID_OPERATION,
-                  "glMapBufferRange(invalid access flags)");
-      return NULL;
-   }
-
-   bufObj = get_buffer(ctx, target);
-   if (!bufObj || !_mesa_is_bufferobj(bufObj)) {
-      _mesa_error(ctx, GL_INVALID_ENUM,
-                  "glMapBufferRange(target = 0x%x)", target);
-      return NULL;
-   }
-
-   if (offset + length > bufObj->Size) {
-      _mesa_error(ctx, GL_INVALID_VALUE,
-                  "glMapBufferRange(offset + length > size)");
-      return NULL;
-   }
-
-   if (_mesa_bufferobj_mapped(bufObj)) {
-      _mesa_error(ctx, GL_INVALID_OPERATION,
-                  "glMapBufferRange(buffer already mapped)");
-      return NULL;
-   }
-      
-   ASSERT(ctx->Driver.MapBufferRange);
-   map = ctx->Driver.MapBufferRange(ctx, target, offset, length,
-                                    access, bufObj);
-   if (!map) {
-      _mesa_error(ctx, GL_OUT_OF_MEMORY, "glMapBufferARB(map failed)");
-   }
-   else {
-      /* The driver callback should have set all these fields.
-       * This is important because other modules (like VBO) might call
-       * the driver function directly.
-       */
-      ASSERT(bufObj->Pointer == map);
-      ASSERT(bufObj->Length == length);
-      ASSERT(bufObj->Offset == offset);
-      ASSERT(bufObj->AccessFlags == access);
-   }
-
-   return map;
-}
-
-
-/**
- * See GL_ARB_map_buffer_range spec
- */
-void GLAPIENTRY
-_mesa_FlushMappedBufferRange(GLenum target, GLintptr offset, GLsizeiptr length)
-{
-   GET_CURRENT_CONTEXT(ctx);
-   struct gl_buffer_object *bufObj;
-   ASSERT_OUTSIDE_BEGIN_END(ctx);
-
-   if (!ctx->Extensions.ARB_map_buffer_range) {
-      _mesa_error(ctx, GL_INVALID_OPERATION,
-                  "glMapBufferRange(extension not supported)");
-      return;
-   }
-
-   if (offset < 0) {
-      _mesa_error(ctx, GL_INVALID_VALUE,
-                  "glMapBufferRange(offset = %ld)", (long)offset);
-      return;
-   }
-
-   if (length < 0) {
-      _mesa_error(ctx, GL_INVALID_VALUE,
-                  "glMapBufferRange(length = %ld)", (long)length);
-      return;
-   }
-
-   bufObj = get_buffer(ctx, target);
-   if (!bufObj) {
-      _mesa_error(ctx, GL_INVALID_ENUM,
-                  "glMapBufferRange(target = 0x%x)", target);
-      return;
-   }
-
-   if (!_mesa_is_bufferobj(bufObj)) {
-      _mesa_error(ctx, GL_INVALID_OPERATION,
-                  "glMapBufferRange(current buffer is 0)");
-      return;
-   }
-
-   if (!_mesa_bufferobj_mapped(bufObj)) {
-      /* buffer is not mapped */
-      _mesa_error(ctx, GL_INVALID_OPERATION,
-                  "glMapBufferRange(buffer is not mapped)");
-      return;
-   }
-
-   if ((bufObj->AccessFlags & GL_MAP_FLUSH_EXPLICIT_BIT) == 0) {
-      _mesa_error(ctx, GL_INVALID_OPERATION,
-                  "glMapBufferRange(GL_MAP_FLUSH_EXPLICIT_BIT not set)");
-      return;
-   }
-
-   if (offset + length > bufObj->Length) {
-      _mesa_error(ctx, GL_INVALID_VALUE,
-		  "glMapBufferRange(offset %ld + length %ld > mapped length %ld)",
-		  (long)offset, (long)length, (long)bufObj->Length);
-      return;
-   }
-
-   ASSERT(bufObj->AccessFlags & GL_MAP_WRITE_BIT);
-
-   if (ctx->Driver.FlushMappedBufferRange)
-      ctx->Driver.FlushMappedBufferRange(ctx, target, offset, length, bufObj);
-}
-
-
-#if FEATURE_APPLE_object_purgeable
-static GLenum
-_mesa_BufferObjectPurgeable(struct gl_context *ctx, GLuint name, GLenum option)
-{
-   struct gl_buffer_object *bufObj;
-   GLenum retval;
-
-   bufObj = _mesa_lookup_bufferobj(ctx, name);
-   if (!bufObj) {
-      _mesa_error(ctx, GL_INVALID_VALUE,
-                  "glObjectPurgeable(name = 0x%x)", name);
-      return 0;
-   }
-   if (!_mesa_is_bufferobj(bufObj)) {
-      _mesa_error(ctx, GL_INVALID_OPERATION, "glObjectPurgeable(buffer 0)" );
-      return 0;
-   }
-
-   if (bufObj->Purgeable) {
-      _mesa_error(ctx, GL_INVALID_OPERATION,
-                  "glObjectPurgeable(name = 0x%x) is already purgeable", name);
-      return GL_VOLATILE_APPLE;
-   }
-
-   bufObj->Purgeable = GL_TRUE;
-
-   retval = GL_VOLATILE_APPLE;
-   if (ctx->Driver.BufferObjectPurgeable)
-      retval = ctx->Driver.BufferObjectPurgeable(ctx, bufObj, option);
-
-   return retval;
-}
-
-
-static GLenum
-_mesa_RenderObjectPurgeable(struct gl_context *ctx, GLuint name, GLenum option)
-{
-   struct gl_renderbuffer *bufObj;
-   GLenum retval;
-
-   bufObj = _mesa_lookup_renderbuffer(ctx, name);
-   if (!bufObj) {
-      _mesa_error(ctx, GL_INVALID_VALUE,
-                  "glObjectUnpurgeable(name = 0x%x)", name);
-      return 0;
-   }
-
-   if (bufObj->Purgeable) {
-      _mesa_error(ctx, GL_INVALID_OPERATION,
-                  "glObjectPurgeable(name = 0x%x) is already purgeable", name);
-      return GL_VOLATILE_APPLE;
-   }
-
-   bufObj->Purgeable = GL_TRUE;
-
-   retval = GL_VOLATILE_APPLE;
-   if (ctx->Driver.RenderObjectPurgeable)
-      retval = ctx->Driver.RenderObjectPurgeable(ctx, bufObj, option);
-
-   return retval;
-}
-
-
-static GLenum
-_mesa_TextureObjectPurgeable(struct gl_context *ctx, GLuint name, GLenum option)
-{
-   struct gl_texture_object *bufObj;
-   GLenum retval;
-
-   bufObj = _mesa_lookup_texture(ctx, name);
-   if (!bufObj) {
-      _mesa_error(ctx, GL_INVALID_VALUE,
-                  "glObjectPurgeable(name = 0x%x)", name);
-      return 0;
-   }
-
-   if (bufObj->Purgeable) {
-      _mesa_error(ctx, GL_INVALID_OPERATION,
-                  "glObjectPurgeable(name = 0x%x) is already purgeable", name);
-      return GL_VOLATILE_APPLE;
-   }
-
-   bufObj->Purgeable = GL_TRUE;
-
-   retval = GL_VOLATILE_APPLE;
-   if (ctx->Driver.TextureObjectPurgeable)
-      retval = ctx->Driver.TextureObjectPurgeable(ctx, bufObj, option);
-
-   return retval;
-}
-
-
-GLenum GLAPIENTRY
-_mesa_ObjectPurgeableAPPLE(GLenum objectType, GLuint name, GLenum option)
-{
-   GLenum retval;
-
-   GET_CURRENT_CONTEXT(ctx);
-   ASSERT_OUTSIDE_BEGIN_END_WITH_RETVAL(ctx, 0);
-
-   if (name == 0) {
-      _mesa_error(ctx, GL_INVALID_VALUE,
-                  "glObjectPurgeable(name = 0x%x)", name);
-      return 0;
-   }
-
-   switch (option) {
-   case GL_VOLATILE_APPLE:
-   case GL_RELEASED_APPLE:
-      /* legal */
-      break;
-   default:
-      _mesa_error(ctx, GL_INVALID_ENUM,
-                  "glObjectPurgeable(name = 0x%x) invalid option: %d",
-                  name, option);
-      return 0;
-   }
-
-   switch (objectType) {
-   case GL_TEXTURE:
-      retval = _mesa_TextureObjectPurgeable (ctx, name, option);
-      break;
-   case GL_RENDERBUFFER_EXT:
-      retval = _mesa_RenderObjectPurgeable (ctx, name, option);
-      break;
-   case GL_BUFFER_OBJECT_APPLE:
-      retval = _mesa_BufferObjectPurgeable (ctx, name, option);
-      break;
-   default:
-      _mesa_error(ctx, GL_INVALID_ENUM,
-                  "glObjectPurgeable(name = 0x%x) invalid type: %d",
-                  name, objectType);
-      return 0;
-   }
-
-   /* In strict conformance to the spec, we must only return VOLATILE when
-    * when passed the VOLATILE option. Madness.
-    *
-    * XXX First fix the spec, then fix me.
-    */
-   return option == GL_VOLATILE_APPLE ? GL_VOLATILE_APPLE : retval;
-}
-
-
-static GLenum
-_mesa_BufferObjectUnpurgeable(struct gl_context *ctx, GLuint name, GLenum option)
-{
-   struct gl_buffer_object *bufObj;
-   GLenum retval;
-
-   bufObj = _mesa_lookup_bufferobj(ctx, name);
-   if (!bufObj) {
-      _mesa_error(ctx, GL_INVALID_VALUE,
-                  "glObjectUnpurgeable(name = 0x%x)", name);
-      return 0;
-   }
-
-   if (! bufObj->Purgeable) {
-      _mesa_error(ctx, GL_INVALID_OPERATION,
-                  "glObjectUnpurgeable(name = 0x%x) object is "
-                  " already \"unpurged\"", name);
-      return 0;
-   }
-
-   bufObj->Purgeable = GL_FALSE;
-
-   retval = option;
-   if (ctx->Driver.BufferObjectUnpurgeable)
-      retval = ctx->Driver.BufferObjectUnpurgeable(ctx, bufObj, option);
-
-   return retval;
-}
-
-
-static GLenum
-_mesa_RenderObjectUnpurgeable(struct gl_context *ctx, GLuint name, GLenum option)
-{
-   struct gl_renderbuffer *bufObj;
-   GLenum retval;
-
-   bufObj = _mesa_lookup_renderbuffer(ctx, name);
-   if (!bufObj) {
-      _mesa_error(ctx, GL_INVALID_VALUE,
-                  "glObjectUnpurgeable(name = 0x%x)", name);
-      return 0;
-   }
-
-   if (! bufObj->Purgeable) {
-      _mesa_error(ctx, GL_INVALID_OPERATION,
-                  "glObjectUnpurgeable(name = 0x%x) object is "
-                  " already \"unpurged\"", name);
-      return 0;
-   }
-
-   bufObj->Purgeable = GL_FALSE;
-
-   retval = option;
-   if (ctx->Driver.RenderObjectUnpurgeable)
-      retval = ctx->Driver.RenderObjectUnpurgeable(ctx, bufObj, option);
-
-   return retval;
-}
-
-
-static GLenum
-_mesa_TextureObjectUnpurgeable(struct gl_context *ctx, GLuint name, GLenum option)
-{
-   struct gl_texture_object *bufObj;
-   GLenum retval;
-
-   bufObj = _mesa_lookup_texture(ctx, name);
-   if (!bufObj) {
-      _mesa_error(ctx, GL_INVALID_VALUE,
-                  "glObjectUnpurgeable(name = 0x%x)", name);
-      return 0;
-   }
-
-   if (! bufObj->Purgeable) {
-      _mesa_error(ctx, GL_INVALID_OPERATION,
-                  "glObjectUnpurgeable(name = 0x%x) object is"
-                  " already \"unpurged\"", name);
-      return 0;
-   }
-
-   bufObj->Purgeable = GL_FALSE;
-
-   retval = option;
-   if (ctx->Driver.TextureObjectUnpurgeable)
-      retval = ctx->Driver.TextureObjectUnpurgeable(ctx, bufObj, option);
-
-   return retval;
-}
-
-
-GLenum GLAPIENTRY
-_mesa_ObjectUnpurgeableAPPLE(GLenum objectType, GLuint name, GLenum option)
-{
-   GET_CURRENT_CONTEXT(ctx);
-   ASSERT_OUTSIDE_BEGIN_END_WITH_RETVAL(ctx, 0);
-
-   if (name == 0) {
-      _mesa_error(ctx, GL_INVALID_VALUE,
-                  "glObjectUnpurgeable(name = 0x%x)", name);
-      return 0;
-   }
-
-   switch (option) {
-   case GL_RETAINED_APPLE:
-   case GL_UNDEFINED_APPLE:
-      /* legal */
-      break;
-   default:
-      _mesa_error(ctx, GL_INVALID_ENUM,
-                  "glObjectUnpurgeable(name = 0x%x) invalid option: %d",
-                  name, option);
-      return 0;
-   }
-
-   switch (objectType) {
-   case GL_BUFFER_OBJECT_APPLE:
-      return _mesa_BufferObjectUnpurgeable(ctx, name, option);
-   case GL_TEXTURE:
-      return _mesa_TextureObjectUnpurgeable(ctx, name, option);
-   case GL_RENDERBUFFER_EXT:
-      return _mesa_RenderObjectUnpurgeable(ctx, name, option);
-   default:
-      _mesa_error(ctx, GL_INVALID_ENUM,
-                  "glObjectUnpurgeable(name = 0x%x) invalid type: %d",
-                  name, objectType);
-      return 0;
-   }
-}
-
-
-static void
-_mesa_GetBufferObjectParameterivAPPLE(struct gl_context *ctx, GLuint name,
-                                      GLenum pname, GLint* params)
-{
-   struct gl_buffer_object *bufObj;
-
-   bufObj = _mesa_lookup_bufferobj(ctx, name);
-   if (!bufObj) {
-      _mesa_error(ctx, GL_INVALID_VALUE,
-                  "glGetObjectParameteriv(name = 0x%x) invalid object", name);
-      return;
-   }
-
-   switch (pname) {
-   case GL_PURGEABLE_APPLE:
-      *params = bufObj->Purgeable;
-      break;
-   default:
-      _mesa_error(ctx, GL_INVALID_ENUM,
-                  "glGetObjectParameteriv(name = 0x%x) invalid enum: %d",
-                  name, pname);
-      break;
-   }
-}
-
-
-static void
-_mesa_GetRenderObjectParameterivAPPLE(struct gl_context *ctx, GLuint name,
-                                      GLenum pname, GLint* params)
-{
-   struct gl_renderbuffer *bufObj;
-
-   bufObj = _mesa_lookup_renderbuffer(ctx, name);
-   if (!bufObj) {
-      _mesa_error(ctx, GL_INVALID_VALUE,
-                  "glObjectUnpurgeable(name = 0x%x)", name);
-      return;
-   }
-
-   switch (pname) {
-   case GL_PURGEABLE_APPLE:
-      *params = bufObj->Purgeable;
-      break;
-   default:
-      _mesa_error(ctx, GL_INVALID_ENUM,
-                  "glGetObjectParameteriv(name = 0x%x) invalid enum: %d",
-                  name, pname);
-      break;
-   }
-}
-
-
-static void
-_mesa_GetTextureObjectParameterivAPPLE(struct gl_context *ctx, GLuint name,
-                                       GLenum pname, GLint* params)
-{
-   struct gl_texture_object *bufObj;
-
-   bufObj = _mesa_lookup_texture(ctx, name);
-   if (!bufObj) {
-      _mesa_error(ctx, GL_INVALID_VALUE,
-                  "glObjectUnpurgeable(name = 0x%x)", name);
-      return;
-   }
-
-   switch (pname) {
-   case GL_PURGEABLE_APPLE:
-      *params = bufObj->Purgeable;
-      break;
-   default:
-      _mesa_error(ctx, GL_INVALID_ENUM,
-                  "glGetObjectParameteriv(name = 0x%x) invalid enum: %d",
-                  name, pname);
-      break;
-   }
-}
-
-
-void GLAPIENTRY
-_mesa_GetObjectParameterivAPPLE(GLenum objectType, GLuint name, GLenum pname,
-                                GLint* params)
-{
-   GET_CURRENT_CONTEXT(ctx);
-
-   if (name == 0) {
-      _mesa_error(ctx, GL_INVALID_VALUE,
-                  "glGetObjectParameteriv(name = 0x%x)", name);
-      return;
-   }
-
-   switch (objectType) {
-   case GL_TEXTURE:
-      _mesa_GetTextureObjectParameterivAPPLE (ctx, name, pname, params);
-      break;
-   case GL_BUFFER_OBJECT_APPLE:
-      _mesa_GetBufferObjectParameterivAPPLE (ctx, name, pname, params);
-      break;
-   case GL_RENDERBUFFER_EXT:
-      _mesa_GetRenderObjectParameterivAPPLE (ctx, name, pname, params);
-      break;
-   default:
-      _mesa_error(ctx, GL_INVALID_ENUM,
-                  "glGetObjectParameteriv(name = 0x%x) invalid type: %d",
-                  name, objectType);
-   }
-}
-
-#endif /* FEATURE_APPLE_object_purgeable */
+/*

+ * Mesa 3-D graphics library

+ * Version:  7.6

+ *

+ * 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 bufferobj.c

+ * \brief Functions for the GL_ARB_vertex/pixel_buffer_object extensions.

+ * \author Brian Paul, Ian Romanick

+ */

+

+

+#include "glheader.h"

+#include "enums.h"

+#include "hash.h"

+#include "imports.h"

+#include "image.h"

+#include "context.h"

+#include "bufferobj.h"

+#include "fbobject.h"

+#include "mfeatures.h"

+#include "mtypes.h"

+#include "texobj.h"

+

+

+/* Debug flags */

+/*#define VBO_DEBUG*/

+/*#define BOUNDS_CHECK*/

+

+

+#if FEATURE_OES_mapbuffer

+#define DEFAULT_ACCESS GL_MAP_WRITE_BIT

+#else

+#define DEFAULT_ACCESS (GL_MAP_READ_BIT | GL_MAP_WRITE_BIT)

+#endif

+

+

+/**

+ * Used as a placeholder for buffer objects between glGenBuffers() and

+ * glBindBuffer() so that glIsBuffer() can work correctly.

+ */

+static struct gl_buffer_object DummyBufferObject;

+

+

+/**

+ * Return pointer to address of a buffer object target.

+ * \param ctx  the GL context

+ * \param target  the buffer object target to be retrieved.

+ * \return   pointer to pointer to the buffer object bound to \c target in the

+ *           specified context or \c NULL if \c target is invalid.

+ */

+static INLINE struct gl_buffer_object **

+get_buffer_target(struct gl_context *ctx, GLenum target)

+{

+   switch (target) {

+   case GL_ARRAY_BUFFER_ARB:

+      return &ctx->Array.ArrayBufferObj;

+   case GL_ELEMENT_ARRAY_BUFFER_ARB:

+      return &ctx->Array.ElementArrayBufferObj;

+   case GL_PIXEL_PACK_BUFFER_EXT:

+      return &ctx->Pack.BufferObj;

+   case GL_PIXEL_UNPACK_BUFFER_EXT:

+      return &ctx->Unpack.BufferObj;

+   case GL_COPY_READ_BUFFER:

+      return &ctx->CopyReadBuffer;

+   case GL_COPY_WRITE_BUFFER:

+      return &ctx->CopyWriteBuffer;

+#if FEATURE_EXT_transform_feedback

+   case GL_TRANSFORM_FEEDBACK_BUFFER:

+      if (ctx->Extensions.EXT_transform_feedback) {

+         return &ctx->TransformFeedback.CurrentBuffer;

+      }

+      break;

+#endif

+   default:

+      return NULL;

+   }

+   return NULL;

+}

+

+

+/**

+ * Get the buffer object bound to the specified target in a GL context.

+ * \param ctx  the GL context

+ * \param target  the buffer object target to be retrieved.

+ * \return   pointer to the buffer object bound to \c target in the

+ *           specified context or \c NULL if \c target is invalid.

+ */

+static INLINE struct gl_buffer_object *

+get_buffer(struct gl_context *ctx, GLenum target)

+{

+   struct gl_buffer_object **bufObj = get_buffer_target(ctx, target);

+   if (bufObj)

+      return *bufObj;

+   return NULL;

+}

+

+

+/**

+ * Convert a GLbitfield describing the mapped buffer access flags

+ * into one of GL_READ_WRITE, GL_READ_ONLY, or GL_WRITE_ONLY.

+ */

+static GLenum

+simplified_access_mode(GLbitfield access)

+{

+   const GLbitfield rwFlags = GL_MAP_READ_BIT | GL_MAP_WRITE_BIT;

+   if ((access & rwFlags) == rwFlags)

+      return GL_READ_WRITE;

+   if ((access & GL_MAP_READ_BIT) == GL_MAP_READ_BIT)

+      return GL_READ_ONLY;

+   if ((access & GL_MAP_WRITE_BIT) == GL_MAP_WRITE_BIT)

+      return GL_WRITE_ONLY;

+   return GL_READ_WRITE; /* this should never happen, but no big deal */

+}

+

+

+/**

+ * Tests the subdata range parameters and sets the GL error code for

+ * \c glBufferSubDataARB and \c glGetBufferSubDataARB.

+ *

+ * \param ctx     GL context.

+ * \param target  Buffer object target on which to operate.

+ * \param offset  Offset of the first byte of the subdata range.

+ * \param size    Size, in bytes, of the subdata range.

+ * \param caller  Name of calling function for recording errors.

+ * \return   A pointer to the buffer object bound to \c target in the

+ *           specified context or \c NULL if any of the parameter or state

+ *           conditions for \c glBufferSubDataARB or \c glGetBufferSubDataARB

+ *           are invalid.

+ *

+ * \sa glBufferSubDataARB, glGetBufferSubDataARB

+ */

+static struct gl_buffer_object *

+buffer_object_subdata_range_good( struct gl_context * ctx, GLenum target, 

+                                  GLintptrARB offset, GLsizeiptrARB size,

+                                  const char *caller )

+{

+   struct gl_buffer_object *bufObj;

+

+   if (size < 0) {

+      _mesa_error(ctx, GL_INVALID_VALUE, "%s(size < 0)", caller);

+      return NULL;

+   }

+

+   if (offset < 0) {

+      _mesa_error(ctx, GL_INVALID_VALUE, "%s(offset < 0)", caller);

+      return NULL;

+   }

+

+   bufObj = get_buffer(ctx, target);

+   if (!bufObj) {

+      _mesa_error(ctx, GL_INVALID_ENUM, "%s(target)", caller);

+      return NULL;

+   }

+   if (!_mesa_is_bufferobj(bufObj)) {

+      _mesa_error(ctx, GL_INVALID_OPERATION, "%s", caller);

+      return NULL;

+   }

+   if (offset + size > bufObj->Size) {

+      _mesa_error(ctx, GL_INVALID_VALUE,

+		  "%s(size + offset > buffer size)", caller);

+      return NULL;

+   }

+   if (_mesa_bufferobj_mapped(bufObj)) {

+      /* Buffer is currently mapped */

+      _mesa_error(ctx, GL_INVALID_OPERATION, "%s", caller);

+      return NULL;

+   }

+

+   return bufObj;

+}

+

+

+/**

+ * Allocate and initialize a new buffer object.

+ * 

+ * Default callback for the \c dd_function_table::NewBufferObject() hook.

+ */

+static struct gl_buffer_object *

+_mesa_new_buffer_object( struct gl_context *ctx, GLuint name, GLenum target )

+{

+   struct gl_buffer_object *obj;

+

+   (void) ctx;

+

+   obj = MALLOC_STRUCT(gl_buffer_object);

+   _mesa_initialize_buffer_object(obj, name, target);

+   return obj;

+}

+

+

+/**

+ * Delete a buffer object.

+ * 

+ * Default callback for the \c dd_function_table::DeleteBuffer() hook.

+ */

+static void

+_mesa_delete_buffer_object( struct gl_context *ctx, struct gl_buffer_object *bufObj )

+{

+   (void) ctx;

+

+   if (bufObj->Data)

+      free(bufObj->Data);

+

+   /* assign strange values here to help w/ debugging */

+   bufObj->RefCount = -1000;

+   bufObj->Name = ~0;

+

+   _glthread_DESTROY_MUTEX(bufObj->Mutex);

+   free(bufObj);

+}

+

+

+

+/**

+ * Set ptr to bufObj w/ reference counting.

+ */

+void

+_mesa_reference_buffer_object(struct gl_context *ctx,

+                              struct gl_buffer_object **ptr,

+                              struct gl_buffer_object *bufObj)

+{

+   if (*ptr == bufObj)

+      return;

+

+   if (*ptr) {

+      /* Unreference the old buffer */

+      GLboolean deleteFlag = GL_FALSE;

+      struct gl_buffer_object *oldObj = *ptr;

+

+      _glthread_LOCK_MUTEX(oldObj->Mutex);

+      ASSERT(oldObj->RefCount > 0);

+      oldObj->RefCount--;

+#if 0

+      printf("BufferObj %p %d DECR to %d\n",

+             (void *) oldObj, oldObj->Name, oldObj->RefCount);

+#endif

+      deleteFlag = (oldObj->RefCount == 0);

+      _glthread_UNLOCK_MUTEX(oldObj->Mutex);

+

+      if (deleteFlag) {

+

+         /* some sanity checking: don't delete a buffer still in use */

+#if 0

+         /* unfortunately, these tests are invalid during context tear-down */

+	 ASSERT(ctx->Array.ArrayBufferObj != bufObj);

+	 ASSERT(ctx->Array.ElementArrayBufferObj != bufObj);

+	 ASSERT(ctx->Array.ArrayObj->Vertex.BufferObj != bufObj);

+#endif

+

+	 ASSERT(ctx->Driver.DeleteBuffer);

+         ctx->Driver.DeleteBuffer(ctx, oldObj);

+      }

+

+      *ptr = NULL;

+   }

+   ASSERT(!*ptr);

+

+   if (bufObj) {

+      /* reference new buffer */

+      _glthread_LOCK_MUTEX(bufObj->Mutex);

+      if (bufObj->RefCount == 0) {

+         /* this buffer's being deleted (look just above) */

+         /* Not sure this can every really happen.  Warn if it does. */

+         _mesa_problem(NULL, "referencing deleted buffer object");

+         *ptr = NULL;

+      }

+      else {

+         bufObj->RefCount++;

+#if 0

+         printf("BufferObj %p %d INCR to %d\n",

+                (void *) bufObj, bufObj->Name, bufObj->RefCount);

+#endif

+         *ptr = bufObj;

+      }

+      _glthread_UNLOCK_MUTEX(bufObj->Mutex);

+   }

+}

+

+

+/**

+ * Initialize a buffer object to default values.

+ */

+void

+_mesa_initialize_buffer_object( struct gl_buffer_object *obj,

+				GLuint name, GLenum target )

+{

+   (void) target;

+

+   memset(obj, 0, sizeof(struct gl_buffer_object));

+   _glthread_INIT_MUTEX(obj->Mutex);

+   obj->RefCount = 1;

+   obj->Name = name;

+   obj->Usage = GL_STATIC_DRAW_ARB;

+   obj->AccessFlags = DEFAULT_ACCESS;

+}

+

+

+/**

+ * Allocate space for and store data in a buffer object.  Any data that was

+ * previously stored in the buffer object is lost.  If \c data is \c NULL,

+ * memory will be allocated, but no copy will occur.

+ *

+ * This is the default callback for \c dd_function_table::BufferData()

+ * Note that all GL error checking will have been done already.

+ *

+ * \param ctx     GL context.

+ * \param target  Buffer object target on which to operate.

+ * \param size    Size, in bytes, of the new data store.

+ * \param data    Pointer to the data to store in the buffer object.  This

+ *                pointer may be \c NULL.

+ * \param usage   Hints about how the data will be used.

+ * \param bufObj  Object to be used.

+ *

+ * \return GL_TRUE for success, GL_FALSE for failure

+ * \sa glBufferDataARB, dd_function_table::BufferData.

+ */

+static GLboolean

+_mesa_buffer_data( struct gl_context *ctx, GLenum target, GLsizeiptrARB size,

+		   const GLvoid * data, GLenum usage,

+		   struct gl_buffer_object * bufObj )

+{

+   void * new_data;

+

+   (void) ctx; (void) target;

+

+   new_data = _mesa_realloc( bufObj->Data, bufObj->Size, size );

+   if (new_data) {

+      bufObj->Data = (GLubyte *) new_data;

+      bufObj->Size = size;

+      bufObj->Usage = usage;

+

+      if (data) {

+	 memcpy( bufObj->Data, data, size );

+      }

+

+      return GL_TRUE;

+   }

+   else {

+      return GL_FALSE;

+   }

+}

+

+

+/**

+ * Replace data in a subrange of buffer object.  If the data range

+ * specified by \c size + \c offset extends beyond the end of the buffer or

+ * if \c data is \c NULL, no copy is performed.

+ *

+ * This is the default callback for \c dd_function_table::BufferSubData()

+ * Note that all GL error checking will have been done already.

+ *

+ * \param ctx     GL context.

+ * \param target  Buffer object target on which to operate.

+ * \param offset  Offset of the first byte to be modified.

+ * \param size    Size, in bytes, of the data range.

+ * \param data    Pointer to the data to store in the buffer object.

+ * \param bufObj  Object to be used.

+ *

+ * \sa glBufferSubDataARB, dd_function_table::BufferSubData.

+ */

+static void

+_mesa_buffer_subdata( struct gl_context *ctx, GLenum target, GLintptrARB offset,

+		      GLsizeiptrARB size, const GLvoid * data,

+		      struct gl_buffer_object * bufObj )

+{

+   (void) ctx; (void) target;

+

+   /* this should have been caught in _mesa_BufferSubData() */

+   ASSERT(size + offset <= bufObj->Size);

+

+   if (bufObj->Data) {

+      memcpy( (GLubyte *) bufObj->Data + offset, data, size );

+   }

+}

+

+

+/**

+ * Retrieve data from a subrange of buffer object.  If the data range

+ * specified by \c size + \c offset extends beyond the end of the buffer or

+ * if \c data is \c NULL, no copy is performed.

+ *

+ * This is the default callback for \c dd_function_table::GetBufferSubData()

+ * Note that all GL error checking will have been done already.

+ *

+ * \param ctx     GL context.

+ * \param target  Buffer object target on which to operate.

+ * \param offset  Offset of the first byte to be fetched.

+ * \param size    Size, in bytes, of the data range.

+ * \param data    Destination for data

+ * \param bufObj  Object to be used.

+ *

+ * \sa glBufferGetSubDataARB, dd_function_table::GetBufferSubData.

+ */

+static void

+_mesa_buffer_get_subdata( struct gl_context *ctx, GLenum target, GLintptrARB offset,

+			  GLsizeiptrARB size, GLvoid * data,

+			  struct gl_buffer_object * bufObj )

+{

+   (void) ctx; (void) target;

+

+   if (bufObj->Data && ((GLsizeiptrARB) (size + offset) <= bufObj->Size)) {

+      memcpy( data, (GLubyte *) bufObj->Data + offset, size );

+   }

+}

+

+

+/**

+ * Default callback for \c dd_function_tabel::MapBuffer().

+ *

+ * The function parameters will have been already tested for errors.

+ *

+ * \param ctx     GL context.

+ * \param target  Buffer object target on which to operate.

+ * \param access  Information about how the buffer will be accessed.

+ * \param bufObj  Object to be mapped.

+ * \return  A pointer to the object's internal data store that can be accessed

+ *          by the processor

+ *

+ * \sa glMapBufferARB, dd_function_table::MapBuffer

+ */

+static void *

+_mesa_buffer_map( struct gl_context *ctx, GLenum target, GLenum access,

+		  struct gl_buffer_object *bufObj )

+{

+   (void) ctx;

+   (void) target;

+   (void) access;

+   /* Just return a direct pointer to the data */

+   if (_mesa_bufferobj_mapped(bufObj)) {

+      /* already mapped! */

+      return NULL;

+   }

+   bufObj->Pointer = bufObj->Data;

+   bufObj->Length = bufObj->Size;

+   bufObj->Offset = 0;

+   return bufObj->Pointer;

+}

+

+

+/**

+ * Default fallback for \c dd_function_table::MapBufferRange().

+ * Called via glMapBufferRange().

+ */

+static void *

+_mesa_buffer_map_range( struct gl_context *ctx, GLenum target, GLintptr offset,

+                        GLsizeiptr length, GLbitfield access,

+                        struct gl_buffer_object *bufObj )

+{

+   (void) ctx;

+   (void) target;

+   assert(!_mesa_bufferobj_mapped(bufObj));

+   /* Just return a direct pointer to the data */

+   bufObj->Pointer = bufObj->Data + offset;

+   bufObj->Length = length;

+   bufObj->Offset = offset;

+   bufObj->AccessFlags = access;

+   return bufObj->Pointer;

+}

+

+

+/**

+ * Default fallback for \c dd_function_table::FlushMappedBufferRange().

+ * Called via glFlushMappedBufferRange().

+ */

+static void

+_mesa_buffer_flush_mapped_range( struct gl_context *ctx, GLenum target, 

+                                 GLintptr offset, GLsizeiptr length,

+                                 struct gl_buffer_object *obj )

+{

+   (void) ctx;

+   (void) target;

+   (void) offset;

+   (void) length;

+   (void) obj;

+   /* no-op */

+}

+

+

+/**

+ * Default callback for \c dd_function_table::MapBuffer().

+ *

+ * The input parameters will have been already tested for errors.

+ *

+ * \sa glUnmapBufferARB, dd_function_table::UnmapBuffer

+ */

+static GLboolean

+_mesa_buffer_unmap( struct gl_context *ctx, GLenum target,

+                    struct gl_buffer_object *bufObj )

+{

+   (void) ctx;

+   (void) target;

+   /* XXX we might assert here that bufObj->Pointer is non-null */

+   bufObj->Pointer = NULL;

+   bufObj->Length = 0;

+   bufObj->Offset = 0;

+   bufObj->AccessFlags = 0x0;

+   return GL_TRUE;

+}

+

+

+/**

+ * Default fallback for \c dd_function_table::CopyBufferSubData().

+ * Called via glCopyBuffserSubData().

+ */

+static void

+_mesa_copy_buffer_subdata(struct gl_context *ctx,

+                          struct gl_buffer_object *src,

+                          struct gl_buffer_object *dst,

+                          GLintptr readOffset, GLintptr writeOffset,

+                          GLsizeiptr size)

+{

+   GLubyte *srcPtr, *dstPtr;

+

+   /* buffer should not already be mapped */

+   assert(!_mesa_bufferobj_mapped(src));

+   assert(!_mesa_bufferobj_mapped(dst));

+

+   srcPtr = (GLubyte *) ctx->Driver.MapBuffer(ctx, GL_COPY_READ_BUFFER,

+                                              GL_READ_ONLY, src);

+   dstPtr = (GLubyte *) ctx->Driver.MapBuffer(ctx, GL_COPY_WRITE_BUFFER,

+                                              GL_WRITE_ONLY, dst);

+

+   if (srcPtr && dstPtr)

+      memcpy(dstPtr + writeOffset, srcPtr + readOffset, size);

+

+   ctx->Driver.UnmapBuffer(ctx, GL_COPY_READ_BUFFER, src);

+   ctx->Driver.UnmapBuffer(ctx, GL_COPY_WRITE_BUFFER, dst);

+}

+

+

+

+/**

+ * Initialize the state associated with buffer objects

+ */

+void

+_mesa_init_buffer_objects( struct gl_context *ctx )

+{

+   memset(&DummyBufferObject, 0, sizeof(DummyBufferObject));

+   _glthread_INIT_MUTEX(DummyBufferObject.Mutex);

+   DummyBufferObject.RefCount = 1000*1000*1000; /* never delete */

+

+   _mesa_reference_buffer_object(ctx, &ctx->Array.ArrayBufferObj,

+                                 ctx->Shared->NullBufferObj);

+   _mesa_reference_buffer_object(ctx, &ctx->Array.ElementArrayBufferObj,

+                                 ctx->Shared->NullBufferObj);

+

+   _mesa_reference_buffer_object(ctx, &ctx->CopyReadBuffer,

+                                 ctx->Shared->NullBufferObj);

+   _mesa_reference_buffer_object(ctx, &ctx->CopyWriteBuffer,

+                                 ctx->Shared->NullBufferObj);

+}

+

+

+void

+_mesa_free_buffer_objects( struct gl_context *ctx )

+{

+   _mesa_reference_buffer_object(ctx, &ctx->Array.ArrayBufferObj, NULL);

+   _mesa_reference_buffer_object(ctx, &ctx->Array.ElementArrayBufferObj, NULL);

+

+   _mesa_reference_buffer_object(ctx, &ctx->CopyReadBuffer, NULL);

+   _mesa_reference_buffer_object(ctx, &ctx->CopyWriteBuffer, NULL);

+}

+

+

+/**

+ * Bind the specified target to buffer for the specified context.

+ * Called by glBindBuffer() and other functions.

+ */

+static void

+bind_buffer_object(struct gl_context *ctx, GLenum target, GLuint buffer)

+{

+   struct gl_buffer_object *oldBufObj;

+   struct gl_buffer_object *newBufObj = NULL;

+   struct gl_buffer_object **bindTarget = NULL;

+

+   bindTarget = get_buffer_target(ctx, target);

+   if (!bindTarget) {

+      _mesa_error(ctx, GL_INVALID_ENUM, "glBindBufferARB(target 0x%x)", target);

+      return;

+   }

+

+   /* Get pointer to old buffer object (to be unbound) */

+   oldBufObj = *bindTarget;

+   if (oldBufObj && oldBufObj->Name == buffer)

+      return;   /* rebinding the same buffer object- no change */

+

+   /*

+    * Get pointer to new buffer object (newBufObj)

+    */

+   if (buffer == 0) {

+      /* The spec says there's not a buffer object named 0, but we use

+       * one internally because it simplifies things.

+       */

+      newBufObj = ctx->Shared->NullBufferObj;

+   }

+   else {

+      /* non-default buffer object */

+      newBufObj = _mesa_lookup_bufferobj(ctx, buffer);

+      if (!newBufObj || newBufObj == &DummyBufferObject) {

+         /* If this is a new buffer object id, or one which was generated but

+          * never used before, allocate a buffer object now.

+          */

+         ASSERT(ctx->Driver.NewBufferObject);

+         newBufObj = ctx->Driver.NewBufferObject(ctx, buffer, target);

+         if (!newBufObj) {

+            _mesa_error(ctx, GL_OUT_OF_MEMORY, "glBindBufferARB");

+            return;

+         }

+         _mesa_HashInsert(ctx->Shared->BufferObjects, buffer, newBufObj);

+      }

+   }

+   

+   /* bind new buffer */

+   _mesa_reference_buffer_object(ctx, bindTarget, newBufObj);

+

+   /* Pass BindBuffer call to device driver */

+   if (ctx->Driver.BindBuffer)

+      ctx->Driver.BindBuffer( ctx, target, newBufObj );

+}

+

+

+/**

+ * Update the default buffer objects in the given context to reference those

+ * specified in the shared state and release those referencing the old 

+ * shared state.

+ */

+void

+_mesa_update_default_objects_buffer_objects(struct gl_context *ctx)

+{

+   /* Bind the NullBufferObj to remove references to those

+    * in the shared context hash table.

+    */

+   bind_buffer_object( ctx, GL_ARRAY_BUFFER_ARB, 0);

+   bind_buffer_object( ctx, GL_ELEMENT_ARRAY_BUFFER_ARB, 0);

+   bind_buffer_object( ctx, GL_PIXEL_PACK_BUFFER_ARB, 0);

+   bind_buffer_object( ctx, GL_PIXEL_UNPACK_BUFFER_ARB, 0);

+}

+

+

+

+/**

+ * Return the gl_buffer_object for the given ID.

+ * Always return NULL for ID 0.

+ */

+struct gl_buffer_object *

+_mesa_lookup_bufferobj(struct gl_context *ctx, GLuint buffer)

+{

+   if (buffer == 0)

+      return NULL;

+   else

+      return (struct gl_buffer_object *)

+         _mesa_HashLookup(ctx->Shared->BufferObjects, buffer);

+}

+

+

+/**

+ * If *ptr points to obj, set ptr = the Null/default buffer object.

+ * This is a helper for buffer object deletion.

+ * The GL spec says that deleting a buffer object causes it to get

+ * unbound from all arrays in the current context.

+ */

+static void

+unbind(struct gl_context *ctx,

+       struct gl_buffer_object **ptr,

+       struct gl_buffer_object *obj)

+{

+   if (*ptr == obj) {

+      _mesa_reference_buffer_object(ctx, ptr, ctx->Shared->NullBufferObj);

+   }

+}

+

+

+/**

+ * Plug default/fallback buffer object functions into the device

+ * driver hooks.

+ */

+void

+_mesa_init_buffer_object_functions(struct dd_function_table *driver)

+{

+   /* GL_ARB_vertex/pixel_buffer_object */

+   driver->NewBufferObject = _mesa_new_buffer_object;

+   driver->DeleteBuffer = _mesa_delete_buffer_object;

+   driver->BindBuffer = NULL;

+   driver->BufferData = _mesa_buffer_data;

+   driver->BufferSubData = _mesa_buffer_subdata;

+   driver->GetBufferSubData = _mesa_buffer_get_subdata;

+   driver->MapBuffer = _mesa_buffer_map;

+   driver->UnmapBuffer = _mesa_buffer_unmap;

+

+   /* GL_ARB_map_buffer_range */

+   driver->MapBufferRange = _mesa_buffer_map_range;

+   driver->FlushMappedBufferRange = _mesa_buffer_flush_mapped_range;

+

+   /* GL_ARB_copy_buffer */

+   driver->CopyBufferSubData = _mesa_copy_buffer_subdata;

+}

+

+

+

+/**********************************************************************/

+/* API Functions                                                      */

+/**********************************************************************/

+

+void GLAPIENTRY

+_mesa_BindBufferARB(GLenum target, GLuint buffer)

+{

+   GET_CURRENT_CONTEXT(ctx);

+   ASSERT_OUTSIDE_BEGIN_END(ctx);

+

+   if (MESA_VERBOSE & VERBOSE_API)

+      _mesa_debug(ctx, "glBindBuffer(%s, %u)\n",

+                  _mesa_lookup_enum_by_nr(target), buffer);

+

+   bind_buffer_object(ctx, target, buffer);

+}

+

+

+/**

+ * Delete a set of buffer objects.

+ * 

+ * \param n      Number of buffer objects to delete.

+ * \param ids    Array of \c n buffer object IDs.

+ */

+void GLAPIENTRY

+_mesa_DeleteBuffersARB(GLsizei n, const GLuint *ids)

+{

+   GET_CURRENT_CONTEXT(ctx);

+   GLsizei i;

+   ASSERT_OUTSIDE_BEGIN_END(ctx);

+   FLUSH_VERTICES(ctx, 0);

+

+   if (n < 0) {

+      _mesa_error(ctx, GL_INVALID_VALUE, "glDeleteBuffersARB(n)");

+      return;

+   }

+

+   _glthread_LOCK_MUTEX(ctx->Shared->Mutex);

+

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

+      struct gl_buffer_object *bufObj = _mesa_lookup_bufferobj(ctx, ids[i]);

+      if (bufObj) {

+         struct gl_array_object *arrayObj = ctx->Array.ArrayObj;

+         GLuint j;

+

+         ASSERT(bufObj->Name == ids[i] || bufObj == &DummyBufferObject);

+

+         if (_mesa_bufferobj_mapped(bufObj)) {

+            /* if mapped, unmap it now */

+            ctx->Driver.UnmapBuffer(ctx, 0, bufObj);

+            bufObj->AccessFlags = DEFAULT_ACCESS;

+            bufObj->Pointer = NULL;

+         }

+

+         /* unbind any vertex pointers bound to this buffer */

+         unbind(ctx, &arrayObj->Vertex.BufferObj, bufObj);

+         unbind(ctx, &arrayObj->Weight.BufferObj, bufObj);

+         unbind(ctx, &arrayObj->Normal.BufferObj, bufObj);

+         unbind(ctx, &arrayObj->Color.BufferObj, bufObj);

+         unbind(ctx, &arrayObj->SecondaryColor.BufferObj, bufObj);

+         unbind(ctx, &arrayObj->FogCoord.BufferObj, bufObj);

+         unbind(ctx, &arrayObj->Index.BufferObj, bufObj);

+         unbind(ctx, &arrayObj->EdgeFlag.BufferObj, bufObj);

+         for (j = 0; j < Elements(arrayObj->TexCoord); j++) {

+            unbind(ctx, &arrayObj->TexCoord[j].BufferObj, bufObj);

+         }

+         for (j = 0; j < Elements(arrayObj->VertexAttrib); j++) {

+            unbind(ctx, &arrayObj->VertexAttrib[j].BufferObj, bufObj);

+         }

+

+         if (ctx->Array.ArrayBufferObj == bufObj) {

+            _mesa_BindBufferARB( GL_ARRAY_BUFFER_ARB, 0 );

+         }

+         if (ctx->Array.ElementArrayBufferObj == bufObj) {

+            _mesa_BindBufferARB( GL_ELEMENT_ARRAY_BUFFER_ARB, 0 );

+         }

+

+         /* unbind any pixel pack/unpack pointers bound to this buffer */

+         if (ctx->Pack.BufferObj == bufObj) {

+            _mesa_BindBufferARB( GL_PIXEL_PACK_BUFFER_EXT, 0 );

+         }

+         if (ctx->Unpack.BufferObj == bufObj) {

+            _mesa_BindBufferARB( GL_PIXEL_UNPACK_BUFFER_EXT, 0 );

+         }

+

+         /* The ID is immediately freed for re-use */

+         _mesa_HashRemove(ctx->Shared->BufferObjects, ids[i]);

+         _mesa_reference_buffer_object(ctx, &bufObj, NULL);

+      }

+   }

+

+   _glthread_UNLOCK_MUTEX(ctx->Shared->Mutex);

+}

+

+

+/**

+ * Generate a set of unique buffer object IDs and store them in \c buffer.

+ * 

+ * \param n       Number of IDs to generate.

+ * \param buffer  Array of \c n locations to store the IDs.

+ */

+void GLAPIENTRY

+_mesa_GenBuffersARB(GLsizei n, GLuint *buffer)

+{

+   GET_CURRENT_CONTEXT(ctx);

+   GLuint first;

+   GLint i;

+   ASSERT_OUTSIDE_BEGIN_END(ctx);

+

+   if (MESA_VERBOSE & VERBOSE_API)

+      _mesa_debug(ctx, "glGenBuffers(%d)\n", n);

+

+   if (n < 0) {

+      _mesa_error(ctx, GL_INVALID_VALUE, "glGenBuffersARB");

+      return;

+   }

+

+   if (!buffer) {

+      return;

+   }

+

+   /*

+    * This must be atomic (generation and allocation of buffer object IDs)

+    */

+   _glthread_LOCK_MUTEX(ctx->Shared->Mutex);

+

+   first = _mesa_HashFindFreeKeyBlock(ctx->Shared->BufferObjects, n);

+

+   /* Insert the ID and pointer to dummy buffer object into hash table */

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

+      _mesa_HashInsert(ctx->Shared->BufferObjects, first + i,

+                       &DummyBufferObject);

+      buffer[i] = first + i;

+   }

+

+   _glthread_UNLOCK_MUTEX(ctx->Shared->Mutex);

+}

+

+

+/**

+ * Determine if ID is the name of a buffer object.

+ * 

+ * \param id  ID of the potential buffer object.

+ * \return  \c GL_TRUE if \c id is the name of a buffer object, 

+ *          \c GL_FALSE otherwise.

+ */

+GLboolean GLAPIENTRY

+_mesa_IsBufferARB(GLuint id)

+{

+   struct gl_buffer_object *bufObj;

+   GET_CURRENT_CONTEXT(ctx);

+   ASSERT_OUTSIDE_BEGIN_END_WITH_RETVAL(ctx, GL_FALSE);

+

+   _glthread_LOCK_MUTEX(ctx->Shared->Mutex);

+   bufObj = _mesa_lookup_bufferobj(ctx, id);

+   _glthread_UNLOCK_MUTEX(ctx->Shared->Mutex);

+

+   return bufObj && bufObj != &DummyBufferObject;

+}

+

+

+void GLAPIENTRY

+_mesa_BufferDataARB(GLenum target, GLsizeiptrARB size,

+                    const GLvoid * data, GLenum usage)

+{

+   GET_CURRENT_CONTEXT(ctx);

+   struct gl_buffer_object *bufObj;

+   ASSERT_OUTSIDE_BEGIN_END(ctx);

+

+   if (MESA_VERBOSE & VERBOSE_API)

+      _mesa_debug(ctx, "glBufferData(%s, %ld, %p, %s)\n",

+                  _mesa_lookup_enum_by_nr(target),

+                  (long int) size, data,

+                  _mesa_lookup_enum_by_nr(usage));

+

+   if (size < 0) {

+      _mesa_error(ctx, GL_INVALID_VALUE, "glBufferDataARB(size < 0)");

+      return;

+   }

+

+   switch (usage) {

+   case GL_STREAM_DRAW_ARB:

+   case GL_STREAM_READ_ARB:

+   case GL_STREAM_COPY_ARB:

+   case GL_STATIC_DRAW_ARB:

+   case GL_STATIC_READ_ARB:

+   case GL_STATIC_COPY_ARB:

+   case GL_DYNAMIC_DRAW_ARB:

+   case GL_DYNAMIC_READ_ARB:

+   case GL_DYNAMIC_COPY_ARB:

+      /* OK */

+      break;

+   default:

+      _mesa_error(ctx, GL_INVALID_ENUM, "glBufferDataARB(usage)");

+      return;

+   }

+

+   bufObj = get_buffer(ctx, target);

+   if (!bufObj) {

+      _mesa_error(ctx, GL_INVALID_ENUM, "glBufferDataARB(target)" );

+      return;

+   }

+   if (!_mesa_is_bufferobj(bufObj)) {

+      _mesa_error(ctx, GL_INVALID_OPERATION, "glBufferDataARB(buffer 0)" );

+      return;

+   }

+   

+   if (_mesa_bufferobj_mapped(bufObj)) {

+      /* Unmap the existing buffer.  We'll replace it now.  Not an error. */

+      ctx->Driver.UnmapBuffer(ctx, target, bufObj);

+      bufObj->AccessFlags = DEFAULT_ACCESS;

+      ASSERT(bufObj->Pointer == NULL);

+   }  

+

+   FLUSH_VERTICES(ctx, _NEW_BUFFER_OBJECT);

+

+   bufObj->Written = GL_TRUE;

+

+#ifdef VBO_DEBUG

+   printf("glBufferDataARB(%u, sz %ld, from %p, usage 0x%x)\n",

+                bufObj->Name, size, data, usage);

+#endif

+

+#ifdef BOUNDS_CHECK

+   size += 100;

+#endif

+

+   ASSERT(ctx->Driver.BufferData);

+   if (!ctx->Driver.BufferData( ctx, target, size, data, usage, bufObj )) {

+      _mesa_error(ctx, GL_OUT_OF_MEMORY, "glBufferDataARB()");

+   }

+}

+

+

+void GLAPIENTRY

+_mesa_BufferSubDataARB(GLenum target, GLintptrARB offset,

+                       GLsizeiptrARB size, const GLvoid * data)

+{

+   GET_CURRENT_CONTEXT(ctx);

+   struct gl_buffer_object *bufObj;

+   ASSERT_OUTSIDE_BEGIN_END(ctx);

+

+   bufObj = buffer_object_subdata_range_good( ctx, target, offset, size,

+                                              "glBufferSubDataARB" );

+   if (!bufObj) {

+      /* error already recorded */

+      return;

+   }

+

+   if (size == 0)

+      return;

+

+   bufObj->Written = GL_TRUE;

+

+   ASSERT(ctx->Driver.BufferSubData);

+   ctx->Driver.BufferSubData( ctx, target, offset, size, data, bufObj );

+}

+

+

+void GLAPIENTRY

+_mesa_GetBufferSubDataARB(GLenum target, GLintptrARB offset,

+                          GLsizeiptrARB size, void * data)

+{

+   GET_CURRENT_CONTEXT(ctx);

+   struct gl_buffer_object *bufObj;

+   ASSERT_OUTSIDE_BEGIN_END(ctx);

+

+   bufObj = buffer_object_subdata_range_good( ctx, target, offset, size,

+                                              "glGetBufferSubDataARB" );

+   if (!bufObj) {

+      /* error already recorded */

+      return;

+   }

+

+   ASSERT(ctx->Driver.GetBufferSubData);

+   ctx->Driver.GetBufferSubData( ctx, target, offset, size, data, bufObj );

+}

+

+

+void * GLAPIENTRY

+_mesa_MapBufferARB(GLenum target, GLenum access)

+{

+   GET_CURRENT_CONTEXT(ctx);

+   struct gl_buffer_object * bufObj;

+   GLbitfield accessFlags;

+   void *map;

+

+   ASSERT_OUTSIDE_BEGIN_END_WITH_RETVAL(ctx, NULL);

+

+   switch (access) {

+   case GL_READ_ONLY_ARB:

+      accessFlags = GL_MAP_READ_BIT;

+      break;

+   case GL_WRITE_ONLY_ARB:

+      accessFlags = GL_MAP_WRITE_BIT;

+      break;

+   case GL_READ_WRITE_ARB:

+      accessFlags = GL_MAP_READ_BIT | GL_MAP_WRITE_BIT;

+      break;

+   default:

+      _mesa_error(ctx, GL_INVALID_ENUM, "glMapBufferARB(access)");

+      return NULL;

+   }

+

+   bufObj = get_buffer(ctx, target);

+   if (!bufObj) {

+      _mesa_error(ctx, GL_INVALID_ENUM, "glMapBufferARB(target)" );

+      return NULL;

+   }

+   if (!_mesa_is_bufferobj(bufObj)) {

+      _mesa_error(ctx, GL_INVALID_OPERATION, "glMapBufferARB(buffer 0)" );

+      return NULL;

+   }

+   if (_mesa_bufferobj_mapped(bufObj)) {

+      _mesa_error(ctx, GL_INVALID_OPERATION, "glMapBufferARB(already mapped)");

+      return NULL;

+   }

+

+   ASSERT(ctx->Driver.MapBuffer);

+   map = ctx->Driver.MapBuffer( ctx, target, access, bufObj );

+   if (!map) {

+      _mesa_error(ctx, GL_OUT_OF_MEMORY, "glMapBufferARB(map failed)");

+      return NULL;

+   }

+   else {

+      /* The driver callback should have set these fields.

+       * This is important because other modules (like VBO) might call

+       * the driver function directly.

+       */

+      ASSERT(bufObj->Pointer == map);

+      ASSERT(bufObj->Length == bufObj->Size);

+      ASSERT(bufObj->Offset == 0);

+      bufObj->AccessFlags = accessFlags;

+   }

+

+   if (access == GL_WRITE_ONLY_ARB || access == GL_READ_WRITE_ARB)

+      bufObj->Written = GL_TRUE;

+

+#ifdef VBO_DEBUG

+   printf("glMapBufferARB(%u, sz %ld, access 0x%x)\n",

+	  bufObj->Name, bufObj->Size, access);

+   if (access == GL_WRITE_ONLY_ARB) {

+      GLuint i;

+      GLubyte *b = (GLubyte *) bufObj->Pointer;

+      for (i = 0; i < bufObj->Size; i++)

+         b[i] = i & 0xff;

+   }

+#endif

+

+#ifdef BOUNDS_CHECK

+   {

+      GLubyte *buf = (GLubyte *) bufObj->Pointer;

+      GLuint i;

+      /* buffer is 100 bytes larger than requested, fill with magic value */

+      for (i = 0; i < 100; i++) {

+         buf[bufObj->Size - i - 1] = 123;

+      }

+   }

+#endif

+

+   return bufObj->Pointer;

+}

+

+

+GLboolean GLAPIENTRY

+_mesa_UnmapBufferARB(GLenum target)

+{

+   GET_CURRENT_CONTEXT(ctx);

+   struct gl_buffer_object *bufObj;

+   GLboolean status = GL_TRUE;

+   ASSERT_OUTSIDE_BEGIN_END_WITH_RETVAL(ctx, GL_FALSE);

+

+   bufObj = get_buffer(ctx, target);

+   if (!bufObj) {

+      _mesa_error(ctx, GL_INVALID_ENUM, "glUnmapBufferARB(target)" );

+      return GL_FALSE;

+   }

+   if (!_mesa_is_bufferobj(bufObj)) {

+      _mesa_error(ctx, GL_INVALID_OPERATION, "glUnmapBufferARB" );

+      return GL_FALSE;

+   }

+   if (!_mesa_bufferobj_mapped(bufObj)) {

+      _mesa_error(ctx, GL_INVALID_OPERATION, "glUnmapBufferARB");

+      return GL_FALSE;

+   }

+

+#ifdef BOUNDS_CHECK

+   if (bufObj->Access != GL_READ_ONLY_ARB) {

+      GLubyte *buf = (GLubyte *) bufObj->Pointer;

+      GLuint i;

+      /* check that last 100 bytes are still = magic value */

+      for (i = 0; i < 100; i++) {

+         GLuint pos = bufObj->Size - i - 1;

+         if (buf[pos] != 123) {

+            _mesa_warning(ctx, "Out of bounds buffer object write detected"

+                          " at position %d (value = %u)\n",

+                          pos, buf[pos]);

+         }

+      }

+   }

+#endif

+

+#ifdef VBO_DEBUG

+   if (bufObj->AccessFlags & GL_MAP_WRITE_BIT) {

+      GLuint i, unchanged = 0;

+      GLubyte *b = (GLubyte *) bufObj->Pointer;

+      GLint pos = -1;

+      /* check which bytes changed */

+      for (i = 0; i < bufObj->Size - 1; i++) {

+         if (b[i] == (i & 0xff) && b[i+1] == ((i+1) & 0xff)) {

+            unchanged++;

+            if (pos == -1)

+               pos = i;

+         }

+      }

+      if (unchanged) {

+         printf("glUnmapBufferARB(%u): %u of %ld unchanged, starting at %d\n",

+                      bufObj->Name, unchanged, bufObj->Size, pos);

+      }

+   }

+#endif

+

+   status = ctx->Driver.UnmapBuffer( ctx, target, bufObj );

+   bufObj->AccessFlags = DEFAULT_ACCESS;

+   ASSERT(bufObj->Pointer == NULL);

+   ASSERT(bufObj->Offset == 0);

+   ASSERT(bufObj->Length == 0);

+

+   return status;

+}

+

+

+void GLAPIENTRY

+_mesa_GetBufferParameterivARB(GLenum target, GLenum pname, GLint *params)

+{

+   GET_CURRENT_CONTEXT(ctx);

+   struct gl_buffer_object *bufObj;

+   ASSERT_OUTSIDE_BEGIN_END(ctx);

+

+   bufObj = get_buffer(ctx, target);

+   if (!bufObj) {

+      _mesa_error(ctx, GL_INVALID_ENUM, "glGetBufferParameterivARB(target)" );

+      return;

+   }

+   if (!_mesa_is_bufferobj(bufObj)) {

+      _mesa_error(ctx, GL_INVALID_OPERATION, "glGetBufferParameterivARB" );

+      return;

+   }

+

+   switch (pname) {

+   case GL_BUFFER_SIZE_ARB:

+      *params = (GLint) bufObj->Size;

+      return;

+   case GL_BUFFER_USAGE_ARB:

+      *params = bufObj->Usage;

+      return;

+   case GL_BUFFER_ACCESS_ARB:

+      *params = simplified_access_mode(bufObj->AccessFlags);

+      return;

+   case GL_BUFFER_MAPPED_ARB:

+      *params = _mesa_bufferobj_mapped(bufObj);

+      return;

+   case GL_BUFFER_ACCESS_FLAGS:

+      if (ctx->VersionMajor < 3)

+         goto invalid_pname;

+      *params = bufObj->AccessFlags;

+      return;

+   case GL_BUFFER_MAP_OFFSET:

+      if (ctx->VersionMajor < 3)

+         goto invalid_pname;

+      *params = (GLint) bufObj->Offset;

+      return;

+   case GL_BUFFER_MAP_LENGTH:

+      if (ctx->VersionMajor < 3)

+         goto invalid_pname;

+      *params = (GLint) bufObj->Length;

+      return;

+   default:

+      ; /* fall-through */

+   }

+

+invalid_pname:

+   _mesa_error(ctx, GL_INVALID_ENUM, "glGetBufferParameterivARB(pname=%s)",

+               _mesa_lookup_enum_by_nr(pname));

+}

+

+

+/**

+ * New in GL 3.2

+ * This is pretty much a duplicate of GetBufferParameteriv() but the

+ * GL_BUFFER_SIZE_ARB attribute will be 64-bits on a 64-bit system.

+ */

+void GLAPIENTRY

+_mesa_GetBufferParameteri64v(GLenum target, GLenum pname, GLint64 *params)

+{

+   GET_CURRENT_CONTEXT(ctx);

+   struct gl_buffer_object *bufObj;

+   ASSERT_OUTSIDE_BEGIN_END(ctx);

+

+   bufObj = get_buffer(ctx, target);

+   if (!bufObj) {

+      _mesa_error(ctx, GL_INVALID_ENUM, "glGetBufferParameteri64v(target)" );

+      return;

+   }

+   if (!_mesa_is_bufferobj(bufObj)) {

+      _mesa_error(ctx, GL_INVALID_OPERATION, "glGetBufferParameteri64v" );

+      return;

+   }

+

+   switch (pname) {

+   case GL_BUFFER_SIZE_ARB:

+      *params = bufObj->Size;

+      return;

+   case GL_BUFFER_USAGE_ARB:

+      *params = bufObj->Usage;

+      return;

+   case GL_BUFFER_ACCESS_ARB:

+      *params = simplified_access_mode(bufObj->AccessFlags);

+      return;

+   case GL_BUFFER_ACCESS_FLAGS:

+      if (ctx->VersionMajor < 3)

+         goto invalid_pname;

+      *params = bufObj->AccessFlags;

+      return;

+   case GL_BUFFER_MAPPED_ARB:

+      *params = _mesa_bufferobj_mapped(bufObj);

+      return;

+   case GL_BUFFER_MAP_OFFSET:

+      if (ctx->VersionMajor < 3)

+         goto invalid_pname;

+      *params = bufObj->Offset;

+      return;

+   case GL_BUFFER_MAP_LENGTH:

+      if (ctx->VersionMajor < 3)

+         goto invalid_pname;

+      *params = bufObj->Length;

+      return;

+   default:

+      ; /* fall-through */

+   }

+

+invalid_pname:

+   _mesa_error(ctx, GL_INVALID_ENUM, "glGetBufferParameteri64v(pname=%s)",

+               _mesa_lookup_enum_by_nr(pname));

+}

+

+

+void GLAPIENTRY

+_mesa_GetBufferPointervARB(GLenum target, GLenum pname, GLvoid **params)

+{

+   GET_CURRENT_CONTEXT(ctx);

+   struct gl_buffer_object * bufObj;

+   ASSERT_OUTSIDE_BEGIN_END(ctx);

+

+   if (pname != GL_BUFFER_MAP_POINTER_ARB) {

+      _mesa_error(ctx, GL_INVALID_ENUM, "glGetBufferPointervARB(pname)");

+      return;

+   }

+

+   bufObj = get_buffer(ctx, target);

+   if (!bufObj) {

+      _mesa_error(ctx, GL_INVALID_ENUM, "glGetBufferPointervARB(target)" );

+      return;

+   }

+   if (!_mesa_is_bufferobj(bufObj)) {

+      _mesa_error(ctx, GL_INVALID_OPERATION, "glGetBufferPointervARB" );

+      return;

+   }

+

+   *params = bufObj->Pointer;

+}

+

+

+void GLAPIENTRY

+_mesa_CopyBufferSubData(GLenum readTarget, GLenum writeTarget,

+                        GLintptr readOffset, GLintptr writeOffset,

+                        GLsizeiptr size)

+{

+   GET_CURRENT_CONTEXT(ctx);

+   struct gl_buffer_object *src, *dst;

+   ASSERT_OUTSIDE_BEGIN_END(ctx);

+

+   src = get_buffer(ctx, readTarget);

+   if (!src || !_mesa_is_bufferobj(src)) {

+      _mesa_error(ctx, GL_INVALID_ENUM,

+                  "glCopyBuffserSubData(readTarget = 0x%x)", readTarget);

+      return;

+   }

+

+   dst = get_buffer(ctx, writeTarget);

+   if (!dst || !_mesa_is_bufferobj(dst)) {

+      _mesa_error(ctx, GL_INVALID_ENUM,

+                  "glCopyBuffserSubData(writeTarget = 0x%x)", writeTarget);

+      return;

+   }

+

+   if (_mesa_bufferobj_mapped(src)) {

+      _mesa_error(ctx, GL_INVALID_OPERATION,

+                  "glCopyBuffserSubData(readBuffer is mapped)");

+      return;

+   }

+

+   if (_mesa_bufferobj_mapped(dst)) {

+      _mesa_error(ctx, GL_INVALID_OPERATION,

+                  "glCopyBuffserSubData(writeBuffer is mapped)");

+      return;

+   }

+

+   if (readOffset < 0) {

+      _mesa_error(ctx, GL_INVALID_VALUE,

+                  "glCopyBuffserSubData(readOffset = %d)", (int) readOffset);

+      return;

+   }

+

+   if (writeOffset < 0) {

+      _mesa_error(ctx, GL_INVALID_VALUE,

+                  "glCopyBuffserSubData(writeOffset = %d)", (int) writeOffset);

+      return;

+   }

+

+   if (readOffset + size > src->Size) {

+      _mesa_error(ctx, GL_INVALID_VALUE,

+                  "glCopyBuffserSubData(readOffset + size = %d)",

+                  (int) (readOffset + size));

+      return;

+   }

+

+   if (writeOffset + size > dst->Size) {

+      _mesa_error(ctx, GL_INVALID_VALUE,

+                  "glCopyBuffserSubData(writeOffset + size = %d)",

+                  (int) (writeOffset + size));

+      return;

+   }

+

+   if (src == dst) {

+      if (readOffset + size <= writeOffset) {

+         /* OK */

+      }

+      else if (writeOffset + size <= readOffset) {

+         /* OK */

+      }

+      else {

+         /* overlapping src/dst is illegal */

+         _mesa_error(ctx, GL_INVALID_VALUE,

+                     "glCopyBuffserSubData(overlapping src/dst)");

+         return;

+      }

+   }

+

+   ctx->Driver.CopyBufferSubData(ctx, src, dst, readOffset, writeOffset, size);

+}

+

+

+/**

+ * See GL_ARB_map_buffer_range spec

+ */

+void * GLAPIENTRY

+_mesa_MapBufferRange(GLenum target, GLintptr offset, GLsizeiptr length,

+                     GLbitfield access)

+{

+   GET_CURRENT_CONTEXT(ctx);

+   struct gl_buffer_object *bufObj;

+   void *map;

+

+   ASSERT_OUTSIDE_BEGIN_END_WITH_RETVAL(ctx, NULL);

+

+   if (!ctx->Extensions.ARB_map_buffer_range) {

+      _mesa_error(ctx, GL_INVALID_OPERATION,

+                  "glMapBufferRange(extension not supported)");

+      return NULL;

+   }

+

+   if (offset < 0) {

+      _mesa_error(ctx, GL_INVALID_VALUE,

+                  "glMapBufferRange(offset = %ld)", (long)offset);

+      return NULL;

+   }

+

+   if (length < 0) {

+      _mesa_error(ctx, GL_INVALID_VALUE,

+                  "glMapBufferRange(length = %ld)", (long)length);

+      return NULL;

+   }

+

+   if ((access & (GL_MAP_READ_BIT | GL_MAP_WRITE_BIT)) == 0) {

+      _mesa_error(ctx, GL_INVALID_OPERATION,

+                  "glMapBufferRange(access indicates neither read or write)");

+      return NULL;

+   }

+

+   if (access & GL_MAP_READ_BIT) {

+      if ((access & GL_MAP_INVALIDATE_RANGE_BIT) ||

+          (access & GL_MAP_INVALIDATE_BUFFER_BIT) ||

+          (access & GL_MAP_UNSYNCHRONIZED_BIT)) {

+         _mesa_error(ctx, GL_INVALID_OPERATION,

+                     "glMapBufferRange(invalid access flags)");

+         return NULL;

+      }

+   }

+

+   if ((access & GL_MAP_FLUSH_EXPLICIT_BIT) &&

+       ((access & GL_MAP_WRITE_BIT) == 0)) {

+      _mesa_error(ctx, GL_INVALID_OPERATION,

+                  "glMapBufferRange(invalid access flags)");

+      return NULL;

+   }

+

+   bufObj = get_buffer(ctx, target);

+   if (!bufObj || !_mesa_is_bufferobj(bufObj)) {

+      _mesa_error(ctx, GL_INVALID_ENUM,

+                  "glMapBufferRange(target = 0x%x)", target);

+      return NULL;

+   }

+

+   if (offset + length > bufObj->Size) {

+      _mesa_error(ctx, GL_INVALID_VALUE,

+                  "glMapBufferRange(offset + length > size)");

+      return NULL;

+   }

+

+   if (_mesa_bufferobj_mapped(bufObj)) {

+      _mesa_error(ctx, GL_INVALID_OPERATION,

+                  "glMapBufferRange(buffer already mapped)");

+      return NULL;

+   }

+      

+   ASSERT(ctx->Driver.MapBufferRange);

+   map = ctx->Driver.MapBufferRange(ctx, target, offset, length,

+                                    access, bufObj);

+   if (!map) {

+      _mesa_error(ctx, GL_OUT_OF_MEMORY, "glMapBufferARB(map failed)");

+   }

+   else {

+      /* The driver callback should have set all these fields.

+       * This is important because other modules (like VBO) might call

+       * the driver function directly.

+       */

+      ASSERT(bufObj->Pointer == map);

+      ASSERT(bufObj->Length == length);

+      ASSERT(bufObj->Offset == offset);

+      ASSERT(bufObj->AccessFlags == access);

+   }

+

+   return map;

+}

+

+

+/**

+ * See GL_ARB_map_buffer_range spec

+ */

+void GLAPIENTRY

+_mesa_FlushMappedBufferRange(GLenum target, GLintptr offset, GLsizeiptr length)

+{

+   GET_CURRENT_CONTEXT(ctx);

+   struct gl_buffer_object *bufObj;

+   ASSERT_OUTSIDE_BEGIN_END(ctx);

+

+   if (!ctx->Extensions.ARB_map_buffer_range) {

+      _mesa_error(ctx, GL_INVALID_OPERATION,

+                  "glMapBufferRange(extension not supported)");

+      return;

+   }

+

+   if (offset < 0) {

+      _mesa_error(ctx, GL_INVALID_VALUE,

+                  "glMapBufferRange(offset = %ld)", (long)offset);

+      return;

+   }

+

+   if (length < 0) {

+      _mesa_error(ctx, GL_INVALID_VALUE,

+                  "glMapBufferRange(length = %ld)", (long)length);

+      return;

+   }

+

+   bufObj = get_buffer(ctx, target);

+   if (!bufObj) {

+      _mesa_error(ctx, GL_INVALID_ENUM,

+                  "glMapBufferRange(target = 0x%x)", target);

+      return;

+   }

+

+   if (!_mesa_is_bufferobj(bufObj)) {

+      _mesa_error(ctx, GL_INVALID_OPERATION,

+                  "glMapBufferRange(current buffer is 0)");

+      return;

+   }

+

+   if (!_mesa_bufferobj_mapped(bufObj)) {

+      /* buffer is not mapped */

+      _mesa_error(ctx, GL_INVALID_OPERATION,

+                  "glMapBufferRange(buffer is not mapped)");

+      return;

+   }

+

+   if ((bufObj->AccessFlags & GL_MAP_FLUSH_EXPLICIT_BIT) == 0) {

+      _mesa_error(ctx, GL_INVALID_OPERATION,

+                  "glMapBufferRange(GL_MAP_FLUSH_EXPLICIT_BIT not set)");

+      return;

+   }

+

+   if (offset + length > bufObj->Length) {

+      _mesa_error(ctx, GL_INVALID_VALUE,

+		  "glMapBufferRange(offset %ld + length %ld > mapped length %ld)",

+		  (long)offset, (long)length, (long)bufObj->Length);

+      return;

+   }

+

+   ASSERT(bufObj->AccessFlags & GL_MAP_WRITE_BIT);

+

+   if (ctx->Driver.FlushMappedBufferRange)

+      ctx->Driver.FlushMappedBufferRange(ctx, target, offset, length, bufObj);

+}

+

+

+#if FEATURE_APPLE_object_purgeable

+static GLenum

+_mesa_BufferObjectPurgeable(struct gl_context *ctx, GLuint name, GLenum option)

+{

+   struct gl_buffer_object *bufObj;

+   GLenum retval;

+

+   bufObj = _mesa_lookup_bufferobj(ctx, name);

+   if (!bufObj) {

+      _mesa_error(ctx, GL_INVALID_VALUE,

+                  "glObjectPurgeable(name = 0x%x)", name);

+      return 0;

+   }

+   if (!_mesa_is_bufferobj(bufObj)) {

+      _mesa_error(ctx, GL_INVALID_OPERATION, "glObjectPurgeable(buffer 0)" );

+      return 0;

+   }

+

+   if (bufObj->Purgeable) {

+      _mesa_error(ctx, GL_INVALID_OPERATION,

+                  "glObjectPurgeable(name = 0x%x) is already purgeable", name);

+      return GL_VOLATILE_APPLE;

+   }

+

+   bufObj->Purgeable = GL_TRUE;

+

+   retval = GL_VOLATILE_APPLE;

+   if (ctx->Driver.BufferObjectPurgeable)

+      retval = ctx->Driver.BufferObjectPurgeable(ctx, bufObj, option);

+

+   return retval;

+}

+

+

+static GLenum

+_mesa_RenderObjectPurgeable(struct gl_context *ctx, GLuint name, GLenum option)

+{

+   struct gl_renderbuffer *bufObj;

+   GLenum retval;

+

+   bufObj = _mesa_lookup_renderbuffer(ctx, name);

+   if (!bufObj) {

+      _mesa_error(ctx, GL_INVALID_VALUE,

+                  "glObjectUnpurgeable(name = 0x%x)", name);

+      return 0;

+   }

+

+   if (bufObj->Purgeable) {

+      _mesa_error(ctx, GL_INVALID_OPERATION,

+                  "glObjectPurgeable(name = 0x%x) is already purgeable", name);

+      return GL_VOLATILE_APPLE;

+   }

+

+   bufObj->Purgeable = GL_TRUE;

+

+   retval = GL_VOLATILE_APPLE;

+   if (ctx->Driver.RenderObjectPurgeable)

+      retval = ctx->Driver.RenderObjectPurgeable(ctx, bufObj, option);

+

+   return retval;

+}

+

+

+static GLenum

+_mesa_TextureObjectPurgeable(struct gl_context *ctx, GLuint name, GLenum option)

+{

+   struct gl_texture_object *bufObj;

+   GLenum retval;

+

+   bufObj = _mesa_lookup_texture(ctx, name);

+   if (!bufObj) {

+      _mesa_error(ctx, GL_INVALID_VALUE,

+                  "glObjectPurgeable(name = 0x%x)", name);

+      return 0;

+   }

+

+   if (bufObj->Purgeable) {

+      _mesa_error(ctx, GL_INVALID_OPERATION,

+                  "glObjectPurgeable(name = 0x%x) is already purgeable", name);

+      return GL_VOLATILE_APPLE;

+   }

+

+   bufObj->Purgeable = GL_TRUE;

+

+   retval = GL_VOLATILE_APPLE;

+   if (ctx->Driver.TextureObjectPurgeable)

+      retval = ctx->Driver.TextureObjectPurgeable(ctx, bufObj, option);

+

+   return retval;

+}

+

+

+GLenum GLAPIENTRY

+_mesa_ObjectPurgeableAPPLE(GLenum objectType, GLuint name, GLenum option)

+{

+   GLenum retval;

+

+   GET_CURRENT_CONTEXT(ctx);

+   ASSERT_OUTSIDE_BEGIN_END_WITH_RETVAL(ctx, 0);

+

+   if (name == 0) {

+      _mesa_error(ctx, GL_INVALID_VALUE,

+                  "glObjectPurgeable(name = 0x%x)", name);

+      return 0;

+   }

+

+   switch (option) {

+   case GL_VOLATILE_APPLE:

+   case GL_RELEASED_APPLE:

+      /* legal */

+      break;

+   default:

+      _mesa_error(ctx, GL_INVALID_ENUM,

+                  "glObjectPurgeable(name = 0x%x) invalid option: %d",

+                  name, option);

+      return 0;

+   }

+

+   switch (objectType) {

+   case GL_TEXTURE:

+      retval = _mesa_TextureObjectPurgeable (ctx, name, option);

+      break;

+   case GL_RENDERBUFFER_EXT:

+      retval = _mesa_RenderObjectPurgeable (ctx, name, option);

+      break;

+   case GL_BUFFER_OBJECT_APPLE:

+      retval = _mesa_BufferObjectPurgeable (ctx, name, option);

+      break;

+   default:

+      _mesa_error(ctx, GL_INVALID_ENUM,

+                  "glObjectPurgeable(name = 0x%x) invalid type: %d",

+                  name, objectType);

+      return 0;

+   }

+

+   /* In strict conformance to the spec, we must only return VOLATILE when

+    * when passed the VOLATILE option. Madness.

+    *

+    * XXX First fix the spec, then fix me.

+    */

+   return option == GL_VOLATILE_APPLE ? GL_VOLATILE_APPLE : retval;

+}

+

+

+static GLenum

+_mesa_BufferObjectUnpurgeable(struct gl_context *ctx, GLuint name, GLenum option)

+{

+   struct gl_buffer_object *bufObj;

+   GLenum retval;

+

+   bufObj = _mesa_lookup_bufferobj(ctx, name);

+   if (!bufObj) {

+      _mesa_error(ctx, GL_INVALID_VALUE,

+                  "glObjectUnpurgeable(name = 0x%x)", name);

+      return 0;

+   }

+

+   if (! bufObj->Purgeable) {

+      _mesa_error(ctx, GL_INVALID_OPERATION,

+                  "glObjectUnpurgeable(name = 0x%x) object is "

+                  " already \"unpurged\"", name);

+      return 0;

+   }

+

+   bufObj->Purgeable = GL_FALSE;

+

+   retval = option;

+   if (ctx->Driver.BufferObjectUnpurgeable)

+      retval = ctx->Driver.BufferObjectUnpurgeable(ctx, bufObj, option);

+

+   return retval;

+}

+

+

+static GLenum

+_mesa_RenderObjectUnpurgeable(struct gl_context *ctx, GLuint name, GLenum option)

+{

+   struct gl_renderbuffer *bufObj;

+   GLenum retval;

+

+   bufObj = _mesa_lookup_renderbuffer(ctx, name);

+   if (!bufObj) {

+      _mesa_error(ctx, GL_INVALID_VALUE,

+                  "glObjectUnpurgeable(name = 0x%x)", name);

+      return 0;

+   }

+

+   if (! bufObj->Purgeable) {

+      _mesa_error(ctx, GL_INVALID_OPERATION,

+                  "glObjectUnpurgeable(name = 0x%x) object is "

+                  " already \"unpurged\"", name);

+      return 0;

+   }

+

+   bufObj->Purgeable = GL_FALSE;

+

+   retval = option;

+   if (ctx->Driver.RenderObjectUnpurgeable)

+      retval = ctx->Driver.RenderObjectUnpurgeable(ctx, bufObj, option);

+

+   return retval;

+}

+

+

+static GLenum

+_mesa_TextureObjectUnpurgeable(struct gl_context *ctx, GLuint name, GLenum option)

+{

+   struct gl_texture_object *bufObj;

+   GLenum retval;

+

+   bufObj = _mesa_lookup_texture(ctx, name);

+   if (!bufObj) {

+      _mesa_error(ctx, GL_INVALID_VALUE,

+                  "glObjectUnpurgeable(name = 0x%x)", name);

+      return 0;

+   }

+

+   if (! bufObj->Purgeable) {

+      _mesa_error(ctx, GL_INVALID_OPERATION,

+                  "glObjectUnpurgeable(name = 0x%x) object is"

+                  " already \"unpurged\"", name);

+      return 0;

+   }

+

+   bufObj->Purgeable = GL_FALSE;

+

+   retval = option;

+   if (ctx->Driver.TextureObjectUnpurgeable)

+      retval = ctx->Driver.TextureObjectUnpurgeable(ctx, bufObj, option);

+

+   return retval;

+}

+

+

+GLenum GLAPIENTRY

+_mesa_ObjectUnpurgeableAPPLE(GLenum objectType, GLuint name, GLenum option)

+{

+   GET_CURRENT_CONTEXT(ctx);

+   ASSERT_OUTSIDE_BEGIN_END_WITH_RETVAL(ctx, 0);

+

+   if (name == 0) {

+      _mesa_error(ctx, GL_INVALID_VALUE,

+                  "glObjectUnpurgeable(name = 0x%x)", name);

+      return 0;

+   }

+

+   switch (option) {

+   case GL_RETAINED_APPLE:

+   case GL_UNDEFINED_APPLE:

+      /* legal */

+      break;

+   default:

+      _mesa_error(ctx, GL_INVALID_ENUM,

+                  "glObjectUnpurgeable(name = 0x%x) invalid option: %d",

+                  name, option);

+      return 0;

+   }

+

+   switch (objectType) {

+   case GL_BUFFER_OBJECT_APPLE:

+      return _mesa_BufferObjectUnpurgeable(ctx, name, option);

+   case GL_TEXTURE:

+      return _mesa_TextureObjectUnpurgeable(ctx, name, option);

+   case GL_RENDERBUFFER_EXT:

+      return _mesa_RenderObjectUnpurgeable(ctx, name, option);

+   default:

+      _mesa_error(ctx, GL_INVALID_ENUM,

+                  "glObjectUnpurgeable(name = 0x%x) invalid type: %d",

+                  name, objectType);

+      return 0;

+   }

+}

+

+

+static void

+_mesa_GetBufferObjectParameterivAPPLE(struct gl_context *ctx, GLuint name,

+                                      GLenum pname, GLint* params)

+{

+   struct gl_buffer_object *bufObj;

+

+   bufObj = _mesa_lookup_bufferobj(ctx, name);

+   if (!bufObj) {

+      _mesa_error(ctx, GL_INVALID_VALUE,

+                  "glGetObjectParameteriv(name = 0x%x) invalid object", name);

+      return;

+   }

+

+   switch (pname) {

+   case GL_PURGEABLE_APPLE:

+      *params = bufObj->Purgeable;

+      break;

+   default:

+      _mesa_error(ctx, GL_INVALID_ENUM,

+                  "glGetObjectParameteriv(name = 0x%x) invalid enum: %d",

+                  name, pname);

+      break;

+   }

+}

+

+

+static void

+_mesa_GetRenderObjectParameterivAPPLE(struct gl_context *ctx, GLuint name,

+                                      GLenum pname, GLint* params)

+{

+   struct gl_renderbuffer *bufObj;

+

+   bufObj = _mesa_lookup_renderbuffer(ctx, name);

+   if (!bufObj) {

+      _mesa_error(ctx, GL_INVALID_VALUE,

+                  "glObjectUnpurgeable(name = 0x%x)", name);

+      return;

+   }

+

+   switch (pname) {

+   case GL_PURGEABLE_APPLE:

+      *params = bufObj->Purgeable;

+      break;

+   default:

+      _mesa_error(ctx, GL_INVALID_ENUM,

+                  "glGetObjectParameteriv(name = 0x%x) invalid enum: %d",

+                  name, pname);

+      break;

+   }

+}

+

+

+static void

+_mesa_GetTextureObjectParameterivAPPLE(struct gl_context *ctx, GLuint name,

+                                       GLenum pname, GLint* params)

+{

+   struct gl_texture_object *bufObj;

+

+   bufObj = _mesa_lookup_texture(ctx, name);

+   if (!bufObj) {

+      _mesa_error(ctx, GL_INVALID_VALUE,

+                  "glObjectUnpurgeable(name = 0x%x)", name);

+      return;

+   }

+

+   switch (pname) {

+   case GL_PURGEABLE_APPLE:

+      *params = bufObj->Purgeable;

+      break;

+   default:

+      _mesa_error(ctx, GL_INVALID_ENUM,

+                  "glGetObjectParameteriv(name = 0x%x) invalid enum: %d",

+                  name, pname);

+      break;

+   }

+}

+

+

+void GLAPIENTRY

+_mesa_GetObjectParameterivAPPLE(GLenum objectType, GLuint name, GLenum pname,

+                                GLint* params)

+{

+   GET_CURRENT_CONTEXT(ctx);

+

+   if (name == 0) {

+      _mesa_error(ctx, GL_INVALID_VALUE,

+                  "glGetObjectParameteriv(name = 0x%x)", name);

+      return;

+   }

+

+   switch (objectType) {

+   case GL_TEXTURE:

+      _mesa_GetTextureObjectParameterivAPPLE (ctx, name, pname, params);

+      break;

+   case GL_BUFFER_OBJECT_APPLE:

+      _mesa_GetBufferObjectParameterivAPPLE (ctx, name, pname, params);

+      break;

+   case GL_RENDERBUFFER_EXT:

+      _mesa_GetRenderObjectParameterivAPPLE (ctx, name, pname, params);

+      break;

+   default:

+      _mesa_error(ctx, GL_INVALID_ENUM,

+                  "glGetObjectParameteriv(name = 0x%x) invalid type: %d",

+                  name, objectType);

+   }

+}

+

+#endif /* FEATURE_APPLE_object_purgeable */

diff --git a/mesalib/src/mesa/main/context.c b/mesalib/src/mesa/main/context.c
index 5d581c840..d5baf4a29 100644
--- a/mesalib/src/mesa/main/context.c
+++ b/mesalib/src/mesa/main/context.c
@@ -1,1883 +1,1885 @@
-/*
- * Mesa 3-D graphics library
- * Version:  7.3
- *
- * Copyright (C) 1999-2007  Brian Paul   All Rights Reserved.
- * Copyright (C) 2008  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 context.c
- * Mesa context/visual/framebuffer management functions.
- * \author Brian Paul
- */
-
-/**
- * \mainpage Mesa Main Module
- *
- * \section MainIntroduction Introduction
- *
- * The Mesa Main module consists of all the files in the main/ directory.
- * Among the features of this module are:
- * <UL>
- * <LI> Structures to represent most GL state </LI>
- * <LI> State set/get functions </LI>
- * <LI> Display lists </LI>
- * <LI> Texture unit, object and image handling </LI>
- * <LI> Matrix and attribute stacks </LI>
- * </UL>
- *
- * Other modules are responsible for API dispatch, vertex transformation,
- * point/line/triangle setup, rasterization, vertex array caching,
- * vertex/fragment programs/shaders, etc.
- *
- *
- * \section AboutDoxygen About Doxygen
- *
- * If you're viewing this information as Doxygen-generated HTML you'll
- * see the documentation index at the top of this page.
- *
- * The first line lists the Mesa source code modules.
- * The second line lists the indexes available for viewing the documentation
- * for each module.
- *
- * Selecting the <b>Main page</b> link will display a summary of the module
- * (this page).
- *
- * Selecting <b>Data Structures</b> will list all C structures.
- *
- * Selecting the <b>File List</b> link will list all the source files in
- * the module.
- * Selecting a filename will show a list of all functions defined in that file.
- *
- * Selecting the <b>Data Fields</b> link will display a list of all
- * documented structure members.
- *
- * Selecting the <b>Globals</b> link will display a list
- * of all functions, structures, global variables and macros in the module.
- *
- */
-
-
-#include "glheader.h"
-#include "mfeatures.h"
-#include "imports.h"
-#include "accum.h"
-#include "api_exec.h"
-#include "arrayobj.h"
-#include "attrib.h"
-#include "blend.h"
-#include "buffers.h"
-#include "bufferobj.h"
-#include "context.h"
-#include "cpuinfo.h"
-#include "debug.h"
-#include "depth.h"
-#include "dlist.h"
-#include "eval.h"
-#include "extensions.h"
-#include "fbobject.h"
-#include "feedback.h"
-#include "fog.h"
-#include "formats.h"
-#include "framebuffer.h"
-#include "hint.h"
-#include "hash.h"
-#include "light.h"
-#include "lines.h"
-#include "macros.h"
-#include "matrix.h"
-#include "multisample.h"
-#include "pixel.h"
-#include "pixelstore.h"
-#include "points.h"
-#include "polygon.h"
-#include "queryobj.h"
-#include "syncobj.h"
-#include "rastpos.h"
-#include "remap.h"
-#include "scissor.h"
-#include "shared.h"
-#include "shaderobj.h"
-#include "simple_list.h"
-#include "state.h"
-#include "stencil.h"
-#include "texcompress_s3tc.h"
-#include "texstate.h"
-#include "transformfeedback.h"
-#include "mtypes.h"
-#include "varray.h"
-#include "version.h"
-#include "viewport.h"
-#include "vtxfmt.h"
-#include "program/program.h"
-#include "program/prog_print.h"
-#if _HAVE_FULL_GL
-#include "math/m_matrix.h"
-#endif
-#include "main/dispatch.h" /* for _gloffset_COUNT */
-
-#ifdef USE_SPARC_ASM
-#include "sparc/sparc.h"
-#endif
-
-#include "glsl_parser_extras.h"
-#include <stdbool.h>
-
-
-#ifndef MESA_VERBOSE
-int MESA_VERBOSE = 0;
-#endif
-
-#ifndef MESA_DEBUG_FLAGS
-int MESA_DEBUG_FLAGS = 0;
-#endif
-
-
-/* ubyte -> float conversion */
-GLfloat _mesa_ubyte_to_float_color_tab[256];
-
-
-
-/**
- * Swap buffers notification callback.
- * 
- * \param ctx GL context.
- *
- * Called by window system just before swapping buffers.
- * We have to finish any pending rendering.
- */
-void
-_mesa_notifySwapBuffers(struct gl_context *ctx)
-{
-   if (MESA_VERBOSE & VERBOSE_SWAPBUFFERS)
-      _mesa_debug(ctx, "SwapBuffers\n");
-   FLUSH_CURRENT( ctx, 0 );
-   if (ctx->Driver.Flush) {
-      ctx->Driver.Flush(ctx);
-   }
-}
-
-
-/**********************************************************************/
-/** \name GL Visual allocation/destruction                            */
-/**********************************************************************/
-/*@{*/
-
-/**
- * Allocates a struct gl_config structure and initializes it via
- * _mesa_initialize_visual().
- * 
- * \param dbFlag double buffering
- * \param stereoFlag stereo buffer
- * \param depthBits requested bits per depth buffer value. Any value in [0, 32]
- * is acceptable but the actual depth type will be GLushort or GLuint as
- * needed.
- * \param stencilBits requested minimum bits per stencil buffer value
- * \param accumRedBits, accumGreenBits, accumBlueBits, accumAlphaBits number of bits per color component in accum buffer.
- * \param indexBits number of bits per pixel if \p rgbFlag is GL_FALSE
- * \param redBits number of bits per color component in frame buffer for RGB(A)
- * mode.  We always use 8 in core Mesa though.
- * \param greenBits same as above.
- * \param blueBits same as above.
- * \param alphaBits same as above.
- * \param numSamples not really used.
- * 
- * \return pointer to new struct gl_config or NULL if requested parameters can't be
- * met.
- *
- * \note Need to add params for level and numAuxBuffers (at least)
- */
-struct gl_config *
-_mesa_create_visual( GLboolean dbFlag,
-                     GLboolean stereoFlag,
-                     GLint redBits,
-                     GLint greenBits,
-                     GLint blueBits,
-                     GLint alphaBits,
-                     GLint depthBits,
-                     GLint stencilBits,
-                     GLint accumRedBits,
-                     GLint accumGreenBits,
-                     GLint accumBlueBits,
-                     GLint accumAlphaBits,
-                     GLint numSamples )
-{
-   struct gl_config *vis = CALLOC_STRUCT(gl_config);
-   if (vis) {
-      if (!_mesa_initialize_visual(vis, dbFlag, stereoFlag,
-                                   redBits, greenBits, blueBits, alphaBits,
-                                   depthBits, stencilBits,
-                                   accumRedBits, accumGreenBits,
-                                   accumBlueBits, accumAlphaBits,
-                                   numSamples)) {
-         free(vis);
-         return NULL;
-      }
-   }
-   return vis;
-}
-
-
-/**
- * Makes some sanity checks and fills in the fields of the struct
- * gl_config object with the given parameters.  If the caller needs to
- * set additional fields, he should just probably init the whole
- * gl_config object himself.
- *
- * \return GL_TRUE on success, or GL_FALSE on failure.
- *
- * \sa _mesa_create_visual() above for the parameter description.
- */
-GLboolean
-_mesa_initialize_visual( struct gl_config *vis,
-                         GLboolean dbFlag,
-                         GLboolean stereoFlag,
-                         GLint redBits,
-                         GLint greenBits,
-                         GLint blueBits,
-                         GLint alphaBits,
-                         GLint depthBits,
-                         GLint stencilBits,
-                         GLint accumRedBits,
-                         GLint accumGreenBits,
-                         GLint accumBlueBits,
-                         GLint accumAlphaBits,
-                         GLint numSamples )
-{
-   assert(vis);
-
-   if (depthBits < 0 || depthBits > 32) {
-      return GL_FALSE;
-   }
-   if (stencilBits < 0 || stencilBits > STENCIL_BITS) {
-      return GL_FALSE;
-   }
-   assert(accumRedBits >= 0);
-   assert(accumGreenBits >= 0);
-   assert(accumBlueBits >= 0);
-   assert(accumAlphaBits >= 0);
-
-   vis->rgbMode          = GL_TRUE;
-   vis->doubleBufferMode = dbFlag;
-   vis->stereoMode       = stereoFlag;
-
-   vis->redBits          = redBits;
-   vis->greenBits        = greenBits;
-   vis->blueBits         = blueBits;
-   vis->alphaBits        = alphaBits;
-   vis->rgbBits          = redBits + greenBits + blueBits;
-
-   vis->indexBits      = 0;
-   vis->depthBits      = depthBits;
-   vis->stencilBits    = stencilBits;
-
-   vis->accumRedBits   = accumRedBits;
-   vis->accumGreenBits = accumGreenBits;
-   vis->accumBlueBits  = accumBlueBits;
-   vis->accumAlphaBits = accumAlphaBits;
-
-   vis->haveAccumBuffer   = accumRedBits > 0;
-   vis->haveDepthBuffer   = depthBits > 0;
-   vis->haveStencilBuffer = stencilBits > 0;
-
-   vis->numAuxBuffers = 0;
-   vis->level = 0;
-   vis->sampleBuffers = numSamples > 0 ? 1 : 0;
-   vis->samples = numSamples;
-
-   return GL_TRUE;
-}
-
-
-/**
- * Destroy a visual and free its memory.
- *
- * \param vis visual.
- * 
- * Frees the visual structure.
- */
-void
-_mesa_destroy_visual( struct gl_config *vis )
-{
-   free(vis);
-}
-
-/*@}*/
-
-
-/**********************************************************************/
-/** \name Context allocation, initialization, destroying
- *
- * The purpose of the most initialization functions here is to provide the
- * default state values according to the OpenGL specification.
- */
-/**********************************************************************/
-/*@{*/
-
-
-/**
- * This is lame.  gdb only seems to recognize enum types that are
- * actually used somewhere.  We want to be able to print/use enum
- * values such as TEXTURE_2D_INDEX in gdb.  But we don't actually use
- * the gl_texture_index type anywhere.  Thus, this lame function.
- */
-static void
-dummy_enum_func(void)
-{
-   gl_buffer_index bi = BUFFER_FRONT_LEFT;
-   gl_face_index fi = FACE_POS_X;
-   gl_frag_attrib fa = FRAG_ATTRIB_WPOS;
-   gl_frag_result fr = FRAG_RESULT_DEPTH;
-   gl_texture_index ti = TEXTURE_2D_ARRAY_INDEX;
-   gl_vert_attrib va = VERT_ATTRIB_POS;
-   gl_vert_result vr = VERT_RESULT_HPOS;
-   gl_geom_attrib ga = GEOM_ATTRIB_POSITION;
-   gl_geom_result gr = GEOM_RESULT_POS;
-
-   (void) bi;
-   (void) fi;
-   (void) fa;
-   (void) fr;
-   (void) ti;
-   (void) va;
-   (void) vr;
-   (void) ga;
-   (void) gr;
-}
-
-
-/**
- * One-time initialization mutex lock.
- *
- * \sa Used by one_time_init().
- */
-_glthread_DECLARE_STATIC_MUTEX(OneTimeLock);
-
-
-
-/**
- * Calls all the various one-time-init functions in Mesa.
- *
- * While holding a global mutex lock, calls several initialization functions,
- * and sets the glapi callbacks if the \c MESA_DEBUG environment variable is
- * defined.
- *
- * \sa _math_init().
- */
-static void
-one_time_init( struct gl_context *ctx )
-{
-   static GLbitfield api_init_mask = 0x0;
-
-   _glthread_LOCK_MUTEX(OneTimeLock);
-
-   /* truly one-time init */
-   if (!api_init_mask) {
-      GLuint i;
-
-      /* do some implementation tests */
-      assert( sizeof(GLbyte) == 1 );
-      assert( sizeof(GLubyte) == 1 );
-      assert( sizeof(GLshort) == 2 );
-      assert( sizeof(GLushort) == 2 );
-      assert( sizeof(GLint) == 4 );
-      assert( sizeof(GLuint) == 4 );
-
-      _mesa_get_cpu_features();
-
-      _mesa_init_sqrt_table();
-
-      /* context dependence is never a one-time thing... */
-      _mesa_init_get_hash(ctx);
-
-      for (i = 0; i < 256; i++) {
-         _mesa_ubyte_to_float_color_tab[i] = (float) i / 255.0F;
-      }
-
-#if defined(DEBUG) && defined(__DATE__) && defined(__TIME__)
-      if (MESA_VERBOSE != 0) {
-	 _mesa_debug(ctx, "Mesa %s DEBUG build %s %s\n",
-		     MESA_VERSION_STRING, __DATE__, __TIME__);
-      }
-#endif
-
-#ifdef DEBUG
-      _mesa_test_formats();
-#endif
-   }
-
-   /* per-API one-time init */
-   if (!(api_init_mask & (1 << ctx->API))) {
-      /*
-       * This is fine as ES does not use the remap table, but it may not be
-       * future-proof.  We cannot always initialize the remap table because
-       * when an app is linked to libGLES*, there are not enough dynamic
-       * entries.
-       */
-      if (ctx->API == API_OPENGL)
-         _mesa_init_remap_table();
-   }
-
-   api_init_mask |= 1 << ctx->API;
-
-   _glthread_UNLOCK_MUTEX(OneTimeLock);
-
-   /* Hopefully atexit() is widely available.  If not, we may need some
-    * #ifdef tests here.
-    */
-   atexit(_mesa_destroy_shader_compiler);
-
-   dummy_enum_func();
-}
-
-
-/**
- * Initialize fields of gl_current_attrib (aka ctx->Current.*)
- */
-static void
-_mesa_init_current(struct gl_context *ctx)
-{
-   GLuint i;
-
-   /* Init all to (0,0,0,1) */
-   for (i = 0; i < Elements(ctx->Current.Attrib); i++) {
-      ASSIGN_4V( ctx->Current.Attrib[i], 0.0, 0.0, 0.0, 1.0 );
-   }
-
-   /* redo special cases: */
-   ASSIGN_4V( ctx->Current.Attrib[VERT_ATTRIB_WEIGHT], 1.0, 0.0, 0.0, 0.0 );
-   ASSIGN_4V( ctx->Current.Attrib[VERT_ATTRIB_NORMAL], 0.0, 0.0, 1.0, 1.0 );
-   ASSIGN_4V( ctx->Current.Attrib[VERT_ATTRIB_COLOR0], 1.0, 1.0, 1.0, 1.0 );
-   ASSIGN_4V( ctx->Current.Attrib[VERT_ATTRIB_COLOR1], 0.0, 0.0, 0.0, 1.0 );
-   ASSIGN_4V( ctx->Current.Attrib[VERT_ATTRIB_COLOR_INDEX], 1.0, 0.0, 0.0, 1.0 );
-   ASSIGN_4V( ctx->Current.Attrib[VERT_ATTRIB_EDGEFLAG], 1.0, 0.0, 0.0, 1.0 );
-}
-
-
-/**
- * Init vertex/fragment/geometry program limits.
- * Important: drivers should override these with actual limits.
- */
-static void
-init_program_limits(GLenum type, struct gl_program_constants *prog)
-{
-   prog->MaxInstructions = MAX_PROGRAM_INSTRUCTIONS;
-   prog->MaxAluInstructions = MAX_PROGRAM_INSTRUCTIONS;
-   prog->MaxTexInstructions = MAX_PROGRAM_INSTRUCTIONS;
-   prog->MaxTexIndirections = MAX_PROGRAM_INSTRUCTIONS;
-   prog->MaxTemps = MAX_PROGRAM_TEMPS;
-   prog->MaxEnvParams = MAX_PROGRAM_ENV_PARAMS;
-   prog->MaxLocalParams = MAX_PROGRAM_LOCAL_PARAMS;
-   prog->MaxUniformComponents = 4 * MAX_UNIFORMS;
-   prog->MaxAddressOffset = MAX_PROGRAM_LOCAL_PARAMS;
-
-   switch (type) {
-   case GL_VERTEX_PROGRAM_ARB:
-      prog->MaxParameters = MAX_VERTEX_PROGRAM_PARAMS;
-      prog->MaxAttribs = MAX_NV_VERTEX_PROGRAM_INPUTS;
-      prog->MaxAddressRegs = MAX_VERTEX_PROGRAM_ADDRESS_REGS;
-      break;
-   case GL_FRAGMENT_PROGRAM_ARB:
-      prog->MaxParameters = MAX_NV_FRAGMENT_PROGRAM_PARAMS;
-      prog->MaxAttribs = MAX_NV_FRAGMENT_PROGRAM_INPUTS;
-      prog->MaxAddressRegs = MAX_FRAGMENT_PROGRAM_ADDRESS_REGS;
-      break;
-   case MESA_GEOMETRY_PROGRAM:
-      prog->MaxParameters = MAX_NV_VERTEX_PROGRAM_PARAMS;
-      prog->MaxAttribs = MAX_NV_VERTEX_PROGRAM_INPUTS;
-      prog->MaxAddressRegs = MAX_VERTEX_PROGRAM_ADDRESS_REGS;
-
-      prog->MaxGeometryTextureImageUnits = MAX_GEOMETRY_TEXTURE_IMAGE_UNITS;
-      prog->MaxGeometryVaryingComponents = MAX_GEOMETRY_VARYING_COMPONENTS;
-      prog->MaxVertexVaryingComponents = MAX_VERTEX_VARYING_COMPONENTS;
-      prog->MaxGeometryUniformComponents = MAX_GEOMETRY_UNIFORM_COMPONENTS;
-      prog->MaxGeometryOutputVertices = MAX_GEOMETRY_OUTPUT_VERTICES;
-      prog->MaxGeometryTotalOutputComponents = MAX_GEOMETRY_TOTAL_OUTPUT_COMPONENTS;
-      break;
-   default:
-      assert(0 && "Bad program type in init_program_limits()");
-   }
-
-   /* Set the native limits to zero.  This implies that there is no native
-    * support for shaders.  Let the drivers fill in the actual values.
-    */
-   prog->MaxNativeInstructions = 0;
-   prog->MaxNativeAluInstructions = 0;
-   prog->MaxNativeTexInstructions = 0;
-   prog->MaxNativeTexIndirections = 0;
-   prog->MaxNativeAttribs = 0;
-   prog->MaxNativeTemps = 0;
-   prog->MaxNativeAddressRegs = 0;
-   prog->MaxNativeParameters = 0;
-
-   /* Set GLSL datatype range/precision info assuming IEEE float values.
-    * Drivers should override these defaults as needed.
-    */
-   prog->MediumFloat.RangeMin = 127;
-   prog->MediumFloat.RangeMax = 127;
-   prog->MediumFloat.Precision = 23;
-   prog->LowFloat = prog->HighFloat = prog->MediumFloat;
-
-   /* Assume ints are stored as floats for now, since this is the least-common
-    * denominator.  The OpenGL ES spec implies (page 132) that the precision
-    * of integer types should be 0.  Practically speaking, IEEE
-    * single-precision floating point values can only store integers in the
-    * range [-0x01000000, 0x01000000] without loss of precision.
-    */
-   prog->MediumInt.RangeMin = 24;
-   prog->MediumInt.RangeMax = 24;
-   prog->MediumInt.Precision = 0;
-   prog->LowInt = prog->HighInt = prog->MediumInt;
-}
-
-
-/**
- * Initialize fields of gl_constants (aka ctx->Const.*).
- * Use defaults from config.h.  The device drivers will often override
- * some of these values (such as number of texture units).
- */
-static void 
-_mesa_init_constants(struct gl_context *ctx)
-{
-   assert(ctx);
-
-   /* Constants, may be overriden (usually only reduced) by device drivers */
-   ctx->Const.MaxTextureMbytes = MAX_TEXTURE_MBYTES;
-   ctx->Const.MaxTextureLevels = MAX_TEXTURE_LEVELS;
-   ctx->Const.Max3DTextureLevels = MAX_3D_TEXTURE_LEVELS;
-   ctx->Const.MaxCubeTextureLevels = MAX_CUBE_TEXTURE_LEVELS;
-   ctx->Const.MaxTextureRectSize = MAX_TEXTURE_RECT_SIZE;
-   ctx->Const.MaxArrayTextureLayers = MAX_ARRAY_TEXTURE_LAYERS;
-   ctx->Const.MaxTextureCoordUnits = MAX_TEXTURE_COORD_UNITS;
-   ctx->Const.MaxTextureImageUnits = MAX_TEXTURE_IMAGE_UNITS;
-   ctx->Const.MaxTextureUnits = MIN2(ctx->Const.MaxTextureCoordUnits,
-                                     ctx->Const.MaxTextureImageUnits);
-   ctx->Const.MaxTextureMaxAnisotropy = MAX_TEXTURE_MAX_ANISOTROPY;
-   ctx->Const.MaxTextureLodBias = MAX_TEXTURE_LOD_BIAS;
-   ctx->Const.MaxArrayLockSize = MAX_ARRAY_LOCK_SIZE;
-   ctx->Const.SubPixelBits = SUB_PIXEL_BITS;
-   ctx->Const.MinPointSize = MIN_POINT_SIZE;
-   ctx->Const.MaxPointSize = MAX_POINT_SIZE;
-   ctx->Const.MinPointSizeAA = MIN_POINT_SIZE;
-   ctx->Const.MaxPointSizeAA = MAX_POINT_SIZE;
-   ctx->Const.PointSizeGranularity = (GLfloat) POINT_SIZE_GRANULARITY;
-   ctx->Const.MinLineWidth = MIN_LINE_WIDTH;
-   ctx->Const.MaxLineWidth = MAX_LINE_WIDTH;
-   ctx->Const.MinLineWidthAA = MIN_LINE_WIDTH;
-   ctx->Const.MaxLineWidthAA = MAX_LINE_WIDTH;
-   ctx->Const.LineWidthGranularity = (GLfloat) LINE_WIDTH_GRANULARITY;
-   ctx->Const.MaxColorTableSize = MAX_COLOR_TABLE_SIZE;
-   ctx->Const.MaxClipPlanes = MAX_CLIP_PLANES;
-   ctx->Const.MaxLights = MAX_LIGHTS;
-   ctx->Const.MaxShininess = 128.0;
-   ctx->Const.MaxSpotExponent = 128.0;
-   ctx->Const.MaxViewportWidth = MAX_WIDTH;
-   ctx->Const.MaxViewportHeight = MAX_HEIGHT;
-#if FEATURE_ARB_vertex_program
-   init_program_limits(GL_VERTEX_PROGRAM_ARB, &ctx->Const.VertexProgram);
-#endif
-#if FEATURE_ARB_fragment_program
-   init_program_limits(GL_FRAGMENT_PROGRAM_ARB, &ctx->Const.FragmentProgram);
-#endif
-#if FEATURE_ARB_geometry_shader4
-   init_program_limits(MESA_GEOMETRY_PROGRAM, &ctx->Const.GeometryProgram);
-#endif
-   ctx->Const.MaxProgramMatrices = MAX_PROGRAM_MATRICES;
-   ctx->Const.MaxProgramMatrixStackDepth = MAX_PROGRAM_MATRIX_STACK_DEPTH;
-
-   /* CheckArrayBounds is overriden by drivers/x11 for X server */
-   ctx->Const.CheckArrayBounds = GL_FALSE;
-
-   /* GL_ARB_draw_buffers */
-   ctx->Const.MaxDrawBuffers = MAX_DRAW_BUFFERS;
-
-#if FEATURE_EXT_framebuffer_object
-   ctx->Const.MaxColorAttachments = MAX_COLOR_ATTACHMENTS;
-   ctx->Const.MaxRenderbufferSize = MAX_WIDTH;
-#endif
-
-#if FEATURE_ARB_vertex_shader
-   ctx->Const.MaxVertexTextureImageUnits = MAX_VERTEX_TEXTURE_IMAGE_UNITS;
-   ctx->Const.MaxCombinedTextureImageUnits = MAX_COMBINED_TEXTURE_IMAGE_UNITS;
-   ctx->Const.MaxVarying = MAX_VARYING;
-#endif
-
-   /* Shading language version */
-   if (ctx->API == API_OPENGL) {
-      ctx->Const.GLSLVersion = 120;
-   }
-   else if (ctx->API == API_OPENGLES2) {
-      ctx->Const.GLSLVersion = 100;
-   }
-   else if (ctx->API == API_OPENGLES) {
-      ctx->Const.GLSLVersion = 0; /* GLSL not supported */
-   }
-
-   /* GL_ARB_framebuffer_object */
-   ctx->Const.MaxSamples = 0;
-
-   /* GL_ARB_sync */
-   ctx->Const.MaxServerWaitTimeout = (GLuint64) ~0;
-
-   /* GL_ATI_envmap_bumpmap */
-   ctx->Const.SupportedBumpUnits = SUPPORTED_ATI_BUMP_UNITS;
-
-   /* GL_EXT_provoking_vertex */
-   ctx->Const.QuadsFollowProvokingVertexConvention = GL_TRUE;
-
-   /* GL_EXT_transform_feedback */
-   ctx->Const.MaxTransformFeedbackSeparateAttribs = MAX_FEEDBACK_ATTRIBS;
-   ctx->Const.MaxTransformFeedbackSeparateComponents = 4 * MAX_FEEDBACK_ATTRIBS;
-   ctx->Const.MaxTransformFeedbackInterleavedComponents = 4 * MAX_FEEDBACK_ATTRIBS;
-
-   /* GL 3.2: hard-coded for now: */
-   ctx->Const.ProfileMask = GL_CONTEXT_COMPATIBILITY_PROFILE_BIT;
-
-   /** GL_EXT_gpu_shader4 */
-   ctx->Const.MinProgramTexelOffset = -8;
-   ctx->Const.MaxProgramTexelOffset = 7;
-}
-
-
-/**
- * Do some sanity checks on the limits/constants for the given context.
- * Only called the first time a context is bound.
- */
-static void
-check_context_limits(struct gl_context *ctx)
-{
-   /* check that we don't exceed the size of various bitfields */
-   assert(VERT_RESULT_MAX <=
-	  (8 * sizeof(ctx->VertexProgram._Current->Base.OutputsWritten)));
-   assert(FRAG_ATTRIB_MAX <=
-	  (8 * sizeof(ctx->FragmentProgram._Current->Base.InputsRead)));
-
-   assert(MAX_COMBINED_TEXTURE_IMAGE_UNITS <= 8 * sizeof(GLbitfield));
-
-   /* shader-related checks */
-   assert(ctx->Const.FragmentProgram.MaxLocalParams <= MAX_PROGRAM_LOCAL_PARAMS);
-   assert(ctx->Const.VertexProgram.MaxLocalParams <= MAX_PROGRAM_LOCAL_PARAMS);
-
-   assert(MAX_NV_FRAGMENT_PROGRAM_TEMPS <= MAX_PROGRAM_TEMPS);
-   assert(MAX_NV_VERTEX_PROGRAM_TEMPS <= MAX_PROGRAM_TEMPS);
-   assert(MAX_NV_VERTEX_PROGRAM_INPUTS <= VERT_ATTRIB_MAX);
-   assert(MAX_NV_VERTEX_PROGRAM_OUTPUTS <= VERT_RESULT_MAX);
-
-   /* Texture unit checks */
-   assert(ctx->Const.MaxTextureImageUnits > 0);
-   assert(ctx->Const.MaxTextureImageUnits <= MAX_TEXTURE_IMAGE_UNITS);
-   assert(ctx->Const.MaxTextureCoordUnits > 0);
-   assert(ctx->Const.MaxTextureCoordUnits <= MAX_TEXTURE_COORD_UNITS);
-   assert(ctx->Const.MaxTextureUnits > 0);
-   assert(ctx->Const.MaxTextureUnits <= MAX_TEXTURE_IMAGE_UNITS);
-   assert(ctx->Const.MaxTextureUnits <= MAX_TEXTURE_COORD_UNITS);
-   assert(ctx->Const.MaxTextureUnits == MIN2(ctx->Const.MaxTextureImageUnits,
-                                             ctx->Const.MaxTextureCoordUnits));
-   assert(ctx->Const.MaxCombinedTextureImageUnits > 0);
-   assert(ctx->Const.MaxCombinedTextureImageUnits <= MAX_COMBINED_TEXTURE_IMAGE_UNITS);
-   assert(ctx->Const.MaxTextureCoordUnits <= MAX_COMBINED_TEXTURE_IMAGE_UNITS);
-   /* number of coord units cannot be greater than number of image units */
-   assert(ctx->Const.MaxTextureCoordUnits <= ctx->Const.MaxTextureImageUnits);
-
-
-   /* Texture size checks */
-   assert(ctx->Const.MaxTextureLevels <= MAX_TEXTURE_LEVELS);
-   assert(ctx->Const.Max3DTextureLevels <= MAX_3D_TEXTURE_LEVELS);
-   assert(ctx->Const.MaxCubeTextureLevels <= MAX_CUBE_TEXTURE_LEVELS);
-   assert(ctx->Const.MaxTextureRectSize <= MAX_TEXTURE_RECT_SIZE);
-
-   /* make sure largest texture image is <= MAX_WIDTH in size */
-   assert((1 << (ctx->Const.MaxTextureLevels - 1)) <= MAX_WIDTH);
-   assert((1 << (ctx->Const.MaxCubeTextureLevels - 1)) <= MAX_WIDTH);
-   assert((1 << (ctx->Const.Max3DTextureLevels - 1)) <= MAX_WIDTH);
-
-   /* Texture level checks */
-   assert(MAX_TEXTURE_LEVELS >= MAX_3D_TEXTURE_LEVELS);
-   assert(MAX_TEXTURE_LEVELS >= MAX_CUBE_TEXTURE_LEVELS);
-
-   /* Max texture size should be <= max viewport size (render to texture) */
-   assert((1 << (MAX_TEXTURE_LEVELS - 1)) <= MAX_WIDTH);
-
-   assert(ctx->Const.MaxViewportWidth <= MAX_WIDTH);
-   assert(ctx->Const.MaxViewportHeight <= MAX_WIDTH);
-
-   assert(ctx->Const.MaxDrawBuffers <= MAX_DRAW_BUFFERS);
-
-   /* if this fails, add more enum values to gl_buffer_index */
-   assert(BUFFER_COLOR0 + MAX_DRAW_BUFFERS <= BUFFER_COUNT);
-
-   /* XXX probably add more tests */
-}
-
-
-/**
- * Initialize the attribute groups in a GL context.
- *
- * \param ctx GL context.
- *
- * Initializes all the attributes, calling the respective <tt>init*</tt>
- * functions for the more complex data structures.
- */
-static GLboolean
-init_attrib_groups(struct gl_context *ctx)
-{
-   assert(ctx);
-
-   /* Constants */
-   _mesa_init_constants( ctx );
-
-   /* Extensions */
-   _mesa_init_extensions( ctx );
-
-   /* Attribute Groups */
-   _mesa_init_accum( ctx );
-   _mesa_init_attrib( ctx );
-   _mesa_init_buffer_objects( ctx );
-   _mesa_init_color( ctx );
-   _mesa_init_current( ctx );
-   _mesa_init_depth( ctx );
-   _mesa_init_debug( ctx );
-   _mesa_init_display_list( ctx );
-   _mesa_init_eval( ctx );
-   _mesa_init_fbobjects( ctx );
-   _mesa_init_feedback( ctx );
-   _mesa_init_fog( ctx );
-   _mesa_init_hint( ctx );
-   _mesa_init_line( ctx );
-   _mesa_init_lighting( ctx );
-   _mesa_init_matrix( ctx );
-   _mesa_init_multisample( ctx );
-   _mesa_init_pixel( ctx );
-   _mesa_init_pixelstore( ctx );
-   _mesa_init_point( ctx );
-   _mesa_init_polygon( ctx );
-   _mesa_init_program( ctx );
-   _mesa_init_queryobj( ctx );
-   _mesa_init_sync( ctx );
-   _mesa_init_rastpos( ctx );
-   _mesa_init_scissor( ctx );
-   _mesa_init_shader_state( ctx );
-   _mesa_init_stencil( ctx );
-   _mesa_init_transform( ctx );
-   _mesa_init_transform_feedback( ctx );
-   _mesa_init_varray( ctx );
-   _mesa_init_viewport( ctx );
-
-   if (!_mesa_init_texture( ctx ))
-      return GL_FALSE;
-
-   _mesa_init_texture_s3tc( ctx );
-
-   /* Miscellaneous */
-   ctx->NewState = _NEW_ALL;
-   ctx->ErrorValue = (GLenum) GL_NO_ERROR;
-   ctx->varying_vp_inputs = ~0;
-
-   return GL_TRUE;
-}
-
-
-/**
- * Update default objects in a GL context with respect to shared state.
- *
- * \param ctx GL context.
- *
- * Removes references to old default objects, (texture objects, program
- * objects, etc.) and changes to reference those from the current shared
- * state.
- */
-static GLboolean
-update_default_objects(struct gl_context *ctx)
-{
-   assert(ctx);
-
-   _mesa_update_default_objects_program(ctx);
-   _mesa_update_default_objects_texture(ctx);
-   _mesa_update_default_objects_buffer_objects(ctx);
-
-   return GL_TRUE;
-}
-
-
-/**
- * This is the default function we plug into all dispatch table slots
- * This helps prevents a segfault when someone calls a GL function without
- * first checking if the extension's supported.
- */
-static int
-generic_nop(void)
-{
-   _mesa_warning(NULL, "User called no-op dispatch function (an unsupported extension function?)");
-   return 0;
-}
-
-
-/**
- * Allocate and initialize a new dispatch table.
- */
-struct _glapi_table *
-_mesa_alloc_dispatch_table(int size)
-{
-   /* Find the larger of Mesa's dispatch table and libGL's dispatch table.
-    * In practice, this'll be the same for stand-alone Mesa.  But for DRI
-    * Mesa we do this to accomodate different versions of libGL and various
-    * DRI drivers.
-    */
-   GLint numEntries = MAX2(_glapi_get_dispatch_table_size(), _gloffset_COUNT);
-   struct _glapi_table *table;
-
-   /* should never happen, but just in case */
-   numEntries = MAX2(numEntries, size);
-
-   table = (struct _glapi_table *) malloc(numEntries * sizeof(_glapi_proc));
-   if (table) {
-      _glapi_proc *entry = (_glapi_proc *) table;
-      GLint i;
-      for (i = 0; i < numEntries; i++) {
-         entry[i] = (_glapi_proc) generic_nop;
-      }
-   }
-   return table;
-}
-
-
-/**
- * Initialize a struct gl_context struct (rendering context).
- *
- * This includes allocating all the other structs and arrays which hang off of
- * the context by pointers.
- * Note that the driver needs to pass in its dd_function_table here since
- * we need to at least call driverFunctions->NewTextureObject to create the
- * default texture objects.
- * 
- * Called by _mesa_create_context().
- *
- * Performs the imports and exports callback tables initialization, and
- * miscellaneous one-time initializations. If no shared context is supplied one
- * is allocated, and increase its reference count.  Setups the GL API dispatch
- * tables.  Initialize the TNL module. Sets the maximum Z buffer depth.
- * Finally queries the \c MESA_DEBUG and \c MESA_VERBOSE environment variables
- * for debug flags.
- *
- * \param ctx the context to initialize
- * \param api the GL API type to create the context for
- * \param visual describes the visual attributes for this context
- * \param share_list points to context to share textures, display lists,
- *        etc with, or NULL
- * \param driverFunctions table of device driver functions for this context
- *        to use
- * \param driverContext pointer to driver-specific context data
- */
-GLboolean
-_mesa_initialize_context(struct gl_context *ctx,
-                         gl_api api,
-                         const struct gl_config *visual,
-                         struct gl_context *share_list,
-                         const struct dd_function_table *driverFunctions,
-                         void *driverContext)
-{
-   struct gl_shared_state *shared;
-   int i;
-
-   /*ASSERT(driverContext);*/
-   assert(driverFunctions->NewTextureObject);
-   assert(driverFunctions->FreeTexImageData);
-
-   ctx->API = api;
-   ctx->Visual = *visual;
-   ctx->DrawBuffer = NULL;
-   ctx->ReadBuffer = NULL;
-   ctx->WinSysDrawBuffer = NULL;
-   ctx->WinSysReadBuffer = NULL;
-
-   /* misc one-time initializations */
-   one_time_init(ctx);
-
-   /* Plug in driver functions and context pointer here.
-    * This is important because when we call alloc_shared_state() below
-    * we'll call ctx->Driver.NewTextureObject() to create the default
-    * textures.
-    */
-   ctx->Driver = *driverFunctions;
-   ctx->DriverCtx = driverContext;
-
-   if (share_list) {
-      /* share state with another context */
-      shared = share_list->Shared;
-   }
-   else {
-      /* allocate new, unshared state */
-      shared = _mesa_alloc_shared_state(ctx);
-      if (!shared)
-         return GL_FALSE;
-   }
-
-   _glthread_LOCK_MUTEX(shared->Mutex);
-   ctx->Shared = shared;
-   shared->RefCount++;
-   _glthread_UNLOCK_MUTEX(shared->Mutex);
-
-   if (!init_attrib_groups( ctx )) {
-      _mesa_release_shared_state(ctx, ctx->Shared);
-      return GL_FALSE;
-   }
-
-#if FEATURE_dispatch
-   /* setup the API dispatch tables */
-   switch (ctx->API) {
-#if FEATURE_GL
-   case API_OPENGL:
-      ctx->Exec = _mesa_create_exec_table();
-      break;
-#endif
-#if FEATURE_ES1
-   case API_OPENGLES:
-      ctx->Exec = _mesa_create_exec_table_es1();
-      break;
-#endif
-#if FEATURE_ES2
-   case API_OPENGLES2:
-      ctx->Exec = _mesa_create_exec_table_es2();
-      break;
-#endif
-   default:
-      _mesa_problem(ctx, "unknown or unsupported API");
-      break;
-   }
-
-   if (!ctx->Exec) {
-      _mesa_release_shared_state(ctx, ctx->Shared);
-      return GL_FALSE;
-   }
-#endif
-   ctx->CurrentDispatch = ctx->Exec;
-
-   ctx->FragmentProgram._MaintainTexEnvProgram
-      = (_mesa_getenv("MESA_TEX_PROG") != NULL);
-
-   ctx->VertexProgram._MaintainTnlProgram
-      = (_mesa_getenv("MESA_TNL_PROG") != NULL);
-   if (ctx->VertexProgram._MaintainTnlProgram) {
-      /* this is required... */
-      ctx->FragmentProgram._MaintainTexEnvProgram = GL_TRUE;
-   }
-
-   /* Mesa core handles all the formats that mesa core knows about.
-    * Drivers will want to override this list with just the formats
-    * they can handle, and confirm that appropriate fallbacks exist in
-    * _mesa_choose_tex_format().
-    */
-   memset(&ctx->TextureFormatSupported, GL_TRUE,
-	  sizeof(ctx->TextureFormatSupported));
-
-   switch (ctx->API) {
-   case API_OPENGL:
-#if FEATURE_dlist
-      ctx->Save = _mesa_create_save_table();
-      if (!ctx->Save) {
-	 _mesa_release_shared_state(ctx, ctx->Shared);
-	 free(ctx->Exec);
-	 return GL_FALSE;
-      }
-
-      _mesa_install_save_vtxfmt( ctx, &ctx->ListState.ListVtxfmt );
-#endif
-      break;
-   case API_OPENGLES:
-      /**
-       * GL_OES_texture_cube_map says
-       * "Initially all texture generation modes are set to REFLECTION_MAP_OES"
-       */
-      for (i = 0; i < MAX_TEXTURE_UNITS; i++) {
-	 struct gl_texture_unit *texUnit = &ctx->Texture.Unit[i];
-	 texUnit->GenS.Mode = GL_REFLECTION_MAP_NV;
-	 texUnit->GenT.Mode = GL_REFLECTION_MAP_NV;
-	 texUnit->GenR.Mode = GL_REFLECTION_MAP_NV;
-	 texUnit->GenS._ModeBit = TEXGEN_REFLECTION_MAP_NV;
-	 texUnit->GenT._ModeBit = TEXGEN_REFLECTION_MAP_NV;
-	 texUnit->GenR._ModeBit = TEXGEN_REFLECTION_MAP_NV;
-      }
-      break;
-   case API_OPENGLES2:
-      ctx->FragmentProgram._MaintainTexEnvProgram = GL_TRUE;
-      ctx->VertexProgram._MaintainTnlProgram = GL_TRUE;
-      ctx->Point.PointSprite = GL_TRUE;  /* always on for ES 2.x */
-      break;
-   }
-
-   ctx->FirstTimeCurrent = GL_TRUE;
-
-   return GL_TRUE;
-}
-
-
-/**
- * Allocate and initialize a struct gl_context structure.
- * Note that the driver needs to pass in its dd_function_table here since
- * we need to at least call driverFunctions->NewTextureObject to initialize
- * the rendering context.
- *
- * \param api the GL API type to create the context for
- * \param visual a struct gl_config pointer (we copy the struct contents)
- * \param share_list another context to share display lists with or NULL
- * \param driverFunctions points to the dd_function_table into which the
- *        driver has plugged in all its special functions.
- * \param driverContext points to the device driver's private context state
- * 
- * \return pointer to a new __struct gl_contextRec or NULL if error.
- */
-struct gl_context *
-_mesa_create_context(gl_api api,
-                     const struct gl_config *visual,
-                     struct gl_context *share_list,
-                     const struct dd_function_table *driverFunctions,
-                     void *driverContext)
-{
-   struct gl_context *ctx;
-
-   ASSERT(visual);
-   /*ASSERT(driverContext);*/
-
-   ctx = (struct gl_context *) calloc(1, sizeof(struct gl_context));
-   if (!ctx)
-      return NULL;
-
-   if (_mesa_initialize_context(ctx, api, visual, share_list,
-                                driverFunctions, driverContext)) {
-      return ctx;
-   }
-   else {
-      free(ctx);
-      return NULL;
-   }
-}
-
-
-/**
- * Free the data associated with the given context.
- * 
- * But doesn't free the struct gl_context struct itself.
- *
- * \sa _mesa_initialize_context() and init_attrib_groups().
- */
-void
-_mesa_free_context_data( struct gl_context *ctx )
-{
-   if (!_mesa_get_current_context()){
-      /* No current context, but we may need one in order to delete
-       * texture objs, etc.  So temporarily bind the context now.
-       */
-      _mesa_make_current(ctx, NULL, NULL);
-   }
-
-   /* unreference WinSysDraw/Read buffers */
-   _mesa_reference_framebuffer(&ctx->WinSysDrawBuffer, NULL);
-   _mesa_reference_framebuffer(&ctx->WinSysReadBuffer, NULL);
-   _mesa_reference_framebuffer(&ctx->DrawBuffer, NULL);
-   _mesa_reference_framebuffer(&ctx->ReadBuffer, NULL);
-
-   _mesa_reference_vertprog(ctx, &ctx->VertexProgram.Current, NULL);
-   _mesa_reference_vertprog(ctx, &ctx->VertexProgram._Current, NULL);
-   _mesa_reference_vertprog(ctx, &ctx->VertexProgram._TnlProgram, NULL);
-
-   _mesa_reference_fragprog(ctx, &ctx->FragmentProgram.Current, NULL);
-   _mesa_reference_fragprog(ctx, &ctx->FragmentProgram._Current, NULL);
-   _mesa_reference_fragprog(ctx, &ctx->FragmentProgram._TexEnvProgram, NULL);
-
-   _mesa_free_attrib_data(ctx);
-   _mesa_free_buffer_objects(ctx);
-   _mesa_free_lighting_data( ctx );
-   _mesa_free_eval_data( ctx );
-   _mesa_free_texture_data( ctx );
-   _mesa_free_matrix_data( ctx );
-   _mesa_free_viewport_data( ctx );
-   _mesa_free_program_data(ctx);
-   _mesa_free_shader_state(ctx);
-   _mesa_free_queryobj_data(ctx);
-   _mesa_free_sync_data(ctx);
-   _mesa_free_varray_data(ctx);
-   _mesa_free_transform_feedback(ctx);
-
-   _mesa_delete_array_object(ctx, ctx->Array.DefaultArrayObj);
-
-#if FEATURE_ARB_pixel_buffer_object
-   _mesa_reference_buffer_object(ctx, &ctx->Pack.BufferObj, NULL);
-   _mesa_reference_buffer_object(ctx, &ctx->Unpack.BufferObj, NULL);
-   _mesa_reference_buffer_object(ctx, &ctx->DefaultPacking.BufferObj, NULL);
-#endif
-
-#if FEATURE_ARB_vertex_buffer_object
-   _mesa_reference_buffer_object(ctx, &ctx->Array.ArrayBufferObj, NULL);
-   _mesa_reference_buffer_object(ctx, &ctx->Array.ElementArrayBufferObj, NULL);
-#endif
-
-   /* free dispatch tables */
-   free(ctx->Exec);
-   free(ctx->Save);
-
-   /* Shared context state (display lists, textures, etc) */
-   _mesa_release_shared_state( ctx, ctx->Shared );
-
-   /* needs to be after freeing shared state */
-   _mesa_free_display_list_data(ctx);
-
-   if (ctx->Extensions.String)
-      free((void *) ctx->Extensions.String);
-
-   if (ctx->VersionString)
-      free(ctx->VersionString);
-
-   /* unbind the context if it's currently bound */
-   if (ctx == _mesa_get_current_context()) {
-      _mesa_make_current(NULL, NULL, NULL);
-   }
-}
-
-
-/**
- * Destroy a struct gl_context structure.
- *
- * \param ctx GL context.
- * 
- * Calls _mesa_free_context_data() and frees the gl_context object itself.
- */
-void
-_mesa_destroy_context( struct gl_context *ctx )
-{
-   if (ctx) {
-      _mesa_free_context_data(ctx);
-      free( (void *) ctx );
-   }
-}
-
-
-#if _HAVE_FULL_GL
-/**
- * Copy attribute groups from one context to another.
- * 
- * \param src source context
- * \param dst destination context
- * \param mask bitwise OR of GL_*_BIT flags
- *
- * According to the bits specified in \p mask, copies the corresponding
- * attributes from \p src into \p dst.  For many of the attributes a simple \c
- * memcpy is not enough due to the existence of internal pointers in their data
- * structures.
- */
-void
-_mesa_copy_context( const struct gl_context *src, struct gl_context *dst, GLuint mask )
-{
-   if (mask & GL_ACCUM_BUFFER_BIT) {
-      /* OK to memcpy */
-      dst->Accum = src->Accum;
-   }
-   if (mask & GL_COLOR_BUFFER_BIT) {
-      /* OK to memcpy */
-      dst->Color = src->Color;
-   }
-   if (mask & GL_CURRENT_BIT) {
-      /* OK to memcpy */
-      dst->Current = src->Current;
-   }
-   if (mask & GL_DEPTH_BUFFER_BIT) {
-      /* OK to memcpy */
-      dst->Depth = src->Depth;
-   }
-   if (mask & GL_ENABLE_BIT) {
-      /* no op */
-   }
-   if (mask & GL_EVAL_BIT) {
-      /* OK to memcpy */
-      dst->Eval = src->Eval;
-   }
-   if (mask & GL_FOG_BIT) {
-      /* OK to memcpy */
-      dst->Fog = src->Fog;
-   }
-   if (mask & GL_HINT_BIT) {
-      /* OK to memcpy */
-      dst->Hint = src->Hint;
-   }
-   if (mask & GL_LIGHTING_BIT) {
-      GLuint i;
-      /* begin with memcpy */
-      dst->Light = src->Light;
-      /* fixup linked lists to prevent pointer insanity */
-      make_empty_list( &(dst->Light.EnabledList) );
-      for (i = 0; i < MAX_LIGHTS; i++) {
-         if (dst->Light.Light[i].Enabled) {
-            insert_at_tail(&(dst->Light.EnabledList), &(dst->Light.Light[i]));
-         }
-      }
-   }
-   if (mask & GL_LINE_BIT) {
-      /* OK to memcpy */
-      dst->Line = src->Line;
-   }
-   if (mask & GL_LIST_BIT) {
-      /* OK to memcpy */
-      dst->List = src->List;
-   }
-   if (mask & GL_PIXEL_MODE_BIT) {
-      /* OK to memcpy */
-      dst->Pixel = src->Pixel;
-   }
-   if (mask & GL_POINT_BIT) {
-      /* OK to memcpy */
-      dst->Point = src->Point;
-   }
-   if (mask & GL_POLYGON_BIT) {
-      /* OK to memcpy */
-      dst->Polygon = src->Polygon;
-   }
-   if (mask & GL_POLYGON_STIPPLE_BIT) {
-      /* Use loop instead of memcpy due to problem with Portland Group's
-       * C compiler.  Reported by John Stone.
-       */
-      GLuint i;
-      for (i = 0; i < 32; i++) {
-         dst->PolygonStipple[i] = src->PolygonStipple[i];
-      }
-   }
-   if (mask & GL_SCISSOR_BIT) {
-      /* OK to memcpy */
-      dst->Scissor = src->Scissor;
-   }
-   if (mask & GL_STENCIL_BUFFER_BIT) {
-      /* OK to memcpy */
-      dst->Stencil = src->Stencil;
-   }
-   if (mask & GL_TEXTURE_BIT) {
-      /* Cannot memcpy because of pointers */
-      _mesa_copy_texture_state(src, dst);
-   }
-   if (mask & GL_TRANSFORM_BIT) {
-      /* OK to memcpy */
-      dst->Transform = src->Transform;
-   }
-   if (mask & GL_VIEWPORT_BIT) {
-      /* Cannot use memcpy, because of pointers in GLmatrix _WindowMap */
-      dst->Viewport.X = src->Viewport.X;
-      dst->Viewport.Y = src->Viewport.Y;
-      dst->Viewport.Width = src->Viewport.Width;
-      dst->Viewport.Height = src->Viewport.Height;
-      dst->Viewport.Near = src->Viewport.Near;
-      dst->Viewport.Far = src->Viewport.Far;
-      _math_matrix_copy(&dst->Viewport._WindowMap, &src->Viewport._WindowMap);
-   }
-
-   /* XXX FIXME:  Call callbacks?
-    */
-   dst->NewState = _NEW_ALL;
-}
-#endif
-
-
-/**
- * Check if the given context can render into the given framebuffer
- * by checking visual attributes.
- *
- * Most of these tests could go away because Mesa is now pretty flexible
- * in terms of mixing rendering contexts with framebuffers.  As long
- * as RGB vs. CI mode agree, we're probably good.
- *
- * \return GL_TRUE if compatible, GL_FALSE otherwise.
- */
-static GLboolean 
-check_compatible(const struct gl_context *ctx,
-                 const struct gl_framebuffer *buffer)
-{
-   const struct gl_config *ctxvis = &ctx->Visual;
-   const struct gl_config *bufvis = &buffer->Visual;
-
-   if (buffer == _mesa_get_incomplete_framebuffer())
-      return GL_TRUE;
-
-#if 0
-   /* disabling this fixes the fgl_glxgears pbuffer demo */
-   if (ctxvis->doubleBufferMode && !bufvis->doubleBufferMode)
-      return GL_FALSE;
-#endif
-   if (ctxvis->stereoMode && !bufvis->stereoMode)
-      return GL_FALSE;
-   if (ctxvis->haveAccumBuffer && !bufvis->haveAccumBuffer)
-      return GL_FALSE;
-   if (ctxvis->haveDepthBuffer && !bufvis->haveDepthBuffer)
-      return GL_FALSE;
-   if (ctxvis->haveStencilBuffer && !bufvis->haveStencilBuffer)
-      return GL_FALSE;
-   if (ctxvis->redMask && ctxvis->redMask != bufvis->redMask)
-      return GL_FALSE;
-   if (ctxvis->greenMask && ctxvis->greenMask != bufvis->greenMask)
-      return GL_FALSE;
-   if (ctxvis->blueMask && ctxvis->blueMask != bufvis->blueMask)
-      return GL_FALSE;
-#if 0
-   /* disabled (see bug 11161) */
-   if (ctxvis->depthBits && ctxvis->depthBits != bufvis->depthBits)
-      return GL_FALSE;
-#endif
-   if (ctxvis->stencilBits && ctxvis->stencilBits != bufvis->stencilBits)
-      return GL_FALSE;
-
-   return GL_TRUE;
-}
-
-
-/**
- * Do one-time initialization for the given framebuffer.  Specifically,
- * ask the driver for the window's current size and update the framebuffer
- * object to match.
- * Really, the device driver should totally take care of this.
- */
-static void
-initialize_framebuffer_size(struct gl_context *ctx, struct gl_framebuffer *fb)
-{
-   GLuint width, height;
-   if (ctx->Driver.GetBufferSize) {
-      ctx->Driver.GetBufferSize(fb, &width, &height);
-      if (ctx->Driver.ResizeBuffers)
-         ctx->Driver.ResizeBuffers(ctx, fb, width, height);
-      fb->Initialized = GL_TRUE;
-   }
-}
-
-
-/**
- * Check if the viewport/scissor size has not yet been initialized.
- * Initialize the size if the given width and height are non-zero.
- */
-void
-_mesa_check_init_viewport(struct gl_context *ctx, GLuint width, GLuint height)
-{
-   if (!ctx->ViewportInitialized && width > 0 && height > 0) {
-      /* Note: set flag here, before calling _mesa_set_viewport(), to prevent
-       * potential infinite recursion.
-       */
-      ctx->ViewportInitialized = GL_TRUE;
-      _mesa_set_viewport(ctx, 0, 0, width, height);
-      _mesa_set_scissor(ctx, 0, 0, width, height);
-   }
-}
-
-
-/**
- * Bind the given context to the given drawBuffer and readBuffer and
- * make it the current context for the calling thread.
- * We'll render into the drawBuffer and read pixels from the
- * readBuffer (i.e. glRead/CopyPixels, glCopyTexImage, etc).
- *
- * We check that the context's and framebuffer's visuals are compatible
- * and return immediately if they're not.
- *
- * \param newCtx  the new GL context. If NULL then there will be no current GL
- *                context.
- * \param drawBuffer  the drawing framebuffer
- * \param readBuffer  the reading framebuffer
- */
-GLboolean
-_mesa_make_current( struct gl_context *newCtx,
-                    struct gl_framebuffer *drawBuffer,
-                    struct gl_framebuffer *readBuffer )
-{
-   GET_CURRENT_CONTEXT(curCtx);
-
-   if (MESA_VERBOSE & VERBOSE_API)
-      _mesa_debug(newCtx, "_mesa_make_current()\n");
-
-   /* Check that the context's and framebuffer's visuals are compatible.
-    */
-   if (newCtx && drawBuffer && newCtx->WinSysDrawBuffer != drawBuffer) {
-      if (!check_compatible(newCtx, drawBuffer)) {
-         _mesa_warning(newCtx,
-              "MakeCurrent: incompatible visuals for context and drawbuffer");
-         return GL_FALSE;
-      }
-   }
-   if (newCtx && readBuffer && newCtx->WinSysReadBuffer != readBuffer) {
-      if (!check_compatible(newCtx, readBuffer)) {
-         _mesa_warning(newCtx,
-              "MakeCurrent: incompatible visuals for context and readbuffer");
-         return GL_FALSE;
-      }
-   }
-
-   if (curCtx && 
-      (curCtx->WinSysDrawBuffer || curCtx->WinSysReadBuffer) && /* make sure this context is valid for flushing */
-      curCtx != newCtx)
-      _mesa_flush(curCtx);
-
-   /* We used to call _glapi_check_multithread() here.  Now do it in drivers */
-   _glapi_set_context((void *) newCtx);
-   ASSERT(_mesa_get_current_context() == newCtx);
-
-   if (!newCtx) {
-      _glapi_set_dispatch(NULL);  /* none current */
-   }
-   else {
-      _glapi_set_dispatch(newCtx->CurrentDispatch);
-
-      if (drawBuffer && readBuffer) {
-	 /* TODO: check if newCtx and buffer's visual match??? */
-
-         ASSERT(drawBuffer->Name == 0);
-         ASSERT(readBuffer->Name == 0);
-         _mesa_reference_framebuffer(&newCtx->WinSysDrawBuffer, drawBuffer);
-         _mesa_reference_framebuffer(&newCtx->WinSysReadBuffer, readBuffer);
-
-         /*
-          * Only set the context's Draw/ReadBuffer fields if they're NULL
-          * or not bound to a user-created FBO.
-          */
-         if (!newCtx->DrawBuffer || newCtx->DrawBuffer->Name == 0) {
-            /* KW: merge conflict here, revisit. 
-             */
-            /* fix up the fb fields - these will end up wrong otherwise
-             * if the DRIdrawable changes, and everything relies on them.
-             * This is a bit messy (same as needed in _mesa_BindFramebufferEXT)
-             */
-            unsigned int i;
-            GLenum buffers[MAX_DRAW_BUFFERS];
-
-            _mesa_reference_framebuffer(&newCtx->DrawBuffer, drawBuffer);
-
-            for(i = 0; i < newCtx->Const.MaxDrawBuffers; i++) {
-               buffers[i] = newCtx->Color.DrawBuffer[i];
-            }
-
-            _mesa_drawbuffers(newCtx, newCtx->Const.MaxDrawBuffers,
-                              buffers, NULL);
-         }
-         if (!newCtx->ReadBuffer || newCtx->ReadBuffer->Name == 0) {
-            _mesa_reference_framebuffer(&newCtx->ReadBuffer, readBuffer);
-         }
-
-         /* XXX only set this flag if we're really changing the draw/read
-          * framebuffer bindings.
-          */
-	 newCtx->NewState |= _NEW_BUFFERS;
-
-#if 1
-         /* We want to get rid of these lines: */
-
-#if _HAVE_FULL_GL
-         if (!drawBuffer->Initialized) {
-            initialize_framebuffer_size(newCtx, drawBuffer);
-         }
-         if (readBuffer != drawBuffer && !readBuffer->Initialized) {
-            initialize_framebuffer_size(newCtx, readBuffer);
-         }
-
-	 _mesa_resizebuffers(newCtx);
-#endif
-
-#else
-         /* We want the drawBuffer and readBuffer to be initialized by
-          * the driver.
-          * This generally means the Width and Height match the actual
-          * window size and the renderbuffers (both hardware and software
-          * based) are allocated to match.  The later can generally be
-          * done with a call to _mesa_resize_framebuffer().
-          *
-          * It's theoretically possible for a buffer to have zero width
-          * or height, but for now, assert check that the driver did what's
-          * expected of it.
-          */
-         ASSERT(drawBuffer->Width > 0);
-         ASSERT(drawBuffer->Height > 0);
-#endif
-
-         if (drawBuffer) {
-            _mesa_check_init_viewport(newCtx,
-                                      drawBuffer->Width, drawBuffer->Height);
-         }
-      }
-
-      if (newCtx->FirstTimeCurrent) {
-         _mesa_compute_version(newCtx);
-
-         newCtx->Extensions.String = _mesa_make_extension_string(newCtx);
-
-         check_context_limits(newCtx);
-
-         /* We can use this to help debug user's problems.  Tell them to set
-          * the MESA_INFO env variable before running their app.  Then the
-          * first time each context is made current we'll print some useful
-          * information.
-          */
-	 if (_mesa_getenv("MESA_INFO")) {
-	    _mesa_print_info();
-	 }
-
-	 newCtx->FirstTimeCurrent = GL_FALSE;
-      }
-   }
-   
-   return GL_TRUE;
-}
-
-
-/**
- * Make context 'ctx' share the display lists, textures and programs
- * that are associated with 'ctxToShare'.
- * Any display lists, textures or programs associated with 'ctx' will
- * be deleted if nobody else is sharing them.
- */
-GLboolean
-_mesa_share_state(struct gl_context *ctx, struct gl_context *ctxToShare)
-{
-   if (ctx && ctxToShare && ctx->Shared && ctxToShare->Shared) {
-      struct gl_shared_state *oldSharedState = ctx->Shared;
-
-      ctx->Shared = ctxToShare->Shared;
-      
-      _glthread_LOCK_MUTEX(ctx->Shared->Mutex);
-      ctx->Shared->RefCount++;
-      _glthread_UNLOCK_MUTEX(ctx->Shared->Mutex);
-
-      update_default_objects(ctx);
-
-      _mesa_release_shared_state(ctx, oldSharedState);
-
-      return GL_TRUE;
-   }
-   else {
-      return GL_FALSE;
-   }
-}
-
-
-
-/**
- * \return pointer to the current GL context for this thread.
- * 
- * Calls _glapi_get_context(). This isn't the fastest way to get the current
- * context.  If you need speed, see the #GET_CURRENT_CONTEXT macro in
- * context.h.
- */
-struct gl_context *
-_mesa_get_current_context( void )
-{
-   return (struct gl_context *) _glapi_get_context();
-}
-
-
-/**
- * Get context's current API dispatch table.
- *
- * It'll either be the immediate-mode execute dispatcher or the display list
- * compile dispatcher.
- * 
- * \param ctx GL context.
- *
- * \return pointer to dispatch_table.
- *
- * Simply returns __struct gl_contextRec::CurrentDispatch.
- */
-struct _glapi_table *
-_mesa_get_dispatch(struct gl_context *ctx)
-{
-   return ctx->CurrentDispatch;
-}
-
-/*@}*/
-
-
-/**********************************************************************/
-/** \name Miscellaneous functions                                     */
-/**********************************************************************/
-/*@{*/
-
-/**
- * Record an error.
- *
- * \param ctx GL context.
- * \param error error code.
- * 
- * Records the given error code and call the driver's dd_function_table::Error
- * function if defined.
- *
- * \sa
- * This is called via _mesa_error().
- */
-void
-_mesa_record_error(struct gl_context *ctx, GLenum error)
-{
-   if (!ctx)
-      return;
-
-   if (ctx->ErrorValue == GL_NO_ERROR) {
-      ctx->ErrorValue = error;
-   }
-
-   /* Call device driver's error handler, if any.  This is used on the Mac. */
-   if (ctx->Driver.Error) {
-      ctx->Driver.Error(ctx);
-   }
-}
-
-
-/**
- * Flush commands and wait for completion.
- */
-void
-_mesa_finish(struct gl_context *ctx)
-{
-   FLUSH_CURRENT( ctx, 0 );
-   if (ctx->Driver.Finish) {
-      ctx->Driver.Finish(ctx);
-   }
-}
-
-
-/**
- * Flush commands.
- */
-void
-_mesa_flush(struct gl_context *ctx)
-{
-   FLUSH_CURRENT( ctx, 0 );
-   if (ctx->Driver.Flush) {
-      ctx->Driver.Flush(ctx);
-   }
-}
-
-
-
-/**
- * Execute glFinish().
- *
- * Calls the #ASSERT_OUTSIDE_BEGIN_END_AND_FLUSH macro and the
- * dd_function_table::Finish driver callback, if not NULL.
- */
-void GLAPIENTRY
-_mesa_Finish(void)
-{
-   GET_CURRENT_CONTEXT(ctx);
-   ASSERT_OUTSIDE_BEGIN_END_AND_FLUSH(ctx);
-   _mesa_finish(ctx);
-}
-
-
-/**
- * Execute glFlush().
- *
- * Calls the #ASSERT_OUTSIDE_BEGIN_END_AND_FLUSH macro and the
- * dd_function_table::Flush driver callback, if not NULL.
- */
-void GLAPIENTRY
-_mesa_Flush(void)
-{
-   GET_CURRENT_CONTEXT(ctx);
-   ASSERT_OUTSIDE_BEGIN_END_AND_FLUSH(ctx);
-   _mesa_flush(ctx);
-}
-
-
-/**
- * Set mvp_with_dp4 flag.  If a driver has a preference for DP4 over
- * MUL/MAD, or vice versa, call this function to register that.
- * Otherwise we default to MUL/MAD.
- */
-void
-_mesa_set_mvp_with_dp4( struct gl_context *ctx,
-                        GLboolean flag )
-{
-   ctx->mvp_with_dp4 = flag;
-}
-
-
-
-/**
- * Prior to drawing anything with glBegin, glDrawArrays, etc. this function
- * is called to see if it's valid to render.  This involves checking that
- * the current shader is valid and the framebuffer is complete.
- * If an error is detected it'll be recorded here.
- * \return GL_TRUE if OK to render, GL_FALSE if not
- */
-GLboolean
-_mesa_valid_to_render(struct gl_context *ctx, const char *where)
-{
-   bool vert_from_glsl_shader = false;
-   bool geom_from_glsl_shader = false;
-   bool frag_from_glsl_shader = false;
-
-   /* This depends on having up to date derived state (shaders) */
-   if (ctx->NewState)
-      _mesa_update_state(ctx);
-
-   if (ctx->Shader.CurrentVertexProgram) {
-      vert_from_glsl_shader = true;
-
-      if (!ctx->Shader.CurrentVertexProgram->LinkStatus) {
-         _mesa_error(ctx, GL_INVALID_OPERATION,
-                     "%s(shader not linked)", where);
-         return GL_FALSE;
-      }
-#if 0 /* not normally enabled */
-      {
-         char errMsg[100];
-         if (!_mesa_validate_shader_program(ctx,
-					    ctx->Shader.CurrentVertexProgram,
-                                            errMsg)) {
-            _mesa_warning(ctx, "Shader program %u is invalid: %s",
-                          ctx->Shader.CurrentVertexProgram->Name, errMsg);
-         }
-      }
-#endif
-   }
-
-   if (ctx->Shader.CurrentGeometryProgram) {
-      geom_from_glsl_shader = true;
-
-      if (!ctx->Shader.CurrentGeometryProgram->LinkStatus) {
-         _mesa_error(ctx, GL_INVALID_OPERATION,
-                     "%s(shader not linked)", where);
-         return GL_FALSE;
-      }
-#if 0 /* not normally enabled */
-      {
-         char errMsg[100];
-         if (!_mesa_validate_shader_program(ctx,
-					    ctx->Shader.CurrentGeometryProgram,
-                                            errMsg)) {
-            _mesa_warning(ctx, "Shader program %u is invalid: %s",
-                          ctx->Shader.CurrentGeometryProgram->Name, errMsg);
-         }
-      }
-#endif
-   }
-
-   if (ctx->Shader.CurrentFragmentProgram) {
-      frag_from_glsl_shader = true;
-
-      if (!ctx->Shader.CurrentFragmentProgram->LinkStatus) {
-         _mesa_error(ctx, GL_INVALID_OPERATION,
-                     "%s(shader not linked)", where);
-         return GL_FALSE;
-      }
-#if 0 /* not normally enabled */
-      {
-         char errMsg[100];
-         if (!_mesa_validate_shader_program(ctx,
-					    ctx->Shader.CurrentFragmentProgram,
-                                            errMsg)) {
-            _mesa_warning(ctx, "Shader program %u is invalid: %s",
-                          ctx->Shader.CurrentFragmentProgram->Name, errMsg);
-         }
-      }
-#endif
-   }
-
-   /* Any shader stages that are not supplied by the GLSL shader and have
-    * assembly shaders enabled must now be validated.
-    */
-   if (!vert_from_glsl_shader
-       && ctx->VertexProgram.Enabled && !ctx->VertexProgram._Enabled) {
-      _mesa_error(ctx, GL_INVALID_OPERATION,
-		  "%s(vertex program not valid)", where);
-      return GL_FALSE;
-   }
-
-   /* FINISHME: If GL_NV_geometry_program4 is ever supported, the current
-    * FINISHME: geometry program should validated here.
-    */
-   (void) geom_from_glsl_shader;
-
-   if (!frag_from_glsl_shader) {
-      if (ctx->FragmentProgram.Enabled && !ctx->FragmentProgram._Enabled) {
-	 _mesa_error(ctx, GL_INVALID_OPERATION,
-		     "%s(fragment program not valid)", where);
-	 return GL_FALSE;
-      }
-
-      /* If drawing to integer-valued color buffers, there must be an
-       * active fragment shader (GL_EXT_texture_integer).
-       */
-      if (ctx->DrawBuffer && ctx->DrawBuffer->_IntegerColor) {
-         _mesa_error(ctx, GL_INVALID_OPERATION,
-                     "%s(integer format but no fragment shader)", where);
-         return GL_FALSE;
-      }
-   }
-
-   if (ctx->DrawBuffer->_Status != GL_FRAMEBUFFER_COMPLETE_EXT) {
-      _mesa_error(ctx, GL_INVALID_FRAMEBUFFER_OPERATION_EXT,
-                  "%s(incomplete framebuffer)", where);
-      return GL_FALSE;
-   }
-
-#ifdef DEBUG
-   if (ctx->Shader.Flags & GLSL_LOG) {
-      struct gl_shader_program *shProg[MESA_SHADER_TYPES];
-      gl_shader_type i;
-
-      shProg[MESA_SHADER_VERTEX] = ctx->Shader.CurrentVertexProgram;
-      shProg[MESA_SHADER_GEOMETRY] = ctx->Shader.CurrentGeometryProgram;
-      shProg[MESA_SHADER_FRAGMENT] = ctx->Shader.CurrentFragmentProgram;
-
-      for (i = 0; i < MESA_SHADER_TYPES; i++) {
-	 struct gl_shader *sh;
-
-	 if (shProg[i] == NULL || shProg[i]->_Used
-	     || shProg[i]->_LinkedShaders[i] == NULL)
-	    continue;
-
-	 /* This is the first time this shader is being used.
-	  * Append shader's constants/uniforms to log file.
-	  *
-	  * The logic is a little odd here.  We only want to log data for each
-	  * shader target that will actually be used, and we only want to log
-	  * it once.  It's possible to have a program bound to the vertex
-	  * shader target that also supplied a fragment shader.  If that
-	  * program isn't also bound to the fragment shader target we don't
-	  * want to log its fragment data.
-	  */
-	 sh = shProg[i]->_LinkedShaders[i];
-	 switch (sh->Type) {
-	 case GL_VERTEX_SHADER:
-	    _mesa_append_uniforms_to_file(sh, &shProg[i]->VertexProgram->Base);
-	    break;
-
-	 case GL_GEOMETRY_SHADER_ARB:
-	    _mesa_append_uniforms_to_file(sh,
-					  &shProg[i]->GeometryProgram->Base);
-	    break;
-
-	 case GL_FRAGMENT_SHADER:
-	    _mesa_append_uniforms_to_file(sh,
-					  &shProg[i]->FragmentProgram->Base);
-	    break;
-	 }
-      }
-
-      for (i = 0; i < MESA_SHADER_TYPES; i++) {
-	 if (shProg[i] != NULL)
-	    shProg[i]->_Used = GL_TRUE;
-      }
-   }
-#endif
-
-   return GL_TRUE;
-}
-
-
-/*@}*/
+/*

+ * Mesa 3-D graphics library

+ * Version:  7.3

+ *

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

+ * Copyright (C) 2008  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 context.c

+ * Mesa context/visual/framebuffer management functions.

+ * \author Brian Paul

+ */

+

+/**

+ * \mainpage Mesa Main Module

+ *

+ * \section MainIntroduction Introduction

+ *

+ * The Mesa Main module consists of all the files in the main/ directory.

+ * Among the features of this module are:

+ * <UL>

+ * <LI> Structures to represent most GL state </LI>

+ * <LI> State set/get functions </LI>

+ * <LI> Display lists </LI>

+ * <LI> Texture unit, object and image handling </LI>

+ * <LI> Matrix and attribute stacks </LI>

+ * </UL>

+ *

+ * Other modules are responsible for API dispatch, vertex transformation,

+ * point/line/triangle setup, rasterization, vertex array caching,

+ * vertex/fragment programs/shaders, etc.

+ *

+ *

+ * \section AboutDoxygen About Doxygen

+ *

+ * If you're viewing this information as Doxygen-generated HTML you'll

+ * see the documentation index at the top of this page.

+ *

+ * The first line lists the Mesa source code modules.

+ * The second line lists the indexes available for viewing the documentation

+ * for each module.

+ *

+ * Selecting the <b>Main page</b> link will display a summary of the module

+ * (this page).

+ *

+ * Selecting <b>Data Structures</b> will list all C structures.

+ *

+ * Selecting the <b>File List</b> link will list all the source files in

+ * the module.

+ * Selecting a filename will show a list of all functions defined in that file.

+ *

+ * Selecting the <b>Data Fields</b> link will display a list of all

+ * documented structure members.

+ *

+ * Selecting the <b>Globals</b> link will display a list

+ * of all functions, structures, global variables and macros in the module.

+ *

+ */

+

+

+#include "glheader.h"

+#include "mfeatures.h"

+#include "imports.h"

+#include "accum.h"

+#include "api_exec.h"

+#include "arrayobj.h"

+#include "attrib.h"

+#include "blend.h"

+#include "buffers.h"

+#include "bufferobj.h"

+#include "context.h"

+#include "cpuinfo.h"

+#include "debug.h"

+#include "depth.h"

+#include "dlist.h"

+#include "eval.h"

+#include "extensions.h"

+#include "fbobject.h"

+#include "feedback.h"

+#include "fog.h"

+#include "formats.h"

+#include "framebuffer.h"

+#include "hint.h"

+#include "hash.h"

+#include "light.h"

+#include "lines.h"

+#include "macros.h"

+#include "matrix.h"

+#include "multisample.h"

+#include "pixel.h"

+#include "pixelstore.h"

+#include "points.h"

+#include "polygon.h"

+#include "queryobj.h"

+#include "syncobj.h"

+#include "rastpos.h"

+#include "remap.h"

+#include "scissor.h"

+#include "shared.h"

+#include "shaderobj.h"

+#include "simple_list.h"

+#include "state.h"

+#include "stencil.h"

+#include "texcompress_s3tc.h"

+#include "texstate.h"

+#include "transformfeedback.h"

+#include "mtypes.h"

+#include "varray.h"

+#include "version.h"

+#include "viewport.h"

+#include "vtxfmt.h"

+#include "program/program.h"

+#include "program/prog_print.h"

+#if _HAVE_FULL_GL

+#include "math/m_matrix.h"

+#endif

+#include "main/dispatch.h" /* for _gloffset_COUNT */

+

+#ifdef USE_SPARC_ASM

+#include "sparc/sparc.h"

+#endif

+

+#include "glsl_parser_extras.h"

+#include <stdbool.h>

+

+

+#ifndef MESA_VERBOSE

+int MESA_VERBOSE = 0;

+#endif

+

+#ifndef MESA_DEBUG_FLAGS

+int MESA_DEBUG_FLAGS = 0;

+#endif

+

+

+/* ubyte -> float conversion */

+GLfloat _mesa_ubyte_to_float_color_tab[256];

+

+

+

+/**

+ * Swap buffers notification callback.

+ * 

+ * \param ctx GL context.

+ *

+ * Called by window system just before swapping buffers.

+ * We have to finish any pending rendering.

+ */

+void

+_mesa_notifySwapBuffers(struct gl_context *ctx)

+{

+   if (MESA_VERBOSE & VERBOSE_SWAPBUFFERS)

+      _mesa_debug(ctx, "SwapBuffers\n");

+   FLUSH_CURRENT( ctx, 0 );

+   if (ctx->Driver.Flush) {

+      ctx->Driver.Flush(ctx);

+   }

+}

+

+

+/**********************************************************************/

+/** \name GL Visual allocation/destruction                            */

+/**********************************************************************/

+/*@{*/

+

+/**

+ * Allocates a struct gl_config structure and initializes it via

+ * _mesa_initialize_visual().

+ * 

+ * \param dbFlag double buffering

+ * \param stereoFlag stereo buffer

+ * \param depthBits requested bits per depth buffer value. Any value in [0, 32]

+ * is acceptable but the actual depth type will be GLushort or GLuint as

+ * needed.

+ * \param stencilBits requested minimum bits per stencil buffer value

+ * \param accumRedBits, accumGreenBits, accumBlueBits, accumAlphaBits number of bits per color component in accum buffer.

+ * \param indexBits number of bits per pixel if \p rgbFlag is GL_FALSE

+ * \param redBits number of bits per color component in frame buffer for RGB(A)

+ * mode.  We always use 8 in core Mesa though.

+ * \param greenBits same as above.

+ * \param blueBits same as above.

+ * \param alphaBits same as above.

+ * \param numSamples not really used.

+ * 

+ * \return pointer to new struct gl_config or NULL if requested parameters can't be

+ * met.

+ *

+ * \note Need to add params for level and numAuxBuffers (at least)

+ */

+struct gl_config *

+_mesa_create_visual( GLboolean dbFlag,

+                     GLboolean stereoFlag,

+                     GLint redBits,

+                     GLint greenBits,

+                     GLint blueBits,

+                     GLint alphaBits,

+                     GLint depthBits,

+                     GLint stencilBits,

+                     GLint accumRedBits,

+                     GLint accumGreenBits,

+                     GLint accumBlueBits,

+                     GLint accumAlphaBits,

+                     GLint numSamples )

+{

+   struct gl_config *vis = CALLOC_STRUCT(gl_config);

+   if (vis) {

+      if (!_mesa_initialize_visual(vis, dbFlag, stereoFlag,

+                                   redBits, greenBits, blueBits, alphaBits,

+                                   depthBits, stencilBits,

+                                   accumRedBits, accumGreenBits,

+                                   accumBlueBits, accumAlphaBits,

+                                   numSamples)) {

+         free(vis);

+         return NULL;

+      }

+   }

+   return vis;

+}

+

+

+/**

+ * Makes some sanity checks and fills in the fields of the struct

+ * gl_config object with the given parameters.  If the caller needs to

+ * set additional fields, he should just probably init the whole

+ * gl_config object himself.

+ *

+ * \return GL_TRUE on success, or GL_FALSE on failure.

+ *

+ * \sa _mesa_create_visual() above for the parameter description.

+ */

+GLboolean

+_mesa_initialize_visual( struct gl_config *vis,

+                         GLboolean dbFlag,

+                         GLboolean stereoFlag,

+                         GLint redBits,

+                         GLint greenBits,

+                         GLint blueBits,

+                         GLint alphaBits,

+                         GLint depthBits,

+                         GLint stencilBits,

+                         GLint accumRedBits,

+                         GLint accumGreenBits,

+                         GLint accumBlueBits,

+                         GLint accumAlphaBits,

+                         GLint numSamples )

+{

+   assert(vis);

+

+   if (depthBits < 0 || depthBits > 32) {

+      return GL_FALSE;

+   }

+   if (stencilBits < 0 || stencilBits > STENCIL_BITS) {

+      return GL_FALSE;

+   }

+   assert(accumRedBits >= 0);

+   assert(accumGreenBits >= 0);

+   assert(accumBlueBits >= 0);

+   assert(accumAlphaBits >= 0);

+

+   vis->rgbMode          = GL_TRUE;

+   vis->doubleBufferMode = dbFlag;

+   vis->stereoMode       = stereoFlag;

+

+   vis->redBits          = redBits;

+   vis->greenBits        = greenBits;

+   vis->blueBits         = blueBits;

+   vis->alphaBits        = alphaBits;

+   vis->rgbBits          = redBits + greenBits + blueBits;

+

+   vis->indexBits      = 0;

+   vis->depthBits      = depthBits;

+   vis->stencilBits    = stencilBits;

+

+   vis->accumRedBits   = accumRedBits;

+   vis->accumGreenBits = accumGreenBits;

+   vis->accumBlueBits  = accumBlueBits;

+   vis->accumAlphaBits = accumAlphaBits;

+

+   vis->haveAccumBuffer   = accumRedBits > 0;

+   vis->haveDepthBuffer   = depthBits > 0;

+   vis->haveStencilBuffer = stencilBits > 0;

+

+   vis->numAuxBuffers = 0;

+   vis->level = 0;

+   vis->sampleBuffers = numSamples > 0 ? 1 : 0;

+   vis->samples = numSamples;

+

+   return GL_TRUE;

+}

+

+

+/**

+ * Destroy a visual and free its memory.

+ *

+ * \param vis visual.

+ * 

+ * Frees the visual structure.

+ */

+void

+_mesa_destroy_visual( struct gl_config *vis )

+{

+   free(vis);

+}

+

+/*@}*/

+

+

+/**********************************************************************/

+/** \name Context allocation, initialization, destroying

+ *

+ * The purpose of the most initialization functions here is to provide the

+ * default state values according to the OpenGL specification.

+ */

+/**********************************************************************/

+/*@{*/

+

+

+/**

+ * This is lame.  gdb only seems to recognize enum types that are

+ * actually used somewhere.  We want to be able to print/use enum

+ * values such as TEXTURE_2D_INDEX in gdb.  But we don't actually use

+ * the gl_texture_index type anywhere.  Thus, this lame function.

+ */

+static void

+dummy_enum_func(void)

+{

+   gl_buffer_index bi = BUFFER_FRONT_LEFT;

+   gl_face_index fi = FACE_POS_X;

+   gl_frag_attrib fa = FRAG_ATTRIB_WPOS;

+   gl_frag_result fr = FRAG_RESULT_DEPTH;

+   gl_texture_index ti = TEXTURE_2D_ARRAY_INDEX;

+   gl_vert_attrib va = VERT_ATTRIB_POS;

+   gl_vert_result vr = VERT_RESULT_HPOS;

+   gl_geom_attrib ga = GEOM_ATTRIB_POSITION;

+   gl_geom_result gr = GEOM_RESULT_POS;

+

+   (void) bi;

+   (void) fi;

+   (void) fa;

+   (void) fr;

+   (void) ti;

+   (void) va;

+   (void) vr;

+   (void) ga;

+   (void) gr;

+}

+

+

+/**

+ * One-time initialization mutex lock.

+ *

+ * \sa Used by one_time_init().

+ */

+_glthread_DECLARE_STATIC_MUTEX(OneTimeLock);

+

+

+

+/**

+ * Calls all the various one-time-init functions in Mesa.

+ *

+ * While holding a global mutex lock, calls several initialization functions,

+ * and sets the glapi callbacks if the \c MESA_DEBUG environment variable is

+ * defined.

+ *

+ * \sa _math_init().

+ */

+static void

+one_time_init( struct gl_context *ctx )

+{

+   static GLbitfield api_init_mask = 0x0;

+

+   _glthread_LOCK_MUTEX(OneTimeLock);

+

+   /* truly one-time init */

+   if (!api_init_mask) {

+      GLuint i;

+

+      /* do some implementation tests */

+      assert( sizeof(GLbyte) == 1 );

+      assert( sizeof(GLubyte) == 1 );

+      assert( sizeof(GLshort) == 2 );

+      assert( sizeof(GLushort) == 2 );

+      assert( sizeof(GLint) == 4 );

+      assert( sizeof(GLuint) == 4 );

+

+      _mesa_get_cpu_features();

+

+      _mesa_init_sqrt_table();

+

+      /* context dependence is never a one-time thing... */

+      _mesa_init_get_hash(ctx);

+

+      for (i = 0; i < 256; i++) {

+         _mesa_ubyte_to_float_color_tab[i] = (float) i / 255.0F;

+      }

+

+#if defined(DEBUG) && defined(__DATE__) && defined(__TIME__)

+      if (MESA_VERBOSE != 0) {

+	 _mesa_debug(ctx, "Mesa %s DEBUG build %s %s\n",

+		     MESA_VERSION_STRING, __DATE__, __TIME__);

+      }

+#endif

+

+#ifdef DEBUG

+      _mesa_test_formats();

+#endif

+   }

+

+   /* per-API one-time init */

+   if (!(api_init_mask & (1 << ctx->API))) {

+      /*

+       * This is fine as ES does not use the remap table, but it may not be

+       * future-proof.  We cannot always initialize the remap table because

+       * when an app is linked to libGLES*, there are not enough dynamic

+       * entries.

+       */

+      if (ctx->API == API_OPENGL)

+         _mesa_init_remap_table();

+   }

+

+   api_init_mask |= 1 << ctx->API;

+

+   _glthread_UNLOCK_MUTEX(OneTimeLock);

+

+   /* Hopefully atexit() is widely available.  If not, we may need some

+    * #ifdef tests here.

+    */

+   atexit(_mesa_destroy_shader_compiler);

+

+   dummy_enum_func();

+}

+

+

+/**

+ * Initialize fields of gl_current_attrib (aka ctx->Current.*)

+ */

+static void

+_mesa_init_current(struct gl_context *ctx)

+{

+   GLuint i;

+

+   /* Init all to (0,0,0,1) */

+   for (i = 0; i < Elements(ctx->Current.Attrib); i++) {

+      ASSIGN_4V( ctx->Current.Attrib[i], 0.0, 0.0, 0.0, 1.0 );

+   }

+

+   /* redo special cases: */

+   ASSIGN_4V( ctx->Current.Attrib[VERT_ATTRIB_WEIGHT], 1.0, 0.0, 0.0, 0.0 );

+   ASSIGN_4V( ctx->Current.Attrib[VERT_ATTRIB_NORMAL], 0.0, 0.0, 1.0, 1.0 );

+   ASSIGN_4V( ctx->Current.Attrib[VERT_ATTRIB_COLOR0], 1.0, 1.0, 1.0, 1.0 );

+   ASSIGN_4V( ctx->Current.Attrib[VERT_ATTRIB_COLOR1], 0.0, 0.0, 0.0, 1.0 );

+   ASSIGN_4V( ctx->Current.Attrib[VERT_ATTRIB_COLOR_INDEX], 1.0, 0.0, 0.0, 1.0 );

+   ASSIGN_4V( ctx->Current.Attrib[VERT_ATTRIB_EDGEFLAG], 1.0, 0.0, 0.0, 1.0 );

+}

+

+

+/**

+ * Init vertex/fragment/geometry program limits.

+ * Important: drivers should override these with actual limits.

+ */

+static void

+init_program_limits(GLenum type, struct gl_program_constants *prog)

+{

+   prog->MaxInstructions = MAX_PROGRAM_INSTRUCTIONS;

+   prog->MaxAluInstructions = MAX_PROGRAM_INSTRUCTIONS;

+   prog->MaxTexInstructions = MAX_PROGRAM_INSTRUCTIONS;

+   prog->MaxTexIndirections = MAX_PROGRAM_INSTRUCTIONS;

+   prog->MaxTemps = MAX_PROGRAM_TEMPS;

+   prog->MaxEnvParams = MAX_PROGRAM_ENV_PARAMS;

+   prog->MaxLocalParams = MAX_PROGRAM_LOCAL_PARAMS;

+   prog->MaxAddressOffset = MAX_PROGRAM_LOCAL_PARAMS;

+

+   switch (type) {

+   case GL_VERTEX_PROGRAM_ARB:

+      prog->MaxParameters = MAX_VERTEX_PROGRAM_PARAMS;

+      prog->MaxAttribs = MAX_NV_VERTEX_PROGRAM_INPUTS;

+      prog->MaxAddressRegs = MAX_VERTEX_PROGRAM_ADDRESS_REGS;

+      prog->MaxUniformComponents = 4 * MAX_UNIFORMS;

+      break;

+   case GL_FRAGMENT_PROGRAM_ARB:

+      prog->MaxParameters = MAX_NV_FRAGMENT_PROGRAM_PARAMS;

+      prog->MaxAttribs = MAX_NV_FRAGMENT_PROGRAM_INPUTS;

+      prog->MaxAddressRegs = MAX_FRAGMENT_PROGRAM_ADDRESS_REGS;

+      prog->MaxUniformComponents = 4 * MAX_UNIFORMS;

+      break;

+   case MESA_GEOMETRY_PROGRAM:

+      prog->MaxParameters = MAX_NV_VERTEX_PROGRAM_PARAMS;

+      prog->MaxAttribs = MAX_NV_VERTEX_PROGRAM_INPUTS;

+      prog->MaxAddressRegs = MAX_VERTEX_PROGRAM_ADDRESS_REGS;

+      prog->MaxUniformComponents = MAX_GEOMETRY_UNIFORM_COMPONENTS;

+      break;

+   default:

+      assert(0 && "Bad program type in init_program_limits()");

+   }

+

+   /* Set the native limits to zero.  This implies that there is no native

+    * support for shaders.  Let the drivers fill in the actual values.

+    */

+   prog->MaxNativeInstructions = 0;

+   prog->MaxNativeAluInstructions = 0;

+   prog->MaxNativeTexInstructions = 0;

+   prog->MaxNativeTexIndirections = 0;

+   prog->MaxNativeAttribs = 0;

+   prog->MaxNativeTemps = 0;

+   prog->MaxNativeAddressRegs = 0;

+   prog->MaxNativeParameters = 0;

+

+   /* Set GLSL datatype range/precision info assuming IEEE float values.

+    * Drivers should override these defaults as needed.

+    */

+   prog->MediumFloat.RangeMin = 127;

+   prog->MediumFloat.RangeMax = 127;

+   prog->MediumFloat.Precision = 23;

+   prog->LowFloat = prog->HighFloat = prog->MediumFloat;

+

+   /* Assume ints are stored as floats for now, since this is the least-common

+    * denominator.  The OpenGL ES spec implies (page 132) that the precision

+    * of integer types should be 0.  Practically speaking, IEEE

+    * single-precision floating point values can only store integers in the

+    * range [-0x01000000, 0x01000000] without loss of precision.

+    */

+   prog->MediumInt.RangeMin = 24;

+   prog->MediumInt.RangeMax = 24;

+   prog->MediumInt.Precision = 0;

+   prog->LowInt = prog->HighInt = prog->MediumInt;

+}

+

+

+/**

+ * Initialize fields of gl_constants (aka ctx->Const.*).

+ * Use defaults from config.h.  The device drivers will often override

+ * some of these values (such as number of texture units).

+ */

+static void 

+_mesa_init_constants(struct gl_context *ctx)

+{

+   assert(ctx);

+

+   /* Constants, may be overriden (usually only reduced) by device drivers */

+   ctx->Const.MaxTextureMbytes = MAX_TEXTURE_MBYTES;

+   ctx->Const.MaxTextureLevels = MAX_TEXTURE_LEVELS;

+   ctx->Const.Max3DTextureLevels = MAX_3D_TEXTURE_LEVELS;

+   ctx->Const.MaxCubeTextureLevels = MAX_CUBE_TEXTURE_LEVELS;

+   ctx->Const.MaxTextureRectSize = MAX_TEXTURE_RECT_SIZE;

+   ctx->Const.MaxArrayTextureLayers = MAX_ARRAY_TEXTURE_LAYERS;

+   ctx->Const.MaxTextureCoordUnits = MAX_TEXTURE_COORD_UNITS;

+   ctx->Const.MaxTextureImageUnits = MAX_TEXTURE_IMAGE_UNITS;

+   ctx->Const.MaxTextureUnits = MIN2(ctx->Const.MaxTextureCoordUnits,

+                                     ctx->Const.MaxTextureImageUnits);

+   ctx->Const.MaxTextureMaxAnisotropy = MAX_TEXTURE_MAX_ANISOTROPY;

+   ctx->Const.MaxTextureLodBias = MAX_TEXTURE_LOD_BIAS;

+   ctx->Const.MaxArrayLockSize = MAX_ARRAY_LOCK_SIZE;

+   ctx->Const.SubPixelBits = SUB_PIXEL_BITS;

+   ctx->Const.MinPointSize = MIN_POINT_SIZE;

+   ctx->Const.MaxPointSize = MAX_POINT_SIZE;

+   ctx->Const.MinPointSizeAA = MIN_POINT_SIZE;

+   ctx->Const.MaxPointSizeAA = MAX_POINT_SIZE;

+   ctx->Const.PointSizeGranularity = (GLfloat) POINT_SIZE_GRANULARITY;

+   ctx->Const.MinLineWidth = MIN_LINE_WIDTH;

+   ctx->Const.MaxLineWidth = MAX_LINE_WIDTH;

+   ctx->Const.MinLineWidthAA = MIN_LINE_WIDTH;

+   ctx->Const.MaxLineWidthAA = MAX_LINE_WIDTH;

+   ctx->Const.LineWidthGranularity = (GLfloat) LINE_WIDTH_GRANULARITY;

+   ctx->Const.MaxColorTableSize = MAX_COLOR_TABLE_SIZE;

+   ctx->Const.MaxClipPlanes = MAX_CLIP_PLANES;

+   ctx->Const.MaxLights = MAX_LIGHTS;

+   ctx->Const.MaxShininess = 128.0;

+   ctx->Const.MaxSpotExponent = 128.0;

+   ctx->Const.MaxViewportWidth = MAX_WIDTH;

+   ctx->Const.MaxViewportHeight = MAX_HEIGHT;

+#if FEATURE_ARB_vertex_program

+   init_program_limits(GL_VERTEX_PROGRAM_ARB, &ctx->Const.VertexProgram);

+#endif

+#if FEATURE_ARB_fragment_program

+   init_program_limits(GL_FRAGMENT_PROGRAM_ARB, &ctx->Const.FragmentProgram);

+#endif

+#if FEATURE_ARB_geometry_shader4

+   init_program_limits(MESA_GEOMETRY_PROGRAM, &ctx->Const.GeometryProgram);

+#endif

+   ctx->Const.MaxProgramMatrices = MAX_PROGRAM_MATRICES;

+   ctx->Const.MaxProgramMatrixStackDepth = MAX_PROGRAM_MATRIX_STACK_DEPTH;

+

+   /* CheckArrayBounds is overriden by drivers/x11 for X server */

+   ctx->Const.CheckArrayBounds = GL_FALSE;

+

+   /* GL_ARB_draw_buffers */

+   ctx->Const.MaxDrawBuffers = MAX_DRAW_BUFFERS;

+

+#if FEATURE_EXT_framebuffer_object

+   ctx->Const.MaxColorAttachments = MAX_COLOR_ATTACHMENTS;

+   ctx->Const.MaxRenderbufferSize = MAX_WIDTH;

+#endif

+

+#if FEATURE_ARB_vertex_shader

+   ctx->Const.MaxVertexTextureImageUnits = MAX_VERTEX_TEXTURE_IMAGE_UNITS;

+   ctx->Const.MaxCombinedTextureImageUnits = MAX_COMBINED_TEXTURE_IMAGE_UNITS;

+   ctx->Const.MaxVarying = MAX_VARYING;

+#endif

+#if FEATURE_ARB_geometry_shader4

+   ctx->Const.MaxGeometryTextureImageUnits = MAX_GEOMETRY_TEXTURE_IMAGE_UNITS;

+   ctx->Const.MaxVertexVaryingComponents = MAX_VERTEX_VARYING_COMPONENTS;

+   ctx->Const.MaxGeometryVaryingComponents = MAX_GEOMETRY_VARYING_COMPONENTS;

+   ctx->Const.MaxGeometryOutputVertices = MAX_GEOMETRY_OUTPUT_VERTICES;

+   ctx->Const.MaxGeometryTotalOutputComponents = MAX_GEOMETRY_TOTAL_OUTPUT_COMPONENTS;

+#endif

+

+   /* Shading language version */

+   if (ctx->API == API_OPENGL) {

+      ctx->Const.GLSLVersion = 120;

+   }

+   else if (ctx->API == API_OPENGLES2) {

+      ctx->Const.GLSLVersion = 100;

+   }

+   else if (ctx->API == API_OPENGLES) {

+      ctx->Const.GLSLVersion = 0; /* GLSL not supported */

+   }

+

+   /* GL_ARB_framebuffer_object */

+   ctx->Const.MaxSamples = 0;

+

+   /* GL_ARB_sync */

+   ctx->Const.MaxServerWaitTimeout = (GLuint64) ~0;

+

+   /* GL_ATI_envmap_bumpmap */

+   ctx->Const.SupportedBumpUnits = SUPPORTED_ATI_BUMP_UNITS;

+

+   /* GL_EXT_provoking_vertex */

+   ctx->Const.QuadsFollowProvokingVertexConvention = GL_TRUE;

+

+   /* GL_EXT_transform_feedback */

+   ctx->Const.MaxTransformFeedbackSeparateAttribs = MAX_FEEDBACK_ATTRIBS;

+   ctx->Const.MaxTransformFeedbackSeparateComponents = 4 * MAX_FEEDBACK_ATTRIBS;

+   ctx->Const.MaxTransformFeedbackInterleavedComponents = 4 * MAX_FEEDBACK_ATTRIBS;

+

+   /* GL 3.2: hard-coded for now: */

+   ctx->Const.ProfileMask = GL_CONTEXT_COMPATIBILITY_PROFILE_BIT;

+

+   /** GL_EXT_gpu_shader4 */

+   ctx->Const.MinProgramTexelOffset = -8;

+   ctx->Const.MaxProgramTexelOffset = 7;

+}

+

+

+/**

+ * Do some sanity checks on the limits/constants for the given context.

+ * Only called the first time a context is bound.

+ */

+static void

+check_context_limits(struct gl_context *ctx)

+{

+   /* check that we don't exceed the size of various bitfields */

+   assert(VERT_RESULT_MAX <=

+	  (8 * sizeof(ctx->VertexProgram._Current->Base.OutputsWritten)));

+   assert(FRAG_ATTRIB_MAX <=

+	  (8 * sizeof(ctx->FragmentProgram._Current->Base.InputsRead)));

+

+   assert(MAX_COMBINED_TEXTURE_IMAGE_UNITS <= 8 * sizeof(GLbitfield));

+

+   /* shader-related checks */

+   assert(ctx->Const.FragmentProgram.MaxLocalParams <= MAX_PROGRAM_LOCAL_PARAMS);

+   assert(ctx->Const.VertexProgram.MaxLocalParams <= MAX_PROGRAM_LOCAL_PARAMS);

+

+   assert(MAX_NV_FRAGMENT_PROGRAM_TEMPS <= MAX_PROGRAM_TEMPS);

+   assert(MAX_NV_VERTEX_PROGRAM_TEMPS <= MAX_PROGRAM_TEMPS);

+   assert(MAX_NV_VERTEX_PROGRAM_INPUTS <= VERT_ATTRIB_MAX);

+   assert(MAX_NV_VERTEX_PROGRAM_OUTPUTS <= VERT_RESULT_MAX);

+

+   /* Texture unit checks */

+   assert(ctx->Const.MaxTextureImageUnits > 0);

+   assert(ctx->Const.MaxTextureImageUnits <= MAX_TEXTURE_IMAGE_UNITS);

+   assert(ctx->Const.MaxTextureCoordUnits > 0);

+   assert(ctx->Const.MaxTextureCoordUnits <= MAX_TEXTURE_COORD_UNITS);

+   assert(ctx->Const.MaxTextureUnits > 0);

+   assert(ctx->Const.MaxTextureUnits <= MAX_TEXTURE_IMAGE_UNITS);

+   assert(ctx->Const.MaxTextureUnits <= MAX_TEXTURE_COORD_UNITS);

+   assert(ctx->Const.MaxTextureUnits == MIN2(ctx->Const.MaxTextureImageUnits,

+                                             ctx->Const.MaxTextureCoordUnits));

+   assert(ctx->Const.MaxCombinedTextureImageUnits > 0);

+   assert(ctx->Const.MaxCombinedTextureImageUnits <= MAX_COMBINED_TEXTURE_IMAGE_UNITS);

+   assert(ctx->Const.MaxTextureCoordUnits <= MAX_COMBINED_TEXTURE_IMAGE_UNITS);

+   /* number of coord units cannot be greater than number of image units */

+   assert(ctx->Const.MaxTextureCoordUnits <= ctx->Const.MaxTextureImageUnits);

+

+

+   /* Texture size checks */

+   assert(ctx->Const.MaxTextureLevels <= MAX_TEXTURE_LEVELS);

+   assert(ctx->Const.Max3DTextureLevels <= MAX_3D_TEXTURE_LEVELS);

+   assert(ctx->Const.MaxCubeTextureLevels <= MAX_CUBE_TEXTURE_LEVELS);

+   assert(ctx->Const.MaxTextureRectSize <= MAX_TEXTURE_RECT_SIZE);

+

+   /* make sure largest texture image is <= MAX_WIDTH in size */

+   assert((1 << (ctx->Const.MaxTextureLevels - 1)) <= MAX_WIDTH);

+   assert((1 << (ctx->Const.MaxCubeTextureLevels - 1)) <= MAX_WIDTH);

+   assert((1 << (ctx->Const.Max3DTextureLevels - 1)) <= MAX_WIDTH);

+

+   /* Texture level checks */

+   assert(MAX_TEXTURE_LEVELS >= MAX_3D_TEXTURE_LEVELS);

+   assert(MAX_TEXTURE_LEVELS >= MAX_CUBE_TEXTURE_LEVELS);

+

+   /* Max texture size should be <= max viewport size (render to texture) */

+   assert((1 << (MAX_TEXTURE_LEVELS - 1)) <= MAX_WIDTH);

+

+   assert(ctx->Const.MaxViewportWidth <= MAX_WIDTH);

+   assert(ctx->Const.MaxViewportHeight <= MAX_WIDTH);

+

+   assert(ctx->Const.MaxDrawBuffers <= MAX_DRAW_BUFFERS);

+

+   /* if this fails, add more enum values to gl_buffer_index */

+   assert(BUFFER_COLOR0 + MAX_DRAW_BUFFERS <= BUFFER_COUNT);

+

+   /* XXX probably add more tests */

+}

+

+

+/**

+ * Initialize the attribute groups in a GL context.

+ *

+ * \param ctx GL context.

+ *

+ * Initializes all the attributes, calling the respective <tt>init*</tt>

+ * functions for the more complex data structures.

+ */

+static GLboolean

+init_attrib_groups(struct gl_context *ctx)

+{

+   assert(ctx);

+

+   /* Constants */

+   _mesa_init_constants( ctx );

+

+   /* Extensions */

+   _mesa_init_extensions( ctx );

+

+   /* Attribute Groups */

+   _mesa_init_accum( ctx );

+   _mesa_init_attrib( ctx );

+   _mesa_init_buffer_objects( ctx );

+   _mesa_init_color( ctx );

+   _mesa_init_current( ctx );

+   _mesa_init_depth( ctx );

+   _mesa_init_debug( ctx );

+   _mesa_init_display_list( ctx );

+   _mesa_init_eval( ctx );

+   _mesa_init_fbobjects( ctx );

+   _mesa_init_feedback( ctx );

+   _mesa_init_fog( ctx );

+   _mesa_init_hint( ctx );

+   _mesa_init_line( ctx );

+   _mesa_init_lighting( ctx );

+   _mesa_init_matrix( ctx );

+   _mesa_init_multisample( ctx );

+   _mesa_init_pixel( ctx );

+   _mesa_init_pixelstore( ctx );

+   _mesa_init_point( ctx );

+   _mesa_init_polygon( ctx );

+   _mesa_init_program( ctx );

+   _mesa_init_queryobj( ctx );

+   _mesa_init_sync( ctx );

+   _mesa_init_rastpos( ctx );

+   _mesa_init_scissor( ctx );

+   _mesa_init_shader_state( ctx );

+   _mesa_init_stencil( ctx );

+   _mesa_init_transform( ctx );

+   _mesa_init_transform_feedback( ctx );

+   _mesa_init_varray( ctx );

+   _mesa_init_viewport( ctx );

+

+   if (!_mesa_init_texture( ctx ))

+      return GL_FALSE;

+

+   _mesa_init_texture_s3tc( ctx );

+

+   /* Miscellaneous */

+   ctx->NewState = _NEW_ALL;

+   ctx->ErrorValue = (GLenum) GL_NO_ERROR;

+   ctx->varying_vp_inputs = ~0;

+

+   return GL_TRUE;

+}

+

+

+/**

+ * Update default objects in a GL context with respect to shared state.

+ *

+ * \param ctx GL context.

+ *

+ * Removes references to old default objects, (texture objects, program

+ * objects, etc.) and changes to reference those from the current shared

+ * state.

+ */

+static GLboolean

+update_default_objects(struct gl_context *ctx)

+{

+   assert(ctx);

+

+   _mesa_update_default_objects_program(ctx);

+   _mesa_update_default_objects_texture(ctx);

+   _mesa_update_default_objects_buffer_objects(ctx);

+

+   return GL_TRUE;

+}

+

+

+/**

+ * This is the default function we plug into all dispatch table slots

+ * This helps prevents a segfault when someone calls a GL function without

+ * first checking if the extension's supported.

+ */

+static int

+generic_nop(void)

+{

+   _mesa_warning(NULL, "User called no-op dispatch function (an unsupported extension function?)");

+   return 0;

+}

+

+

+/**

+ * Allocate and initialize a new dispatch table.

+ */

+struct _glapi_table *

+_mesa_alloc_dispatch_table(int size)

+{

+   /* Find the larger of Mesa's dispatch table and libGL's dispatch table.

+    * In practice, this'll be the same for stand-alone Mesa.  But for DRI

+    * Mesa we do this to accomodate different versions of libGL and various

+    * DRI drivers.

+    */

+   GLint numEntries = MAX2(_glapi_get_dispatch_table_size(), _gloffset_COUNT);

+   struct _glapi_table *table;

+

+   /* should never happen, but just in case */

+   numEntries = MAX2(numEntries, size);

+

+   table = (struct _glapi_table *) malloc(numEntries * sizeof(_glapi_proc));

+   if (table) {

+      _glapi_proc *entry = (_glapi_proc *) table;

+      GLint i;

+      for (i = 0; i < numEntries; i++) {

+         entry[i] = (_glapi_proc) generic_nop;

+      }

+   }

+   return table;

+}

+

+

+/**

+ * Initialize a struct gl_context struct (rendering context).

+ *

+ * This includes allocating all the other structs and arrays which hang off of

+ * the context by pointers.

+ * Note that the driver needs to pass in its dd_function_table here since

+ * we need to at least call driverFunctions->NewTextureObject to create the

+ * default texture objects.

+ * 

+ * Called by _mesa_create_context().

+ *

+ * Performs the imports and exports callback tables initialization, and

+ * miscellaneous one-time initializations. If no shared context is supplied one

+ * is allocated, and increase its reference count.  Setups the GL API dispatch

+ * tables.  Initialize the TNL module. Sets the maximum Z buffer depth.

+ * Finally queries the \c MESA_DEBUG and \c MESA_VERBOSE environment variables

+ * for debug flags.

+ *

+ * \param ctx the context to initialize

+ * \param api the GL API type to create the context for

+ * \param visual describes the visual attributes for this context

+ * \param share_list points to context to share textures, display lists,

+ *        etc with, or NULL

+ * \param driverFunctions table of device driver functions for this context

+ *        to use

+ * \param driverContext pointer to driver-specific context data

+ */

+GLboolean

+_mesa_initialize_context(struct gl_context *ctx,

+                         gl_api api,

+                         const struct gl_config *visual,

+                         struct gl_context *share_list,

+                         const struct dd_function_table *driverFunctions,

+                         void *driverContext)

+{

+   struct gl_shared_state *shared;

+   int i;

+

+   /*ASSERT(driverContext);*/

+   assert(driverFunctions->NewTextureObject);

+   assert(driverFunctions->FreeTexImageData);

+

+   ctx->API = api;

+   ctx->Visual = *visual;

+   ctx->DrawBuffer = NULL;

+   ctx->ReadBuffer = NULL;

+   ctx->WinSysDrawBuffer = NULL;

+   ctx->WinSysReadBuffer = NULL;

+

+   /* misc one-time initializations */

+   one_time_init(ctx);

+

+   /* Plug in driver functions and context pointer here.

+    * This is important because when we call alloc_shared_state() below

+    * we'll call ctx->Driver.NewTextureObject() to create the default

+    * textures.

+    */

+   ctx->Driver = *driverFunctions;

+   ctx->DriverCtx = driverContext;

+

+   if (share_list) {

+      /* share state with another context */

+      shared = share_list->Shared;

+   }

+   else {

+      /* allocate new, unshared state */

+      shared = _mesa_alloc_shared_state(ctx);

+      if (!shared)

+         return GL_FALSE;

+   }

+

+   _glthread_LOCK_MUTEX(shared->Mutex);

+   ctx->Shared = shared;

+   shared->RefCount++;

+   _glthread_UNLOCK_MUTEX(shared->Mutex);

+

+   if (!init_attrib_groups( ctx )) {

+      _mesa_release_shared_state(ctx, ctx->Shared);

+      return GL_FALSE;

+   }

+

+#if FEATURE_dispatch

+   /* setup the API dispatch tables */

+   switch (ctx->API) {

+#if FEATURE_GL

+   case API_OPENGL:

+      ctx->Exec = _mesa_create_exec_table();

+      break;

+#endif

+#if FEATURE_ES1

+   case API_OPENGLES:

+      ctx->Exec = _mesa_create_exec_table_es1();

+      break;

+#endif

+#if FEATURE_ES2

+   case API_OPENGLES2:

+      ctx->Exec = _mesa_create_exec_table_es2();

+      break;

+#endif

+   default:

+      _mesa_problem(ctx, "unknown or unsupported API");

+      break;

+   }

+

+   if (!ctx->Exec) {

+      _mesa_release_shared_state(ctx, ctx->Shared);

+      return GL_FALSE;

+   }

+#endif

+   ctx->CurrentDispatch = ctx->Exec;

+

+   ctx->FragmentProgram._MaintainTexEnvProgram

+      = (_mesa_getenv("MESA_TEX_PROG") != NULL);

+

+   ctx->VertexProgram._MaintainTnlProgram

+      = (_mesa_getenv("MESA_TNL_PROG") != NULL);

+   if (ctx->VertexProgram._MaintainTnlProgram) {

+      /* this is required... */

+      ctx->FragmentProgram._MaintainTexEnvProgram = GL_TRUE;

+   }

+

+   /* Mesa core handles all the formats that mesa core knows about.

+    * Drivers will want to override this list with just the formats

+    * they can handle, and confirm that appropriate fallbacks exist in

+    * _mesa_choose_tex_format().

+    */

+   memset(&ctx->TextureFormatSupported, GL_TRUE,

+	  sizeof(ctx->TextureFormatSupported));

+

+   switch (ctx->API) {

+   case API_OPENGL:

+#if FEATURE_dlist

+      ctx->Save = _mesa_create_save_table();

+      if (!ctx->Save) {

+	 _mesa_release_shared_state(ctx, ctx->Shared);

+	 free(ctx->Exec);

+	 return GL_FALSE;

+      }

+

+      _mesa_install_save_vtxfmt( ctx, &ctx->ListState.ListVtxfmt );

+#endif

+      break;

+   case API_OPENGLES:

+      /**

+       * GL_OES_texture_cube_map says

+       * "Initially all texture generation modes are set to REFLECTION_MAP_OES"

+       */

+      for (i = 0; i < MAX_TEXTURE_UNITS; i++) {

+	 struct gl_texture_unit *texUnit = &ctx->Texture.Unit[i];

+	 texUnit->GenS.Mode = GL_REFLECTION_MAP_NV;

+	 texUnit->GenT.Mode = GL_REFLECTION_MAP_NV;

+	 texUnit->GenR.Mode = GL_REFLECTION_MAP_NV;

+	 texUnit->GenS._ModeBit = TEXGEN_REFLECTION_MAP_NV;

+	 texUnit->GenT._ModeBit = TEXGEN_REFLECTION_MAP_NV;

+	 texUnit->GenR._ModeBit = TEXGEN_REFLECTION_MAP_NV;

+      }

+      break;

+   case API_OPENGLES2:

+      ctx->FragmentProgram._MaintainTexEnvProgram = GL_TRUE;

+      ctx->VertexProgram._MaintainTnlProgram = GL_TRUE;

+      ctx->Point.PointSprite = GL_TRUE;  /* always on for ES 2.x */

+      break;

+   }

+

+   ctx->FirstTimeCurrent = GL_TRUE;

+

+   return GL_TRUE;

+}

+

+

+/**

+ * Allocate and initialize a struct gl_context structure.

+ * Note that the driver needs to pass in its dd_function_table here since

+ * we need to at least call driverFunctions->NewTextureObject to initialize

+ * the rendering context.

+ *

+ * \param api the GL API type to create the context for

+ * \param visual a struct gl_config pointer (we copy the struct contents)

+ * \param share_list another context to share display lists with or NULL

+ * \param driverFunctions points to the dd_function_table into which the

+ *        driver has plugged in all its special functions.

+ * \param driverContext points to the device driver's private context state

+ * 

+ * \return pointer to a new __struct gl_contextRec or NULL if error.

+ */

+struct gl_context *

+_mesa_create_context(gl_api api,

+                     const struct gl_config *visual,

+                     struct gl_context *share_list,

+                     const struct dd_function_table *driverFunctions,

+                     void *driverContext)

+{

+   struct gl_context *ctx;

+

+   ASSERT(visual);

+   /*ASSERT(driverContext);*/

+

+   ctx = (struct gl_context *) calloc(1, sizeof(struct gl_context));

+   if (!ctx)

+      return NULL;

+

+   if (_mesa_initialize_context(ctx, api, visual, share_list,

+                                driverFunctions, driverContext)) {

+      return ctx;

+   }

+   else {

+      free(ctx);

+      return NULL;

+   }

+}

+

+

+/**

+ * Free the data associated with the given context.

+ * 

+ * But doesn't free the struct gl_context struct itself.

+ *

+ * \sa _mesa_initialize_context() and init_attrib_groups().

+ */

+void

+_mesa_free_context_data( struct gl_context *ctx )

+{

+   if (!_mesa_get_current_context()){

+      /* No current context, but we may need one in order to delete

+       * texture objs, etc.  So temporarily bind the context now.

+       */

+      _mesa_make_current(ctx, NULL, NULL);

+   }

+

+   /* unreference WinSysDraw/Read buffers */

+   _mesa_reference_framebuffer(&ctx->WinSysDrawBuffer, NULL);

+   _mesa_reference_framebuffer(&ctx->WinSysReadBuffer, NULL);

+   _mesa_reference_framebuffer(&ctx->DrawBuffer, NULL);

+   _mesa_reference_framebuffer(&ctx->ReadBuffer, NULL);

+

+   _mesa_reference_vertprog(ctx, &ctx->VertexProgram.Current, NULL);

+   _mesa_reference_vertprog(ctx, &ctx->VertexProgram._Current, NULL);

+   _mesa_reference_vertprog(ctx, &ctx->VertexProgram._TnlProgram, NULL);

+

+   _mesa_reference_fragprog(ctx, &ctx->FragmentProgram.Current, NULL);

+   _mesa_reference_fragprog(ctx, &ctx->FragmentProgram._Current, NULL);

+   _mesa_reference_fragprog(ctx, &ctx->FragmentProgram._TexEnvProgram, NULL);

+

+   _mesa_free_attrib_data(ctx);

+   _mesa_free_buffer_objects(ctx);

+   _mesa_free_lighting_data( ctx );

+   _mesa_free_eval_data( ctx );

+   _mesa_free_texture_data( ctx );

+   _mesa_free_matrix_data( ctx );

+   _mesa_free_viewport_data( ctx );

+   _mesa_free_program_data(ctx);

+   _mesa_free_shader_state(ctx);

+   _mesa_free_queryobj_data(ctx);

+   _mesa_free_sync_data(ctx);

+   _mesa_free_varray_data(ctx);

+   _mesa_free_transform_feedback(ctx);

+

+   _mesa_delete_array_object(ctx, ctx->Array.DefaultArrayObj);

+

+#if FEATURE_ARB_pixel_buffer_object

+   _mesa_reference_buffer_object(ctx, &ctx->Pack.BufferObj, NULL);

+   _mesa_reference_buffer_object(ctx, &ctx->Unpack.BufferObj, NULL);

+   _mesa_reference_buffer_object(ctx, &ctx->DefaultPacking.BufferObj, NULL);

+#endif

+

+#if FEATURE_ARB_vertex_buffer_object

+   _mesa_reference_buffer_object(ctx, &ctx->Array.ArrayBufferObj, NULL);

+   _mesa_reference_buffer_object(ctx, &ctx->Array.ElementArrayBufferObj, NULL);

+#endif

+

+   /* free dispatch tables */

+   free(ctx->Exec);

+   free(ctx->Save);

+

+   /* Shared context state (display lists, textures, etc) */

+   _mesa_release_shared_state( ctx, ctx->Shared );

+

+   /* needs to be after freeing shared state */

+   _mesa_free_display_list_data(ctx);

+

+   if (ctx->Extensions.String)

+      free((void *) ctx->Extensions.String);

+

+   if (ctx->VersionString)

+      free(ctx->VersionString);

+

+   /* unbind the context if it's currently bound */

+   if (ctx == _mesa_get_current_context()) {

+      _mesa_make_current(NULL, NULL, NULL);

+   }

+}

+

+

+/**

+ * Destroy a struct gl_context structure.

+ *

+ * \param ctx GL context.

+ * 

+ * Calls _mesa_free_context_data() and frees the gl_context object itself.

+ */

+void

+_mesa_destroy_context( struct gl_context *ctx )

+{

+   if (ctx) {

+      _mesa_free_context_data(ctx);

+      free( (void *) ctx );

+   }

+}

+

+

+#if _HAVE_FULL_GL

+/**

+ * Copy attribute groups from one context to another.

+ * 

+ * \param src source context

+ * \param dst destination context

+ * \param mask bitwise OR of GL_*_BIT flags

+ *

+ * According to the bits specified in \p mask, copies the corresponding

+ * attributes from \p src into \p dst.  For many of the attributes a simple \c

+ * memcpy is not enough due to the existence of internal pointers in their data

+ * structures.

+ */

+void

+_mesa_copy_context( const struct gl_context *src, struct gl_context *dst, GLuint mask )

+{

+   if (mask & GL_ACCUM_BUFFER_BIT) {

+      /* OK to memcpy */

+      dst->Accum = src->Accum;

+   }

+   if (mask & GL_COLOR_BUFFER_BIT) {

+      /* OK to memcpy */

+      dst->Color = src->Color;

+   }

+   if (mask & GL_CURRENT_BIT) {

+      /* OK to memcpy */

+      dst->Current = src->Current;

+   }

+   if (mask & GL_DEPTH_BUFFER_BIT) {

+      /* OK to memcpy */

+      dst->Depth = src->Depth;

+   }

+   if (mask & GL_ENABLE_BIT) {

+      /* no op */

+   }

+   if (mask & GL_EVAL_BIT) {

+      /* OK to memcpy */

+      dst->Eval = src->Eval;

+   }

+   if (mask & GL_FOG_BIT) {

+      /* OK to memcpy */

+      dst->Fog = src->Fog;

+   }

+   if (mask & GL_HINT_BIT) {

+      /* OK to memcpy */

+      dst->Hint = src->Hint;

+   }

+   if (mask & GL_LIGHTING_BIT) {

+      GLuint i;

+      /* begin with memcpy */

+      dst->Light = src->Light;

+      /* fixup linked lists to prevent pointer insanity */

+      make_empty_list( &(dst->Light.EnabledList) );

+      for (i = 0; i < MAX_LIGHTS; i++) {

+         if (dst->Light.Light[i].Enabled) {

+            insert_at_tail(&(dst->Light.EnabledList), &(dst->Light.Light[i]));

+         }

+      }

+   }

+   if (mask & GL_LINE_BIT) {

+      /* OK to memcpy */

+      dst->Line = src->Line;

+   }

+   if (mask & GL_LIST_BIT) {

+      /* OK to memcpy */

+      dst->List = src->List;

+   }

+   if (mask & GL_PIXEL_MODE_BIT) {

+      /* OK to memcpy */

+      dst->Pixel = src->Pixel;

+   }

+   if (mask & GL_POINT_BIT) {

+      /* OK to memcpy */

+      dst->Point = src->Point;

+   }

+   if (mask & GL_POLYGON_BIT) {

+      /* OK to memcpy */

+      dst->Polygon = src->Polygon;

+   }

+   if (mask & GL_POLYGON_STIPPLE_BIT) {

+      /* Use loop instead of memcpy due to problem with Portland Group's

+       * C compiler.  Reported by John Stone.

+       */

+      GLuint i;

+      for (i = 0; i < 32; i++) {

+         dst->PolygonStipple[i] = src->PolygonStipple[i];

+      }

+   }

+   if (mask & GL_SCISSOR_BIT) {

+      /* OK to memcpy */

+      dst->Scissor = src->Scissor;

+   }

+   if (mask & GL_STENCIL_BUFFER_BIT) {

+      /* OK to memcpy */

+      dst->Stencil = src->Stencil;

+   }

+   if (mask & GL_TEXTURE_BIT) {

+      /* Cannot memcpy because of pointers */

+      _mesa_copy_texture_state(src, dst);

+   }

+   if (mask & GL_TRANSFORM_BIT) {

+      /* OK to memcpy */

+      dst->Transform = src->Transform;

+   }

+   if (mask & GL_VIEWPORT_BIT) {

+      /* Cannot use memcpy, because of pointers in GLmatrix _WindowMap */

+      dst->Viewport.X = src->Viewport.X;

+      dst->Viewport.Y = src->Viewport.Y;

+      dst->Viewport.Width = src->Viewport.Width;

+      dst->Viewport.Height = src->Viewport.Height;

+      dst->Viewport.Near = src->Viewport.Near;

+      dst->Viewport.Far = src->Viewport.Far;

+      _math_matrix_copy(&dst->Viewport._WindowMap, &src->Viewport._WindowMap);

+   }

+

+   /* XXX FIXME:  Call callbacks?

+    */

+   dst->NewState = _NEW_ALL;

+}

+#endif

+

+

+/**

+ * Check if the given context can render into the given framebuffer

+ * by checking visual attributes.

+ *

+ * Most of these tests could go away because Mesa is now pretty flexible

+ * in terms of mixing rendering contexts with framebuffers.  As long

+ * as RGB vs. CI mode agree, we're probably good.

+ *

+ * \return GL_TRUE if compatible, GL_FALSE otherwise.

+ */

+static GLboolean 

+check_compatible(const struct gl_context *ctx,

+                 const struct gl_framebuffer *buffer)

+{

+   const struct gl_config *ctxvis = &ctx->Visual;

+   const struct gl_config *bufvis = &buffer->Visual;

+

+   if (buffer == _mesa_get_incomplete_framebuffer())

+      return GL_TRUE;

+

+#if 0

+   /* disabling this fixes the fgl_glxgears pbuffer demo */

+   if (ctxvis->doubleBufferMode && !bufvis->doubleBufferMode)

+      return GL_FALSE;

+#endif

+   if (ctxvis->stereoMode && !bufvis->stereoMode)

+      return GL_FALSE;

+   if (ctxvis->haveAccumBuffer && !bufvis->haveAccumBuffer)

+      return GL_FALSE;

+   if (ctxvis->haveDepthBuffer && !bufvis->haveDepthBuffer)

+      return GL_FALSE;

+   if (ctxvis->haveStencilBuffer && !bufvis->haveStencilBuffer)

+      return GL_FALSE;

+   if (ctxvis->redMask && ctxvis->redMask != bufvis->redMask)

+      return GL_FALSE;

+   if (ctxvis->greenMask && ctxvis->greenMask != bufvis->greenMask)

+      return GL_FALSE;

+   if (ctxvis->blueMask && ctxvis->blueMask != bufvis->blueMask)

+      return GL_FALSE;

+#if 0

+   /* disabled (see bug 11161) */

+   if (ctxvis->depthBits && ctxvis->depthBits != bufvis->depthBits)

+      return GL_FALSE;

+#endif

+   if (ctxvis->stencilBits && ctxvis->stencilBits != bufvis->stencilBits)

+      return GL_FALSE;

+

+   return GL_TRUE;

+}

+

+

+/**

+ * Do one-time initialization for the given framebuffer.  Specifically,

+ * ask the driver for the window's current size and update the framebuffer

+ * object to match.

+ * Really, the device driver should totally take care of this.

+ */

+static void

+initialize_framebuffer_size(struct gl_context *ctx, struct gl_framebuffer *fb)

+{

+   GLuint width, height;

+   if (ctx->Driver.GetBufferSize) {

+      ctx->Driver.GetBufferSize(fb, &width, &height);

+      if (ctx->Driver.ResizeBuffers)

+         ctx->Driver.ResizeBuffers(ctx, fb, width, height);

+      fb->Initialized = GL_TRUE;

+   }

+}

+

+

+/**

+ * Check if the viewport/scissor size has not yet been initialized.

+ * Initialize the size if the given width and height are non-zero.

+ */

+void

+_mesa_check_init_viewport(struct gl_context *ctx, GLuint width, GLuint height)

+{

+   if (!ctx->ViewportInitialized && width > 0 && height > 0) {

+      /* Note: set flag here, before calling _mesa_set_viewport(), to prevent

+       * potential infinite recursion.

+       */

+      ctx->ViewportInitialized = GL_TRUE;

+      _mesa_set_viewport(ctx, 0, 0, width, height);

+      _mesa_set_scissor(ctx, 0, 0, width, height);

+   }

+}

+

+

+/**

+ * Bind the given context to the given drawBuffer and readBuffer and

+ * make it the current context for the calling thread.

+ * We'll render into the drawBuffer and read pixels from the

+ * readBuffer (i.e. glRead/CopyPixels, glCopyTexImage, etc).

+ *

+ * We check that the context's and framebuffer's visuals are compatible

+ * and return immediately if they're not.

+ *

+ * \param newCtx  the new GL context. If NULL then there will be no current GL

+ *                context.

+ * \param drawBuffer  the drawing framebuffer

+ * \param readBuffer  the reading framebuffer

+ */

+GLboolean

+_mesa_make_current( struct gl_context *newCtx,

+                    struct gl_framebuffer *drawBuffer,

+                    struct gl_framebuffer *readBuffer )

+{

+   GET_CURRENT_CONTEXT(curCtx);

+

+   if (MESA_VERBOSE & VERBOSE_API)

+      _mesa_debug(newCtx, "_mesa_make_current()\n");

+

+   /* Check that the context's and framebuffer's visuals are compatible.

+    */

+   if (newCtx && drawBuffer && newCtx->WinSysDrawBuffer != drawBuffer) {

+      if (!check_compatible(newCtx, drawBuffer)) {

+         _mesa_warning(newCtx,

+              "MakeCurrent: incompatible visuals for context and drawbuffer");

+         return GL_FALSE;

+      }

+   }

+   if (newCtx && readBuffer && newCtx->WinSysReadBuffer != readBuffer) {

+      if (!check_compatible(newCtx, readBuffer)) {

+         _mesa_warning(newCtx,

+              "MakeCurrent: incompatible visuals for context and readbuffer");

+         return GL_FALSE;

+      }

+   }

+

+   if (curCtx && 

+      (curCtx->WinSysDrawBuffer || curCtx->WinSysReadBuffer) && /* make sure this context is valid for flushing */

+      curCtx != newCtx)

+      _mesa_flush(curCtx);

+

+   /* We used to call _glapi_check_multithread() here.  Now do it in drivers */

+   _glapi_set_context((void *) newCtx);

+   ASSERT(_mesa_get_current_context() == newCtx);

+

+   if (!newCtx) {

+      _glapi_set_dispatch(NULL);  /* none current */

+   }

+   else {

+      _glapi_set_dispatch(newCtx->CurrentDispatch);

+

+      if (drawBuffer && readBuffer) {

+	 /* TODO: check if newCtx and buffer's visual match??? */

+

+         ASSERT(drawBuffer->Name == 0);

+         ASSERT(readBuffer->Name == 0);

+         _mesa_reference_framebuffer(&newCtx->WinSysDrawBuffer, drawBuffer);

+         _mesa_reference_framebuffer(&newCtx->WinSysReadBuffer, readBuffer);

+

+         /*

+          * Only set the context's Draw/ReadBuffer fields if they're NULL

+          * or not bound to a user-created FBO.

+          */

+         if (!newCtx->DrawBuffer || newCtx->DrawBuffer->Name == 0) {

+            /* KW: merge conflict here, revisit. 

+             */

+            /* fix up the fb fields - these will end up wrong otherwise

+             * if the DRIdrawable changes, and everything relies on them.

+             * This is a bit messy (same as needed in _mesa_BindFramebufferEXT)

+             */

+            unsigned int i;

+            GLenum buffers[MAX_DRAW_BUFFERS];

+

+            _mesa_reference_framebuffer(&newCtx->DrawBuffer, drawBuffer);

+

+            for(i = 0; i < newCtx->Const.MaxDrawBuffers; i++) {

+               buffers[i] = newCtx->Color.DrawBuffer[i];

+            }

+

+            _mesa_drawbuffers(newCtx, newCtx->Const.MaxDrawBuffers,

+                              buffers, NULL);

+         }

+         if (!newCtx->ReadBuffer || newCtx->ReadBuffer->Name == 0) {

+            _mesa_reference_framebuffer(&newCtx->ReadBuffer, readBuffer);

+         }

+

+         /* XXX only set this flag if we're really changing the draw/read

+          * framebuffer bindings.

+          */

+	 newCtx->NewState |= _NEW_BUFFERS;

+

+#if 1

+         /* We want to get rid of these lines: */

+

+#if _HAVE_FULL_GL

+         if (!drawBuffer->Initialized) {

+            initialize_framebuffer_size(newCtx, drawBuffer);

+         }

+         if (readBuffer != drawBuffer && !readBuffer->Initialized) {

+            initialize_framebuffer_size(newCtx, readBuffer);

+         }

+

+	 _mesa_resizebuffers(newCtx);

+#endif

+

+#else

+         /* We want the drawBuffer and readBuffer to be initialized by

+          * the driver.

+          * This generally means the Width and Height match the actual

+          * window size and the renderbuffers (both hardware and software

+          * based) are allocated to match.  The later can generally be

+          * done with a call to _mesa_resize_framebuffer().

+          *

+          * It's theoretically possible for a buffer to have zero width

+          * or height, but for now, assert check that the driver did what's

+          * expected of it.

+          */

+         ASSERT(drawBuffer->Width > 0);

+         ASSERT(drawBuffer->Height > 0);

+#endif

+

+         if (drawBuffer) {

+            _mesa_check_init_viewport(newCtx,

+                                      drawBuffer->Width, drawBuffer->Height);

+         }

+      }

+

+      if (newCtx->FirstTimeCurrent) {

+         _mesa_compute_version(newCtx);

+

+         newCtx->Extensions.String = _mesa_make_extension_string(newCtx);

+

+         check_context_limits(newCtx);

+

+         /* We can use this to help debug user's problems.  Tell them to set

+          * the MESA_INFO env variable before running their app.  Then the

+          * first time each context is made current we'll print some useful

+          * information.

+          */

+	 if (_mesa_getenv("MESA_INFO")) {

+	    _mesa_print_info();

+	 }

+

+	 newCtx->FirstTimeCurrent = GL_FALSE;

+      }

+   }

+   

+   return GL_TRUE;

+}

+

+

+/**

+ * Make context 'ctx' share the display lists, textures and programs

+ * that are associated with 'ctxToShare'.

+ * Any display lists, textures or programs associated with 'ctx' will

+ * be deleted if nobody else is sharing them.

+ */

+GLboolean

+_mesa_share_state(struct gl_context *ctx, struct gl_context *ctxToShare)

+{

+   if (ctx && ctxToShare && ctx->Shared && ctxToShare->Shared) {

+      struct gl_shared_state *oldSharedState = ctx->Shared;

+

+      ctx->Shared = ctxToShare->Shared;

+      

+      _glthread_LOCK_MUTEX(ctx->Shared->Mutex);

+      ctx->Shared->RefCount++;

+      _glthread_UNLOCK_MUTEX(ctx->Shared->Mutex);

+

+      update_default_objects(ctx);

+

+      _mesa_release_shared_state(ctx, oldSharedState);

+

+      return GL_TRUE;

+   }

+   else {

+      return GL_FALSE;

+   }

+}

+

+

+

+/**

+ * \return pointer to the current GL context for this thread.

+ * 

+ * Calls _glapi_get_context(). This isn't the fastest way to get the current

+ * context.  If you need speed, see the #GET_CURRENT_CONTEXT macro in

+ * context.h.

+ */

+struct gl_context *

+_mesa_get_current_context( void )

+{

+   return (struct gl_context *) _glapi_get_context();

+}

+

+

+/**

+ * Get context's current API dispatch table.

+ *

+ * It'll either be the immediate-mode execute dispatcher or the display list

+ * compile dispatcher.

+ * 

+ * \param ctx GL context.

+ *

+ * \return pointer to dispatch_table.

+ *

+ * Simply returns __struct gl_contextRec::CurrentDispatch.

+ */

+struct _glapi_table *

+_mesa_get_dispatch(struct gl_context *ctx)

+{

+   return ctx->CurrentDispatch;

+}

+

+/*@}*/

+

+

+/**********************************************************************/

+/** \name Miscellaneous functions                                     */

+/**********************************************************************/

+/*@{*/

+

+/**

+ * Record an error.

+ *

+ * \param ctx GL context.

+ * \param error error code.

+ * 

+ * Records the given error code and call the driver's dd_function_table::Error

+ * function if defined.

+ *

+ * \sa

+ * This is called via _mesa_error().

+ */

+void

+_mesa_record_error(struct gl_context *ctx, GLenum error)

+{

+   if (!ctx)

+      return;

+

+   if (ctx->ErrorValue == GL_NO_ERROR) {

+      ctx->ErrorValue = error;

+   }

+

+   /* Call device driver's error handler, if any.  This is used on the Mac. */

+   if (ctx->Driver.Error) {

+      ctx->Driver.Error(ctx);

+   }

+}

+

+

+/**

+ * Flush commands and wait for completion.

+ */

+void

+_mesa_finish(struct gl_context *ctx)

+{

+   FLUSH_CURRENT( ctx, 0 );

+   if (ctx->Driver.Finish) {

+      ctx->Driver.Finish(ctx);

+   }

+}

+

+

+/**

+ * Flush commands.

+ */

+void

+_mesa_flush(struct gl_context *ctx)

+{

+   FLUSH_CURRENT( ctx, 0 );

+   if (ctx->Driver.Flush) {

+      ctx->Driver.Flush(ctx);

+   }

+}

+

+

+

+/**

+ * Execute glFinish().

+ *

+ * Calls the #ASSERT_OUTSIDE_BEGIN_END_AND_FLUSH macro and the

+ * dd_function_table::Finish driver callback, if not NULL.

+ */

+void GLAPIENTRY

+_mesa_Finish(void)

+{

+   GET_CURRENT_CONTEXT(ctx);

+   ASSERT_OUTSIDE_BEGIN_END_AND_FLUSH(ctx);

+   _mesa_finish(ctx);

+}

+

+

+/**

+ * Execute glFlush().

+ *

+ * Calls the #ASSERT_OUTSIDE_BEGIN_END_AND_FLUSH macro and the

+ * dd_function_table::Flush driver callback, if not NULL.

+ */

+void GLAPIENTRY

+_mesa_Flush(void)

+{

+   GET_CURRENT_CONTEXT(ctx);

+   ASSERT_OUTSIDE_BEGIN_END_AND_FLUSH(ctx);

+   _mesa_flush(ctx);

+}

+

+

+/**

+ * Set mvp_with_dp4 flag.  If a driver has a preference for DP4 over

+ * MUL/MAD, or vice versa, call this function to register that.

+ * Otherwise we default to MUL/MAD.

+ */

+void

+_mesa_set_mvp_with_dp4( struct gl_context *ctx,

+                        GLboolean flag )

+{

+   ctx->mvp_with_dp4 = flag;

+}

+

+

+

+/**

+ * Prior to drawing anything with glBegin, glDrawArrays, etc. this function

+ * is called to see if it's valid to render.  This involves checking that

+ * the current shader is valid and the framebuffer is complete.

+ * If an error is detected it'll be recorded here.

+ * \return GL_TRUE if OK to render, GL_FALSE if not

+ */

+GLboolean

+_mesa_valid_to_render(struct gl_context *ctx, const char *where)

+{

+   bool vert_from_glsl_shader = false;

+   bool geom_from_glsl_shader = false;

+   bool frag_from_glsl_shader = false;

+

+   /* This depends on having up to date derived state (shaders) */

+   if (ctx->NewState)

+      _mesa_update_state(ctx);

+

+   if (ctx->Shader.CurrentVertexProgram) {

+      vert_from_glsl_shader = true;

+

+      if (!ctx->Shader.CurrentVertexProgram->LinkStatus) {

+         _mesa_error(ctx, GL_INVALID_OPERATION,

+                     "%s(shader not linked)", where);

+         return GL_FALSE;

+      }

+#if 0 /* not normally enabled */

+      {

+         char errMsg[100];

+         if (!_mesa_validate_shader_program(ctx,

+					    ctx->Shader.CurrentVertexProgram,

+                                            errMsg)) {

+            _mesa_warning(ctx, "Shader program %u is invalid: %s",

+                          ctx->Shader.CurrentVertexProgram->Name, errMsg);

+         }

+      }

+#endif

+   }

+

+   if (ctx->Shader.CurrentGeometryProgram) {

+      geom_from_glsl_shader = true;

+

+      if (!ctx->Shader.CurrentGeometryProgram->LinkStatus) {

+         _mesa_error(ctx, GL_INVALID_OPERATION,

+                     "%s(shader not linked)", where);

+         return GL_FALSE;

+      }

+#if 0 /* not normally enabled */

+      {

+         char errMsg[100];

+         if (!_mesa_validate_shader_program(ctx,

+					    ctx->Shader.CurrentGeometryProgram,

+                                            errMsg)) {

+            _mesa_warning(ctx, "Shader program %u is invalid: %s",

+                          ctx->Shader.CurrentGeometryProgram->Name, errMsg);

+         }

+      }

+#endif

+   }

+

+   if (ctx->Shader.CurrentFragmentProgram) {

+      frag_from_glsl_shader = true;

+

+      if (!ctx->Shader.CurrentFragmentProgram->LinkStatus) {

+         _mesa_error(ctx, GL_INVALID_OPERATION,

+                     "%s(shader not linked)", where);

+         return GL_FALSE;

+      }

+#if 0 /* not normally enabled */

+      {

+         char errMsg[100];

+         if (!_mesa_validate_shader_program(ctx,

+					    ctx->Shader.CurrentFragmentProgram,

+                                            errMsg)) {

+            _mesa_warning(ctx, "Shader program %u is invalid: %s",

+                          ctx->Shader.CurrentFragmentProgram->Name, errMsg);

+         }

+      }

+#endif

+   }

+

+   /* Any shader stages that are not supplied by the GLSL shader and have

+    * assembly shaders enabled must now be validated.

+    */

+   if (!vert_from_glsl_shader

+       && ctx->VertexProgram.Enabled && !ctx->VertexProgram._Enabled) {

+      _mesa_error(ctx, GL_INVALID_OPERATION,

+		  "%s(vertex program not valid)", where);

+      return GL_FALSE;

+   }

+

+   /* FINISHME: If GL_NV_geometry_program4 is ever supported, the current

+    * FINISHME: geometry program should validated here.

+    */

+   (void) geom_from_glsl_shader;

+

+   if (!frag_from_glsl_shader) {

+      if (ctx->FragmentProgram.Enabled && !ctx->FragmentProgram._Enabled) {

+	 _mesa_error(ctx, GL_INVALID_OPERATION,

+		     "%s(fragment program not valid)", where);

+	 return GL_FALSE;

+      }

+

+      /* If drawing to integer-valued color buffers, there must be an

+       * active fragment shader (GL_EXT_texture_integer).

+       */

+      if (ctx->DrawBuffer && ctx->DrawBuffer->_IntegerColor) {

+         _mesa_error(ctx, GL_INVALID_OPERATION,

+                     "%s(integer format but no fragment shader)", where);

+         return GL_FALSE;

+      }

+   }

+

+   if (ctx->DrawBuffer->_Status != GL_FRAMEBUFFER_COMPLETE_EXT) {

+      _mesa_error(ctx, GL_INVALID_FRAMEBUFFER_OPERATION_EXT,

+                  "%s(incomplete framebuffer)", where);

+      return GL_FALSE;

+   }

+

+#ifdef DEBUG

+   if (ctx->Shader.Flags & GLSL_LOG) {

+      struct gl_shader_program *shProg[MESA_SHADER_TYPES];

+      gl_shader_type i;

+

+      shProg[MESA_SHADER_VERTEX] = ctx->Shader.CurrentVertexProgram;

+      shProg[MESA_SHADER_GEOMETRY] = ctx->Shader.CurrentGeometryProgram;

+      shProg[MESA_SHADER_FRAGMENT] = ctx->Shader.CurrentFragmentProgram;

+

+      for (i = 0; i < MESA_SHADER_TYPES; i++) {

+	 struct gl_shader *sh;

+

+	 if (shProg[i] == NULL || shProg[i]->_Used

+	     || shProg[i]->_LinkedShaders[i] == NULL)

+	    continue;

+

+	 /* This is the first time this shader is being used.

+	  * Append shader's constants/uniforms to log file.

+	  *

+	  * The logic is a little odd here.  We only want to log data for each

+	  * shader target that will actually be used, and we only want to log

+	  * it once.  It's possible to have a program bound to the vertex

+	  * shader target that also supplied a fragment shader.  If that

+	  * program isn't also bound to the fragment shader target we don't

+	  * want to log its fragment data.

+	  */

+	 sh = shProg[i]->_LinkedShaders[i];

+	 switch (sh->Type) {

+	 case GL_VERTEX_SHADER:

+	    _mesa_append_uniforms_to_file(sh, &shProg[i]->VertexProgram->Base);

+	    break;

+

+	 case GL_GEOMETRY_SHADER_ARB:

+	    _mesa_append_uniforms_to_file(sh,

+					  &shProg[i]->GeometryProgram->Base);

+	    break;

+

+	 case GL_FRAGMENT_SHADER:

+	    _mesa_append_uniforms_to_file(sh,

+					  &shProg[i]->FragmentProgram->Base);

+	    break;

+	 }

+      }

+

+      for (i = 0; i < MESA_SHADER_TYPES; i++) {

+	 if (shProg[i] != NULL)

+	    shProg[i]->_Used = GL_TRUE;

+      }

+   }

+#endif

+

+   return GL_TRUE;

+}

+

+

+/*@}*/

diff --git a/mesalib/src/mesa/main/context.h b/mesalib/src/mesa/main/context.h
index 4e391dde4..ae4d6f7da 100644
--- a/mesalib/src/mesa/main/context.h
+++ b/mesalib/src/mesa/main/context.h
@@ -1,313 +1,289 @@
-/*
- * Mesa 3-D graphics library
- * Version:  6.5.1
- *
- * Copyright (C) 1999-2006  Brian Paul   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 context.h
- * Mesa context and visual-related functions.
- *
- * There are three large Mesa data types/classes which are meant to be
- * used by device drivers:
- * - struct gl_context: this contains the Mesa rendering state
- * - struct gl_config:  this describes the color buffer (RGB vs. ci), whether or not
- *   there's a depth buffer, stencil buffer, etc.
- * - struct gl_framebuffer:  contains pointers to the depth buffer, stencil buffer,
- *   accum buffer and alpha buffers.
- *
- * These types should be encapsulated by corresponding device driver
- * data types.  See xmesa.h and xmesaP.h for an example.
- *
- * In OOP terms, struct gl_context, struct gl_config, and struct gl_framebuffer are base classes
- * which the device driver must derive from.
- *
- * The following functions create and destroy these data types.
- */
-
-
-#ifndef CONTEXT_H
-#define CONTEXT_H
-
-
-#include "imports.h"
-#include "mtypes.h"
-
-
-struct _glapi_table;
-
-
-/** \name Visual-related functions */
-/*@{*/
- 
-extern struct gl_config *
-_mesa_create_visual( GLboolean dbFlag,
-                     GLboolean stereoFlag,
-                     GLint redBits,
-                     GLint greenBits,
-                     GLint blueBits,
-                     GLint alphaBits,
-                     GLint depthBits,
-                     GLint stencilBits,
-                     GLint accumRedBits,
-                     GLint accumGreenBits,
-                     GLint accumBlueBits,
-                     GLint accumAlphaBits,
-                     GLint numSamples );
-
-extern GLboolean
-_mesa_initialize_visual( struct gl_config *v,
-                         GLboolean dbFlag,
-                         GLboolean stereoFlag,
-                         GLint redBits,
-                         GLint greenBits,
-                         GLint blueBits,
-                         GLint alphaBits,
-                         GLint depthBits,
-                         GLint stencilBits,
-                         GLint accumRedBits,
-                         GLint accumGreenBits,
-                         GLint accumBlueBits,
-                         GLint accumAlphaBits,
-                         GLint numSamples );
-
-extern void
-_mesa_destroy_visual( struct gl_config *vis );
-
-/*@}*/
-
-
-/** \name Context-related functions */
-/*@{*/
-
-extern GLboolean
-_mesa_initialize_context( struct gl_context *ctx,
-                          gl_api api,
-                          const struct gl_config *visual,
-                          struct gl_context *share_list,
-                          const struct dd_function_table *driverFunctions,
-                          void *driverContext );
-
-extern struct gl_context *
-_mesa_create_context(gl_api api,
-                     const struct gl_config *visual,
-                     struct gl_context *share_list,
-                     const struct dd_function_table *driverFunctions,
-                     void *driverContext);
-
-extern void
-_mesa_free_context_data( struct gl_context *ctx );
-
-extern void
-_mesa_destroy_context( struct gl_context *ctx );
-
-
-extern void
-_mesa_copy_context(const struct gl_context *src, struct gl_context *dst, GLuint mask);
-
-
-extern void
-_mesa_check_init_viewport(struct gl_context *ctx, GLuint width, GLuint height);
-
-extern GLboolean
-_mesa_make_current( struct gl_context *ctx, struct gl_framebuffer *drawBuffer,
-                    struct gl_framebuffer *readBuffer );
-
-extern GLboolean
-_mesa_share_state(struct gl_context *ctx, struct gl_context *ctxToShare);
-
-extern struct gl_context *
-_mesa_get_current_context(void);
-
-/*@}*/
-
-extern void
-_mesa_init_get_hash(struct gl_context *ctx);
-
-extern void
-_mesa_notifySwapBuffers(struct gl_context *gc);
-
-
-extern struct _glapi_table *
-_mesa_get_dispatch(struct gl_context *ctx);
-
-
-void
-_mesa_set_mvp_with_dp4( struct gl_context *ctx,
-                        GLboolean flag );
-
-
-extern GLboolean
-_mesa_valid_to_render(struct gl_context *ctx, const char *where);
-
-
-
-/** \name Miscellaneous */
-/*@{*/
-
-extern void
-_mesa_record_error( struct gl_context *ctx, GLenum error );
-
-
-extern void
-_mesa_finish(struct gl_context *ctx);
-
-extern void
-_mesa_flush(struct gl_context *ctx);
-
-
-extern void GLAPIENTRY
-_mesa_Finish( void );
-
-extern void GLAPIENTRY
-_mesa_Flush( void );
-
-/*@}*/
-
-
-/**
- * \name Macros for flushing buffered rendering commands before state changes,
- * checking if inside glBegin/glEnd, etc.
- */
-/*@{*/
-
-/**
- * Flush vertices.
- *
- * \param ctx GL context.
- * \param newstate new state.
- *
- * Checks if dd_function_table::NeedFlush is marked to flush stored vertices,
- * and calls dd_function_table::FlushVertices if so. Marks
- * __struct gl_contextRec::NewState with \p newstate.
- */
-#define FLUSH_VERTICES(ctx, newstate)				\
-do {								\
-   if (MESA_VERBOSE & VERBOSE_STATE)				\
-      _mesa_debug(ctx, "FLUSH_VERTICES in %s\n", MESA_FUNCTION);\
-   if (ctx->Driver.NeedFlush & FLUSH_STORED_VERTICES)		\
-      ctx->Driver.FlushVertices(ctx, FLUSH_STORED_VERTICES);	\
-   ctx->NewState |= newstate;					\
-} while (0)
-
-/**
- * Flush current state.
- *
- * \param ctx GL context.
- * \param newstate new state.
- *
- * Checks if dd_function_table::NeedFlush is marked to flush current state,
- * and calls dd_function_table::FlushVertices if so. Marks
- * __struct gl_contextRec::NewState with \p newstate.
- */
-#define FLUSH_CURRENT(ctx, newstate)				\
-do {								\
-   if (MESA_VERBOSE & VERBOSE_STATE)				\
-      _mesa_debug(ctx, "FLUSH_CURRENT in %s\n", MESA_FUNCTION);	\
-   if (ctx->Driver.NeedFlush & FLUSH_UPDATE_CURRENT)		\
-      ctx->Driver.FlushVertices(ctx, FLUSH_UPDATE_CURRENT);	\
-   ctx->NewState |= newstate;					\
-} while (0)
-
-/**
- * Macro to assert that the API call was made outside the
- * glBegin()/glEnd() pair, with return value.
- * 
- * \param ctx GL context.
- * \param retval value to return value in case the assertion fails.
- */
-#define ASSERT_OUTSIDE_BEGIN_END_WITH_RETVAL(ctx, retval)		\
-do {									\
-   if (ctx->Driver.CurrentExecPrimitive != PRIM_OUTSIDE_BEGIN_END) {	\
-      _mesa_error(ctx, GL_INVALID_OPERATION, "Inside glBegin/glEnd");	\
-      return retval;							\
-   }									\
-} while (0)
-
-/**
- * Macro to assert that the API call was made outside the
- * glBegin()/glEnd() pair.
- * 
- * \param ctx GL context.
- */
-#define ASSERT_OUTSIDE_BEGIN_END(ctx)					\
-do {									\
-   if (ctx->Driver.CurrentExecPrimitive != PRIM_OUTSIDE_BEGIN_END) {	\
-      _mesa_error(ctx, GL_INVALID_OPERATION, "Inside glBegin/glEnd");	\
-      return;								\
-   }									\
-} while (0)
-
-/**
- * Macro to assert that the API call was made outside the
- * glBegin()/glEnd() pair and flush the vertices.
- * 
- * \param ctx GL context.
- */
-#define ASSERT_OUTSIDE_BEGIN_END_AND_FLUSH(ctx)				\
-do {									\
-   ASSERT_OUTSIDE_BEGIN_END(ctx);					\
-   FLUSH_VERTICES(ctx, 0);						\
-} while (0)
-
-/**
- * Macro to assert that the API call was made outside the
- * glBegin()/glEnd() pair and flush the vertices, with return value.
- * 
- * \param ctx GL context.
- * \param retval value to return value in case the assertion fails.
- */
-#define ASSERT_OUTSIDE_BEGIN_END_AND_FLUSH_WITH_RETVAL(ctx, retval)	\
-do {									\
-   ASSERT_OUTSIDE_BEGIN_END_WITH_RETVAL(ctx, retval);			\
-   FLUSH_VERTICES(ctx, 0);						\
-} while (0)
-
-/*@}*/
-
-
-
-/**
- * Is the secondary color needed?
- */
-#define NEED_SECONDARY_COLOR(CTX)					\
-   (((CTX)->Light.Enabled &&						\
-     (CTX)->Light.Model.ColorControl == GL_SEPARATE_SPECULAR_COLOR)	\
-    || (CTX)->Fog.ColorSumEnabled					\
-    || ((CTX)->VertexProgram._Current &&				\
-        ((CTX)->VertexProgram._Current != (CTX)->VertexProgram._TnlProgram) &&    \
-        ((CTX)->VertexProgram._Current->Base.InputsRead & VERT_BIT_COLOR1)) \
-    || ((CTX)->FragmentProgram._Current &&				\
-        ((CTX)->FragmentProgram._Current != (CTX)->FragmentProgram._TexEnvProgram) &&  \
-        ((CTX)->FragmentProgram._Current->Base.InputsRead & FRAG_BIT_COL1)) \
-   )
-
-
-/**
- * Is RGBA LogicOp enabled?
- */
-#define RGBA_LOGICOP_ENABLED(CTX) \
-  ((CTX)->Color.ColorLogicOpEnabled || \
-   ((CTX)->Color.BlendEnabled && (CTX)->Color.Blend[0].EquationRGB == GL_LOGIC_OP))
-
-
-#endif /* CONTEXT_H */
+/*

+ * Mesa 3-D graphics library

+ * Version:  6.5.1

+ *

+ * Copyright (C) 1999-2006  Brian Paul   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 context.h

+ * Mesa context and visual-related functions.

+ *

+ * There are three large Mesa data types/classes which are meant to be

+ * used by device drivers:

+ * - struct gl_context: this contains the Mesa rendering state

+ * - struct gl_config:  this describes the color buffer (RGB vs. ci), whether or not

+ *   there's a depth buffer, stencil buffer, etc.

+ * - struct gl_framebuffer:  contains pointers to the depth buffer, stencil buffer,

+ *   accum buffer and alpha buffers.

+ *

+ * These types should be encapsulated by corresponding device driver

+ * data types.  See xmesa.h and xmesaP.h for an example.

+ *

+ * In OOP terms, struct gl_context, struct gl_config, and struct gl_framebuffer are base classes

+ * which the device driver must derive from.

+ *

+ * The following functions create and destroy these data types.

+ */

+

+

+#ifndef CONTEXT_H

+#define CONTEXT_H

+

+

+#include "imports.h"

+#include "mtypes.h"

+

+

+struct _glapi_table;

+

+

+/** \name Visual-related functions */

+/*@{*/

+ 

+extern struct gl_config *

+_mesa_create_visual( GLboolean dbFlag,

+                     GLboolean stereoFlag,

+                     GLint redBits,

+                     GLint greenBits,

+                     GLint blueBits,

+                     GLint alphaBits,

+                     GLint depthBits,

+                     GLint stencilBits,

+                     GLint accumRedBits,

+                     GLint accumGreenBits,

+                     GLint accumBlueBits,

+                     GLint accumAlphaBits,

+                     GLint numSamples );

+

+extern GLboolean

+_mesa_initialize_visual( struct gl_config *v,

+                         GLboolean dbFlag,

+                         GLboolean stereoFlag,

+                         GLint redBits,

+                         GLint greenBits,

+                         GLint blueBits,

+                         GLint alphaBits,

+                         GLint depthBits,

+                         GLint stencilBits,

+                         GLint accumRedBits,

+                         GLint accumGreenBits,

+                         GLint accumBlueBits,

+                         GLint accumAlphaBits,

+                         GLint numSamples );

+

+extern void

+_mesa_destroy_visual( struct gl_config *vis );

+

+/*@}*/

+

+

+/** \name Context-related functions */

+/*@{*/

+

+extern GLboolean

+_mesa_initialize_context( struct gl_context *ctx,

+                          gl_api api,

+                          const struct gl_config *visual,

+                          struct gl_context *share_list,

+                          const struct dd_function_table *driverFunctions,

+                          void *driverContext );

+

+extern struct gl_context *

+_mesa_create_context(gl_api api,

+                     const struct gl_config *visual,

+                     struct gl_context *share_list,

+                     const struct dd_function_table *driverFunctions,

+                     void *driverContext);

+

+extern void

+_mesa_free_context_data( struct gl_context *ctx );

+

+extern void

+_mesa_destroy_context( struct gl_context *ctx );

+

+

+extern void

+_mesa_copy_context(const struct gl_context *src, struct gl_context *dst, GLuint mask);

+

+

+extern void

+_mesa_check_init_viewport(struct gl_context *ctx, GLuint width, GLuint height);

+

+extern GLboolean

+_mesa_make_current( struct gl_context *ctx, struct gl_framebuffer *drawBuffer,

+                    struct gl_framebuffer *readBuffer );

+

+extern GLboolean

+_mesa_share_state(struct gl_context *ctx, struct gl_context *ctxToShare);

+

+extern struct gl_context *

+_mesa_get_current_context(void);

+

+/*@}*/

+

+extern void

+_mesa_init_get_hash(struct gl_context *ctx);

+

+extern void

+_mesa_notifySwapBuffers(struct gl_context *gc);

+

+

+extern struct _glapi_table *

+_mesa_get_dispatch(struct gl_context *ctx);

+

+

+void

+_mesa_set_mvp_with_dp4( struct gl_context *ctx,

+                        GLboolean flag );

+

+

+extern GLboolean

+_mesa_valid_to_render(struct gl_context *ctx, const char *where);

+

+

+

+/** \name Miscellaneous */

+/*@{*/

+

+extern void

+_mesa_record_error( struct gl_context *ctx, GLenum error );

+

+

+extern void

+_mesa_finish(struct gl_context *ctx);

+

+extern void

+_mesa_flush(struct gl_context *ctx);

+

+

+extern void GLAPIENTRY

+_mesa_Finish( void );

+

+extern void GLAPIENTRY

+_mesa_Flush( void );

+

+/*@}*/

+

+

+/**

+ * \name Macros for flushing buffered rendering commands before state changes,

+ * checking if inside glBegin/glEnd, etc.

+ */

+/*@{*/

+

+/**

+ * Flush vertices.

+ *

+ * \param ctx GL context.

+ * \param newstate new state.

+ *

+ * Checks if dd_function_table::NeedFlush is marked to flush stored vertices,

+ * and calls dd_function_table::FlushVertices if so. Marks

+ * __struct gl_contextRec::NewState with \p newstate.

+ */

+#define FLUSH_VERTICES(ctx, newstate)				\

+do {								\

+   if (MESA_VERBOSE & VERBOSE_STATE)				\

+      _mesa_debug(ctx, "FLUSH_VERTICES in %s\n", MESA_FUNCTION);\

+   if (ctx->Driver.NeedFlush & FLUSH_STORED_VERTICES)		\

+      ctx->Driver.FlushVertices(ctx, FLUSH_STORED_VERTICES);	\

+   ctx->NewState |= newstate;					\

+} while (0)

+

+/**

+ * Flush current state.

+ *

+ * \param ctx GL context.

+ * \param newstate new state.

+ *

+ * Checks if dd_function_table::NeedFlush is marked to flush current state,

+ * and calls dd_function_table::FlushVertices if so. Marks

+ * __struct gl_contextRec::NewState with \p newstate.

+ */

+#define FLUSH_CURRENT(ctx, newstate)				\

+do {								\

+   if (MESA_VERBOSE & VERBOSE_STATE)				\

+      _mesa_debug(ctx, "FLUSH_CURRENT in %s\n", MESA_FUNCTION);	\

+   if (ctx->Driver.NeedFlush & FLUSH_UPDATE_CURRENT)		\

+      ctx->Driver.FlushVertices(ctx, FLUSH_UPDATE_CURRENT);	\

+   ctx->NewState |= newstate;					\

+} while (0)

+

+/**

+ * Macro to assert that the API call was made outside the

+ * glBegin()/glEnd() pair, with return value.

+ * 

+ * \param ctx GL context.

+ * \param retval value to return value in case the assertion fails.

+ */

+#define ASSERT_OUTSIDE_BEGIN_END_WITH_RETVAL(ctx, retval)		\

+do {									\

+   if (ctx->Driver.CurrentExecPrimitive != PRIM_OUTSIDE_BEGIN_END) {	\

+      _mesa_error(ctx, GL_INVALID_OPERATION, "Inside glBegin/glEnd");	\

+      return retval;							\

+   }									\

+} while (0)

+

+/**

+ * Macro to assert that the API call was made outside the

+ * glBegin()/glEnd() pair.

+ * 

+ * \param ctx GL context.

+ */

+#define ASSERT_OUTSIDE_BEGIN_END(ctx)					\

+do {									\

+   if (ctx->Driver.CurrentExecPrimitive != PRIM_OUTSIDE_BEGIN_END) {	\

+      _mesa_error(ctx, GL_INVALID_OPERATION, "Inside glBegin/glEnd");	\

+      return;								\

+   }									\

+} while (0)

+

+/**

+ * Macro to assert that the API call was made outside the

+ * glBegin()/glEnd() pair and flush the vertices.

+ * 

+ * \param ctx GL context.

+ */

+#define ASSERT_OUTSIDE_BEGIN_END_AND_FLUSH(ctx)				\

+do {									\

+   ASSERT_OUTSIDE_BEGIN_END(ctx);					\

+   FLUSH_VERTICES(ctx, 0);						\

+} while (0)

+

+/**

+ * Macro to assert that the API call was made outside the

+ * glBegin()/glEnd() pair and flush the vertices, with return value.

+ * 

+ * \param ctx GL context.

+ * \param retval value to return value in case the assertion fails.

+ */

+#define ASSERT_OUTSIDE_BEGIN_END_AND_FLUSH_WITH_RETVAL(ctx, retval)	\

+do {									\

+   ASSERT_OUTSIDE_BEGIN_END_WITH_RETVAL(ctx, retval);			\

+   FLUSH_VERTICES(ctx, 0);						\

+} while (0)

+

+/*@}*/

+

+

+

+#endif /* CONTEXT_H */

diff --git a/mesalib/src/mesa/main/ff_fragment_shader.cpp b/mesalib/src/mesa/main/ff_fragment_shader.cpp
new file mode 100644
index 000000000..ed513397a
--- /dev/null
+++ b/mesalib/src/mesa/main/ff_fragment_shader.cpp
@@ -0,0 +1,1504 @@
+/**************************************************************************

+ * 

+ * Copyright 2007 Tungsten Graphics, Inc., Cedar Park, Texas.

+ * All Rights Reserved.

+ * Copyright 2009 VMware, Inc.  All Rights Reserved.

+ * Copyright © 2010 Intel Corporation

+ * 

+ * 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, sub license, 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 (including the

+ * next paragraph) 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 NON-INFRINGEMENT.

+ * IN NO EVENT SHALL TUNGSTEN GRAPHICS AND/OR ITS SUPPLIERS 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.

+ * 

+ **************************************************************************/

+

+extern "C" {

+#include "glheader.h"

+#include "imports.h"

+#include "mtypes.h"

+#include "main/uniforms.h"

+#include "main/macros.h"

+#include "program/program.h"

+#include "program/prog_parameter.h"

+#include "program/prog_cache.h"

+#include "program/prog_instruction.h"

+#include "program/prog_print.h"

+#include "program/prog_statevars.h"

+#include "program/programopt.h"

+#include "texenvprogram.h"

+}

+#include "../glsl/glsl_types.h"

+#include "../glsl/ir.h"

+#include "../glsl/glsl_symbol_table.h"

+#include "../glsl/glsl_parser_extras.h"

+#include "../glsl/ir_optimization.h"

+#include "../glsl/ir_print_visitor.h"

+#include "../program/ir_to_mesa.h"

+

+/*

+ * Note on texture units:

+ *

+ * The number of texture units supported by fixed-function fragment

+ * processing is MAX_TEXTURE_COORD_UNITS, not MAX_TEXTURE_IMAGE_UNITS.

+ * That's because there's a one-to-one correspondence between texture

+ * coordinates and samplers in fixed-function processing.

+ *

+ * Since fixed-function vertex processing is limited to MAX_TEXTURE_COORD_UNITS

+ * sets of texcoords, so is fixed-function fragment processing.

+ *

+ * We can safely use ctx->Const.MaxTextureUnits for loop bounds.

+ */

+

+

+struct texenvprog_cache_item

+{

+   GLuint hash;

+   void *key;

+   struct gl_shader_program *data;

+   struct texenvprog_cache_item *next;

+};

+

+static GLboolean

+texenv_doing_secondary_color(struct gl_context *ctx)

+{

+   if (ctx->Light.Enabled &&

+       (ctx->Light.Model.ColorControl == GL_SEPARATE_SPECULAR_COLOR))

+      return GL_TRUE;

+

+   if (ctx->Fog.ColorSumEnabled)

+      return GL_TRUE;

+

+   return GL_FALSE;

+}

+

+struct mode_opt {

+#ifdef __GNUC__

+   __extension__ GLubyte Source:4;  /**< SRC_x */

+   __extension__ GLubyte Operand:3; /**< OPR_x */

+#else

+   GLubyte Source;  /**< SRC_x */

+   GLubyte Operand; /**< OPR_x */

+#endif

+};

+

+struct state_key {

+   GLuint nr_enabled_units:8;

+   GLuint enabled_units:8;

+   GLuint separate_specular:1;

+   GLuint fog_enabled:1;

+   GLuint fog_mode:2;          /**< FOG_x */

+   GLuint inputs_available:12;

+   GLuint num_draw_buffers:4;

+

+   /* NOTE: This array of structs must be last! (see "keySize" below) */

+   struct {

+      GLuint enabled:1;

+      GLuint source_index:3;   /**< TEXTURE_x_INDEX */

+      GLuint shadow:1;

+      GLuint ScaleShiftRGB:2;

+      GLuint ScaleShiftA:2;

+

+      GLuint NumArgsRGB:3;  /**< up to MAX_COMBINER_TERMS */

+      GLuint ModeRGB:5;     /**< MODE_x */

+

+      GLuint NumArgsA:3;  /**< up to MAX_COMBINER_TERMS */

+      GLuint ModeA:5;     /**< MODE_x */

+

+      struct mode_opt OptRGB[MAX_COMBINER_TERMS];

+      struct mode_opt OptA[MAX_COMBINER_TERMS];

+   } unit[MAX_TEXTURE_UNITS];

+};

+

+#define FOG_LINEAR  0

+#define FOG_EXP     1

+#define FOG_EXP2    2

+#define FOG_UNKNOWN 3

+

+static GLuint translate_fog_mode( GLenum mode )

+{

+   switch (mode) {

+   case GL_LINEAR: return FOG_LINEAR;

+   case GL_EXP: return FOG_EXP;

+   case GL_EXP2: return FOG_EXP2;

+   default: return FOG_UNKNOWN;

+   }

+}

+

+#define OPR_SRC_COLOR           0

+#define OPR_ONE_MINUS_SRC_COLOR 1

+#define OPR_SRC_ALPHA           2

+#define OPR_ONE_MINUS_SRC_ALPHA	3

+#define OPR_ZERO                4

+#define OPR_ONE                 5

+#define OPR_UNKNOWN             7

+

+static GLuint translate_operand( GLenum operand )

+{

+   switch (operand) {

+   case GL_SRC_COLOR: return OPR_SRC_COLOR;

+   case GL_ONE_MINUS_SRC_COLOR: return OPR_ONE_MINUS_SRC_COLOR;

+   case GL_SRC_ALPHA: return OPR_SRC_ALPHA;

+   case GL_ONE_MINUS_SRC_ALPHA: return OPR_ONE_MINUS_SRC_ALPHA;

+   case GL_ZERO: return OPR_ZERO;

+   case GL_ONE: return OPR_ONE;

+   default:

+      assert(0);

+      return OPR_UNKNOWN;

+   }

+}

+

+#define SRC_TEXTURE  0

+#define SRC_TEXTURE0 1

+#define SRC_TEXTURE1 2

+#define SRC_TEXTURE2 3

+#define SRC_TEXTURE3 4

+#define SRC_TEXTURE4 5

+#define SRC_TEXTURE5 6

+#define SRC_TEXTURE6 7

+#define SRC_TEXTURE7 8

+#define SRC_CONSTANT 9

+#define SRC_PRIMARY_COLOR 10

+#define SRC_PREVIOUS 11

+#define SRC_ZERO     12

+#define SRC_UNKNOWN  15

+

+static GLuint translate_source( GLenum src )

+{

+   switch (src) {

+   case GL_TEXTURE: return SRC_TEXTURE;

+   case GL_TEXTURE0:

+   case GL_TEXTURE1:

+   case GL_TEXTURE2:

+   case GL_TEXTURE3:

+   case GL_TEXTURE4:

+   case GL_TEXTURE5:

+   case GL_TEXTURE6:

+   case GL_TEXTURE7: return SRC_TEXTURE0 + (src - GL_TEXTURE0);

+   case GL_CONSTANT: return SRC_CONSTANT;

+   case GL_PRIMARY_COLOR: return SRC_PRIMARY_COLOR;

+   case GL_PREVIOUS: return SRC_PREVIOUS;

+   case GL_ZERO:

+      return SRC_ZERO;

+   default:

+      assert(0);

+      return SRC_UNKNOWN;

+   }

+}

+

+#define MODE_REPLACE                     0  /* r = a0 */

+#define MODE_MODULATE                    1  /* r = a0 * a1 */

+#define MODE_ADD                         2  /* r = a0 + a1 */

+#define MODE_ADD_SIGNED                  3  /* r = a0 + a1 - 0.5 */

+#define MODE_INTERPOLATE                 4  /* r = a0 * a2 + a1 * (1 - a2) */

+#define MODE_SUBTRACT                    5  /* r = a0 - a1 */

+#define MODE_DOT3_RGB                    6  /* r = a0 . a1 */

+#define MODE_DOT3_RGB_EXT                7  /* r = a0 . a1 */

+#define MODE_DOT3_RGBA                   8  /* r = a0 . a1 */

+#define MODE_DOT3_RGBA_EXT               9  /* r = a0 . a1 */

+#define MODE_MODULATE_ADD_ATI           10  /* r = a0 * a2 + a1 */

+#define MODE_MODULATE_SIGNED_ADD_ATI    11  /* r = a0 * a2 + a1 - 0.5 */

+#define MODE_MODULATE_SUBTRACT_ATI      12  /* r = a0 * a2 - a1 */

+#define MODE_ADD_PRODUCTS               13  /* r = a0 * a1 + a2 * a3 */

+#define MODE_ADD_PRODUCTS_SIGNED        14  /* r = a0 * a1 + a2 * a3 - 0.5 */

+#define MODE_BUMP_ENVMAP_ATI            15  /* special */

+#define MODE_UNKNOWN                    16

+

+/**

+ * Translate GL combiner state into a MODE_x value

+ */

+static GLuint translate_mode( GLenum envMode, GLenum mode )

+{

+   switch (mode) {

+   case GL_REPLACE: return MODE_REPLACE;

+   case GL_MODULATE: return MODE_MODULATE;

+   case GL_ADD:

+      if (envMode == GL_COMBINE4_NV)

+         return MODE_ADD_PRODUCTS;

+      else

+         return MODE_ADD;

+   case GL_ADD_SIGNED:

+      if (envMode == GL_COMBINE4_NV)

+         return MODE_ADD_PRODUCTS_SIGNED;

+      else

+         return MODE_ADD_SIGNED;

+   case GL_INTERPOLATE: return MODE_INTERPOLATE;

+   case GL_SUBTRACT: return MODE_SUBTRACT;

+   case GL_DOT3_RGB: return MODE_DOT3_RGB;

+   case GL_DOT3_RGB_EXT: return MODE_DOT3_RGB_EXT;

+   case GL_DOT3_RGBA: return MODE_DOT3_RGBA;

+   case GL_DOT3_RGBA_EXT: return MODE_DOT3_RGBA_EXT;

+   case GL_MODULATE_ADD_ATI: return MODE_MODULATE_ADD_ATI;

+   case GL_MODULATE_SIGNED_ADD_ATI: return MODE_MODULATE_SIGNED_ADD_ATI;

+   case GL_MODULATE_SUBTRACT_ATI: return MODE_MODULATE_SUBTRACT_ATI;

+   case GL_BUMP_ENVMAP_ATI: return MODE_BUMP_ENVMAP_ATI;

+   default:

+      assert(0);

+      return MODE_UNKNOWN;

+   }

+}

+

+

+/**

+ * Do we need to clamp the results of the given texture env/combine mode?

+ * If the inputs to the mode are in [0,1] we don't always have to clamp

+ * the results.

+ */

+static GLboolean

+need_saturate( GLuint mode )

+{

+   switch (mode) {

+   case MODE_REPLACE:

+   case MODE_MODULATE:

+   case MODE_INTERPOLATE:

+      return GL_FALSE;

+   case MODE_ADD:

+   case MODE_ADD_SIGNED:

+   case MODE_SUBTRACT:

+   case MODE_DOT3_RGB:

+   case MODE_DOT3_RGB_EXT:

+   case MODE_DOT3_RGBA:

+   case MODE_DOT3_RGBA_EXT:

+   case MODE_MODULATE_ADD_ATI:

+   case MODE_MODULATE_SIGNED_ADD_ATI:

+   case MODE_MODULATE_SUBTRACT_ATI:

+   case MODE_ADD_PRODUCTS:

+   case MODE_ADD_PRODUCTS_SIGNED:

+   case MODE_BUMP_ENVMAP_ATI:

+      return GL_TRUE;

+   default:

+      assert(0);

+      return GL_FALSE;

+   }

+}

+

+

+

+/**

+ * Translate TEXTURE_x_BIT to TEXTURE_x_INDEX.

+ */

+static GLuint translate_tex_src_bit( GLbitfield bit )

+{

+   ASSERT(bit);

+   return _mesa_ffs(bit) - 1;

+}

+

+

+#define VERT_BIT_TEX_ANY    (0xff << VERT_ATTRIB_TEX0)

+#define VERT_RESULT_TEX_ANY (0xff << VERT_RESULT_TEX0)

+

+/**

+ * Identify all possible varying inputs.  The fragment program will

+ * never reference non-varying inputs, but will track them via state

+ * constants instead.

+ *

+ * This function figures out all the inputs that the fragment program

+ * has access to.  The bitmask is later reduced to just those which

+ * are actually referenced.

+ */

+static GLbitfield get_fp_input_mask( struct gl_context *ctx )

+{

+   /* _NEW_PROGRAM */

+   const GLboolean vertexShader =

+      (ctx->Shader.CurrentVertexProgram &&

+       ctx->Shader.CurrentVertexProgram->LinkStatus &&

+       ctx->Shader.CurrentVertexProgram->VertexProgram);

+   const GLboolean vertexProgram = ctx->VertexProgram._Enabled;

+   GLbitfield fp_inputs = 0x0;

+

+   if (ctx->VertexProgram._Overriden) {

+      /* Somebody's messing with the vertex program and we don't have

+       * a clue what's happening.  Assume that it could be producing

+       * all possible outputs.

+       */

+      fp_inputs = ~0;

+   }

+   else if (ctx->RenderMode == GL_FEEDBACK) {

+      /* _NEW_RENDERMODE */

+      fp_inputs = (FRAG_BIT_COL0 | FRAG_BIT_TEX0);

+   }

+   else if (!(vertexProgram || vertexShader) ||

+            !ctx->VertexProgram._Current) {

+      /* Fixed function vertex logic */

+      /* _NEW_ARRAY */

+      GLbitfield varying_inputs = ctx->varying_vp_inputs;

+

+      /* These get generated in the setup routine regardless of the

+       * vertex program:

+       */

+      /* _NEW_POINT */

+      if (ctx->Point.PointSprite)

+         varying_inputs |= FRAG_BITS_TEX_ANY;

+

+      /* First look at what values may be computed by the generated

+       * vertex program:

+       */

+      /* _NEW_LIGHT */

+      if (ctx->Light.Enabled) {

+         fp_inputs |= FRAG_BIT_COL0;

+

+         if (texenv_doing_secondary_color(ctx))

+            fp_inputs |= FRAG_BIT_COL1;

+      }

+

+      /* _NEW_TEXTURE */

+      fp_inputs |= (ctx->Texture._TexGenEnabled |

+                    ctx->Texture._TexMatEnabled) << FRAG_ATTRIB_TEX0;

+

+      /* Then look at what might be varying as a result of enabled

+       * arrays, etc:

+       */

+      if (varying_inputs & VERT_BIT_COLOR0)

+         fp_inputs |= FRAG_BIT_COL0;

+      if (varying_inputs & VERT_BIT_COLOR1)

+         fp_inputs |= FRAG_BIT_COL1;

+

+      fp_inputs |= (((varying_inputs & VERT_BIT_TEX_ANY) >> VERT_ATTRIB_TEX0) 

+                    << FRAG_ATTRIB_TEX0);

+

+   }

+   else {

+      /* calculate from vp->outputs */

+      struct gl_vertex_program *vprog;

+      GLbitfield64 vp_outputs;

+

+      /* Choose GLSL vertex shader over ARB vertex program.  Need this

+       * since vertex shader state validation comes after fragment state

+       * validation (see additional comments in state.c).

+       */

+      if (vertexShader)

+         vprog = ctx->Shader.CurrentVertexProgram->VertexProgram;

+      else

+         vprog = ctx->VertexProgram.Current;

+

+      vp_outputs = vprog->Base.OutputsWritten;

+

+      /* These get generated in the setup routine regardless of the

+       * vertex program:

+       */

+      /* _NEW_POINT */

+      if (ctx->Point.PointSprite)

+         vp_outputs |= FRAG_BITS_TEX_ANY;

+

+      if (vp_outputs & (1 << VERT_RESULT_COL0))

+         fp_inputs |= FRAG_BIT_COL0;

+      if (vp_outputs & (1 << VERT_RESULT_COL1))

+         fp_inputs |= FRAG_BIT_COL1;

+

+      fp_inputs |= (((vp_outputs & VERT_RESULT_TEX_ANY) >> VERT_RESULT_TEX0) 

+                    << FRAG_ATTRIB_TEX0);

+   }

+   

+   return fp_inputs;

+}

+

+

+/**

+ * Examine current texture environment state and generate a unique

+ * key to identify it.

+ */

+static GLuint make_state_key( struct gl_context *ctx,  struct state_key *key )

+{

+   GLuint i, j;

+   GLbitfield inputs_referenced = FRAG_BIT_COL0;

+   const GLbitfield inputs_available = get_fp_input_mask( ctx );

+   GLuint keySize;

+

+   memset(key, 0, sizeof(*key));

+

+   /* _NEW_TEXTURE */

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

+      const struct gl_texture_unit *texUnit = &ctx->Texture.Unit[i];

+      const struct gl_texture_object *texObj = texUnit->_Current;

+      const struct gl_tex_env_combine_state *comb = texUnit->_CurrentCombine;

+      GLenum format;

+

+      if (!texUnit->_ReallyEnabled || !texUnit->Enabled)

+         continue;

+

+      format = texObj->Image[0][texObj->BaseLevel]->_BaseFormat;

+

+      key->unit[i].enabled = 1;

+      key->enabled_units |= (1<<i);

+      key->nr_enabled_units = i + 1;

+      inputs_referenced |= FRAG_BIT_TEX(i);

+

+      key->unit[i].source_index =

+         translate_tex_src_bit(texUnit->_ReallyEnabled);

+

+      key->unit[i].shadow = ((texObj->CompareMode == GL_COMPARE_R_TO_TEXTURE) &&

+                             ((format == GL_DEPTH_COMPONENT) || 

+                              (format == GL_DEPTH_STENCIL_EXT)));

+

+      key->unit[i].NumArgsRGB = comb->_NumArgsRGB;

+      key->unit[i].NumArgsA = comb->_NumArgsA;

+

+      key->unit[i].ModeRGB =

+	 translate_mode(texUnit->EnvMode, comb->ModeRGB);

+      key->unit[i].ModeA =

+	 translate_mode(texUnit->EnvMode, comb->ModeA);

+

+      key->unit[i].ScaleShiftRGB = comb->ScaleShiftRGB;

+      key->unit[i].ScaleShiftA = comb->ScaleShiftA;

+

+      for (j = 0; j < MAX_COMBINER_TERMS; j++) {

+         key->unit[i].OptRGB[j].Operand = translate_operand(comb->OperandRGB[j]);

+         key->unit[i].OptA[j].Operand = translate_operand(comb->OperandA[j]);

+         key->unit[i].OptRGB[j].Source = translate_source(comb->SourceRGB[j]);

+         key->unit[i].OptA[j].Source = translate_source(comb->SourceA[j]);

+      }

+

+      if (key->unit[i].ModeRGB == MODE_BUMP_ENVMAP_ATI) {

+         /* requires some special translation */

+         key->unit[i].NumArgsRGB = 2;

+         key->unit[i].ScaleShiftRGB = 0;

+         key->unit[i].OptRGB[0].Operand = OPR_SRC_COLOR;

+         key->unit[i].OptRGB[0].Source = SRC_TEXTURE;

+         key->unit[i].OptRGB[1].Operand = OPR_SRC_COLOR;

+         key->unit[i].OptRGB[1].Source = texUnit->BumpTarget - GL_TEXTURE0 + SRC_TEXTURE0;

+       }

+   }

+

+   /* _NEW_LIGHT | _NEW_FOG */

+   if (texenv_doing_secondary_color(ctx)) {

+      key->separate_specular = 1;

+      inputs_referenced |= FRAG_BIT_COL1;

+   }

+

+   /* _NEW_FOG */

+   if (ctx->Fog.Enabled) {

+      key->fog_enabled = 1;

+      key->fog_mode = translate_fog_mode(ctx->Fog.Mode);

+      inputs_referenced |= FRAG_BIT_FOGC; /* maybe */

+   }

+

+   /* _NEW_BUFFERS */

+   key->num_draw_buffers = ctx->DrawBuffer->_NumColorDrawBuffers;

+

+   key->inputs_available = (inputs_available & inputs_referenced);

+

+   /* compute size of state key, ignoring unused texture units */

+   keySize = sizeof(*key) - sizeof(key->unit)

+      + key->nr_enabled_units * sizeof(key->unit[0]);

+

+   return keySize;

+}

+

+

+/** State used to build the fragment program:

+ */

+struct texenv_fragment_program {

+   struct gl_shader_program *shader_program;

+   struct gl_shader *shader;

+   struct gl_fragment_program *program;

+   exec_list *instructions;

+   exec_list *top_instructions;

+   void *mem_ctx;

+   struct state_key *state;

+

+   GLbitfield alu_temps;	/**< Track texture indirections, see spec. */

+   GLbitfield temps_output;	/**< Track texture indirections, see spec. */

+   GLbitfield temp_in_use;	/**< Tracks temporary regs which are in use. */

+   GLboolean error;

+

+   ir_variable *src_texture[MAX_TEXTURE_COORD_UNITS];

+   /* Reg containing each texture unit's sampled texture color,

+    * else undef.

+    */

+

+   /* Texcoord override from bumpmapping. */

+   struct ir_variable *texcoord_tex[MAX_TEXTURE_COORD_UNITS];

+

+   /* Reg containing texcoord for a texture unit,

+    * needed for bump mapping, else undef.

+    */

+

+   ir_rvalue *src_previous;	/**< Reg containing color from previous

+				 * stage.  May need to be decl'd.

+				 */

+

+   GLuint last_tex_stage;	/**< Number of last enabled texture unit */

+};

+

+static ir_rvalue *

+get_source(struct texenv_fragment_program *p,

+	   GLuint src, GLuint unit)

+{

+   ir_variable *var;

+   ir_dereference *deref;

+

+   switch (src) {

+   case SRC_TEXTURE: 

+      return new(p->mem_ctx) ir_dereference_variable(p->src_texture[unit]);

+

+   case SRC_TEXTURE0:

+   case SRC_TEXTURE1:

+   case SRC_TEXTURE2:

+   case SRC_TEXTURE3:

+   case SRC_TEXTURE4:

+   case SRC_TEXTURE5:

+   case SRC_TEXTURE6:

+   case SRC_TEXTURE7: 

+      return new(p->mem_ctx)

+	 ir_dereference_variable(p->src_texture[src - SRC_TEXTURE0]);

+

+   case SRC_CONSTANT:

+      var = p->shader->symbols->get_variable("gl_TextureEnvColor");

+      assert(var);

+      deref = new(p->mem_ctx) ir_dereference_variable(var);

+      var->max_array_access = MAX2(var->max_array_access, unit);

+      return new(p->mem_ctx) ir_dereference_array(deref,

+						  new(p->mem_ctx) ir_constant(unit));

+

+   case SRC_PRIMARY_COLOR:

+      var = p->shader->symbols->get_variable("gl_Color");

+      assert(var);

+      return new(p->mem_ctx) ir_dereference_variable(var);

+

+   case SRC_ZERO:

+      return new(p->mem_ctx) ir_constant(0.0f);

+

+   case SRC_PREVIOUS:

+      if (!p->src_previous) {

+	 var = p->shader->symbols->get_variable("gl_Color");

+	 assert(var);

+	 return new(p->mem_ctx) ir_dereference_variable(var);

+      } else {

+	 return p->src_previous->clone(p->mem_ctx, NULL);

+      }

+

+   default:

+      assert(0);

+      return NULL;

+   }

+}

+

+static ir_rvalue *

+emit_combine_source(struct texenv_fragment_program *p,

+		    GLuint unit,

+		    GLuint source,

+		    GLuint operand)

+{

+   ir_rvalue *src;

+

+   src = get_source(p, source, unit);

+

+   switch (operand) {

+   case OPR_ONE_MINUS_SRC_COLOR: 

+      return new(p->mem_ctx) ir_expression(ir_binop_sub,

+					   new(p->mem_ctx) ir_constant(1.0f),

+					   src);

+

+   case OPR_SRC_ALPHA: 

+      return new(p->mem_ctx) ir_swizzle(src, 3, 3, 3, 3, 1);

+

+   case OPR_ONE_MINUS_SRC_ALPHA: 

+      return new(p->mem_ctx) ir_expression(ir_binop_sub,

+					   new(p->mem_ctx) ir_constant(1.0f),

+					   new(p->mem_ctx) ir_swizzle(src,

+								      3, 3,

+								      3, 3, 1));

+   case OPR_ZERO:

+      return new(p->mem_ctx) ir_constant(0.0f);

+   case OPR_ONE:

+      return new(p->mem_ctx) ir_constant(1.0f);

+   case OPR_SRC_COLOR: 

+      return src;

+   default:

+      assert(0);

+      return src;

+   }

+}

+

+/**

+ * Check if the RGB and Alpha sources and operands match for the given

+ * texture unit's combinder state.  When the RGB and A sources and

+ * operands match, we can emit fewer instructions.

+ */

+static GLboolean args_match( const struct state_key *key, GLuint unit )

+{

+   GLuint i, numArgs = key->unit[unit].NumArgsRGB;

+

+   for (i = 0; i < numArgs; i++) {

+      if (key->unit[unit].OptA[i].Source != key->unit[unit].OptRGB[i].Source) 

+	 return GL_FALSE;

+

+      switch (key->unit[unit].OptA[i].Operand) {

+      case OPR_SRC_ALPHA: 

+	 switch (key->unit[unit].OptRGB[i].Operand) {

+	 case OPR_SRC_COLOR: 

+	 case OPR_SRC_ALPHA: 

+	    break;

+	 default:

+	    return GL_FALSE;

+	 }

+	 break;

+      case OPR_ONE_MINUS_SRC_ALPHA: 

+	 switch (key->unit[unit].OptRGB[i].Operand) {

+	 case OPR_ONE_MINUS_SRC_COLOR: 

+	 case OPR_ONE_MINUS_SRC_ALPHA: 

+	    break;

+	 default:

+	    return GL_FALSE;

+	 }

+	 break;

+      default: 

+	 return GL_FALSE;	/* impossible */

+      }

+   }

+

+   return GL_TRUE;

+}

+

+static ir_rvalue *

+smear(struct texenv_fragment_program *p, ir_rvalue *val)

+{

+   if (!val->type->is_scalar())

+      return val;

+

+   return new(p->mem_ctx) ir_swizzle(val, 0, 0, 0, 0, 4);

+}

+

+static ir_rvalue *

+emit_combine(struct texenv_fragment_program *p,

+	     GLuint unit,

+	     GLuint nr,

+	     GLuint mode,

+	     const struct mode_opt *opt)

+{

+   ir_rvalue *src[MAX_COMBINER_TERMS];

+   ir_rvalue *tmp0, *tmp1;

+   GLuint i;

+

+   assert(nr <= MAX_COMBINER_TERMS);

+

+   for (i = 0; i < nr; i++)

+      src[i] = emit_combine_source( p, unit, opt[i].Source, opt[i].Operand );

+

+   switch (mode) {

+   case MODE_REPLACE: 

+      return src[0];

+

+   case MODE_MODULATE: 

+      return new(p->mem_ctx) ir_expression(ir_binop_mul, src[0], src[1]);

+

+   case MODE_ADD: 

+      return new(p->mem_ctx) ir_expression(ir_binop_add, src[0], src[1]);

+

+   case MODE_ADD_SIGNED:

+      tmp0 = new(p->mem_ctx) ir_expression(ir_binop_add, src[0], src[1]);

+      return new(p->mem_ctx) ir_expression(ir_binop_add, tmp0,

+					   new(p->mem_ctx) ir_constant(-0.5f));

+

+   case MODE_INTERPOLATE: 

+      /* Arg0 * (Arg2) + Arg1 * (1-Arg2) */

+      tmp0 = new(p->mem_ctx) ir_expression(ir_binop_mul, src[0], src[2]);

+

+      tmp1 = new(p->mem_ctx) ir_expression(ir_binop_sub,

+					   new(p->mem_ctx) ir_constant(1.0f),

+					   src[2]->clone(p->mem_ctx, NULL));

+      tmp1 = new(p->mem_ctx) ir_expression(ir_binop_mul, src[1], tmp1);

+

+      return new(p->mem_ctx) ir_expression(ir_binop_add, tmp0, tmp1);

+

+   case MODE_SUBTRACT: 

+      return new(p->mem_ctx) ir_expression(ir_binop_sub, src[0], src[1]);

+

+   case MODE_DOT3_RGBA:

+   case MODE_DOT3_RGBA_EXT: 

+   case MODE_DOT3_RGB_EXT:

+   case MODE_DOT3_RGB: {

+      tmp0 = new(p->mem_ctx) ir_expression(ir_binop_mul, src[0],

+					   new(p->mem_ctx) ir_constant(2.0f));

+      tmp0 = new(p->mem_ctx) ir_expression(ir_binop_add, tmp0,

+					   new(p->mem_ctx) ir_constant(-1.0f));

+      tmp0 = new(p->mem_ctx) ir_swizzle(smear(p, tmp0), 0, 1, 2, 3, 3);

+

+      tmp1 = new(p->mem_ctx) ir_expression(ir_binop_mul, src[1],

+					   new(p->mem_ctx) ir_constant(2.0f));

+      tmp1 = new(p->mem_ctx) ir_expression(ir_binop_add, tmp1,

+					   new(p->mem_ctx) ir_constant(-1.0f));

+      tmp1 = new(p->mem_ctx) ir_swizzle(smear(p, tmp1), 0, 1, 2, 3, 3);

+

+      return new(p->mem_ctx) ir_expression(ir_binop_dot, tmp0, tmp1);

+   }

+   case MODE_MODULATE_ADD_ATI:

+      tmp0 = new(p->mem_ctx) ir_expression(ir_binop_mul, src[0], src[2]);

+      return new(p->mem_ctx) ir_expression(ir_binop_add, tmp0, src[1]);

+

+   case MODE_MODULATE_SIGNED_ADD_ATI:

+      tmp0 = new(p->mem_ctx) ir_expression(ir_binop_mul, src[0], src[2]);

+      tmp0 = new(p->mem_ctx) ir_expression(ir_binop_add, tmp0, src[1]);

+      return new(p->mem_ctx) ir_expression(ir_binop_add, tmp0,

+					   new(p->mem_ctx) ir_constant(-0.5f));

+

+   case MODE_MODULATE_SUBTRACT_ATI:

+      tmp0 = new(p->mem_ctx) ir_expression(ir_binop_mul, src[0], src[2]);

+      return new(p->mem_ctx) ir_expression(ir_binop_sub, tmp0, src[1]);

+

+   case MODE_ADD_PRODUCTS:

+      tmp0 = new(p->mem_ctx) ir_expression(ir_binop_mul, src[0], src[1]);

+      tmp1 = new(p->mem_ctx) ir_expression(ir_binop_mul, src[2], src[3]);

+      return new(p->mem_ctx) ir_expression(ir_binop_add, tmp0, tmp1);

+

+   case MODE_ADD_PRODUCTS_SIGNED:

+      tmp0 = new(p->mem_ctx) ir_expression(ir_binop_mul, src[0], src[1]);

+      tmp1 = new(p->mem_ctx) ir_expression(ir_binop_mul, src[2], src[3]);

+      tmp0 = new(p->mem_ctx) ir_expression(ir_binop_add, tmp0, tmp1);

+      return new(p->mem_ctx) ir_expression(ir_binop_add, tmp0,

+					   new(p->mem_ctx) ir_constant(-0.5f));

+

+   case MODE_BUMP_ENVMAP_ATI:

+      /* special - not handled here */

+      assert(0);

+      return src[0];

+   default: 

+      assert(0);

+      return src[0];

+   }

+}

+

+static ir_rvalue *

+saturate(struct texenv_fragment_program *p, ir_rvalue *val)

+{

+   val = new(p->mem_ctx) ir_expression(ir_binop_min, val,

+				       new(p->mem_ctx) ir_constant(1.0f));

+   return new(p->mem_ctx) ir_expression(ir_binop_max, val,

+					new(p->mem_ctx) ir_constant(0.0f));

+}

+

+/**

+ * Generate instructions for one texture unit's env/combiner mode.

+ */

+static ir_rvalue *

+emit_texenv(struct texenv_fragment_program *p, GLuint unit)

+{

+   const struct state_key *key = p->state;

+   GLboolean rgb_saturate, alpha_saturate;

+   GLuint rgb_shift, alpha_shift;

+

+   if (!key->unit[unit].enabled) {

+      return get_source(p, SRC_PREVIOUS, 0);

+   }

+   if (key->unit[unit].ModeRGB == MODE_BUMP_ENVMAP_ATI) {

+      /* this isn't really a env stage delivering a color and handled elsewhere */

+      return get_source(p, SRC_PREVIOUS, 0);

+   }

+   

+   switch (key->unit[unit].ModeRGB) {

+   case MODE_DOT3_RGB_EXT:

+      alpha_shift = key->unit[unit].ScaleShiftA;

+      rgb_shift = 0;

+      break;

+   case MODE_DOT3_RGBA_EXT:

+      alpha_shift = 0;

+      rgb_shift = 0;

+      break;

+   default:

+      rgb_shift = key->unit[unit].ScaleShiftRGB;

+      alpha_shift = key->unit[unit].ScaleShiftA;

+      break;

+   }

+   

+   /* If we'll do rgb/alpha shifting don't saturate in emit_combine().

+    * We don't want to clamp twice.

+    */

+   if (rgb_shift)

+      rgb_saturate = GL_FALSE;  /* saturate after rgb shift */

+   else if (need_saturate(key->unit[unit].ModeRGB))

+      rgb_saturate = GL_TRUE;

+   else

+      rgb_saturate = GL_FALSE;

+

+   if (alpha_shift)

+      alpha_saturate = GL_FALSE;  /* saturate after alpha shift */

+   else if (need_saturate(key->unit[unit].ModeA))

+      alpha_saturate = GL_TRUE;

+   else

+      alpha_saturate = GL_FALSE;

+

+   ir_variable *temp_var = new(p->mem_ctx) ir_variable(glsl_type::vec4_type,

+						       "texenv_combine",

+						       ir_var_temporary);

+   p->instructions->push_tail(temp_var);

+

+   ir_dereference *deref;

+   ir_assignment *assign;

+   ir_rvalue *val;

+

+   /* Emit the RGB and A combine ops

+    */

+   if (key->unit[unit].ModeRGB == key->unit[unit].ModeA &&

+       args_match(key, unit)) {

+      val = emit_combine(p, unit,

+			 key->unit[unit].NumArgsRGB,

+			 key->unit[unit].ModeRGB,

+			 key->unit[unit].OptRGB);

+      val = smear(p, val);

+      if (rgb_saturate)

+	 val = saturate(p, val);

+

+      deref = new(p->mem_ctx) ir_dereference_variable(temp_var);

+      assign = new(p->mem_ctx) ir_assignment(deref, val, NULL);

+      p->instructions->push_tail(assign);

+   }

+   else if (key->unit[unit].ModeRGB == MODE_DOT3_RGBA_EXT ||

+	    key->unit[unit].ModeRGB == MODE_DOT3_RGBA) {

+      ir_rvalue *val = emit_combine(p, unit,

+				    key->unit[unit].NumArgsRGB,

+				    key->unit[unit].ModeRGB,

+				    key->unit[unit].OptRGB);

+      val = smear(p, val);

+      if (rgb_saturate)

+	 val = saturate(p, val);

+      deref = new(p->mem_ctx) ir_dereference_variable(temp_var);

+      assign = new(p->mem_ctx) ir_assignment(deref, val, NULL);

+      p->instructions->push_tail(assign);

+   }

+   else {

+      /* Need to do something to stop from re-emitting identical

+       * argument calculations here:

+       */

+      val = emit_combine(p, unit,

+			 key->unit[unit].NumArgsRGB,

+			 key->unit[unit].ModeRGB,

+			 key->unit[unit].OptRGB);

+      val = smear(p, val);

+      val = new(p->mem_ctx) ir_swizzle(val, 0, 1, 2, 3, 3);

+      if (rgb_saturate)

+	 val = saturate(p, val);

+      deref = new(p->mem_ctx) ir_dereference_variable(temp_var);

+      assign = new(p->mem_ctx) ir_assignment(deref, val, NULL, WRITEMASK_XYZ);

+      p->instructions->push_tail(assign);

+

+      val = emit_combine(p, unit,

+			 key->unit[unit].NumArgsA,

+			 key->unit[unit].ModeA,

+			 key->unit[unit].OptA);

+      val = smear(p, val);

+      val = new(p->mem_ctx) ir_swizzle(val, 3, 3, 3, 3, 1);

+      if (alpha_saturate)

+	 val = saturate(p, val);

+      deref = new(p->mem_ctx) ir_dereference_variable(temp_var);

+      assign = new(p->mem_ctx) ir_assignment(deref, val, NULL, WRITEMASK_W);

+      p->instructions->push_tail(assign);

+   }

+

+   deref = new(p->mem_ctx) ir_dereference_variable(temp_var);

+

+   /* Deal with the final shift:

+    */

+   if (alpha_shift || rgb_shift) {

+      ir_constant *shift;

+

+      if (rgb_shift == alpha_shift) {

+	 shift = new(p->mem_ctx) ir_constant((float)(1 << rgb_shift));

+      }

+      else {

+	 float const_data[4] = {

+	    1 << rgb_shift,

+	    1 << rgb_shift,

+	    1 << rgb_shift,

+	    1 << alpha_shift

+	 };

+	 shift = new(p->mem_ctx) ir_constant(glsl_type::vec4_type,

+					     (ir_constant_data *)const_data);

+      }

+

+      return saturate(p, new(p->mem_ctx) ir_expression(ir_binop_mul,

+						       deref, shift));

+   }

+   else

+      return deref;

+}

+

+

+/**

+ * Generate instruction for getting a texture source term.

+ */

+ static void load_texture( struct texenv_fragment_program *p, GLuint unit )

+ {

+    ir_dereference *deref;

+    ir_assignment *assign;

+

+    if (p->src_texture[unit])

+       return;

+

+    const GLuint texTarget = p->state->unit[unit].source_index;

+    ir_rvalue *texcoord;

+

+    if (p->texcoord_tex[unit]) {

+       texcoord = new(p->mem_ctx) ir_dereference_variable(p->texcoord_tex[unit]);

+    }

+    else {

+       ir_variable *tc_array = p->shader->symbols->get_variable("gl_TexCoord");

+       assert(tc_array);

+       texcoord = new(p->mem_ctx) ir_dereference_variable(tc_array);

+       ir_rvalue *index = new(p->mem_ctx) ir_constant(unit);

+       texcoord = new(p->mem_ctx) ir_dereference_array(texcoord, index);

+       tc_array->max_array_access = MAX2(tc_array->max_array_access, unit);

+    }

+

+    if (!p->state->unit[unit].enabled) {

+       p->src_texture[unit] = new(p->mem_ctx) ir_variable(glsl_type::vec4_type,

+							  "dummy_tex",

+							  ir_var_temporary);

+       p->instructions->push_tail(p->src_texture[unit]);

+

+       deref = new(p->mem_ctx) ir_dereference_variable(p->src_texture[unit]);

+       assign = new(p->mem_ctx) ir_assignment(deref,

+					      new(p->mem_ctx) ir_constant(0.0f),

+					      NULL);

+       p->instructions->push_tail(assign);

+       return ;

+    }

+

+    const glsl_type *sampler_type = NULL;

+    int coords = 0;

+

+    switch (texTarget) {

+    case TEXTURE_1D_INDEX:

+       if (p->state->unit[unit].shadow)

+	  sampler_type = p->shader->symbols->get_type("sampler1DShadow");

+       else

+	  sampler_type = p->shader->symbols->get_type("sampler1D");

+       coords = 1;

+       break;

+    case TEXTURE_1D_ARRAY_INDEX:

+       if (p->state->unit[unit].shadow)

+	  sampler_type = p->shader->symbols->get_type("sampler1DArrayShadow");

+       else

+	  sampler_type = p->shader->symbols->get_type("sampler1DArray");

+       coords = 2;

+       break;

+    case TEXTURE_2D_INDEX:

+       if (p->state->unit[unit].shadow)

+	  sampler_type = p->shader->symbols->get_type("sampler2DShadow");

+       else

+	  sampler_type = p->shader->symbols->get_type("sampler2D");

+       coords = 2;

+       break;

+    case TEXTURE_2D_ARRAY_INDEX:

+       if (p->state->unit[unit].shadow)

+	  sampler_type = p->shader->symbols->get_type("sampler2DArrayShadow");

+       else

+	  sampler_type = p->shader->symbols->get_type("sampler2DArray");

+       coords = 3;

+       break;

+    case TEXTURE_RECT_INDEX:

+       if (p->state->unit[unit].shadow)

+	  sampler_type = p->shader->symbols->get_type("sampler2DRectShadow");

+       else

+	  sampler_type = p->shader->symbols->get_type("sampler2DRect");

+       coords = 2;

+       break;

+    case TEXTURE_3D_INDEX:

+       assert(!p->state->unit[unit].shadow);

+       sampler_type = p->shader->symbols->get_type("sampler3D");

+       coords = 3;

+       break;

+    case TEXTURE_CUBE_INDEX:

+       if (p->state->unit[unit].shadow)

+	  sampler_type = p->shader->symbols->get_type("samplerCubeShadow");

+       else

+	  sampler_type = p->shader->symbols->get_type("samplerCube");

+       coords = 3;

+       break;

+    }

+

+    p->src_texture[unit] = new(p->mem_ctx) ir_variable(glsl_type::vec4_type,

+						       "tex",

+						       ir_var_temporary);

+    p->instructions->push_tail(p->src_texture[unit]);

+

+    ir_texture *tex = new(p->mem_ctx) ir_texture(ir_tex);

+

+

+    char *sampler_name = ralloc_asprintf(p->mem_ctx, "sampler_%d", unit);

+    ir_variable *sampler = new(p->mem_ctx) ir_variable(sampler_type,

+						       sampler_name,

+						       ir_var_uniform);

+    p->top_instructions->push_head(sampler);

+    deref = new(p->mem_ctx) ir_dereference_variable(sampler);

+    tex->set_sampler(deref);

+

+    tex->coordinate = new(p->mem_ctx) ir_swizzle(texcoord, 0, 1, 2, 3, coords);

+

+    if (p->state->unit[unit].shadow) {

+       texcoord = texcoord->clone(p->mem_ctx, NULL);

+       tex->shadow_comparitor = new(p->mem_ctx) ir_swizzle(texcoord,

+							   coords, 0, 0, 0,

+							   1);

+       coords++;

+    }

+

+    texcoord = texcoord->clone(p->mem_ctx, NULL);

+    tex->projector = new(p->mem_ctx) ir_swizzle(texcoord, 3, 0, 0, 0, 1);

+

+    deref = new(p->mem_ctx) ir_dereference_variable(p->src_texture[unit]);

+    assign = new(p->mem_ctx) ir_assignment(deref, tex, NULL);

+    p->instructions->push_tail(assign);

+ }

+

+static void

+load_texenv_source(struct texenv_fragment_program *p,

+		   GLuint src, GLuint unit)

+{

+   switch (src) {

+   case SRC_TEXTURE:

+      load_texture(p, unit);

+      break;

+

+   case SRC_TEXTURE0:

+   case SRC_TEXTURE1:

+   case SRC_TEXTURE2:

+   case SRC_TEXTURE3:

+   case SRC_TEXTURE4:

+   case SRC_TEXTURE5:

+   case SRC_TEXTURE6:

+   case SRC_TEXTURE7:       

+      load_texture(p, src - SRC_TEXTURE0);

+      break;

+      

+   default:

+      /* not a texture src - do nothing */

+      break;

+   }

+}

+

+

+/**

+ * Generate instructions for loading all texture source terms.

+ */

+static GLboolean

+load_texunit_sources( struct texenv_fragment_program *p, GLuint unit )

+{

+   const struct state_key *key = p->state;

+   GLuint i;

+

+   for (i = 0; i < key->unit[unit].NumArgsRGB; i++) {

+      load_texenv_source( p, key->unit[unit].OptRGB[i].Source, unit );

+   }

+

+   for (i = 0; i < key->unit[unit].NumArgsA; i++) {

+      load_texenv_source( p, key->unit[unit].OptA[i].Source, unit );

+   }

+

+   return GL_TRUE;

+}

+

+/**

+ * Generate instructions for loading bump map textures.

+ */

+static void

+load_texunit_bumpmap( struct texenv_fragment_program *p, GLuint unit )

+{

+   const struct state_key *key = p->state;

+   GLuint bumpedUnitNr = key->unit[unit].OptRGB[1].Source - SRC_TEXTURE0;

+   ir_rvalue *bump;

+   ir_rvalue *texcoord;

+   ir_variable *rot_mat_0_var, *rot_mat_1_var;

+   ir_dereference_variable *rot_mat_0, *rot_mat_1;

+

+   rot_mat_0_var = p->shader->symbols->get_variable("gl_MESABumpRotMatrix0");

+   rot_mat_1_var = p->shader->symbols->get_variable("gl_MESABumpRotMatrix1");

+   rot_mat_0 = new(p->mem_ctx) ir_dereference_variable(rot_mat_0_var);

+   rot_mat_1 = new(p->mem_ctx) ir_dereference_variable(rot_mat_1_var);

+

+   ir_variable *tc_array = p->shader->symbols->get_variable("gl_TexCoord");

+   assert(tc_array);

+   texcoord = new(p->mem_ctx) ir_dereference_variable(tc_array);

+   ir_rvalue *index = new(p->mem_ctx) ir_constant(bumpedUnitNr);

+   texcoord = new(p->mem_ctx) ir_dereference_array(texcoord, index);

+   tc_array->max_array_access = MAX2(tc_array->max_array_access, unit);

+

+   load_texenv_source( p, unit + SRC_TEXTURE0, unit );

+

+   /* Apply rot matrix and add coords to be available in next phase.

+    * dest = Arg1 + (Arg0.xx * rotMat0) + (Arg0.yy * rotMat1)

+    * note only 2 coords are affected the rest are left unchanged (mul by 0)

+    */

+   ir_dereference *deref;

+   ir_assignment *assign;

+   ir_rvalue *bump_x, *bump_y;

+

+   texcoord = smear(p, texcoord);

+

+   /* bump_texcoord = texcoord */

+   ir_variable *bumped = new(p->mem_ctx) ir_variable(texcoord->type,

+						     "bump_texcoord",

+						     ir_var_temporary);

+   p->instructions->push_tail(bumped);

+

+   deref = new(p->mem_ctx) ir_dereference_variable(bumped);

+   assign = new(p->mem_ctx) ir_assignment(deref, texcoord, NULL);

+   p->instructions->push_tail(assign);

+

+   /* bump_texcoord.xy += arg0.x * rotmat0 + arg0.y * rotmat1 */

+   bump = get_source(p, key->unit[unit].OptRGB[0].Source, unit);

+   bump_x = new(p->mem_ctx) ir_swizzle(bump, 0, 0, 0, 0, 1);

+   bump = bump->clone(p->mem_ctx, NULL);

+   bump_y = new(p->mem_ctx) ir_swizzle(bump, 1, 0, 0, 0, 1);

+

+   bump_x = new(p->mem_ctx) ir_expression(ir_binop_mul, bump_x, rot_mat_0);

+   bump_y = new(p->mem_ctx) ir_expression(ir_binop_mul, bump_y, rot_mat_1);

+

+   ir_expression *expr;

+   expr = new(p->mem_ctx) ir_expression(ir_binop_add, bump_x, bump_y);

+

+   deref = new(p->mem_ctx) ir_dereference_variable(bumped);

+   expr = new(p->mem_ctx) ir_expression(ir_binop_add,

+					new(p->mem_ctx) ir_swizzle(deref,

+								   0, 1, 1, 1,

+								   2),

+					expr);

+

+   deref = new(p->mem_ctx) ir_dereference_variable(bumped);

+   assign = new(p->mem_ctx) ir_assignment(deref, expr, NULL, WRITEMASK_XY);

+   p->instructions->push_tail(assign);

+

+   p->texcoord_tex[bumpedUnitNr] = bumped;

+}

+

+/**

+ * Applies the fog calculations.

+ *

+ * This is basically like the ARB_fragment_prorgam fog options.  Note

+ * that ffvertex_prog.c produces fogcoord for us when

+ * GL_FOG_COORDINATE_EXT is set to GL_FRAGMENT_DEPTH_EXT.

+ */

+static ir_rvalue *

+emit_fog_instructions(struct texenv_fragment_program *p,

+		      ir_rvalue *fragcolor)

+{

+   struct state_key *key = p->state;

+   ir_rvalue *f, *temp;

+   ir_variable *params, *oparams;

+   ir_variable *fogcoord;

+   ir_assignment *assign;

+

+   /* Temporary storage for the whole fog result.  Fog calculations

+    * only affect rgb so we're hanging on to the .a value of fragcolor

+    * this way.

+    */

+   ir_variable *fog_result = new(p->mem_ctx) ir_variable(glsl_type::vec4_type,

+							 "fog_result",

+							 ir_var_auto);

+   p->instructions->push_tail(fog_result);

+   temp = new(p->mem_ctx) ir_dereference_variable(fog_result);

+   assign = new(p->mem_ctx) ir_assignment(temp, fragcolor, NULL);

+   p->instructions->push_tail(assign);

+

+   temp = new(p->mem_ctx) ir_dereference_variable(fog_result);

+   fragcolor = new(p->mem_ctx) ir_swizzle(temp, 0, 1, 2, 3, 3);

+

+   oparams = p->shader->symbols->get_variable("gl_MESAFogParamsOptimized");

+   fogcoord = p->shader->symbols->get_variable("gl_FogFragCoord");

+   params = p->shader->symbols->get_variable("gl_Fog");

+   f = new(p->mem_ctx) ir_dereference_variable(fogcoord);

+

+   ir_variable *f_var = new(p->mem_ctx) ir_variable(glsl_type::float_type,

+						    "fog_factor", ir_var_auto);

+   p->instructions->push_tail(f_var);

+

+   switch (key->fog_mode) {

+   case FOG_LINEAR:

+      /* f = (end - z) / (end - start)

+       *

+       * gl_MesaFogParamsOptimized gives us (-1 / (end - start)) and

+       * (end / (end - start)) so we can generate a single MAD.

+       */

+      temp = new(p->mem_ctx) ir_dereference_variable(oparams);

+      temp = new(p->mem_ctx) ir_swizzle(temp, 0, 0, 0, 0, 1);

+      f = new(p->mem_ctx) ir_expression(ir_binop_mul, f, temp);

+

+      temp = new(p->mem_ctx) ir_dereference_variable(oparams);

+      temp = new(p->mem_ctx) ir_swizzle(temp, 1, 0, 0, 0, 1);

+      f = new(p->mem_ctx) ir_expression(ir_binop_add, f, temp);

+      break;

+   case FOG_EXP:

+      /* f = e^(-(density * fogcoord))

+       *

+       * gl_MesaFogParamsOptimized gives us density/ln(2) so we can

+       * use EXP2 which is generally the native instruction without

+       * having to do any further math on the fog density uniform.

+       */

+      temp = new(p->mem_ctx) ir_dereference_variable(oparams);

+      temp = new(p->mem_ctx) ir_swizzle(temp, 2, 0, 0, 0, 1);

+      f = new(p->mem_ctx) ir_expression(ir_binop_mul, f, temp);

+      f = new(p->mem_ctx) ir_expression(ir_unop_neg, f);

+      f = new(p->mem_ctx) ir_expression(ir_unop_exp2, f);

+      break;

+   case FOG_EXP2:

+      /* f = e^(-(density * fogcoord)^2)

+       *

+       * gl_MesaFogParamsOptimized gives us density/sqrt(ln(2)) so we

+       * can do this like FOG_EXP but with a squaring after the

+       * multiply by density.

+       */

+      ir_variable *temp_var = new(p->mem_ctx) ir_variable(glsl_type::float_type,

+							  "fog_temp",

+							  ir_var_auto);

+      p->instructions->push_tail(temp_var);

+

+      temp = new(p->mem_ctx) ir_dereference_variable(oparams);

+      temp = new(p->mem_ctx) ir_swizzle(temp, 3, 0, 0, 0, 1);

+      f = new(p->mem_ctx) ir_expression(ir_binop_mul,

+					f, temp);

+

+      temp = new(p->mem_ctx) ir_dereference_variable(temp_var);

+      ir_assignment *assign = new(p->mem_ctx) ir_assignment(temp, f, NULL);

+      p->instructions->push_tail(assign);

+

+      f = new(p->mem_ctx) ir_dereference_variable(temp_var);

+      temp = new(p->mem_ctx) ir_dereference_variable(temp_var);

+      f = new(p->mem_ctx) ir_expression(ir_binop_mul, f, temp);

+      f = new(p->mem_ctx) ir_expression(ir_unop_neg, f);

+      f = new(p->mem_ctx) ir_expression(ir_unop_exp2, f);

+      break;

+   }

+

+   f = saturate(p, f);

+

+   temp = new(p->mem_ctx) ir_dereference_variable(f_var);

+   assign = new(p->mem_ctx) ir_assignment(temp, f, NULL);

+   p->instructions->push_tail(assign);

+

+   f = new(p->mem_ctx) ir_dereference_variable(f_var);

+   f = new(p->mem_ctx) ir_expression(ir_binop_sub,

+				     new(p->mem_ctx) ir_constant(1.0f),

+				     f);

+   temp = new(p->mem_ctx) ir_dereference_variable(params);

+   temp = new(p->mem_ctx) ir_dereference_record(temp, "color");

+   temp = new(p->mem_ctx) ir_swizzle(temp, 0, 1, 2, 3, 3);

+   temp = new(p->mem_ctx) ir_expression(ir_binop_mul, temp, f);

+

+   f = new(p->mem_ctx) ir_dereference_variable(f_var);

+   f = new(p->mem_ctx) ir_expression(ir_binop_mul, fragcolor, f);

+   f = new(p->mem_ctx) ir_expression(ir_binop_add, temp, f);

+

+   ir_dereference *deref = new(p->mem_ctx) ir_dereference_variable(fog_result);

+   assign = new(p->mem_ctx) ir_assignment(deref, f, NULL, WRITEMASK_XYZ);

+   p->instructions->push_tail(assign);

+

+   return new(p->mem_ctx) ir_dereference_variable(fog_result);

+}

+

+static void

+emit_instructions(struct texenv_fragment_program *p)

+{

+   struct state_key *key = p->state;

+   GLuint unit;

+

+   if (key->enabled_units) {

+      /* Zeroth pass - bump map textures first */

+      for (unit = 0; unit < key->nr_enabled_units; unit++) {

+	 if (key->unit[unit].enabled &&

+             key->unit[unit].ModeRGB == MODE_BUMP_ENVMAP_ATI) {

+	    load_texunit_bumpmap(p, unit);

+	 }

+      }

+

+      /* First pass - to support texture_env_crossbar, first identify

+       * all referenced texture sources and emit texld instructions

+       * for each:

+       */

+      for (unit = 0; unit < key->nr_enabled_units; unit++)

+	 if (key->unit[unit].enabled) {

+	    load_texunit_sources(p, unit);

+	    p->last_tex_stage = unit;

+	 }

+

+      /* Second pass - emit combine instructions to build final color:

+       */

+      for (unit = 0; unit < key->nr_enabled_units; unit++) {

+	 if (key->unit[unit].enabled) {

+	    p->src_previous = emit_texenv(p, unit);

+	 }

+      }

+   }

+

+   ir_rvalue *cf = get_source(p, SRC_PREVIOUS, 0);

+   ir_dereference_variable *deref;

+   ir_assignment *assign;

+

+   if (key->separate_specular) {

+      ir_rvalue *tmp0, *tmp1;

+      ir_variable *spec_result = new(p->mem_ctx) ir_variable(glsl_type::vec4_type,

+							    "specular_add",

+							    ir_var_temporary);

+

+      p->instructions->push_tail(spec_result);

+

+      deref = new(p->mem_ctx) ir_dereference_variable(spec_result);

+      assign = new(p->mem_ctx) ir_assignment(deref, cf, NULL);

+      p->instructions->push_tail(assign);

+

+      deref = new(p->mem_ctx) ir_dereference_variable(spec_result);

+      tmp0 = new(p->mem_ctx) ir_swizzle(deref, 0, 1, 2, 3, 3);

+

+      ir_variable *secondary =

+	 p->shader->symbols->get_variable("gl_SecondaryColor");

+      assert(secondary);

+      deref = new(p->mem_ctx) ir_dereference_variable(secondary);

+      tmp1 = new(p->mem_ctx) ir_swizzle(deref, 0, 1, 2, 3, 3);

+

+      tmp0 = new(p->mem_ctx) ir_expression(ir_binop_add,

+					  tmp0, tmp1);

+

+      deref = new(p->mem_ctx) ir_dereference_variable(spec_result);

+      assign = new(p->mem_ctx) ir_assignment(deref, tmp0, NULL, WRITEMASK_XYZ);

+      p->instructions->push_tail(assign);

+

+      cf = new(p->mem_ctx) ir_dereference_variable(spec_result);

+   }

+

+   if (key->fog_enabled) {

+      cf = emit_fog_instructions(p, cf);

+   }

+

+   ir_variable *frag_color = p->shader->symbols->get_variable("gl_FragColor");

+   assert(frag_color);

+   deref = new(p->mem_ctx) ir_dereference_variable(frag_color);

+   assign = new(p->mem_ctx) ir_assignment(deref, cf, NULL);

+   p->instructions->push_tail(assign);

+}

+

+/**

+ * Generate a new fragment program which implements the context's

+ * current texture env/combine mode.

+ */

+static struct gl_shader_program *

+create_new_program(struct gl_context *ctx, struct state_key *key)

+{

+   struct texenv_fragment_program p;

+   unsigned int unit;

+   _mesa_glsl_parse_state *state;

+

+   memset(&p, 0, sizeof(p));

+   p.mem_ctx = ralloc_context(NULL);

+   p.shader = ctx->Driver.NewShader(ctx, 0, GL_FRAGMENT_SHADER);

+   p.shader->ir = new(p.shader) exec_list;

+   state = new(p.shader) _mesa_glsl_parse_state(ctx, GL_FRAGMENT_SHADER,

+						p.shader);

+   p.shader->symbols = state->symbols;

+   p.top_instructions = p.shader->ir;

+   p.instructions = p.shader->ir;

+   p.state = key;

+   p.shader_program = ctx->Driver.NewShaderProgram(ctx, 0);

+

+   state->language_version = 120;

+   _mesa_glsl_initialize_types(state);

+   _mesa_glsl_initialize_variables(p.instructions, state);

+

+   for (unit = 0; unit < ctx->Const.MaxTextureUnits; unit++) {

+      p.src_texture[unit] = NULL;

+      p.texcoord_tex[unit] = NULL;

+   }

+

+   p.src_previous = NULL;

+

+   p.last_tex_stage = 0;

+

+   ir_function *main_f = new(p.mem_ctx) ir_function("main");

+   p.instructions->push_tail(main_f);

+   state->symbols->add_function(main_f);

+

+   ir_function_signature *main_sig =

+      new(p.mem_ctx) ir_function_signature(p.shader->symbols->get_type("void"));

+   main_sig->is_defined = true;

+   main_f->add_signature(main_sig);

+

+   p.instructions = &main_sig->body;

+   if (key->num_draw_buffers)

+      emit_instructions(&p);

+

+   validate_ir_tree(p.shader->ir);

+

+   while (do_common_optimization(p.shader->ir, false, 32))

+      ;

+   reparent_ir(p.shader->ir, p.shader->ir);

+

+   p.shader->CompileStatus = true;

+   p.shader->Version = state->language_version;

+   p.shader->num_builtins_to_link = state->num_builtins_to_link;

+   p.shader_program->Shaders =

+      (gl_shader **)malloc(sizeof(*p.shader_program->Shaders));

+   p.shader_program->Shaders[0] = p.shader;

+   p.shader_program->NumShaders = 1;

+

+   _mesa_glsl_link_shader(ctx, p.shader_program);

+

+   /* Set the sampler uniforms, and relink to get them into the linked

+    * program.

+    */

+   struct gl_fragment_program *fp = p.shader_program->FragmentProgram;

+   for (unsigned int i = 0; i < MAX_TEXTURE_UNITS; i++) {

+      char *name = ralloc_asprintf(p.mem_ctx, "sampler_%d", i);

+      int loc = _mesa_get_uniform_location(ctx, p.shader_program, name);

+      if (loc != -1) {

+	 /* Avoid using _mesa_uniform() because it flags state

+	  * updates, so if we're generating this shader_program in a

+	  * state update, we end up recursing.  Instead, just set the

+	  * value, which is picked up at re-link.

+	  */

+	 loc = (loc & 0xffff) + (loc >> 16);

+	 int sampler = fp->Base.Parameters->ParameterValues[loc][0];

+	 fp->Base.SamplerUnits[sampler] = i;

+      }

+   }

+   _mesa_update_shader_textures_used(&fp->Base);

+   (void) ctx->Driver.ProgramStringNotify(ctx, fp->Base.Target, &fp->Base);

+

+   if (!p.shader_program->LinkStatus)

+      _mesa_problem(ctx, "Failed to link fixed function fragment shader: %s\n",

+		    p.shader_program->InfoLog);

+

+   ralloc_free(p.mem_ctx);

+   return p.shader_program;

+}

+

+extern "C" {

+

+/**

+ * Return a fragment program which implements the current

+ * fixed-function texture, fog and color-sum operations.

+ */

+struct gl_shader_program *

+_mesa_get_fixed_func_fragment_program(struct gl_context *ctx)

+{

+   struct gl_shader_program *shader_program;

+   struct state_key key;

+   GLuint keySize;

+

+   keySize = make_state_key(ctx, &key);

+

+   shader_program = (struct gl_shader_program *)

+      _mesa_search_program_cache(ctx->FragmentProgram.Cache,

+                                 &key, keySize);

+

+   if (!shader_program) {

+      shader_program = create_new_program(ctx, &key);

+

+      _mesa_shader_cache_insert(ctx, ctx->FragmentProgram.Cache,

+				&key, keySize, shader_program);

+   }

+

+   return shader_program;

+}

+

+}

diff --git a/mesalib/src/mesa/main/get.c b/mesalib/src/mesa/main/get.c
index 336304c59..a3cae1cbc 100644
--- a/mesalib/src/mesa/main/get.c
+++ b/mesalib/src/mesa/main/get.c
@@ -1,2527 +1,2527 @@
-/*
- * Copyright (C) 2010  Brian Paul   All Rights Reserved.
- * Copyright (C) 2010  Intel Corporation
- *
- * 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.
- *
- * Author: Kristian Høgsberg <krh@bitplanet.net>
- */
-
-#include "glheader.h"
-#include "context.h"
-#include "enable.h"
-#include "enums.h"
-#include "extensions.h"
-#include "get.h"
-#include "macros.h"
-#include "mfeatures.h"
-#include "mtypes.h"
-#include "state.h"
-#include "texcompress.h"
-#include "framebuffer.h"
-
-/* This is a table driven implemetation of the glGet*v() functions.
- * The basic idea is that most getters just look up an int somewhere
- * in struct gl_context and then convert it to a bool or float according to
- * which of glGetIntegerv() glGetBooleanv() etc is being called.
- * Instead of generating code to do this, we can just record the enum
- * value and the offset into struct gl_context in an array of structs.  Then
- * in glGet*(), we lookup the struct for the enum in question, and use
- * the offset to get the int we need.
- *
- * Sometimes we need to look up a float, a boolean, a bit in a
- * bitfield, a matrix or other types instead, so we need to track the
- * type of the value in struct gl_context.  And sometimes the value isn't in
- * struct gl_context but in the drawbuffer, the array object, current texture
- * unit, or maybe it's a computed value.  So we need to also track
- * where or how to find the value.  Finally, we sometimes need to
- * check that one of a number of extensions are enabled, the GL
- * version or flush or call _mesa_update_state().  This is done by
- * attaching optional extra information to the value description
- * struct, it's sort of like an array of opcodes that describe extra
- * checks or actions.
- *
- * Putting all this together we end up with struct value_desc below,
- * and with a couple of macros to help, the table of struct value_desc
- * is about as concise as the specification in the old python script.
- */
-
-#undef CONST
-
-#define FLOAT_TO_BOOLEAN(X)   ( (X) ? GL_TRUE : GL_FALSE )
-#define FLOAT_TO_FIXED(F)     ( ((F) * 65536.0f > INT_MAX) ? INT_MAX : \
-                                ((F) * 65536.0f < INT_MIN) ? INT_MIN : \
-                                (GLint) ((F) * 65536.0f) )
-
-#define INT_TO_BOOLEAN(I)     ( (I) ? GL_TRUE : GL_FALSE )
-#define INT_TO_FIXED(I)       ( ((I) > SHRT_MAX) ? INT_MAX : \
-                                ((I) < SHRT_MIN) ? INT_MIN : \
-                                (GLint) ((I) * 65536) )
-
-#define INT64_TO_BOOLEAN(I)   ( (I) ? GL_TRUE : GL_FALSE )
-#define INT64_TO_INT(I)       ( (GLint)((I > INT_MAX) ? INT_MAX : ((I < INT_MIN) ? INT_MIN : (I))) )
-
-#define BOOLEAN_TO_INT(B)     ( (GLint) (B) )
-#define BOOLEAN_TO_INT64(B)   ( (GLint64) (B) )
-#define BOOLEAN_TO_FLOAT(B)   ( (B) ? 1.0F : 0.0F )
-#define BOOLEAN_TO_FIXED(B)   ( (GLint) ((B) ? 1 : 0) << 16 )
-
-#define ENUM_TO_INT64(E)      ( (GLint64) (E) )
-#define ENUM_TO_FIXED(E)      (E)
-
-enum value_type {
-   TYPE_INVALID,
-   TYPE_API_MASK,
-   TYPE_INT,
-   TYPE_INT_2,
-   TYPE_INT_3,
-   TYPE_INT_4,
-   TYPE_INT_N,
-   TYPE_INT64,
-   TYPE_ENUM,
-   TYPE_ENUM_2,
-   TYPE_BOOLEAN,
-   TYPE_BIT_0,
-   TYPE_BIT_1,
-   TYPE_BIT_2,
-   TYPE_BIT_3,
-   TYPE_BIT_4,
-   TYPE_BIT_5,
-   TYPE_FLOAT,
-   TYPE_FLOAT_2,
-   TYPE_FLOAT_3,
-   TYPE_FLOAT_4,
-   TYPE_FLOATN,
-   TYPE_FLOATN_2,
-   TYPE_FLOATN_3,
-   TYPE_FLOATN_4,
-   TYPE_DOUBLEN,
-   TYPE_MATRIX,
-   TYPE_MATRIX_T,
-   TYPE_CONST
-};
-
-enum value_location {
-   LOC_BUFFER,
-   LOC_CONTEXT,
-   LOC_ARRAY,
-   LOC_TEXUNIT,
-   LOC_CUSTOM
-};
-
-enum value_extra {
-   EXTRA_END = 0x8000,
-   EXTRA_VERSION_30,
-   EXTRA_VERSION_31,
-   EXTRA_VERSION_32,
-   EXTRA_VERSION_ES2,
-   EXTRA_NEW_BUFFERS, 
-   EXTRA_VALID_DRAW_BUFFER,
-   EXTRA_VALID_TEXTURE_UNIT,
-   EXTRA_FLUSH_CURRENT,
-};
-
-#define NO_EXTRA NULL
-#define NO_OFFSET 0
-
-struct value_desc {
-   GLenum pname;
-   GLubyte location;  /**< enum value_location */
-   GLubyte type;      /**< enum value_type */
-   int offset;
-   const int *extra;
-};
-
-union value {
-   GLfloat value_float;
-   GLfloat value_float_4[4];
-   GLmatrix *value_matrix;
-   GLint value_int;
-   GLint value_int_4[4];
-   GLint64 value_int64;
-   GLenum value_enum;
-
-   /* Sigh, see GL_COMPRESSED_TEXTURE_FORMATS_ARB handling */
-   struct {
-      GLint n, ints[100];
-   } value_int_n;
-   GLboolean value_bool;
-};
-
-#define BUFFER_FIELD(field, type) \
-   LOC_BUFFER, type, offsetof(struct gl_framebuffer, field)
-#define CONTEXT_FIELD(field, type) \
-   LOC_CONTEXT, type, offsetof(struct gl_context, field)
-#define ARRAY_FIELD(field, type) \
-   LOC_ARRAY, type, offsetof(struct gl_array_object, field)
-#define CONST(value) \
-   LOC_CONTEXT, TYPE_CONST, value
-
-#define BUFFER_INT(field) BUFFER_FIELD(field, TYPE_INT)
-#define BUFFER_ENUM(field) BUFFER_FIELD(field, TYPE_ENUM)
-#define BUFFER_BOOL(field) BUFFER_FIELD(field, TYPE_BOOLEAN)
-
-#define CONTEXT_INT(field) CONTEXT_FIELD(field, TYPE_INT)
-#define CONTEXT_INT2(field) CONTEXT_FIELD(field, TYPE_INT_2)
-#define CONTEXT_INT64(field) CONTEXT_FIELD(field, TYPE_INT64)
-#define CONTEXT_ENUM(field) CONTEXT_FIELD(field, TYPE_ENUM)
-#define CONTEXT_ENUM2(field) CONTEXT_FIELD(field, TYPE_ENUM_2)
-#define CONTEXT_BOOL(field) CONTEXT_FIELD(field, TYPE_BOOLEAN)
-#define CONTEXT_BIT0(field) CONTEXT_FIELD(field, TYPE_BIT_0)
-#define CONTEXT_BIT1(field) CONTEXT_FIELD(field, TYPE_BIT_1)
-#define CONTEXT_BIT2(field) CONTEXT_FIELD(field, TYPE_BIT_2)
-#define CONTEXT_BIT3(field) CONTEXT_FIELD(field, TYPE_BIT_3)
-#define CONTEXT_BIT4(field) CONTEXT_FIELD(field, TYPE_BIT_4)
-#define CONTEXT_BIT5(field) CONTEXT_FIELD(field, TYPE_BIT_5)
-#define CONTEXT_FLOAT(field) CONTEXT_FIELD(field, TYPE_FLOAT)
-#define CONTEXT_FLOAT2(field) CONTEXT_FIELD(field, TYPE_FLOAT_2)
-#define CONTEXT_FLOAT3(field) CONTEXT_FIELD(field, TYPE_FLOAT_3)
-#define CONTEXT_FLOAT4(field) CONTEXT_FIELD(field, TYPE_FLOAT_4)
-#define CONTEXT_MATRIX(field) CONTEXT_FIELD(field, TYPE_MATRIX)
-#define CONTEXT_MATRIX_T(field) CONTEXT_FIELD(field, TYPE_MATRIX_T)
-
-#define ARRAY_INT(field) ARRAY_FIELD(field, TYPE_INT)
-#define ARRAY_ENUM(field) ARRAY_FIELD(field, TYPE_ENUM)
-#define ARRAY_BOOL(field) ARRAY_FIELD(field, TYPE_BOOLEAN)
-
-#define EXT(f)					\
-   offsetof(struct gl_extensions, f)
-
-#define EXTRA_EXT(e)				\
-   static const int extra_##e[] = {		\
-      EXT(e), EXTRA_END				\
-   }
-
-#define EXTRA_EXT2(e1, e2)			\
-   static const int extra_##e1##_##e2[] = {	\
-      EXT(e1), EXT(e2), EXTRA_END		\
-   }
-
-/* The 'extra' mechanism is a way to specify extra checks (such as
- * extensions or specific gl versions) or actions (flush current, new
- * buffers) that we need to do before looking up an enum.  We need to
- * declare them all up front so we can refer to them in the value_desc
- * structs below. */
-
-static const int extra_new_buffers[] = {
-   EXTRA_NEW_BUFFERS,
-   EXTRA_END
-};
-
-static const int extra_valid_draw_buffer[] = {
-   EXTRA_VALID_DRAW_BUFFER,
-   EXTRA_END
-};
-
-static const int extra_valid_texture_unit[] = {
-   EXTRA_VALID_TEXTURE_UNIT,
-   EXTRA_END
-};
-
-static const int extra_flush_current_valid_texture_unit[] = {
-   EXTRA_FLUSH_CURRENT,
-   EXTRA_VALID_TEXTURE_UNIT,
-   EXTRA_END
-};
-
-static const int extra_flush_current[] = {
-   EXTRA_FLUSH_CURRENT,
-   EXTRA_END
-};
-
-static const int extra_new_buffers_OES_read_format[] = {
-   EXTRA_NEW_BUFFERS,
-   EXT(OES_read_format),
-   EXTRA_END
-};
-
-static const int extra_EXT_secondary_color_flush_current[] = {
-   EXT(EXT_secondary_color),
-   EXTRA_FLUSH_CURRENT,
-   EXTRA_END
-};
-
-static const int extra_EXT_fog_coord_flush_current[] = {
-   EXT(EXT_fog_coord),
-   EXTRA_FLUSH_CURRENT,
-   EXTRA_END
-};
-
-static const int extra_EXT_texture_integer[] = {
-   EXT(EXT_texture_integer),
-   EXTRA_END
-};
-
-static const int extra_EXT_gpu_shader4[] = {
-   EXT(EXT_gpu_shader4),
-   EXTRA_END
-};
-
-
-EXTRA_EXT(ARB_ES2_compatibility);
-EXTRA_EXT(ARB_multitexture);
-EXTRA_EXT(ARB_texture_cube_map);
-EXTRA_EXT(MESA_texture_array);
-EXTRA_EXT2(EXT_secondary_color, ARB_vertex_program);
-EXTRA_EXT(EXT_secondary_color);
-EXTRA_EXT(EXT_fog_coord);
-EXTRA_EXT(EXT_texture_lod_bias);
-EXTRA_EXT(EXT_texture_filter_anisotropic);
-EXTRA_EXT(IBM_rasterpos_clip);
-EXTRA_EXT(NV_point_sprite);
-EXTRA_EXT(SGIS_generate_mipmap);
-EXTRA_EXT(NV_vertex_program);
-EXTRA_EXT(NV_fragment_program);
-EXTRA_EXT(NV_texture_rectangle);
-EXTRA_EXT(EXT_stencil_two_side);
-EXTRA_EXT(NV_light_max_exponent);
-EXTRA_EXT(EXT_depth_bounds_test);
-EXTRA_EXT(ARB_depth_clamp);
-EXTRA_EXT(ATI_fragment_shader);
-EXTRA_EXT(EXT_framebuffer_blit);
-EXTRA_EXT(ARB_shader_objects);
-EXTRA_EXT(EXT_provoking_vertex);
-EXTRA_EXT(ARB_fragment_shader);
-EXTRA_EXT(ARB_fragment_program);
-EXTRA_EXT2(ARB_framebuffer_object, EXT_framebuffer_multisample);
-EXTRA_EXT(EXT_framebuffer_object);
-EXTRA_EXT(APPLE_vertex_array_object);
-EXTRA_EXT(ARB_seamless_cube_map);
-EXTRA_EXT(EXT_compiled_vertex_array);
-EXTRA_EXT(ARB_sync);
-EXTRA_EXT(ARB_vertex_shader);
-EXTRA_EXT(EXT_transform_feedback);
-EXTRA_EXT(ARB_transform_feedback2);
-EXTRA_EXT(EXT_pixel_buffer_object);
-EXTRA_EXT(ARB_vertex_program);
-EXTRA_EXT2(NV_point_sprite, ARB_point_sprite);
-EXTRA_EXT2(ARB_fragment_program, NV_fragment_program);
-EXTRA_EXT2(ARB_vertex_program, NV_vertex_program);
-EXTRA_EXT2(ARB_vertex_program, ARB_fragment_program);
-EXTRA_EXT(ARB_vertex_buffer_object);
-EXTRA_EXT(ARB_geometry_shader4);
-EXTRA_EXT(ARB_copy_buffer);
-EXTRA_EXT(EXT_framebuffer_sRGB);
-
-static const int
-extra_ARB_vertex_program_ARB_fragment_program_NV_vertex_program[] = {
-   EXT(ARB_vertex_program),
-   EXT(ARB_fragment_program),
-   EXT(NV_vertex_program),
-   EXTRA_END
-};
-
-static const int
-extra_NV_vertex_program_ARB_vertex_program_ARB_fragment_program_NV_vertex_program[] = {
-   EXT(NV_vertex_program),
-   EXT(ARB_vertex_program),
-   EXT(ARB_fragment_program),
-   EXT(NV_vertex_program),
-   EXTRA_END
-};
-
-static const int
-extra_NV_primitive_restart[] = {
-   EXT(NV_primitive_restart),
-   EXTRA_END
-};
-
-static const int extra_version_30[] = { EXTRA_VERSION_30, EXTRA_END };
-static const int extra_version_31[] = { EXTRA_VERSION_31, EXTRA_END };
-static const int extra_version_32[] = { EXTRA_VERSION_32, EXTRA_END };
-
-static const int
-extra_ARB_vertex_program_version_es2[] = {
-   EXT(ARB_vertex_program),
-   EXTRA_VERSION_ES2,
-   EXTRA_END
-};
-
-#define API_OPENGL_BIT (1 << API_OPENGL)
-#define API_OPENGLES_BIT (1 << API_OPENGLES)
-#define API_OPENGLES2_BIT (1 << API_OPENGLES2)
-
-/* This is the big table describing all the enums we accept in
- * glGet*v().  The table is partitioned into six parts: enums
- * understood by all GL APIs (OpenGL, GLES and GLES2), enums shared
- * between OpenGL and GLES, enums exclusive to GLES, etc for the
- * remaining combinations.  When we add the enums to the hash table in
- * _mesa_init_get_hash(), we only add the enums for the API we're
- * instantiating and the different sections are guarded by #if
- * FEATURE_GL etc to make sure we only compile in the enums we may
- * need. */
-
-static const struct value_desc values[] = {
-   /* Enums shared between OpenGL, GLES1 and GLES2 */
-   { 0, 0, TYPE_API_MASK,
-     API_OPENGL_BIT | API_OPENGLES_BIT | API_OPENGLES2_BIT, NO_EXTRA},
-   { GL_ALPHA_BITS, BUFFER_INT(Visual.alphaBits), extra_new_buffers },
-   { GL_BLEND, CONTEXT_BIT0(Color.BlendEnabled), NO_EXTRA },
-   { GL_BLEND_SRC, CONTEXT_ENUM(Color.Blend[0].SrcRGB), NO_EXTRA },
-   { GL_BLUE_BITS, BUFFER_INT(Visual.blueBits), extra_new_buffers },
-   { GL_COLOR_CLEAR_VALUE, CONTEXT_FIELD(Color.ClearColor[0], TYPE_FLOATN_4), NO_EXTRA },
-   { GL_COLOR_WRITEMASK, LOC_CUSTOM, TYPE_INT_4, 0, NO_EXTRA },
-   { GL_CULL_FACE, CONTEXT_BOOL(Polygon.CullFlag), NO_EXTRA },
-   { GL_CULL_FACE_MODE, CONTEXT_ENUM(Polygon.CullFaceMode), NO_EXTRA },
-   { GL_DEPTH_BITS, BUFFER_INT(Visual.depthBits), NO_EXTRA },
-   { GL_DEPTH_CLEAR_VALUE, CONTEXT_FIELD(Depth.Clear, TYPE_DOUBLEN), NO_EXTRA },
-   { GL_DEPTH_FUNC, CONTEXT_ENUM(Depth.Func), NO_EXTRA },
-   { GL_DEPTH_RANGE, CONTEXT_FIELD(Viewport.Near, TYPE_FLOATN_2), NO_EXTRA },
-   { GL_DEPTH_TEST, CONTEXT_BOOL(Depth.Test), NO_EXTRA },
-   { GL_DEPTH_WRITEMASK, CONTEXT_BOOL(Depth.Mask), NO_EXTRA },
-   { GL_DITHER, CONTEXT_BOOL(Color.DitherFlag), NO_EXTRA },
-   { GL_FRONT_FACE, CONTEXT_ENUM(Polygon.FrontFace), NO_EXTRA },
-   { GL_GREEN_BITS, BUFFER_INT(Visual.greenBits), extra_new_buffers },
-   { GL_LINE_WIDTH, CONTEXT_FLOAT(Line.Width), NO_EXTRA },
-   { GL_ALIASED_LINE_WIDTH_RANGE, CONTEXT_FLOAT2(Const.MinLineWidth), NO_EXTRA },
-   { GL_MAX_ELEMENTS_VERTICES, CONTEXT_INT(Const.MaxArrayLockSize), NO_EXTRA },
-   { GL_MAX_ELEMENTS_INDICES, CONTEXT_INT(Const.MaxArrayLockSize), NO_EXTRA },
-   { GL_MAX_TEXTURE_SIZE, LOC_CUSTOM, TYPE_INT,
-     offsetof(struct gl_context, Const.MaxTextureLevels), NO_EXTRA },
-   { GL_MAX_VIEWPORT_DIMS, CONTEXT_INT2(Const.MaxViewportWidth), NO_EXTRA },
-   { GL_PACK_ALIGNMENT, CONTEXT_INT(Pack.Alignment), NO_EXTRA },
-   { GL_ALIASED_POINT_SIZE_RANGE, CONTEXT_FLOAT2(Const.MinPointSize), NO_EXTRA },
-   { GL_POLYGON_OFFSET_FACTOR, CONTEXT_FLOAT(Polygon.OffsetFactor ), NO_EXTRA },
-   { GL_POLYGON_OFFSET_UNITS, CONTEXT_FLOAT(Polygon.OffsetUnits ), NO_EXTRA },
-   { GL_POLYGON_OFFSET_FILL, CONTEXT_BOOL(Polygon.OffsetFill), NO_EXTRA },
-   { GL_RED_BITS, BUFFER_INT(Visual.redBits), extra_new_buffers },
-   { GL_SCISSOR_BOX, LOC_CUSTOM, TYPE_INT_4, 0, NO_EXTRA },
-   { GL_SCISSOR_TEST, CONTEXT_BOOL(Scissor.Enabled), NO_EXTRA },
-   { GL_STENCIL_BITS, BUFFER_INT(Visual.stencilBits), NO_EXTRA },
-   { GL_STENCIL_CLEAR_VALUE, CONTEXT_INT(Stencil.Clear), NO_EXTRA },
-   { GL_STENCIL_FAIL, LOC_CUSTOM, TYPE_ENUM, NO_OFFSET, NO_EXTRA },
-   { GL_STENCIL_FUNC, LOC_CUSTOM, TYPE_ENUM, NO_OFFSET, NO_EXTRA },
-   { GL_STENCIL_PASS_DEPTH_FAIL, LOC_CUSTOM, TYPE_ENUM, NO_OFFSET, NO_EXTRA },
-   { GL_STENCIL_PASS_DEPTH_PASS, LOC_CUSTOM, TYPE_ENUM, NO_OFFSET, NO_EXTRA },
-   { GL_STENCIL_REF, LOC_CUSTOM, TYPE_INT, NO_OFFSET, NO_EXTRA },
-   { GL_STENCIL_TEST, CONTEXT_BOOL(Stencil.Enabled), NO_EXTRA },
-   { GL_STENCIL_VALUE_MASK, LOC_CUSTOM, TYPE_INT, NO_OFFSET, NO_EXTRA },
-   { GL_STENCIL_WRITEMASK, LOC_CUSTOM, TYPE_INT, NO_OFFSET, NO_EXTRA },
-   { GL_SUBPIXEL_BITS, CONTEXT_INT(Const.SubPixelBits), NO_EXTRA },
-   { GL_TEXTURE_BINDING_2D, LOC_CUSTOM, TYPE_INT, TEXTURE_2D_INDEX, NO_EXTRA },
-   { GL_UNPACK_ALIGNMENT, CONTEXT_INT(Unpack.Alignment), NO_EXTRA },
-   { GL_VIEWPORT, LOC_CUSTOM, TYPE_INT_4, 0, NO_EXTRA },
-
-   /* GL_ARB_multitexture */
-   { GL_ACTIVE_TEXTURE_ARB,
-     LOC_CUSTOM, TYPE_INT, 0, extra_ARB_multitexture },
-
-   /* Note that all the OES_* extensions require that the Mesa "struct
-    * gl_extensions" include a member with the name of the extension.
-    * That structure does not yet include OES extensions (and we're
-    * not sure whether it will).  If it does, all the OES_*
-    * extensions below should mark the dependency. */
-
-   /* GL_ARB_texture_cube_map */
-   { GL_TEXTURE_BINDING_CUBE_MAP_ARB, LOC_CUSTOM, TYPE_INT,
-     TEXTURE_CUBE_INDEX, extra_ARB_texture_cube_map },
-   { GL_MAX_CUBE_MAP_TEXTURE_SIZE_ARB, LOC_CUSTOM, TYPE_INT,
-     offsetof(struct gl_context, Const.MaxCubeTextureLevels),
-     extra_ARB_texture_cube_map }, /* XXX: OES_texture_cube_map */
-
-   /* XXX: OES_blend_subtract */
-   { GL_BLEND_SRC_RGB_EXT, CONTEXT_ENUM(Color.Blend[0].SrcRGB), NO_EXTRA },
-   { GL_BLEND_DST_RGB_EXT, CONTEXT_ENUM(Color.Blend[0].DstRGB), NO_EXTRA },
-   { GL_BLEND_SRC_ALPHA_EXT, CONTEXT_ENUM(Color.Blend[0].SrcA), NO_EXTRA },
-   { GL_BLEND_DST_ALPHA_EXT, CONTEXT_ENUM(Color.Blend[0].DstA), NO_EXTRA },
-
-   /* GL_BLEND_EQUATION_RGB, which is what we're really after, is
-    * defined identically to GL_BLEND_EQUATION. */
-   { GL_BLEND_EQUATION, CONTEXT_ENUM(Color.Blend[0].EquationRGB), NO_EXTRA },
-   { GL_BLEND_EQUATION_ALPHA_EXT, CONTEXT_ENUM(Color.Blend[0].EquationA), NO_EXTRA },
-
-   /* GL_ARB_texture_compression */
-   { GL_NUM_COMPRESSED_TEXTURE_FORMATS_ARB, LOC_CUSTOM, TYPE_INT, 0, NO_EXTRA },
-   { GL_COMPRESSED_TEXTURE_FORMATS_ARB, LOC_CUSTOM, TYPE_INT_N, 0, NO_EXTRA },
-
-   /* GL_ARB_multisample */
-   { GL_SAMPLE_ALPHA_TO_COVERAGE_ARB,
-     CONTEXT_BOOL(Multisample.SampleAlphaToCoverage), NO_EXTRA },
-   { GL_SAMPLE_COVERAGE_ARB, CONTEXT_BOOL(Multisample.SampleCoverage), NO_EXTRA },
-   { GL_SAMPLE_COVERAGE_VALUE_ARB,
-     CONTEXT_FLOAT(Multisample.SampleCoverageValue), NO_EXTRA },
-   { GL_SAMPLE_COVERAGE_INVERT_ARB,
-     CONTEXT_BOOL(Multisample.SampleCoverageInvert), NO_EXTRA },
-   { GL_SAMPLE_BUFFERS_ARB, BUFFER_INT(Visual.sampleBuffers), NO_EXTRA },
-   { GL_SAMPLES_ARB, BUFFER_INT(Visual.samples), NO_EXTRA },
-
-   /* GL_SGIS_generate_mipmap */
-   { GL_GENERATE_MIPMAP_HINT_SGIS, CONTEXT_ENUM(Hint.GenerateMipmap),
-     extra_SGIS_generate_mipmap },
-
-   /* GL_ARB_vertex_buffer_object */
-   { GL_ARRAY_BUFFER_BINDING_ARB, LOC_CUSTOM, TYPE_INT, 0, NO_EXTRA },
-
-   /* GL_ARB_vertex_buffer_object */
-   /* GL_WEIGHT_ARRAY_BUFFER_BINDING_ARB - not supported */
-   { GL_ELEMENT_ARRAY_BUFFER_BINDING_ARB, LOC_CUSTOM, TYPE_INT, 0,
-     extra_ARB_vertex_buffer_object },
-
-   /* GL_ARB_copy_buffer */
-   { GL_COPY_READ_BUFFER, LOC_CUSTOM, TYPE_INT, 0, extra_ARB_copy_buffer },
-   { GL_COPY_WRITE_BUFFER, LOC_CUSTOM, TYPE_INT, 0, extra_ARB_copy_buffer },
-
-   /* GL_OES_read_format */
-   { GL_IMPLEMENTATION_COLOR_READ_TYPE_OES, LOC_CUSTOM, TYPE_INT, 0,
-     extra_new_buffers_OES_read_format },
-   { GL_IMPLEMENTATION_COLOR_READ_FORMAT_OES, LOC_CUSTOM, TYPE_INT, 0,
-     extra_new_buffers_OES_read_format },
-
-   /* GL_EXT_framebuffer_object */
-   { GL_FRAMEBUFFER_BINDING_EXT, BUFFER_INT(Name),
-     extra_EXT_framebuffer_object },
-   { GL_RENDERBUFFER_BINDING_EXT, LOC_CUSTOM, TYPE_INT, 0,
-     extra_EXT_framebuffer_object },
-   { GL_MAX_RENDERBUFFER_SIZE_EXT, CONTEXT_INT(Const.MaxRenderbufferSize),
-     extra_EXT_framebuffer_object },
-
-   /* This entry isn't spec'ed for GLES 2, but is needed for Mesa's
-    * GLSL: */
-   { GL_MAX_CLIP_PLANES, CONTEXT_INT(Const.MaxClipPlanes), NO_EXTRA },
-
-#if FEATURE_GL || FEATURE_ES1
-   /* Enums in OpenGL and GLES1 */
-   { 0, 0, TYPE_API_MASK, API_OPENGL_BIT | API_OPENGLES_BIT, NO_EXTRA },
-   { GL_LIGHT0, CONTEXT_BOOL(Light.Light[0].Enabled), NO_EXTRA },
-   { GL_LIGHT1, CONTEXT_BOOL(Light.Light[1].Enabled), NO_EXTRA },
-   { GL_LIGHT2, CONTEXT_BOOL(Light.Light[2].Enabled), NO_EXTRA },
-   { GL_LIGHT3, CONTEXT_BOOL(Light.Light[3].Enabled), NO_EXTRA },
-   { GL_LIGHT4, CONTEXT_BOOL(Light.Light[4].Enabled), NO_EXTRA },
-   { GL_LIGHT5, CONTEXT_BOOL(Light.Light[5].Enabled), NO_EXTRA },
-   { GL_LIGHT6, CONTEXT_BOOL(Light.Light[6].Enabled), NO_EXTRA },
-   { GL_LIGHT7, CONTEXT_BOOL(Light.Light[7].Enabled), NO_EXTRA },
-   { GL_LIGHTING, CONTEXT_BOOL(Light.Enabled), NO_EXTRA },
-   { GL_LIGHT_MODEL_AMBIENT,
-     CONTEXT_FIELD(Light.Model.Ambient[0], TYPE_FLOATN_4), NO_EXTRA },
-   { GL_LIGHT_MODEL_TWO_SIDE, CONTEXT_BOOL(Light.Model.TwoSide), NO_EXTRA },
-   { GL_ALPHA_TEST, CONTEXT_BOOL(Color.AlphaEnabled), NO_EXTRA },
-   { GL_ALPHA_TEST_FUNC, CONTEXT_ENUM(Color.AlphaFunc), NO_EXTRA },
-   { GL_ALPHA_TEST_REF, CONTEXT_FIELD(Color.AlphaRef, TYPE_FLOATN), NO_EXTRA },
-   { GL_BLEND_DST, CONTEXT_ENUM(Color.Blend[0].DstRGB), NO_EXTRA },
-   { GL_CLIP_PLANE0, CONTEXT_BIT0(Transform.ClipPlanesEnabled), NO_EXTRA },
-   { GL_CLIP_PLANE1, CONTEXT_BIT1(Transform.ClipPlanesEnabled), NO_EXTRA },
-   { GL_CLIP_PLANE2, CONTEXT_BIT2(Transform.ClipPlanesEnabled), NO_EXTRA },
-   { GL_CLIP_PLANE3, CONTEXT_BIT3(Transform.ClipPlanesEnabled), NO_EXTRA },
-   { GL_CLIP_PLANE4, CONTEXT_BIT4(Transform.ClipPlanesEnabled), NO_EXTRA },
-   { GL_CLIP_PLANE5, CONTEXT_BIT5(Transform.ClipPlanesEnabled), NO_EXTRA },
-   { GL_COLOR_MATERIAL, CONTEXT_BOOL(Light.ColorMaterialEnabled), NO_EXTRA },
-   { GL_CURRENT_COLOR,
-     CONTEXT_FIELD(Current.Attrib[VERT_ATTRIB_COLOR0][0], TYPE_FLOATN_4),
-     extra_flush_current },
-   { GL_CURRENT_NORMAL,
-     CONTEXT_FIELD(Current.Attrib[VERT_ATTRIB_NORMAL][0], TYPE_FLOATN_3),
-     extra_flush_current },
-   { GL_CURRENT_TEXTURE_COORDS, LOC_CUSTOM, TYPE_FLOAT_4, 0,
-     extra_flush_current_valid_texture_unit },
-   { GL_DISTANCE_ATTENUATION_EXT, CONTEXT_FLOAT3(Point.Params[0]), NO_EXTRA },
-   { GL_FOG, CONTEXT_BOOL(Fog.Enabled), NO_EXTRA },
-   { GL_FOG_COLOR, CONTEXT_FIELD(Fog.Color[0], TYPE_FLOATN_4), NO_EXTRA },
-   { GL_FOG_DENSITY, CONTEXT_FLOAT(Fog.Density), NO_EXTRA },
-   { GL_FOG_END, CONTEXT_FLOAT(Fog.End), NO_EXTRA },
-   { GL_FOG_HINT, CONTEXT_ENUM(Hint.Fog), NO_EXTRA },
-   { GL_FOG_MODE, CONTEXT_ENUM(Fog.Mode), NO_EXTRA },
-   { GL_FOG_START, CONTEXT_FLOAT(Fog.Start), NO_EXTRA },
-   { GL_LINE_SMOOTH, CONTEXT_BOOL(Line.SmoothFlag), NO_EXTRA },
-   { GL_LINE_SMOOTH_HINT, CONTEXT_ENUM(Hint.LineSmooth), NO_EXTRA },
-   { GL_LINE_WIDTH_RANGE, CONTEXT_FLOAT2(Const.MinLineWidthAA), NO_EXTRA },
-   { GL_COLOR_LOGIC_OP, CONTEXT_BOOL(Color.ColorLogicOpEnabled), NO_EXTRA },
-   { GL_LOGIC_OP_MODE, CONTEXT_ENUM(Color.LogicOp), NO_EXTRA },
-   { GL_MATRIX_MODE, CONTEXT_ENUM(Transform.MatrixMode), NO_EXTRA },
-   { GL_MAX_MODELVIEW_STACK_DEPTH, CONST(MAX_MODELVIEW_STACK_DEPTH), NO_EXTRA },
-   { GL_MAX_PROJECTION_STACK_DEPTH, CONST(MAX_PROJECTION_STACK_DEPTH), NO_EXTRA },
-   { GL_MAX_TEXTURE_STACK_DEPTH, CONST(MAX_TEXTURE_STACK_DEPTH), NO_EXTRA },
-   { GL_MODELVIEW_MATRIX, CONTEXT_MATRIX(ModelviewMatrixStack.Top), NO_EXTRA },
-   { GL_MODELVIEW_STACK_DEPTH, LOC_CUSTOM, TYPE_INT,
-     offsetof(struct gl_context, ModelviewMatrixStack.Depth), NO_EXTRA },
-   { GL_NORMALIZE, CONTEXT_BOOL(Transform.Normalize), NO_EXTRA },
-   { GL_PACK_SKIP_IMAGES_EXT, CONTEXT_INT(Pack.SkipImages), NO_EXTRA },
-   { GL_PERSPECTIVE_CORRECTION_HINT, CONTEXT_ENUM(Hint.PerspectiveCorrection), NO_EXTRA },
-   { GL_POINT_SIZE, CONTEXT_FLOAT(Point.Size), NO_EXTRA },
-   { GL_POINT_SIZE_RANGE, CONTEXT_FLOAT2(Const.MinPointSizeAA), NO_EXTRA },
-   { GL_POINT_SMOOTH, CONTEXT_BOOL(Point.SmoothFlag), NO_EXTRA },
-   { GL_POINT_SMOOTH_HINT, CONTEXT_ENUM(Hint.PointSmooth), NO_EXTRA },
-   { GL_POINT_SIZE_MIN_EXT, CONTEXT_FLOAT(Point.MinSize), NO_EXTRA },
-   { GL_POINT_SIZE_MAX_EXT, CONTEXT_FLOAT(Point.MaxSize), NO_EXTRA },
-   { GL_POINT_FADE_THRESHOLD_SIZE_EXT, CONTEXT_FLOAT(Point.Threshold), NO_EXTRA },
-   { GL_PROJECTION_MATRIX, CONTEXT_MATRIX(ProjectionMatrixStack.Top), NO_EXTRA },
-   { GL_PROJECTION_STACK_DEPTH, LOC_CUSTOM, TYPE_INT,
-     offsetof(struct gl_context, ProjectionMatrixStack.Depth), NO_EXTRA },
-   { GL_RESCALE_NORMAL, CONTEXT_BOOL(Transform.RescaleNormals), NO_EXTRA },
-   { GL_SHADE_MODEL, CONTEXT_ENUM(Light.ShadeModel), NO_EXTRA },
-   { GL_TEXTURE_2D, LOC_CUSTOM, TYPE_BOOLEAN, 0, NO_EXTRA },
-   { GL_TEXTURE_MATRIX, LOC_CUSTOM, TYPE_MATRIX, 0, extra_valid_texture_unit },
-   { GL_TEXTURE_STACK_DEPTH, LOC_CUSTOM, TYPE_INT, 0,
-     extra_valid_texture_unit  },
-
-   { GL_VERTEX_ARRAY, ARRAY_BOOL(Vertex.Enabled), NO_EXTRA },
-   { GL_VERTEX_ARRAY_SIZE, ARRAY_INT(Vertex.Size), NO_EXTRA },
-   { GL_VERTEX_ARRAY_TYPE, ARRAY_ENUM(Vertex.Type), NO_EXTRA },
-   { GL_VERTEX_ARRAY_STRIDE, ARRAY_INT(Vertex.Stride), NO_EXTRA },
-   { GL_NORMAL_ARRAY, ARRAY_ENUM(Normal.Enabled), NO_EXTRA },
-   { GL_NORMAL_ARRAY_TYPE, ARRAY_ENUM(Normal.Type), NO_EXTRA },
-   { GL_NORMAL_ARRAY_STRIDE, ARRAY_INT(Normal.Stride), NO_EXTRA },
-   { GL_COLOR_ARRAY, ARRAY_BOOL(Color.Enabled), NO_EXTRA },
-   { GL_COLOR_ARRAY_SIZE, ARRAY_INT(Color.Size), NO_EXTRA },
-   { GL_COLOR_ARRAY_TYPE, ARRAY_ENUM(Color.Type), NO_EXTRA },
-   { GL_COLOR_ARRAY_STRIDE, ARRAY_INT(Color.Stride), NO_EXTRA },
-   { GL_TEXTURE_COORD_ARRAY,
-     LOC_CUSTOM, TYPE_BOOLEAN, offsetof(struct gl_client_array, Enabled), NO_EXTRA },
-   { GL_TEXTURE_COORD_ARRAY_SIZE,
-     LOC_CUSTOM, TYPE_BOOLEAN, offsetof(struct gl_client_array, Size), NO_EXTRA },
-   { GL_TEXTURE_COORD_ARRAY_TYPE,
-     LOC_CUSTOM, TYPE_BOOLEAN, offsetof(struct gl_client_array, Type), NO_EXTRA },
-   { GL_TEXTURE_COORD_ARRAY_STRIDE,
-     LOC_CUSTOM, TYPE_BOOLEAN, offsetof(struct gl_client_array, Stride), NO_EXTRA },
-
-   /* GL_ARB_ES2_compatibility */
-   { GL_SHADER_COMPILER, CONST(1), extra_ARB_ES2_compatibility },
-   { GL_MAX_VARYING_VECTORS, CONTEXT_INT(Const.MaxVarying),
-     extra_ARB_ES2_compatibility },
-   { GL_MAX_VERTEX_UNIFORM_VECTORS, LOC_CUSTOM, TYPE_INT, 0,
-     extra_ARB_ES2_compatibility },
-   { GL_MAX_FRAGMENT_UNIFORM_VECTORS, LOC_CUSTOM, TYPE_INT, 0,
-     extra_ARB_ES2_compatibility },
-
-   /* GL_ARB_multitexture */
-   { GL_MAX_TEXTURE_UNITS_ARB,
-     CONTEXT_INT(Const.MaxTextureUnits), extra_ARB_multitexture },
-   { GL_CLIENT_ACTIVE_TEXTURE_ARB,
-     LOC_CUSTOM, TYPE_INT, 0, extra_ARB_multitexture },
-
-   /* GL_ARB_texture_cube_map */
-   { GL_TEXTURE_CUBE_MAP_ARB, LOC_CUSTOM, TYPE_BOOLEAN, 0, NO_EXTRA },
-   /* S, T, and R are always set at the same time */
-   { GL_TEXTURE_GEN_STR_OES, LOC_TEXUNIT, TYPE_BIT_0,
-     offsetof(struct gl_texture_unit, TexGenEnabled), NO_EXTRA },
-
-   /* GL_ARB_multisample */
-   { GL_MULTISAMPLE_ARB, CONTEXT_BOOL(Multisample.Enabled), NO_EXTRA },
-   { GL_SAMPLE_ALPHA_TO_ONE_ARB, CONTEXT_BOOL(Multisample.SampleAlphaToOne), NO_EXTRA },
-
-   /* GL_ARB_vertex_buffer_object */
-   { GL_VERTEX_ARRAY_BUFFER_BINDING_ARB, LOC_CUSTOM, TYPE_INT,
-     offsetof(struct gl_array_object, Vertex.BufferObj), NO_EXTRA },
-   { GL_NORMAL_ARRAY_BUFFER_BINDING_ARB, LOC_CUSTOM, TYPE_INT,
-     offsetof(struct gl_array_object, Normal.BufferObj), NO_EXTRA },
-   { GL_COLOR_ARRAY_BUFFER_BINDING_ARB, LOC_CUSTOM, TYPE_INT,
-     offsetof(struct gl_array_object, Color.BufferObj), NO_EXTRA },
-   { GL_TEXTURE_COORD_ARRAY_BUFFER_BINDING_ARB, LOC_CUSTOM, TYPE_INT, NO_OFFSET, NO_EXTRA },
-
-   /* GL_OES_point_sprite */
-   { GL_POINT_SPRITE_NV,
-     CONTEXT_BOOL(Point.PointSprite),
-     extra_NV_point_sprite_ARB_point_sprite },
-
-   /* GL_ARB_fragment_shader */
-   { GL_MAX_FRAGMENT_UNIFORM_COMPONENTS_ARB,
-     CONTEXT_INT(Const.FragmentProgram.MaxUniformComponents),
-     extra_ARB_fragment_shader },
-
-   /* GL_ARB_vertex_shader */
-   { GL_MAX_VERTEX_UNIFORM_COMPONENTS_ARB,
-     CONTEXT_INT(Const.VertexProgram.MaxUniformComponents),
-     extra_ARB_vertex_shader },
-   { GL_MAX_VARYING_FLOATS_ARB, LOC_CUSTOM, TYPE_INT, 0,
-     extra_ARB_vertex_shader },
-
-   /* GL_EXT_texture_lod_bias */
-   { GL_MAX_TEXTURE_LOD_BIAS_EXT, CONTEXT_FLOAT(Const.MaxTextureLodBias),
-	 extra_EXT_texture_lod_bias },
-
-   /* GL_EXT_texture_filter_anisotropic */
-   { GL_MAX_TEXTURE_MAX_ANISOTROPY_EXT,
-     CONTEXT_FLOAT(Const.MaxTextureMaxAnisotropy),
-     extra_EXT_texture_filter_anisotropic },
-#endif /* FEATURE_GL || FEATURE_ES1 */
-
-#if FEATURE_ES1
-   { 0, 0, TYPE_API_MASK, API_OPENGLES_BIT },
-   /* XXX: OES_matrix_get */
-   { GL_MODELVIEW_MATRIX_FLOAT_AS_INT_BITS_OES },
-   { GL_PROJECTION_MATRIX_FLOAT_AS_INT_BITS_OES },
-   { GL_TEXTURE_MATRIX_FLOAT_AS_INT_BITS_OES },
-
-   /* OES_point_size_array */
-   { GL_POINT_SIZE_ARRAY_OES, ARRAY_FIELD(PointSize.Enabled, TYPE_BOOLEAN) },
-   { GL_POINT_SIZE_ARRAY_TYPE_OES, ARRAY_FIELD(PointSize.Type, TYPE_ENUM) },
-   { GL_POINT_SIZE_ARRAY_STRIDE_OES, ARRAY_FIELD(PointSize.Stride, TYPE_INT) },
-   { GL_POINT_SIZE_ARRAY_BUFFER_BINDING_OES, LOC_CUSTOM, TYPE_INT, 0 },
-#endif /* FEATURE_ES1 */
-
-#if FEATURE_GL || FEATURE_ES2
-   { 0, 0, TYPE_API_MASK, API_OPENGL_BIT | API_OPENGLES2_BIT, NO_EXTRA },
-   /* This entry isn't spec'ed for GLES 2, but is needed for Mesa's GLSL: */
-   { GL_MAX_LIGHTS, CONTEXT_INT(Const.MaxLights), NO_EXTRA },
-   { GL_MAX_TEXTURE_COORDS_ARB, /* == GL_MAX_TEXTURE_COORDS_NV */
-     CONTEXT_INT(Const.MaxTextureCoordUnits),
-     extra_ARB_fragment_program_NV_fragment_program },
-
-   /* GL_ARB_draw_buffers */
-   { GL_MAX_DRAW_BUFFERS_ARB, CONTEXT_INT(Const.MaxDrawBuffers), NO_EXTRA },
-
-   { GL_BLEND_COLOR_EXT, CONTEXT_FIELD(Color.BlendColor[0], TYPE_FLOATN_4), NO_EXTRA },
-   /* GL_ARB_fragment_program */
-   { GL_MAX_TEXTURE_IMAGE_UNITS_ARB, /* == GL_MAX_TEXTURE_IMAGE_UNITS_NV */
-     CONTEXT_INT(Const.MaxTextureImageUnits),
-     extra_ARB_fragment_program_NV_fragment_program },
-   { GL_MAX_VERTEX_TEXTURE_IMAGE_UNITS_ARB,
-     CONTEXT_INT(Const.MaxVertexTextureImageUnits), extra_ARB_vertex_shader },
-   { GL_MAX_COMBINED_TEXTURE_IMAGE_UNITS_ARB,
-     CONTEXT_INT(Const.MaxCombinedTextureImageUnits),
-     extra_ARB_vertex_shader },
-
-   /* GL_ARB_shader_objects
-    * Actually, this token isn't part of GL_ARB_shader_objects, but is
-    * close enough for now. */
-   { GL_CURRENT_PROGRAM, LOC_CUSTOM, TYPE_INT, 0, extra_ARB_shader_objects },
-
-   /* OpenGL 2.0 */
-   { GL_STENCIL_BACK_FUNC, CONTEXT_ENUM(Stencil.Function[1]), NO_EXTRA },
-   { GL_STENCIL_BACK_VALUE_MASK, CONTEXT_INT(Stencil.ValueMask[1]), NO_EXTRA },
-   { GL_STENCIL_BACK_WRITEMASK, CONTEXT_INT(Stencil.WriteMask[1]), NO_EXTRA },
-   { GL_STENCIL_BACK_REF, CONTEXT_INT(Stencil.Ref[1]), NO_EXTRA },
-   { GL_STENCIL_BACK_FAIL, CONTEXT_ENUM(Stencil.FailFunc[1]), NO_EXTRA },
-   { GL_STENCIL_BACK_PASS_DEPTH_FAIL, CONTEXT_ENUM(Stencil.ZFailFunc[1]), NO_EXTRA },
-   { GL_STENCIL_BACK_PASS_DEPTH_PASS, CONTEXT_ENUM(Stencil.ZPassFunc[1]), NO_EXTRA },
-
-   { GL_MAX_VERTEX_ATTRIBS_ARB,
-     CONTEXT_INT(Const.VertexProgram.MaxAttribs),
-     extra_ARB_vertex_program_version_es2 },
-
-   /* OES_texture_3D */
-   { GL_TEXTURE_BINDING_3D, LOC_CUSTOM, TYPE_INT, TEXTURE_3D_INDEX, NO_EXTRA },
-   { GL_MAX_3D_TEXTURE_SIZE, LOC_CUSTOM, TYPE_INT,
-     offsetof(struct gl_context, Const.Max3DTextureLevels), NO_EXTRA },
-
-   /* GL_ARB_fragment_program/OES_standard_derivatives */
-   { GL_FRAGMENT_SHADER_DERIVATIVE_HINT_ARB,
-     CONTEXT_ENUM(Hint.FragmentShaderDerivative), extra_ARB_fragment_shader },
-#endif /* FEATURE_GL || FEATURE_ES2 */
-
-#if FEATURE_ES2
-   /* Enums unique to OpenGL ES 2.0 */
-   { 0, 0, TYPE_API_MASK, API_OPENGLES2_BIT, NO_EXTRA },
-   { GL_MAX_FRAGMENT_UNIFORM_VECTORS, LOC_CUSTOM, TYPE_INT, 0, NO_EXTRA },
-   { GL_MAX_VARYING_VECTORS, CONTEXT_INT(Const.MaxVarying), NO_EXTRA },
-   { GL_MAX_VERTEX_UNIFORM_VECTORS, LOC_CUSTOM, TYPE_INT, 0, NO_EXTRA },
-   { GL_SHADER_COMPILER, CONST(1), NO_EXTRA },
-   /* OES_get_program_binary */
-   { GL_NUM_SHADER_BINARY_FORMATS, CONST(0), NO_EXTRA },
-   { GL_SHADER_BINARY_FORMATS, CONST(0), NO_EXTRA },
-#endif /* FEATURE_ES2 */
-
-#if FEATURE_GL
-   /* Remaining enums are only in OpenGL */
-   { 0, 0, TYPE_API_MASK, API_OPENGL_BIT, NO_EXTRA },
-   { GL_ACCUM_RED_BITS, BUFFER_INT(Visual.accumRedBits), NO_EXTRA },
-   { GL_ACCUM_GREEN_BITS, BUFFER_INT(Visual.accumGreenBits), NO_EXTRA },
-   { GL_ACCUM_BLUE_BITS, BUFFER_INT(Visual.accumBlueBits), NO_EXTRA },
-   { GL_ACCUM_ALPHA_BITS, BUFFER_INT(Visual.accumAlphaBits), NO_EXTRA },
-   { GL_ACCUM_CLEAR_VALUE, CONTEXT_FIELD(Accum.ClearColor[0], TYPE_FLOATN_4), NO_EXTRA },
-   { GL_ALPHA_BIAS, CONTEXT_FLOAT(Pixel.AlphaBias), NO_EXTRA },
-   { GL_ALPHA_SCALE, CONTEXT_FLOAT(Pixel.AlphaScale), NO_EXTRA },
-   { GL_ATTRIB_STACK_DEPTH, CONTEXT_INT(AttribStackDepth), NO_EXTRA },
-   { GL_AUTO_NORMAL, CONTEXT_BOOL(Eval.AutoNormal), NO_EXTRA },
-   { GL_AUX_BUFFERS, BUFFER_INT(Visual.numAuxBuffers), NO_EXTRA },
-   { GL_BLUE_BIAS, CONTEXT_FLOAT(Pixel.BlueBias), NO_EXTRA },
-   { GL_BLUE_SCALE, CONTEXT_FLOAT(Pixel.BlueScale), NO_EXTRA },
-   { GL_CLIENT_ATTRIB_STACK_DEPTH, CONTEXT_INT(ClientAttribStackDepth), NO_EXTRA },
-   { GL_COLOR_MATERIAL_FACE, CONTEXT_ENUM(Light.ColorMaterialFace), NO_EXTRA },
-   { GL_COLOR_MATERIAL_PARAMETER, CONTEXT_ENUM(Light.ColorMaterialMode), NO_EXTRA },
-   { GL_CURRENT_INDEX,
-     CONTEXT_FLOAT(Current.Attrib[VERT_ATTRIB_COLOR_INDEX][0]),
-     extra_flush_current },
-   { GL_CURRENT_RASTER_COLOR,
-     CONTEXT_FIELD(Current.RasterColor[0], TYPE_FLOATN_4), NO_EXTRA },
-   { GL_CURRENT_RASTER_DISTANCE, CONTEXT_FLOAT(Current.RasterDistance), NO_EXTRA },
-   { GL_CURRENT_RASTER_INDEX, CONST(1), NO_EXTRA },
-   { GL_CURRENT_RASTER_POSITION, CONTEXT_FLOAT4(Current.RasterPos[0]), NO_EXTRA },
-   { GL_CURRENT_RASTER_SECONDARY_COLOR,
-     CONTEXT_FIELD(Current.RasterSecondaryColor[0], TYPE_FLOATN_4), NO_EXTRA },
-   { GL_CURRENT_RASTER_TEXTURE_COORDS, LOC_CUSTOM, TYPE_FLOAT_4, 0,
-     extra_valid_texture_unit },
-   { GL_CURRENT_RASTER_POSITION_VALID, CONTEXT_BOOL(Current.RasterPosValid), NO_EXTRA },
-   { GL_DEPTH_BIAS, CONTEXT_FLOAT(Pixel.DepthBias), NO_EXTRA },
-   { GL_DEPTH_SCALE, CONTEXT_FLOAT(Pixel.DepthScale), NO_EXTRA },
-   { GL_DOUBLEBUFFER, BUFFER_INT(Visual.doubleBufferMode), NO_EXTRA },
-   { GL_DRAW_BUFFER, BUFFER_ENUM(ColorDrawBuffer[0]), NO_EXTRA },
-   { GL_EDGE_FLAG, LOC_CUSTOM, TYPE_BOOLEAN, 0, NO_EXTRA },
-   { GL_FEEDBACK_BUFFER_SIZE, CONTEXT_INT(Feedback.BufferSize), NO_EXTRA },
-   { GL_FEEDBACK_BUFFER_TYPE, CONTEXT_ENUM(Feedback.Type), NO_EXTRA },
-   { GL_FOG_INDEX, CONTEXT_FLOAT(Fog.Index), NO_EXTRA },
-   { GL_GREEN_BIAS, CONTEXT_FLOAT(Pixel.GreenBias), NO_EXTRA },
-   { GL_GREEN_SCALE, CONTEXT_FLOAT(Pixel.GreenScale), NO_EXTRA },
-   { GL_INDEX_BITS, BUFFER_INT(Visual.indexBits), extra_new_buffers },
-   { GL_INDEX_CLEAR_VALUE, CONTEXT_INT(Color.ClearIndex), NO_EXTRA },
-   { GL_INDEX_MODE, CONST(0) , NO_EXTRA}, 
-   { GL_INDEX_OFFSET, CONTEXT_INT(Pixel.IndexOffset), NO_EXTRA },
-   { GL_INDEX_SHIFT, CONTEXT_INT(Pixel.IndexShift), NO_EXTRA },
-   { GL_INDEX_WRITEMASK, CONTEXT_INT(Color.IndexMask), NO_EXTRA },
-   { GL_LIGHT_MODEL_COLOR_CONTROL, CONTEXT_ENUM(Light.Model.ColorControl), NO_EXTRA },
-   { GL_LIGHT_MODEL_LOCAL_VIEWER, CONTEXT_BOOL(Light.Model.LocalViewer), NO_EXTRA },
-   { GL_LINE_STIPPLE, CONTEXT_BOOL(Line.StippleFlag), NO_EXTRA },
-   { GL_LINE_STIPPLE_PATTERN, LOC_CUSTOM, TYPE_INT, 0, NO_EXTRA },
-   { GL_LINE_STIPPLE_REPEAT, CONTEXT_INT(Line.StippleFactor), NO_EXTRA },
-   { GL_LINE_WIDTH_GRANULARITY, CONTEXT_FLOAT(Const.LineWidthGranularity), NO_EXTRA },
-   { GL_LIST_BASE, CONTEXT_INT(List.ListBase), NO_EXTRA },
-   { GL_LIST_INDEX, LOC_CUSTOM, TYPE_INT, 0, NO_EXTRA },
-   { GL_LIST_MODE, LOC_CUSTOM, TYPE_ENUM, 0, NO_EXTRA },
-   { GL_INDEX_LOGIC_OP, CONTEXT_BOOL(Color.IndexLogicOpEnabled), NO_EXTRA },
-   { GL_MAP1_COLOR_4, CONTEXT_BOOL(Eval.Map1Color4), NO_EXTRA },
-   { GL_MAP1_GRID_DOMAIN, CONTEXT_FLOAT2(Eval.MapGrid1u1), NO_EXTRA },
-   { GL_MAP1_GRID_SEGMENTS, CONTEXT_INT(Eval.MapGrid1un), NO_EXTRA },
-   { GL_MAP1_INDEX, CONTEXT_BOOL(Eval.Map1Index), NO_EXTRA },
-   { GL_MAP1_NORMAL, CONTEXT_BOOL(Eval.Map1Normal), NO_EXTRA },
-   { GL_MAP1_TEXTURE_COORD_1, CONTEXT_BOOL(Eval.Map1TextureCoord1), NO_EXTRA },
-   { GL_MAP1_TEXTURE_COORD_2, CONTEXT_BOOL(Eval.Map1TextureCoord2), NO_EXTRA },
-   { GL_MAP1_TEXTURE_COORD_3, CONTEXT_BOOL(Eval.Map1TextureCoord3), NO_EXTRA },
-   { GL_MAP1_TEXTURE_COORD_4, CONTEXT_BOOL(Eval.Map1TextureCoord4), NO_EXTRA },
-   { GL_MAP1_VERTEX_3, CONTEXT_BOOL(Eval.Map1Vertex3), NO_EXTRA },
-   { GL_MAP1_VERTEX_4, CONTEXT_BOOL(Eval.Map1Vertex4), NO_EXTRA },
-   { GL_MAP2_COLOR_4, CONTEXT_BOOL(Eval.Map2Color4), NO_EXTRA },
-   { GL_MAP2_GRID_DOMAIN, LOC_CUSTOM, TYPE_FLOAT_4, 0, NO_EXTRA },
-   { GL_MAP2_GRID_SEGMENTS, CONTEXT_INT2(Eval.MapGrid2un), NO_EXTRA },
-   { GL_MAP2_INDEX, CONTEXT_BOOL(Eval.Map2Index), NO_EXTRA },
-   { GL_MAP2_NORMAL, CONTEXT_BOOL(Eval.Map2Normal), NO_EXTRA },
-   { GL_MAP2_TEXTURE_COORD_1, CONTEXT_BOOL(Eval.Map2TextureCoord1), NO_EXTRA },
-   { GL_MAP2_TEXTURE_COORD_2, CONTEXT_BOOL(Eval.Map2TextureCoord2), NO_EXTRA },
-   { GL_MAP2_TEXTURE_COORD_3, CONTEXT_BOOL(Eval.Map2TextureCoord3), NO_EXTRA },
-   { GL_MAP2_TEXTURE_COORD_4, CONTEXT_BOOL(Eval.Map2TextureCoord4), NO_EXTRA },
-   { GL_MAP2_VERTEX_3, CONTEXT_BOOL(Eval.Map2Vertex3), NO_EXTRA },
-   { GL_MAP2_VERTEX_4, CONTEXT_BOOL(Eval.Map2Vertex4), NO_EXTRA },
-   { GL_MAP_COLOR, CONTEXT_BOOL(Pixel.MapColorFlag), NO_EXTRA },
-   { GL_MAP_STENCIL, CONTEXT_BOOL(Pixel.MapStencilFlag), NO_EXTRA },
-   { GL_MAX_ATTRIB_STACK_DEPTH, CONST(MAX_ATTRIB_STACK_DEPTH), NO_EXTRA },
-   { GL_MAX_CLIENT_ATTRIB_STACK_DEPTH, CONST(MAX_CLIENT_ATTRIB_STACK_DEPTH), NO_EXTRA },
-
-   { GL_MAX_EVAL_ORDER, CONST(MAX_EVAL_ORDER), NO_EXTRA },
-   { GL_MAX_LIST_NESTING, CONST(MAX_LIST_NESTING), NO_EXTRA },
-   { GL_MAX_NAME_STACK_DEPTH, CONST(MAX_NAME_STACK_DEPTH), NO_EXTRA },
-   { GL_MAX_PIXEL_MAP_TABLE, CONST(MAX_PIXEL_MAP_TABLE), NO_EXTRA },
-   { GL_NAME_STACK_DEPTH, CONTEXT_INT(Select.NameStackDepth), NO_EXTRA },
-   { GL_PACK_LSB_FIRST, CONTEXT_BOOL(Pack.LsbFirst), NO_EXTRA },
-   { GL_PACK_ROW_LENGTH, CONTEXT_INT(Pack.RowLength), NO_EXTRA },
-   { GL_PACK_SKIP_PIXELS, CONTEXT_INT(Pack.SkipPixels), NO_EXTRA },
-   { GL_PACK_SKIP_ROWS, CONTEXT_INT(Pack.SkipRows), NO_EXTRA },
-   { GL_PACK_SWAP_BYTES, CONTEXT_BOOL(Pack.SwapBytes), NO_EXTRA },
-   { GL_PACK_IMAGE_HEIGHT_EXT, CONTEXT_INT(Pack.ImageHeight), NO_EXTRA },
-   { GL_PACK_INVERT_MESA, CONTEXT_BOOL(Pack.Invert), NO_EXTRA },
-   { GL_PIXEL_MAP_A_TO_A_SIZE, CONTEXT_INT(PixelMaps.AtoA.Size), NO_EXTRA },
-   { GL_PIXEL_MAP_B_TO_B_SIZE, CONTEXT_INT(PixelMaps.BtoB.Size), NO_EXTRA },
-   { GL_PIXEL_MAP_G_TO_G_SIZE, CONTEXT_INT(PixelMaps.GtoG.Size), NO_EXTRA },
-   { GL_PIXEL_MAP_I_TO_A_SIZE, CONTEXT_INT(PixelMaps.ItoA.Size), NO_EXTRA },
-   { GL_PIXEL_MAP_I_TO_B_SIZE, CONTEXT_INT(PixelMaps.ItoB.Size), NO_EXTRA },
-   { GL_PIXEL_MAP_I_TO_G_SIZE, CONTEXT_INT(PixelMaps.ItoG.Size), NO_EXTRA },
-   { GL_PIXEL_MAP_I_TO_I_SIZE, CONTEXT_INT(PixelMaps.ItoI.Size), NO_EXTRA },
-   { GL_PIXEL_MAP_I_TO_R_SIZE, CONTEXT_INT(PixelMaps.ItoR.Size), NO_EXTRA },
-   { GL_PIXEL_MAP_R_TO_R_SIZE, CONTEXT_INT(PixelMaps.RtoR.Size), NO_EXTRA },
-   { GL_PIXEL_MAP_S_TO_S_SIZE, CONTEXT_INT(PixelMaps.StoS.Size), NO_EXTRA },
-   { GL_POINT_SIZE_GRANULARITY, CONTEXT_FLOAT(Const.PointSizeGranularity), NO_EXTRA },
-   { GL_POLYGON_MODE, CONTEXT_ENUM2(Polygon.FrontMode), NO_EXTRA },
-   { GL_POLYGON_OFFSET_BIAS_EXT, CONTEXT_FLOAT(Polygon.OffsetUnits), NO_EXTRA },
-   { GL_POLYGON_OFFSET_POINT, CONTEXT_BOOL(Polygon.OffsetPoint), NO_EXTRA },
-   { GL_POLYGON_OFFSET_LINE, CONTEXT_BOOL(Polygon.OffsetLine), NO_EXTRA },
-   { GL_POLYGON_SMOOTH, CONTEXT_BOOL(Polygon.SmoothFlag), NO_EXTRA },
-   { GL_POLYGON_SMOOTH_HINT, CONTEXT_ENUM(Hint.PolygonSmooth), NO_EXTRA },
-   { GL_POLYGON_STIPPLE, CONTEXT_BOOL(Polygon.StippleFlag), NO_EXTRA },
-   { GL_READ_BUFFER, LOC_CUSTOM, TYPE_ENUM, NO_OFFSET, NO_EXTRA },
-   { GL_RED_BIAS, CONTEXT_FLOAT(Pixel.RedBias), NO_EXTRA },
-   { GL_RED_SCALE, CONTEXT_FLOAT(Pixel.RedScale), NO_EXTRA },
-   { GL_RENDER_MODE, CONTEXT_ENUM(RenderMode), NO_EXTRA },
-   { GL_RGBA_MODE, CONST(1), NO_EXTRA },
-   { GL_SELECTION_BUFFER_SIZE, CONTEXT_INT(Select.BufferSize), NO_EXTRA },
-   { GL_SHARED_TEXTURE_PALETTE_EXT, CONTEXT_BOOL(Texture.SharedPalette), NO_EXTRA },
-
-   { GL_STEREO, BUFFER_INT(Visual.stereoMode), NO_EXTRA },
-
-   { GL_TEXTURE_1D, LOC_CUSTOM, TYPE_BOOLEAN, NO_OFFSET, NO_EXTRA },
-   { GL_TEXTURE_3D, LOC_CUSTOM, TYPE_BOOLEAN, NO_OFFSET, NO_EXTRA },
-   { GL_TEXTURE_1D_ARRAY_EXT, LOC_CUSTOM, TYPE_BOOLEAN, NO_OFFSET, NO_EXTRA },
-   { GL_TEXTURE_2D_ARRAY_EXT, LOC_CUSTOM, TYPE_BOOLEAN, NO_OFFSET, NO_EXTRA },
-
-   { GL_TEXTURE_BINDING_1D, LOC_CUSTOM, TYPE_INT, TEXTURE_1D_INDEX, NO_EXTRA },
-   { GL_TEXTURE_BINDING_1D_ARRAY, LOC_CUSTOM, TYPE_INT,
-     TEXTURE_1D_ARRAY_INDEX, extra_MESA_texture_array },
-   { GL_TEXTURE_BINDING_2D_ARRAY, LOC_CUSTOM, TYPE_INT,
-     TEXTURE_1D_ARRAY_INDEX, extra_MESA_texture_array },
-   { GL_MAX_ARRAY_TEXTURE_LAYERS_EXT,
-     CONTEXT_INT(Const.MaxArrayTextureLayers), extra_MESA_texture_array },
-
-   { GL_TEXTURE_GEN_S, LOC_TEXUNIT, TYPE_BIT_0,
-     offsetof(struct gl_texture_unit, TexGenEnabled), NO_EXTRA },
-   { GL_TEXTURE_GEN_T, LOC_TEXUNIT, TYPE_BIT_1,
-     offsetof(struct gl_texture_unit, TexGenEnabled), NO_EXTRA },
-   { GL_TEXTURE_GEN_R, LOC_TEXUNIT, TYPE_BIT_2,
-     offsetof(struct gl_texture_unit, TexGenEnabled), NO_EXTRA },
-   { GL_TEXTURE_GEN_Q, LOC_TEXUNIT, TYPE_BIT_3,
-     offsetof(struct gl_texture_unit, TexGenEnabled), NO_EXTRA },
-   { GL_UNPACK_LSB_FIRST, CONTEXT_BOOL(Unpack.LsbFirst), NO_EXTRA },
-   { GL_UNPACK_ROW_LENGTH, CONTEXT_INT(Unpack.RowLength), NO_EXTRA },
-   { GL_UNPACK_SKIP_PIXELS, CONTEXT_INT(Unpack.SkipPixels), NO_EXTRA },
-   { GL_UNPACK_SKIP_ROWS, CONTEXT_INT(Unpack.SkipRows), NO_EXTRA },
-   { GL_UNPACK_SWAP_BYTES, CONTEXT_BOOL(Unpack.SwapBytes), NO_EXTRA },
-   { GL_UNPACK_SKIP_IMAGES_EXT, CONTEXT_INT(Unpack.SkipImages), NO_EXTRA },
-   { GL_UNPACK_IMAGE_HEIGHT_EXT, CONTEXT_INT(Unpack.ImageHeight), NO_EXTRA },
-   { GL_UNPACK_CLIENT_STORAGE_APPLE, CONTEXT_BOOL(Unpack.ClientStorage), NO_EXTRA },
-   { GL_ZOOM_X, CONTEXT_FLOAT(Pixel.ZoomX), NO_EXTRA },
-   { GL_ZOOM_Y, CONTEXT_FLOAT(Pixel.ZoomY), NO_EXTRA },
-
-   /* Vertex arrays */
-   { GL_VERTEX_ARRAY_COUNT_EXT, CONST(0), NO_EXTRA },
-   { GL_NORMAL_ARRAY_COUNT_EXT, CONST(0), NO_EXTRA },
-   { GL_COLOR_ARRAY_COUNT_EXT, CONST(0), NO_EXTRA },
-   { GL_INDEX_ARRAY, ARRAY_BOOL(Index.Enabled), NO_EXTRA },
-   { GL_INDEX_ARRAY_TYPE, ARRAY_ENUM(Index.Type), NO_EXTRA },
-   { GL_INDEX_ARRAY_STRIDE, ARRAY_INT(Index.Stride), NO_EXTRA },
-   { GL_INDEX_ARRAY_COUNT_EXT, CONST(0), NO_EXTRA },
-   { GL_TEXTURE_COORD_ARRAY_COUNT_EXT, CONST(0), NO_EXTRA },
-   { GL_EDGE_FLAG_ARRAY, ARRAY_BOOL(EdgeFlag.Enabled), NO_EXTRA },
-   { GL_EDGE_FLAG_ARRAY_STRIDE, ARRAY_INT(EdgeFlag.Stride), NO_EXTRA },
-   { GL_EDGE_FLAG_ARRAY_COUNT_EXT, CONST(0), NO_EXTRA },
-
-   /* GL_ARB_texture_compression */
-   { GL_TEXTURE_COMPRESSION_HINT_ARB, CONTEXT_INT(Hint.TextureCompression), NO_EXTRA },
-
-   /* GL_EXT_compiled_vertex_array */
-   { GL_ARRAY_ELEMENT_LOCK_FIRST_EXT, CONTEXT_INT(Array.LockFirst),
-     extra_EXT_compiled_vertex_array },
-   { GL_ARRAY_ELEMENT_LOCK_COUNT_EXT, CONTEXT_INT(Array.LockCount),
-     extra_EXT_compiled_vertex_array },
-
-   /* GL_ARB_transpose_matrix */
-   { GL_TRANSPOSE_MODELVIEW_MATRIX_ARB,
-     CONTEXT_MATRIX_T(ModelviewMatrixStack), NO_EXTRA },
-   { GL_TRANSPOSE_PROJECTION_MATRIX_ARB,
-     CONTEXT_MATRIX_T(ProjectionMatrixStack.Top), NO_EXTRA },
-   { GL_TRANSPOSE_TEXTURE_MATRIX_ARB, CONTEXT_MATRIX_T(TextureMatrixStack), NO_EXTRA },
-
-   /* GL_EXT_secondary_color */
-   { GL_COLOR_SUM_EXT, CONTEXT_BOOL(Fog.ColorSumEnabled),
-     extra_EXT_secondary_color_ARB_vertex_program },
-   { GL_CURRENT_SECONDARY_COLOR_EXT,
-     CONTEXT_FIELD(Current.Attrib[VERT_ATTRIB_COLOR1][0], TYPE_FLOATN_4),
-     extra_EXT_secondary_color_flush_current },
-   { GL_SECONDARY_COLOR_ARRAY_EXT, ARRAY_BOOL(SecondaryColor.Enabled),
-     extra_EXT_secondary_color },
-   { GL_SECONDARY_COLOR_ARRAY_TYPE_EXT, ARRAY_ENUM(SecondaryColor.Type),
-     extra_EXT_secondary_color },
-   { GL_SECONDARY_COLOR_ARRAY_STRIDE_EXT, ARRAY_INT(SecondaryColor.Stride),
-     extra_EXT_secondary_color },
-   { GL_SECONDARY_COLOR_ARRAY_SIZE_EXT, ARRAY_INT(SecondaryColor.Size),
-     extra_EXT_secondary_color },
-
-   /* GL_EXT_fog_coord */
-   { GL_CURRENT_FOG_COORDINATE_EXT,
-     CONTEXT_FLOAT(Current.Attrib[VERT_ATTRIB_FOG][0]),
-     extra_EXT_fog_coord_flush_current },
-   { GL_FOG_COORDINATE_ARRAY_EXT, ARRAY_BOOL(FogCoord.Enabled),
-     extra_EXT_fog_coord },
-   { GL_FOG_COORDINATE_ARRAY_TYPE_EXT, ARRAY_ENUM(FogCoord.Type),
-     extra_EXT_fog_coord },
-   { GL_FOG_COORDINATE_ARRAY_STRIDE_EXT, ARRAY_INT(FogCoord.Stride),
-     extra_EXT_fog_coord },
-   { GL_FOG_COORDINATE_SOURCE_EXT, CONTEXT_ENUM(Fog.FogCoordinateSource),
-     extra_EXT_fog_coord },
-
-   /* GL_IBM_rasterpos_clip */
-   { GL_RASTER_POSITION_UNCLIPPED_IBM,
-     CONTEXT_BOOL(Transform.RasterPositionUnclipped),
-     extra_IBM_rasterpos_clip },
-
-   /* GL_NV_point_sprite */
-   { GL_POINT_SPRITE_R_MODE_NV,
-     CONTEXT_ENUM(Point.SpriteRMode), extra_NV_point_sprite },
-   { GL_POINT_SPRITE_COORD_ORIGIN, CONTEXT_ENUM(Point.SpriteOrigin),
-     extra_NV_point_sprite_ARB_point_sprite },
-
-   /* GL_NV_vertex_program */
-   { GL_VERTEX_PROGRAM_BINDING_NV, LOC_CUSTOM, TYPE_INT, 0,
-     extra_NV_vertex_program },
-   { GL_VERTEX_ATTRIB_ARRAY0_NV, ARRAY_BOOL(VertexAttrib[0].Enabled),
-     extra_NV_vertex_program },
-   { GL_VERTEX_ATTRIB_ARRAY1_NV, ARRAY_BOOL(VertexAttrib[1].Enabled),
-     extra_NV_vertex_program },
-   { GL_VERTEX_ATTRIB_ARRAY2_NV, ARRAY_BOOL(VertexAttrib[2].Enabled),
-     extra_NV_vertex_program },
-   { GL_VERTEX_ATTRIB_ARRAY3_NV, ARRAY_BOOL(VertexAttrib[3].Enabled),
-     extra_NV_vertex_program },
-   { GL_VERTEX_ATTRIB_ARRAY4_NV, ARRAY_BOOL(VertexAttrib[4].Enabled),
-     extra_NV_vertex_program },
-   { GL_VERTEX_ATTRIB_ARRAY5_NV, ARRAY_BOOL(VertexAttrib[5].Enabled),
-     extra_NV_vertex_program },
-   { GL_VERTEX_ATTRIB_ARRAY6_NV, ARRAY_BOOL(VertexAttrib[6].Enabled),
-     extra_NV_vertex_program },
-   { GL_VERTEX_ATTRIB_ARRAY7_NV, ARRAY_BOOL(VertexAttrib[7].Enabled),
-     extra_NV_vertex_program },
-   { GL_VERTEX_ATTRIB_ARRAY8_NV, ARRAY_BOOL(VertexAttrib[8].Enabled),
-     extra_NV_vertex_program },
-   { GL_VERTEX_ATTRIB_ARRAY9_NV, ARRAY_BOOL(VertexAttrib[9].Enabled),
-     extra_NV_vertex_program },
-   { GL_VERTEX_ATTRIB_ARRAY10_NV, ARRAY_BOOL(VertexAttrib[10].Enabled),
-     extra_NV_vertex_program },
-   { GL_VERTEX_ATTRIB_ARRAY11_NV, ARRAY_BOOL(VertexAttrib[11].Enabled),
-     extra_NV_vertex_program },
-   { GL_VERTEX_ATTRIB_ARRAY12_NV, ARRAY_BOOL(VertexAttrib[12].Enabled),
-     extra_NV_vertex_program },
-   { GL_VERTEX_ATTRIB_ARRAY13_NV, ARRAY_BOOL(VertexAttrib[13].Enabled),
-     extra_NV_vertex_program },
-   { GL_VERTEX_ATTRIB_ARRAY14_NV, ARRAY_BOOL(VertexAttrib[14].Enabled),
-     extra_NV_vertex_program },
-   { GL_VERTEX_ATTRIB_ARRAY15_NV, ARRAY_BOOL(VertexAttrib[15].Enabled),
-     extra_NV_vertex_program },
-   { GL_MAP1_VERTEX_ATTRIB0_4_NV, CONTEXT_BOOL(Eval.Map1Attrib[0]),
-     extra_NV_vertex_program },
-   { GL_MAP1_VERTEX_ATTRIB1_4_NV, CONTEXT_BOOL(Eval.Map1Attrib[1]),
-     extra_NV_vertex_program },
-   { GL_MAP1_VERTEX_ATTRIB2_4_NV, CONTEXT_BOOL(Eval.Map1Attrib[2]),
-     extra_NV_vertex_program },
-   { GL_MAP1_VERTEX_ATTRIB3_4_NV, CONTEXT_BOOL(Eval.Map1Attrib[3]),
-     extra_NV_vertex_program },
-   { GL_MAP1_VERTEX_ATTRIB4_4_NV, CONTEXT_BOOL(Eval.Map1Attrib[4]),
-     extra_NV_vertex_program },
-   { GL_MAP1_VERTEX_ATTRIB5_4_NV, CONTEXT_BOOL(Eval.Map1Attrib[5]),
-     extra_NV_vertex_program },
-   { GL_MAP1_VERTEX_ATTRIB6_4_NV, CONTEXT_BOOL(Eval.Map1Attrib[6]),
-     extra_NV_vertex_program },
-   { GL_MAP1_VERTEX_ATTRIB7_4_NV, CONTEXT_BOOL(Eval.Map1Attrib[7]),
-     extra_NV_vertex_program },
-   { GL_MAP1_VERTEX_ATTRIB8_4_NV, CONTEXT_BOOL(Eval.Map1Attrib[8]),
-     extra_NV_vertex_program },
-   { GL_MAP1_VERTEX_ATTRIB9_4_NV, CONTEXT_BOOL(Eval.Map1Attrib[9]),
-     extra_NV_vertex_program },
-   { GL_MAP1_VERTEX_ATTRIB10_4_NV, CONTEXT_BOOL(Eval.Map1Attrib[10]),
-     extra_NV_vertex_program },
-   { GL_MAP1_VERTEX_ATTRIB11_4_NV, CONTEXT_BOOL(Eval.Map1Attrib[11]),
-     extra_NV_vertex_program },
-   { GL_MAP1_VERTEX_ATTRIB12_4_NV, CONTEXT_BOOL(Eval.Map1Attrib[12]),
-     extra_NV_vertex_program },
-   { GL_MAP1_VERTEX_ATTRIB13_4_NV, CONTEXT_BOOL(Eval.Map1Attrib[13]),
-     extra_NV_vertex_program },
-   { GL_MAP1_VERTEX_ATTRIB14_4_NV, CONTEXT_BOOL(Eval.Map1Attrib[14]),
-     extra_NV_vertex_program },
-   { GL_MAP1_VERTEX_ATTRIB15_4_NV, CONTEXT_BOOL(Eval.Map1Attrib[15]),
-     extra_NV_vertex_program },
-
-   /* GL_NV_fragment_program */
-   { GL_FRAGMENT_PROGRAM_NV, CONTEXT_BOOL(FragmentProgram.Enabled),
-     extra_NV_fragment_program },
-   { GL_FRAGMENT_PROGRAM_BINDING_NV, LOC_CUSTOM, TYPE_INT, 0,
-     extra_NV_fragment_program },
-   { GL_MAX_FRAGMENT_PROGRAM_LOCAL_PARAMETERS_NV,
-     CONST(MAX_NV_FRAGMENT_PROGRAM_PARAMS),
-     extra_NV_fragment_program },
-
-   /* GL_NV_texture_rectangle */
-   { GL_TEXTURE_RECTANGLE_NV,
-     LOC_CUSTOM, TYPE_BOOLEAN, 0, extra_NV_texture_rectangle },
-   { GL_TEXTURE_BINDING_RECTANGLE_NV,
-     LOC_CUSTOM, TYPE_INT, TEXTURE_RECT_INDEX, extra_NV_texture_rectangle },
-   { GL_MAX_RECTANGLE_TEXTURE_SIZE_NV,
-     CONTEXT_INT(Const.MaxTextureRectSize), extra_NV_texture_rectangle },
-
-   /* GL_EXT_stencil_two_side */
-   { GL_STENCIL_TEST_TWO_SIDE_EXT, CONTEXT_BOOL(Stencil.TestTwoSide),
-	 extra_EXT_stencil_two_side },
-   { GL_ACTIVE_STENCIL_FACE_EXT, LOC_CUSTOM, TYPE_ENUM, NO_OFFSET, NO_EXTRA },
-
-   /* GL_NV_light_max_exponent */
-   { GL_MAX_SHININESS_NV, CONTEXT_FLOAT(Const.MaxShininess),
-     extra_NV_light_max_exponent },
-   { GL_MAX_SPOT_EXPONENT_NV, CONTEXT_FLOAT(Const.MaxSpotExponent),
-     extra_NV_light_max_exponent },
-     
-   /* GL_NV_primitive_restart */
-   { GL_PRIMITIVE_RESTART_NV, CONTEXT_BOOL(Array.PrimitiveRestart),
-     extra_NV_primitive_restart },
-   { GL_PRIMITIVE_RESTART_INDEX_NV, CONTEXT_INT(Array.RestartIndex),
-     extra_NV_primitive_restart },
- 
-   /* GL_ARB_vertex_buffer_object */
-   { GL_INDEX_ARRAY_BUFFER_BINDING_ARB, LOC_CUSTOM, TYPE_INT,
-     offsetof(struct gl_array_object, Index.BufferObj), NO_EXTRA },
-   { GL_EDGE_FLAG_ARRAY_BUFFER_BINDING_ARB, LOC_CUSTOM, TYPE_INT,
-     offsetof(struct gl_array_object, EdgeFlag.BufferObj), NO_EXTRA },
-   { GL_SECONDARY_COLOR_ARRAY_BUFFER_BINDING_ARB, LOC_CUSTOM, TYPE_INT,
-     offsetof(struct gl_array_object, SecondaryColor.BufferObj), NO_EXTRA },
-   { GL_FOG_COORDINATE_ARRAY_BUFFER_BINDING_ARB, LOC_CUSTOM, TYPE_INT,
-     offsetof(struct gl_array_object, FogCoord.BufferObj), NO_EXTRA },
-
-   /* GL_EXT_pixel_buffer_object */
-   { GL_PIXEL_PACK_BUFFER_BINDING_EXT, LOC_CUSTOM, TYPE_INT, 0,
-     extra_EXT_pixel_buffer_object },
-   { GL_PIXEL_UNPACK_BUFFER_BINDING_EXT, LOC_CUSTOM, TYPE_INT, 0,
-     extra_EXT_pixel_buffer_object },
-
-   /* GL_ARB_vertex_program */
-   { GL_VERTEX_PROGRAM_ARB, /* == GL_VERTEX_PROGRAM_NV */
-     CONTEXT_BOOL(VertexProgram.Enabled),
-     extra_ARB_vertex_program_NV_vertex_program },
-   { GL_VERTEX_PROGRAM_POINT_SIZE_ARB, /* == GL_VERTEX_PROGRAM_POINT_SIZE_NV*/
-     CONTEXT_BOOL(VertexProgram.PointSizeEnabled),
-     extra_ARB_vertex_program_NV_vertex_program },
-   { GL_VERTEX_PROGRAM_TWO_SIDE_ARB, /* == GL_VERTEX_PROGRAM_TWO_SIDE_NV */
-     CONTEXT_BOOL(VertexProgram.TwoSideEnabled),
-     extra_ARB_vertex_program_NV_vertex_program },
-   { GL_MAX_PROGRAM_MATRIX_STACK_DEPTH_ARB, /* == GL_MAX_TRACK_MATRIX_STACK_DEPTH_NV */
-     CONTEXT_INT(Const.MaxProgramMatrixStackDepth),
-     extra_ARB_vertex_program_ARB_fragment_program_NV_vertex_program },
-   { GL_MAX_PROGRAM_MATRICES_ARB, /* == GL_MAX_TRACK_MATRICES_NV */
-     CONTEXT_INT(Const.MaxProgramMatrices),
-     extra_ARB_vertex_program_ARB_fragment_program_NV_vertex_program },
-   { GL_CURRENT_MATRIX_STACK_DEPTH_ARB, /* == GL_CURRENT_MATRIX_STACK_DEPTH_NV */
-     LOC_CUSTOM, TYPE_INT, 0,
-     extra_ARB_vertex_program_ARB_fragment_program_NV_vertex_program },
-
-   { GL_CURRENT_MATRIX_ARB, /* == GL_CURRENT_MATRIX_NV */
-     LOC_CUSTOM, TYPE_MATRIX, 0,
-     extra_ARB_vertex_program_ARB_fragment_program_NV_vertex_program },
-   { GL_TRANSPOSE_CURRENT_MATRIX_ARB, /* == GL_CURRENT_MATRIX_NV */
-     LOC_CUSTOM, TYPE_MATRIX, 0,
-     extra_ARB_vertex_program_ARB_fragment_program },
-
-   { GL_PROGRAM_ERROR_POSITION_ARB, /* == GL_PROGRAM_ERROR_POSITION_NV */
-     CONTEXT_INT(Program.ErrorPos),
-     extra_NV_vertex_program_ARB_vertex_program_ARB_fragment_program_NV_vertex_program },
-
-   /* GL_ARB_fragment_program */
-   { GL_FRAGMENT_PROGRAM_ARB, CONTEXT_BOOL(FragmentProgram.Enabled),
-     extra_ARB_fragment_program },
-
-   /* GL_EXT_depth_bounds_test */
-   { GL_DEPTH_BOUNDS_TEST_EXT, CONTEXT_BOOL(Depth.BoundsTest),
-     extra_EXT_depth_bounds_test },
-   { GL_DEPTH_BOUNDS_EXT, CONTEXT_FLOAT2(Depth.BoundsMin),
-     extra_EXT_depth_bounds_test },
-
-   /* GL_ARB_depth_clamp*/
-   { GL_DEPTH_CLAMP, CONTEXT_BOOL(Transform.DepthClamp),
-     extra_ARB_depth_clamp },
-
-   /* GL_ARB_draw_buffers */
-   { GL_DRAW_BUFFER0_ARB, BUFFER_ENUM(ColorDrawBuffer[0]), NO_EXTRA },
-   { GL_DRAW_BUFFER1_ARB, BUFFER_ENUM(ColorDrawBuffer[1]),
-     extra_valid_draw_buffer },
-   { GL_DRAW_BUFFER2_ARB, BUFFER_ENUM(ColorDrawBuffer[2]),
-     extra_valid_draw_buffer },
-   { GL_DRAW_BUFFER3_ARB, BUFFER_ENUM(ColorDrawBuffer[3]),
-     extra_valid_draw_buffer },
-   { GL_DRAW_BUFFER4_ARB, BUFFER_ENUM(ColorDrawBuffer[4]),
-     extra_valid_draw_buffer },
-   { GL_DRAW_BUFFER5_ARB, BUFFER_ENUM(ColorDrawBuffer[5]),
-     extra_valid_draw_buffer },
-   { GL_DRAW_BUFFER6_ARB, BUFFER_ENUM(ColorDrawBuffer[6]),
-     extra_valid_draw_buffer },
-   { GL_DRAW_BUFFER7_ARB, BUFFER_ENUM(ColorDrawBuffer[7]),
-     extra_valid_draw_buffer },
-
-   /* GL_ATI_fragment_shader */
-   { GL_NUM_FRAGMENT_REGISTERS_ATI, CONST(6), extra_ATI_fragment_shader },
-   { GL_NUM_FRAGMENT_CONSTANTS_ATI, CONST(8), extra_ATI_fragment_shader },
-   { GL_NUM_PASSES_ATI, CONST(2), extra_ATI_fragment_shader },
-   { GL_NUM_INSTRUCTIONS_PER_PASS_ATI, CONST(8), extra_ATI_fragment_shader },
-   { GL_NUM_INSTRUCTIONS_TOTAL_ATI, CONST(16), extra_ATI_fragment_shader },
-   { GL_COLOR_ALPHA_PAIRING_ATI, CONST(GL_TRUE), extra_ATI_fragment_shader },
-   { GL_NUM_LOOPBACK_COMPONENTS_ATI, CONST(3), extra_ATI_fragment_shader },
-   { GL_NUM_INPUT_INTERPOLATOR_COMPONENTS_ATI,
-     CONST(3), extra_ATI_fragment_shader },
-
-   /* GL_EXT_framebuffer_object */
-   { GL_MAX_COLOR_ATTACHMENTS_EXT, CONTEXT_INT(Const.MaxColorAttachments),
-     extra_EXT_framebuffer_object },
-   
-   /* GL_EXT_framebuffer_blit
-    * NOTE: GL_DRAW_FRAMEBUFFER_BINDING_EXT == GL_FRAMEBUFFER_BINDING_EXT */
-   { GL_READ_FRAMEBUFFER_BINDING_EXT, LOC_CUSTOM, TYPE_INT, 0,
-     extra_EXT_framebuffer_blit },
-
-   /* GL_EXT_provoking_vertex */
-   { GL_PROVOKING_VERTEX_EXT,
-     CONTEXT_BOOL(Light.ProvokingVertex), extra_EXT_provoking_vertex },
-   { GL_QUADS_FOLLOW_PROVOKING_VERTEX_CONVENTION_EXT,
-     CONTEXT_BOOL(Const.QuadsFollowProvokingVertexConvention),
-     extra_EXT_provoking_vertex },
-
-   /* GL_ARB_framebuffer_object */
-   { GL_MAX_SAMPLES, CONTEXT_INT(Const.MaxSamples),
-     extra_ARB_framebuffer_object_EXT_framebuffer_multisample },
-
-   /* GL_APPLE_vertex_array_object */
-   { GL_VERTEX_ARRAY_BINDING_APPLE, ARRAY_INT(Name),
-     extra_APPLE_vertex_array_object },
-
-   /* GL_ARB_seamless_cube_map */
-   { GL_TEXTURE_CUBE_MAP_SEAMLESS,
-     CONTEXT_BOOL(Texture.CubeMapSeamless), extra_ARB_seamless_cube_map },
-
-   /* GL_ARB_sync */
-   { GL_MAX_SERVER_WAIT_TIMEOUT,
-     CONTEXT_INT64(Const.MaxServerWaitTimeout), extra_ARB_sync },
-
-   /* GL_EXT_texture_integer */
-   { GL_RGBA_INTEGER_MODE_EXT, BUFFER_BOOL(_IntegerColor),
-     extra_EXT_texture_integer },
-
-   /* GL_EXT_transform_feedback */
-   { GL_TRANSFORM_FEEDBACK_BUFFER_BINDING, LOC_CUSTOM, TYPE_INT, 0,
-     extra_EXT_transform_feedback },
-   { GL_RASTERIZER_DISCARD, CONTEXT_BOOL(TransformFeedback.RasterDiscard),
-     extra_EXT_transform_feedback },
-   { GL_MAX_TRANSFORM_FEEDBACK_INTERLEAVED_COMPONENTS,
-     CONTEXT_INT(Const.MaxTransformFeedbackInterleavedComponents),
-     extra_EXT_transform_feedback },
-   { GL_MAX_TRANSFORM_FEEDBACK_SEPARATE_ATTRIBS,
-     CONTEXT_INT(Const.MaxTransformFeedbackSeparateAttribs),
-     extra_EXT_transform_feedback },
-   { GL_MAX_TRANSFORM_FEEDBACK_SEPARATE_COMPONENTS,
-     CONTEXT_INT(Const.MaxTransformFeedbackSeparateComponents),
-     extra_EXT_transform_feedback },
-
-   /* GL_ARB_transform_feedback2 */
-   { GL_TRANSFORM_FEEDBACK_BUFFER_PAUSED, LOC_CUSTOM, TYPE_BOOLEAN, 0,
-     extra_ARB_transform_feedback2 },
-   { GL_TRANSFORM_FEEDBACK_BUFFER_ACTIVE, LOC_CUSTOM, TYPE_BOOLEAN, 0,
-     extra_ARB_transform_feedback2 },
-   { GL_TRANSFORM_FEEDBACK_BINDING, LOC_CUSTOM, TYPE_INT, 0,
-     extra_ARB_transform_feedback2 },
-
-   /* GL_ARB_geometry_shader4 */
-   { GL_MAX_GEOMETRY_TEXTURE_IMAGE_UNITS_ARB,
-     CONTEXT_INT(Const.GeometryProgram.MaxGeometryTextureImageUnits),
-     extra_ARB_geometry_shader4 },
-   { GL_MAX_GEOMETRY_OUTPUT_VERTICES_ARB,
-     CONTEXT_INT(Const.GeometryProgram.MaxGeometryOutputVertices),
-     extra_ARB_geometry_shader4 },
-   { GL_MAX_GEOMETRY_TOTAL_OUTPUT_COMPONENTS_ARB,
-     CONTEXT_INT(Const.GeometryProgram.MaxGeometryTotalOutputComponents),
-     extra_ARB_geometry_shader4 },
-   { GL_MAX_GEOMETRY_UNIFORM_COMPONENTS_ARB,
-     CONTEXT_INT(Const.GeometryProgram.MaxGeometryUniformComponents),
-     extra_ARB_geometry_shader4 },
-   { GL_MAX_GEOMETRY_VARYING_COMPONENTS_ARB,
-     CONTEXT_INT(Const.GeometryProgram.MaxGeometryVaryingComponents),
-     extra_ARB_geometry_shader4 },
-   { GL_MAX_VERTEX_VARYING_COMPONENTS_ARB,
-     CONTEXT_INT(Const.GeometryProgram.MaxVertexVaryingComponents),
-     extra_ARB_geometry_shader4 },
-
-   /* GL_EXT_gpu_shader4 / GL 3.0 */
-   { GL_MIN_PROGRAM_TEXEL_OFFSET,
-     CONTEXT_INT(Const.MinProgramTexelOffset),
-     extra_EXT_gpu_shader4 },
-   { GL_MAX_PROGRAM_TEXEL_OFFSET,
-     CONTEXT_INT(Const.MaxProgramTexelOffset),
-     extra_EXT_gpu_shader4 },
-
-   /* GL 3.0 */
-   { GL_NUM_EXTENSIONS, LOC_CUSTOM, TYPE_INT, 0, extra_version_30 },
-   { GL_MAJOR_VERSION, CONTEXT_INT(VersionMajor), extra_version_30 },
-   { GL_MINOR_VERSION, CONTEXT_INT(VersionMinor), extra_version_30  },
-   { GL_CONTEXT_FLAGS, CONTEXT_INT(Const.ContextFlags), extra_version_30  },
-
-   /* GL3.0 / GL_EXT_framebuffer_sRGB */
-   { GL_FRAMEBUFFER_SRGB_EXT, CONTEXT_BOOL(Color.sRGBEnabled), extra_EXT_framebuffer_sRGB },
-   { GL_FRAMEBUFFER_SRGB_CAPABLE_EXT, BUFFER_INT(Visual.sRGBCapable), extra_EXT_framebuffer_sRGB },
-
-   /* GL 3.1 */
-   /* NOTE: different enum values for GL_PRIMITIVE_RESTART_NV
-    * vs. GL_PRIMITIVE_RESTART!
-    */
-   { GL_PRIMITIVE_RESTART, CONTEXT_BOOL(Array.PrimitiveRestart),
-     extra_version_31 },
-   { GL_PRIMITIVE_RESTART_INDEX, CONTEXT_INT(Array.RestartIndex),
-     extra_version_31 },
- 
-
-   /* GL 3.2 */
-   { GL_CONTEXT_PROFILE_MASK, CONTEXT_INT(Const.ProfileMask),
-     extra_version_32 },
-#endif /* FEATURE_GL */
-};
-
-/* All we need now is a way to look up the value struct from the enum.
- * The code generated by gcc for the old generated big switch
- * statement is a big, balanced, open coded if/else tree, essentially
- * an unrolled binary search.  It would be natural to sort the new
- * enum table and use bsearch(), but we will use a read-only hash
- * table instead.  bsearch() has a nice guaranteed worst case
- * performance, but we're also guaranteed to hit that worst case
- * (log2(n) iterations) for about half the enums.  Instead, using an
- * open addressing hash table, we can find the enum on the first try
- * for 80% of the enums, 1 collision for 10% and never more than 5
- * collisions for any enum (typical numbers).  And the code is very
- * simple, even though it feels a little magic. */
-
-static unsigned short table[1024];
-static const int prime_factor = 89, prime_step = 281;
-
-#ifdef GET_DEBUG
-static void
-print_table_stats(void)
-{
-   int i, j, collisions[11], count, hash, mask;
-   const struct value_desc *d;
-
-   count = 0;
-   mask = Elements(table) - 1;
-   memset(collisions, 0, sizeof collisions);
-
-   for (i = 0; i < Elements(table); i++) {
-      if (!table[i])
-	 continue;
-      count++;
-      d = &values[table[i]];
-      hash = (d->pname * prime_factor);
-      j = 0;
-      while (1) {
-	 if (values[table[hash & mask]].pname == d->pname)
-	    break;
-	 hash += prime_step;
-	 j++;
-      }
-
-      if (j < 10)
-	 collisions[j]++;
-      else
-	 collisions[10]++;
-   }
-
-   printf("number of enums: %d (total %d)\n", count, Elements(values));
-   for (i = 0; i < Elements(collisions) - 1; i++)
-      if (collisions[i] > 0)
-	 printf("  %d enums with %d %scollisions\n",
-		collisions[i], i, i == 10 ? "or more " : "");
-}
-#endif
-
-/**
- * Initialize the enum hash for a given API 
- *
- * This is called from one_time_init() to insert the enum values that
- * are valid for the API in question into the enum hash table.
- *
- * \param the current context, for determining the API in question
- */
-void _mesa_init_get_hash(struct gl_context *ctx)
-{
-   int i, hash, index, mask;
-   int api_mask = 0, api_bit;
-
-   mask = Elements(table) - 1;
-   api_bit = 1 << ctx->API;
-
-   for (i = 0; i < Elements(values); i++) {
-      if (values[i].type == TYPE_API_MASK) {
-	 api_mask = values[i].offset;
-	 continue;
-      }
-      if (!(api_mask & api_bit))
-	 continue;
-
-      hash = (values[i].pname * prime_factor) & mask;
-      while (1) {
-	 index = hash & mask;
-	 if (!table[index]) {
-	    table[index] = i;
-	    break;
-	 }
-	 hash += prime_step;
-      }
-   }
-
-#ifdef GET_DEBUG
-   print_table_stats();
-#endif
-}
-
-/**
- * Handle irregular enums
- *
- * Some values don't conform to the "well-known type at context
- * pointer + offset" pattern, so we have this function to catch all
- * the corner cases.  Typically, it's a computed value or a one-off
- * pointer to a custom struct or something.
- *
- * In this case we can't return a pointer to the value, so we'll have
- * to use the temporary variable 'v' declared back in the calling
- * glGet*v() function to store the result.
- *
- * \param ctx the current context
- * \param d the struct value_desc that describes the enum
- * \param v pointer to the tmp declared in the calling glGet*v() function
- */
-static void
-find_custom_value(struct gl_context *ctx, const struct value_desc *d, union value *v)
-{
-   struct gl_buffer_object *buffer_obj;
-   struct gl_client_array *array;
-   GLuint unit, *p;
-
-   switch (d->pname) {
-   case GL_TEXTURE_1D:
-   case GL_TEXTURE_2D:
-   case GL_TEXTURE_3D:
-   case GL_TEXTURE_1D_ARRAY_EXT:
-   case GL_TEXTURE_2D_ARRAY_EXT:
-   case GL_TEXTURE_CUBE_MAP_ARB:
-   case GL_TEXTURE_RECTANGLE_NV:
-      v->value_bool = _mesa_IsEnabled(d->pname);
-      break;
-
-   case GL_LINE_STIPPLE_PATTERN:
-      /* This is the only GLushort, special case it here by promoting
-       * to an int rather than introducing a new type. */
-      v->value_int = ctx->Line.StipplePattern;
-      break;
-
-   case GL_CURRENT_RASTER_TEXTURE_COORDS:
-      unit = ctx->Texture.CurrentUnit;
-      v->value_float_4[0] = ctx->Current.RasterTexCoords[unit][0];
-      v->value_float_4[1] = ctx->Current.RasterTexCoords[unit][1];
-      v->value_float_4[2] = ctx->Current.RasterTexCoords[unit][2];
-      v->value_float_4[3] = ctx->Current.RasterTexCoords[unit][3];
-      break;
-
-   case GL_CURRENT_TEXTURE_COORDS:
-      unit = ctx->Texture.CurrentUnit;
-      v->value_float_4[0] = ctx->Current.Attrib[VERT_ATTRIB_TEX0 + unit][0];
-      v->value_float_4[1] = ctx->Current.Attrib[VERT_ATTRIB_TEX0 + unit][1];
-      v->value_float_4[2] = ctx->Current.Attrib[VERT_ATTRIB_TEX0 + unit][2];
-      v->value_float_4[3] = ctx->Current.Attrib[VERT_ATTRIB_TEX0 + unit][3];
-      break;
-
-   case GL_COLOR_WRITEMASK:
-      v->value_int_4[0] = ctx->Color.ColorMask[0][RCOMP] ? 1 : 0;
-      v->value_int_4[1] = ctx->Color.ColorMask[0][GCOMP] ? 1 : 0;
-      v->value_int_4[2] = ctx->Color.ColorMask[0][BCOMP] ? 1 : 0;
-      v->value_int_4[3] = ctx->Color.ColorMask[0][ACOMP] ? 1 : 0;
-      break;
-
-   case GL_EDGE_FLAG:
-      v->value_bool = ctx->Current.Attrib[VERT_ATTRIB_EDGEFLAG][0] == 1.0;
-      break;
-
-   case GL_READ_BUFFER:
-      v->value_enum = ctx->ReadBuffer->ColorReadBuffer;
-      break;
-
-   case GL_MAP2_GRID_DOMAIN:
-      v->value_float_4[0] = ctx->Eval.MapGrid2u1;
-      v->value_float_4[1] = ctx->Eval.MapGrid2u2;
-      v->value_float_4[2] = ctx->Eval.MapGrid2v1;
-      v->value_float_4[3] = ctx->Eval.MapGrid2v2;
-      break;
-
-   case GL_TEXTURE_STACK_DEPTH:
-      unit = ctx->Texture.CurrentUnit;
-      v->value_int = ctx->TextureMatrixStack[unit].Depth + 1;
-      break;
-   case GL_TEXTURE_MATRIX:
-      unit = ctx->Texture.CurrentUnit;
-      v->value_matrix = ctx->TextureMatrixStack[unit].Top;
-      break;
-
-   case GL_TEXTURE_COORD_ARRAY:
-   case GL_TEXTURE_COORD_ARRAY_SIZE:
-   case GL_TEXTURE_COORD_ARRAY_TYPE:
-   case GL_TEXTURE_COORD_ARRAY_STRIDE:
-      array = &ctx->Array.ArrayObj->TexCoord[ctx->Array.ActiveTexture];
-      v->value_int = *(GLuint *) ((char *) array + d->offset);
-      break;
-
-   case GL_ACTIVE_TEXTURE_ARB:
-      v->value_int = GL_TEXTURE0_ARB + ctx->Texture.CurrentUnit;
-      break;
-   case GL_CLIENT_ACTIVE_TEXTURE_ARB:
-      v->value_int = GL_TEXTURE0_ARB + ctx->Array.ActiveTexture;
-      break;
-
-   case GL_MODELVIEW_STACK_DEPTH:
-   case GL_PROJECTION_STACK_DEPTH:
-      v->value_int = *(GLint *) ((char *) ctx + d->offset) + 1;
-      break;
-
-   case GL_MAX_TEXTURE_SIZE:
-   case GL_MAX_3D_TEXTURE_SIZE:
-   case GL_MAX_CUBE_MAP_TEXTURE_SIZE_ARB:
-      p = (GLuint *) ((char *) ctx + d->offset);
-      v->value_int = 1 << (*p - 1);
-      break;
-
-   case GL_SCISSOR_BOX:
-      v->value_int_4[0] = ctx->Scissor.X;
-      v->value_int_4[1] = ctx->Scissor.Y;
-      v->value_int_4[2] = ctx->Scissor.Width;
-      v->value_int_4[3] = ctx->Scissor.Height;
-      break;
-
-   case GL_LIST_INDEX:
-      v->value_int =
-	 ctx->ListState.CurrentList ? ctx->ListState.CurrentList->Name : 0;
-      break;
-   case GL_LIST_MODE:
-      if (!ctx->CompileFlag)
-	 v->value_enum = 0;
-      else if (ctx->ExecuteFlag)
-	 v->value_enum = GL_COMPILE_AND_EXECUTE;
-      else
-	 v->value_enum = GL_COMPILE;
-      break;
-
-   case GL_VIEWPORT:
-      v->value_int_4[0] = ctx->Viewport.X;
-      v->value_int_4[1] = ctx->Viewport.Y;
-      v->value_int_4[2] = ctx->Viewport.Width;
-      v->value_int_4[3] = ctx->Viewport.Height;
-      break;
-
-   case GL_ACTIVE_STENCIL_FACE_EXT:
-      v->value_enum = ctx->Stencil.ActiveFace ? GL_BACK : GL_FRONT;
-      break;
-
-   case GL_STENCIL_FAIL:
-      v->value_enum = ctx->Stencil.FailFunc[ctx->Stencil.ActiveFace];
-      break;
-   case GL_STENCIL_FUNC:
-      v->value_enum = ctx->Stencil.Function[ctx->Stencil.ActiveFace];
-      break;
-   case GL_STENCIL_PASS_DEPTH_FAIL:
-      v->value_enum = ctx->Stencil.ZFailFunc[ctx->Stencil.ActiveFace];
-      break;
-   case GL_STENCIL_PASS_DEPTH_PASS:
-      v->value_enum = ctx->Stencil.ZPassFunc[ctx->Stencil.ActiveFace];
-      break;
-   case GL_STENCIL_REF:
-      v->value_int = ctx->Stencil.Ref[ctx->Stencil.ActiveFace];
-      break;
-   case GL_STENCIL_VALUE_MASK:
-      v->value_int = ctx->Stencil.ValueMask[ctx->Stencil.ActiveFace];
-      break;
-   case GL_STENCIL_WRITEMASK:
-      v->value_int = ctx->Stencil.WriteMask[ctx->Stencil.ActiveFace];
-      break;
-
-   case GL_NUM_EXTENSIONS:
-      v->value_int = _mesa_get_extension_count(ctx);
-      break;
-
-   case GL_IMPLEMENTATION_COLOR_READ_TYPE_OES:
-      v->value_int = _mesa_get_color_read_type(ctx);
-      break;
-   case GL_IMPLEMENTATION_COLOR_READ_FORMAT_OES:
-      v->value_int = _mesa_get_color_read_format(ctx);
-      break;
-
-   case GL_CURRENT_MATRIX_STACK_DEPTH_ARB:
-      v->value_int = ctx->CurrentStack->Depth + 1;
-      break;
-   case GL_CURRENT_MATRIX_ARB:
-   case GL_TRANSPOSE_CURRENT_MATRIX_ARB:
-      v->value_matrix = ctx->CurrentStack->Top;
-      break;
-
-   case GL_NUM_COMPRESSED_TEXTURE_FORMATS_ARB:
-      v->value_int = _mesa_get_compressed_formats(ctx, NULL, GL_FALSE);
-      break;
-   case GL_COMPRESSED_TEXTURE_FORMATS_ARB:
-      v->value_int_n.n = 
-	 _mesa_get_compressed_formats(ctx, v->value_int_n.ints, GL_FALSE);
-      ASSERT(v->value_int_n.n <= 100);
-      break;
-
-   case GL_MAX_VARYING_FLOATS_ARB:
-      v->value_int = ctx->Const.MaxVarying * 4;
-      break;
-
-   /* Various object names */
-
-   case GL_TEXTURE_BINDING_1D:
-   case GL_TEXTURE_BINDING_2D:
-   case GL_TEXTURE_BINDING_3D:
-   case GL_TEXTURE_BINDING_1D_ARRAY_EXT:
-   case GL_TEXTURE_BINDING_2D_ARRAY_EXT:
-   case GL_TEXTURE_BINDING_CUBE_MAP_ARB:
-   case GL_TEXTURE_BINDING_RECTANGLE_NV:
-      unit = ctx->Texture.CurrentUnit;
-      v->value_int =
-	 ctx->Texture.Unit[unit].CurrentTex[d->offset]->Name;
-      break;
-
-   /* GL_ARB_vertex_buffer_object */
-   case GL_VERTEX_ARRAY_BUFFER_BINDING_ARB:
-   case GL_NORMAL_ARRAY_BUFFER_BINDING_ARB:
-   case GL_COLOR_ARRAY_BUFFER_BINDING_ARB:
-   case GL_INDEX_ARRAY_BUFFER_BINDING_ARB:
-   case GL_EDGE_FLAG_ARRAY_BUFFER_BINDING_ARB:
-   case GL_SECONDARY_COLOR_ARRAY_BUFFER_BINDING_ARB:
-   case GL_FOG_COORDINATE_ARRAY_BUFFER_BINDING_ARB:
-      buffer_obj = (struct gl_buffer_object *)
-	 ((char *) ctx->Array.ArrayObj + d->offset);
-      v->value_int = buffer_obj->Name;
-      break;
-   case GL_ARRAY_BUFFER_BINDING_ARB:
-      v->value_int = ctx->Array.ArrayBufferObj->Name;
-      break;
-   case GL_TEXTURE_COORD_ARRAY_BUFFER_BINDING_ARB:
-      v->value_int =
-	 ctx->Array.ArrayObj->TexCoord[ctx->Array.ActiveTexture].BufferObj->Name;
-      break;
-   case GL_ELEMENT_ARRAY_BUFFER_BINDING_ARB:
-      v->value_int = ctx->Array.ElementArrayBufferObj->Name;
-      break;
-
-   /* ARB_copy_buffer */
-   case GL_COPY_READ_BUFFER:
-      v->value_int = ctx->CopyReadBuffer->Name;
-      break;
-   case GL_COPY_WRITE_BUFFER:
-      v->value_int = ctx->CopyWriteBuffer->Name;
-      break;
-
-   case GL_FRAGMENT_PROGRAM_BINDING_NV:
-      v->value_int = 
-	 ctx->FragmentProgram.Current ? ctx->FragmentProgram.Current->Base.Id : 0;
-      break;
-   case GL_VERTEX_PROGRAM_BINDING_NV:
-      v->value_int =
-	 ctx->VertexProgram.Current ? ctx->VertexProgram.Current->Base.Id : 0;
-      break;
-   case GL_PIXEL_PACK_BUFFER_BINDING_EXT:
-      v->value_int = ctx->Pack.BufferObj->Name;
-      break;
-   case GL_PIXEL_UNPACK_BUFFER_BINDING_EXT:
-      v->value_int = ctx->Unpack.BufferObj->Name;
-      break;
-   case GL_TRANSFORM_FEEDBACK_BUFFER_BINDING:
-      v->value_int = ctx->TransformFeedback.CurrentBuffer->Name;
-      break;
-   case GL_TRANSFORM_FEEDBACK_BUFFER_PAUSED:
-      v->value_int = ctx->TransformFeedback.CurrentObject->Paused;
-      break;
-   case GL_TRANSFORM_FEEDBACK_BUFFER_ACTIVE:
-      v->value_int = ctx->TransformFeedback.CurrentObject->Active;
-      break;
-   case GL_TRANSFORM_FEEDBACK_BINDING:
-      v->value_int = ctx->TransformFeedback.CurrentObject->Name;
-      break;
-   case GL_CURRENT_PROGRAM:
-      v->value_int =
-	 ctx->Shader.ActiveProgram ? ctx->Shader.ActiveProgram->Name : 0;
-      break;
-   case GL_READ_FRAMEBUFFER_BINDING_EXT:
-      v->value_int = ctx->ReadBuffer->Name;
-      break;
-   case GL_RENDERBUFFER_BINDING_EXT:
-      v->value_int =
-	 ctx->CurrentRenderbuffer ? ctx->CurrentRenderbuffer->Name : 0;
-      break;
-   case GL_POINT_SIZE_ARRAY_BUFFER_BINDING_OES:
-      v->value_int = ctx->Array.ArrayObj->PointSize.BufferObj->Name;
-      break;
-
-   case GL_MAX_VERTEX_UNIFORM_VECTORS:
-      v->value_int = ctx->Const.VertexProgram.MaxUniformComponents / 4;
-      break;
-
-   case GL_MAX_FRAGMENT_UNIFORM_VECTORS:
-      v->value_int = ctx->Const.FragmentProgram.MaxUniformComponents / 4;
-      break;
-   }   
-}
-
-/**
- * Check extra constraints on a struct value_desc descriptor
- *
- * If a struct value_desc has a non-NULL extra pointer, it means that
- * there are a number of extra constraints to check or actions to
- * perform.  The extras is just an integer array where each integer
- * encode different constraints or actions.
- *
- * \param ctx current context
- * \param func name of calling glGet*v() function for error reporting
- * \param d the struct value_desc that has the extra constraints
- *
- * \return GL_FALSE if one of the constraints was not satisfied,
- *     otherwise GL_TRUE.
- */
-static GLboolean
-check_extra(struct gl_context *ctx, const char *func, const struct value_desc *d)
-{
-   const GLuint version = ctx->VersionMajor * 10 + ctx->VersionMinor;
-   int total, enabled;
-   const int *e;
-
-   total = 0;
-   enabled = 0;
-   for (e = d->extra; *e != EXTRA_END; e++)
-      switch (*e) {
-      case EXTRA_VERSION_30:
-	 if (version >= 30) {
-	    total++;
-	    enabled++;
-	 }
-	 break;
-      case EXTRA_VERSION_31:
-	 if (version >= 31) {
-	    total++;
-	    enabled++;
-	 }
-	 break;
-      case EXTRA_VERSION_32:
-	 if (version >= 32) {
-	    total++;
-	    enabled++;
-	 }
-	 break;
-      case EXTRA_VERSION_ES2:
-	 if (ctx->API == API_OPENGLES2) {
-	    total++;
-	    enabled++;
-	 }
-	 break;
-      case EXTRA_NEW_BUFFERS:
-	 if (ctx->NewState & _NEW_BUFFERS)
-	    _mesa_update_state(ctx);
-	 break;
-      case EXTRA_FLUSH_CURRENT:
-	 FLUSH_CURRENT(ctx, 0);
-	 break;
-      case EXTRA_VALID_DRAW_BUFFER:
-	 if (d->pname - GL_DRAW_BUFFER0_ARB >= ctx->Const.MaxDrawBuffers) {
-	    _mesa_error(ctx, GL_INVALID_OPERATION, "%s(draw buffer %u)",
-			func, d->pname - GL_DRAW_BUFFER0_ARB);
-	    return GL_FALSE;
-	 }
-	 break;
-      case EXTRA_VALID_TEXTURE_UNIT:
-	 if (ctx->Texture.CurrentUnit >= ctx->Const.MaxTextureCoordUnits) {
-	    _mesa_error(ctx, GL_INVALID_OPERATION, "%s(texture %u)",
-			func, ctx->Texture.CurrentUnit);
-	    return GL_FALSE;
-	 }
-	 break;
-      case EXTRA_END:
-	 break;
-      default: /* *e is a offset into the extension struct */
-	 total++;
-	 if (*(GLboolean *) ((char *) &ctx->Extensions + *e))
-	    enabled++;
-	 break;
-      }
-
-   if (total > 0 && enabled == 0) {
-      _mesa_error(ctx, GL_INVALID_ENUM, "%s(pname=%s)", func,
-                  _mesa_lookup_enum_by_nr(d->pname));
-      return GL_FALSE;
-   }
-
-   return GL_TRUE;
-}
-
-static const struct value_desc error_value =
-   { 0, 0, TYPE_INVALID, NO_OFFSET, NO_EXTRA };
-
-/**
- * Find the struct value_desc corresponding to the enum 'pname'.
- * 
- * We hash the enum value to get an index into the 'table' array,
- * which holds the index in the 'values' array of struct value_desc.
- * Once we've found the entry, we do the extra checks, if any, then
- * look up the value and return a pointer to it.
- *
- * If the value has to be computed (for example, it's the result of a
- * function call or we need to add 1 to it), we use the tmp 'v' to
- * store the result.
- * 
- * \param func name of glGet*v() func for error reporting
- * \param pname the enum value we're looking up
- * \param p is were we return the pointer to the value
- * \param v a tmp union value variable in the calling glGet*v() function
- *
- * \return the struct value_desc corresponding to the enum or a struct
- *     value_desc of TYPE_INVALID if not found.  This lets the calling
- *     glGet*v() function jump right into a switch statement and
- *     handle errors there instead of having to check for NULL.
- */
-static const struct value_desc *
-find_value(const char *func, GLenum pname, void **p, union value *v)
-{
-   GET_CURRENT_CONTEXT(ctx);
-   struct gl_texture_unit *unit;
-   int mask, hash;
-   const struct value_desc *d;
-
-   mask = Elements(table) - 1;
-   hash = (pname * prime_factor);
-   while (1) {
-      d = &values[table[hash & mask]];
-
-      /* If the enum isn't valid, the hash walk ends with index 0,
-       * which is the API mask entry at the beginning of values[]. */
-      if (unlikely(d->type == TYPE_API_MASK)) {
-	 _mesa_error(ctx, GL_INVALID_ENUM, "%s(pname=%s)", func,
-                     _mesa_lookup_enum_by_nr(pname));
-	 return &error_value;
-      }
-
-      if (likely(d->pname == pname))
-	 break;
-
-      hash += prime_step;
-   }
-
-   if (unlikely(d->extra && !check_extra(ctx, func, d)))
-      return &error_value;
-
-   switch (d->location) {
-   case LOC_BUFFER:
-      *p = ((char *) ctx->DrawBuffer + d->offset);
-      return d;
-   case LOC_CONTEXT:
-      *p = ((char *) ctx + d->offset);
-      return d;
-   case LOC_ARRAY:
-      *p = ((char *) ctx->Array.ArrayObj + d->offset);
-      return d;
-   case LOC_TEXUNIT:
-      unit = &ctx->Texture.Unit[ctx->Texture.CurrentUnit];
-      *p = ((char *) unit + d->offset);
-      return d;
-   case LOC_CUSTOM:
-      find_custom_value(ctx, d, v);
-      *p = v;
-      return d;
-   default:
-      assert(0);
-      break;
-   }
-
-   /* silence warning */
-   return &error_value;
-}
-
-static const int transpose[] = {
-   0, 4,  8, 12,
-   1, 5,  9, 13,
-   2, 6, 10, 14,
-   3, 7, 11, 15
-};
-
-void GLAPIENTRY
-_mesa_GetBooleanv(GLenum pname, GLboolean *params)
-{
-   const struct value_desc *d;
-   union value v;
-   GLmatrix *m;
-   int shift, i;
-   void *p;
-
-   d = find_value("glGetBooleanv", pname, &p, &v);
-   switch (d->type) {
-   case TYPE_INVALID:
-      break;
-   case TYPE_CONST:
-      params[0] = INT_TO_BOOLEAN(d->offset);
-      break;
-
-   case TYPE_FLOAT_4:
-   case TYPE_FLOATN_4:
-      params[3] = FLOAT_TO_BOOLEAN(((GLfloat *) p)[3]);
-   case TYPE_FLOAT_3:
-   case TYPE_FLOATN_3:
-      params[2] = FLOAT_TO_BOOLEAN(((GLfloat *) p)[2]);
-   case TYPE_FLOAT_2:
-   case TYPE_FLOATN_2:
-      params[1] = FLOAT_TO_BOOLEAN(((GLfloat *) p)[1]);
-   case TYPE_FLOAT:
-   case TYPE_FLOATN:
-      params[0] = FLOAT_TO_BOOLEAN(((GLfloat *) p)[0]);
-      break;
-
-   case TYPE_DOUBLEN:
-      params[0] = FLOAT_TO_BOOLEAN(((GLdouble *) p)[0]);
-      break;
-
-   case TYPE_INT_4:
-      params[3] = INT_TO_BOOLEAN(((GLint *) p)[3]);
-   case TYPE_INT_3:
-      params[2] = INT_TO_BOOLEAN(((GLint *) p)[2]);
-   case TYPE_INT_2:
-   case TYPE_ENUM_2:
-      params[1] = INT_TO_BOOLEAN(((GLint *) p)[1]);
-   case TYPE_INT:
-   case TYPE_ENUM:
-      params[0] = INT_TO_BOOLEAN(((GLint *) p)[0]);
-      break;
-
-   case TYPE_INT_N:
-      for (i = 0; i < v.value_int_n.n; i++)
-	 params[i] = INT_TO_BOOLEAN(v.value_int_n.ints[i]);
-      break;
-
-   case TYPE_INT64:
-      params[0] = INT64_TO_BOOLEAN(((GLint64 *) p)[0]);
-      break;
-
-   case TYPE_BOOLEAN:
-      params[0] = ((GLboolean*) p)[0];
-      break;		
-
-   case TYPE_MATRIX:
-      m = *(GLmatrix **) p;
-      for (i = 0; i < 16; i++)
-	 params[i] = FLOAT_TO_BOOLEAN(m->m[i]);
-      break;
-
-   case TYPE_MATRIX_T:
-      m = *(GLmatrix **) p;
-      for (i = 0; i < 16; i++)
-	 params[i] = FLOAT_TO_BOOLEAN(m->m[transpose[i]]);
-      break;
-
-   case TYPE_BIT_0:
-   case TYPE_BIT_1:
-   case TYPE_BIT_2:
-   case TYPE_BIT_3:
-   case TYPE_BIT_4:
-   case TYPE_BIT_5:
-      shift = d->type - TYPE_BIT_0;
-      params[0] = (*(GLbitfield *) p >> shift) & 1;
-      break;
-   }
-}
-
-void GLAPIENTRY
-_mesa_GetFloatv(GLenum pname, GLfloat *params)
-{
-   const struct value_desc *d;
-   union value v;
-   GLmatrix *m;
-   int shift, i;
-   void *p;
-
-   d = find_value("glGetFloatv", pname, &p, &v);
-   switch (d->type) {
-   case TYPE_INVALID:
-      break;
-   case TYPE_CONST:
-      params[0] = (GLfloat) d->offset;
-      break;
-
-   case TYPE_FLOAT_4:
-   case TYPE_FLOATN_4:
-      params[3] = ((GLfloat *) p)[3];
-   case TYPE_FLOAT_3:
-   case TYPE_FLOATN_3:
-      params[2] = ((GLfloat *) p)[2];
-   case TYPE_FLOAT_2:
-   case TYPE_FLOATN_2:
-      params[1] = ((GLfloat *) p)[1];
-   case TYPE_FLOAT:
-   case TYPE_FLOATN:
-      params[0] = ((GLfloat *) p)[0];
-      break;
-
-   case TYPE_DOUBLEN:
-      params[0] = ((GLdouble *) p)[0];
-      break;
-
-   case TYPE_INT_4:
-      params[3] = (GLfloat) (((GLint *) p)[3]);
-   case TYPE_INT_3:
-      params[2] = (GLfloat) (((GLint *) p)[2]);
-   case TYPE_INT_2:
-   case TYPE_ENUM_2:
-      params[1] = (GLfloat) (((GLint *) p)[1]);
-   case TYPE_INT:
-   case TYPE_ENUM:
-      params[0] = (GLfloat) (((GLint *) p)[0]);
-      break;
-
-   case TYPE_INT_N:
-      for (i = 0; i < v.value_int_n.n; i++)
-	 params[i] = INT_TO_FLOAT(v.value_int_n.ints[i]);
-      break;
-
-   case TYPE_INT64:
-      params[0] = ((GLint64 *) p)[0];
-      break;
-
-   case TYPE_BOOLEAN:
-      params[0] = BOOLEAN_TO_FLOAT(*(GLboolean*) p);
-      break;		
-
-   case TYPE_MATRIX:
-      m = *(GLmatrix **) p;
-      for (i = 0; i < 16; i++)
-	 params[i] = m->m[i];
-      break;
-
-   case TYPE_MATRIX_T:
-      m = *(GLmatrix **) p;
-      for (i = 0; i < 16; i++)
-	 params[i] = m->m[transpose[i]];
-      break;
-
-   case TYPE_BIT_0:
-   case TYPE_BIT_1:
-   case TYPE_BIT_2:
-   case TYPE_BIT_3:
-   case TYPE_BIT_4:
-   case TYPE_BIT_5:
-      shift = d->type - TYPE_BIT_0;
-      params[0] = BOOLEAN_TO_FLOAT((*(GLbitfield *) p >> shift) & 1);
-      break;
-   }
-}
-
-void GLAPIENTRY
-_mesa_GetIntegerv(GLenum pname, GLint *params)
-{
-   const struct value_desc *d;
-   union value v;
-   GLmatrix *m;
-   int shift, i;
-   void *p;
-
-   d = find_value("glGetIntegerv", pname, &p, &v);
-   switch (d->type) {
-   case TYPE_INVALID:
-      break;
-   case TYPE_CONST:
-      params[0] = d->offset;
-      break;
-
-   case TYPE_FLOAT_4:
-      params[3] = IROUND(((GLfloat *) p)[3]);
-   case TYPE_FLOAT_3:
-      params[2] = IROUND(((GLfloat *) p)[2]);
-   case TYPE_FLOAT_2:
-      params[1] = IROUND(((GLfloat *) p)[1]);
-   case TYPE_FLOAT:
-      params[0] = IROUND(((GLfloat *) p)[0]);
-      break;
-
-   case TYPE_FLOATN_4:
-      params[3] = FLOAT_TO_INT(((GLfloat *) p)[3]);
-   case TYPE_FLOATN_3:
-      params[2] = FLOAT_TO_INT(((GLfloat *) p)[2]);
-   case TYPE_FLOATN_2:
-      params[1] = FLOAT_TO_INT(((GLfloat *) p)[1]);
-   case TYPE_FLOATN:
-      params[0] = FLOAT_TO_INT(((GLfloat *) p)[0]);
-      break;
-
-   case TYPE_DOUBLEN:
-      params[0] = FLOAT_TO_INT(((GLdouble *) p)[0]);
-      break;
-
-   case TYPE_INT_4:
-      params[3] = ((GLint *) p)[3];
-   case TYPE_INT_3:
-      params[2] = ((GLint *) p)[2];
-   case TYPE_INT_2:
-   case TYPE_ENUM_2:
-      params[1] = ((GLint *) p)[1];
-   case TYPE_INT:
-   case TYPE_ENUM:
-      params[0] = ((GLint *) p)[0];
-      break;
-
-   case TYPE_INT_N:
-      for (i = 0; i < v.value_int_n.n; i++)
-	 params[i] = v.value_int_n.ints[i];
-      break;
-
-   case TYPE_INT64:
-      params[0] = INT64_TO_INT(((GLint64 *) p)[0]);
-      break;
-
-   case TYPE_BOOLEAN:
-      params[0] = BOOLEAN_TO_INT(*(GLboolean*) p);
-      break;		
-
-   case TYPE_MATRIX:
-      m = *(GLmatrix **) p;
-      for (i = 0; i < 16; i++)
-	 params[i] = FLOAT_TO_INT(m->m[i]);
-      break;
-
-   case TYPE_MATRIX_T:
-      m = *(GLmatrix **) p;
-      for (i = 0; i < 16; i++)
-	 params[i] = FLOAT_TO_INT(m->m[transpose[i]]);
-      break;
-
-   case TYPE_BIT_0:
-   case TYPE_BIT_1:
-   case TYPE_BIT_2:
-   case TYPE_BIT_3:
-   case TYPE_BIT_4:
-   case TYPE_BIT_5:
-      shift = d->type - TYPE_BIT_0;
-      params[0] = (*(GLbitfield *) p >> shift) & 1;
-      break;
-   }
-}
-
-#if FEATURE_ARB_sync
-void GLAPIENTRY
-_mesa_GetInteger64v(GLenum pname, GLint64 *params)
-{
-   const struct value_desc *d;
-   union value v;
-   GLmatrix *m;
-   int shift, i;
-   void *p;
-
-   d = find_value("glGetInteger64v", pname, &p, &v);
-   switch (d->type) {
-   case TYPE_INVALID:
-      break;
-   case TYPE_CONST:
-      params[0] = d->offset;
-      break;
-
-   case TYPE_FLOAT_4:
-      params[3] = IROUND64(((GLfloat *) p)[3]);
-   case TYPE_FLOAT_3:
-      params[2] = IROUND64(((GLfloat *) p)[2]);
-   case TYPE_FLOAT_2:
-      params[1] = IROUND64(((GLfloat *) p)[1]);
-   case TYPE_FLOAT:
-      params[0] = IROUND64(((GLfloat *) p)[0]);
-      break;
-
-   case TYPE_FLOATN_4:
-      params[3] = FLOAT_TO_INT64(((GLfloat *) p)[3]);
-   case TYPE_FLOATN_3:
-      params[2] = FLOAT_TO_INT64(((GLfloat *) p)[2]);
-   case TYPE_FLOATN_2:
-      params[1] = FLOAT_TO_INT64(((GLfloat *) p)[1]);
-   case TYPE_FLOATN:
-      params[0] = FLOAT_TO_INT64(((GLfloat *) p)[0]);
-      break;
-
-   case TYPE_DOUBLEN:
-      params[0] = FLOAT_TO_INT64(((GLdouble *) p)[0]);
-      break;
-
-   case TYPE_INT_4:
-      params[3] = ((GLint *) p)[3];
-   case TYPE_INT_3:
-      params[2] = ((GLint *) p)[2];
-   case TYPE_INT_2:
-   case TYPE_ENUM_2:
-      params[1] = ((GLint *) p)[1];
-   case TYPE_INT:
-   case TYPE_ENUM:
-      params[0] = ((GLint *) p)[0];
-      break;
-
-   case TYPE_INT_N:
-      for (i = 0; i < v.value_int_n.n; i++)
-	 params[i] = INT_TO_BOOLEAN(v.value_int_n.ints[i]);
-      break;
-
-   case TYPE_INT64:
-      params[0] = ((GLint64 *) p)[0];
-      break;
-
-   case TYPE_BOOLEAN:
-      params[0] = ((GLboolean*) p)[0];
-      break;		
-
-   case TYPE_MATRIX:
-      m = *(GLmatrix **) p;
-      for (i = 0; i < 16; i++)
-	 params[i] = FLOAT_TO_INT64(m->m[i]);
-      break;
-
-   case TYPE_MATRIX_T:
-      m = *(GLmatrix **) p;
-      for (i = 0; i < 16; i++)
-	 params[i] = FLOAT_TO_INT64(m->m[transpose[i]]);
-      break;
-
-   case TYPE_BIT_0:
-   case TYPE_BIT_1:
-   case TYPE_BIT_2:
-   case TYPE_BIT_3:
-   case TYPE_BIT_4:
-   case TYPE_BIT_5:
-      shift = d->type - TYPE_BIT_0;
-      params[0] = (*(GLbitfield *) p >> shift) & 1;
-      break;
-   }
-}
-#endif /* FEATURE_ARB_sync */
-
-void GLAPIENTRY
-_mesa_GetDoublev(GLenum pname, GLdouble *params)
-{
-   const struct value_desc *d;
-   union value v;
-   GLmatrix *m;
-   int shift, i;
-   void *p;
-
-   d = find_value("glGetDoublev", pname, &p, &v);
-   switch (d->type) {
-   case TYPE_INVALID:
-      break;
-   case TYPE_CONST:
-      params[0] = d->offset;
-      break;
-
-   case TYPE_FLOAT_4:
-   case TYPE_FLOATN_4:
-      params[3] = ((GLfloat *) p)[3];
-   case TYPE_FLOAT_3:
-   case TYPE_FLOATN_3:
-      params[2] = ((GLfloat *) p)[2];
-   case TYPE_FLOAT_2:
-   case TYPE_FLOATN_2:
-      params[1] = ((GLfloat *) p)[1];
-   case TYPE_FLOAT:
-   case TYPE_FLOATN:
-      params[0] = ((GLfloat *) p)[0];
-      break;
-
-   case TYPE_DOUBLEN:
-      params[0] = ((GLdouble *) p)[0];
-      break;
-
-   case TYPE_INT_4:
-      params[3] = ((GLint *) p)[3];
-   case TYPE_INT_3:
-      params[2] = ((GLint *) p)[2];
-   case TYPE_INT_2:
-   case TYPE_ENUM_2:
-      params[1] = ((GLint *) p)[1];
-   case TYPE_INT:
-   case TYPE_ENUM:
-      params[0] = ((GLint *) p)[0];
-      break;
-
-   case TYPE_INT_N:
-      for (i = 0; i < v.value_int_n.n; i++)
-	 params[i] = v.value_int_n.ints[i];
-      break;
-
-   case TYPE_INT64:
-      params[0] = ((GLint64 *) p)[0];
-      break;
-
-   case TYPE_BOOLEAN:
-      params[0] = *(GLboolean*) p;
-      break;		
-
-   case TYPE_MATRIX:
-      m = *(GLmatrix **) p;
-      for (i = 0; i < 16; i++)
-	 params[i] = m->m[i];
-      break;
-
-   case TYPE_MATRIX_T:
-      m = *(GLmatrix **) p;
-      for (i = 0; i < 16; i++)
-	 params[i] = m->m[transpose[i]];
-      break;
-
-   case TYPE_BIT_0:
-   case TYPE_BIT_1:
-   case TYPE_BIT_2:
-   case TYPE_BIT_3:
-   case TYPE_BIT_4:
-   case TYPE_BIT_5:
-      shift = d->type - TYPE_BIT_0;
-      params[0] = (*(GLbitfield *) p >> shift) & 1;
-      break;
-   }
-}
-
-static enum value_type
-find_value_indexed(const char *func, GLenum pname, int index, union value *v)
-{
-   GET_CURRENT_CONTEXT(ctx);
-
-   switch (pname) {
-
-   case GL_BLEND:
-      if (index >= ctx->Const.MaxDrawBuffers)
-	 goto invalid_value;
-      if (!ctx->Extensions.EXT_draw_buffers2)
-	 goto invalid_enum;
-      v->value_int = (ctx->Color.BlendEnabled >> index) & 1;
-      return TYPE_INT;
-
-   case GL_BLEND_SRC:
-      /* fall-through */
-   case GL_BLEND_SRC_RGB:
-      if (index >= ctx->Const.MaxDrawBuffers)
-	 goto invalid_value;
-      if (!ctx->Extensions.ARB_draw_buffers_blend)
-	 goto invalid_enum;
-      v->value_int = ctx->Color.Blend[index].SrcRGB;
-      return TYPE_INT;
-   case GL_BLEND_SRC_ALPHA:
-      if (index >= ctx->Const.MaxDrawBuffers)
-	 goto invalid_value;
-      if (!ctx->Extensions.ARB_draw_buffers_blend)
-	 goto invalid_enum;
-      v->value_int = ctx->Color.Blend[index].SrcA;
-      return TYPE_INT;
-   case GL_BLEND_DST:
-      /* fall-through */
-   case GL_BLEND_DST_RGB:
-      if (index >= ctx->Const.MaxDrawBuffers)
-	 goto invalid_value;
-      if (!ctx->Extensions.ARB_draw_buffers_blend)
-	 goto invalid_enum;
-      v->value_int = ctx->Color.Blend[index].DstRGB;
-      return TYPE_INT;
-   case GL_BLEND_DST_ALPHA:
-      if (index >= ctx->Const.MaxDrawBuffers)
-	 goto invalid_value;
-      if (!ctx->Extensions.ARB_draw_buffers_blend)
-	 goto invalid_enum;
-      v->value_int = ctx->Color.Blend[index].DstA;
-      return TYPE_INT;
-   case GL_BLEND_EQUATION_RGB:
-      if (index >= ctx->Const.MaxDrawBuffers)
-	 goto invalid_value;
-      if (!ctx->Extensions.ARB_draw_buffers_blend)
-	 goto invalid_enum;
-      v->value_int = ctx->Color.Blend[index].EquationRGB;
-      return TYPE_INT;
-   case GL_BLEND_EQUATION_ALPHA:
-      if (index >= ctx->Const.MaxDrawBuffers)
-	 goto invalid_value;
-      if (!ctx->Extensions.ARB_draw_buffers_blend)
-	 goto invalid_enum;
-      v->value_int = ctx->Color.Blend[index].EquationA;
-      return TYPE_INT;
-
-   case GL_COLOR_WRITEMASK:
-      if (index >= ctx->Const.MaxDrawBuffers)
-	 goto invalid_value;
-      if (!ctx->Extensions.EXT_draw_buffers2)
-	 goto invalid_enum;
-      v->value_int_4[0] = ctx->Color.ColorMask[index][RCOMP] ? 1 : 0;
-      v->value_int_4[1] = ctx->Color.ColorMask[index][GCOMP] ? 1 : 0;
-      v->value_int_4[2] = ctx->Color.ColorMask[index][BCOMP] ? 1 : 0;
-      v->value_int_4[3] = ctx->Color.ColorMask[index][ACOMP] ? 1 : 0;
-      return TYPE_INT_4;
-
-   case GL_TRANSFORM_FEEDBACK_BUFFER_START:
-      if (index >= ctx->Const.MaxTransformFeedbackSeparateAttribs)
-	 goto invalid_value;
-      if (!ctx->Extensions.EXT_transform_feedback)
-	 goto invalid_enum;
-      v->value_int64 = ctx->TransformFeedback.CurrentObject->Offset[index];
-      return TYPE_INT64;
-
-   case GL_TRANSFORM_FEEDBACK_BUFFER_SIZE:
-      if (index >= ctx->Const.MaxTransformFeedbackSeparateAttribs)
-	 goto invalid_value;
-      if (!ctx->Extensions.EXT_transform_feedback)
-	 goto invalid_enum;
-      v->value_int64 = ctx->TransformFeedback.CurrentObject->Size[index];
-      return TYPE_INT64;
-
-   case GL_TRANSFORM_FEEDBACK_BUFFER_BINDING:
-      if (index >= ctx->Const.MaxTransformFeedbackSeparateAttribs)
-	 goto invalid_value;
-      if (!ctx->Extensions.EXT_transform_feedback)
-	 goto invalid_enum;
-      v->value_int = ctx->TransformFeedback.CurrentObject->Buffers[index]->Name;
-      return TYPE_INT;
-   }
-
- invalid_enum:
-   _mesa_error(ctx, GL_INVALID_ENUM, "%s(pname=%s)", func,
-               _mesa_lookup_enum_by_nr(pname));
-   return TYPE_INVALID;
- invalid_value:
-   _mesa_error(ctx, GL_INVALID_VALUE, "%s(pname=%s)", func,
-               _mesa_lookup_enum_by_nr(pname));
-   return TYPE_INVALID;
-}
-
-void GLAPIENTRY
-_mesa_GetBooleanIndexedv( GLenum pname, GLuint index, GLboolean *params )
-{
-   union value v;
-   enum value_type type =
-      find_value_indexed("glGetBooleanIndexedv", pname, index, &v);
-
-   switch (type) {
-   case TYPE_INT:
-      params[0] = INT_TO_BOOLEAN(v.value_int);
-      break;
-   case TYPE_INT_4:
-      params[0] = INT_TO_BOOLEAN(v.value_int_4[0]);
-      params[1] = INT_TO_BOOLEAN(v.value_int_4[1]);
-      params[2] = INT_TO_BOOLEAN(v.value_int_4[2]);
-      params[3] = INT_TO_BOOLEAN(v.value_int_4[3]);
-      break;
-   case TYPE_INT64:
-      params[0] = INT64_TO_BOOLEAN(v.value_int);
-      break;
-   default:
-      ; /* nothing - GL error was recorded */
-   }
-}
-
-void GLAPIENTRY
-_mesa_GetIntegerIndexedv( GLenum pname, GLuint index, GLint *params )
-{
-   union value v;
-   enum value_type type =
-      find_value_indexed("glGetIntegerIndexedv", pname, index, &v);
-
-   switch (type) {
-   case TYPE_INT:
-      params[0] = v.value_int;
-      break;
-   case TYPE_INT_4:
-      params[0] = v.value_int_4[0];
-      params[1] = v.value_int_4[1];
-      params[2] = v.value_int_4[2];
-      params[3] = v.value_int_4[3];
-      break;
-   case TYPE_INT64:
-      params[0] = INT64_TO_INT(v.value_int);
-      break;
-   default:
-      ; /* nothing - GL error was recorded */
-   }
-}
-
-#if FEATURE_ARB_sync
-void GLAPIENTRY
-_mesa_GetInteger64Indexedv( GLenum pname, GLuint index, GLint64 *params )
-{
-   union value v;
-   enum value_type type =
-      find_value_indexed("glGetIntegerIndexedv", pname, index, &v);      
-
-   switch (type) {
-   case TYPE_INT:
-      params[0] = v.value_int;
-      break;
-   case TYPE_INT_4:
-      params[0] = v.value_int_4[0];
-      params[1] = v.value_int_4[1];
-      params[2] = v.value_int_4[2];
-      params[3] = v.value_int_4[3];
-      break;
-   case TYPE_INT64:
-      params[0] = v.value_int;
-      break;
-   default:
-      ; /* nothing - GL error was recorded */
-   }
-}
-#endif /* FEATURE_ARB_sync */
-
-#if FEATURE_ES1
-void GLAPIENTRY
-_mesa_GetFixedv(GLenum pname, GLfixed *params)
-{
-   const struct value_desc *d;
-   union value v;
-   GLmatrix *m;
-   int shift, i;
-   void *p;
-
-   d = find_value("glGetDoublev", pname, &p, &v);
-   switch (d->type) {
-   case TYPE_INVALID:
-      break;
-   case TYPE_CONST:
-      params[0] = INT_TO_FIXED(d->offset);
-      break;
-
-   case TYPE_FLOAT_4:
-   case TYPE_FLOATN_4:
-      params[3] = FLOAT_TO_FIXED(((GLfloat *) p)[3]);
-   case TYPE_FLOAT_3:
-   case TYPE_FLOATN_3:
-      params[2] = FLOAT_TO_FIXED(((GLfloat *) p)[2]);
-   case TYPE_FLOAT_2:
-   case TYPE_FLOATN_2:
-      params[1] = FLOAT_TO_FIXED(((GLfloat *) p)[1]);
-   case TYPE_FLOAT:
-   case TYPE_FLOATN:
-      params[0] = FLOAT_TO_FIXED(((GLfloat *) p)[0]);
-      break;
-
-   case TYPE_DOUBLEN:
-      params[0] = FLOAT_TO_FIXED(((GLdouble *) p)[0]);
-      break;
-
-   case TYPE_INT_4:
-      params[3] = INT_TO_FIXED(((GLint *) p)[3]);
-   case TYPE_INT_3:
-      params[2] = INT_TO_FIXED(((GLint *) p)[2]);
-   case TYPE_INT_2:
-   case TYPE_ENUM_2:
-      params[1] = INT_TO_FIXED(((GLint *) p)[1]);
-   case TYPE_INT:
-   case TYPE_ENUM:
-      params[0] = INT_TO_FIXED(((GLint *) p)[0]);
-      break;
-
-   case TYPE_INT_N:
-      for (i = 0; i < v.value_int_n.n; i++)
-	 params[i] = INT_TO_FIXED(v.value_int_n.ints[i]);
-      break;
-
-   case TYPE_INT64:
-      params[0] = ((GLint64 *) p)[0];
-      break;
-
-   case TYPE_BOOLEAN:
-      params[0] = BOOLEAN_TO_FIXED(((GLboolean*) p)[0]);
-      break;		
-
-   case TYPE_MATRIX:
-      m = *(GLmatrix **) p;
-      for (i = 0; i < 16; i++)
-	 params[i] = FLOAT_TO_FIXED(m->m[i]);
-      break;
-
-   case TYPE_MATRIX_T:
-      m = *(GLmatrix **) p;
-      for (i = 0; i < 16; i++)
-	 params[i] = FLOAT_TO_FIXED(m->m[transpose[i]]);
-      break;
-
-   case TYPE_BIT_0:
-   case TYPE_BIT_1:
-   case TYPE_BIT_2:
-   case TYPE_BIT_3:
-   case TYPE_BIT_4:
-   case TYPE_BIT_5:
-      shift = d->type - TYPE_BIT_0;
-      params[0] = BOOLEAN_TO_FIXED((*(GLbitfield *) p >> shift) & 1);
-      break;
-   }
-}
-#endif
+/*

+ * Copyright (C) 2010  Brian Paul   All Rights Reserved.

+ * Copyright (C) 2010  Intel Corporation

+ *

+ * 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.

+ *

+ * Author: Kristian Høgsberg <krh@bitplanet.net>

+ */

+

+#include "glheader.h"

+#include "context.h"

+#include "enable.h"

+#include "enums.h"

+#include "extensions.h"

+#include "get.h"

+#include "macros.h"

+#include "mfeatures.h"

+#include "mtypes.h"

+#include "state.h"

+#include "texcompress.h"

+#include "framebuffer.h"

+

+/* This is a table driven implemetation of the glGet*v() functions.

+ * The basic idea is that most getters just look up an int somewhere

+ * in struct gl_context and then convert it to a bool or float according to

+ * which of glGetIntegerv() glGetBooleanv() etc is being called.

+ * Instead of generating code to do this, we can just record the enum

+ * value and the offset into struct gl_context in an array of structs.  Then

+ * in glGet*(), we lookup the struct for the enum in question, and use

+ * the offset to get the int we need.

+ *

+ * Sometimes we need to look up a float, a boolean, a bit in a

+ * bitfield, a matrix or other types instead, so we need to track the

+ * type of the value in struct gl_context.  And sometimes the value isn't in

+ * struct gl_context but in the drawbuffer, the array object, current texture

+ * unit, or maybe it's a computed value.  So we need to also track

+ * where or how to find the value.  Finally, we sometimes need to

+ * check that one of a number of extensions are enabled, the GL

+ * version or flush or call _mesa_update_state().  This is done by

+ * attaching optional extra information to the value description

+ * struct, it's sort of like an array of opcodes that describe extra

+ * checks or actions.

+ *

+ * Putting all this together we end up with struct value_desc below,

+ * and with a couple of macros to help, the table of struct value_desc

+ * is about as concise as the specification in the old python script.

+ */

+

+#undef CONST

+

+#define FLOAT_TO_BOOLEAN(X)   ( (X) ? GL_TRUE : GL_FALSE )

+#define FLOAT_TO_FIXED(F)     ( ((F) * 65536.0f > INT_MAX) ? INT_MAX : \

+                                ((F) * 65536.0f < INT_MIN) ? INT_MIN : \

+                                (GLint) ((F) * 65536.0f) )

+

+#define INT_TO_BOOLEAN(I)     ( (I) ? GL_TRUE : GL_FALSE )

+#define INT_TO_FIXED(I)       ( ((I) > SHRT_MAX) ? INT_MAX : \

+                                ((I) < SHRT_MIN) ? INT_MIN : \

+                                (GLint) ((I) * 65536) )

+

+#define INT64_TO_BOOLEAN(I)   ( (I) ? GL_TRUE : GL_FALSE )

+#define INT64_TO_INT(I)       ( (GLint)((I > INT_MAX) ? INT_MAX : ((I < INT_MIN) ? INT_MIN : (I))) )

+

+#define BOOLEAN_TO_INT(B)     ( (GLint) (B) )

+#define BOOLEAN_TO_INT64(B)   ( (GLint64) (B) )

+#define BOOLEAN_TO_FLOAT(B)   ( (B) ? 1.0F : 0.0F )

+#define BOOLEAN_TO_FIXED(B)   ( (GLint) ((B) ? 1 : 0) << 16 )

+

+#define ENUM_TO_INT64(E)      ( (GLint64) (E) )

+#define ENUM_TO_FIXED(E)      (E)

+

+enum value_type {

+   TYPE_INVALID,

+   TYPE_API_MASK,

+   TYPE_INT,

+   TYPE_INT_2,

+   TYPE_INT_3,

+   TYPE_INT_4,

+   TYPE_INT_N,

+   TYPE_INT64,

+   TYPE_ENUM,

+   TYPE_ENUM_2,

+   TYPE_BOOLEAN,

+   TYPE_BIT_0,

+   TYPE_BIT_1,

+   TYPE_BIT_2,

+   TYPE_BIT_3,

+   TYPE_BIT_4,

+   TYPE_BIT_5,

+   TYPE_FLOAT,

+   TYPE_FLOAT_2,

+   TYPE_FLOAT_3,

+   TYPE_FLOAT_4,

+   TYPE_FLOATN,

+   TYPE_FLOATN_2,

+   TYPE_FLOATN_3,

+   TYPE_FLOATN_4,

+   TYPE_DOUBLEN,

+   TYPE_MATRIX,

+   TYPE_MATRIX_T,

+   TYPE_CONST

+};

+

+enum value_location {

+   LOC_BUFFER,

+   LOC_CONTEXT,

+   LOC_ARRAY,

+   LOC_TEXUNIT,

+   LOC_CUSTOM

+};

+

+enum value_extra {

+   EXTRA_END = 0x8000,

+   EXTRA_VERSION_30,

+   EXTRA_VERSION_31,

+   EXTRA_VERSION_32,

+   EXTRA_VERSION_ES2,

+   EXTRA_NEW_BUFFERS, 

+   EXTRA_VALID_DRAW_BUFFER,

+   EXTRA_VALID_TEXTURE_UNIT,

+   EXTRA_FLUSH_CURRENT,

+};

+

+#define NO_EXTRA NULL

+#define NO_OFFSET 0

+

+struct value_desc {

+   GLenum pname;

+   GLubyte location;  /**< enum value_location */

+   GLubyte type;      /**< enum value_type */

+   int offset;

+   const int *extra;

+};

+

+union value {

+   GLfloat value_float;

+   GLfloat value_float_4[4];

+   GLmatrix *value_matrix;

+   GLint value_int;

+   GLint value_int_4[4];

+   GLint64 value_int64;

+   GLenum value_enum;

+

+   /* Sigh, see GL_COMPRESSED_TEXTURE_FORMATS_ARB handling */

+   struct {

+      GLint n, ints[100];

+   } value_int_n;

+   GLboolean value_bool;

+};

+

+#define BUFFER_FIELD(field, type) \

+   LOC_BUFFER, type, offsetof(struct gl_framebuffer, field)

+#define CONTEXT_FIELD(field, type) \

+   LOC_CONTEXT, type, offsetof(struct gl_context, field)

+#define ARRAY_FIELD(field, type) \

+   LOC_ARRAY, type, offsetof(struct gl_array_object, field)

+#define CONST(value) \

+   LOC_CONTEXT, TYPE_CONST, value

+

+#define BUFFER_INT(field) BUFFER_FIELD(field, TYPE_INT)

+#define BUFFER_ENUM(field) BUFFER_FIELD(field, TYPE_ENUM)

+#define BUFFER_BOOL(field) BUFFER_FIELD(field, TYPE_BOOLEAN)

+

+#define CONTEXT_INT(field) CONTEXT_FIELD(field, TYPE_INT)

+#define CONTEXT_INT2(field) CONTEXT_FIELD(field, TYPE_INT_2)

+#define CONTEXT_INT64(field) CONTEXT_FIELD(field, TYPE_INT64)

+#define CONTEXT_ENUM(field) CONTEXT_FIELD(field, TYPE_ENUM)

+#define CONTEXT_ENUM2(field) CONTEXT_FIELD(field, TYPE_ENUM_2)

+#define CONTEXT_BOOL(field) CONTEXT_FIELD(field, TYPE_BOOLEAN)

+#define CONTEXT_BIT0(field) CONTEXT_FIELD(field, TYPE_BIT_0)

+#define CONTEXT_BIT1(field) CONTEXT_FIELD(field, TYPE_BIT_1)

+#define CONTEXT_BIT2(field) CONTEXT_FIELD(field, TYPE_BIT_2)

+#define CONTEXT_BIT3(field) CONTEXT_FIELD(field, TYPE_BIT_3)

+#define CONTEXT_BIT4(field) CONTEXT_FIELD(field, TYPE_BIT_4)

+#define CONTEXT_BIT5(field) CONTEXT_FIELD(field, TYPE_BIT_5)

+#define CONTEXT_FLOAT(field) CONTEXT_FIELD(field, TYPE_FLOAT)

+#define CONTEXT_FLOAT2(field) CONTEXT_FIELD(field, TYPE_FLOAT_2)

+#define CONTEXT_FLOAT3(field) CONTEXT_FIELD(field, TYPE_FLOAT_3)

+#define CONTEXT_FLOAT4(field) CONTEXT_FIELD(field, TYPE_FLOAT_4)

+#define CONTEXT_MATRIX(field) CONTEXT_FIELD(field, TYPE_MATRIX)

+#define CONTEXT_MATRIX_T(field) CONTEXT_FIELD(field, TYPE_MATRIX_T)

+

+#define ARRAY_INT(field) ARRAY_FIELD(field, TYPE_INT)

+#define ARRAY_ENUM(field) ARRAY_FIELD(field, TYPE_ENUM)

+#define ARRAY_BOOL(field) ARRAY_FIELD(field, TYPE_BOOLEAN)

+

+#define EXT(f)					\

+   offsetof(struct gl_extensions, f)

+

+#define EXTRA_EXT(e)				\

+   static const int extra_##e[] = {		\

+      EXT(e), EXTRA_END				\

+   }

+

+#define EXTRA_EXT2(e1, e2)			\

+   static const int extra_##e1##_##e2[] = {	\

+      EXT(e1), EXT(e2), EXTRA_END		\

+   }

+

+/* The 'extra' mechanism is a way to specify extra checks (such as

+ * extensions or specific gl versions) or actions (flush current, new

+ * buffers) that we need to do before looking up an enum.  We need to

+ * declare them all up front so we can refer to them in the value_desc

+ * structs below. */

+

+static const int extra_new_buffers[] = {

+   EXTRA_NEW_BUFFERS,

+   EXTRA_END

+};

+

+static const int extra_valid_draw_buffer[] = {

+   EXTRA_VALID_DRAW_BUFFER,

+   EXTRA_END

+};

+

+static const int extra_valid_texture_unit[] = {

+   EXTRA_VALID_TEXTURE_UNIT,

+   EXTRA_END

+};

+

+static const int extra_flush_current_valid_texture_unit[] = {

+   EXTRA_FLUSH_CURRENT,

+   EXTRA_VALID_TEXTURE_UNIT,

+   EXTRA_END

+};

+

+static const int extra_flush_current[] = {

+   EXTRA_FLUSH_CURRENT,

+   EXTRA_END

+};

+

+static const int extra_new_buffers_OES_read_format[] = {

+   EXTRA_NEW_BUFFERS,

+   EXT(OES_read_format),

+   EXTRA_END

+};

+

+static const int extra_EXT_secondary_color_flush_current[] = {

+   EXT(EXT_secondary_color),

+   EXTRA_FLUSH_CURRENT,

+   EXTRA_END

+};

+

+static const int extra_EXT_fog_coord_flush_current[] = {

+   EXT(EXT_fog_coord),

+   EXTRA_FLUSH_CURRENT,

+   EXTRA_END

+};

+

+static const int extra_EXT_texture_integer[] = {

+   EXT(EXT_texture_integer),

+   EXTRA_END

+};

+

+static const int extra_EXT_gpu_shader4[] = {

+   EXT(EXT_gpu_shader4),

+   EXTRA_END

+};

+

+

+EXTRA_EXT(ARB_ES2_compatibility);

+EXTRA_EXT(ARB_multitexture);

+EXTRA_EXT(ARB_texture_cube_map);

+EXTRA_EXT(MESA_texture_array);

+EXTRA_EXT2(EXT_secondary_color, ARB_vertex_program);

+EXTRA_EXT(EXT_secondary_color);

+EXTRA_EXT(EXT_fog_coord);

+EXTRA_EXT(EXT_texture_lod_bias);

+EXTRA_EXT(EXT_texture_filter_anisotropic);

+EXTRA_EXT(IBM_rasterpos_clip);

+EXTRA_EXT(NV_point_sprite);

+EXTRA_EXT(SGIS_generate_mipmap);

+EXTRA_EXT(NV_vertex_program);

+EXTRA_EXT(NV_fragment_program);

+EXTRA_EXT(NV_texture_rectangle);

+EXTRA_EXT(EXT_stencil_two_side);

+EXTRA_EXT(NV_light_max_exponent);

+EXTRA_EXT(EXT_depth_bounds_test);

+EXTRA_EXT(ARB_depth_clamp);

+EXTRA_EXT(ATI_fragment_shader);

+EXTRA_EXT(EXT_framebuffer_blit);

+EXTRA_EXT(ARB_shader_objects);

+EXTRA_EXT(EXT_provoking_vertex);

+EXTRA_EXT(ARB_fragment_shader);

+EXTRA_EXT(ARB_fragment_program);

+EXTRA_EXT2(ARB_framebuffer_object, EXT_framebuffer_multisample);

+EXTRA_EXT(EXT_framebuffer_object);

+EXTRA_EXT(APPLE_vertex_array_object);

+EXTRA_EXT(ARB_seamless_cube_map);

+EXTRA_EXT(EXT_compiled_vertex_array);

+EXTRA_EXT(ARB_sync);

+EXTRA_EXT(ARB_vertex_shader);

+EXTRA_EXT(EXT_transform_feedback);

+EXTRA_EXT(ARB_transform_feedback2);

+EXTRA_EXT(EXT_pixel_buffer_object);

+EXTRA_EXT(ARB_vertex_program);

+EXTRA_EXT2(NV_point_sprite, ARB_point_sprite);

+EXTRA_EXT2(ARB_fragment_program, NV_fragment_program);

+EXTRA_EXT2(ARB_vertex_program, NV_vertex_program);

+EXTRA_EXT2(ARB_vertex_program, ARB_fragment_program);

+EXTRA_EXT(ARB_vertex_buffer_object);

+EXTRA_EXT(ARB_geometry_shader4);

+EXTRA_EXT(ARB_copy_buffer);

+EXTRA_EXT(EXT_framebuffer_sRGB);

+

+static const int

+extra_ARB_vertex_program_ARB_fragment_program_NV_vertex_program[] = {

+   EXT(ARB_vertex_program),

+   EXT(ARB_fragment_program),

+   EXT(NV_vertex_program),

+   EXTRA_END

+};

+

+static const int

+extra_NV_vertex_program_ARB_vertex_program_ARB_fragment_program_NV_vertex_program[] = {

+   EXT(NV_vertex_program),

+   EXT(ARB_vertex_program),

+   EXT(ARB_fragment_program),

+   EXT(NV_vertex_program),

+   EXTRA_END

+};

+

+static const int

+extra_NV_primitive_restart[] = {

+   EXT(NV_primitive_restart),

+   EXTRA_END

+};

+

+static const int extra_version_30[] = { EXTRA_VERSION_30, EXTRA_END };

+static const int extra_version_31[] = { EXTRA_VERSION_31, EXTRA_END };

+static const int extra_version_32[] = { EXTRA_VERSION_32, EXTRA_END };

+

+static const int

+extra_ARB_vertex_program_version_es2[] = {

+   EXT(ARB_vertex_program),

+   EXTRA_VERSION_ES2,

+   EXTRA_END

+};

+

+#define API_OPENGL_BIT (1 << API_OPENGL)

+#define API_OPENGLES_BIT (1 << API_OPENGLES)

+#define API_OPENGLES2_BIT (1 << API_OPENGLES2)

+

+/* This is the big table describing all the enums we accept in

+ * glGet*v().  The table is partitioned into six parts: enums

+ * understood by all GL APIs (OpenGL, GLES and GLES2), enums shared

+ * between OpenGL and GLES, enums exclusive to GLES, etc for the

+ * remaining combinations.  When we add the enums to the hash table in

+ * _mesa_init_get_hash(), we only add the enums for the API we're

+ * instantiating and the different sections are guarded by #if

+ * FEATURE_GL etc to make sure we only compile in the enums we may

+ * need. */

+

+static const struct value_desc values[] = {

+   /* Enums shared between OpenGL, GLES1 and GLES2 */

+   { 0, 0, TYPE_API_MASK,

+     API_OPENGL_BIT | API_OPENGLES_BIT | API_OPENGLES2_BIT, NO_EXTRA},

+   { GL_ALPHA_BITS, BUFFER_INT(Visual.alphaBits), extra_new_buffers },

+   { GL_BLEND, CONTEXT_BIT0(Color.BlendEnabled), NO_EXTRA },

+   { GL_BLEND_SRC, CONTEXT_ENUM(Color.Blend[0].SrcRGB), NO_EXTRA },

+   { GL_BLUE_BITS, BUFFER_INT(Visual.blueBits), extra_new_buffers },

+   { GL_COLOR_CLEAR_VALUE, CONTEXT_FIELD(Color.ClearColor[0], TYPE_FLOATN_4), NO_EXTRA },

+   { GL_COLOR_WRITEMASK, LOC_CUSTOM, TYPE_INT_4, 0, NO_EXTRA },

+   { GL_CULL_FACE, CONTEXT_BOOL(Polygon.CullFlag), NO_EXTRA },

+   { GL_CULL_FACE_MODE, CONTEXT_ENUM(Polygon.CullFaceMode), NO_EXTRA },

+   { GL_DEPTH_BITS, BUFFER_INT(Visual.depthBits), NO_EXTRA },

+   { GL_DEPTH_CLEAR_VALUE, CONTEXT_FIELD(Depth.Clear, TYPE_DOUBLEN), NO_EXTRA },

+   { GL_DEPTH_FUNC, CONTEXT_ENUM(Depth.Func), NO_EXTRA },

+   { GL_DEPTH_RANGE, CONTEXT_FIELD(Viewport.Near, TYPE_FLOATN_2), NO_EXTRA },

+   { GL_DEPTH_TEST, CONTEXT_BOOL(Depth.Test), NO_EXTRA },

+   { GL_DEPTH_WRITEMASK, CONTEXT_BOOL(Depth.Mask), NO_EXTRA },

+   { GL_DITHER, CONTEXT_BOOL(Color.DitherFlag), NO_EXTRA },

+   { GL_FRONT_FACE, CONTEXT_ENUM(Polygon.FrontFace), NO_EXTRA },

+   { GL_GREEN_BITS, BUFFER_INT(Visual.greenBits), extra_new_buffers },

+   { GL_LINE_WIDTH, CONTEXT_FLOAT(Line.Width), NO_EXTRA },

+   { GL_ALIASED_LINE_WIDTH_RANGE, CONTEXT_FLOAT2(Const.MinLineWidth), NO_EXTRA },

+   { GL_MAX_ELEMENTS_VERTICES, CONTEXT_INT(Const.MaxArrayLockSize), NO_EXTRA },

+   { GL_MAX_ELEMENTS_INDICES, CONTEXT_INT(Const.MaxArrayLockSize), NO_EXTRA },

+   { GL_MAX_TEXTURE_SIZE, LOC_CUSTOM, TYPE_INT,

+     offsetof(struct gl_context, Const.MaxTextureLevels), NO_EXTRA },

+   { GL_MAX_VIEWPORT_DIMS, CONTEXT_INT2(Const.MaxViewportWidth), NO_EXTRA },

+   { GL_PACK_ALIGNMENT, CONTEXT_INT(Pack.Alignment), NO_EXTRA },

+   { GL_ALIASED_POINT_SIZE_RANGE, CONTEXT_FLOAT2(Const.MinPointSize), NO_EXTRA },

+   { GL_POLYGON_OFFSET_FACTOR, CONTEXT_FLOAT(Polygon.OffsetFactor ), NO_EXTRA },

+   { GL_POLYGON_OFFSET_UNITS, CONTEXT_FLOAT(Polygon.OffsetUnits ), NO_EXTRA },

+   { GL_POLYGON_OFFSET_FILL, CONTEXT_BOOL(Polygon.OffsetFill), NO_EXTRA },

+   { GL_RED_BITS, BUFFER_INT(Visual.redBits), extra_new_buffers },

+   { GL_SCISSOR_BOX, LOC_CUSTOM, TYPE_INT_4, 0, NO_EXTRA },

+   { GL_SCISSOR_TEST, CONTEXT_BOOL(Scissor.Enabled), NO_EXTRA },

+   { GL_STENCIL_BITS, BUFFER_INT(Visual.stencilBits), NO_EXTRA },

+   { GL_STENCIL_CLEAR_VALUE, CONTEXT_INT(Stencil.Clear), NO_EXTRA },

+   { GL_STENCIL_FAIL, LOC_CUSTOM, TYPE_ENUM, NO_OFFSET, NO_EXTRA },

+   { GL_STENCIL_FUNC, LOC_CUSTOM, TYPE_ENUM, NO_OFFSET, NO_EXTRA },

+   { GL_STENCIL_PASS_DEPTH_FAIL, LOC_CUSTOM, TYPE_ENUM, NO_OFFSET, NO_EXTRA },

+   { GL_STENCIL_PASS_DEPTH_PASS, LOC_CUSTOM, TYPE_ENUM, NO_OFFSET, NO_EXTRA },

+   { GL_STENCIL_REF, LOC_CUSTOM, TYPE_INT, NO_OFFSET, NO_EXTRA },

+   { GL_STENCIL_TEST, CONTEXT_BOOL(Stencil.Enabled), NO_EXTRA },

+   { GL_STENCIL_VALUE_MASK, LOC_CUSTOM, TYPE_INT, NO_OFFSET, NO_EXTRA },

+   { GL_STENCIL_WRITEMASK, LOC_CUSTOM, TYPE_INT, NO_OFFSET, NO_EXTRA },

+   { GL_SUBPIXEL_BITS, CONTEXT_INT(Const.SubPixelBits), NO_EXTRA },

+   { GL_TEXTURE_BINDING_2D, LOC_CUSTOM, TYPE_INT, TEXTURE_2D_INDEX, NO_EXTRA },

+   { GL_UNPACK_ALIGNMENT, CONTEXT_INT(Unpack.Alignment), NO_EXTRA },

+   { GL_VIEWPORT, LOC_CUSTOM, TYPE_INT_4, 0, NO_EXTRA },

+

+   /* GL_ARB_multitexture */

+   { GL_ACTIVE_TEXTURE_ARB,

+     LOC_CUSTOM, TYPE_INT, 0, extra_ARB_multitexture },

+

+   /* Note that all the OES_* extensions require that the Mesa "struct

+    * gl_extensions" include a member with the name of the extension.

+    * That structure does not yet include OES extensions (and we're

+    * not sure whether it will).  If it does, all the OES_*

+    * extensions below should mark the dependency. */

+

+   /* GL_ARB_texture_cube_map */

+   { GL_TEXTURE_BINDING_CUBE_MAP_ARB, LOC_CUSTOM, TYPE_INT,

+     TEXTURE_CUBE_INDEX, extra_ARB_texture_cube_map },

+   { GL_MAX_CUBE_MAP_TEXTURE_SIZE_ARB, LOC_CUSTOM, TYPE_INT,

+     offsetof(struct gl_context, Const.MaxCubeTextureLevels),

+     extra_ARB_texture_cube_map }, /* XXX: OES_texture_cube_map */

+

+   /* XXX: OES_blend_subtract */

+   { GL_BLEND_SRC_RGB_EXT, CONTEXT_ENUM(Color.Blend[0].SrcRGB), NO_EXTRA },

+   { GL_BLEND_DST_RGB_EXT, CONTEXT_ENUM(Color.Blend[0].DstRGB), NO_EXTRA },

+   { GL_BLEND_SRC_ALPHA_EXT, CONTEXT_ENUM(Color.Blend[0].SrcA), NO_EXTRA },

+   { GL_BLEND_DST_ALPHA_EXT, CONTEXT_ENUM(Color.Blend[0].DstA), NO_EXTRA },

+

+   /* GL_BLEND_EQUATION_RGB, which is what we're really after, is

+    * defined identically to GL_BLEND_EQUATION. */

+   { GL_BLEND_EQUATION, CONTEXT_ENUM(Color.Blend[0].EquationRGB), NO_EXTRA },

+   { GL_BLEND_EQUATION_ALPHA_EXT, CONTEXT_ENUM(Color.Blend[0].EquationA), NO_EXTRA },

+

+   /* GL_ARB_texture_compression */

+   { GL_NUM_COMPRESSED_TEXTURE_FORMATS_ARB, LOC_CUSTOM, TYPE_INT, 0, NO_EXTRA },

+   { GL_COMPRESSED_TEXTURE_FORMATS_ARB, LOC_CUSTOM, TYPE_INT_N, 0, NO_EXTRA },

+

+   /* GL_ARB_multisample */

+   { GL_SAMPLE_ALPHA_TO_COVERAGE_ARB,

+     CONTEXT_BOOL(Multisample.SampleAlphaToCoverage), NO_EXTRA },

+   { GL_SAMPLE_COVERAGE_ARB, CONTEXT_BOOL(Multisample.SampleCoverage), NO_EXTRA },

+   { GL_SAMPLE_COVERAGE_VALUE_ARB,

+     CONTEXT_FLOAT(Multisample.SampleCoverageValue), NO_EXTRA },

+   { GL_SAMPLE_COVERAGE_INVERT_ARB,

+     CONTEXT_BOOL(Multisample.SampleCoverageInvert), NO_EXTRA },

+   { GL_SAMPLE_BUFFERS_ARB, BUFFER_INT(Visual.sampleBuffers), NO_EXTRA },

+   { GL_SAMPLES_ARB, BUFFER_INT(Visual.samples), NO_EXTRA },

+

+   /* GL_SGIS_generate_mipmap */

+   { GL_GENERATE_MIPMAP_HINT_SGIS, CONTEXT_ENUM(Hint.GenerateMipmap),

+     extra_SGIS_generate_mipmap },

+

+   /* GL_ARB_vertex_buffer_object */

+   { GL_ARRAY_BUFFER_BINDING_ARB, LOC_CUSTOM, TYPE_INT, 0, NO_EXTRA },

+

+   /* GL_ARB_vertex_buffer_object */

+   /* GL_WEIGHT_ARRAY_BUFFER_BINDING_ARB - not supported */

+   { GL_ELEMENT_ARRAY_BUFFER_BINDING_ARB, LOC_CUSTOM, TYPE_INT, 0,

+     extra_ARB_vertex_buffer_object },

+

+   /* GL_ARB_copy_buffer */

+   { GL_COPY_READ_BUFFER, LOC_CUSTOM, TYPE_INT, 0, extra_ARB_copy_buffer },

+   { GL_COPY_WRITE_BUFFER, LOC_CUSTOM, TYPE_INT, 0, extra_ARB_copy_buffer },

+

+   /* GL_OES_read_format */

+   { GL_IMPLEMENTATION_COLOR_READ_TYPE_OES, LOC_CUSTOM, TYPE_INT, 0,

+     extra_new_buffers_OES_read_format },

+   { GL_IMPLEMENTATION_COLOR_READ_FORMAT_OES, LOC_CUSTOM, TYPE_INT, 0,

+     extra_new_buffers_OES_read_format },

+

+   /* GL_EXT_framebuffer_object */

+   { GL_FRAMEBUFFER_BINDING_EXT, BUFFER_INT(Name),

+     extra_EXT_framebuffer_object },

+   { GL_RENDERBUFFER_BINDING_EXT, LOC_CUSTOM, TYPE_INT, 0,

+     extra_EXT_framebuffer_object },

+   { GL_MAX_RENDERBUFFER_SIZE_EXT, CONTEXT_INT(Const.MaxRenderbufferSize),

+     extra_EXT_framebuffer_object },

+

+   /* This entry isn't spec'ed for GLES 2, but is needed for Mesa's

+    * GLSL: */

+   { GL_MAX_CLIP_PLANES, CONTEXT_INT(Const.MaxClipPlanes), NO_EXTRA },

+

+#if FEATURE_GL || FEATURE_ES1

+   /* Enums in OpenGL and GLES1 */

+   { 0, 0, TYPE_API_MASK, API_OPENGL_BIT | API_OPENGLES_BIT, NO_EXTRA },

+   { GL_LIGHT0, CONTEXT_BOOL(Light.Light[0].Enabled), NO_EXTRA },

+   { GL_LIGHT1, CONTEXT_BOOL(Light.Light[1].Enabled), NO_EXTRA },

+   { GL_LIGHT2, CONTEXT_BOOL(Light.Light[2].Enabled), NO_EXTRA },

+   { GL_LIGHT3, CONTEXT_BOOL(Light.Light[3].Enabled), NO_EXTRA },

+   { GL_LIGHT4, CONTEXT_BOOL(Light.Light[4].Enabled), NO_EXTRA },

+   { GL_LIGHT5, CONTEXT_BOOL(Light.Light[5].Enabled), NO_EXTRA },

+   { GL_LIGHT6, CONTEXT_BOOL(Light.Light[6].Enabled), NO_EXTRA },

+   { GL_LIGHT7, CONTEXT_BOOL(Light.Light[7].Enabled), NO_EXTRA },

+   { GL_LIGHTING, CONTEXT_BOOL(Light.Enabled), NO_EXTRA },

+   { GL_LIGHT_MODEL_AMBIENT,

+     CONTEXT_FIELD(Light.Model.Ambient[0], TYPE_FLOATN_4), NO_EXTRA },

+   { GL_LIGHT_MODEL_TWO_SIDE, CONTEXT_BOOL(Light.Model.TwoSide), NO_EXTRA },

+   { GL_ALPHA_TEST, CONTEXT_BOOL(Color.AlphaEnabled), NO_EXTRA },

+   { GL_ALPHA_TEST_FUNC, CONTEXT_ENUM(Color.AlphaFunc), NO_EXTRA },

+   { GL_ALPHA_TEST_REF, CONTEXT_FIELD(Color.AlphaRef, TYPE_FLOATN), NO_EXTRA },

+   { GL_BLEND_DST, CONTEXT_ENUM(Color.Blend[0].DstRGB), NO_EXTRA },

+   { GL_CLIP_PLANE0, CONTEXT_BIT0(Transform.ClipPlanesEnabled), NO_EXTRA },

+   { GL_CLIP_PLANE1, CONTEXT_BIT1(Transform.ClipPlanesEnabled), NO_EXTRA },

+   { GL_CLIP_PLANE2, CONTEXT_BIT2(Transform.ClipPlanesEnabled), NO_EXTRA },

+   { GL_CLIP_PLANE3, CONTEXT_BIT3(Transform.ClipPlanesEnabled), NO_EXTRA },

+   { GL_CLIP_PLANE4, CONTEXT_BIT4(Transform.ClipPlanesEnabled), NO_EXTRA },

+   { GL_CLIP_PLANE5, CONTEXT_BIT5(Transform.ClipPlanesEnabled), NO_EXTRA },

+   { GL_COLOR_MATERIAL, CONTEXT_BOOL(Light.ColorMaterialEnabled), NO_EXTRA },

+   { GL_CURRENT_COLOR,

+     CONTEXT_FIELD(Current.Attrib[VERT_ATTRIB_COLOR0][0], TYPE_FLOATN_4),

+     extra_flush_current },

+   { GL_CURRENT_NORMAL,

+     CONTEXT_FIELD(Current.Attrib[VERT_ATTRIB_NORMAL][0], TYPE_FLOATN_3),

+     extra_flush_current },

+   { GL_CURRENT_TEXTURE_COORDS, LOC_CUSTOM, TYPE_FLOAT_4, 0,

+     extra_flush_current_valid_texture_unit },

+   { GL_DISTANCE_ATTENUATION_EXT, CONTEXT_FLOAT3(Point.Params[0]), NO_EXTRA },

+   { GL_FOG, CONTEXT_BOOL(Fog.Enabled), NO_EXTRA },

+   { GL_FOG_COLOR, CONTEXT_FIELD(Fog.Color[0], TYPE_FLOATN_4), NO_EXTRA },

+   { GL_FOG_DENSITY, CONTEXT_FLOAT(Fog.Density), NO_EXTRA },

+   { GL_FOG_END, CONTEXT_FLOAT(Fog.End), NO_EXTRA },

+   { GL_FOG_HINT, CONTEXT_ENUM(Hint.Fog), NO_EXTRA },

+   { GL_FOG_MODE, CONTEXT_ENUM(Fog.Mode), NO_EXTRA },

+   { GL_FOG_START, CONTEXT_FLOAT(Fog.Start), NO_EXTRA },

+   { GL_LINE_SMOOTH, CONTEXT_BOOL(Line.SmoothFlag), NO_EXTRA },

+   { GL_LINE_SMOOTH_HINT, CONTEXT_ENUM(Hint.LineSmooth), NO_EXTRA },

+   { GL_LINE_WIDTH_RANGE, CONTEXT_FLOAT2(Const.MinLineWidthAA), NO_EXTRA },

+   { GL_COLOR_LOGIC_OP, CONTEXT_BOOL(Color.ColorLogicOpEnabled), NO_EXTRA },

+   { GL_LOGIC_OP_MODE, CONTEXT_ENUM(Color.LogicOp), NO_EXTRA },

+   { GL_MATRIX_MODE, CONTEXT_ENUM(Transform.MatrixMode), NO_EXTRA },

+   { GL_MAX_MODELVIEW_STACK_DEPTH, CONST(MAX_MODELVIEW_STACK_DEPTH), NO_EXTRA },

+   { GL_MAX_PROJECTION_STACK_DEPTH, CONST(MAX_PROJECTION_STACK_DEPTH), NO_EXTRA },

+   { GL_MAX_TEXTURE_STACK_DEPTH, CONST(MAX_TEXTURE_STACK_DEPTH), NO_EXTRA },

+   { GL_MODELVIEW_MATRIX, CONTEXT_MATRIX(ModelviewMatrixStack.Top), NO_EXTRA },

+   { GL_MODELVIEW_STACK_DEPTH, LOC_CUSTOM, TYPE_INT,

+     offsetof(struct gl_context, ModelviewMatrixStack.Depth), NO_EXTRA },

+   { GL_NORMALIZE, CONTEXT_BOOL(Transform.Normalize), NO_EXTRA },

+   { GL_PACK_SKIP_IMAGES_EXT, CONTEXT_INT(Pack.SkipImages), NO_EXTRA },

+   { GL_PERSPECTIVE_CORRECTION_HINT, CONTEXT_ENUM(Hint.PerspectiveCorrection), NO_EXTRA },

+   { GL_POINT_SIZE, CONTEXT_FLOAT(Point.Size), NO_EXTRA },

+   { GL_POINT_SIZE_RANGE, CONTEXT_FLOAT2(Const.MinPointSizeAA), NO_EXTRA },

+   { GL_POINT_SMOOTH, CONTEXT_BOOL(Point.SmoothFlag), NO_EXTRA },

+   { GL_POINT_SMOOTH_HINT, CONTEXT_ENUM(Hint.PointSmooth), NO_EXTRA },

+   { GL_POINT_SIZE_MIN_EXT, CONTEXT_FLOAT(Point.MinSize), NO_EXTRA },

+   { GL_POINT_SIZE_MAX_EXT, CONTEXT_FLOAT(Point.MaxSize), NO_EXTRA },

+   { GL_POINT_FADE_THRESHOLD_SIZE_EXT, CONTEXT_FLOAT(Point.Threshold), NO_EXTRA },

+   { GL_PROJECTION_MATRIX, CONTEXT_MATRIX(ProjectionMatrixStack.Top), NO_EXTRA },

+   { GL_PROJECTION_STACK_DEPTH, LOC_CUSTOM, TYPE_INT,

+     offsetof(struct gl_context, ProjectionMatrixStack.Depth), NO_EXTRA },

+   { GL_RESCALE_NORMAL, CONTEXT_BOOL(Transform.RescaleNormals), NO_EXTRA },

+   { GL_SHADE_MODEL, CONTEXT_ENUM(Light.ShadeModel), NO_EXTRA },

+   { GL_TEXTURE_2D, LOC_CUSTOM, TYPE_BOOLEAN, 0, NO_EXTRA },

+   { GL_TEXTURE_MATRIX, LOC_CUSTOM, TYPE_MATRIX, 0, extra_valid_texture_unit },

+   { GL_TEXTURE_STACK_DEPTH, LOC_CUSTOM, TYPE_INT, 0,

+     extra_valid_texture_unit  },

+

+   { GL_VERTEX_ARRAY, ARRAY_BOOL(Vertex.Enabled), NO_EXTRA },

+   { GL_VERTEX_ARRAY_SIZE, ARRAY_INT(Vertex.Size), NO_EXTRA },

+   { GL_VERTEX_ARRAY_TYPE, ARRAY_ENUM(Vertex.Type), NO_EXTRA },

+   { GL_VERTEX_ARRAY_STRIDE, ARRAY_INT(Vertex.Stride), NO_EXTRA },

+   { GL_NORMAL_ARRAY, ARRAY_ENUM(Normal.Enabled), NO_EXTRA },

+   { GL_NORMAL_ARRAY_TYPE, ARRAY_ENUM(Normal.Type), NO_EXTRA },

+   { GL_NORMAL_ARRAY_STRIDE, ARRAY_INT(Normal.Stride), NO_EXTRA },

+   { GL_COLOR_ARRAY, ARRAY_BOOL(Color.Enabled), NO_EXTRA },

+   { GL_COLOR_ARRAY_SIZE, ARRAY_INT(Color.Size), NO_EXTRA },

+   { GL_COLOR_ARRAY_TYPE, ARRAY_ENUM(Color.Type), NO_EXTRA },

+   { GL_COLOR_ARRAY_STRIDE, ARRAY_INT(Color.Stride), NO_EXTRA },

+   { GL_TEXTURE_COORD_ARRAY,

+     LOC_CUSTOM, TYPE_BOOLEAN, offsetof(struct gl_client_array, Enabled), NO_EXTRA },

+   { GL_TEXTURE_COORD_ARRAY_SIZE,

+     LOC_CUSTOM, TYPE_BOOLEAN, offsetof(struct gl_client_array, Size), NO_EXTRA },

+   { GL_TEXTURE_COORD_ARRAY_TYPE,

+     LOC_CUSTOM, TYPE_BOOLEAN, offsetof(struct gl_client_array, Type), NO_EXTRA },

+   { GL_TEXTURE_COORD_ARRAY_STRIDE,

+     LOC_CUSTOM, TYPE_BOOLEAN, offsetof(struct gl_client_array, Stride), NO_EXTRA },

+

+   /* GL_ARB_ES2_compatibility */

+   { GL_SHADER_COMPILER, CONST(1), extra_ARB_ES2_compatibility },

+   { GL_MAX_VARYING_VECTORS, CONTEXT_INT(Const.MaxVarying),

+     extra_ARB_ES2_compatibility },

+   { GL_MAX_VERTEX_UNIFORM_VECTORS, LOC_CUSTOM, TYPE_INT, 0,

+     extra_ARB_ES2_compatibility },

+   { GL_MAX_FRAGMENT_UNIFORM_VECTORS, LOC_CUSTOM, TYPE_INT, 0,

+     extra_ARB_ES2_compatibility },

+

+   /* GL_ARB_multitexture */

+   { GL_MAX_TEXTURE_UNITS_ARB,

+     CONTEXT_INT(Const.MaxTextureUnits), extra_ARB_multitexture },

+   { GL_CLIENT_ACTIVE_TEXTURE_ARB,

+     LOC_CUSTOM, TYPE_INT, 0, extra_ARB_multitexture },

+

+   /* GL_ARB_texture_cube_map */

+   { GL_TEXTURE_CUBE_MAP_ARB, LOC_CUSTOM, TYPE_BOOLEAN, 0, NO_EXTRA },

+   /* S, T, and R are always set at the same time */

+   { GL_TEXTURE_GEN_STR_OES, LOC_TEXUNIT, TYPE_BIT_0,

+     offsetof(struct gl_texture_unit, TexGenEnabled), NO_EXTRA },

+

+   /* GL_ARB_multisample */

+   { GL_MULTISAMPLE_ARB, CONTEXT_BOOL(Multisample.Enabled), NO_EXTRA },

+   { GL_SAMPLE_ALPHA_TO_ONE_ARB, CONTEXT_BOOL(Multisample.SampleAlphaToOne), NO_EXTRA },

+

+   /* GL_ARB_vertex_buffer_object */

+   { GL_VERTEX_ARRAY_BUFFER_BINDING_ARB, LOC_CUSTOM, TYPE_INT,

+     offsetof(struct gl_array_object, Vertex.BufferObj), NO_EXTRA },

+   { GL_NORMAL_ARRAY_BUFFER_BINDING_ARB, LOC_CUSTOM, TYPE_INT,

+     offsetof(struct gl_array_object, Normal.BufferObj), NO_EXTRA },

+   { GL_COLOR_ARRAY_BUFFER_BINDING_ARB, LOC_CUSTOM, TYPE_INT,

+     offsetof(struct gl_array_object, Color.BufferObj), NO_EXTRA },

+   { GL_TEXTURE_COORD_ARRAY_BUFFER_BINDING_ARB, LOC_CUSTOM, TYPE_INT, NO_OFFSET, NO_EXTRA },

+

+   /* GL_OES_point_sprite */

+   { GL_POINT_SPRITE_NV,

+     CONTEXT_BOOL(Point.PointSprite),

+     extra_NV_point_sprite_ARB_point_sprite },

+

+   /* GL_ARB_fragment_shader */

+   { GL_MAX_FRAGMENT_UNIFORM_COMPONENTS_ARB,

+     CONTEXT_INT(Const.FragmentProgram.MaxUniformComponents),

+     extra_ARB_fragment_shader },

+

+   /* GL_ARB_vertex_shader */

+   { GL_MAX_VERTEX_UNIFORM_COMPONENTS_ARB,

+     CONTEXT_INT(Const.VertexProgram.MaxUniformComponents),

+     extra_ARB_vertex_shader },

+   { GL_MAX_VARYING_FLOATS_ARB, LOC_CUSTOM, TYPE_INT, 0,

+     extra_ARB_vertex_shader },

+

+   /* GL_EXT_texture_lod_bias */

+   { GL_MAX_TEXTURE_LOD_BIAS_EXT, CONTEXT_FLOAT(Const.MaxTextureLodBias),

+	 extra_EXT_texture_lod_bias },

+

+   /* GL_EXT_texture_filter_anisotropic */

+   { GL_MAX_TEXTURE_MAX_ANISOTROPY_EXT,

+     CONTEXT_FLOAT(Const.MaxTextureMaxAnisotropy),

+     extra_EXT_texture_filter_anisotropic },

+#endif /* FEATURE_GL || FEATURE_ES1 */

+

+#if FEATURE_ES1

+   { 0, 0, TYPE_API_MASK, API_OPENGLES_BIT },

+   /* XXX: OES_matrix_get */

+   { GL_MODELVIEW_MATRIX_FLOAT_AS_INT_BITS_OES },

+   { GL_PROJECTION_MATRIX_FLOAT_AS_INT_BITS_OES },

+   { GL_TEXTURE_MATRIX_FLOAT_AS_INT_BITS_OES },

+

+   /* OES_point_size_array */

+   { GL_POINT_SIZE_ARRAY_OES, ARRAY_FIELD(PointSize.Enabled, TYPE_BOOLEAN) },

+   { GL_POINT_SIZE_ARRAY_TYPE_OES, ARRAY_FIELD(PointSize.Type, TYPE_ENUM) },

+   { GL_POINT_SIZE_ARRAY_STRIDE_OES, ARRAY_FIELD(PointSize.Stride, TYPE_INT) },

+   { GL_POINT_SIZE_ARRAY_BUFFER_BINDING_OES, LOC_CUSTOM, TYPE_INT, 0 },

+#endif /* FEATURE_ES1 */

+

+#if FEATURE_GL || FEATURE_ES2

+   { 0, 0, TYPE_API_MASK, API_OPENGL_BIT | API_OPENGLES2_BIT, NO_EXTRA },

+   /* This entry isn't spec'ed for GLES 2, but is needed for Mesa's GLSL: */

+   { GL_MAX_LIGHTS, CONTEXT_INT(Const.MaxLights), NO_EXTRA },

+   { GL_MAX_TEXTURE_COORDS_ARB, /* == GL_MAX_TEXTURE_COORDS_NV */

+     CONTEXT_INT(Const.MaxTextureCoordUnits),

+     extra_ARB_fragment_program_NV_fragment_program },

+

+   /* GL_ARB_draw_buffers */

+   { GL_MAX_DRAW_BUFFERS_ARB, CONTEXT_INT(Const.MaxDrawBuffers), NO_EXTRA },

+

+   { GL_BLEND_COLOR_EXT, CONTEXT_FIELD(Color.BlendColor[0], TYPE_FLOATN_4), NO_EXTRA },

+   /* GL_ARB_fragment_program */

+   { GL_MAX_TEXTURE_IMAGE_UNITS_ARB, /* == GL_MAX_TEXTURE_IMAGE_UNITS_NV */

+     CONTEXT_INT(Const.MaxTextureImageUnits),

+     extra_ARB_fragment_program_NV_fragment_program },

+   { GL_MAX_VERTEX_TEXTURE_IMAGE_UNITS_ARB,

+     CONTEXT_INT(Const.MaxVertexTextureImageUnits), extra_ARB_vertex_shader },

+   { GL_MAX_COMBINED_TEXTURE_IMAGE_UNITS_ARB,

+     CONTEXT_INT(Const.MaxCombinedTextureImageUnits),

+     extra_ARB_vertex_shader },

+

+   /* GL_ARB_shader_objects

+    * Actually, this token isn't part of GL_ARB_shader_objects, but is

+    * close enough for now. */

+   { GL_CURRENT_PROGRAM, LOC_CUSTOM, TYPE_INT, 0, extra_ARB_shader_objects },

+

+   /* OpenGL 2.0 */

+   { GL_STENCIL_BACK_FUNC, CONTEXT_ENUM(Stencil.Function[1]), NO_EXTRA },

+   { GL_STENCIL_BACK_VALUE_MASK, CONTEXT_INT(Stencil.ValueMask[1]), NO_EXTRA },

+   { GL_STENCIL_BACK_WRITEMASK, CONTEXT_INT(Stencil.WriteMask[1]), NO_EXTRA },

+   { GL_STENCIL_BACK_REF, CONTEXT_INT(Stencil.Ref[1]), NO_EXTRA },

+   { GL_STENCIL_BACK_FAIL, CONTEXT_ENUM(Stencil.FailFunc[1]), NO_EXTRA },

+   { GL_STENCIL_BACK_PASS_DEPTH_FAIL, CONTEXT_ENUM(Stencil.ZFailFunc[1]), NO_EXTRA },

+   { GL_STENCIL_BACK_PASS_DEPTH_PASS, CONTEXT_ENUM(Stencil.ZPassFunc[1]), NO_EXTRA },

+

+   { GL_MAX_VERTEX_ATTRIBS_ARB,

+     CONTEXT_INT(Const.VertexProgram.MaxAttribs),

+     extra_ARB_vertex_program_version_es2 },

+

+   /* OES_texture_3D */

+   { GL_TEXTURE_BINDING_3D, LOC_CUSTOM, TYPE_INT, TEXTURE_3D_INDEX, NO_EXTRA },

+   { GL_MAX_3D_TEXTURE_SIZE, LOC_CUSTOM, TYPE_INT,

+     offsetof(struct gl_context, Const.Max3DTextureLevels), NO_EXTRA },

+

+   /* GL_ARB_fragment_program/OES_standard_derivatives */

+   { GL_FRAGMENT_SHADER_DERIVATIVE_HINT_ARB,

+     CONTEXT_ENUM(Hint.FragmentShaderDerivative), extra_ARB_fragment_shader },

+#endif /* FEATURE_GL || FEATURE_ES2 */

+

+#if FEATURE_ES2

+   /* Enums unique to OpenGL ES 2.0 */

+   { 0, 0, TYPE_API_MASK, API_OPENGLES2_BIT, NO_EXTRA },

+   { GL_MAX_FRAGMENT_UNIFORM_VECTORS, LOC_CUSTOM, TYPE_INT, 0, NO_EXTRA },

+   { GL_MAX_VARYING_VECTORS, CONTEXT_INT(Const.MaxVarying), NO_EXTRA },

+   { GL_MAX_VERTEX_UNIFORM_VECTORS, LOC_CUSTOM, TYPE_INT, 0, NO_EXTRA },

+   { GL_SHADER_COMPILER, CONST(1), NO_EXTRA },

+   /* OES_get_program_binary */

+   { GL_NUM_SHADER_BINARY_FORMATS, CONST(0), NO_EXTRA },

+   { GL_SHADER_BINARY_FORMATS, CONST(0), NO_EXTRA },

+#endif /* FEATURE_ES2 */

+

+#if FEATURE_GL

+   /* Remaining enums are only in OpenGL */

+   { 0, 0, TYPE_API_MASK, API_OPENGL_BIT, NO_EXTRA },

+   { GL_ACCUM_RED_BITS, BUFFER_INT(Visual.accumRedBits), NO_EXTRA },

+   { GL_ACCUM_GREEN_BITS, BUFFER_INT(Visual.accumGreenBits), NO_EXTRA },

+   { GL_ACCUM_BLUE_BITS, BUFFER_INT(Visual.accumBlueBits), NO_EXTRA },

+   { GL_ACCUM_ALPHA_BITS, BUFFER_INT(Visual.accumAlphaBits), NO_EXTRA },

+   { GL_ACCUM_CLEAR_VALUE, CONTEXT_FIELD(Accum.ClearColor[0], TYPE_FLOATN_4), NO_EXTRA },

+   { GL_ALPHA_BIAS, CONTEXT_FLOAT(Pixel.AlphaBias), NO_EXTRA },

+   { GL_ALPHA_SCALE, CONTEXT_FLOAT(Pixel.AlphaScale), NO_EXTRA },

+   { GL_ATTRIB_STACK_DEPTH, CONTEXT_INT(AttribStackDepth), NO_EXTRA },

+   { GL_AUTO_NORMAL, CONTEXT_BOOL(Eval.AutoNormal), NO_EXTRA },

+   { GL_AUX_BUFFERS, BUFFER_INT(Visual.numAuxBuffers), NO_EXTRA },

+   { GL_BLUE_BIAS, CONTEXT_FLOAT(Pixel.BlueBias), NO_EXTRA },

+   { GL_BLUE_SCALE, CONTEXT_FLOAT(Pixel.BlueScale), NO_EXTRA },

+   { GL_CLIENT_ATTRIB_STACK_DEPTH, CONTEXT_INT(ClientAttribStackDepth), NO_EXTRA },

+   { GL_COLOR_MATERIAL_FACE, CONTEXT_ENUM(Light.ColorMaterialFace), NO_EXTRA },

+   { GL_COLOR_MATERIAL_PARAMETER, CONTEXT_ENUM(Light.ColorMaterialMode), NO_EXTRA },

+   { GL_CURRENT_INDEX,

+     CONTEXT_FLOAT(Current.Attrib[VERT_ATTRIB_COLOR_INDEX][0]),

+     extra_flush_current },

+   { GL_CURRENT_RASTER_COLOR,

+     CONTEXT_FIELD(Current.RasterColor[0], TYPE_FLOATN_4), NO_EXTRA },

+   { GL_CURRENT_RASTER_DISTANCE, CONTEXT_FLOAT(Current.RasterDistance), NO_EXTRA },

+   { GL_CURRENT_RASTER_INDEX, CONST(1), NO_EXTRA },

+   { GL_CURRENT_RASTER_POSITION, CONTEXT_FLOAT4(Current.RasterPos[0]), NO_EXTRA },

+   { GL_CURRENT_RASTER_SECONDARY_COLOR,

+     CONTEXT_FIELD(Current.RasterSecondaryColor[0], TYPE_FLOATN_4), NO_EXTRA },

+   { GL_CURRENT_RASTER_TEXTURE_COORDS, LOC_CUSTOM, TYPE_FLOAT_4, 0,

+     extra_valid_texture_unit },

+   { GL_CURRENT_RASTER_POSITION_VALID, CONTEXT_BOOL(Current.RasterPosValid), NO_EXTRA },

+   { GL_DEPTH_BIAS, CONTEXT_FLOAT(Pixel.DepthBias), NO_EXTRA },

+   { GL_DEPTH_SCALE, CONTEXT_FLOAT(Pixel.DepthScale), NO_EXTRA },

+   { GL_DOUBLEBUFFER, BUFFER_INT(Visual.doubleBufferMode), NO_EXTRA },

+   { GL_DRAW_BUFFER, BUFFER_ENUM(ColorDrawBuffer[0]), NO_EXTRA },

+   { GL_EDGE_FLAG, LOC_CUSTOM, TYPE_BOOLEAN, 0, NO_EXTRA },

+   { GL_FEEDBACK_BUFFER_SIZE, CONTEXT_INT(Feedback.BufferSize), NO_EXTRA },

+   { GL_FEEDBACK_BUFFER_TYPE, CONTEXT_ENUM(Feedback.Type), NO_EXTRA },

+   { GL_FOG_INDEX, CONTEXT_FLOAT(Fog.Index), NO_EXTRA },

+   { GL_GREEN_BIAS, CONTEXT_FLOAT(Pixel.GreenBias), NO_EXTRA },

+   { GL_GREEN_SCALE, CONTEXT_FLOAT(Pixel.GreenScale), NO_EXTRA },

+   { GL_INDEX_BITS, BUFFER_INT(Visual.indexBits), extra_new_buffers },

+   { GL_INDEX_CLEAR_VALUE, CONTEXT_INT(Color.ClearIndex), NO_EXTRA },

+   { GL_INDEX_MODE, CONST(0) , NO_EXTRA}, 

+   { GL_INDEX_OFFSET, CONTEXT_INT(Pixel.IndexOffset), NO_EXTRA },

+   { GL_INDEX_SHIFT, CONTEXT_INT(Pixel.IndexShift), NO_EXTRA },

+   { GL_INDEX_WRITEMASK, CONTEXT_INT(Color.IndexMask), NO_EXTRA },

+   { GL_LIGHT_MODEL_COLOR_CONTROL, CONTEXT_ENUM(Light.Model.ColorControl), NO_EXTRA },

+   { GL_LIGHT_MODEL_LOCAL_VIEWER, CONTEXT_BOOL(Light.Model.LocalViewer), NO_EXTRA },

+   { GL_LINE_STIPPLE, CONTEXT_BOOL(Line.StippleFlag), NO_EXTRA },

+   { GL_LINE_STIPPLE_PATTERN, LOC_CUSTOM, TYPE_INT, 0, NO_EXTRA },

+   { GL_LINE_STIPPLE_REPEAT, CONTEXT_INT(Line.StippleFactor), NO_EXTRA },

+   { GL_LINE_WIDTH_GRANULARITY, CONTEXT_FLOAT(Const.LineWidthGranularity), NO_EXTRA },

+   { GL_LIST_BASE, CONTEXT_INT(List.ListBase), NO_EXTRA },

+   { GL_LIST_INDEX, LOC_CUSTOM, TYPE_INT, 0, NO_EXTRA },

+   { GL_LIST_MODE, LOC_CUSTOM, TYPE_ENUM, 0, NO_EXTRA },

+   { GL_INDEX_LOGIC_OP, CONTEXT_BOOL(Color.IndexLogicOpEnabled), NO_EXTRA },

+   { GL_MAP1_COLOR_4, CONTEXT_BOOL(Eval.Map1Color4), NO_EXTRA },

+   { GL_MAP1_GRID_DOMAIN, CONTEXT_FLOAT2(Eval.MapGrid1u1), NO_EXTRA },

+   { GL_MAP1_GRID_SEGMENTS, CONTEXT_INT(Eval.MapGrid1un), NO_EXTRA },

+   { GL_MAP1_INDEX, CONTEXT_BOOL(Eval.Map1Index), NO_EXTRA },

+   { GL_MAP1_NORMAL, CONTEXT_BOOL(Eval.Map1Normal), NO_EXTRA },

+   { GL_MAP1_TEXTURE_COORD_1, CONTEXT_BOOL(Eval.Map1TextureCoord1), NO_EXTRA },

+   { GL_MAP1_TEXTURE_COORD_2, CONTEXT_BOOL(Eval.Map1TextureCoord2), NO_EXTRA },

+   { GL_MAP1_TEXTURE_COORD_3, CONTEXT_BOOL(Eval.Map1TextureCoord3), NO_EXTRA },

+   { GL_MAP1_TEXTURE_COORD_4, CONTEXT_BOOL(Eval.Map1TextureCoord4), NO_EXTRA },

+   { GL_MAP1_VERTEX_3, CONTEXT_BOOL(Eval.Map1Vertex3), NO_EXTRA },

+   { GL_MAP1_VERTEX_4, CONTEXT_BOOL(Eval.Map1Vertex4), NO_EXTRA },

+   { GL_MAP2_COLOR_4, CONTEXT_BOOL(Eval.Map2Color4), NO_EXTRA },

+   { GL_MAP2_GRID_DOMAIN, LOC_CUSTOM, TYPE_FLOAT_4, 0, NO_EXTRA },

+   { GL_MAP2_GRID_SEGMENTS, CONTEXT_INT2(Eval.MapGrid2un), NO_EXTRA },

+   { GL_MAP2_INDEX, CONTEXT_BOOL(Eval.Map2Index), NO_EXTRA },

+   { GL_MAP2_NORMAL, CONTEXT_BOOL(Eval.Map2Normal), NO_EXTRA },

+   { GL_MAP2_TEXTURE_COORD_1, CONTEXT_BOOL(Eval.Map2TextureCoord1), NO_EXTRA },

+   { GL_MAP2_TEXTURE_COORD_2, CONTEXT_BOOL(Eval.Map2TextureCoord2), NO_EXTRA },

+   { GL_MAP2_TEXTURE_COORD_3, CONTEXT_BOOL(Eval.Map2TextureCoord3), NO_EXTRA },

+   { GL_MAP2_TEXTURE_COORD_4, CONTEXT_BOOL(Eval.Map2TextureCoord4), NO_EXTRA },

+   { GL_MAP2_VERTEX_3, CONTEXT_BOOL(Eval.Map2Vertex3), NO_EXTRA },

+   { GL_MAP2_VERTEX_4, CONTEXT_BOOL(Eval.Map2Vertex4), NO_EXTRA },

+   { GL_MAP_COLOR, CONTEXT_BOOL(Pixel.MapColorFlag), NO_EXTRA },

+   { GL_MAP_STENCIL, CONTEXT_BOOL(Pixel.MapStencilFlag), NO_EXTRA },

+   { GL_MAX_ATTRIB_STACK_DEPTH, CONST(MAX_ATTRIB_STACK_DEPTH), NO_EXTRA },

+   { GL_MAX_CLIENT_ATTRIB_STACK_DEPTH, CONST(MAX_CLIENT_ATTRIB_STACK_DEPTH), NO_EXTRA },

+

+   { GL_MAX_EVAL_ORDER, CONST(MAX_EVAL_ORDER), NO_EXTRA },

+   { GL_MAX_LIST_NESTING, CONST(MAX_LIST_NESTING), NO_EXTRA },

+   { GL_MAX_NAME_STACK_DEPTH, CONST(MAX_NAME_STACK_DEPTH), NO_EXTRA },

+   { GL_MAX_PIXEL_MAP_TABLE, CONST(MAX_PIXEL_MAP_TABLE), NO_EXTRA },

+   { GL_NAME_STACK_DEPTH, CONTEXT_INT(Select.NameStackDepth), NO_EXTRA },

+   { GL_PACK_LSB_FIRST, CONTEXT_BOOL(Pack.LsbFirst), NO_EXTRA },

+   { GL_PACK_ROW_LENGTH, CONTEXT_INT(Pack.RowLength), NO_EXTRA },

+   { GL_PACK_SKIP_PIXELS, CONTEXT_INT(Pack.SkipPixels), NO_EXTRA },

+   { GL_PACK_SKIP_ROWS, CONTEXT_INT(Pack.SkipRows), NO_EXTRA },

+   { GL_PACK_SWAP_BYTES, CONTEXT_BOOL(Pack.SwapBytes), NO_EXTRA },

+   { GL_PACK_IMAGE_HEIGHT_EXT, CONTEXT_INT(Pack.ImageHeight), NO_EXTRA },

+   { GL_PACK_INVERT_MESA, CONTEXT_BOOL(Pack.Invert), NO_EXTRA },

+   { GL_PIXEL_MAP_A_TO_A_SIZE, CONTEXT_INT(PixelMaps.AtoA.Size), NO_EXTRA },

+   { GL_PIXEL_MAP_B_TO_B_SIZE, CONTEXT_INT(PixelMaps.BtoB.Size), NO_EXTRA },

+   { GL_PIXEL_MAP_G_TO_G_SIZE, CONTEXT_INT(PixelMaps.GtoG.Size), NO_EXTRA },

+   { GL_PIXEL_MAP_I_TO_A_SIZE, CONTEXT_INT(PixelMaps.ItoA.Size), NO_EXTRA },

+   { GL_PIXEL_MAP_I_TO_B_SIZE, CONTEXT_INT(PixelMaps.ItoB.Size), NO_EXTRA },

+   { GL_PIXEL_MAP_I_TO_G_SIZE, CONTEXT_INT(PixelMaps.ItoG.Size), NO_EXTRA },

+   { GL_PIXEL_MAP_I_TO_I_SIZE, CONTEXT_INT(PixelMaps.ItoI.Size), NO_EXTRA },

+   { GL_PIXEL_MAP_I_TO_R_SIZE, CONTEXT_INT(PixelMaps.ItoR.Size), NO_EXTRA },

+   { GL_PIXEL_MAP_R_TO_R_SIZE, CONTEXT_INT(PixelMaps.RtoR.Size), NO_EXTRA },

+   { GL_PIXEL_MAP_S_TO_S_SIZE, CONTEXT_INT(PixelMaps.StoS.Size), NO_EXTRA },

+   { GL_POINT_SIZE_GRANULARITY, CONTEXT_FLOAT(Const.PointSizeGranularity), NO_EXTRA },

+   { GL_POLYGON_MODE, CONTEXT_ENUM2(Polygon.FrontMode), NO_EXTRA },

+   { GL_POLYGON_OFFSET_BIAS_EXT, CONTEXT_FLOAT(Polygon.OffsetUnits), NO_EXTRA },

+   { GL_POLYGON_OFFSET_POINT, CONTEXT_BOOL(Polygon.OffsetPoint), NO_EXTRA },

+   { GL_POLYGON_OFFSET_LINE, CONTEXT_BOOL(Polygon.OffsetLine), NO_EXTRA },

+   { GL_POLYGON_SMOOTH, CONTEXT_BOOL(Polygon.SmoothFlag), NO_EXTRA },

+   { GL_POLYGON_SMOOTH_HINT, CONTEXT_ENUM(Hint.PolygonSmooth), NO_EXTRA },

+   { GL_POLYGON_STIPPLE, CONTEXT_BOOL(Polygon.StippleFlag), NO_EXTRA },

+   { GL_READ_BUFFER, LOC_CUSTOM, TYPE_ENUM, NO_OFFSET, NO_EXTRA },

+   { GL_RED_BIAS, CONTEXT_FLOAT(Pixel.RedBias), NO_EXTRA },

+   { GL_RED_SCALE, CONTEXT_FLOAT(Pixel.RedScale), NO_EXTRA },

+   { GL_RENDER_MODE, CONTEXT_ENUM(RenderMode), NO_EXTRA },

+   { GL_RGBA_MODE, CONST(1), NO_EXTRA },

+   { GL_SELECTION_BUFFER_SIZE, CONTEXT_INT(Select.BufferSize), NO_EXTRA },

+   { GL_SHARED_TEXTURE_PALETTE_EXT, CONTEXT_BOOL(Texture.SharedPalette), NO_EXTRA },

+

+   { GL_STEREO, BUFFER_INT(Visual.stereoMode), NO_EXTRA },

+

+   { GL_TEXTURE_1D, LOC_CUSTOM, TYPE_BOOLEAN, NO_OFFSET, NO_EXTRA },

+   { GL_TEXTURE_3D, LOC_CUSTOM, TYPE_BOOLEAN, NO_OFFSET, NO_EXTRA },

+   { GL_TEXTURE_1D_ARRAY_EXT, LOC_CUSTOM, TYPE_BOOLEAN, NO_OFFSET, NO_EXTRA },

+   { GL_TEXTURE_2D_ARRAY_EXT, LOC_CUSTOM, TYPE_BOOLEAN, NO_OFFSET, NO_EXTRA },

+

+   { GL_TEXTURE_BINDING_1D, LOC_CUSTOM, TYPE_INT, TEXTURE_1D_INDEX, NO_EXTRA },

+   { GL_TEXTURE_BINDING_1D_ARRAY, LOC_CUSTOM, TYPE_INT,

+     TEXTURE_1D_ARRAY_INDEX, extra_MESA_texture_array },

+   { GL_TEXTURE_BINDING_2D_ARRAY, LOC_CUSTOM, TYPE_INT,

+     TEXTURE_1D_ARRAY_INDEX, extra_MESA_texture_array },

+   { GL_MAX_ARRAY_TEXTURE_LAYERS_EXT,

+     CONTEXT_INT(Const.MaxArrayTextureLayers), extra_MESA_texture_array },

+

+   { GL_TEXTURE_GEN_S, LOC_TEXUNIT, TYPE_BIT_0,

+     offsetof(struct gl_texture_unit, TexGenEnabled), NO_EXTRA },

+   { GL_TEXTURE_GEN_T, LOC_TEXUNIT, TYPE_BIT_1,

+     offsetof(struct gl_texture_unit, TexGenEnabled), NO_EXTRA },

+   { GL_TEXTURE_GEN_R, LOC_TEXUNIT, TYPE_BIT_2,

+     offsetof(struct gl_texture_unit, TexGenEnabled), NO_EXTRA },

+   { GL_TEXTURE_GEN_Q, LOC_TEXUNIT, TYPE_BIT_3,

+     offsetof(struct gl_texture_unit, TexGenEnabled), NO_EXTRA },

+   { GL_UNPACK_LSB_FIRST, CONTEXT_BOOL(Unpack.LsbFirst), NO_EXTRA },

+   { GL_UNPACK_ROW_LENGTH, CONTEXT_INT(Unpack.RowLength), NO_EXTRA },

+   { GL_UNPACK_SKIP_PIXELS, CONTEXT_INT(Unpack.SkipPixels), NO_EXTRA },

+   { GL_UNPACK_SKIP_ROWS, CONTEXT_INT(Unpack.SkipRows), NO_EXTRA },

+   { GL_UNPACK_SWAP_BYTES, CONTEXT_BOOL(Unpack.SwapBytes), NO_EXTRA },

+   { GL_UNPACK_SKIP_IMAGES_EXT, CONTEXT_INT(Unpack.SkipImages), NO_EXTRA },

+   { GL_UNPACK_IMAGE_HEIGHT_EXT, CONTEXT_INT(Unpack.ImageHeight), NO_EXTRA },

+   { GL_UNPACK_CLIENT_STORAGE_APPLE, CONTEXT_BOOL(Unpack.ClientStorage), NO_EXTRA },

+   { GL_ZOOM_X, CONTEXT_FLOAT(Pixel.ZoomX), NO_EXTRA },

+   { GL_ZOOM_Y, CONTEXT_FLOAT(Pixel.ZoomY), NO_EXTRA },

+

+   /* Vertex arrays */

+   { GL_VERTEX_ARRAY_COUNT_EXT, CONST(0), NO_EXTRA },

+   { GL_NORMAL_ARRAY_COUNT_EXT, CONST(0), NO_EXTRA },

+   { GL_COLOR_ARRAY_COUNT_EXT, CONST(0), NO_EXTRA },

+   { GL_INDEX_ARRAY, ARRAY_BOOL(Index.Enabled), NO_EXTRA },

+   { GL_INDEX_ARRAY_TYPE, ARRAY_ENUM(Index.Type), NO_EXTRA },

+   { GL_INDEX_ARRAY_STRIDE, ARRAY_INT(Index.Stride), NO_EXTRA },

+   { GL_INDEX_ARRAY_COUNT_EXT, CONST(0), NO_EXTRA },

+   { GL_TEXTURE_COORD_ARRAY_COUNT_EXT, CONST(0), NO_EXTRA },

+   { GL_EDGE_FLAG_ARRAY, ARRAY_BOOL(EdgeFlag.Enabled), NO_EXTRA },

+   { GL_EDGE_FLAG_ARRAY_STRIDE, ARRAY_INT(EdgeFlag.Stride), NO_EXTRA },

+   { GL_EDGE_FLAG_ARRAY_COUNT_EXT, CONST(0), NO_EXTRA },

+

+   /* GL_ARB_texture_compression */

+   { GL_TEXTURE_COMPRESSION_HINT_ARB, CONTEXT_INT(Hint.TextureCompression), NO_EXTRA },

+

+   /* GL_EXT_compiled_vertex_array */

+   { GL_ARRAY_ELEMENT_LOCK_FIRST_EXT, CONTEXT_INT(Array.LockFirst),

+     extra_EXT_compiled_vertex_array },

+   { GL_ARRAY_ELEMENT_LOCK_COUNT_EXT, CONTEXT_INT(Array.LockCount),

+     extra_EXT_compiled_vertex_array },

+

+   /* GL_ARB_transpose_matrix */

+   { GL_TRANSPOSE_MODELVIEW_MATRIX_ARB,

+     CONTEXT_MATRIX_T(ModelviewMatrixStack), NO_EXTRA },

+   { GL_TRANSPOSE_PROJECTION_MATRIX_ARB,

+     CONTEXT_MATRIX_T(ProjectionMatrixStack.Top), NO_EXTRA },

+   { GL_TRANSPOSE_TEXTURE_MATRIX_ARB, CONTEXT_MATRIX_T(TextureMatrixStack), NO_EXTRA },

+

+   /* GL_EXT_secondary_color */

+   { GL_COLOR_SUM_EXT, CONTEXT_BOOL(Fog.ColorSumEnabled),

+     extra_EXT_secondary_color_ARB_vertex_program },

+   { GL_CURRENT_SECONDARY_COLOR_EXT,

+     CONTEXT_FIELD(Current.Attrib[VERT_ATTRIB_COLOR1][0], TYPE_FLOATN_4),

+     extra_EXT_secondary_color_flush_current },

+   { GL_SECONDARY_COLOR_ARRAY_EXT, ARRAY_BOOL(SecondaryColor.Enabled),

+     extra_EXT_secondary_color },

+   { GL_SECONDARY_COLOR_ARRAY_TYPE_EXT, ARRAY_ENUM(SecondaryColor.Type),

+     extra_EXT_secondary_color },

+   { GL_SECONDARY_COLOR_ARRAY_STRIDE_EXT, ARRAY_INT(SecondaryColor.Stride),

+     extra_EXT_secondary_color },

+   { GL_SECONDARY_COLOR_ARRAY_SIZE_EXT, ARRAY_INT(SecondaryColor.Size),

+     extra_EXT_secondary_color },

+

+   /* GL_EXT_fog_coord */

+   { GL_CURRENT_FOG_COORDINATE_EXT,

+     CONTEXT_FLOAT(Current.Attrib[VERT_ATTRIB_FOG][0]),

+     extra_EXT_fog_coord_flush_current },

+   { GL_FOG_COORDINATE_ARRAY_EXT, ARRAY_BOOL(FogCoord.Enabled),

+     extra_EXT_fog_coord },

+   { GL_FOG_COORDINATE_ARRAY_TYPE_EXT, ARRAY_ENUM(FogCoord.Type),

+     extra_EXT_fog_coord },

+   { GL_FOG_COORDINATE_ARRAY_STRIDE_EXT, ARRAY_INT(FogCoord.Stride),

+     extra_EXT_fog_coord },

+   { GL_FOG_COORDINATE_SOURCE_EXT, CONTEXT_ENUM(Fog.FogCoordinateSource),

+     extra_EXT_fog_coord },

+

+   /* GL_IBM_rasterpos_clip */

+   { GL_RASTER_POSITION_UNCLIPPED_IBM,

+     CONTEXT_BOOL(Transform.RasterPositionUnclipped),

+     extra_IBM_rasterpos_clip },

+

+   /* GL_NV_point_sprite */

+   { GL_POINT_SPRITE_R_MODE_NV,

+     CONTEXT_ENUM(Point.SpriteRMode), extra_NV_point_sprite },

+   { GL_POINT_SPRITE_COORD_ORIGIN, CONTEXT_ENUM(Point.SpriteOrigin),

+     extra_NV_point_sprite_ARB_point_sprite },

+

+   /* GL_NV_vertex_program */

+   { GL_VERTEX_PROGRAM_BINDING_NV, LOC_CUSTOM, TYPE_INT, 0,

+     extra_NV_vertex_program },

+   { GL_VERTEX_ATTRIB_ARRAY0_NV, ARRAY_BOOL(VertexAttrib[0].Enabled),

+     extra_NV_vertex_program },

+   { GL_VERTEX_ATTRIB_ARRAY1_NV, ARRAY_BOOL(VertexAttrib[1].Enabled),

+     extra_NV_vertex_program },

+   { GL_VERTEX_ATTRIB_ARRAY2_NV, ARRAY_BOOL(VertexAttrib[2].Enabled),

+     extra_NV_vertex_program },

+   { GL_VERTEX_ATTRIB_ARRAY3_NV, ARRAY_BOOL(VertexAttrib[3].Enabled),

+     extra_NV_vertex_program },

+   { GL_VERTEX_ATTRIB_ARRAY4_NV, ARRAY_BOOL(VertexAttrib[4].Enabled),

+     extra_NV_vertex_program },

+   { GL_VERTEX_ATTRIB_ARRAY5_NV, ARRAY_BOOL(VertexAttrib[5].Enabled),

+     extra_NV_vertex_program },

+   { GL_VERTEX_ATTRIB_ARRAY6_NV, ARRAY_BOOL(VertexAttrib[6].Enabled),

+     extra_NV_vertex_program },

+   { GL_VERTEX_ATTRIB_ARRAY7_NV, ARRAY_BOOL(VertexAttrib[7].Enabled),

+     extra_NV_vertex_program },

+   { GL_VERTEX_ATTRIB_ARRAY8_NV, ARRAY_BOOL(VertexAttrib[8].Enabled),

+     extra_NV_vertex_program },

+   { GL_VERTEX_ATTRIB_ARRAY9_NV, ARRAY_BOOL(VertexAttrib[9].Enabled),

+     extra_NV_vertex_program },

+   { GL_VERTEX_ATTRIB_ARRAY10_NV, ARRAY_BOOL(VertexAttrib[10].Enabled),

+     extra_NV_vertex_program },

+   { GL_VERTEX_ATTRIB_ARRAY11_NV, ARRAY_BOOL(VertexAttrib[11].Enabled),

+     extra_NV_vertex_program },

+   { GL_VERTEX_ATTRIB_ARRAY12_NV, ARRAY_BOOL(VertexAttrib[12].Enabled),

+     extra_NV_vertex_program },

+   { GL_VERTEX_ATTRIB_ARRAY13_NV, ARRAY_BOOL(VertexAttrib[13].Enabled),

+     extra_NV_vertex_program },

+   { GL_VERTEX_ATTRIB_ARRAY14_NV, ARRAY_BOOL(VertexAttrib[14].Enabled),

+     extra_NV_vertex_program },

+   { GL_VERTEX_ATTRIB_ARRAY15_NV, ARRAY_BOOL(VertexAttrib[15].Enabled),

+     extra_NV_vertex_program },

+   { GL_MAP1_VERTEX_ATTRIB0_4_NV, CONTEXT_BOOL(Eval.Map1Attrib[0]),

+     extra_NV_vertex_program },

+   { GL_MAP1_VERTEX_ATTRIB1_4_NV, CONTEXT_BOOL(Eval.Map1Attrib[1]),

+     extra_NV_vertex_program },

+   { GL_MAP1_VERTEX_ATTRIB2_4_NV, CONTEXT_BOOL(Eval.Map1Attrib[2]),

+     extra_NV_vertex_program },

+   { GL_MAP1_VERTEX_ATTRIB3_4_NV, CONTEXT_BOOL(Eval.Map1Attrib[3]),

+     extra_NV_vertex_program },

+   { GL_MAP1_VERTEX_ATTRIB4_4_NV, CONTEXT_BOOL(Eval.Map1Attrib[4]),

+     extra_NV_vertex_program },

+   { GL_MAP1_VERTEX_ATTRIB5_4_NV, CONTEXT_BOOL(Eval.Map1Attrib[5]),

+     extra_NV_vertex_program },

+   { GL_MAP1_VERTEX_ATTRIB6_4_NV, CONTEXT_BOOL(Eval.Map1Attrib[6]),

+     extra_NV_vertex_program },

+   { GL_MAP1_VERTEX_ATTRIB7_4_NV, CONTEXT_BOOL(Eval.Map1Attrib[7]),

+     extra_NV_vertex_program },

+   { GL_MAP1_VERTEX_ATTRIB8_4_NV, CONTEXT_BOOL(Eval.Map1Attrib[8]),

+     extra_NV_vertex_program },

+   { GL_MAP1_VERTEX_ATTRIB9_4_NV, CONTEXT_BOOL(Eval.Map1Attrib[9]),

+     extra_NV_vertex_program },

+   { GL_MAP1_VERTEX_ATTRIB10_4_NV, CONTEXT_BOOL(Eval.Map1Attrib[10]),

+     extra_NV_vertex_program },

+   { GL_MAP1_VERTEX_ATTRIB11_4_NV, CONTEXT_BOOL(Eval.Map1Attrib[11]),

+     extra_NV_vertex_program },

+   { GL_MAP1_VERTEX_ATTRIB12_4_NV, CONTEXT_BOOL(Eval.Map1Attrib[12]),

+     extra_NV_vertex_program },

+   { GL_MAP1_VERTEX_ATTRIB13_4_NV, CONTEXT_BOOL(Eval.Map1Attrib[13]),

+     extra_NV_vertex_program },

+   { GL_MAP1_VERTEX_ATTRIB14_4_NV, CONTEXT_BOOL(Eval.Map1Attrib[14]),

+     extra_NV_vertex_program },

+   { GL_MAP1_VERTEX_ATTRIB15_4_NV, CONTEXT_BOOL(Eval.Map1Attrib[15]),

+     extra_NV_vertex_program },

+

+   /* GL_NV_fragment_program */

+   { GL_FRAGMENT_PROGRAM_NV, CONTEXT_BOOL(FragmentProgram.Enabled),

+     extra_NV_fragment_program },

+   { GL_FRAGMENT_PROGRAM_BINDING_NV, LOC_CUSTOM, TYPE_INT, 0,

+     extra_NV_fragment_program },

+   { GL_MAX_FRAGMENT_PROGRAM_LOCAL_PARAMETERS_NV,

+     CONST(MAX_NV_FRAGMENT_PROGRAM_PARAMS),

+     extra_NV_fragment_program },

+

+   /* GL_NV_texture_rectangle */

+   { GL_TEXTURE_RECTANGLE_NV,

+     LOC_CUSTOM, TYPE_BOOLEAN, 0, extra_NV_texture_rectangle },

+   { GL_TEXTURE_BINDING_RECTANGLE_NV,

+     LOC_CUSTOM, TYPE_INT, TEXTURE_RECT_INDEX, extra_NV_texture_rectangle },

+   { GL_MAX_RECTANGLE_TEXTURE_SIZE_NV,

+     CONTEXT_INT(Const.MaxTextureRectSize), extra_NV_texture_rectangle },

+

+   /* GL_EXT_stencil_two_side */

+   { GL_STENCIL_TEST_TWO_SIDE_EXT, CONTEXT_BOOL(Stencil.TestTwoSide),

+	 extra_EXT_stencil_two_side },

+   { GL_ACTIVE_STENCIL_FACE_EXT, LOC_CUSTOM, TYPE_ENUM, NO_OFFSET, NO_EXTRA },

+

+   /* GL_NV_light_max_exponent */

+   { GL_MAX_SHININESS_NV, CONTEXT_FLOAT(Const.MaxShininess),

+     extra_NV_light_max_exponent },

+   { GL_MAX_SPOT_EXPONENT_NV, CONTEXT_FLOAT(Const.MaxSpotExponent),

+     extra_NV_light_max_exponent },

+     

+   /* GL_NV_primitive_restart */

+   { GL_PRIMITIVE_RESTART_NV, CONTEXT_BOOL(Array.PrimitiveRestart),

+     extra_NV_primitive_restart },

+   { GL_PRIMITIVE_RESTART_INDEX_NV, CONTEXT_INT(Array.RestartIndex),

+     extra_NV_primitive_restart },

+ 

+   /* GL_ARB_vertex_buffer_object */

+   { GL_INDEX_ARRAY_BUFFER_BINDING_ARB, LOC_CUSTOM, TYPE_INT,

+     offsetof(struct gl_array_object, Index.BufferObj), NO_EXTRA },

+   { GL_EDGE_FLAG_ARRAY_BUFFER_BINDING_ARB, LOC_CUSTOM, TYPE_INT,

+     offsetof(struct gl_array_object, EdgeFlag.BufferObj), NO_EXTRA },

+   { GL_SECONDARY_COLOR_ARRAY_BUFFER_BINDING_ARB, LOC_CUSTOM, TYPE_INT,

+     offsetof(struct gl_array_object, SecondaryColor.BufferObj), NO_EXTRA },

+   { GL_FOG_COORDINATE_ARRAY_BUFFER_BINDING_ARB, LOC_CUSTOM, TYPE_INT,

+     offsetof(struct gl_array_object, FogCoord.BufferObj), NO_EXTRA },

+

+   /* GL_EXT_pixel_buffer_object */

+   { GL_PIXEL_PACK_BUFFER_BINDING_EXT, LOC_CUSTOM, TYPE_INT, 0,

+     extra_EXT_pixel_buffer_object },

+   { GL_PIXEL_UNPACK_BUFFER_BINDING_EXT, LOC_CUSTOM, TYPE_INT, 0,

+     extra_EXT_pixel_buffer_object },

+

+   /* GL_ARB_vertex_program */

+   { GL_VERTEX_PROGRAM_ARB, /* == GL_VERTEX_PROGRAM_NV */

+     CONTEXT_BOOL(VertexProgram.Enabled),

+     extra_ARB_vertex_program_NV_vertex_program },

+   { GL_VERTEX_PROGRAM_POINT_SIZE_ARB, /* == GL_VERTEX_PROGRAM_POINT_SIZE_NV*/

+     CONTEXT_BOOL(VertexProgram.PointSizeEnabled),

+     extra_ARB_vertex_program_NV_vertex_program },

+   { GL_VERTEX_PROGRAM_TWO_SIDE_ARB, /* == GL_VERTEX_PROGRAM_TWO_SIDE_NV */

+     CONTEXT_BOOL(VertexProgram.TwoSideEnabled),

+     extra_ARB_vertex_program_NV_vertex_program },

+   { GL_MAX_PROGRAM_MATRIX_STACK_DEPTH_ARB, /* == GL_MAX_TRACK_MATRIX_STACK_DEPTH_NV */

+     CONTEXT_INT(Const.MaxProgramMatrixStackDepth),

+     extra_ARB_vertex_program_ARB_fragment_program_NV_vertex_program },

+   { GL_MAX_PROGRAM_MATRICES_ARB, /* == GL_MAX_TRACK_MATRICES_NV */

+     CONTEXT_INT(Const.MaxProgramMatrices),

+     extra_ARB_vertex_program_ARB_fragment_program_NV_vertex_program },

+   { GL_CURRENT_MATRIX_STACK_DEPTH_ARB, /* == GL_CURRENT_MATRIX_STACK_DEPTH_NV */

+     LOC_CUSTOM, TYPE_INT, 0,

+     extra_ARB_vertex_program_ARB_fragment_program_NV_vertex_program },

+

+   { GL_CURRENT_MATRIX_ARB, /* == GL_CURRENT_MATRIX_NV */

+     LOC_CUSTOM, TYPE_MATRIX, 0,

+     extra_ARB_vertex_program_ARB_fragment_program_NV_vertex_program },

+   { GL_TRANSPOSE_CURRENT_MATRIX_ARB, /* == GL_CURRENT_MATRIX_NV */

+     LOC_CUSTOM, TYPE_MATRIX, 0,

+     extra_ARB_vertex_program_ARB_fragment_program },

+

+   { GL_PROGRAM_ERROR_POSITION_ARB, /* == GL_PROGRAM_ERROR_POSITION_NV */

+     CONTEXT_INT(Program.ErrorPos),

+     extra_NV_vertex_program_ARB_vertex_program_ARB_fragment_program_NV_vertex_program },

+

+   /* GL_ARB_fragment_program */

+   { GL_FRAGMENT_PROGRAM_ARB, CONTEXT_BOOL(FragmentProgram.Enabled),

+     extra_ARB_fragment_program },

+

+   /* GL_EXT_depth_bounds_test */

+   { GL_DEPTH_BOUNDS_TEST_EXT, CONTEXT_BOOL(Depth.BoundsTest),

+     extra_EXT_depth_bounds_test },

+   { GL_DEPTH_BOUNDS_EXT, CONTEXT_FLOAT2(Depth.BoundsMin),

+     extra_EXT_depth_bounds_test },

+

+   /* GL_ARB_depth_clamp*/

+   { GL_DEPTH_CLAMP, CONTEXT_BOOL(Transform.DepthClamp),

+     extra_ARB_depth_clamp },

+

+   /* GL_ARB_draw_buffers */

+   { GL_DRAW_BUFFER0_ARB, BUFFER_ENUM(ColorDrawBuffer[0]), NO_EXTRA },

+   { GL_DRAW_BUFFER1_ARB, BUFFER_ENUM(ColorDrawBuffer[1]),

+     extra_valid_draw_buffer },

+   { GL_DRAW_BUFFER2_ARB, BUFFER_ENUM(ColorDrawBuffer[2]),

+     extra_valid_draw_buffer },

+   { GL_DRAW_BUFFER3_ARB, BUFFER_ENUM(ColorDrawBuffer[3]),

+     extra_valid_draw_buffer },

+   { GL_DRAW_BUFFER4_ARB, BUFFER_ENUM(ColorDrawBuffer[4]),

+     extra_valid_draw_buffer },

+   { GL_DRAW_BUFFER5_ARB, BUFFER_ENUM(ColorDrawBuffer[5]),

+     extra_valid_draw_buffer },

+   { GL_DRAW_BUFFER6_ARB, BUFFER_ENUM(ColorDrawBuffer[6]),

+     extra_valid_draw_buffer },

+   { GL_DRAW_BUFFER7_ARB, BUFFER_ENUM(ColorDrawBuffer[7]),

+     extra_valid_draw_buffer },

+

+   /* GL_ATI_fragment_shader */

+   { GL_NUM_FRAGMENT_REGISTERS_ATI, CONST(6), extra_ATI_fragment_shader },

+   { GL_NUM_FRAGMENT_CONSTANTS_ATI, CONST(8), extra_ATI_fragment_shader },

+   { GL_NUM_PASSES_ATI, CONST(2), extra_ATI_fragment_shader },

+   { GL_NUM_INSTRUCTIONS_PER_PASS_ATI, CONST(8), extra_ATI_fragment_shader },

+   { GL_NUM_INSTRUCTIONS_TOTAL_ATI, CONST(16), extra_ATI_fragment_shader },

+   { GL_COLOR_ALPHA_PAIRING_ATI, CONST(GL_TRUE), extra_ATI_fragment_shader },

+   { GL_NUM_LOOPBACK_COMPONENTS_ATI, CONST(3), extra_ATI_fragment_shader },

+   { GL_NUM_INPUT_INTERPOLATOR_COMPONENTS_ATI,

+     CONST(3), extra_ATI_fragment_shader },

+

+   /* GL_EXT_framebuffer_object */

+   { GL_MAX_COLOR_ATTACHMENTS_EXT, CONTEXT_INT(Const.MaxColorAttachments),

+     extra_EXT_framebuffer_object },

+   

+   /* GL_EXT_framebuffer_blit

+    * NOTE: GL_DRAW_FRAMEBUFFER_BINDING_EXT == GL_FRAMEBUFFER_BINDING_EXT */

+   { GL_READ_FRAMEBUFFER_BINDING_EXT, LOC_CUSTOM, TYPE_INT, 0,

+     extra_EXT_framebuffer_blit },

+

+   /* GL_EXT_provoking_vertex */

+   { GL_PROVOKING_VERTEX_EXT,

+     CONTEXT_BOOL(Light.ProvokingVertex), extra_EXT_provoking_vertex },

+   { GL_QUADS_FOLLOW_PROVOKING_VERTEX_CONVENTION_EXT,

+     CONTEXT_BOOL(Const.QuadsFollowProvokingVertexConvention),

+     extra_EXT_provoking_vertex },

+

+   /* GL_ARB_framebuffer_object */

+   { GL_MAX_SAMPLES, CONTEXT_INT(Const.MaxSamples),

+     extra_ARB_framebuffer_object_EXT_framebuffer_multisample },

+

+   /* GL_APPLE_vertex_array_object */

+   { GL_VERTEX_ARRAY_BINDING_APPLE, ARRAY_INT(Name),

+     extra_APPLE_vertex_array_object },

+

+   /* GL_ARB_seamless_cube_map */

+   { GL_TEXTURE_CUBE_MAP_SEAMLESS,

+     CONTEXT_BOOL(Texture.CubeMapSeamless), extra_ARB_seamless_cube_map },

+

+   /* GL_ARB_sync */

+   { GL_MAX_SERVER_WAIT_TIMEOUT,

+     CONTEXT_INT64(Const.MaxServerWaitTimeout), extra_ARB_sync },

+

+   /* GL_EXT_texture_integer */

+   { GL_RGBA_INTEGER_MODE_EXT, BUFFER_BOOL(_IntegerColor),

+     extra_EXT_texture_integer },

+

+   /* GL_EXT_transform_feedback */

+   { GL_TRANSFORM_FEEDBACK_BUFFER_BINDING, LOC_CUSTOM, TYPE_INT, 0,

+     extra_EXT_transform_feedback },

+   { GL_RASTERIZER_DISCARD, CONTEXT_BOOL(TransformFeedback.RasterDiscard),

+     extra_EXT_transform_feedback },

+   { GL_MAX_TRANSFORM_FEEDBACK_INTERLEAVED_COMPONENTS,

+     CONTEXT_INT(Const.MaxTransformFeedbackInterleavedComponents),

+     extra_EXT_transform_feedback },

+   { GL_MAX_TRANSFORM_FEEDBACK_SEPARATE_ATTRIBS,

+     CONTEXT_INT(Const.MaxTransformFeedbackSeparateAttribs),

+     extra_EXT_transform_feedback },

+   { GL_MAX_TRANSFORM_FEEDBACK_SEPARATE_COMPONENTS,

+     CONTEXT_INT(Const.MaxTransformFeedbackSeparateComponents),

+     extra_EXT_transform_feedback },

+

+   /* GL_ARB_transform_feedback2 */

+   { GL_TRANSFORM_FEEDBACK_BUFFER_PAUSED, LOC_CUSTOM, TYPE_BOOLEAN, 0,

+     extra_ARB_transform_feedback2 },

+   { GL_TRANSFORM_FEEDBACK_BUFFER_ACTIVE, LOC_CUSTOM, TYPE_BOOLEAN, 0,

+     extra_ARB_transform_feedback2 },

+   { GL_TRANSFORM_FEEDBACK_BINDING, LOC_CUSTOM, TYPE_INT, 0,

+     extra_ARB_transform_feedback2 },

+

+   /* GL_ARB_geometry_shader4 */

+   { GL_MAX_GEOMETRY_TEXTURE_IMAGE_UNITS_ARB,

+     CONTEXT_INT(Const.MaxGeometryTextureImageUnits),

+     extra_ARB_geometry_shader4 },

+   { GL_MAX_GEOMETRY_OUTPUT_VERTICES_ARB,

+     CONTEXT_INT(Const.MaxGeometryOutputVertices),

+     extra_ARB_geometry_shader4 },

+   { GL_MAX_GEOMETRY_TOTAL_OUTPUT_COMPONENTS_ARB,

+     CONTEXT_INT(Const.MaxGeometryTotalOutputComponents),

+     extra_ARB_geometry_shader4 },

+   { GL_MAX_GEOMETRY_UNIFORM_COMPONENTS_ARB,

+     CONTEXT_INT(Const.GeometryProgram.MaxUniformComponents),

+     extra_ARB_geometry_shader4 },

+   { GL_MAX_GEOMETRY_VARYING_COMPONENTS_ARB,

+     CONTEXT_INT(Const.MaxGeometryVaryingComponents),

+     extra_ARB_geometry_shader4 },

+   { GL_MAX_VERTEX_VARYING_COMPONENTS_ARB,

+     CONTEXT_INT(Const.MaxVertexVaryingComponents),

+     extra_ARB_geometry_shader4 },

+

+   /* GL_EXT_gpu_shader4 / GL 3.0 */

+   { GL_MIN_PROGRAM_TEXEL_OFFSET,

+     CONTEXT_INT(Const.MinProgramTexelOffset),

+     extra_EXT_gpu_shader4 },

+   { GL_MAX_PROGRAM_TEXEL_OFFSET,

+     CONTEXT_INT(Const.MaxProgramTexelOffset),

+     extra_EXT_gpu_shader4 },

+

+   /* GL 3.0 */

+   { GL_NUM_EXTENSIONS, LOC_CUSTOM, TYPE_INT, 0, extra_version_30 },

+   { GL_MAJOR_VERSION, CONTEXT_INT(VersionMajor), extra_version_30 },

+   { GL_MINOR_VERSION, CONTEXT_INT(VersionMinor), extra_version_30  },

+   { GL_CONTEXT_FLAGS, CONTEXT_INT(Const.ContextFlags), extra_version_30  },

+

+   /* GL3.0 / GL_EXT_framebuffer_sRGB */

+   { GL_FRAMEBUFFER_SRGB_EXT, CONTEXT_BOOL(Color.sRGBEnabled), extra_EXT_framebuffer_sRGB },

+   { GL_FRAMEBUFFER_SRGB_CAPABLE_EXT, BUFFER_INT(Visual.sRGBCapable), extra_EXT_framebuffer_sRGB },

+

+   /* GL 3.1 */

+   /* NOTE: different enum values for GL_PRIMITIVE_RESTART_NV

+    * vs. GL_PRIMITIVE_RESTART!

+    */

+   { GL_PRIMITIVE_RESTART, CONTEXT_BOOL(Array.PrimitiveRestart),

+     extra_version_31 },

+   { GL_PRIMITIVE_RESTART_INDEX, CONTEXT_INT(Array.RestartIndex),

+     extra_version_31 },

+ 

+

+   /* GL 3.2 */

+   { GL_CONTEXT_PROFILE_MASK, CONTEXT_INT(Const.ProfileMask),

+     extra_version_32 },

+#endif /* FEATURE_GL */

+};

+

+/* All we need now is a way to look up the value struct from the enum.

+ * The code generated by gcc for the old generated big switch

+ * statement is a big, balanced, open coded if/else tree, essentially

+ * an unrolled binary search.  It would be natural to sort the new

+ * enum table and use bsearch(), but we will use a read-only hash

+ * table instead.  bsearch() has a nice guaranteed worst case

+ * performance, but we're also guaranteed to hit that worst case

+ * (log2(n) iterations) for about half the enums.  Instead, using an

+ * open addressing hash table, we can find the enum on the first try

+ * for 80% of the enums, 1 collision for 10% and never more than 5

+ * collisions for any enum (typical numbers).  And the code is very

+ * simple, even though it feels a little magic. */

+

+static unsigned short table[1024];

+static const int prime_factor = 89, prime_step = 281;

+

+#ifdef GET_DEBUG

+static void

+print_table_stats(void)

+{

+   int i, j, collisions[11], count, hash, mask;

+   const struct value_desc *d;

+

+   count = 0;

+   mask = Elements(table) - 1;

+   memset(collisions, 0, sizeof collisions);

+

+   for (i = 0; i < Elements(table); i++) {

+      if (!table[i])

+	 continue;

+      count++;

+      d = &values[table[i]];

+      hash = (d->pname * prime_factor);

+      j = 0;

+      while (1) {

+	 if (values[table[hash & mask]].pname == d->pname)

+	    break;

+	 hash += prime_step;

+	 j++;

+      }

+

+      if (j < 10)

+	 collisions[j]++;

+      else

+	 collisions[10]++;

+   }

+

+   printf("number of enums: %d (total %d)\n", count, Elements(values));

+   for (i = 0; i < Elements(collisions) - 1; i++)

+      if (collisions[i] > 0)

+	 printf("  %d enums with %d %scollisions\n",

+		collisions[i], i, i == 10 ? "or more " : "");

+}

+#endif

+

+/**

+ * Initialize the enum hash for a given API 

+ *

+ * This is called from one_time_init() to insert the enum values that

+ * are valid for the API in question into the enum hash table.

+ *

+ * \param the current context, for determining the API in question

+ */

+void _mesa_init_get_hash(struct gl_context *ctx)

+{

+   int i, hash, index, mask;

+   int api_mask = 0, api_bit;

+

+   mask = Elements(table) - 1;

+   api_bit = 1 << ctx->API;

+

+   for (i = 0; i < Elements(values); i++) {

+      if (values[i].type == TYPE_API_MASK) {

+	 api_mask = values[i].offset;

+	 continue;

+      }

+      if (!(api_mask & api_bit))

+	 continue;

+

+      hash = (values[i].pname * prime_factor) & mask;

+      while (1) {

+	 index = hash & mask;

+	 if (!table[index]) {

+	    table[index] = i;

+	    break;

+	 }

+	 hash += prime_step;

+      }

+   }

+

+#ifdef GET_DEBUG

+   print_table_stats();

+#endif

+}

+

+/**

+ * Handle irregular enums

+ *

+ * Some values don't conform to the "well-known type at context

+ * pointer + offset" pattern, so we have this function to catch all

+ * the corner cases.  Typically, it's a computed value or a one-off

+ * pointer to a custom struct or something.

+ *

+ * In this case we can't return a pointer to the value, so we'll have

+ * to use the temporary variable 'v' declared back in the calling

+ * glGet*v() function to store the result.

+ *

+ * \param ctx the current context

+ * \param d the struct value_desc that describes the enum

+ * \param v pointer to the tmp declared in the calling glGet*v() function

+ */

+static void

+find_custom_value(struct gl_context *ctx, const struct value_desc *d, union value *v)

+{

+   struct gl_buffer_object *buffer_obj;

+   struct gl_client_array *array;

+   GLuint unit, *p;

+

+   switch (d->pname) {

+   case GL_TEXTURE_1D:

+   case GL_TEXTURE_2D:

+   case GL_TEXTURE_3D:

+   case GL_TEXTURE_1D_ARRAY_EXT:

+   case GL_TEXTURE_2D_ARRAY_EXT:

+   case GL_TEXTURE_CUBE_MAP_ARB:

+   case GL_TEXTURE_RECTANGLE_NV:

+      v->value_bool = _mesa_IsEnabled(d->pname);

+      break;

+

+   case GL_LINE_STIPPLE_PATTERN:

+      /* This is the only GLushort, special case it here by promoting

+       * to an int rather than introducing a new type. */

+      v->value_int = ctx->Line.StipplePattern;

+      break;

+

+   case GL_CURRENT_RASTER_TEXTURE_COORDS:

+      unit = ctx->Texture.CurrentUnit;

+      v->value_float_4[0] = ctx->Current.RasterTexCoords[unit][0];

+      v->value_float_4[1] = ctx->Current.RasterTexCoords[unit][1];

+      v->value_float_4[2] = ctx->Current.RasterTexCoords[unit][2];

+      v->value_float_4[3] = ctx->Current.RasterTexCoords[unit][3];

+      break;

+

+   case GL_CURRENT_TEXTURE_COORDS:

+      unit = ctx->Texture.CurrentUnit;

+      v->value_float_4[0] = ctx->Current.Attrib[VERT_ATTRIB_TEX0 + unit][0];

+      v->value_float_4[1] = ctx->Current.Attrib[VERT_ATTRIB_TEX0 + unit][1];

+      v->value_float_4[2] = ctx->Current.Attrib[VERT_ATTRIB_TEX0 + unit][2];

+      v->value_float_4[3] = ctx->Current.Attrib[VERT_ATTRIB_TEX0 + unit][3];

+      break;

+

+   case GL_COLOR_WRITEMASK:

+      v->value_int_4[0] = ctx->Color.ColorMask[0][RCOMP] ? 1 : 0;

+      v->value_int_4[1] = ctx->Color.ColorMask[0][GCOMP] ? 1 : 0;

+      v->value_int_4[2] = ctx->Color.ColorMask[0][BCOMP] ? 1 : 0;

+      v->value_int_4[3] = ctx->Color.ColorMask[0][ACOMP] ? 1 : 0;

+      break;

+

+   case GL_EDGE_FLAG:

+      v->value_bool = ctx->Current.Attrib[VERT_ATTRIB_EDGEFLAG][0] == 1.0;

+      break;

+

+   case GL_READ_BUFFER:

+      v->value_enum = ctx->ReadBuffer->ColorReadBuffer;

+      break;

+

+   case GL_MAP2_GRID_DOMAIN:

+      v->value_float_4[0] = ctx->Eval.MapGrid2u1;

+      v->value_float_4[1] = ctx->Eval.MapGrid2u2;

+      v->value_float_4[2] = ctx->Eval.MapGrid2v1;

+      v->value_float_4[3] = ctx->Eval.MapGrid2v2;

+      break;

+

+   case GL_TEXTURE_STACK_DEPTH:

+      unit = ctx->Texture.CurrentUnit;

+      v->value_int = ctx->TextureMatrixStack[unit].Depth + 1;

+      break;

+   case GL_TEXTURE_MATRIX:

+      unit = ctx->Texture.CurrentUnit;

+      v->value_matrix = ctx->TextureMatrixStack[unit].Top;

+      break;

+

+   case GL_TEXTURE_COORD_ARRAY:

+   case GL_TEXTURE_COORD_ARRAY_SIZE:

+   case GL_TEXTURE_COORD_ARRAY_TYPE:

+   case GL_TEXTURE_COORD_ARRAY_STRIDE:

+      array = &ctx->Array.ArrayObj->TexCoord[ctx->Array.ActiveTexture];

+      v->value_int = *(GLuint *) ((char *) array + d->offset);

+      break;

+

+   case GL_ACTIVE_TEXTURE_ARB:

+      v->value_int = GL_TEXTURE0_ARB + ctx->Texture.CurrentUnit;

+      break;

+   case GL_CLIENT_ACTIVE_TEXTURE_ARB:

+      v->value_int = GL_TEXTURE0_ARB + ctx->Array.ActiveTexture;

+      break;

+

+   case GL_MODELVIEW_STACK_DEPTH:

+   case GL_PROJECTION_STACK_DEPTH:

+      v->value_int = *(GLint *) ((char *) ctx + d->offset) + 1;

+      break;

+

+   case GL_MAX_TEXTURE_SIZE:

+   case GL_MAX_3D_TEXTURE_SIZE:

+   case GL_MAX_CUBE_MAP_TEXTURE_SIZE_ARB:

+      p = (GLuint *) ((char *) ctx + d->offset);

+      v->value_int = 1 << (*p - 1);

+      break;

+

+   case GL_SCISSOR_BOX:

+      v->value_int_4[0] = ctx->Scissor.X;

+      v->value_int_4[1] = ctx->Scissor.Y;

+      v->value_int_4[2] = ctx->Scissor.Width;

+      v->value_int_4[3] = ctx->Scissor.Height;

+      break;

+

+   case GL_LIST_INDEX:

+      v->value_int =

+	 ctx->ListState.CurrentList ? ctx->ListState.CurrentList->Name : 0;

+      break;

+   case GL_LIST_MODE:

+      if (!ctx->CompileFlag)

+	 v->value_enum = 0;

+      else if (ctx->ExecuteFlag)

+	 v->value_enum = GL_COMPILE_AND_EXECUTE;

+      else

+	 v->value_enum = GL_COMPILE;

+      break;

+

+   case GL_VIEWPORT:

+      v->value_int_4[0] = ctx->Viewport.X;

+      v->value_int_4[1] = ctx->Viewport.Y;

+      v->value_int_4[2] = ctx->Viewport.Width;

+      v->value_int_4[3] = ctx->Viewport.Height;

+      break;

+

+   case GL_ACTIVE_STENCIL_FACE_EXT:

+      v->value_enum = ctx->Stencil.ActiveFace ? GL_BACK : GL_FRONT;

+      break;

+

+   case GL_STENCIL_FAIL:

+      v->value_enum = ctx->Stencil.FailFunc[ctx->Stencil.ActiveFace];

+      break;

+   case GL_STENCIL_FUNC:

+      v->value_enum = ctx->Stencil.Function[ctx->Stencil.ActiveFace];

+      break;

+   case GL_STENCIL_PASS_DEPTH_FAIL:

+      v->value_enum = ctx->Stencil.ZFailFunc[ctx->Stencil.ActiveFace];

+      break;

+   case GL_STENCIL_PASS_DEPTH_PASS:

+      v->value_enum = ctx->Stencil.ZPassFunc[ctx->Stencil.ActiveFace];

+      break;

+   case GL_STENCIL_REF:

+      v->value_int = ctx->Stencil.Ref[ctx->Stencil.ActiveFace];

+      break;

+   case GL_STENCIL_VALUE_MASK:

+      v->value_int = ctx->Stencil.ValueMask[ctx->Stencil.ActiveFace];

+      break;

+   case GL_STENCIL_WRITEMASK:

+      v->value_int = ctx->Stencil.WriteMask[ctx->Stencil.ActiveFace];

+      break;

+

+   case GL_NUM_EXTENSIONS:

+      v->value_int = _mesa_get_extension_count(ctx);

+      break;

+

+   case GL_IMPLEMENTATION_COLOR_READ_TYPE_OES:

+      v->value_int = _mesa_get_color_read_type(ctx);

+      break;

+   case GL_IMPLEMENTATION_COLOR_READ_FORMAT_OES:

+      v->value_int = _mesa_get_color_read_format(ctx);

+      break;

+

+   case GL_CURRENT_MATRIX_STACK_DEPTH_ARB:

+      v->value_int = ctx->CurrentStack->Depth + 1;

+      break;

+   case GL_CURRENT_MATRIX_ARB:

+   case GL_TRANSPOSE_CURRENT_MATRIX_ARB:

+      v->value_matrix = ctx->CurrentStack->Top;

+      break;

+

+   case GL_NUM_COMPRESSED_TEXTURE_FORMATS_ARB:

+      v->value_int = _mesa_get_compressed_formats(ctx, NULL, GL_FALSE);

+      break;

+   case GL_COMPRESSED_TEXTURE_FORMATS_ARB:

+      v->value_int_n.n = 

+	 _mesa_get_compressed_formats(ctx, v->value_int_n.ints, GL_FALSE);

+      ASSERT(v->value_int_n.n <= 100);

+      break;

+

+   case GL_MAX_VARYING_FLOATS_ARB:

+      v->value_int = ctx->Const.MaxVarying * 4;

+      break;

+

+   /* Various object names */

+

+   case GL_TEXTURE_BINDING_1D:

+   case GL_TEXTURE_BINDING_2D:

+   case GL_TEXTURE_BINDING_3D:

+   case GL_TEXTURE_BINDING_1D_ARRAY_EXT:

+   case GL_TEXTURE_BINDING_2D_ARRAY_EXT:

+   case GL_TEXTURE_BINDING_CUBE_MAP_ARB:

+   case GL_TEXTURE_BINDING_RECTANGLE_NV:

+      unit = ctx->Texture.CurrentUnit;

+      v->value_int =

+	 ctx->Texture.Unit[unit].CurrentTex[d->offset]->Name;

+      break;

+

+   /* GL_ARB_vertex_buffer_object */

+   case GL_VERTEX_ARRAY_BUFFER_BINDING_ARB:

+   case GL_NORMAL_ARRAY_BUFFER_BINDING_ARB:

+   case GL_COLOR_ARRAY_BUFFER_BINDING_ARB:

+   case GL_INDEX_ARRAY_BUFFER_BINDING_ARB:

+   case GL_EDGE_FLAG_ARRAY_BUFFER_BINDING_ARB:

+   case GL_SECONDARY_COLOR_ARRAY_BUFFER_BINDING_ARB:

+   case GL_FOG_COORDINATE_ARRAY_BUFFER_BINDING_ARB:

+      buffer_obj = (struct gl_buffer_object *)

+	 ((char *) ctx->Array.ArrayObj + d->offset);

+      v->value_int = buffer_obj->Name;

+      break;

+   case GL_ARRAY_BUFFER_BINDING_ARB:

+      v->value_int = ctx->Array.ArrayBufferObj->Name;

+      break;

+   case GL_TEXTURE_COORD_ARRAY_BUFFER_BINDING_ARB:

+      v->value_int =

+	 ctx->Array.ArrayObj->TexCoord[ctx->Array.ActiveTexture].BufferObj->Name;

+      break;

+   case GL_ELEMENT_ARRAY_BUFFER_BINDING_ARB:

+      v->value_int = ctx->Array.ElementArrayBufferObj->Name;

+      break;

+

+   /* ARB_copy_buffer */

+   case GL_COPY_READ_BUFFER:

+      v->value_int = ctx->CopyReadBuffer->Name;

+      break;

+   case GL_COPY_WRITE_BUFFER:

+      v->value_int = ctx->CopyWriteBuffer->Name;

+      break;

+

+   case GL_FRAGMENT_PROGRAM_BINDING_NV:

+      v->value_int = 

+	 ctx->FragmentProgram.Current ? ctx->FragmentProgram.Current->Base.Id : 0;

+      break;

+   case GL_VERTEX_PROGRAM_BINDING_NV:

+      v->value_int =

+	 ctx->VertexProgram.Current ? ctx->VertexProgram.Current->Base.Id : 0;

+      break;

+   case GL_PIXEL_PACK_BUFFER_BINDING_EXT:

+      v->value_int = ctx->Pack.BufferObj->Name;

+      break;

+   case GL_PIXEL_UNPACK_BUFFER_BINDING_EXT:

+      v->value_int = ctx->Unpack.BufferObj->Name;

+      break;

+   case GL_TRANSFORM_FEEDBACK_BUFFER_BINDING:

+      v->value_int = ctx->TransformFeedback.CurrentBuffer->Name;

+      break;

+   case GL_TRANSFORM_FEEDBACK_BUFFER_PAUSED:

+      v->value_int = ctx->TransformFeedback.CurrentObject->Paused;

+      break;

+   case GL_TRANSFORM_FEEDBACK_BUFFER_ACTIVE:

+      v->value_int = ctx->TransformFeedback.CurrentObject->Active;

+      break;

+   case GL_TRANSFORM_FEEDBACK_BINDING:

+      v->value_int = ctx->TransformFeedback.CurrentObject->Name;

+      break;

+   case GL_CURRENT_PROGRAM:

+      v->value_int =

+	 ctx->Shader.ActiveProgram ? ctx->Shader.ActiveProgram->Name : 0;

+      break;

+   case GL_READ_FRAMEBUFFER_BINDING_EXT:

+      v->value_int = ctx->ReadBuffer->Name;

+      break;

+   case GL_RENDERBUFFER_BINDING_EXT:

+      v->value_int =

+	 ctx->CurrentRenderbuffer ? ctx->CurrentRenderbuffer->Name : 0;

+      break;

+   case GL_POINT_SIZE_ARRAY_BUFFER_BINDING_OES:

+      v->value_int = ctx->Array.ArrayObj->PointSize.BufferObj->Name;

+      break;

+

+   case GL_MAX_VERTEX_UNIFORM_VECTORS:

+      v->value_int = ctx->Const.VertexProgram.MaxUniformComponents / 4;

+      break;

+

+   case GL_MAX_FRAGMENT_UNIFORM_VECTORS:

+      v->value_int = ctx->Const.FragmentProgram.MaxUniformComponents / 4;

+      break;

+   }   

+}

+

+/**

+ * Check extra constraints on a struct value_desc descriptor

+ *

+ * If a struct value_desc has a non-NULL extra pointer, it means that

+ * there are a number of extra constraints to check or actions to

+ * perform.  The extras is just an integer array where each integer

+ * encode different constraints or actions.

+ *

+ * \param ctx current context

+ * \param func name of calling glGet*v() function for error reporting

+ * \param d the struct value_desc that has the extra constraints

+ *

+ * \return GL_FALSE if one of the constraints was not satisfied,

+ *     otherwise GL_TRUE.

+ */

+static GLboolean

+check_extra(struct gl_context *ctx, const char *func, const struct value_desc *d)

+{

+   const GLuint version = ctx->VersionMajor * 10 + ctx->VersionMinor;

+   int total, enabled;

+   const int *e;

+

+   total = 0;

+   enabled = 0;

+   for (e = d->extra; *e != EXTRA_END; e++)

+      switch (*e) {

+      case EXTRA_VERSION_30:

+	 if (version >= 30) {

+	    total++;

+	    enabled++;

+	 }

+	 break;

+      case EXTRA_VERSION_31:

+	 if (version >= 31) {

+	    total++;

+	    enabled++;

+	 }

+	 break;

+      case EXTRA_VERSION_32:

+	 if (version >= 32) {

+	    total++;

+	    enabled++;

+	 }

+	 break;

+      case EXTRA_VERSION_ES2:

+	 if (ctx->API == API_OPENGLES2) {

+	    total++;

+	    enabled++;

+	 }

+	 break;

+      case EXTRA_NEW_BUFFERS:

+	 if (ctx->NewState & _NEW_BUFFERS)

+	    _mesa_update_state(ctx);

+	 break;

+      case EXTRA_FLUSH_CURRENT:

+	 FLUSH_CURRENT(ctx, 0);

+	 break;

+      case EXTRA_VALID_DRAW_BUFFER:

+	 if (d->pname - GL_DRAW_BUFFER0_ARB >= ctx->Const.MaxDrawBuffers) {

+	    _mesa_error(ctx, GL_INVALID_OPERATION, "%s(draw buffer %u)",

+			func, d->pname - GL_DRAW_BUFFER0_ARB);

+	    return GL_FALSE;

+	 }

+	 break;

+      case EXTRA_VALID_TEXTURE_UNIT:

+	 if (ctx->Texture.CurrentUnit >= ctx->Const.MaxTextureCoordUnits) {

+	    _mesa_error(ctx, GL_INVALID_OPERATION, "%s(texture %u)",

+			func, ctx->Texture.CurrentUnit);

+	    return GL_FALSE;

+	 }

+	 break;

+      case EXTRA_END:

+	 break;

+      default: /* *e is a offset into the extension struct */

+	 total++;

+	 if (*(GLboolean *) ((char *) &ctx->Extensions + *e))

+	    enabled++;

+	 break;

+      }

+

+   if (total > 0 && enabled == 0) {

+      _mesa_error(ctx, GL_INVALID_ENUM, "%s(pname=%s)", func,

+                  _mesa_lookup_enum_by_nr(d->pname));

+      return GL_FALSE;

+   }

+

+   return GL_TRUE;

+}

+

+static const struct value_desc error_value =

+   { 0, 0, TYPE_INVALID, NO_OFFSET, NO_EXTRA };

+

+/**

+ * Find the struct value_desc corresponding to the enum 'pname'.

+ * 

+ * We hash the enum value to get an index into the 'table' array,

+ * which holds the index in the 'values' array of struct value_desc.

+ * Once we've found the entry, we do the extra checks, if any, then

+ * look up the value and return a pointer to it.

+ *

+ * If the value has to be computed (for example, it's the result of a

+ * function call or we need to add 1 to it), we use the tmp 'v' to

+ * store the result.

+ * 

+ * \param func name of glGet*v() func for error reporting

+ * \param pname the enum value we're looking up

+ * \param p is were we return the pointer to the value

+ * \param v a tmp union value variable in the calling glGet*v() function

+ *

+ * \return the struct value_desc corresponding to the enum or a struct

+ *     value_desc of TYPE_INVALID if not found.  This lets the calling

+ *     glGet*v() function jump right into a switch statement and

+ *     handle errors there instead of having to check for NULL.

+ */

+static const struct value_desc *

+find_value(const char *func, GLenum pname, void **p, union value *v)

+{

+   GET_CURRENT_CONTEXT(ctx);

+   struct gl_texture_unit *unit;

+   int mask, hash;

+   const struct value_desc *d;

+

+   mask = Elements(table) - 1;

+   hash = (pname * prime_factor);

+   while (1) {

+      d = &values[table[hash & mask]];

+

+      /* If the enum isn't valid, the hash walk ends with index 0,

+       * which is the API mask entry at the beginning of values[]. */

+      if (unlikely(d->type == TYPE_API_MASK)) {

+	 _mesa_error(ctx, GL_INVALID_ENUM, "%s(pname=%s)", func,

+                     _mesa_lookup_enum_by_nr(pname));

+	 return &error_value;

+      }

+

+      if (likely(d->pname == pname))

+	 break;

+

+      hash += prime_step;

+   }

+

+   if (unlikely(d->extra && !check_extra(ctx, func, d)))

+      return &error_value;

+

+   switch (d->location) {

+   case LOC_BUFFER:

+      *p = ((char *) ctx->DrawBuffer + d->offset);

+      return d;

+   case LOC_CONTEXT:

+      *p = ((char *) ctx + d->offset);

+      return d;

+   case LOC_ARRAY:

+      *p = ((char *) ctx->Array.ArrayObj + d->offset);

+      return d;

+   case LOC_TEXUNIT:

+      unit = &ctx->Texture.Unit[ctx->Texture.CurrentUnit];

+      *p = ((char *) unit + d->offset);

+      return d;

+   case LOC_CUSTOM:

+      find_custom_value(ctx, d, v);

+      *p = v;

+      return d;

+   default:

+      assert(0);

+      break;

+   }

+

+   /* silence warning */

+   return &error_value;

+}

+

+static const int transpose[] = {

+   0, 4,  8, 12,

+   1, 5,  9, 13,

+   2, 6, 10, 14,

+   3, 7, 11, 15

+};

+

+void GLAPIENTRY

+_mesa_GetBooleanv(GLenum pname, GLboolean *params)

+{

+   const struct value_desc *d;

+   union value v;

+   GLmatrix *m;

+   int shift, i;

+   void *p;

+

+   d = find_value("glGetBooleanv", pname, &p, &v);

+   switch (d->type) {

+   case TYPE_INVALID:

+      break;

+   case TYPE_CONST:

+      params[0] = INT_TO_BOOLEAN(d->offset);

+      break;

+

+   case TYPE_FLOAT_4:

+   case TYPE_FLOATN_4:

+      params[3] = FLOAT_TO_BOOLEAN(((GLfloat *) p)[3]);

+   case TYPE_FLOAT_3:

+   case TYPE_FLOATN_3:

+      params[2] = FLOAT_TO_BOOLEAN(((GLfloat *) p)[2]);

+   case TYPE_FLOAT_2:

+   case TYPE_FLOATN_2:

+      params[1] = FLOAT_TO_BOOLEAN(((GLfloat *) p)[1]);

+   case TYPE_FLOAT:

+   case TYPE_FLOATN:

+      params[0] = FLOAT_TO_BOOLEAN(((GLfloat *) p)[0]);

+      break;

+

+   case TYPE_DOUBLEN:

+      params[0] = FLOAT_TO_BOOLEAN(((GLdouble *) p)[0]);

+      break;

+

+   case TYPE_INT_4:

+      params[3] = INT_TO_BOOLEAN(((GLint *) p)[3]);

+   case TYPE_INT_3:

+      params[2] = INT_TO_BOOLEAN(((GLint *) p)[2]);

+   case TYPE_INT_2:

+   case TYPE_ENUM_2:

+      params[1] = INT_TO_BOOLEAN(((GLint *) p)[1]);

+   case TYPE_INT:

+   case TYPE_ENUM:

+      params[0] = INT_TO_BOOLEAN(((GLint *) p)[0]);

+      break;

+

+   case TYPE_INT_N:

+      for (i = 0; i < v.value_int_n.n; i++)

+	 params[i] = INT_TO_BOOLEAN(v.value_int_n.ints[i]);

+      break;

+

+   case TYPE_INT64:

+      params[0] = INT64_TO_BOOLEAN(((GLint64 *) p)[0]);

+      break;

+

+   case TYPE_BOOLEAN:

+      params[0] = ((GLboolean*) p)[0];

+      break;		

+

+   case TYPE_MATRIX:

+      m = *(GLmatrix **) p;

+      for (i = 0; i < 16; i++)

+	 params[i] = FLOAT_TO_BOOLEAN(m->m[i]);

+      break;

+

+   case TYPE_MATRIX_T:

+      m = *(GLmatrix **) p;

+      for (i = 0; i < 16; i++)

+	 params[i] = FLOAT_TO_BOOLEAN(m->m[transpose[i]]);

+      break;

+

+   case TYPE_BIT_0:

+   case TYPE_BIT_1:

+   case TYPE_BIT_2:

+   case TYPE_BIT_3:

+   case TYPE_BIT_4:

+   case TYPE_BIT_5:

+      shift = d->type - TYPE_BIT_0;

+      params[0] = (*(GLbitfield *) p >> shift) & 1;

+      break;

+   }

+}

+

+void GLAPIENTRY

+_mesa_GetFloatv(GLenum pname, GLfloat *params)

+{

+   const struct value_desc *d;

+   union value v;

+   GLmatrix *m;

+   int shift, i;

+   void *p;

+

+   d = find_value("glGetFloatv", pname, &p, &v);

+   switch (d->type) {

+   case TYPE_INVALID:

+      break;

+   case TYPE_CONST:

+      params[0] = (GLfloat) d->offset;

+      break;

+

+   case TYPE_FLOAT_4:

+   case TYPE_FLOATN_4:

+      params[3] = ((GLfloat *) p)[3];

+   case TYPE_FLOAT_3:

+   case TYPE_FLOATN_3:

+      params[2] = ((GLfloat *) p)[2];

+   case TYPE_FLOAT_2:

+   case TYPE_FLOATN_2:

+      params[1] = ((GLfloat *) p)[1];

+   case TYPE_FLOAT:

+   case TYPE_FLOATN:

+      params[0] = ((GLfloat *) p)[0];

+      break;

+

+   case TYPE_DOUBLEN:

+      params[0] = ((GLdouble *) p)[0];

+      break;

+

+   case TYPE_INT_4:

+      params[3] = (GLfloat) (((GLint *) p)[3]);

+   case TYPE_INT_3:

+      params[2] = (GLfloat) (((GLint *) p)[2]);

+   case TYPE_INT_2:

+   case TYPE_ENUM_2:

+      params[1] = (GLfloat) (((GLint *) p)[1]);

+   case TYPE_INT:

+   case TYPE_ENUM:

+      params[0] = (GLfloat) (((GLint *) p)[0]);

+      break;

+

+   case TYPE_INT_N:

+      for (i = 0; i < v.value_int_n.n; i++)

+	 params[i] = INT_TO_FLOAT(v.value_int_n.ints[i]);

+      break;

+

+   case TYPE_INT64:

+      params[0] = ((GLint64 *) p)[0];

+      break;

+

+   case TYPE_BOOLEAN:

+      params[0] = BOOLEAN_TO_FLOAT(*(GLboolean*) p);

+      break;		

+

+   case TYPE_MATRIX:

+      m = *(GLmatrix **) p;

+      for (i = 0; i < 16; i++)

+	 params[i] = m->m[i];

+      break;

+

+   case TYPE_MATRIX_T:

+      m = *(GLmatrix **) p;

+      for (i = 0; i < 16; i++)

+	 params[i] = m->m[transpose[i]];

+      break;

+

+   case TYPE_BIT_0:

+   case TYPE_BIT_1:

+   case TYPE_BIT_2:

+   case TYPE_BIT_3:

+   case TYPE_BIT_4:

+   case TYPE_BIT_5:

+      shift = d->type - TYPE_BIT_0;

+      params[0] = BOOLEAN_TO_FLOAT((*(GLbitfield *) p >> shift) & 1);

+      break;

+   }

+}

+

+void GLAPIENTRY

+_mesa_GetIntegerv(GLenum pname, GLint *params)

+{

+   const struct value_desc *d;

+   union value v;

+   GLmatrix *m;

+   int shift, i;

+   void *p;

+

+   d = find_value("glGetIntegerv", pname, &p, &v);

+   switch (d->type) {

+   case TYPE_INVALID:

+      break;

+   case TYPE_CONST:

+      params[0] = d->offset;

+      break;

+

+   case TYPE_FLOAT_4:

+      params[3] = IROUND(((GLfloat *) p)[3]);

+   case TYPE_FLOAT_3:

+      params[2] = IROUND(((GLfloat *) p)[2]);

+   case TYPE_FLOAT_2:

+      params[1] = IROUND(((GLfloat *) p)[1]);

+   case TYPE_FLOAT:

+      params[0] = IROUND(((GLfloat *) p)[0]);

+      break;

+

+   case TYPE_FLOATN_4:

+      params[3] = FLOAT_TO_INT(((GLfloat *) p)[3]);

+   case TYPE_FLOATN_3:

+      params[2] = FLOAT_TO_INT(((GLfloat *) p)[2]);

+   case TYPE_FLOATN_2:

+      params[1] = FLOAT_TO_INT(((GLfloat *) p)[1]);

+   case TYPE_FLOATN:

+      params[0] = FLOAT_TO_INT(((GLfloat *) p)[0]);

+      break;

+

+   case TYPE_DOUBLEN:

+      params[0] = FLOAT_TO_INT(((GLdouble *) p)[0]);

+      break;

+

+   case TYPE_INT_4:

+      params[3] = ((GLint *) p)[3];

+   case TYPE_INT_3:

+      params[2] = ((GLint *) p)[2];

+   case TYPE_INT_2:

+   case TYPE_ENUM_2:

+      params[1] = ((GLint *) p)[1];

+   case TYPE_INT:

+   case TYPE_ENUM:

+      params[0] = ((GLint *) p)[0];

+      break;

+

+   case TYPE_INT_N:

+      for (i = 0; i < v.value_int_n.n; i++)

+	 params[i] = v.value_int_n.ints[i];

+      break;

+

+   case TYPE_INT64:

+      params[0] = INT64_TO_INT(((GLint64 *) p)[0]);

+      break;

+

+   case TYPE_BOOLEAN:

+      params[0] = BOOLEAN_TO_INT(*(GLboolean*) p);

+      break;		

+

+   case TYPE_MATRIX:

+      m = *(GLmatrix **) p;

+      for (i = 0; i < 16; i++)

+	 params[i] = FLOAT_TO_INT(m->m[i]);

+      break;

+

+   case TYPE_MATRIX_T:

+      m = *(GLmatrix **) p;

+      for (i = 0; i < 16; i++)

+	 params[i] = FLOAT_TO_INT(m->m[transpose[i]]);

+      break;

+

+   case TYPE_BIT_0:

+   case TYPE_BIT_1:

+   case TYPE_BIT_2:

+   case TYPE_BIT_3:

+   case TYPE_BIT_4:

+   case TYPE_BIT_5:

+      shift = d->type - TYPE_BIT_0;

+      params[0] = (*(GLbitfield *) p >> shift) & 1;

+      break;

+   }

+}

+

+#if FEATURE_ARB_sync

+void GLAPIENTRY

+_mesa_GetInteger64v(GLenum pname, GLint64 *params)

+{

+   const struct value_desc *d;

+   union value v;

+   GLmatrix *m;

+   int shift, i;

+   void *p;

+

+   d = find_value("glGetInteger64v", pname, &p, &v);

+   switch (d->type) {

+   case TYPE_INVALID:

+      break;

+   case TYPE_CONST:

+      params[0] = d->offset;

+      break;

+

+   case TYPE_FLOAT_4:

+      params[3] = IROUND64(((GLfloat *) p)[3]);

+   case TYPE_FLOAT_3:

+      params[2] = IROUND64(((GLfloat *) p)[2]);

+   case TYPE_FLOAT_2:

+      params[1] = IROUND64(((GLfloat *) p)[1]);

+   case TYPE_FLOAT:

+      params[0] = IROUND64(((GLfloat *) p)[0]);

+      break;

+

+   case TYPE_FLOATN_4:

+      params[3] = FLOAT_TO_INT64(((GLfloat *) p)[3]);

+   case TYPE_FLOATN_3:

+      params[2] = FLOAT_TO_INT64(((GLfloat *) p)[2]);

+   case TYPE_FLOATN_2:

+      params[1] = FLOAT_TO_INT64(((GLfloat *) p)[1]);

+   case TYPE_FLOATN:

+      params[0] = FLOAT_TO_INT64(((GLfloat *) p)[0]);

+      break;

+

+   case TYPE_DOUBLEN:

+      params[0] = FLOAT_TO_INT64(((GLdouble *) p)[0]);

+      break;

+

+   case TYPE_INT_4:

+      params[3] = ((GLint *) p)[3];

+   case TYPE_INT_3:

+      params[2] = ((GLint *) p)[2];

+   case TYPE_INT_2:

+   case TYPE_ENUM_2:

+      params[1] = ((GLint *) p)[1];

+   case TYPE_INT:

+   case TYPE_ENUM:

+      params[0] = ((GLint *) p)[0];

+      break;

+

+   case TYPE_INT_N:

+      for (i = 0; i < v.value_int_n.n; i++)

+	 params[i] = INT_TO_BOOLEAN(v.value_int_n.ints[i]);

+      break;

+

+   case TYPE_INT64:

+      params[0] = ((GLint64 *) p)[0];

+      break;

+

+   case TYPE_BOOLEAN:

+      params[0] = ((GLboolean*) p)[0];

+      break;		

+

+   case TYPE_MATRIX:

+      m = *(GLmatrix **) p;

+      for (i = 0; i < 16; i++)

+	 params[i] = FLOAT_TO_INT64(m->m[i]);

+      break;

+

+   case TYPE_MATRIX_T:

+      m = *(GLmatrix **) p;

+      for (i = 0; i < 16; i++)

+	 params[i] = FLOAT_TO_INT64(m->m[transpose[i]]);

+      break;

+

+   case TYPE_BIT_0:

+   case TYPE_BIT_1:

+   case TYPE_BIT_2:

+   case TYPE_BIT_3:

+   case TYPE_BIT_4:

+   case TYPE_BIT_5:

+      shift = d->type - TYPE_BIT_0;

+      params[0] = (*(GLbitfield *) p >> shift) & 1;

+      break;

+   }

+}

+#endif /* FEATURE_ARB_sync */

+

+void GLAPIENTRY

+_mesa_GetDoublev(GLenum pname, GLdouble *params)

+{

+   const struct value_desc *d;

+   union value v;

+   GLmatrix *m;

+   int shift, i;

+   void *p;

+

+   d = find_value("glGetDoublev", pname, &p, &v);

+   switch (d->type) {

+   case TYPE_INVALID:

+      break;

+   case TYPE_CONST:

+      params[0] = d->offset;

+      break;

+

+   case TYPE_FLOAT_4:

+   case TYPE_FLOATN_4:

+      params[3] = ((GLfloat *) p)[3];

+   case TYPE_FLOAT_3:

+   case TYPE_FLOATN_3:

+      params[2] = ((GLfloat *) p)[2];

+   case TYPE_FLOAT_2:

+   case TYPE_FLOATN_2:

+      params[1] = ((GLfloat *) p)[1];

+   case TYPE_FLOAT:

+   case TYPE_FLOATN:

+      params[0] = ((GLfloat *) p)[0];

+      break;

+

+   case TYPE_DOUBLEN:

+      params[0] = ((GLdouble *) p)[0];

+      break;

+

+   case TYPE_INT_4:

+      params[3] = ((GLint *) p)[3];

+   case TYPE_INT_3:

+      params[2] = ((GLint *) p)[2];

+   case TYPE_INT_2:

+   case TYPE_ENUM_2:

+      params[1] = ((GLint *) p)[1];

+   case TYPE_INT:

+   case TYPE_ENUM:

+      params[0] = ((GLint *) p)[0];

+      break;

+

+   case TYPE_INT_N:

+      for (i = 0; i < v.value_int_n.n; i++)

+	 params[i] = v.value_int_n.ints[i];

+      break;

+

+   case TYPE_INT64:

+      params[0] = ((GLint64 *) p)[0];

+      break;

+

+   case TYPE_BOOLEAN:

+      params[0] = *(GLboolean*) p;

+      break;		

+

+   case TYPE_MATRIX:

+      m = *(GLmatrix **) p;

+      for (i = 0; i < 16; i++)

+	 params[i] = m->m[i];

+      break;

+

+   case TYPE_MATRIX_T:

+      m = *(GLmatrix **) p;

+      for (i = 0; i < 16; i++)

+	 params[i] = m->m[transpose[i]];

+      break;

+

+   case TYPE_BIT_0:

+   case TYPE_BIT_1:

+   case TYPE_BIT_2:

+   case TYPE_BIT_3:

+   case TYPE_BIT_4:

+   case TYPE_BIT_5:

+      shift = d->type - TYPE_BIT_0;

+      params[0] = (*(GLbitfield *) p >> shift) & 1;

+      break;

+   }

+}

+

+static enum value_type

+find_value_indexed(const char *func, GLenum pname, int index, union value *v)

+{

+   GET_CURRENT_CONTEXT(ctx);

+

+   switch (pname) {

+

+   case GL_BLEND:

+      if (index >= ctx->Const.MaxDrawBuffers)

+	 goto invalid_value;

+      if (!ctx->Extensions.EXT_draw_buffers2)

+	 goto invalid_enum;

+      v->value_int = (ctx->Color.BlendEnabled >> index) & 1;

+      return TYPE_INT;

+

+   case GL_BLEND_SRC:

+      /* fall-through */

+   case GL_BLEND_SRC_RGB:

+      if (index >= ctx->Const.MaxDrawBuffers)

+	 goto invalid_value;

+      if (!ctx->Extensions.ARB_draw_buffers_blend)

+	 goto invalid_enum;

+      v->value_int = ctx->Color.Blend[index].SrcRGB;

+      return TYPE_INT;

+   case GL_BLEND_SRC_ALPHA:

+      if (index >= ctx->Const.MaxDrawBuffers)

+	 goto invalid_value;

+      if (!ctx->Extensions.ARB_draw_buffers_blend)

+	 goto invalid_enum;

+      v->value_int = ctx->Color.Blend[index].SrcA;

+      return TYPE_INT;

+   case GL_BLEND_DST:

+      /* fall-through */

+   case GL_BLEND_DST_RGB:

+      if (index >= ctx->Const.MaxDrawBuffers)

+	 goto invalid_value;

+      if (!ctx->Extensions.ARB_draw_buffers_blend)

+	 goto invalid_enum;

+      v->value_int = ctx->Color.Blend[index].DstRGB;

+      return TYPE_INT;

+   case GL_BLEND_DST_ALPHA:

+      if (index >= ctx->Const.MaxDrawBuffers)

+	 goto invalid_value;

+      if (!ctx->Extensions.ARB_draw_buffers_blend)

+	 goto invalid_enum;

+      v->value_int = ctx->Color.Blend[index].DstA;

+      return TYPE_INT;

+   case GL_BLEND_EQUATION_RGB:

+      if (index >= ctx->Const.MaxDrawBuffers)

+	 goto invalid_value;

+      if (!ctx->Extensions.ARB_draw_buffers_blend)

+	 goto invalid_enum;

+      v->value_int = ctx->Color.Blend[index].EquationRGB;

+      return TYPE_INT;

+   case GL_BLEND_EQUATION_ALPHA:

+      if (index >= ctx->Const.MaxDrawBuffers)

+	 goto invalid_value;

+      if (!ctx->Extensions.ARB_draw_buffers_blend)

+	 goto invalid_enum;

+      v->value_int = ctx->Color.Blend[index].EquationA;

+      return TYPE_INT;

+

+   case GL_COLOR_WRITEMASK:

+      if (index >= ctx->Const.MaxDrawBuffers)

+	 goto invalid_value;

+      if (!ctx->Extensions.EXT_draw_buffers2)

+	 goto invalid_enum;

+      v->value_int_4[0] = ctx->Color.ColorMask[index][RCOMP] ? 1 : 0;

+      v->value_int_4[1] = ctx->Color.ColorMask[index][GCOMP] ? 1 : 0;

+      v->value_int_4[2] = ctx->Color.ColorMask[index][BCOMP] ? 1 : 0;

+      v->value_int_4[3] = ctx->Color.ColorMask[index][ACOMP] ? 1 : 0;

+      return TYPE_INT_4;

+

+   case GL_TRANSFORM_FEEDBACK_BUFFER_START:

+      if (index >= ctx->Const.MaxTransformFeedbackSeparateAttribs)

+	 goto invalid_value;

+      if (!ctx->Extensions.EXT_transform_feedback)

+	 goto invalid_enum;

+      v->value_int64 = ctx->TransformFeedback.CurrentObject->Offset[index];

+      return TYPE_INT64;

+

+   case GL_TRANSFORM_FEEDBACK_BUFFER_SIZE:

+      if (index >= ctx->Const.MaxTransformFeedbackSeparateAttribs)

+	 goto invalid_value;

+      if (!ctx->Extensions.EXT_transform_feedback)

+	 goto invalid_enum;

+      v->value_int64 = ctx->TransformFeedback.CurrentObject->Size[index];

+      return TYPE_INT64;

+

+   case GL_TRANSFORM_FEEDBACK_BUFFER_BINDING:

+      if (index >= ctx->Const.MaxTransformFeedbackSeparateAttribs)

+	 goto invalid_value;

+      if (!ctx->Extensions.EXT_transform_feedback)

+	 goto invalid_enum;

+      v->value_int = ctx->TransformFeedback.CurrentObject->Buffers[index]->Name;

+      return TYPE_INT;

+   }

+

+ invalid_enum:

+   _mesa_error(ctx, GL_INVALID_ENUM, "%s(pname=%s)", func,

+               _mesa_lookup_enum_by_nr(pname));

+   return TYPE_INVALID;

+ invalid_value:

+   _mesa_error(ctx, GL_INVALID_VALUE, "%s(pname=%s)", func,

+               _mesa_lookup_enum_by_nr(pname));

+   return TYPE_INVALID;

+}

+

+void GLAPIENTRY

+_mesa_GetBooleanIndexedv( GLenum pname, GLuint index, GLboolean *params )

+{

+   union value v;

+   enum value_type type =

+      find_value_indexed("glGetBooleanIndexedv", pname, index, &v);

+

+   switch (type) {

+   case TYPE_INT:

+      params[0] = INT_TO_BOOLEAN(v.value_int);

+      break;

+   case TYPE_INT_4:

+      params[0] = INT_TO_BOOLEAN(v.value_int_4[0]);

+      params[1] = INT_TO_BOOLEAN(v.value_int_4[1]);

+      params[2] = INT_TO_BOOLEAN(v.value_int_4[2]);

+      params[3] = INT_TO_BOOLEAN(v.value_int_4[3]);

+      break;

+   case TYPE_INT64:

+      params[0] = INT64_TO_BOOLEAN(v.value_int);

+      break;

+   default:

+      ; /* nothing - GL error was recorded */

+   }

+}

+

+void GLAPIENTRY

+_mesa_GetIntegerIndexedv( GLenum pname, GLuint index, GLint *params )

+{

+   union value v;

+   enum value_type type =

+      find_value_indexed("glGetIntegerIndexedv", pname, index, &v);

+

+   switch (type) {

+   case TYPE_INT:

+      params[0] = v.value_int;

+      break;

+   case TYPE_INT_4:

+      params[0] = v.value_int_4[0];

+      params[1] = v.value_int_4[1];

+      params[2] = v.value_int_4[2];

+      params[3] = v.value_int_4[3];

+      break;

+   case TYPE_INT64:

+      params[0] = INT64_TO_INT(v.value_int);

+      break;

+   default:

+      ; /* nothing - GL error was recorded */

+   }

+}

+

+#if FEATURE_ARB_sync

+void GLAPIENTRY

+_mesa_GetInteger64Indexedv( GLenum pname, GLuint index, GLint64 *params )

+{

+   union value v;

+   enum value_type type =

+      find_value_indexed("glGetIntegerIndexedv", pname, index, &v);      

+

+   switch (type) {

+   case TYPE_INT:

+      params[0] = v.value_int;

+      break;

+   case TYPE_INT_4:

+      params[0] = v.value_int_4[0];

+      params[1] = v.value_int_4[1];

+      params[2] = v.value_int_4[2];

+      params[3] = v.value_int_4[3];

+      break;

+   case TYPE_INT64:

+      params[0] = v.value_int;

+      break;

+   default:

+      ; /* nothing - GL error was recorded */

+   }

+}

+#endif /* FEATURE_ARB_sync */

+

+#if FEATURE_ES1

+void GLAPIENTRY

+_mesa_GetFixedv(GLenum pname, GLfixed *params)

+{

+   const struct value_desc *d;

+   union value v;

+   GLmatrix *m;

+   int shift, i;

+   void *p;

+

+   d = find_value("glGetDoublev", pname, &p, &v);

+   switch (d->type) {

+   case TYPE_INVALID:

+      break;

+   case TYPE_CONST:

+      params[0] = INT_TO_FIXED(d->offset);

+      break;

+

+   case TYPE_FLOAT_4:

+   case TYPE_FLOATN_4:

+      params[3] = FLOAT_TO_FIXED(((GLfloat *) p)[3]);

+   case TYPE_FLOAT_3:

+   case TYPE_FLOATN_3:

+      params[2] = FLOAT_TO_FIXED(((GLfloat *) p)[2]);

+   case TYPE_FLOAT_2:

+   case TYPE_FLOATN_2:

+      params[1] = FLOAT_TO_FIXED(((GLfloat *) p)[1]);

+   case TYPE_FLOAT:

+   case TYPE_FLOATN:

+      params[0] = FLOAT_TO_FIXED(((GLfloat *) p)[0]);

+      break;

+

+   case TYPE_DOUBLEN:

+      params[0] = FLOAT_TO_FIXED(((GLdouble *) p)[0]);

+      break;

+

+   case TYPE_INT_4:

+      params[3] = INT_TO_FIXED(((GLint *) p)[3]);

+   case TYPE_INT_3:

+      params[2] = INT_TO_FIXED(((GLint *) p)[2]);

+   case TYPE_INT_2:

+   case TYPE_ENUM_2:

+      params[1] = INT_TO_FIXED(((GLint *) p)[1]);

+   case TYPE_INT:

+   case TYPE_ENUM:

+      params[0] = INT_TO_FIXED(((GLint *) p)[0]);

+      break;

+

+   case TYPE_INT_N:

+      for (i = 0; i < v.value_int_n.n; i++)

+	 params[i] = INT_TO_FIXED(v.value_int_n.ints[i]);

+      break;

+

+   case TYPE_INT64:

+      params[0] = ((GLint64 *) p)[0];

+      break;

+

+   case TYPE_BOOLEAN:

+      params[0] = BOOLEAN_TO_FIXED(((GLboolean*) p)[0]);

+      break;		

+

+   case TYPE_MATRIX:

+      m = *(GLmatrix **) p;

+      for (i = 0; i < 16; i++)

+	 params[i] = FLOAT_TO_FIXED(m->m[i]);

+      break;

+

+   case TYPE_MATRIX_T:

+      m = *(GLmatrix **) p;

+      for (i = 0; i < 16; i++)

+	 params[i] = FLOAT_TO_FIXED(m->m[transpose[i]]);

+      break;

+

+   case TYPE_BIT_0:

+   case TYPE_BIT_1:

+   case TYPE_BIT_2:

+   case TYPE_BIT_3:

+   case TYPE_BIT_4:

+   case TYPE_BIT_5:

+      shift = d->type - TYPE_BIT_0;

+      params[0] = BOOLEAN_TO_FIXED((*(GLbitfield *) p >> shift) & 1);

+      break;

+   }

+}

+#endif

diff --git a/mesalib/src/mesa/main/mtypes.h b/mesalib/src/mesa/main/mtypes.h
index 695d93652..520d96689 100644
--- a/mesalib/src/mesa/main/mtypes.h
+++ b/mesalib/src/mesa/main/mtypes.h
@@ -1,3360 +1,3362 @@
-/*
- * Mesa 3-D graphics library
- * Version:  7.7
- *
- * 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 mtypes.h
- * Main Mesa data structures.
- *
- * Please try to mark derived values with a leading underscore ('_').
- */
-
-#ifndef MTYPES_H
-#define MTYPES_H
-
-
-#include "main/glheader.h"
-#include "main/config.h"
-#include "main/mfeatures.h"
-#include "glapi/glapi.h"
-#include "math/m_matrix.h"	/* GLmatrix */
-#include "main/simple_list.h"	/* struct simple_node */
-#include "main/formats.h"       /* MESA_FORMAT_COUNT */
-
-
-/**
- * Color channel data type.
- */
-#if CHAN_BITS == 8
-   typedef GLubyte GLchan;
-#define CHAN_MAX 255
-#define CHAN_MAXF 255.0F
-#define CHAN_TYPE GL_UNSIGNED_BYTE
-#elif CHAN_BITS == 16
-   typedef GLushort GLchan;
-#define CHAN_MAX 65535
-#define CHAN_MAXF 65535.0F
-#define CHAN_TYPE GL_UNSIGNED_SHORT
-#elif CHAN_BITS == 32
-   typedef GLfloat GLchan;
-#define CHAN_MAX 1.0
-#define CHAN_MAXF 1.0F
-#define CHAN_TYPE GL_FLOAT
-#else
-#error "illegal number of color channel bits"
-#endif
-
-
-/**
- * Stencil buffer data type.
- */
-#if STENCIL_BITS==8
-   typedef GLubyte GLstencil;
-#elif STENCIL_BITS==16
-   typedef GLushort GLstencil;
-#else
-#  error "illegal number of stencil bits"
-#endif
-
-
-/**
- * \name 64-bit extension of GLbitfield.
- */
-/*@{*/
-typedef GLuint64 GLbitfield64;
-
-/** Set a single bit */
-#define BITFIELD64_BIT(b)      (1ULL << (b))
-
-
-/**
- * \name Some forward type declarations
- */
-/*@{*/
-struct _mesa_HashTable;
-struct gl_attrib_node;
-struct gl_list_extensions;
-struct gl_meta_state;
-struct gl_pixelstore_attrib;
-struct gl_program_cache;
-struct gl_texture_format;
-struct gl_texture_image;
-struct gl_texture_object;
-struct gl_context;
-struct st_context;
-/*@}*/
-
-
-/** Extra draw modes beyond GL_POINTS, GL_TRIANGLE_FAN, etc */
-#define PRIM_OUTSIDE_BEGIN_END   (GL_POLYGON+1)
-#define PRIM_INSIDE_UNKNOWN_PRIM (GL_POLYGON+2)
-#define PRIM_UNKNOWN             (GL_POLYGON+3)
-
-
-/**
- * Shader stages. Note that these will become 5 with tessellation.
- * These MUST have the same values as gallium's PIPE_SHADER_*
- */
-typedef enum
-{
-   MESA_SHADER_VERTEX = 0,
-   MESA_SHADER_FRAGMENT = 1,
-   MESA_SHADER_GEOMETRY = 2,
-   MESA_SHADER_TYPES = 3
-} gl_shader_type;
-
-
-
-/**
- * Indexes for vertex program attributes.
- * GL_NV_vertex_program aliases generic attributes over the conventional
- * attributes.  In GL_ARB_vertex_program shader the aliasing is optional.
- * In GL_ARB_vertex_shader / OpenGL 2.0 the aliasing is disallowed (the
- * generic attributes are distinct/separate).
- */
-typedef enum
-{
-   VERT_ATTRIB_POS = 0,
-   VERT_ATTRIB_WEIGHT = 1,
-   VERT_ATTRIB_NORMAL = 2,
-   VERT_ATTRIB_COLOR0 = 3,
-   VERT_ATTRIB_COLOR1 = 4,
-   VERT_ATTRIB_FOG = 5,
-   VERT_ATTRIB_COLOR_INDEX = 6,
-   VERT_ATTRIB_POINT_SIZE = 6,  /*alias*/
-   VERT_ATTRIB_EDGEFLAG = 7,
-   VERT_ATTRIB_TEX0 = 8,
-   VERT_ATTRIB_TEX1 = 9,
-   VERT_ATTRIB_TEX2 = 10,
-   VERT_ATTRIB_TEX3 = 11,
-   VERT_ATTRIB_TEX4 = 12,
-   VERT_ATTRIB_TEX5 = 13,
-   VERT_ATTRIB_TEX6 = 14,
-   VERT_ATTRIB_TEX7 = 15,
-   VERT_ATTRIB_GENERIC0 = 16,
-   VERT_ATTRIB_GENERIC1 = 17,
-   VERT_ATTRIB_GENERIC2 = 18,
-   VERT_ATTRIB_GENERIC3 = 19,
-   VERT_ATTRIB_GENERIC4 = 20,
-   VERT_ATTRIB_GENERIC5 = 21,
-   VERT_ATTRIB_GENERIC6 = 22,
-   VERT_ATTRIB_GENERIC7 = 23,
-   VERT_ATTRIB_GENERIC8 = 24,
-   VERT_ATTRIB_GENERIC9 = 25,
-   VERT_ATTRIB_GENERIC10 = 26,
-   VERT_ATTRIB_GENERIC11 = 27,
-   VERT_ATTRIB_GENERIC12 = 28,
-   VERT_ATTRIB_GENERIC13 = 29,
-   VERT_ATTRIB_GENERIC14 = 30,
-   VERT_ATTRIB_GENERIC15 = 31,
-   VERT_ATTRIB_MAX = 32
-} gl_vert_attrib;
-
-/**
- * Bitflags for vertex attributes.
- * These are used in bitfields in many places.
- */
-/*@{*/
-#define VERT_BIT_POS         (1 << VERT_ATTRIB_POS)
-#define VERT_BIT_WEIGHT      (1 << VERT_ATTRIB_WEIGHT)
-#define VERT_BIT_NORMAL      (1 << VERT_ATTRIB_NORMAL)
-#define VERT_BIT_COLOR0      (1 << VERT_ATTRIB_COLOR0)
-#define VERT_BIT_COLOR1      (1 << VERT_ATTRIB_COLOR1)
-#define VERT_BIT_FOG         (1 << VERT_ATTRIB_FOG)
-#define VERT_BIT_COLOR_INDEX (1 << VERT_ATTRIB_COLOR_INDEX)
-#define VERT_BIT_EDGEFLAG    (1 << VERT_ATTRIB_EDGEFLAG)
-#define VERT_BIT_TEX0        (1 << VERT_ATTRIB_TEX0)
-#define VERT_BIT_TEX1        (1 << VERT_ATTRIB_TEX1)
-#define VERT_BIT_TEX2        (1 << VERT_ATTRIB_TEX2)
-#define VERT_BIT_TEX3        (1 << VERT_ATTRIB_TEX3)
-#define VERT_BIT_TEX4        (1 << VERT_ATTRIB_TEX4)
-#define VERT_BIT_TEX5        (1 << VERT_ATTRIB_TEX5)
-#define VERT_BIT_TEX6        (1 << VERT_ATTRIB_TEX6)
-#define VERT_BIT_TEX7        (1 << VERT_ATTRIB_TEX7)
-#define VERT_BIT_GENERIC0    (1 << VERT_ATTRIB_GENERIC0)
-#define VERT_BIT_GENERIC1    (1 << VERT_ATTRIB_GENERIC1)
-#define VERT_BIT_GENERIC2    (1 << VERT_ATTRIB_GENERIC2)
-#define VERT_BIT_GENERIC3    (1 << VERT_ATTRIB_GENERIC3)
-#define VERT_BIT_GENERIC4    (1 << VERT_ATTRIB_GENERIC4)
-#define VERT_BIT_GENERIC5    (1 << VERT_ATTRIB_GENERIC5)
-#define VERT_BIT_GENERIC6    (1 << VERT_ATTRIB_GENERIC6)
-#define VERT_BIT_GENERIC7    (1 << VERT_ATTRIB_GENERIC7)
-#define VERT_BIT_GENERIC8    (1 << VERT_ATTRIB_GENERIC8)
-#define VERT_BIT_GENERIC9    (1 << VERT_ATTRIB_GENERIC9)
-#define VERT_BIT_GENERIC10   (1 << VERT_ATTRIB_GENERIC10)
-#define VERT_BIT_GENERIC11   (1 << VERT_ATTRIB_GENERIC11)
-#define VERT_BIT_GENERIC12   (1 << VERT_ATTRIB_GENERIC12)
-#define VERT_BIT_GENERIC13   (1 << VERT_ATTRIB_GENERIC13)
-#define VERT_BIT_GENERIC14   (1 << VERT_ATTRIB_GENERIC14)
-#define VERT_BIT_GENERIC15   (1 << VERT_ATTRIB_GENERIC15)
-
-#define VERT_BIT_TEX(u)  (1 << (VERT_ATTRIB_TEX0 + (u)))
-#define VERT_BIT_GENERIC(g)  (1 << (VERT_ATTRIB_GENERIC0 + (g)))
-/*@}*/
-
-
-/**
- * Indexes for vertex program result attributes
- */
-typedef enum
-{
-   VERT_RESULT_HPOS = 0,
-   VERT_RESULT_COL0 = 1,
-   VERT_RESULT_COL1 = 2,
-   VERT_RESULT_FOGC = 3,
-   VERT_RESULT_TEX0 = 4,
-   VERT_RESULT_TEX1 = 5,
-   VERT_RESULT_TEX2 = 6,
-   VERT_RESULT_TEX3 = 7,
-   VERT_RESULT_TEX4 = 8,
-   VERT_RESULT_TEX5 = 9,
-   VERT_RESULT_TEX6 = 10,
-   VERT_RESULT_TEX7 = 11,
-   VERT_RESULT_PSIZ = 12,
-   VERT_RESULT_BFC0 = 13,
-   VERT_RESULT_BFC1 = 14,
-   VERT_RESULT_EDGE = 15,
-   VERT_RESULT_VAR0 = 16,  /**< shader varying */
-   VERT_RESULT_MAX = (VERT_RESULT_VAR0 + MAX_VARYING)
-} gl_vert_result;
-
-
-/*********************************************/
-
-/**
- * Indexes for geometry program attributes.
- */
-typedef enum
-{
-   GEOM_ATTRIB_POSITION = 0,
-   GEOM_ATTRIB_COLOR0 = 1,
-   GEOM_ATTRIB_COLOR1 = 2,
-   GEOM_ATTRIB_SECONDARY_COLOR0 = 3,
-   GEOM_ATTRIB_SECONDARY_COLOR1 = 4,
-   GEOM_ATTRIB_FOG_FRAG_COORD = 5,
-   GEOM_ATTRIB_POINT_SIZE = 6,
-   GEOM_ATTRIB_CLIP_VERTEX = 7,
-   GEOM_ATTRIB_PRIMITIVE_ID = 8,
-   GEOM_ATTRIB_TEX_COORD = 9,
-
-   GEOM_ATTRIB_VAR0 = 16,
-   GEOM_ATTRIB_MAX = (GEOM_ATTRIB_VAR0 + MAX_VARYING)
-} gl_geom_attrib;
-
-/**
- * Bitflags for geometry attributes.
- * These are used in bitfields in many places.
- */
-/*@{*/
-#define GEOM_BIT_COLOR0      (1 << GEOM_ATTRIB_COLOR0)
-#define GEOM_BIT_COLOR1      (1 << GEOM_ATTRIB_COLOR1)
-#define GEOM_BIT_SCOLOR0     (1 << GEOM_ATTRIB_SECONDARY_COLOR0)
-#define GEOM_BIT_SCOLOR1     (1 << GEOM_ATTRIB_SECONDARY_COLOR1)
-#define GEOM_BIT_TEX_COORD   (1 << GEOM_ATTRIB_TEX_COORD)
-#define GEOM_BIT_FOG_COORD   (1 << GEOM_ATTRIB_FOG_FRAG_COORD)
-#define GEOM_BIT_POSITION    (1 << GEOM_ATTRIB_POSITION)
-#define GEOM_BIT_POINT_SIDE  (1 << GEOM_ATTRIB_POINT_SIZE)
-#define GEOM_BIT_CLIP_VERTEX (1 << GEOM_ATTRIB_CLIP_VERTEX)
-#define GEOM_BIT_PRIM_ID     (1 << GEOM_ATTRIB_PRIMITIVE_ID)
-#define GEOM_BIT_VAR0        (1 << GEOM_ATTRIB_VAR0)
-
-#define GEOM_BIT_VAR(g)  (1 << (GEOM_BIT_VAR0 + (g)))
-/*@}*/
-
-
-/**
- * Indexes for geometry program result attributes
- */
-typedef enum
-{
-   GEOM_RESULT_POS  = 0,
-   GEOM_RESULT_COL0  = 1,
-   GEOM_RESULT_COL1  = 2,
-   GEOM_RESULT_SCOL0 = 3,
-   GEOM_RESULT_SCOL1 = 4,
-   GEOM_RESULT_FOGC = 5,
-   GEOM_RESULT_TEX0 = 6,
-   GEOM_RESULT_TEX1 = 7,
-   GEOM_RESULT_TEX2 = 8,
-   GEOM_RESULT_TEX3 = 9,
-   GEOM_RESULT_TEX4 = 10,
-   GEOM_RESULT_TEX5 = 11,
-   GEOM_RESULT_TEX6 = 12,
-   GEOM_RESULT_TEX7 = 13,
-   GEOM_RESULT_PSIZ = 14,
-   GEOM_RESULT_CLPV = 15,
-   GEOM_RESULT_PRID = 16,
-   GEOM_RESULT_LAYR = 17,
-   GEOM_RESULT_VAR0 = 18,  /**< shader varying, should really be 16 */
-   /* ### we need to -2 because var0 is 18 instead 16 like in the others */
-   GEOM_RESULT_MAX  =  (GEOM_RESULT_VAR0 + MAX_VARYING - 2)
-} gl_geom_result;
-
-
-/**
- * Indexes for fragment program input attributes.
- */
-typedef enum
-{
-   FRAG_ATTRIB_WPOS = 0,
-   FRAG_ATTRIB_COL0 = 1,
-   FRAG_ATTRIB_COL1 = 2,
-   FRAG_ATTRIB_FOGC = 3,
-   FRAG_ATTRIB_TEX0 = 4,
-   FRAG_ATTRIB_TEX1 = 5,
-   FRAG_ATTRIB_TEX2 = 6,
-   FRAG_ATTRIB_TEX3 = 7,
-   FRAG_ATTRIB_TEX4 = 8,
-   FRAG_ATTRIB_TEX5 = 9,
-   FRAG_ATTRIB_TEX6 = 10,
-   FRAG_ATTRIB_TEX7 = 11,
-   FRAG_ATTRIB_FACE = 12,  /**< front/back face */
-   FRAG_ATTRIB_PNTC = 13,  /**< sprite/point coord */
-   FRAG_ATTRIB_VAR0 = 14,  /**< shader varying */
-   FRAG_ATTRIB_MAX = (FRAG_ATTRIB_VAR0 + MAX_VARYING)
-} gl_frag_attrib;
-
-/**
- * Bitflags for fragment program input attributes.
- */
-/*@{*/
-#define FRAG_BIT_WPOS  (1 << FRAG_ATTRIB_WPOS)
-#define FRAG_BIT_COL0  (1 << FRAG_ATTRIB_COL0)
-#define FRAG_BIT_COL1  (1 << FRAG_ATTRIB_COL1)
-#define FRAG_BIT_FOGC  (1 << FRAG_ATTRIB_FOGC)
-#define FRAG_BIT_FACE  (1 << FRAG_ATTRIB_FACE)
-#define FRAG_BIT_PNTC  (1 << FRAG_ATTRIB_PNTC)
-#define FRAG_BIT_TEX0  (1 << FRAG_ATTRIB_TEX0)
-#define FRAG_BIT_TEX1  (1 << FRAG_ATTRIB_TEX1)
-#define FRAG_BIT_TEX2  (1 << FRAG_ATTRIB_TEX2)
-#define FRAG_BIT_TEX3  (1 << FRAG_ATTRIB_TEX3)
-#define FRAG_BIT_TEX4  (1 << FRAG_ATTRIB_TEX4)
-#define FRAG_BIT_TEX5  (1 << FRAG_ATTRIB_TEX5)
-#define FRAG_BIT_TEX6  (1 << FRAG_ATTRIB_TEX6)
-#define FRAG_BIT_TEX7  (1 << FRAG_ATTRIB_TEX7)
-#define FRAG_BIT_VAR0  (1 << FRAG_ATTRIB_VAR0)
-
-#define FRAG_BIT_TEX(U)  (FRAG_BIT_TEX0 << (U))
-#define FRAG_BIT_VAR(V)  (FRAG_BIT_VAR0 << (V))
-
-#define FRAG_BITS_TEX_ANY (FRAG_BIT_TEX0|	\
-			   FRAG_BIT_TEX1|	\
-			   FRAG_BIT_TEX2|	\
-			   FRAG_BIT_TEX3|	\
-			   FRAG_BIT_TEX4|	\
-			   FRAG_BIT_TEX5|	\
-			   FRAG_BIT_TEX6|	\
-			   FRAG_BIT_TEX7)
-/*@}*/
-
-
-/**
- * Fragment program results
- */
-typedef enum
-{
-   FRAG_RESULT_DEPTH = 0,
-   FRAG_RESULT_STENCIL = 1,
-   FRAG_RESULT_COLOR = 2,
-   FRAG_RESULT_DATA0 = 3,
-   FRAG_RESULT_MAX = (FRAG_RESULT_DATA0 + MAX_DRAW_BUFFERS)
-} gl_frag_result;
-
-
-/**
- * Indexes for all renderbuffers
- */
-typedef enum
-{
-   /* the four standard color buffers */
-   BUFFER_FRONT_LEFT,
-   BUFFER_BACK_LEFT,
-   BUFFER_FRONT_RIGHT,
-   BUFFER_BACK_RIGHT,
-   BUFFER_DEPTH,
-   BUFFER_STENCIL,
-   BUFFER_ACCUM,
-   /* optional aux buffer */
-   BUFFER_AUX0,
-   /* generic renderbuffers */
-   BUFFER_COLOR0,
-   BUFFER_COLOR1,
-   BUFFER_COLOR2,
-   BUFFER_COLOR3,
-   BUFFER_COLOR4,
-   BUFFER_COLOR5,
-   BUFFER_COLOR6,
-   BUFFER_COLOR7,
-   BUFFER_COUNT
-} gl_buffer_index;
-
-/**
- * Bit flags for all renderbuffers
- */
-#define BUFFER_BIT_FRONT_LEFT   (1 << BUFFER_FRONT_LEFT)
-#define BUFFER_BIT_BACK_LEFT    (1 << BUFFER_BACK_LEFT)
-#define BUFFER_BIT_FRONT_RIGHT  (1 << BUFFER_FRONT_RIGHT)
-#define BUFFER_BIT_BACK_RIGHT   (1 << BUFFER_BACK_RIGHT)
-#define BUFFER_BIT_AUX0         (1 << BUFFER_AUX0)
-#define BUFFER_BIT_AUX1         (1 << BUFFER_AUX1)
-#define BUFFER_BIT_AUX2         (1 << BUFFER_AUX2)
-#define BUFFER_BIT_AUX3         (1 << BUFFER_AUX3)
-#define BUFFER_BIT_DEPTH        (1 << BUFFER_DEPTH)
-#define BUFFER_BIT_STENCIL      (1 << BUFFER_STENCIL)
-#define BUFFER_BIT_ACCUM        (1 << BUFFER_ACCUM)
-#define BUFFER_BIT_COLOR0       (1 << BUFFER_COLOR0)
-#define BUFFER_BIT_COLOR1       (1 << BUFFER_COLOR1)
-#define BUFFER_BIT_COLOR2       (1 << BUFFER_COLOR2)
-#define BUFFER_BIT_COLOR3       (1 << BUFFER_COLOR3)
-#define BUFFER_BIT_COLOR4       (1 << BUFFER_COLOR4)
-#define BUFFER_BIT_COLOR5       (1 << BUFFER_COLOR5)
-#define BUFFER_BIT_COLOR6       (1 << BUFFER_COLOR6)
-#define BUFFER_BIT_COLOR7       (1 << BUFFER_COLOR7)
-
-/**
- * Mask of all the color buffer bits (but not accum).
- */
-#define BUFFER_BITS_COLOR  (BUFFER_BIT_FRONT_LEFT | \
-                            BUFFER_BIT_BACK_LEFT | \
-                            BUFFER_BIT_FRONT_RIGHT | \
-                            BUFFER_BIT_BACK_RIGHT | \
-                            BUFFER_BIT_AUX0 | \
-                            BUFFER_BIT_COLOR0 | \
-                            BUFFER_BIT_COLOR1 | \
-                            BUFFER_BIT_COLOR2 | \
-                            BUFFER_BIT_COLOR3 | \
-                            BUFFER_BIT_COLOR4 | \
-                            BUFFER_BIT_COLOR5 | \
-                            BUFFER_BIT_COLOR6 | \
-                            BUFFER_BIT_COLOR7)
-
-
-/**
- * Framebuffer configuration (aka visual / pixelformat)
- * Note: some of these fields should be boolean, but it appears that
- * code in drivers/dri/common/util.c requires int-sized fields.
- */
-struct gl_config
-{
-   GLboolean rgbMode;
-   GLboolean floatMode;
-   GLboolean colorIndexMode;  /* XXX is this used anywhere? */
-   GLuint doubleBufferMode;
-   GLuint stereoMode;
-
-   GLboolean haveAccumBuffer;
-   GLboolean haveDepthBuffer;
-   GLboolean haveStencilBuffer;
-
-   GLint redBits, greenBits, blueBits, alphaBits;	/* bits per comp */
-   GLuint redMask, greenMask, blueMask, alphaMask;
-   GLint rgbBits;		/* total bits for rgb */
-   GLint indexBits;		/* total bits for colorindex */
-
-   GLint accumRedBits, accumGreenBits, accumBlueBits, accumAlphaBits;
-   GLint depthBits;
-   GLint stencilBits;
-
-   GLint numAuxBuffers;
-
-   GLint level;
-
-   /* EXT_visual_rating / GLX 1.2 */
-   GLint visualRating;
-
-   /* EXT_visual_info / GLX 1.2 */
-   GLint transparentPixel;
-   /*    colors are floats scaled to ints */
-   GLint transparentRed, transparentGreen, transparentBlue, transparentAlpha;
-   GLint transparentIndex;
-
-   /* ARB_multisample / SGIS_multisample */
-   GLint sampleBuffers;
-   GLint samples;
-
-   /* SGIX_pbuffer / GLX 1.3 */
-   GLint maxPbufferWidth;
-   GLint maxPbufferHeight;
-   GLint maxPbufferPixels;
-   GLint optimalPbufferWidth;   /* Only for SGIX_pbuffer. */
-   GLint optimalPbufferHeight;  /* Only for SGIX_pbuffer. */
-
-   /* OML_swap_method */
-   GLint swapMethod;
-
-   /* EXT_texture_from_pixmap */
-   GLint bindToTextureRgb;
-   GLint bindToTextureRgba;
-   GLint bindToMipmapTexture;
-   GLint bindToTextureTargets;
-   GLint yInverted;
-
-   /* EXT_framebuffer_sRGB */
-   GLint sRGBCapable;
-};
-
-
-/**
- * Data structure for color tables
- */
-struct gl_color_table
-{
-   GLenum InternalFormat;      /**< The user-specified format */
-   GLenum _BaseFormat;         /**< GL_ALPHA, GL_RGBA, GL_RGB, etc */
-   GLuint Size;                /**< number of entries in table */
-   GLfloat *TableF;            /**< Color table, floating point values */
-   GLubyte *TableUB;           /**< Color table, ubyte values */
-   GLubyte RedSize;
-   GLubyte GreenSize;
-   GLubyte BlueSize;
-   GLubyte AlphaSize;
-   GLubyte LuminanceSize;
-   GLubyte IntensitySize;
-};
-
-
-/**
- * \name Bit flags used for updating material values.
- */
-/*@{*/
-#define MAT_ATTRIB_FRONT_AMBIENT           0 
-#define MAT_ATTRIB_BACK_AMBIENT            1
-#define MAT_ATTRIB_FRONT_DIFFUSE           2 
-#define MAT_ATTRIB_BACK_DIFFUSE            3
-#define MAT_ATTRIB_FRONT_SPECULAR          4 
-#define MAT_ATTRIB_BACK_SPECULAR           5
-#define MAT_ATTRIB_FRONT_EMISSION          6
-#define MAT_ATTRIB_BACK_EMISSION           7
-#define MAT_ATTRIB_FRONT_SHININESS         8
-#define MAT_ATTRIB_BACK_SHININESS          9
-#define MAT_ATTRIB_FRONT_INDEXES           10
-#define MAT_ATTRIB_BACK_INDEXES            11
-#define MAT_ATTRIB_MAX                     12
-
-#define MAT_ATTRIB_AMBIENT(f)  (MAT_ATTRIB_FRONT_AMBIENT+(f))  
-#define MAT_ATTRIB_DIFFUSE(f)  (MAT_ATTRIB_FRONT_DIFFUSE+(f))  
-#define MAT_ATTRIB_SPECULAR(f) (MAT_ATTRIB_FRONT_SPECULAR+(f)) 
-#define MAT_ATTRIB_EMISSION(f) (MAT_ATTRIB_FRONT_EMISSION+(f)) 
-#define MAT_ATTRIB_SHININESS(f)(MAT_ATTRIB_FRONT_SHININESS+(f))
-#define MAT_ATTRIB_INDEXES(f)  (MAT_ATTRIB_FRONT_INDEXES+(f))  
-
-#define MAT_INDEX_AMBIENT  0
-#define MAT_INDEX_DIFFUSE  1
-#define MAT_INDEX_SPECULAR 2
-
-#define MAT_BIT_FRONT_AMBIENT         (1<<MAT_ATTRIB_FRONT_AMBIENT)
-#define MAT_BIT_BACK_AMBIENT          (1<<MAT_ATTRIB_BACK_AMBIENT)
-#define MAT_BIT_FRONT_DIFFUSE         (1<<MAT_ATTRIB_FRONT_DIFFUSE)
-#define MAT_BIT_BACK_DIFFUSE          (1<<MAT_ATTRIB_BACK_DIFFUSE)
-#define MAT_BIT_FRONT_SPECULAR        (1<<MAT_ATTRIB_FRONT_SPECULAR)
-#define MAT_BIT_BACK_SPECULAR         (1<<MAT_ATTRIB_BACK_SPECULAR)
-#define MAT_BIT_FRONT_EMISSION        (1<<MAT_ATTRIB_FRONT_EMISSION)
-#define MAT_BIT_BACK_EMISSION         (1<<MAT_ATTRIB_BACK_EMISSION)
-#define MAT_BIT_FRONT_SHININESS       (1<<MAT_ATTRIB_FRONT_SHININESS)
-#define MAT_BIT_BACK_SHININESS        (1<<MAT_ATTRIB_BACK_SHININESS)
-#define MAT_BIT_FRONT_INDEXES         (1<<MAT_ATTRIB_FRONT_INDEXES)
-#define MAT_BIT_BACK_INDEXES          (1<<MAT_ATTRIB_BACK_INDEXES)
-
-
-#define FRONT_MATERIAL_BITS	(MAT_BIT_FRONT_EMISSION | 	\
-				 MAT_BIT_FRONT_AMBIENT |	\
-				 MAT_BIT_FRONT_DIFFUSE | 	\
-				 MAT_BIT_FRONT_SPECULAR |	\
-				 MAT_BIT_FRONT_SHININESS | 	\
-				 MAT_BIT_FRONT_INDEXES)
-
-#define BACK_MATERIAL_BITS	(MAT_BIT_BACK_EMISSION |	\
-				 MAT_BIT_BACK_AMBIENT |		\
-				 MAT_BIT_BACK_DIFFUSE |		\
-				 MAT_BIT_BACK_SPECULAR |	\
-				 MAT_BIT_BACK_SHININESS |	\
-				 MAT_BIT_BACK_INDEXES)
-
-#define ALL_MATERIAL_BITS	(FRONT_MATERIAL_BITS | BACK_MATERIAL_BITS)
-/*@}*/
-
-
-#define EXP_TABLE_SIZE 512	/**< Specular exponent lookup table sizes */
-#define SHINE_TABLE_SIZE 256	/**< Material shininess lookup table sizes */
-
-/**
- * Material shininess lookup table.
- */
-struct gl_shine_tab
-{
-   struct gl_shine_tab *next, *prev;
-   GLfloat tab[SHINE_TABLE_SIZE+1];
-   GLfloat shininess;
-   GLuint refcount;
-};
-
-
-/**
- * Light source state.
- */
-struct gl_light
-{
-   struct gl_light *next;	/**< double linked list with sentinel */
-   struct gl_light *prev;
-
-   GLfloat Ambient[4];		/**< ambient color */
-   GLfloat Diffuse[4];		/**< diffuse color */
-   GLfloat Specular[4];		/**< specular color */
-   GLfloat EyePosition[4];	/**< position in eye coordinates */
-   GLfloat SpotDirection[4];	/**< spotlight direction in eye coordinates */
-   GLfloat SpotExponent;
-   GLfloat SpotCutoff;		/**< in degrees */
-   GLfloat _CosCutoffNeg;	/**< = cos(SpotCutoff) */
-   GLfloat _CosCutoff;		/**< = MAX(0, cos(SpotCutoff)) */
-   GLfloat ConstantAttenuation;
-   GLfloat LinearAttenuation;
-   GLfloat QuadraticAttenuation;
-   GLboolean Enabled;		/**< On/off flag */
-
-   /** 
-    * \name Derived fields
-    */
-   /*@{*/
-   GLbitfield _Flags;		/**< State */
-
-   GLfloat _Position[4];	/**< position in eye/obj coordinates */
-   GLfloat _VP_inf_norm[3];	/**< Norm direction to infinite light */
-   GLfloat _h_inf_norm[3];	/**< Norm( _VP_inf_norm + <0,0,1> ) */
-   GLfloat _NormSpotDirection[4]; /**< normalized spotlight direction */
-   GLfloat _VP_inf_spot_attenuation;
-
-   GLfloat _SpotExpTable[EXP_TABLE_SIZE][2];  /**< to replace a pow() call */
-   GLfloat _MatAmbient[2][3];	/**< material ambient * light ambient */
-   GLfloat _MatDiffuse[2][3];	/**< material diffuse * light diffuse */
-   GLfloat _MatSpecular[2][3];	/**< material spec * light specular */
-   GLfloat _dli;		/**< CI diffuse light intensity */
-   GLfloat _sli;		/**< CI specular light intensity */
-   /*@}*/
-};
-
-
-/**
- * Light model state.
- */
-struct gl_lightmodel
-{
-   GLfloat Ambient[4];		/**< ambient color */
-   GLboolean LocalViewer;	/**< Local (or infinite) view point? */
-   GLboolean TwoSide;		/**< Two (or one) sided lighting? */
-   GLenum ColorControl;		/**< either GL_SINGLE_COLOR
-				 *    or GL_SEPARATE_SPECULAR_COLOR */
-};
-
-
-/**
- * Material state.
- */
-struct gl_material
-{
-   GLfloat Attrib[MAT_ATTRIB_MAX][4];
-};
-
-
-/**
- * Accumulation buffer attribute group (GL_ACCUM_BUFFER_BIT)
- */
-struct gl_accum_attrib
-{
-   GLfloat ClearColor[4];	/**< Accumulation buffer clear color */
-};
-
-
-/**
- * Color buffer attribute group (GL_COLOR_BUFFER_BIT).
- */
-struct gl_colorbuffer_attrib
-{
-   GLuint ClearIndex;			/**< Index to use for glClear */
-   GLclampf ClearColor[4];		/**< Color to use for glClear */
-
-   GLuint IndexMask;			/**< Color index write mask */
-   GLubyte ColorMask[MAX_DRAW_BUFFERS][4];/**< Each flag is 0xff or 0x0 */
-
-   GLenum DrawBuffer[MAX_DRAW_BUFFERS];	/**< Which buffer to draw into */
-
-   /** 
-    * \name alpha testing
-    */
-   /*@{*/
-   GLboolean AlphaEnabled;		/**< Alpha test enabled flag */
-   GLenum AlphaFunc;			/**< Alpha test function */
-   GLclampf AlphaRef;			/**< Alpha reference value */
-   /*@}*/
-
-   /** 
-    * \name Blending
-    */
-   /*@{*/
-   GLbitfield BlendEnabled;		/**< Per-buffer blend enable flags */
-   GLfloat BlendColor[4];		/**< Blending color */
-   struct
-   {
-      GLenum SrcRGB;             /**< RGB blend source term */
-      GLenum DstRGB;             /**< RGB blend dest term */
-      GLenum SrcA;               /**< Alpha blend source term */
-      GLenum DstA;               /**< Alpha blend dest term */
-      GLenum EquationRGB;        /**< GL_ADD, GL_SUBTRACT, etc. */
-      GLenum EquationA;          /**< GL_ADD, GL_SUBTRACT, etc. */
-   } Blend[MAX_DRAW_BUFFERS];
-   /** Are the blend func terms currently different for each buffer/target? */
-   GLboolean _BlendFuncPerBuffer;
-   /** Are the blend equations currently different for each buffer/target? */
-   GLboolean _BlendEquationPerBuffer;
-   /*@}*/
-
-   /** 
-    * \name Logic op
-    */
-   /*@{*/
-   GLenum LogicOp;			/**< Logic operator */
-   GLboolean IndexLogicOpEnabled;	/**< Color index logic op enabled flag */
-   GLboolean ColorLogicOpEnabled;	/**< RGBA logic op enabled flag */
-   GLboolean _LogicOpEnabled;		/**< RGBA logic op + EXT_blend_logic_op enabled flag */
-   /*@}*/
-
-   GLboolean DitherFlag;		/**< Dither enable flag */
-
-   GLenum ClampFragmentColor; /**< GL_TRUE, GL_FALSE or GL_FIXED_ONLY_ARB */
-   GLenum ClampReadColor;     /**< GL_TRUE, GL_FALSE or GL_FIXED_ONLY_ARB */
-
-   GLboolean sRGBEnabled;	/**< Framebuffer sRGB blending/updating requested */
-};
-
-
-/**
- * Current attribute group (GL_CURRENT_BIT).
- */
-struct gl_current_attrib
-{
-   /**
-    * \name Current vertex attributes.
-    * \note Values are valid only after FLUSH_VERTICES has been called.
-    * \note Index and Edgeflag current values are stored as floats in the 
-    * SIX and SEVEN attribute slots.
-    */
-   GLfloat Attrib[VERT_ATTRIB_MAX][4];	/**< Position, color, texcoords, etc */
-
-   /**
-    * \name Current raster position attributes (always valid).
-    * \note This set of attributes is very similar to the SWvertex struct.
-    */
-   /*@{*/
-   GLfloat RasterPos[4];
-   GLfloat RasterDistance;
-   GLfloat RasterColor[4];
-   GLfloat RasterSecondaryColor[4];
-   GLfloat RasterTexCoords[MAX_TEXTURE_COORD_UNITS][4];
-   GLboolean RasterPosValid;
-   /*@}*/
-};
-
-
-/**
- * Depth buffer attribute group (GL_DEPTH_BUFFER_BIT).
- */
-struct gl_depthbuffer_attrib
-{
-   GLenum Func;			/**< Function for depth buffer compare */
-   GLclampd Clear;		/**< Value to clear depth buffer to */
-   GLboolean Test;		/**< Depth buffering enabled flag */
-   GLboolean Mask;		/**< Depth buffer writable? */
-   GLboolean BoundsTest;        /**< GL_EXT_depth_bounds_test */
-   GLfloat BoundsMin, BoundsMax;/**< GL_EXT_depth_bounds_test */
-};
-
-
-/**
- * Evaluator attribute group (GL_EVAL_BIT).
- */
-struct gl_eval_attrib
-{
-   /**
-    * \name Enable bits 
-    */
-   /*@{*/
-   GLboolean Map1Color4;
-   GLboolean Map1Index;
-   GLboolean Map1Normal;
-   GLboolean Map1TextureCoord1;
-   GLboolean Map1TextureCoord2;
-   GLboolean Map1TextureCoord3;
-   GLboolean Map1TextureCoord4;
-   GLboolean Map1Vertex3;
-   GLboolean Map1Vertex4;
-   GLboolean Map1Attrib[16];  /* GL_NV_vertex_program */
-   GLboolean Map2Color4;
-   GLboolean Map2Index;
-   GLboolean Map2Normal;
-   GLboolean Map2TextureCoord1;
-   GLboolean Map2TextureCoord2;
-   GLboolean Map2TextureCoord3;
-   GLboolean Map2TextureCoord4;
-   GLboolean Map2Vertex3;
-   GLboolean Map2Vertex4;
-   GLboolean Map2Attrib[16];  /* GL_NV_vertex_program */
-   GLboolean AutoNormal;
-   /*@}*/
-   
-   /**
-    * \name Map Grid endpoints and divisions and calculated du values
-    */
-   /*@{*/
-   GLint MapGrid1un;
-   GLfloat MapGrid1u1, MapGrid1u2, MapGrid1du;
-   GLint MapGrid2un, MapGrid2vn;
-   GLfloat MapGrid2u1, MapGrid2u2, MapGrid2du;
-   GLfloat MapGrid2v1, MapGrid2v2, MapGrid2dv;
-   /*@}*/
-};
-
-
-/**
- * Fog attribute group (GL_FOG_BIT).
- */
-struct gl_fog_attrib
-{
-   GLboolean Enabled;		/**< Fog enabled flag */
-   GLfloat Color[4];		/**< Fog color */
-   GLfloat Density;		/**< Density >= 0.0 */
-   GLfloat Start;		/**< Start distance in eye coords */
-   GLfloat End;			/**< End distance in eye coords */
-   GLfloat Index;		/**< Fog index */
-   GLenum Mode;			/**< Fog mode */
-   GLboolean ColorSumEnabled;
-   GLenum FogCoordinateSource;  /**< GL_EXT_fog_coord */
-   GLfloat _Scale;		/**< (End == Start) ? 1.0 : 1.0 / (End - Start) */
-};
-
-
-/**
- * \brief Layout qualifiers for gl_FragDepth.
- *
- * Extension AMD_conservative_depth allows gl_FragDepth to be redeclared with
- * a layout qualifier.
- *
- * \see enum ir_depth_layout
- */
-enum gl_frag_depth_layout {
-    FRAG_DEPTH_LAYOUT_NONE, /**< No layout is specified. */
-    FRAG_DEPTH_LAYOUT_ANY,
-    FRAG_DEPTH_LAYOUT_GREATER,
-    FRAG_DEPTH_LAYOUT_LESS,
-    FRAG_DEPTH_LAYOUT_UNCHANGED
-};
-
-
-/** 
- * Hint attribute group (GL_HINT_BIT).
- * 
- * Values are always one of GL_FASTEST, GL_NICEST, or GL_DONT_CARE.
- */
-struct gl_hint_attrib
-{
-   GLenum PerspectiveCorrection;
-   GLenum PointSmooth;
-   GLenum LineSmooth;
-   GLenum PolygonSmooth;
-   GLenum Fog;
-   GLenum ClipVolumeClipping;   /**< GL_EXT_clip_volume_hint */
-   GLenum TextureCompression;   /**< GL_ARB_texture_compression */
-   GLenum GenerateMipmap;       /**< GL_SGIS_generate_mipmap */
-   GLenum FragmentShaderDerivative; /**< GL_ARB_fragment_shader */
-};
-
-/**
- * Light state flags.
- */
-/*@{*/
-#define LIGHT_SPOT         0x1
-#define LIGHT_LOCAL_VIEWER 0x2
-#define LIGHT_POSITIONAL   0x4
-#define LIGHT_NEED_VERTICES (LIGHT_POSITIONAL|LIGHT_LOCAL_VIEWER)
-/*@}*/
-
-
-/**
- * Lighting attribute group (GL_LIGHT_BIT).
- */
-struct gl_light_attrib
-{
-   struct gl_light Light[MAX_LIGHTS];	/**< Array of light sources */
-   struct gl_lightmodel Model;		/**< Lighting model */
-
-   /**
-    * Must flush FLUSH_VERTICES before referencing:
-    */
-   /*@{*/
-   struct gl_material Material; 	/**< Includes front & back values */
-   /*@}*/
-
-   GLboolean Enabled;			/**< Lighting enabled flag */
-   GLenum ShadeModel;			/**< GL_FLAT or GL_SMOOTH */
-   GLenum ProvokingVertex;              /**< GL_EXT_provoking_vertex */
-   GLenum ColorMaterialFace;		/**< GL_FRONT, BACK or FRONT_AND_BACK */
-   GLenum ColorMaterialMode;		/**< GL_AMBIENT, GL_DIFFUSE, etc */
-   GLbitfield ColorMaterialBitmask;	/**< bitmask formed from Face and Mode */
-   GLboolean ColorMaterialEnabled;
-   GLenum ClampVertexColor;
-
-   struct gl_light EnabledList;         /**< List sentinel */
-
-   /** 
-    * Derived state for optimizations: 
-    */
-   /*@{*/
-   GLboolean _NeedEyeCoords;		
-   GLboolean _NeedVertices;		/**< Use fast shader? */
-   GLbitfield _Flags;		        /**< LIGHT_* flags, see above */
-   GLfloat _BaseColor[2][3];
-   /*@}*/
-};
-
-
-/**
- * Line attribute group (GL_LINE_BIT).
- */
-struct gl_line_attrib
-{
-   GLboolean SmoothFlag;	/**< GL_LINE_SMOOTH enabled? */
-   GLboolean StippleFlag;	/**< GL_LINE_STIPPLE enabled? */
-   GLushort StipplePattern;	/**< Stipple pattern */
-   GLint StippleFactor;		/**< Stipple repeat factor */
-   GLfloat Width;		/**< Line width */
-};
-
-
-/**
- * Display list attribute group (GL_LIST_BIT).
- */
-struct gl_list_attrib
-{
-   GLuint ListBase;
-};
-
-
-/**
- * Multisample attribute group (GL_MULTISAMPLE_BIT).
- */
-struct gl_multisample_attrib
-{
-   GLboolean Enabled;
-   GLboolean _Enabled;   /**< true if Enabled and multisample buffer */
-   GLboolean SampleAlphaToCoverage;
-   GLboolean SampleAlphaToOne;
-   GLboolean SampleCoverage;
-   GLfloat SampleCoverageValue;
-   GLboolean SampleCoverageInvert;
-};
-
-
-/**
- * A pixelmap (see glPixelMap)
- */
-struct gl_pixelmap
-{
-   GLint Size;
-   GLfloat Map[MAX_PIXEL_MAP_TABLE];
-   GLubyte Map8[MAX_PIXEL_MAP_TABLE];  /**< converted to 8-bit color */
-};
-
-
-/**
- * Collection of all pixelmaps
- */
-struct gl_pixelmaps
-{
-   struct gl_pixelmap RtoR;  /**< i.e. GL_PIXEL_MAP_R_TO_R */
-   struct gl_pixelmap GtoG;
-   struct gl_pixelmap BtoB;
-   struct gl_pixelmap AtoA;
-   struct gl_pixelmap ItoR;
-   struct gl_pixelmap ItoG;
-   struct gl_pixelmap ItoB;
-   struct gl_pixelmap ItoA;
-   struct gl_pixelmap ItoI;
-   struct gl_pixelmap StoS;
-};
-
-
-/**
- * Pixel attribute group (GL_PIXEL_MODE_BIT).
- */
-struct gl_pixel_attrib
-{
-   GLenum ReadBuffer;		/**< source buffer for glRead/CopyPixels() */
-
-   /*--- Begin Pixel Transfer State ---*/
-   /* Fields are in the order in which they're applied... */
-
-   /** Scale & Bias (index shift, offset) */
-   /*@{*/
-   GLfloat RedBias, RedScale;
-   GLfloat GreenBias, GreenScale;
-   GLfloat BlueBias, BlueScale;
-   GLfloat AlphaBias, AlphaScale;
-   GLfloat DepthBias, DepthScale;
-   GLint IndexShift, IndexOffset;
-   /*@}*/
-
-   /* Pixel Maps */
-   /* Note: actual pixel maps are not part of this attrib group */
-   GLboolean MapColorFlag;
-   GLboolean MapStencilFlag;
-
-   /*--- End Pixel Transfer State ---*/
-
-   /** glPixelZoom */
-   GLfloat ZoomX, ZoomY;
-};
-
-
-/**
- * Point attribute group (GL_POINT_BIT).
- */
-struct gl_point_attrib
-{
-   GLboolean SmoothFlag;	/**< True if GL_POINT_SMOOTH is enabled */
-   GLfloat Size;		/**< User-specified point size */
-   GLfloat Params[3];		/**< GL_EXT_point_parameters */
-   GLfloat MinSize, MaxSize;	/**< GL_EXT_point_parameters */
-   GLfloat Threshold;		/**< GL_EXT_point_parameters */
-   GLboolean _Attenuated;	/**< True if Params != [1, 0, 0] */
-   GLboolean PointSprite;	/**< GL_NV/ARB_point_sprite */
-   GLboolean CoordReplace[MAX_TEXTURE_COORD_UNITS]; /**< GL_ARB_point_sprite*/
-   GLenum SpriteRMode;		/**< GL_NV_point_sprite (only!) */
-   GLenum SpriteOrigin;		/**< GL_ARB_point_sprite */
-};
-
-
-/**
- * Polygon attribute group (GL_POLYGON_BIT).
- */
-struct gl_polygon_attrib
-{
-   GLenum FrontFace;		/**< Either GL_CW or GL_CCW */
-   GLenum FrontMode;		/**< Either GL_POINT, GL_LINE or GL_FILL */
-   GLenum BackMode;		/**< Either GL_POINT, GL_LINE or GL_FILL */
-   GLboolean _FrontBit;		/**< 0=GL_CCW, 1=GL_CW */
-   GLboolean CullFlag;		/**< Culling on/off flag */
-   GLboolean SmoothFlag;	/**< True if GL_POLYGON_SMOOTH is enabled */
-   GLboolean StippleFlag;	/**< True if GL_POLYGON_STIPPLE is enabled */
-   GLenum CullFaceMode;		/**< Culling mode GL_FRONT or GL_BACK */
-   GLfloat OffsetFactor;	/**< Polygon offset factor, from user */
-   GLfloat OffsetUnits;		/**< Polygon offset units, from user */
-   GLboolean OffsetPoint;	/**< Offset in GL_POINT mode */
-   GLboolean OffsetLine;	/**< Offset in GL_LINE mode */
-   GLboolean OffsetFill;	/**< Offset in GL_FILL mode */
-};
-
-
-/**
- * Scissor attributes (GL_SCISSOR_BIT).
- */
-struct gl_scissor_attrib
-{
-   GLboolean Enabled;		/**< Scissor test enabled? */
-   GLint X, Y;			/**< Lower left corner of box */
-   GLsizei Width, Height;	/**< Size of box */
-};
-
-
-/**
- * Stencil attribute group (GL_STENCIL_BUFFER_BIT).
- *
- * Three sets of stencil data are tracked so that OpenGL 2.0,
- * GL_EXT_stencil_two_side, and GL_ATI_separate_stencil can all be supported
- * simultaneously.  In each of the stencil state arrays, element 0 corresponds
- * to GL_FRONT.  Element 1 corresponds to the OpenGL 2.0 /
- * GL_ATI_separate_stencil GL_BACK state.  Element 2 corresponds to the
- * GL_EXT_stencil_two_side GL_BACK state.
- *
- * The derived value \c _BackFace is either 1 or 2 depending on whether or
- * not GL_STENCIL_TEST_TWO_SIDE_EXT is enabled.
- *
- * The derived value \c _TestTwoSide is set when the front-face and back-face
- * stencil state are different.
- */
-struct gl_stencil_attrib
-{
-   GLboolean Enabled;		/**< Enabled flag */
-   GLboolean TestTwoSide;	/**< GL_EXT_stencil_two_side */
-   GLubyte ActiveFace;		/**< GL_EXT_stencil_two_side (0 or 2) */
-   GLboolean _Enabled;          /**< Enabled and stencil buffer present */
-   GLboolean _TestTwoSide;
-   GLubyte _BackFace;           /**< Current back stencil state (1 or 2) */
-   GLenum Function[3];		/**< Stencil function */
-   GLenum FailFunc[3];		/**< Fail function */
-   GLenum ZPassFunc[3];		/**< Depth buffer pass function */
-   GLenum ZFailFunc[3];		/**< Depth buffer fail function */
-   GLint Ref[3];		/**< Reference value */
-   GLuint ValueMask[3];		/**< Value mask */
-   GLuint WriteMask[3];		/**< Write mask */
-   GLuint Clear;		/**< Clear value */
-};
-
-
-/**
- * An index for each type of texture object.  These correspond to the GL
- * texture target enums, such as GL_TEXTURE_2D, GL_TEXTURE_CUBE_MAP, etc.
- * Note: the order is from highest priority to lowest priority.
- */
-typedef enum
-{
-   TEXTURE_2D_ARRAY_INDEX,
-   TEXTURE_1D_ARRAY_INDEX,
-   TEXTURE_CUBE_INDEX,
-   TEXTURE_3D_INDEX,
-   TEXTURE_RECT_INDEX,
-   TEXTURE_2D_INDEX,
-   TEXTURE_1D_INDEX,
-   NUM_TEXTURE_TARGETS
-} gl_texture_index;
-
-
-/**
- * Bit flags for each type of texture object
- * Used for Texture.Unit[]._ReallyEnabled flags.
- */
-/*@{*/
-#define TEXTURE_2D_ARRAY_BIT (1 << TEXTURE_2D_ARRAY_INDEX)
-#define TEXTURE_1D_ARRAY_BIT (1 << TEXTURE_1D_ARRAY_INDEX)
-#define TEXTURE_CUBE_BIT     (1 << TEXTURE_CUBE_INDEX)
-#define TEXTURE_3D_BIT       (1 << TEXTURE_3D_INDEX)
-#define TEXTURE_RECT_BIT     (1 << TEXTURE_RECT_INDEX)
-#define TEXTURE_2D_BIT       (1 << TEXTURE_2D_INDEX)
-#define TEXTURE_1D_BIT       (1 << TEXTURE_1D_INDEX)
-/*@}*/
-
-
-/**
- * TexGenEnabled flags.
- */
-/*@{*/
-#define S_BIT 1
-#define T_BIT 2
-#define R_BIT 4
-#define Q_BIT 8
-#define STR_BITS (S_BIT | T_BIT | R_BIT)
-/*@}*/
-
-
-/**
- * Bit flag versions of the corresponding GL_ constants.
- */
-/*@{*/
-#define TEXGEN_SPHERE_MAP        0x1
-#define TEXGEN_OBJ_LINEAR        0x2
-#define TEXGEN_EYE_LINEAR        0x4
-#define TEXGEN_REFLECTION_MAP_NV 0x8
-#define TEXGEN_NORMAL_MAP_NV     0x10
-
-#define TEXGEN_NEED_NORMALS      (TEXGEN_SPHERE_MAP        | \
-				  TEXGEN_REFLECTION_MAP_NV | \
-				  TEXGEN_NORMAL_MAP_NV)
-#define TEXGEN_NEED_EYE_COORD    (TEXGEN_SPHERE_MAP        | \
-				  TEXGEN_REFLECTION_MAP_NV | \
-				  TEXGEN_NORMAL_MAP_NV     | \
-				  TEXGEN_EYE_LINEAR)
-/*@}*/
-
-
-
-/** Tex-gen enabled for texture unit? */
-#define ENABLE_TEXGEN(unit) (1 << (unit))
-
-/** Non-identity texture matrix for texture unit? */
-#define ENABLE_TEXMAT(unit) (1 << (unit))
-
-
-/**
- * Texel fetch function prototype.  We use texel fetch functions to
- * extract RGBA, color indexes and depth components out of 1D, 2D and 3D
- * texture images.  These functions help to isolate us from the gritty
- * details of all the various texture image encodings.
- * 
- * \param texImage texture image.
- * \param col texel column.
- * \param row texel row.
- * \param img texel image level/layer.
- * \param texelOut output texel (up to 4 GLchans)
- */
-typedef void (*FetchTexelFuncC)( const struct gl_texture_image *texImage,
-                                 GLint col, GLint row, GLint img,
-                                 GLchan *texelOut );
-
-/**
- * As above, but returns floats.
- * Used for depth component images and for upcoming signed/float
- * texture images.
- */
-typedef void (*FetchTexelFuncF)( const struct gl_texture_image *texImage,
-                                 GLint col, GLint row, GLint img,
-                                 GLfloat *texelOut );
-
-
-typedef void (*StoreTexelFunc)(struct gl_texture_image *texImage,
-                               GLint col, GLint row, GLint img,
-                               const void *texel);
-
-
-/**
- * Texture image state.  Describes the dimensions of a texture image,
- * the texel format and pointers to Texel Fetch functions.
- */
-struct gl_texture_image
-{
-   GLint InternalFormat;	/**< Internal format as given by the user */
-   GLenum _BaseFormat;		/**< Either GL_RGB, GL_RGBA, GL_ALPHA,
-				 *   GL_LUMINANCE, GL_LUMINANCE_ALPHA,
-				 *   GL_INTENSITY, GL_COLOR_INDEX,
-				 *   GL_DEPTH_COMPONENT or GL_DEPTH_STENCIL_EXT
-                                 *   only. Used for choosing TexEnv arithmetic.
-				 */
-   gl_format TexFormat;         /**< The actual texture memory format */
-
-   GLuint Border;		/**< 0 or 1 */
-   GLuint Width;		/**< = 2^WidthLog2 + 2*Border */
-   GLuint Height;		/**< = 2^HeightLog2 + 2*Border */
-   GLuint Depth;		/**< = 2^DepthLog2 + 2*Border */
-   GLuint Width2;		/**< = Width - 2*Border */
-   GLuint Height2;		/**< = Height - 2*Border */
-   GLuint Depth2;		/**< = Depth - 2*Border */
-   GLuint WidthLog2;		/**< = log2(Width2) */
-   GLuint HeightLog2;		/**< = log2(Height2) */
-   GLuint DepthLog2;		/**< = log2(Depth2) */
-   GLuint MaxLog2;		/**< = MAX(WidthLog2, HeightLog2) */
-   GLfloat WidthScale;		/**< used for mipmap LOD computation */
-   GLfloat HeightScale;		/**< used for mipmap LOD computation */
-   GLfloat DepthScale;		/**< used for mipmap LOD computation */
-   GLboolean IsClientData;	/**< Data owned by client? */
-   GLboolean _IsPowerOfTwo;	/**< Are all dimensions powers of two? */
-
-   struct gl_texture_object *TexObject;  /**< Pointer back to parent object */
-
-   FetchTexelFuncC FetchTexelc;	/**< GLchan texel fetch function pointer */
-   FetchTexelFuncF FetchTexelf;	/**< Float texel fetch function pointer */
-
-   GLuint RowStride;		/**< Padded width in units of texels */
-   GLuint *ImageOffsets;        /**< if 3D texture: array [Depth] of offsets to
-                                     each 2D slice in 'Data', in texels */
-   GLvoid *Data;		/**< Image data, accessed via FetchTexel() */
-
-   /**
-    * \name For device driver:
-    */
-   /*@{*/
-   void *DriverData;		/**< Arbitrary device driver data */
-   /*@}*/
-};
-
-
-/**
- * Indexes for cube map faces.
- */
-typedef enum
-{
-   FACE_POS_X = 0,
-   FACE_NEG_X = 1,
-   FACE_POS_Y = 2,
-   FACE_NEG_Y = 3,
-   FACE_POS_Z = 4,
-   FACE_NEG_Z = 5,
-   MAX_FACES = 6
-} gl_face_index;
-
-
-/**
- * Texture object state.  Contains the array of mipmap images, border color,
- * wrap modes, filter modes, shadow/texcompare state, and the per-texture
- * color palette.
- */
-struct gl_texture_object
-{
-   _glthread_Mutex Mutex;	/**< for thread safety */
-   GLint RefCount;		/**< reference count */
-   GLuint Name;			/**< the user-visible texture object ID */
-   GLenum Target;               /**< GL_TEXTURE_1D, GL_TEXTURE_2D, etc. */
-   GLfloat Priority;		/**< in [0,1] */
-   union {
-      GLfloat f[4];
-      GLuint ui[4];
-      GLint i[4];
-   } BorderColor;               /**< Interpreted according to texture format */
-   GLenum WrapS;		/**< S-axis texture image wrap mode */
-   GLenum WrapT;		/**< T-axis texture image wrap mode */
-   GLenum WrapR;		/**< R-axis texture image wrap mode */
-   GLenum MinFilter;		/**< minification filter */
-   GLenum MagFilter;		/**< magnification filter */
-   GLfloat MinLod;		/**< min lambda, OpenGL 1.2 */
-   GLfloat MaxLod;		/**< max lambda, OpenGL 1.2 */
-   GLfloat LodBias;		/**< OpenGL 1.4 */
-   GLint BaseLevel;		/**< min mipmap level, OpenGL 1.2 */
-   GLint MaxLevel;		/**< max mipmap level, OpenGL 1.2 */
-   GLfloat MaxAnisotropy;	/**< GL_EXT_texture_filter_anisotropic */
-   GLenum CompareMode;		/**< GL_ARB_shadow */
-   GLenum CompareFunc;		/**< GL_ARB_shadow */
-   GLfloat CompareFailValue;    /**< GL_ARB_shadow_ambient */
-   GLenum DepthMode;		/**< GL_ARB_depth_texture */
-   GLint _MaxLevel;		/**< actual max mipmap level (q in the spec) */
-   GLfloat _MaxLambda;		/**< = _MaxLevel - BaseLevel (q - b in spec) */
-   GLint CropRect[4];           /**< GL_OES_draw_texture */
-   GLenum Swizzle[4];           /**< GL_EXT_texture_swizzle */
-   GLuint _Swizzle;             /**< same as Swizzle, but SWIZZLE_* format */
-   GLboolean GenerateMipmap;    /**< GL_SGIS_generate_mipmap */
-   GLboolean _Complete;		/**< Is texture object complete? */
-   GLboolean _RenderToTexture;  /**< Any rendering to this texture? */
-   GLboolean Purgeable;         /**< Is the buffer purgeable under memory pressure? */
-   GLenum sRGBDecode;           /**< GL_DECODE_EXT or GL_SKIP_DECODE_EXT */
-
-   /** Actual texture images, indexed by [cube face] and [mipmap level] */
-   struct gl_texture_image *Image[MAX_FACES][MAX_TEXTURE_LEVELS];
-
-   /** GL_EXT_paletted_texture */
-   struct gl_color_table Palette;
-
-   /**
-    * \name For device driver.
-    * Note: instead of attaching driver data to this pointer, it's preferable
-    * to instead use this struct as a base class for your own texture object
-    * class.  Driver->NewTextureObject() can be used to implement the
-    * allocation.
-    */
-   void *DriverData;	/**< Arbitrary device driver data */
-};
-
-
-/** Up to four combiner sources are possible with GL_NV_texture_env_combine4 */
-#define MAX_COMBINER_TERMS 4
-
-
-/**
- * Texture combine environment state.
- */
-struct gl_tex_env_combine_state
-{
-   GLenum ModeRGB;       /**< GL_REPLACE, GL_DECAL, GL_ADD, etc. */
-   GLenum ModeA;         /**< GL_REPLACE, GL_DECAL, GL_ADD, etc. */
-   /** Source terms: GL_PRIMARY_COLOR, GL_TEXTURE, etc */
-   GLenum SourceRGB[MAX_COMBINER_TERMS];
-   GLenum SourceA[MAX_COMBINER_TERMS];
-   /** Source operands: GL_SRC_COLOR, GL_ONE_MINUS_SRC_COLOR, etc */
-   GLenum OperandRGB[MAX_COMBINER_TERMS];
-   GLenum OperandA[MAX_COMBINER_TERMS];
-   GLuint ScaleShiftRGB; /**< 0, 1 or 2 */
-   GLuint ScaleShiftA;   /**< 0, 1 or 2 */
-   GLuint _NumArgsRGB;   /**< Number of inputs used for the RGB combiner */
-   GLuint _NumArgsA;     /**< Number of inputs used for the A combiner */
-};
-
-
-/**
- * Texture coord generation state.
- */
-struct gl_texgen
-{
-   GLenum Mode;         /**< GL_EYE_LINEAR, GL_SPHERE_MAP, etc */
-   GLbitfield _ModeBit; /**< TEXGEN_x bit corresponding to Mode */
-   GLfloat ObjectPlane[4];
-   GLfloat EyePlane[4];
-};
-
-
-/**
- * Texture unit state.  Contains enable flags, texture environment/function/
- * combiners, texgen state, pointers to current texture objects and
- * post-filter color tables.
- */
-struct gl_texture_unit
-{
-   GLbitfield Enabled;          /**< bitmask of TEXTURE_*_BIT flags */
-   GLbitfield _ReallyEnabled;   /**< 0 or exactly one of TEXTURE_*_BIT flags */
-
-   GLenum EnvMode;              /**< GL_MODULATE, GL_DECAL, GL_BLEND, etc. */
-   GLfloat EnvColor[4];
-
-   struct gl_texgen GenS;
-   struct gl_texgen GenT;
-   struct gl_texgen GenR;
-   struct gl_texgen GenQ;
-   GLbitfield TexGenEnabled;	/**< Bitwise-OR of [STRQ]_BIT values */
-   GLbitfield _GenFlags;	/**< Bitwise-OR of Gen[STRQ]._ModeBit */
-
-   GLfloat LodBias;		/**< for biasing mipmap levels */
-   GLenum BumpTarget;
-   GLfloat RotMatrix[4]; /* 2x2 matrix */
-
-   /** 
-    * \name GL_EXT_texture_env_combine 
-    */
-   struct gl_tex_env_combine_state Combine;
-
-   /**
-    * Derived state based on \c EnvMode and the \c BaseFormat of the
-    * currently enabled texture.
-    */
-   struct gl_tex_env_combine_state _EnvMode;
-
-   /**
-    * Currently enabled combiner state.  This will point to either
-    * \c Combine or \c _EnvMode.
-    */
-   struct gl_tex_env_combine_state *_CurrentCombine;
-
-   /** Current texture object pointers */
-   struct gl_texture_object *CurrentTex[NUM_TEXTURE_TARGETS];
-
-   /** Points to highest priority, complete and enabled texture object */
-   struct gl_texture_object *_Current;
-};
-
-
-/**
- * Texture attribute group (GL_TEXTURE_BIT).
- */
-struct gl_texture_attrib
-{
-   GLuint CurrentUnit;   /**< GL_ACTIVE_TEXTURE */
-   struct gl_texture_unit Unit[MAX_COMBINED_TEXTURE_IMAGE_UNITS];
-
-   struct gl_texture_object *ProxyTex[NUM_TEXTURE_TARGETS];
-
-   /** GL_ARB_seamless_cubemap */
-   GLboolean CubeMapSeamless;
-
-   /** GL_EXT_shared_texture_palette */
-   GLboolean SharedPalette;
-   struct gl_color_table Palette;
-
-   /** Texture units/samplers used by vertex or fragment texturing */
-   GLbitfield _EnabledUnits;
-
-   /** Texture coord units/sets used for fragment texturing */
-   GLbitfield _EnabledCoordUnits;
-
-   /** Texture coord units that have texgen enabled */
-   GLbitfield _TexGenEnabled;
-
-   /** Texture coord units that have non-identity matrices */
-   GLbitfield _TexMatEnabled;
-
-   /** Bitwise-OR of all Texture.Unit[i]._GenFlags */
-   GLbitfield _GenFlags;
-};
-
-
-/**
- * Transformation attribute group (GL_TRANSFORM_BIT).
- */
-struct gl_transform_attrib
-{
-   GLenum MatrixMode;				/**< Matrix mode */
-   GLfloat EyeUserPlane[MAX_CLIP_PLANES][4];	/**< User clip planes */
-   GLfloat _ClipUserPlane[MAX_CLIP_PLANES][4];	/**< derived */
-   GLbitfield ClipPlanesEnabled;                /**< on/off bitmask */
-   GLboolean Normalize;				/**< Normalize all normals? */
-   GLboolean RescaleNormals;			/**< GL_EXT_rescale_normal */
-   GLboolean RasterPositionUnclipped;           /**< GL_IBM_rasterpos_clip */
-   GLboolean DepthClamp;			/**< GL_ARB_depth_clamp */
-
-   GLfloat CullEyePos[4];
-   GLfloat CullObjPos[4];
-};
-
-
-/**
- * Viewport attribute group (GL_VIEWPORT_BIT).
- */
-struct gl_viewport_attrib
-{
-   GLint X, Y;			/**< position */
-   GLsizei Width, Height;	/**< size */
-   GLfloat Near, Far;		/**< Depth buffer range */
-   GLmatrix _WindowMap;		/**< Mapping transformation as a matrix. */
-};
-
-
-/**
- * GL_ARB_vertex/pixel_buffer_object buffer object
- */
-struct gl_buffer_object
-{
-   _glthread_Mutex Mutex;
-   GLint RefCount;
-   GLuint Name;
-   GLenum Usage;        /**< GL_STREAM_DRAW_ARB, GL_STREAM_READ_ARB, etc. */
-   GLsizeiptrARB Size;  /**< Size of buffer storage in bytes */
-   GLubyte *Data;       /**< Location of storage either in RAM or VRAM. */
-   /** Fields describing a mapped buffer */
-   /*@{*/
-   GLbitfield AccessFlags; /**< Mask of GL_MAP_x_BIT flags */
-   GLvoid *Pointer;     /**< User-space address of mapping */
-   GLintptr Offset;     /**< Mapped offset */
-   GLsizeiptr Length;   /**< Mapped length */
-   /*@}*/
-   GLboolean Written;   /**< Ever written to? (for debugging) */
-   GLboolean Purgeable; /**< Is the buffer purgeable under memory pressure? */
-};
-
-
-/**
- * Client pixel packing/unpacking attributes
- */
-struct gl_pixelstore_attrib
-{
-   GLint Alignment;
-   GLint RowLength;
-   GLint SkipPixels;
-   GLint SkipRows;
-   GLint ImageHeight;
-   GLint SkipImages;
-   GLboolean SwapBytes;
-   GLboolean LsbFirst;
-   GLboolean ClientStorage; /**< GL_APPLE_client_storage */
-   GLboolean Invert;        /**< GL_MESA_pack_invert */
-   struct gl_buffer_object *BufferObj; /**< GL_ARB_pixel_buffer_object */
-};
-
-
-/**
- * Client vertex array attributes
- */
-struct gl_client_array
-{
-   GLint Size;                  /**< components per element (1,2,3,4) */
-   GLenum Type;                 /**< datatype: GL_FLOAT, GL_INT, etc */
-   GLenum Format;               /**< default: GL_RGBA, but may be GL_BGRA */
-   GLsizei Stride;		/**< user-specified stride */
-   GLsizei StrideB;		/**< actual stride in bytes */
-   const GLubyte *Ptr;          /**< Points to array data */
-   GLboolean Enabled;		/**< Enabled flag is a boolean */
-   GLboolean Normalized;        /**< GL_ARB_vertex_program */
-   GLboolean Integer;           /**< Integer-valued? */
-   GLuint InstanceDivisor;      /**< GL_ARB_instanced_arrays */
-   GLuint _ElementSize;         /**< size of each element in bytes */
-
-   struct gl_buffer_object *BufferObj;/**< GL_ARB_vertex_buffer_object */
-   GLuint _MaxElement;          /**< max element index into array buffer + 1 */
-};
-
-
-/**
- * Collection of vertex arrays.  Defined by the GL_APPLE_vertex_array_object
- * extension, but a nice encapsulation in any case.
- */
-struct gl_array_object
-{
-   /** Name of the array object as received from glGenVertexArrayAPPLE. */
-   GLuint Name;
-
-   GLint RefCount;
-   _glthread_Mutex Mutex;
-   GLboolean VBOonly;  /**< require all arrays to live in VBOs? */
-
-   /** Conventional vertex arrays */
-   /*@{*/
-   struct gl_client_array Vertex;
-   struct gl_client_array Weight;
-   struct gl_client_array Normal;
-   struct gl_client_array Color;
-   struct gl_client_array SecondaryColor;
-   struct gl_client_array FogCoord;
-   struct gl_client_array Index;
-   struct gl_client_array EdgeFlag;
-   struct gl_client_array TexCoord[MAX_TEXTURE_COORD_UNITS];
-   struct gl_client_array PointSize;
-   /*@}*/
-
-   /**
-    * Generic arrays for vertex programs/shaders.
-    * For NV vertex programs, these attributes alias and take priority
-    * over the conventional attribs above.  For ARB vertex programs and
-    * GLSL vertex shaders, these attributes are separate.
-    */
-   struct gl_client_array VertexAttrib[MAX_VERTEX_GENERIC_ATTRIBS];
-
-   /** Mask of _NEW_ARRAY_* values indicating which arrays are enabled */
-   GLbitfield _Enabled;
-
-   /**
-    * Min of all enabled arrays' _MaxElement.  When arrays reside inside VBOs
-    * we can determine the max legal (in bounds) glDrawElements array index.
-    */
-   GLuint _MaxElement;
-};
-
-
-/**
- * Vertex array state
- */
-struct gl_array_attrib
-{
-   /** Currently bound array object. See _mesa_BindVertexArrayAPPLE() */
-   struct gl_array_object *ArrayObj;
-
-   /** The default vertex array object */
-   struct gl_array_object *DefaultArrayObj;
-
-   /** Array objects (GL_ARB/APPLE_vertex_array_object) */
-   struct _mesa_HashTable *Objects;
-
-   GLint ActiveTexture;		/**< Client Active Texture */
-   GLuint LockFirst;            /**< GL_EXT_compiled_vertex_array */
-   GLuint LockCount;            /**< GL_EXT_compiled_vertex_array */
-
-   /** GL 3.1 (slightly different from GL_NV_primitive_restart) */
-   GLboolean PrimitiveRestart;
-   GLuint RestartIndex;
-
-   GLbitfield NewState;		/**< mask of _NEW_ARRAY_* values */
-   GLboolean RebindArrays; /**< whether the VBO module should rebind arrays */
-
-   /* GL_ARB_vertex_buffer_object */
-   struct gl_buffer_object *ArrayBufferObj;
-   struct gl_buffer_object *ElementArrayBufferObj;
-};
-
-
-/**
- * Feedback buffer state
- */
-struct gl_feedback
-{
-   GLenum Type;
-   GLbitfield _Mask;    /**< FB_* bits */
-   GLfloat *Buffer;
-   GLuint BufferSize;
-   GLuint Count;
-};
-
-
-/**
- * Selection buffer state
- */
-struct gl_selection
-{
-   GLuint *Buffer;	/**< selection buffer */
-   GLuint BufferSize;	/**< size of the selection buffer */
-   GLuint BufferCount;	/**< number of values in the selection buffer */
-   GLuint Hits;		/**< number of records in the selection buffer */
-   GLuint NameStackDepth; /**< name stack depth */
-   GLuint NameStack[MAX_NAME_STACK_DEPTH]; /**< name stack */
-   GLboolean HitFlag;	/**< hit flag */
-   GLfloat HitMinZ;	/**< minimum hit depth */
-   GLfloat HitMaxZ;	/**< maximum hit depth */
-};
-
-
-/**
- * 1-D Evaluator control points
- */
-struct gl_1d_map
-{
-   GLuint Order;	/**< Number of control points */
-   GLfloat u1, u2, du;	/**< u1, u2, 1.0/(u2-u1) */
-   GLfloat *Points;	/**< Points to contiguous control points */
-};
-
-
-/**
- * 2-D Evaluator control points
- */
-struct gl_2d_map
-{
-   GLuint Uorder;		/**< Number of control points in U dimension */
-   GLuint Vorder;		/**< Number of control points in V dimension */
-   GLfloat u1, u2, du;
-   GLfloat v1, v2, dv;
-   GLfloat *Points;		/**< Points to contiguous control points */
-};
-
-
-/**
- * All evaluator control point state
- */
-struct gl_evaluators
-{
-   /** 
-    * \name 1-D maps
-    */
-   /*@{*/
-   struct gl_1d_map Map1Vertex3;
-   struct gl_1d_map Map1Vertex4;
-   struct gl_1d_map Map1Index;
-   struct gl_1d_map Map1Color4;
-   struct gl_1d_map Map1Normal;
-   struct gl_1d_map Map1Texture1;
-   struct gl_1d_map Map1Texture2;
-   struct gl_1d_map Map1Texture3;
-   struct gl_1d_map Map1Texture4;
-   struct gl_1d_map Map1Attrib[16];  /**< GL_NV_vertex_program */
-   /*@}*/
-
-   /** 
-    * \name 2-D maps 
-    */
-   /*@{*/
-   struct gl_2d_map Map2Vertex3;
-   struct gl_2d_map Map2Vertex4;
-   struct gl_2d_map Map2Index;
-   struct gl_2d_map Map2Color4;
-   struct gl_2d_map Map2Normal;
-   struct gl_2d_map Map2Texture1;
-   struct gl_2d_map Map2Texture2;
-   struct gl_2d_map Map2Texture3;
-   struct gl_2d_map Map2Texture4;
-   struct gl_2d_map Map2Attrib[16];  /**< GL_NV_vertex_program */
-   /*@}*/
-};
-
-
-/**
- * Names of the various vertex/fragment program register files, etc.
- *
- * NOTE: first four tokens must fit into 2 bits (see t_vb_arbprogram.c)
- * All values should fit in a 4-bit field.
- *
- * NOTE: PROGRAM_ENV_PARAM, PROGRAM_STATE_VAR, PROGRAM_NAMED_PARAM,
- * PROGRAM_CONSTANT, and PROGRAM_UNIFORM can all be considered to
- * be "uniform" variables since they can only be set outside glBegin/End.
- * They're also all stored in the same Parameters array.
- */
-typedef enum
-{
-   PROGRAM_TEMPORARY,   /**< machine->Temporary[] */
-   PROGRAM_INPUT,       /**< machine->Inputs[] */
-   PROGRAM_OUTPUT,      /**< machine->Outputs[] */
-   PROGRAM_VARYING,     /**< machine->Inputs[]/Outputs[] */
-   PROGRAM_LOCAL_PARAM, /**< gl_program->LocalParams[] */
-   PROGRAM_ENV_PARAM,   /**< gl_program->Parameters[] */
-   PROGRAM_STATE_VAR,   /**< gl_program->Parameters[] */
-   PROGRAM_NAMED_PARAM, /**< gl_program->Parameters[] */
-   PROGRAM_CONSTANT,    /**< gl_program->Parameters[] */
-   PROGRAM_UNIFORM,     /**< gl_program->Parameters[] */
-   PROGRAM_WRITE_ONLY,  /**< A dummy, write-only register */
-   PROGRAM_ADDRESS,     /**< machine->AddressReg */
-   PROGRAM_SAMPLER,     /**< for shader samplers, compile-time only */
-   PROGRAM_SYSTEM_VALUE,/**< InstanceId, PrimitiveID, etc. */
-   PROGRAM_UNDEFINED,   /**< Invalid/TBD value */
-   PROGRAM_FILE_MAX
-} gl_register_file;
-
-
-/**
- * If the register file is PROGRAM_SYSTEM_VALUE, the register index will be
- * one of these values.
- */
-typedef enum
-{
-   SYSTEM_VALUE_FRONT_FACE,  /**< Fragment shader only (not done yet) */
-   SYSTEM_VALUE_INSTANCE_ID, /**< Vertex shader only */
-   SYSTEM_VALUE_MAX          /**< Number of values */
-} gl_system_value;
-
-
-/** Vertex and fragment instructions */
-struct prog_instruction;
-struct gl_program_parameter_list;
-struct gl_uniform_list;
-
-
-/**
- * Base class for any kind of program object
- */
-struct gl_program
-{
-   GLuint Id;
-   GLubyte *String;  /**< Null-terminated program text */
-   GLint RefCount;
-   GLenum Target;    /**< GL_VERTEX/FRAGMENT_PROGRAM_ARB, GL_FRAGMENT_PROGRAM_NV */
-   GLenum Format;    /**< String encoding format */
-   GLboolean Resident;
-
-   struct prog_instruction *Instructions;
-
-   GLbitfield InputsRead;     /**< Bitmask of which input regs are read */
-   GLbitfield64 OutputsWritten; /**< Bitmask of which output regs are written */
-   GLbitfield SystemValuesRead;   /**< Bitmask of SYSTEM_VALUE_x inputs used */
-   GLbitfield InputFlags[MAX_PROGRAM_INPUTS];   /**< PROG_PARAM_BIT_x flags */
-   GLbitfield OutputFlags[MAX_PROGRAM_OUTPUTS]; /**< PROG_PARAM_BIT_x flags */
-   GLbitfield TexturesUsed[MAX_TEXTURE_UNITS];  /**< TEXTURE_x_BIT bitmask */
-   GLbitfield SamplersUsed;   /**< Bitfield of which samplers are used */
-   GLbitfield ShadowSamplers; /**< Texture units used for shadow sampling. */
-
-
-   /** Named parameters, constants, etc. from program text */
-   struct gl_program_parameter_list *Parameters;
-   /** Numbered local parameters */
-   GLfloat LocalParams[MAX_PROGRAM_LOCAL_PARAMS][4];
-
-   /** Vertex/fragment shader varying vars */
-   struct gl_program_parameter_list *Varying;
-   /** Vertex program user-defined attributes */
-   struct gl_program_parameter_list *Attributes;
-
-   /** Map from sampler unit to texture unit (set by glUniform1i()) */
-   GLubyte SamplerUnits[MAX_SAMPLERS];
-   /** Which texture target is being sampled (TEXTURE_1D/2D/3D/etc_INDEX) */
-   gl_texture_index SamplerTargets[MAX_SAMPLERS];
-
-   /** Bitmask of which register files are read/written with indirect
-    * addressing.  Mask of (1 << PROGRAM_x) bits.
-    */
-   GLbitfield IndirectRegisterFiles;
-
-   /** Logical counts */
-   /*@{*/
-   GLuint NumInstructions;
-   GLuint NumTemporaries;
-   GLuint NumParameters;
-   GLuint NumAttributes;
-   GLuint NumAddressRegs;
-   GLuint NumAluInstructions;
-   GLuint NumTexInstructions;
-   GLuint NumTexIndirections;
-   /*@}*/
-   /** Native, actual h/w counts */
-   /*@{*/
-   GLuint NumNativeInstructions;
-   GLuint NumNativeTemporaries;
-   GLuint NumNativeParameters;
-   GLuint NumNativeAttributes;
-   GLuint NumNativeAddressRegs;
-   GLuint NumNativeAluInstructions;
-   GLuint NumNativeTexInstructions;
-   GLuint NumNativeTexIndirections;
-   /*@}*/
-};
-
-
-/** Vertex program object */
-struct gl_vertex_program
-{
-   struct gl_program Base;   /**< base class */
-   GLboolean IsNVProgram;    /**< is this a GL_NV_vertex_program program? */
-   GLboolean IsPositionInvariant;
-};
-
-
-/** Geometry program object */
-struct gl_geometry_program
-{
-   struct gl_program Base;   /**< base class */
-
-   GLint VerticesOut;
-   GLenum InputType;  /**< GL_POINTS, GL_LINES, GL_LINES_ADJACENCY_ARB,
-                           GL_TRIANGLES, or GL_TRIANGLES_ADJACENCY_ARB */
-   GLenum OutputType; /**< GL_POINTS, GL_LINE_STRIP or GL_TRIANGLE_STRIP */
-};
-
-
-/** Fragment program object */
-struct gl_fragment_program
-{
-   struct gl_program Base;   /**< base class */
-   GLenum FogOption;
-   GLboolean UsesKill;          /**< shader uses KIL instruction */
-   GLboolean OriginUpperLeft;
-   GLboolean PixelCenterInteger;
-   enum gl_frag_depth_layout FragDepthLayout;
-};
-
-
-/**
- * State common to vertex and fragment programs.
- */
-struct gl_program_state
-{
-   GLint ErrorPos;                       /* GL_PROGRAM_ERROR_POSITION_ARB/NV */
-   const char *ErrorString;              /* GL_PROGRAM_ERROR_STRING_ARB/NV */
-};
-
-
-/**
- * Context state for vertex programs.
- */
-struct gl_vertex_program_state
-{
-   GLboolean Enabled;            /**< User-set GL_VERTEX_PROGRAM_ARB/NV flag */
-   GLboolean _Enabled;           /**< Enabled and _valid_ user program? */
-   GLboolean PointSizeEnabled;   /**< GL_VERTEX_PROGRAM_POINT_SIZE_ARB/NV */
-   GLboolean TwoSideEnabled;     /**< GL_VERTEX_PROGRAM_TWO_SIDE_ARB/NV */
-   struct gl_vertex_program *Current;  /**< User-bound vertex program */
-
-   /** Currently enabled and valid vertex program (including internal
-    * programs, user-defined vertex programs and GLSL vertex shaders).
-    * This is the program we must use when rendering.
-    */
-   struct gl_vertex_program *_Current;
-
-   GLfloat Parameters[MAX_PROGRAM_ENV_PARAMS][4]; /**< Env params */
-
-   /* For GL_NV_vertex_program only: */
-   GLenum TrackMatrix[MAX_PROGRAM_ENV_PARAMS / 4];
-   GLenum TrackMatrixTransform[MAX_PROGRAM_ENV_PARAMS / 4];
-
-   /** Should fixed-function T&L be implemented with a vertex prog? */
-   GLboolean _MaintainTnlProgram;
-
-   /** Program to emulate fixed-function T&L (see above) */
-   struct gl_vertex_program *_TnlProgram;
-
-   /** Cache of fixed-function programs */
-   struct gl_program_cache *Cache;
-
-   GLboolean _Overriden;
-};
-
-
-/**
- * Context state for geometry programs.
- */
-struct gl_geometry_program_state
-{
-   GLboolean Enabled;               /**< GL_ARB_GEOMETRY_SHADER4 */
-   GLboolean _Enabled;              /**< Enabled and valid program? */
-   struct gl_geometry_program *Current;  /**< user-bound geometry program */
-
-   /** Currently enabled and valid program (including internal programs
-    * and compiled shader programs).
-    */
-   struct gl_geometry_program *_Current;
-
-   GLfloat Parameters[MAX_PROGRAM_ENV_PARAMS][4]; /**< Env params */
-
-   /** Cache of fixed-function programs */
-   struct gl_program_cache *Cache;
-};
-
-/**
- * Context state for fragment programs.
- */
-struct gl_fragment_program_state
-{
-   GLboolean Enabled;     /**< User-set fragment program enable flag */
-   GLboolean _Enabled;    /**< Enabled and _valid_ user program? */
-   struct gl_fragment_program *Current;  /**< User-bound fragment program */
-
-   /** Currently enabled and valid fragment program (including internal
-    * programs, user-defined fragment programs and GLSL fragment shaders).
-    * This is the program we must use when rendering.
-    */
-   struct gl_fragment_program *_Current;
-
-   GLfloat Parameters[MAX_PROGRAM_ENV_PARAMS][4]; /**< Env params */
-
-   /** Should fixed-function texturing be implemented with a fragment prog? */
-   GLboolean _MaintainTexEnvProgram;
-
-   /** Program to emulate fixed-function texture env/combine (see above) */
-   struct gl_fragment_program *_TexEnvProgram;
-
-   /** Cache of fixed-function programs */
-   struct gl_program_cache *Cache;
-};
-
-
-/**
- * ATI_fragment_shader runtime state
- */
-#define ATI_FS_INPUT_PRIMARY 0
-#define ATI_FS_INPUT_SECONDARY 1
-
-struct atifs_instruction;
-struct atifs_setupinst;
-
-/**
- * ATI fragment shader
- */
-struct ati_fragment_shader
-{
-   GLuint Id;
-   GLint RefCount;
-   struct atifs_instruction *Instructions[2];
-   struct atifs_setupinst *SetupInst[2];
-   GLfloat Constants[8][4];
-   GLbitfield LocalConstDef;  /**< Indicates which constants have been set */
-   GLubyte numArithInstr[2];
-   GLubyte regsAssigned[2];
-   GLubyte NumPasses;         /**< 1 or 2 */
-   GLubyte cur_pass;
-   GLubyte last_optype;
-   GLboolean interpinp1;
-   GLboolean isValid;
-   GLuint swizzlerq;
-};
-
-/**
- * Context state for GL_ATI_fragment_shader
- */
-struct gl_ati_fragment_shader_state
-{
-   GLboolean Enabled;
-   GLboolean _Enabled;                  /**< enabled and valid shader? */
-   GLboolean Compiling;
-   GLfloat GlobalConstants[8][4];
-   struct ati_fragment_shader *Current;
-};
-
-
-/**
- * Occlusion/timer query object.
- */
-struct gl_query_object
-{
-   GLenum Target;      /**< The query target, when active */
-   GLuint Id;          /**< hash table ID/name */
-   GLuint64EXT Result; /**< the counter */
-   GLboolean Active;   /**< inside Begin/EndQuery */
-   GLboolean Ready;    /**< result is ready? */
-};
-
-
-/**
- * Context state for query objects.
- */
-struct gl_query_state
-{
-   struct _mesa_HashTable *QueryObjects;
-   struct gl_query_object *CurrentOcclusionObject; /* GL_ARB_occlusion_query */
-   struct gl_query_object *CurrentTimerObject;     /* GL_EXT_timer_query */
-
-   /** GL_NV_conditional_render */
-   struct gl_query_object *CondRenderQuery;
-
-   /** GL_EXT_transform_feedback */
-   struct gl_query_object *PrimitivesGenerated;
-   struct gl_query_object *PrimitivesWritten;
-
-   /** GL_ARB_timer_query */
-   struct gl_query_object *TimeElapsed;
-
-   GLenum CondRenderMode;
-};
-
-
-/** Sync object state */
-struct gl_sync_object {
-   struct simple_node link;
-   GLenum Type;               /**< GL_SYNC_FENCE */
-   GLuint Name;               /**< Fence name */
-   GLint RefCount;            /**< Reference count */
-   GLboolean DeletePending;   /**< Object was deleted while there were still
-			       * live references (e.g., sync not yet finished)
-			       */
-   GLenum SyncCondition;
-   GLbitfield Flags;          /**< Flags passed to glFenceSync */
-   GLuint StatusFlag:1;       /**< Has the sync object been signaled? */
-};
-
-
-/** Set by #pragma directives */
-struct gl_sl_pragmas
-{
-   GLboolean IgnoreOptimize;  /**< ignore #pragma optimize(on/off) ? */
-   GLboolean IgnoreDebug;     /**< ignore #pragma debug(on/off) ? */
-   GLboolean Optimize;  /**< defaults on */
-   GLboolean Debug;     /**< defaults off */
-};
-
-
-/**
- * A GLSL vertex or fragment shader object.
- */
-struct gl_shader
-{
-   GLenum Type;  /**< GL_FRAGMENT_SHADER || GL_VERTEX_SHADER || GL_GEOMETRY_SHADER_ARB (first field!) */
-   GLuint Name;  /**< AKA the handle */
-   GLint RefCount;  /**< Reference count */
-   GLboolean DeletePending;
-   GLboolean CompileStatus;
-   const GLchar *Source;  /**< Source code string */
-   GLuint SourceChecksum;       /**< for debug/logging purposes */
-   struct gl_program *Program;  /**< Post-compile assembly code */
-   GLchar *InfoLog;
-   struct gl_sl_pragmas Pragmas;
-
-   unsigned Version;       /**< GLSL version used for linking */
-
-   struct exec_list *ir;
-   struct glsl_symbol_table *symbols;
-
-   /** Shaders containing built-in functions that are used for linking. */
-   struct gl_shader *builtins_to_link[16];
-   unsigned num_builtins_to_link;
-};
-
-
-/**
- * A GLSL program object.
- * Basically a linked collection of vertex and fragment shaders.
- */
-struct gl_shader_program
-{
-   GLenum Type;  /**< Always GL_SHADER_PROGRAM (internal token) */
-   GLuint Name;  /**< aka handle or ID */
-   GLint RefCount;  /**< Reference count */
-   GLboolean DeletePending;
-
-   GLuint NumShaders;          /**< number of attached shaders */
-   struct gl_shader **Shaders; /**< List of attached the shaders */
-
-   /** User-defined attribute bindings (glBindAttribLocation) */
-   struct gl_program_parameter_list *Attributes;
-
-   /** Transform feedback varyings */
-   struct {
-      GLenum BufferMode;
-      GLuint NumVarying;
-      GLchar **VaryingNames;  /**< Array [NumVarying] of char * */
-   } TransformFeedback;
-
-   /** Geometry shader state - copied into gl_geometry_program at link time */
-   struct {
-      GLint VerticesOut;
-      GLenum InputType;  /**< GL_POINTS, GL_LINES, GL_LINES_ADJACENCY_ARB,
-                              GL_TRIANGLES, or GL_TRIANGLES_ADJACENCY_ARB */
-      GLenum OutputType; /**< GL_POINTS, GL_LINE_STRIP or GL_TRIANGLE_STRIP */
-   } Geom;
-
-   /* post-link info: */
-   struct gl_vertex_program *VertexProgram;     /**< Linked vertex program */
-   struct gl_fragment_program *FragmentProgram; /**< Linked fragment prog */
-   struct gl_geometry_program *GeometryProgram; /**< Linked geometry prog */
-   struct gl_uniform_list *Uniforms;
-   struct gl_program_parameter_list *Varying;
-   GLboolean LinkStatus;   /**< GL_LINK_STATUS */
-   GLboolean Validated;
-   GLboolean _Used;        /**< Ever used for drawing? */
-   GLchar *InfoLog;
-
-   unsigned Version;       /**< GLSL version used for linking */
-
-   /**
-    * Per-stage shaders resulting from the first stage of linking.
-    *
-    * Set of linked shaders for this program.  The array is accessed using the
-    * \c MESA_SHADER_* defines.  Entries for non-existent stages will be
-    * \c NULL.
-    */
-   struct gl_shader *_LinkedShaders[MESA_SHADER_TYPES];
-};   
-
-
-#define GLSL_DUMP      0x1  /**< Dump shaders to stdout */
-#define GLSL_LOG       0x2  /**< Write shaders to files */
-#define GLSL_OPT       0x4  /**< Force optimizations (override pragmas) */
-#define GLSL_NO_OPT    0x8  /**< Force no optimizations (override pragmas) */
-#define GLSL_UNIFORMS 0x10  /**< Print glUniform calls */
-#define GLSL_NOP_VERT 0x20  /**< Force no-op vertex shaders */
-#define GLSL_NOP_FRAG 0x40  /**< Force no-op fragment shaders */
-#define GLSL_USE_PROG 0x80  /**< Log glUseProgram calls */
-
-
-/**
- * Context state for GLSL vertex/fragment shaders.
- */
-struct gl_shader_state
-{
-   /**
-    * Programs used for rendering
-    *
-    * There is a separate program set for each shader stage.  If
-    * GL_EXT_separate_shader_objects is not supported, each of these must point
-    * to \c NULL or to the same program.
-    */
-   struct gl_shader_program *CurrentVertexProgram;
-   struct gl_shader_program *CurrentGeometryProgram;
-   struct gl_shader_program *CurrentFragmentProgram;
-
-   /**
-    * Program used by glUniform calls.
-    *
-    * Explicitly set by \c glUseProgram and \c glActiveProgramEXT.
-    */
-   struct gl_shader_program *ActiveProgram;
-
-   void *MemPool;
-
-   GLbitfield Flags;                    /**< Mask of GLSL_x flags */
-};
-
-/**
- * Compiler options for a single GLSL shaders type
- */
-struct gl_shader_compiler_options
-{
-   /** Driver-selectable options: */
-   GLboolean EmitCondCodes;             /**< Use condition codes? */
-   GLboolean EmitNVTempInitialization;  /**< 0-fill NV temp registers */
-   /**
-    * Attempts to flatten all ir_if (OPCODE_IF) for GPUs that can't
-    * support control flow.
-    */
-   GLboolean EmitNoIfs;
-   GLboolean EmitNoLoops;
-   GLboolean EmitNoFunctions;
-   GLboolean EmitNoCont;                  /**< Emit CONT opcode? */
-   GLboolean EmitNoMainReturn;            /**< Emit CONT/RET opcodes? */
-   GLboolean EmitNoNoise;                 /**< Emit NOISE opcodes? */
-   GLboolean EmitNoPow;                   /**< Emit POW opcodes? */
-
-   /**
-    * \name Forms of indirect addressing the driver cannot do.
-    */
-   /*@{*/
-   GLboolean EmitNoIndirectInput;   /**< No indirect addressing of inputs */
-   GLboolean EmitNoIndirectOutput;  /**< No indirect addressing of outputs */
-   GLboolean EmitNoIndirectTemp;    /**< No indirect addressing of temps */
-   GLboolean EmitNoIndirectUniform; /**< No indirect addressing of constants */
-   /*@}*/
-
-   GLuint MaxUnrollIterations;
-
-   struct gl_sl_pragmas DefaultPragmas; /**< Default #pragma settings */
-};
-
-/**
- * Transform feedback object state
- */
-struct gl_transform_feedback_object
-{
-   GLuint Name;  /**< AKA the object ID */
-   GLint RefCount;
-   GLboolean Active;  /**< Is transform feedback enabled? */
-   GLboolean Paused;  /**< Is transform feedback paused? */
-
-   /** The feedback buffers */
-   GLuint BufferNames[MAX_FEEDBACK_ATTRIBS];
-   struct gl_buffer_object *Buffers[MAX_FEEDBACK_ATTRIBS];
-
-   /** Start of feedback data in dest buffer */
-   GLintptr Offset[MAX_FEEDBACK_ATTRIBS];
-   /** Max data to put into dest buffer (in bytes) */
-   GLsizeiptr Size[MAX_FEEDBACK_ATTRIBS];
-};
-
-
-/**
- * Context state for transform feedback.
- */
-struct gl_transform_feedback
-{
-   GLenum Mode;       /**< GL_POINTS, GL_LINES or GL_TRIANGLES */
-
-   GLboolean RasterDiscard;  /**< GL_RASTERIZER_DISCARD */
-
-   /** The general binding point (GL_TRANSFORM_FEEDBACK_BUFFER) */
-   struct gl_buffer_object *CurrentBuffer;
-
-   /** The table of all transform feedback objects */
-   struct _mesa_HashTable *Objects;
-
-   /** The current xform-fb object (GL_TRANSFORM_FEEDBACK_BINDING) */
-   struct gl_transform_feedback_object *CurrentObject;
-
-   /** The default xform-fb object (Name==0) */
-   struct gl_transform_feedback_object *DefaultObject;
-};
-
-
-
-/**
- * State which can be shared by multiple contexts:
- */
-struct gl_shared_state
-{
-   _glthread_Mutex Mutex;		   /**< for thread safety */
-   GLint RefCount;			   /**< Reference count */
-   struct _mesa_HashTable *DisplayList;	   /**< Display lists hash table */
-   struct _mesa_HashTable *TexObjects;	   /**< Texture objects hash table */
-
-   /** Default texture objects (shared by all texture units) */
-   struct gl_texture_object *DefaultTex[NUM_TEXTURE_TARGETS];
-
-   /** Fallback texture used when a bound texture is incomplete */
-   struct gl_texture_object *FallbackTex;
-
-   /**
-    * \name Thread safety and statechange notification for texture
-    * objects. 
-    *
-    * \todo Improve the granularity of locking.
-    */
-   /*@{*/
-   _glthread_Mutex TexMutex;		/**< texobj thread safety */
-   GLuint TextureStateStamp;	        /**< state notification for shared tex */
-   /*@}*/
-
-   /** Default buffer object for vertex arrays that aren't in VBOs */
-   struct gl_buffer_object *NullBufferObj;
-
-   /**
-    * \name Vertex/geometry/fragment programs
-    */
-   /*@{*/
-   struct _mesa_HashTable *Programs; /**< All vertex/fragment programs */
-   struct gl_vertex_program *DefaultVertexProgram;
-   struct gl_fragment_program *DefaultFragmentProgram;
-   struct gl_geometry_program *DefaultGeometryProgram;
-   /*@}*/
-
-   /* GL_ATI_fragment_shader */
-   struct _mesa_HashTable *ATIShaders;
-   struct ati_fragment_shader *DefaultFragmentShader;
-
-   struct _mesa_HashTable *BufferObjects;
-
-   /** Table of both gl_shader and gl_shader_program objects */
-   struct _mesa_HashTable *ShaderObjects;
-
-   /* GL_EXT_framebuffer_object */
-   struct _mesa_HashTable *RenderBuffers;
-   struct _mesa_HashTable *FrameBuffers;
-
-   /* GL_ARB_sync */
-   struct simple_node SyncObjects;
-
-   void *DriverData;  /**< Device driver shared state */
-};
-
-
-
-
-/**
- * A renderbuffer stores colors or depth values or stencil values.
- * A framebuffer object will have a collection of these.
- * Data are read/written to the buffer with a handful of Get/Put functions.
- *
- * Instances of this object are allocated with the Driver's NewRenderbuffer
- * hook.  Drivers will likely wrap this class inside a driver-specific
- * class to simulate inheritance.
- */
-struct gl_renderbuffer
-{
-#define RB_MAGIC 0xaabbccdd
-   int Magic; /** XXX TEMPORARY DEBUG INFO */
-   _glthread_Mutex Mutex;		   /**< for thread safety */
-   GLuint ClassID;        /**< Useful for drivers */
-   GLuint Name;
-   GLint RefCount;
-   GLuint Width, Height;
-   GLboolean Purgeable;   /**< Is the buffer purgeable under memory pressure? */
-
-   GLenum InternalFormat; /**< The user-specified format */
-   GLenum _BaseFormat;    /**< Either GL_RGB, GL_RGBA, GL_DEPTH_COMPONENT or
-                               GL_STENCIL_INDEX. */
-   gl_format Format;      /**< The actual renderbuffer memory format */
-
-   GLubyte NumSamples;
-
-   GLenum DataType;      /**< Type of values passed to the Get/Put functions */
-   GLvoid *Data;        /**< This may not be used by some kinds of RBs */
-
-   GLboolean AttachedAnytime; /**< TRUE if it was attached to a framebuffer */
-
-   /* Used to wrap one renderbuffer around another: */
-   struct gl_renderbuffer *Wrapped;
-
-   /* Delete this renderbuffer */
-   void (*Delete)(struct gl_renderbuffer *rb);
-
-   /* Allocate new storage for this renderbuffer */
-   GLboolean (*AllocStorage)(struct gl_context *ctx, struct gl_renderbuffer *rb,
-                             GLenum internalFormat,
-                             GLuint width, GLuint height);
-
-   /* Lock/Unlock are called before/after calling the Get/Put functions.
-    * Not sure this is the right place for these yet.
-   void (*Lock)(struct gl_context *ctx, struct gl_renderbuffer *rb);
-   void (*Unlock)(struct gl_context *ctx, struct gl_renderbuffer *rb);
-    */
-
-   /* Return a pointer to the element/pixel at (x,y).
-    * Should return NULL if the buffer memory can't be directly addressed.
-    */
-   void *(*GetPointer)(struct gl_context *ctx, struct gl_renderbuffer *rb,
-                       GLint x, GLint y);
-
-   /* Get/Read a row of values.
-    * The values will be of format _BaseFormat and type DataType.
-    */
-   void (*GetRow)(struct gl_context *ctx, struct gl_renderbuffer *rb, GLuint count,
-                  GLint x, GLint y, void *values);
-
-   /* Get/Read values at arbitrary locations.
-    * The values will be of format _BaseFormat and type DataType.
-    */
-   void (*GetValues)(struct gl_context *ctx, struct gl_renderbuffer *rb, GLuint count,
-                     const GLint x[], const GLint y[], void *values);
-
-   /* Put/Write a row of values.
-    * The values will be of format _BaseFormat and type DataType.
-    */
-   void (*PutRow)(struct gl_context *ctx, struct gl_renderbuffer *rb, GLuint count,
-                  GLint x, GLint y, const void *values, const GLubyte *mask);
-
-   /* Put/Write a row of RGB values.  This is a special-case routine that's
-    * only used for RGBA renderbuffers when the source data is GL_RGB. That's
-    * a common case for glDrawPixels and some triangle routines.
-    * The values will be of format GL_RGB and type DataType.
-    */
-   void (*PutRowRGB)(struct gl_context *ctx, struct gl_renderbuffer *rb, GLuint count,
-                    GLint x, GLint y, const void *values, const GLubyte *mask);
-
-
-   /* Put/Write a row of identical values.
-    * The values will be of format _BaseFormat and type DataType.
-    */
-   void (*PutMonoRow)(struct gl_context *ctx, struct gl_renderbuffer *rb, GLuint count,
-                     GLint x, GLint y, const void *value, const GLubyte *mask);
-
-   /* Put/Write values at arbitrary locations.
-    * The values will be of format _BaseFormat and type DataType.
-    */
-   void (*PutValues)(struct gl_context *ctx, struct gl_renderbuffer *rb, GLuint count,
-                     const GLint x[], const GLint y[], const void *values,
-                     const GLubyte *mask);
-   /* Put/Write identical values at arbitrary locations.
-    * The values will be of format _BaseFormat and type DataType.
-    */
-   void (*PutMonoValues)(struct gl_context *ctx, struct gl_renderbuffer *rb,
-                         GLuint count, const GLint x[], const GLint y[],
-                         const void *value, const GLubyte *mask);
-};
-
-
-/**
- * A renderbuffer attachment points to either a texture object (and specifies
- * a mipmap level, cube face or 3D texture slice) or points to a renderbuffer.
- */
-struct gl_renderbuffer_attachment
-{
-   GLenum Type;  /**< \c GL_NONE or \c GL_TEXTURE or \c GL_RENDERBUFFER_EXT */
-   GLboolean Complete;
-
-   /**
-    * If \c Type is \c GL_RENDERBUFFER_EXT, this stores a pointer to the
-    * application supplied renderbuffer object.
-    */
-   struct gl_renderbuffer *Renderbuffer;
-
-   /**
-    * If \c Type is \c GL_TEXTURE, this stores a pointer to the application
-    * supplied texture object.
-    */
-   struct gl_texture_object *Texture;
-   GLuint TextureLevel; /**< Attached mipmap level. */
-   GLuint CubeMapFace;  /**< 0 .. 5, for cube map textures. */
-   GLuint Zoffset;      /**< Slice for 3D textures,  or layer for both 1D
-                         * and 2D array textures */
-};
-
-
-/**
- * A framebuffer is a collection of renderbuffers (color, depth, stencil, etc).
- * In C++ terms, think of this as a base class from which device drivers
- * will make derived classes.
- */
-struct gl_framebuffer
-{
-   _glthread_Mutex Mutex;  /**< for thread safety */
-   /**
-    * If zero, this is a window system framebuffer.  If non-zero, this
-    * is a FBO framebuffer; note that for some devices (i.e. those with
-    * a natural pixel coordinate system for FBOs that differs from the
-    * OpenGL/Mesa coordinate system), this means that the viewport,
-    * polygon face orientation, and polygon stipple will have to be inverted.
-    */
-   GLuint Name;
-
-   GLint RefCount;
-   GLboolean DeletePending;
-
-   /**
-    * The framebuffer's visual. Immutable if this is a window system buffer.
-    * Computed from attachments if user-made FBO.
-    */
-   struct gl_config Visual;
-
-   GLboolean Initialized;
-
-   GLuint Width, Height;	/**< size of frame buffer in pixels */
-
-   /** \name  Drawing bounds (Intersection of buffer size and scissor box) */
-   /*@{*/
-   GLint _Xmin, _Xmax;  /**< inclusive */
-   GLint _Ymin, _Ymax;  /**< exclusive */
-   /*@}*/
-
-   /** \name  Derived Z buffer stuff */
-   /*@{*/
-   GLuint _DepthMax;	/**< Max depth buffer value */
-   GLfloat _DepthMaxF;	/**< Float max depth buffer value */
-   GLfloat _MRD;	/**< minimum resolvable difference in Z values */
-   /*@}*/
-
-   /** One of the GL_FRAMEBUFFER_(IN)COMPLETE_* tokens */
-   GLenum _Status;
-
-   /** Integer color values */
-   GLboolean _IntegerColor;
-
-   /** Array of all renderbuffer attachments, indexed by BUFFER_* tokens. */
-   struct gl_renderbuffer_attachment Attachment[BUFFER_COUNT];
-
-   /* In unextended OpenGL these vars are part of the GL_COLOR_BUFFER
-    * attribute group and GL_PIXEL attribute group, respectively.
-    */
-   GLenum ColorDrawBuffer[MAX_DRAW_BUFFERS];
-   GLenum ColorReadBuffer;
-
-   /** Computed from ColorDraw/ReadBuffer above */
-   GLuint _NumColorDrawBuffers;
-   GLint _ColorDrawBufferIndexes[MAX_DRAW_BUFFERS]; /**< BUFFER_x or -1 */
-   GLint _ColorReadBufferIndex; /* -1 = None */
-   struct gl_renderbuffer *_ColorDrawBuffers[MAX_DRAW_BUFFERS];
-   struct gl_renderbuffer *_ColorReadBuffer;
-
-   /** The Actual depth/stencil buffers to use.  May be wrappers around the
-    * depth/stencil buffers attached above. */
-   struct gl_renderbuffer *_DepthBuffer;
-   struct gl_renderbuffer *_StencilBuffer;
-
-   /** Delete this framebuffer */
-   void (*Delete)(struct gl_framebuffer *fb);
-};
-
-
-/**
- * Precision info for shader datatypes.  See glGetShaderPrecisionFormat().
- */
-struct gl_precision
-{
-   GLushort RangeMin;   /**< min value exponent */
-   GLushort RangeMax;   /**< max value exponent */
-   GLushort Precision;  /**< number of mantissa bits */
-};
-
-
-/**
- * Limits for vertex and fragment programs/shaders.
- */
-struct gl_program_constants
-{
-   /* logical limits */
-   GLuint MaxInstructions;
-   GLuint MaxAluInstructions;
-   GLuint MaxTexInstructions;
-   GLuint MaxTexIndirections;
-   GLuint MaxAttribs;
-   GLuint MaxTemps;
-   GLuint MaxAddressRegs;
-   GLuint MaxAddressOffset;  /**< [-MaxAddressOffset, MaxAddressOffset-1] */
-   GLuint MaxParameters;
-   GLuint MaxLocalParams;
-   GLuint MaxEnvParams;
-   /* native/hardware limits */
-   GLuint MaxNativeInstructions;
-   GLuint MaxNativeAluInstructions;
-   GLuint MaxNativeTexInstructions;
-   GLuint MaxNativeTexIndirections;
-   GLuint MaxNativeAttribs;
-   GLuint MaxNativeTemps;
-   GLuint MaxNativeAddressRegs;
-   GLuint MaxNativeParameters;
-   /* For shaders */
-   GLuint MaxUniformComponents;
-   /* GL_ARB_geometry_shader4 */
-   GLuint MaxGeometryTextureImageUnits;
-   GLuint MaxGeometryVaryingComponents;
-   GLuint MaxVertexVaryingComponents;
-   GLuint MaxGeometryUniformComponents;
-   GLuint MaxGeometryOutputVertices;
-   GLuint MaxGeometryTotalOutputComponents;
-   /* ES 2.0 and GL_ARB_ES2_compatibility */
-   struct gl_precision LowFloat, MediumFloat, HighFloat;
-   struct gl_precision LowInt, MediumInt, HighInt;
-};
-
-
-/**
- * Constants which may be overridden by device driver during context creation
- * but are never changed after that.
- */
-struct gl_constants
-{
-   GLint MaxTextureMbytes;      /**< Max memory per image, in MB */
-   GLint MaxTextureLevels;      /**< Max mipmap levels. */ 
-   GLint Max3DTextureLevels;    /**< Max mipmap levels for 3D textures */
-   GLint MaxCubeTextureLevels;  /**< Max mipmap levels for cube textures */
-   GLint MaxArrayTextureLayers; /**< Max layers in array textures */
-   GLint MaxTextureRectSize;    /**< Max rectangle texture size, in pixes */
-   GLuint MaxTextureCoordUnits;
-   GLuint MaxTextureImageUnits;
-   GLuint MaxVertexTextureImageUnits;
-   GLuint MaxCombinedTextureImageUnits;
-   GLuint MaxTextureUnits;           /**< = MIN(CoordUnits, ImageUnits) */
-   GLfloat MaxTextureMaxAnisotropy;  /**< GL_EXT_texture_filter_anisotropic */
-   GLfloat MaxTextureLodBias;        /**< GL_EXT_texture_lod_bias */
-
-   GLuint MaxArrayLockSize;
-
-   GLint SubPixelBits;
-
-   GLfloat MinPointSize, MaxPointSize;	     /**< aliased */
-   GLfloat MinPointSizeAA, MaxPointSizeAA;   /**< antialiased */
-   GLfloat PointSizeGranularity;
-   GLfloat MinLineWidth, MaxLineWidth;       /**< aliased */
-   GLfloat MinLineWidthAA, MaxLineWidthAA;   /**< antialiased */
-   GLfloat LineWidthGranularity;
-
-   GLuint MaxColorTableSize;
-
-   GLuint MaxClipPlanes;
-   GLuint MaxLights;
-   GLfloat MaxShininess;                     /**< GL_NV_light_max_exponent */
-   GLfloat MaxSpotExponent;                  /**< GL_NV_light_max_exponent */
-
-   GLuint MaxViewportWidth, MaxViewportHeight;
-
-   struct gl_program_constants VertexProgram;   /**< GL_ARB_vertex_program */
-   struct gl_program_constants FragmentProgram; /**< GL_ARB_fragment_program */
-   struct gl_program_constants GeometryProgram;  /**< GL_ARB_geometry_shader4 */
-   GLuint MaxProgramMatrices;
-   GLuint MaxProgramMatrixStackDepth;
-
-   /** vertex array / buffer object bounds checking */
-   GLboolean CheckArrayBounds;
-
-   GLuint MaxDrawBuffers;    /**< GL_ARB_draw_buffers */
-
-   GLuint MaxColorAttachments;   /**< GL_EXT_framebuffer_object */
-   GLuint MaxRenderbufferSize;   /**< GL_EXT_framebuffer_object */
-   GLuint MaxSamples;            /**< GL_ARB_framebuffer_object */
-
-   GLuint MaxVarying;  /**< Number of float[4] varying parameters */
-
-   GLuint GLSLVersion;  /**< GLSL version supported (ex: 120 = 1.20) */
-
-   /** Which texture units support GL_ATI_envmap_bumpmap as targets */
-   GLbitfield SupportedBumpUnits;
-
-   /**
-    * Maximum amount of time, measured in nanseconds, that the server can wait.
-    */
-   GLuint64 MaxServerWaitTimeout;
-
-   /** GL_EXT_provoking_vertex */
-   GLboolean QuadsFollowProvokingVertexConvention;
-
-   /** OpenGL version 3.0 */
-   GLbitfield ContextFlags;  /**< Ex: GL_CONTEXT_FLAG_FORWARD_COMPATIBLE_BIT */
-
-   /** OpenGL version 3.2 */
-   GLbitfield ProfileMask;   /**< Mask of CONTEXT_x_PROFILE_BIT */
-
-   /** GL_EXT_transform_feedback */
-   GLuint MaxTransformFeedbackSeparateAttribs;
-   GLuint MaxTransformFeedbackSeparateComponents;
-   GLuint MaxTransformFeedbackInterleavedComponents;
-
-   /** GL_EXT_gpu_shader4 */
-   GLint MinProgramTexelOffset, MaxProgramTexelOffset;
-
-   /* GL_EXT_framebuffer_sRGB */
-   GLboolean sRGBCapable; /* can enable sRGB blend/update on FBOs */
-};
-
-
-/**
- * Enable flag for each OpenGL extension.  Different device drivers will
- * enable different extensions at runtime.
- */
-struct gl_extensions
-{
-   GLboolean dummy;  /* don't remove this! */
-   GLboolean dummy_true;  /* Set true by _mesa_init_extensions(). */
-   GLboolean dummy_false; /* Set false by _mesa_init_extensions(). */
-   GLboolean ARB_ES2_compatibility;
-   GLboolean ARB_blend_func_extended;
-   GLboolean ARB_copy_buffer;
-   GLboolean ARB_depth_buffer_float;
-   GLboolean ARB_depth_clamp;
-   GLboolean ARB_depth_texture;
-   GLboolean ARB_draw_buffers;
-   GLboolean ARB_draw_buffers_blend;
-   GLboolean ARB_draw_elements_base_vertex;
-   GLboolean ARB_draw_instanced;
-   GLboolean ARB_fragment_coord_conventions;
-   GLboolean ARB_fragment_program;
-   GLboolean ARB_fragment_program_shadow;
-   GLboolean ARB_fragment_shader;
-   GLboolean ARB_framebuffer_object;
-   GLboolean ARB_explicit_attrib_location;
-   GLboolean ARB_geometry_shader4;
-   GLboolean ARB_half_float_pixel;
-   GLboolean ARB_half_float_vertex;
-   GLboolean ARB_instanced_arrays;
-   GLboolean ARB_map_buffer_range;
-   GLboolean ARB_multisample;
-   GLboolean ARB_multitexture;
-   GLboolean ARB_occlusion_query;
-   GLboolean ARB_occlusion_query2;
-   GLboolean ARB_point_sprite;
-   GLboolean ARB_sampler_objects;
-   GLboolean ARB_seamless_cube_map;
-   GLboolean ARB_shader_objects;
-   GLboolean ARB_shader_stencil_export;
-   GLboolean ARB_shading_language_100;
-   GLboolean ARB_shadow;
-   GLboolean ARB_shadow_ambient;
-   GLboolean ARB_sync;
-   GLboolean ARB_texture_border_clamp;
-   GLboolean ARB_texture_buffer_object;
-   GLboolean ARB_texture_compression;
-   GLboolean ARB_texture_compression_rgtc;
-   GLboolean ARB_texture_cube_map;
-   GLboolean ARB_texture_env_combine;
-   GLboolean ARB_texture_env_crossbar;
-   GLboolean ARB_texture_env_dot3;
-   GLboolean ARB_texture_float;
-   GLboolean ARB_texture_mirrored_repeat;
-   GLboolean ARB_texture_multisample;
-   GLboolean ARB_texture_non_power_of_two;
-   GLboolean ARB_texture_rg;
-   GLboolean ARB_texture_rgb10_a2ui;
-   GLboolean ARB_timer_query;
-   GLboolean ARB_transform_feedback2;
-   GLboolean ARB_transpose_matrix;
-   GLboolean ARB_uniform_buffer_object;
-   GLboolean ARB_vertex_array_object;
-   GLboolean ARB_vertex_buffer_object;
-   GLboolean ARB_vertex_program;
-   GLboolean ARB_vertex_shader;
-   GLboolean ARB_vertex_type_2_10_10_10_rev;
-   GLboolean ARB_window_pos;
-   GLboolean EXT_abgr;
-   GLboolean EXT_bgra;
-   GLboolean EXT_blend_color;
-   GLboolean EXT_blend_equation_separate;
-   GLboolean EXT_blend_func_separate;
-   GLboolean EXT_blend_logic_op;
-   GLboolean EXT_blend_minmax;
-   GLboolean EXT_blend_subtract;
-   GLboolean EXT_clip_volume_hint;
-   GLboolean EXT_compiled_vertex_array;
-   GLboolean EXT_copy_texture;
-   GLboolean EXT_depth_bounds_test;
-   GLboolean EXT_draw_buffers2;
-   GLboolean EXT_draw_range_elements;
-   GLboolean EXT_fog_coord;
-   GLboolean EXT_framebuffer_blit;
-   GLboolean EXT_framebuffer_multisample;
-   GLboolean EXT_framebuffer_object;
-   GLboolean EXT_framebuffer_sRGB;
-   GLboolean EXT_gpu_program_parameters;
-   GLboolean EXT_gpu_shader4;
-   GLboolean EXT_multi_draw_arrays;
-   GLboolean EXT_paletted_texture;
-   GLboolean EXT_packed_depth_stencil;
-   GLboolean EXT_packed_float;
-   GLboolean EXT_packed_pixels;
-   GLboolean EXT_pixel_buffer_object;
-   GLboolean EXT_point_parameters;
-   GLboolean EXT_polygon_offset;
-   GLboolean EXT_provoking_vertex;
-   GLboolean EXT_rescale_normal;
-   GLboolean EXT_shadow_funcs;
-   GLboolean EXT_secondary_color;
-   GLboolean EXT_separate_shader_objects;
-   GLboolean EXT_separate_specular_color;
-   GLboolean EXT_shared_texture_palette;
-   GLboolean EXT_stencil_wrap;
-   GLboolean EXT_stencil_two_side;
-   GLboolean EXT_subtexture;
-   GLboolean EXT_texture;
-   GLboolean EXT_texture_object;
-   GLboolean EXT_texture3D;
-   GLboolean EXT_texture_array;
-   GLboolean EXT_texture_compression_latc;
-   GLboolean EXT_texture_compression_s3tc;
-   GLboolean EXT_texture_env_add;
-   GLboolean EXT_texture_env_combine;
-   GLboolean EXT_texture_env_dot3;
-   GLboolean EXT_texture_filter_anisotropic;
-   GLboolean EXT_texture_integer;
-   GLboolean EXT_texture_lod_bias;
-   GLboolean EXT_texture_mirror_clamp;
-   GLboolean EXT_texture_shared_exponent;
-   GLboolean EXT_texture_sRGB;
-   GLboolean EXT_texture_sRGB_decode;
-   GLboolean EXT_texture_swizzle;
-   GLboolean EXT_transform_feedback;
-   GLboolean EXT_timer_query;
-   GLboolean EXT_vertex_array;
-   GLboolean EXT_vertex_array_bgra;
-   GLboolean EXT_vertex_array_set;
-   GLboolean OES_standard_derivatives;
-   /* vendor extensions */
-   GLboolean AMD_conservative_depth;
-   GLboolean APPLE_client_storage;
-   GLboolean APPLE_packed_pixels;
-   GLboolean APPLE_vertex_array_object;
-   GLboolean APPLE_object_purgeable;
-   GLboolean ATI_envmap_bumpmap;
-   GLboolean ATI_texture_compression_3dc;
-   GLboolean ATI_texture_mirror_once;
-   GLboolean ATI_texture_env_combine3;
-   GLboolean ATI_fragment_shader;
-   GLboolean ATI_separate_stencil;
-   GLboolean IBM_rasterpos_clip;
-   GLboolean IBM_multimode_draw_arrays;
-   GLboolean MESA_pack_invert;
-   GLboolean MESA_resize_buffers;
-   GLboolean MESA_ycbcr_texture;
-   GLboolean MESA_texture_array;
-   GLboolean MESA_texture_signed_rgba;
-   GLboolean NV_blend_square;
-   GLboolean NV_conditional_render;
-   GLboolean NV_fragment_program;
-   GLboolean NV_fragment_program_option;
-   GLboolean NV_light_max_exponent;
-   GLboolean NV_point_sprite;
-   GLboolean NV_primitive_restart;
-   GLboolean NV_texgen_reflection;
-   GLboolean NV_texture_env_combine4;
-   GLboolean NV_texture_rectangle;
-   GLboolean NV_vertex_program;
-   GLboolean NV_vertex_program1_1;
-   GLboolean OES_read_format;
-   GLboolean SGIS_generate_mipmap;
-   GLboolean SGIS_texture_edge_clamp;
-   GLboolean SGIS_texture_lod;
-   GLboolean TDFX_texture_compression_FXT1;
-   GLboolean S3_s3tc;
-   GLboolean OES_EGL_image;
-   GLboolean OES_draw_texture;
-   GLboolean EXT_texture_format_BGRA8888;
-   GLboolean extension_sentinel;
-   /** The extension string */
-   const GLubyte *String;
-   /** Number of supported extensions */
-   GLuint Count;
-};
-
-
-/**
- * A stack of matrices (projection, modelview, color, texture, etc).
- */
-struct gl_matrix_stack
-{
-   GLmatrix *Top;      /**< points into Stack */
-   GLmatrix *Stack;    /**< array [MaxDepth] of GLmatrix */
-   GLuint Depth;       /**< 0 <= Depth < MaxDepth */
-   GLuint MaxDepth;    /**< size of Stack[] array */
-   GLuint DirtyFlag;   /**< _NEW_MODELVIEW or _NEW_PROJECTION, for example */
-};
-
-
-/**
- * \name Bits for image transfer operations 
- * \sa __struct gl_contextRec::ImageTransferState.
- */
-/*@{*/
-#define IMAGE_SCALE_BIAS_BIT                      0x1
-#define IMAGE_SHIFT_OFFSET_BIT                    0x2
-#define IMAGE_MAP_COLOR_BIT                       0x4
-#define IMAGE_CLAMP_BIT                           0x800
-
-
-/** Pixel Transfer ops */
-#define IMAGE_BITS (IMAGE_SCALE_BIAS_BIT |			\
-		    IMAGE_SHIFT_OFFSET_BIT |			\
-		    IMAGE_MAP_COLOR_BIT)
-
-/**
- * \name Bits to indicate what state has changed.  
- */
-/*@{*/
-#define _NEW_MODELVIEW         (1 << 0)   /**< gl_context::ModelView */
-#define _NEW_PROJECTION        (1 << 1)   /**< gl_context::Projection */
-#define _NEW_TEXTURE_MATRIX    (1 << 2)   /**< gl_context::TextureMatrix */
-#define _NEW_COLOR             (1 << 3)   /**< gl_context::Color */
-#define _NEW_DEPTH             (1 << 4)   /**< gl_context::Depth */
-#define _NEW_EVAL              (1 << 5)   /**< gl_context::Eval, EvalMap */
-#define _NEW_FOG               (1 << 6)   /**< gl_context::Fog */
-#define _NEW_HINT              (1 << 7)   /**< gl_context::Hint */
-#define _NEW_LIGHT             (1 << 8)   /**< gl_context::Light */
-#define _NEW_LINE              (1 << 9)   /**< gl_context::Line */
-#define _NEW_PIXEL             (1 << 10)  /**< gl_context::Pixel */
-#define _NEW_POINT             (1 << 11)  /**< gl_context::Point */
-#define _NEW_POLYGON           (1 << 12)  /**< gl_context::Polygon */
-#define _NEW_POLYGONSTIPPLE    (1 << 13)  /**< gl_context::PolygonStipple */
-#define _NEW_SCISSOR           (1 << 14)  /**< gl_context::Scissor */
-#define _NEW_STENCIL           (1 << 15)  /**< gl_context::Stencil */
-#define _NEW_TEXTURE           (1 << 16)  /**< gl_context::Texture */
-#define _NEW_TRANSFORM         (1 << 17)  /**< gl_context::Transform */
-#define _NEW_VIEWPORT          (1 << 18)  /**< gl_context::Viewport */
-#define _NEW_PACKUNPACK        (1 << 19)  /**< gl_context::Pack, Unpack */
-#define _NEW_ARRAY             (1 << 20)  /**< gl_context::Array */
-#define _NEW_RENDERMODE        (1 << 21)  /**< gl_context::RenderMode, etc */
-#define _NEW_BUFFERS           (1 << 22)  /**< gl_context::Visual, DrawBuffer, */
-#define _NEW_CURRENT_ATTRIB    (1 << 23)  /**< gl_context::Current */
-#define _NEW_MULTISAMPLE       (1 << 24)  /**< gl_context::Multisample */
-#define _NEW_TRACK_MATRIX      (1 << 25)  /**< gl_context::VertexProgram */
-#define _NEW_PROGRAM           (1 << 26)  /**< New program/shader state */
-#define _NEW_PROGRAM_CONSTANTS (1 << 27)
-#define _NEW_BUFFER_OBJECT     (1 << 28)
-#define _NEW_ALL ~0
-/*@}*/
-
-
-/**
- * \name Bits to track array state changes 
- *
- * Also used to summarize array enabled.
- */
-/*@{*/
-#define _NEW_ARRAY_VERTEX           VERT_BIT_POS
-#define _NEW_ARRAY_WEIGHT           VERT_BIT_WEIGHT
-#define _NEW_ARRAY_NORMAL           VERT_BIT_NORMAL
-#define _NEW_ARRAY_COLOR0           VERT_BIT_COLOR0
-#define _NEW_ARRAY_COLOR1           VERT_BIT_COLOR1
-#define _NEW_ARRAY_FOGCOORD         VERT_BIT_FOG
-#define _NEW_ARRAY_INDEX            VERT_BIT_COLOR_INDEX
-#define _NEW_ARRAY_EDGEFLAG         VERT_BIT_EDGEFLAG
-#define _NEW_ARRAY_POINT_SIZE       VERT_BIT_COLOR_INDEX  /* aliased */
-#define _NEW_ARRAY_TEXCOORD_0       VERT_BIT_TEX0
-#define _NEW_ARRAY_TEXCOORD_1       VERT_BIT_TEX1
-#define _NEW_ARRAY_TEXCOORD_2       VERT_BIT_TEX2
-#define _NEW_ARRAY_TEXCOORD_3       VERT_BIT_TEX3
-#define _NEW_ARRAY_TEXCOORD_4       VERT_BIT_TEX4
-#define _NEW_ARRAY_TEXCOORD_5       VERT_BIT_TEX5
-#define _NEW_ARRAY_TEXCOORD_6       VERT_BIT_TEX6
-#define _NEW_ARRAY_TEXCOORD_7       VERT_BIT_TEX7
-#define _NEW_ARRAY_ATTRIB_0         VERT_BIT_GENERIC0  /* start at bit 16 */
-#define _NEW_ARRAY_ALL              0xffffffff
-
-
-#define _NEW_ARRAY_TEXCOORD(i) (_NEW_ARRAY_TEXCOORD_0 << (i))
-#define _NEW_ARRAY_ATTRIB(i) (_NEW_ARRAY_ATTRIB_0 << (i))
-/*@}*/
-
-
-
-/**
- * \name A bunch of flags that we think might be useful to drivers.
- * 
- * Set in the __struct gl_contextRec::_TriangleCaps bitfield.
- */
-/*@{*/
-#define DD_FLATSHADE                0x1
-#define DD_SEPARATE_SPECULAR        0x2
-#define DD_TRI_CULL_FRONT_BACK      0x4 /* special case on some hw */
-#define DD_TRI_LIGHT_TWOSIDE        0x8
-#define DD_TRI_UNFILLED             0x10
-#define DD_TRI_SMOOTH               0x20
-#define DD_TRI_STIPPLE              0x40
-#define DD_TRI_OFFSET               0x80
-#define DD_LINE_SMOOTH              0x100
-#define DD_LINE_STIPPLE             0x200
-#define DD_POINT_SMOOTH             0x400
-#define DD_POINT_ATTEN              0x800
-#define DD_TRI_TWOSTENCIL           0x1000
-/*@}*/
-
-
-/**
- * \name Define the state changes under which each of these bits might change
- */
-/*@{*/
-#define _DD_NEW_FLATSHADE                _NEW_LIGHT
-#define _DD_NEW_SEPARATE_SPECULAR        (_NEW_LIGHT | _NEW_FOG | _NEW_PROGRAM)
-#define _DD_NEW_TRI_CULL_FRONT_BACK      _NEW_POLYGON
-#define _DD_NEW_TRI_LIGHT_TWOSIDE        _NEW_LIGHT
-#define _DD_NEW_TRI_UNFILLED             _NEW_POLYGON
-#define _DD_NEW_TRI_SMOOTH               _NEW_POLYGON
-#define _DD_NEW_TRI_STIPPLE              _NEW_POLYGON
-#define _DD_NEW_TRI_OFFSET               _NEW_POLYGON
-#define _DD_NEW_LINE_SMOOTH              _NEW_LINE
-#define _DD_NEW_LINE_STIPPLE             _NEW_LINE
-#define _DD_NEW_LINE_WIDTH               _NEW_LINE
-#define _DD_NEW_POINT_SMOOTH             _NEW_POINT
-#define _DD_NEW_POINT_SIZE               _NEW_POINT
-#define _DD_NEW_POINT_ATTEN              _NEW_POINT
-/*@}*/
-
-
-/**
- * Composite state flags
- */
-/*@{*/
-#define _MESA_NEW_NEED_EYE_COORDS         (_NEW_LIGHT |		\
-                                           _NEW_TEXTURE |	\
-                                           _NEW_POINT |		\
-                                           _NEW_PROGRAM |	\
-                                           _NEW_MODELVIEW)
-
-#define _MESA_NEW_NEED_NORMALS            (_NEW_LIGHT |		\
-                                           _NEW_TEXTURE)
-
-#define _MESA_NEW_TRANSFER_STATE          (_NEW_PIXEL)
-/*@}*/
-
-
-
-
-/* This has to be included here. */
-#include "dd.h"
-
-
-/**
- * Display list flags.
- * Strictly this is a tnl-private concept, but it doesn't seem
- * worthwhile adding a tnl private structure just to hold this one bit
- * of information:
- */
-#define DLIST_DANGLING_REFS     0x1 
-
-
-/** Opaque declaration of display list payload data type */
-union gl_dlist_node;
-
-
-/**
- * Provide a location where information about a display list can be
- * collected.  Could be extended with driverPrivate structures,
- * etc. in the future.
- */
-struct gl_display_list
-{
-   GLuint Name;
-   GLbitfield Flags;  /**< DLIST_x flags */
-   /** The dlist commands are in a linked list of nodes */
-   union gl_dlist_node *Head;
-};
-
-
-/**
- * State used during display list compilation and execution.
- */
-struct gl_dlist_state
-{
-   GLuint CallDepth;		/**< Current recursion calling depth */
-
-   struct gl_display_list *CurrentList; /**< List currently being compiled */
-   union gl_dlist_node *CurrentBlock; /**< Pointer to current block of nodes */
-   GLuint CurrentPos;		/**< Index into current block of nodes */
-
-   GLvertexformat ListVtxfmt;
-
-   GLubyte ActiveAttribSize[VERT_ATTRIB_MAX];
-   GLfloat CurrentAttrib[VERT_ATTRIB_MAX][4];
-   
-   GLubyte ActiveMaterialSize[MAT_ATTRIB_MAX];
-   GLfloat CurrentMaterial[MAT_ATTRIB_MAX][4];
-
-   GLubyte ActiveIndex;
-   GLfloat CurrentIndex;
-   
-   GLubyte ActiveEdgeFlag;
-   GLboolean CurrentEdgeFlag;
-
-   struct {
-      /* State known to have been set by the currently-compiling display
-       * list.  Used to eliminate some redundant state changes.
-       */
-      GLenum ShadeModel;
-   } Current;
-};
-
-
-/**
- * Enum for the OpenGL APIs we know about and may support.
- */
-typedef enum
-{
-   API_OPENGL,
-   API_OPENGLES,
-   API_OPENGLES2
-} gl_api;
-
-
-/**
- * Mesa rendering context.
- *
- * This is the central context data structure for Mesa.  Almost all
- * OpenGL state is contained in this structure.
- * Think of this as a base class from which device drivers will derive
- * sub classes.
- *
- * The struct gl_context typedef names this structure.
- */
-struct gl_context
-{
-   /** State possibly shared with other contexts in the address space */
-   struct gl_shared_state *Shared;
-
-   /** \name API function pointer tables */
-   /*@{*/
-   gl_api API;
-   struct _glapi_table *Save;	/**< Display list save functions */
-   struct _glapi_table *Exec;	/**< Execute functions */
-   struct _glapi_table *CurrentDispatch;  /**< == Save or Exec !! */
-   /*@}*/
-
-   struct gl_config Visual;
-   struct gl_framebuffer *DrawBuffer;	/**< buffer for writing */
-   struct gl_framebuffer *ReadBuffer;	/**< buffer for reading */
-   struct gl_framebuffer *WinSysDrawBuffer;  /**< set with MakeCurrent */
-   struct gl_framebuffer *WinSysReadBuffer;  /**< set with MakeCurrent */
-
-   /**
-    * Device driver function pointer table
-    */
-   struct dd_function_table Driver;
-
-   void *DriverCtx;	/**< Points to device driver context/state */
-
-   /** Core/Driver constants */
-   struct gl_constants Const;
-
-   /** \name The various 4x4 matrix stacks */
-   /*@{*/
-   struct gl_matrix_stack ModelviewMatrixStack;
-   struct gl_matrix_stack ProjectionMatrixStack;
-   struct gl_matrix_stack TextureMatrixStack[MAX_TEXTURE_UNITS];
-   struct gl_matrix_stack ProgramMatrixStack[MAX_PROGRAM_MATRICES];
-   struct gl_matrix_stack *CurrentStack; /**< Points to one of the above stacks */
-   /*@}*/
-
-   /** Combined modelview and projection matrix */
-   GLmatrix _ModelProjectMatrix;
-
-   /** \name Display lists */
-   struct gl_dlist_state ListState;
-
-   GLboolean ExecuteFlag;	/**< Execute GL commands? */
-   GLboolean CompileFlag;	/**< Compile GL commands into display list? */
-
-   /** Extension information */
-   struct gl_extensions Extensions;
-
-   /** Version info */
-   GLuint VersionMajor, VersionMinor;
-   char *VersionString;
-
-   /** \name State attribute stack (for glPush/PopAttrib) */
-   /*@{*/
-   GLuint AttribStackDepth;
-   struct gl_attrib_node *AttribStack[MAX_ATTRIB_STACK_DEPTH];
-   /*@}*/
-
-   /** \name Renderer attribute groups
-    * 
-    * We define a struct for each attribute group to make pushing and popping
-    * attributes easy.  Also it's a good organization.
-    */
-   /*@{*/
-   struct gl_accum_attrib	Accum;		/**< Accum buffer attributes */
-   struct gl_colorbuffer_attrib	Color;		/**< Color buffer attributes */
-   struct gl_current_attrib	Current;	/**< Current attributes */
-   struct gl_depthbuffer_attrib	Depth;		/**< Depth buffer attributes */
-   struct gl_eval_attrib	Eval;		/**< Eval attributes */
-   struct gl_fog_attrib		Fog;		/**< Fog attributes */
-   struct gl_hint_attrib	Hint;		/**< Hint attributes */
-   struct gl_light_attrib	Light;		/**< Light attributes */
-   struct gl_line_attrib	Line;		/**< Line attributes */
-   struct gl_list_attrib	List;		/**< List attributes */
-   struct gl_multisample_attrib Multisample;
-   struct gl_pixel_attrib	Pixel;		/**< Pixel attributes */
-   struct gl_point_attrib	Point;		/**< Point attributes */
-   struct gl_polygon_attrib	Polygon;	/**< Polygon attributes */
-   GLuint PolygonStipple[32];			/**< Polygon stipple */
-   struct gl_scissor_attrib	Scissor;	/**< Scissor attributes */
-   struct gl_stencil_attrib	Stencil;	/**< Stencil buffer attributes */
-   struct gl_texture_attrib	Texture;	/**< Texture attributes */
-   struct gl_transform_attrib	Transform;	/**< Transformation attributes */
-   struct gl_viewport_attrib	Viewport;	/**< Viewport attributes */
-   /*@}*/
-
-   /** \name Client attribute stack */
-   /*@{*/
-   GLuint ClientAttribStackDepth;
-   struct gl_attrib_node *ClientAttribStack[MAX_CLIENT_ATTRIB_STACK_DEPTH];
-   /*@}*/
-
-   /** \name Client attribute groups */
-   /*@{*/
-   struct gl_array_attrib	Array;	/**< Vertex arrays */
-   struct gl_pixelstore_attrib	Pack;	/**< Pixel packing */
-   struct gl_pixelstore_attrib	Unpack;	/**< Pixel unpacking */
-   struct gl_pixelstore_attrib	DefaultPacking;	/**< Default params */
-   /*@}*/
-
-   /** \name Other assorted state (not pushed/popped on attribute stack) */
-   /*@{*/
-   struct gl_pixelmaps          PixelMaps;
-
-   struct gl_evaluators EvalMap;   /**< All evaluators */
-   struct gl_feedback   Feedback;  /**< Feedback */
-   struct gl_selection  Select;    /**< Selection */
-
-   struct gl_program_state Program;  /**< general program state */
-   struct gl_vertex_program_state VertexProgram;
-   struct gl_fragment_program_state FragmentProgram;
-   struct gl_geometry_program_state GeometryProgram;
-   struct gl_ati_fragment_shader_state ATIFragmentShader;
-
-   struct gl_shader_state Shader; /**< GLSL shader object state */
-   struct gl_shader_compiler_options ShaderCompilerOptions[MESA_SHADER_TYPES];
-
-   struct gl_query_state Query;  /**< occlusion, timer queries */
-
-   struct gl_transform_feedback TransformFeedback;
-
-   struct gl_buffer_object *CopyReadBuffer; /**< GL_ARB_copy_buffer */
-   struct gl_buffer_object *CopyWriteBuffer; /**< GL_ARB_copy_buffer */
-   /*@}*/
-
-   struct gl_meta_state *Meta;  /**< for "meta" operations */
-
-   /* GL_EXT_framebuffer_object */
-   struct gl_renderbuffer *CurrentRenderbuffer;
-
-   GLenum ErrorValue;        /**< Last error code */
-
-   /**
-    * Recognize and silence repeated error debug messages in buggy apps.
-    */
-   const char *ErrorDebugFmtString;
-   GLuint ErrorDebugCount;
-
-   GLenum RenderMode;        /**< either GL_RENDER, GL_SELECT, GL_FEEDBACK */
-   GLbitfield NewState;      /**< bitwise-or of _NEW_* flags */
-
-   GLboolean ViewportInitialized;  /**< has viewport size been initialized? */
-
-   GLbitfield varying_vp_inputs;  /**< mask of VERT_BIT_* flags */
-
-   /** \name Derived state */
-   /*@{*/
-   /** Bitwise-or of DD_* flags.  Note that this bitfield may be used before
-    * state validation so they need to always be current.
-    */
-   GLbitfield _TriangleCaps;
-   GLbitfield _ImageTransferState;/**< bitwise-or of IMAGE_*_BIT flags */
-   GLfloat _EyeZDir[3];
-   GLfloat _ModelViewInvScale;
-   GLboolean _NeedEyeCoords;
-   GLboolean _ForceEyeCoords; 
-
-   GLuint TextureStateTimestamp; /**< detect changes to shared state */
-
-   struct gl_shine_tab *_ShineTable[2]; /**< Active shine tables */
-   struct gl_shine_tab *_ShineTabList;  /**< MRU list of inactive shine tables */
-   /**@}*/
-
-   struct gl_list_extensions *ListExt; /**< driver dlist extensions */
-
-   /** \name For debugging/development only */
-   /*@{*/
-   GLboolean FirstTimeCurrent;
-   /*@}*/
-
-   /** software compression/decompression supported or not */
-   GLboolean Mesa_DXTn;
-
-   GLboolean TextureFormatSupported[MESA_FORMAT_COUNT];
-
-   /** 
-    * Use dp4 (rather than mul/mad) instructions for position
-    * transformation?
-    */
-   GLboolean mvp_with_dp4;
-
-   /**
-    * \name Hooks for module contexts.  
-    *
-    * These will eventually live in the driver or elsewhere.
-    */
-   /*@{*/
-   void *swrast_context;
-   void *swsetup_context;
-   void *swtnl_context;
-   void *swtnl_im;
-   struct st_context *st;
-   void *aelt_context;
-   /*@}*/
-};
-
-
-#ifdef DEBUG
-extern int MESA_VERBOSE;
-extern int MESA_DEBUG_FLAGS;
-# define MESA_FUNCTION __FUNCTION__
-#else
-# define MESA_VERBOSE 0
-# define MESA_DEBUG_FLAGS 0
-# define MESA_FUNCTION "a function"
-# ifndef NDEBUG
-#  define NDEBUG
-# endif
-#endif
-
-
-/** The MESA_VERBOSE var is a bitmask of these flags */
-enum _verbose
-{
-   VERBOSE_VARRAY		= 0x0001,
-   VERBOSE_TEXTURE		= 0x0002,
-   VERBOSE_MATERIAL		= 0x0004,
-   VERBOSE_PIPELINE		= 0x0008,
-   VERBOSE_DRIVER		= 0x0010,
-   VERBOSE_STATE		= 0x0020,
-   VERBOSE_API			= 0x0040,
-   VERBOSE_DISPLAY_LIST		= 0x0100,
-   VERBOSE_LIGHTING		= 0x0200,
-   VERBOSE_PRIMS		= 0x0400,
-   VERBOSE_VERTS		= 0x0800,
-   VERBOSE_DISASSEM		= 0x1000,
-   VERBOSE_DRAW                 = 0x2000,
-   VERBOSE_SWAPBUFFERS          = 0x4000
-};
-
-
-/** The MESA_DEBUG_FLAGS var is a bitmask of these flags */
-enum _debug
-{
-   DEBUG_ALWAYS_FLUSH		= 0x1
-};
-
-
-
-#endif /* MTYPES_H */
+/*

+ * Mesa 3-D graphics library

+ * Version:  7.7

+ *

+ * 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 mtypes.h

+ * Main Mesa data structures.

+ *

+ * Please try to mark derived values with a leading underscore ('_').

+ */

+

+#ifndef MTYPES_H

+#define MTYPES_H

+

+

+#include "main/glheader.h"

+#include "main/config.h"

+#include "main/mfeatures.h"

+#include "glapi/glapi.h"

+#include "math/m_matrix.h"	/* GLmatrix */

+#include "main/simple_list.h"	/* struct simple_node */

+#include "main/formats.h"       /* MESA_FORMAT_COUNT */

+

+

+/**

+ * Color channel data type.

+ */

+#if CHAN_BITS == 8

+   typedef GLubyte GLchan;

+#define CHAN_MAX 255

+#define CHAN_MAXF 255.0F

+#define CHAN_TYPE GL_UNSIGNED_BYTE

+#elif CHAN_BITS == 16

+   typedef GLushort GLchan;

+#define CHAN_MAX 65535

+#define CHAN_MAXF 65535.0F

+#define CHAN_TYPE GL_UNSIGNED_SHORT

+#elif CHAN_BITS == 32

+   typedef GLfloat GLchan;

+#define CHAN_MAX 1.0

+#define CHAN_MAXF 1.0F

+#define CHAN_TYPE GL_FLOAT

+#else

+#error "illegal number of color channel bits"

+#endif

+

+

+/**

+ * Stencil buffer data type.

+ */

+#if STENCIL_BITS==8

+   typedef GLubyte GLstencil;

+#elif STENCIL_BITS==16

+   typedef GLushort GLstencil;

+#else

+#  error "illegal number of stencil bits"

+#endif

+

+

+/**

+ * \name 64-bit extension of GLbitfield.

+ */

+/*@{*/

+typedef GLuint64 GLbitfield64;

+

+/** Set a single bit */

+#define BITFIELD64_BIT(b)      (1ULL << (b))

+

+

+/**

+ * \name Some forward type declarations

+ */

+/*@{*/

+struct _mesa_HashTable;

+struct gl_attrib_node;

+struct gl_list_extensions;

+struct gl_meta_state;

+struct gl_pixelstore_attrib;

+struct gl_program_cache;

+struct gl_texture_format;

+struct gl_texture_image;

+struct gl_texture_object;

+struct gl_context;

+struct st_context;

+/*@}*/

+

+

+/** Extra draw modes beyond GL_POINTS, GL_TRIANGLE_FAN, etc */

+#define PRIM_OUTSIDE_BEGIN_END   (GL_POLYGON+1)

+#define PRIM_INSIDE_UNKNOWN_PRIM (GL_POLYGON+2)

+#define PRIM_UNKNOWN             (GL_POLYGON+3)

+

+

+/**

+ * Shader stages. Note that these will become 5 with tessellation.

+ * These MUST have the same values as gallium's PIPE_SHADER_*

+ */

+typedef enum

+{

+   MESA_SHADER_VERTEX = 0,

+   MESA_SHADER_FRAGMENT = 1,

+   MESA_SHADER_GEOMETRY = 2,

+   MESA_SHADER_TYPES = 3

+} gl_shader_type;

+

+

+

+/**

+ * Indexes for vertex program attributes.

+ * GL_NV_vertex_program aliases generic attributes over the conventional

+ * attributes.  In GL_ARB_vertex_program shader the aliasing is optional.

+ * In GL_ARB_vertex_shader / OpenGL 2.0 the aliasing is disallowed (the

+ * generic attributes are distinct/separate).

+ */

+typedef enum

+{

+   VERT_ATTRIB_POS = 0,

+   VERT_ATTRIB_WEIGHT = 1,

+   VERT_ATTRIB_NORMAL = 2,

+   VERT_ATTRIB_COLOR0 = 3,

+   VERT_ATTRIB_COLOR1 = 4,

+   VERT_ATTRIB_FOG = 5,

+   VERT_ATTRIB_COLOR_INDEX = 6,

+   VERT_ATTRIB_POINT_SIZE = 6,  /*alias*/

+   VERT_ATTRIB_EDGEFLAG = 7,

+   VERT_ATTRIB_TEX0 = 8,

+   VERT_ATTRIB_TEX1 = 9,

+   VERT_ATTRIB_TEX2 = 10,

+   VERT_ATTRIB_TEX3 = 11,

+   VERT_ATTRIB_TEX4 = 12,

+   VERT_ATTRIB_TEX5 = 13,

+   VERT_ATTRIB_TEX6 = 14,

+   VERT_ATTRIB_TEX7 = 15,

+   VERT_ATTRIB_GENERIC0 = 16,

+   VERT_ATTRIB_GENERIC1 = 17,

+   VERT_ATTRIB_GENERIC2 = 18,

+   VERT_ATTRIB_GENERIC3 = 19,

+   VERT_ATTRIB_GENERIC4 = 20,

+   VERT_ATTRIB_GENERIC5 = 21,

+   VERT_ATTRIB_GENERIC6 = 22,

+   VERT_ATTRIB_GENERIC7 = 23,

+   VERT_ATTRIB_GENERIC8 = 24,

+   VERT_ATTRIB_GENERIC9 = 25,

+   VERT_ATTRIB_GENERIC10 = 26,

+   VERT_ATTRIB_GENERIC11 = 27,

+   VERT_ATTRIB_GENERIC12 = 28,

+   VERT_ATTRIB_GENERIC13 = 29,

+   VERT_ATTRIB_GENERIC14 = 30,

+   VERT_ATTRIB_GENERIC15 = 31,

+   VERT_ATTRIB_MAX = 32

+} gl_vert_attrib;

+

+/**

+ * Bitflags for vertex attributes.

+ * These are used in bitfields in many places.

+ */

+/*@{*/

+#define VERT_BIT_POS         (1 << VERT_ATTRIB_POS)

+#define VERT_BIT_WEIGHT      (1 << VERT_ATTRIB_WEIGHT)

+#define VERT_BIT_NORMAL      (1 << VERT_ATTRIB_NORMAL)

+#define VERT_BIT_COLOR0      (1 << VERT_ATTRIB_COLOR0)

+#define VERT_BIT_COLOR1      (1 << VERT_ATTRIB_COLOR1)

+#define VERT_BIT_FOG         (1 << VERT_ATTRIB_FOG)

+#define VERT_BIT_COLOR_INDEX (1 << VERT_ATTRIB_COLOR_INDEX)

+#define VERT_BIT_EDGEFLAG    (1 << VERT_ATTRIB_EDGEFLAG)

+#define VERT_BIT_TEX0        (1 << VERT_ATTRIB_TEX0)

+#define VERT_BIT_TEX1        (1 << VERT_ATTRIB_TEX1)

+#define VERT_BIT_TEX2        (1 << VERT_ATTRIB_TEX2)

+#define VERT_BIT_TEX3        (1 << VERT_ATTRIB_TEX3)

+#define VERT_BIT_TEX4        (1 << VERT_ATTRIB_TEX4)

+#define VERT_BIT_TEX5        (1 << VERT_ATTRIB_TEX5)

+#define VERT_BIT_TEX6        (1 << VERT_ATTRIB_TEX6)

+#define VERT_BIT_TEX7        (1 << VERT_ATTRIB_TEX7)

+#define VERT_BIT_GENERIC0    (1 << VERT_ATTRIB_GENERIC0)

+#define VERT_BIT_GENERIC1    (1 << VERT_ATTRIB_GENERIC1)

+#define VERT_BIT_GENERIC2    (1 << VERT_ATTRIB_GENERIC2)

+#define VERT_BIT_GENERIC3    (1 << VERT_ATTRIB_GENERIC3)

+#define VERT_BIT_GENERIC4    (1 << VERT_ATTRIB_GENERIC4)

+#define VERT_BIT_GENERIC5    (1 << VERT_ATTRIB_GENERIC5)

+#define VERT_BIT_GENERIC6    (1 << VERT_ATTRIB_GENERIC6)

+#define VERT_BIT_GENERIC7    (1 << VERT_ATTRIB_GENERIC7)

+#define VERT_BIT_GENERIC8    (1 << VERT_ATTRIB_GENERIC8)

+#define VERT_BIT_GENERIC9    (1 << VERT_ATTRIB_GENERIC9)

+#define VERT_BIT_GENERIC10   (1 << VERT_ATTRIB_GENERIC10)

+#define VERT_BIT_GENERIC11   (1 << VERT_ATTRIB_GENERIC11)

+#define VERT_BIT_GENERIC12   (1 << VERT_ATTRIB_GENERIC12)

+#define VERT_BIT_GENERIC13   (1 << VERT_ATTRIB_GENERIC13)

+#define VERT_BIT_GENERIC14   (1 << VERT_ATTRIB_GENERIC14)

+#define VERT_BIT_GENERIC15   (1 << VERT_ATTRIB_GENERIC15)

+

+#define VERT_BIT_TEX(u)  (1 << (VERT_ATTRIB_TEX0 + (u)))

+#define VERT_BIT_GENERIC(g)  (1 << (VERT_ATTRIB_GENERIC0 + (g)))

+/*@}*/

+

+

+/**

+ * Indexes for vertex program result attributes

+ */

+typedef enum

+{

+   VERT_RESULT_HPOS = 0,

+   VERT_RESULT_COL0 = 1,

+   VERT_RESULT_COL1 = 2,

+   VERT_RESULT_FOGC = 3,

+   VERT_RESULT_TEX0 = 4,

+   VERT_RESULT_TEX1 = 5,

+   VERT_RESULT_TEX2 = 6,

+   VERT_RESULT_TEX3 = 7,

+   VERT_RESULT_TEX4 = 8,

+   VERT_RESULT_TEX5 = 9,

+   VERT_RESULT_TEX6 = 10,

+   VERT_RESULT_TEX7 = 11,

+   VERT_RESULT_PSIZ = 12,

+   VERT_RESULT_BFC0 = 13,

+   VERT_RESULT_BFC1 = 14,

+   VERT_RESULT_EDGE = 15,

+   VERT_RESULT_VAR0 = 16,  /**< shader varying */

+   VERT_RESULT_MAX = (VERT_RESULT_VAR0 + MAX_VARYING)

+} gl_vert_result;

+

+

+/*********************************************/

+

+/**

+ * Indexes for geometry program attributes.

+ */

+typedef enum

+{

+   GEOM_ATTRIB_POSITION = 0,

+   GEOM_ATTRIB_COLOR0 = 1,

+   GEOM_ATTRIB_COLOR1 = 2,

+   GEOM_ATTRIB_SECONDARY_COLOR0 = 3,

+   GEOM_ATTRIB_SECONDARY_COLOR1 = 4,

+   GEOM_ATTRIB_FOG_FRAG_COORD = 5,

+   GEOM_ATTRIB_POINT_SIZE = 6,

+   GEOM_ATTRIB_CLIP_VERTEX = 7,

+   GEOM_ATTRIB_PRIMITIVE_ID = 8,

+   GEOM_ATTRIB_TEX_COORD = 9,

+

+   GEOM_ATTRIB_VAR0 = 16,

+   GEOM_ATTRIB_MAX = (GEOM_ATTRIB_VAR0 + MAX_VARYING)

+} gl_geom_attrib;

+

+/**

+ * Bitflags for geometry attributes.

+ * These are used in bitfields in many places.

+ */

+/*@{*/

+#define GEOM_BIT_COLOR0      (1 << GEOM_ATTRIB_COLOR0)

+#define GEOM_BIT_COLOR1      (1 << GEOM_ATTRIB_COLOR1)

+#define GEOM_BIT_SCOLOR0     (1 << GEOM_ATTRIB_SECONDARY_COLOR0)

+#define GEOM_BIT_SCOLOR1     (1 << GEOM_ATTRIB_SECONDARY_COLOR1)

+#define GEOM_BIT_TEX_COORD   (1 << GEOM_ATTRIB_TEX_COORD)

+#define GEOM_BIT_FOG_COORD   (1 << GEOM_ATTRIB_FOG_FRAG_COORD)

+#define GEOM_BIT_POSITION    (1 << GEOM_ATTRIB_POSITION)

+#define GEOM_BIT_POINT_SIDE  (1 << GEOM_ATTRIB_POINT_SIZE)

+#define GEOM_BIT_CLIP_VERTEX (1 << GEOM_ATTRIB_CLIP_VERTEX)

+#define GEOM_BIT_PRIM_ID     (1 << GEOM_ATTRIB_PRIMITIVE_ID)

+#define GEOM_BIT_VAR0        (1 << GEOM_ATTRIB_VAR0)

+

+#define GEOM_BIT_VAR(g)  (1 << (GEOM_BIT_VAR0 + (g)))

+/*@}*/

+

+

+/**

+ * Indexes for geometry program result attributes

+ */

+typedef enum

+{

+   GEOM_RESULT_POS  = 0,

+   GEOM_RESULT_COL0  = 1,

+   GEOM_RESULT_COL1  = 2,

+   GEOM_RESULT_SCOL0 = 3,

+   GEOM_RESULT_SCOL1 = 4,

+   GEOM_RESULT_FOGC = 5,

+   GEOM_RESULT_TEX0 = 6,

+   GEOM_RESULT_TEX1 = 7,

+   GEOM_RESULT_TEX2 = 8,

+   GEOM_RESULT_TEX3 = 9,

+   GEOM_RESULT_TEX4 = 10,

+   GEOM_RESULT_TEX5 = 11,

+   GEOM_RESULT_TEX6 = 12,

+   GEOM_RESULT_TEX7 = 13,

+   GEOM_RESULT_PSIZ = 14,

+   GEOM_RESULT_CLPV = 15,

+   GEOM_RESULT_PRID = 16,

+   GEOM_RESULT_LAYR = 17,

+   GEOM_RESULT_VAR0 = 18,  /**< shader varying, should really be 16 */

+   /* ### we need to -2 because var0 is 18 instead 16 like in the others */

+   GEOM_RESULT_MAX  =  (GEOM_RESULT_VAR0 + MAX_VARYING - 2)

+} gl_geom_result;

+

+

+/**

+ * Indexes for fragment program input attributes.

+ */

+typedef enum

+{

+   FRAG_ATTRIB_WPOS = 0,

+   FRAG_ATTRIB_COL0 = 1,

+   FRAG_ATTRIB_COL1 = 2,

+   FRAG_ATTRIB_FOGC = 3,

+   FRAG_ATTRIB_TEX0 = 4,

+   FRAG_ATTRIB_TEX1 = 5,

+   FRAG_ATTRIB_TEX2 = 6,

+   FRAG_ATTRIB_TEX3 = 7,

+   FRAG_ATTRIB_TEX4 = 8,

+   FRAG_ATTRIB_TEX5 = 9,

+   FRAG_ATTRIB_TEX6 = 10,

+   FRAG_ATTRIB_TEX7 = 11,

+   FRAG_ATTRIB_FACE = 12,  /**< front/back face */

+   FRAG_ATTRIB_PNTC = 13,  /**< sprite/point coord */

+   FRAG_ATTRIB_VAR0 = 14,  /**< shader varying */

+   FRAG_ATTRIB_MAX = (FRAG_ATTRIB_VAR0 + MAX_VARYING)

+} gl_frag_attrib;

+

+/**

+ * Bitflags for fragment program input attributes.

+ */

+/*@{*/

+#define FRAG_BIT_WPOS  (1 << FRAG_ATTRIB_WPOS)

+#define FRAG_BIT_COL0  (1 << FRAG_ATTRIB_COL0)

+#define FRAG_BIT_COL1  (1 << FRAG_ATTRIB_COL1)

+#define FRAG_BIT_FOGC  (1 << FRAG_ATTRIB_FOGC)

+#define FRAG_BIT_FACE  (1 << FRAG_ATTRIB_FACE)

+#define FRAG_BIT_PNTC  (1 << FRAG_ATTRIB_PNTC)

+#define FRAG_BIT_TEX0  (1 << FRAG_ATTRIB_TEX0)

+#define FRAG_BIT_TEX1  (1 << FRAG_ATTRIB_TEX1)

+#define FRAG_BIT_TEX2  (1 << FRAG_ATTRIB_TEX2)

+#define FRAG_BIT_TEX3  (1 << FRAG_ATTRIB_TEX3)

+#define FRAG_BIT_TEX4  (1 << FRAG_ATTRIB_TEX4)

+#define FRAG_BIT_TEX5  (1 << FRAG_ATTRIB_TEX5)

+#define FRAG_BIT_TEX6  (1 << FRAG_ATTRIB_TEX6)

+#define FRAG_BIT_TEX7  (1 << FRAG_ATTRIB_TEX7)

+#define FRAG_BIT_VAR0  (1 << FRAG_ATTRIB_VAR0)

+

+#define FRAG_BIT_TEX(U)  (FRAG_BIT_TEX0 << (U))

+#define FRAG_BIT_VAR(V)  (FRAG_BIT_VAR0 << (V))

+

+#define FRAG_BITS_TEX_ANY (FRAG_BIT_TEX0|	\

+			   FRAG_BIT_TEX1|	\

+			   FRAG_BIT_TEX2|	\

+			   FRAG_BIT_TEX3|	\

+			   FRAG_BIT_TEX4|	\

+			   FRAG_BIT_TEX5|	\

+			   FRAG_BIT_TEX6|	\

+			   FRAG_BIT_TEX7)

+/*@}*/

+

+

+/**

+ * Fragment program results

+ */

+typedef enum

+{

+   FRAG_RESULT_DEPTH = 0,

+   FRAG_RESULT_STENCIL = 1,

+   FRAG_RESULT_COLOR = 2,

+   FRAG_RESULT_DATA0 = 3,

+   FRAG_RESULT_MAX = (FRAG_RESULT_DATA0 + MAX_DRAW_BUFFERS)

+} gl_frag_result;

+

+

+/**

+ * Indexes for all renderbuffers

+ */

+typedef enum

+{

+   /* the four standard color buffers */

+   BUFFER_FRONT_LEFT,

+   BUFFER_BACK_LEFT,

+   BUFFER_FRONT_RIGHT,

+   BUFFER_BACK_RIGHT,

+   BUFFER_DEPTH,

+   BUFFER_STENCIL,

+   BUFFER_ACCUM,

+   /* optional aux buffer */

+   BUFFER_AUX0,

+   /* generic renderbuffers */

+   BUFFER_COLOR0,

+   BUFFER_COLOR1,

+   BUFFER_COLOR2,

+   BUFFER_COLOR3,

+   BUFFER_COLOR4,

+   BUFFER_COLOR5,

+   BUFFER_COLOR6,

+   BUFFER_COLOR7,

+   BUFFER_COUNT

+} gl_buffer_index;

+

+/**

+ * Bit flags for all renderbuffers

+ */

+#define BUFFER_BIT_FRONT_LEFT   (1 << BUFFER_FRONT_LEFT)

+#define BUFFER_BIT_BACK_LEFT    (1 << BUFFER_BACK_LEFT)

+#define BUFFER_BIT_FRONT_RIGHT  (1 << BUFFER_FRONT_RIGHT)

+#define BUFFER_BIT_BACK_RIGHT   (1 << BUFFER_BACK_RIGHT)

+#define BUFFER_BIT_AUX0         (1 << BUFFER_AUX0)

+#define BUFFER_BIT_AUX1         (1 << BUFFER_AUX1)

+#define BUFFER_BIT_AUX2         (1 << BUFFER_AUX2)

+#define BUFFER_BIT_AUX3         (1 << BUFFER_AUX3)

+#define BUFFER_BIT_DEPTH        (1 << BUFFER_DEPTH)

+#define BUFFER_BIT_STENCIL      (1 << BUFFER_STENCIL)

+#define BUFFER_BIT_ACCUM        (1 << BUFFER_ACCUM)

+#define BUFFER_BIT_COLOR0       (1 << BUFFER_COLOR0)

+#define BUFFER_BIT_COLOR1       (1 << BUFFER_COLOR1)

+#define BUFFER_BIT_COLOR2       (1 << BUFFER_COLOR2)

+#define BUFFER_BIT_COLOR3       (1 << BUFFER_COLOR3)

+#define BUFFER_BIT_COLOR4       (1 << BUFFER_COLOR4)

+#define BUFFER_BIT_COLOR5       (1 << BUFFER_COLOR5)

+#define BUFFER_BIT_COLOR6       (1 << BUFFER_COLOR6)

+#define BUFFER_BIT_COLOR7       (1 << BUFFER_COLOR7)

+

+/**

+ * Mask of all the color buffer bits (but not accum).

+ */

+#define BUFFER_BITS_COLOR  (BUFFER_BIT_FRONT_LEFT | \

+                            BUFFER_BIT_BACK_LEFT | \

+                            BUFFER_BIT_FRONT_RIGHT | \

+                            BUFFER_BIT_BACK_RIGHT | \

+                            BUFFER_BIT_AUX0 | \

+                            BUFFER_BIT_COLOR0 | \

+                            BUFFER_BIT_COLOR1 | \

+                            BUFFER_BIT_COLOR2 | \

+                            BUFFER_BIT_COLOR3 | \

+                            BUFFER_BIT_COLOR4 | \

+                            BUFFER_BIT_COLOR5 | \

+                            BUFFER_BIT_COLOR6 | \

+                            BUFFER_BIT_COLOR7)

+

+

+/**

+ * Framebuffer configuration (aka visual / pixelformat)

+ * Note: some of these fields should be boolean, but it appears that

+ * code in drivers/dri/common/util.c requires int-sized fields.

+ */

+struct gl_config

+{

+   GLboolean rgbMode;

+   GLboolean floatMode;

+   GLboolean colorIndexMode;  /* XXX is this used anywhere? */

+   GLuint doubleBufferMode;

+   GLuint stereoMode;

+

+   GLboolean haveAccumBuffer;

+   GLboolean haveDepthBuffer;

+   GLboolean haveStencilBuffer;

+

+   GLint redBits, greenBits, blueBits, alphaBits;	/* bits per comp */

+   GLuint redMask, greenMask, blueMask, alphaMask;

+   GLint rgbBits;		/* total bits for rgb */

+   GLint indexBits;		/* total bits for colorindex */

+

+   GLint accumRedBits, accumGreenBits, accumBlueBits, accumAlphaBits;

+   GLint depthBits;

+   GLint stencilBits;

+

+   GLint numAuxBuffers;

+

+   GLint level;

+

+   /* EXT_visual_rating / GLX 1.2 */

+   GLint visualRating;

+

+   /* EXT_visual_info / GLX 1.2 */

+   GLint transparentPixel;

+   /*    colors are floats scaled to ints */

+   GLint transparentRed, transparentGreen, transparentBlue, transparentAlpha;

+   GLint transparentIndex;

+

+   /* ARB_multisample / SGIS_multisample */

+   GLint sampleBuffers;

+   GLint samples;

+

+   /* SGIX_pbuffer / GLX 1.3 */

+   GLint maxPbufferWidth;

+   GLint maxPbufferHeight;

+   GLint maxPbufferPixels;

+   GLint optimalPbufferWidth;   /* Only for SGIX_pbuffer. */

+   GLint optimalPbufferHeight;  /* Only for SGIX_pbuffer. */

+

+   /* OML_swap_method */

+   GLint swapMethod;

+

+   /* EXT_texture_from_pixmap */

+   GLint bindToTextureRgb;

+   GLint bindToTextureRgba;

+   GLint bindToMipmapTexture;

+   GLint bindToTextureTargets;

+   GLint yInverted;

+

+   /* EXT_framebuffer_sRGB */

+   GLint sRGBCapable;

+};

+

+

+/**

+ * Data structure for color tables

+ */

+struct gl_color_table

+{

+   GLenum InternalFormat;      /**< The user-specified format */

+   GLenum _BaseFormat;         /**< GL_ALPHA, GL_RGBA, GL_RGB, etc */

+   GLuint Size;                /**< number of entries in table */

+   GLfloat *TableF;            /**< Color table, floating point values */

+   GLubyte *TableUB;           /**< Color table, ubyte values */

+   GLubyte RedSize;

+   GLubyte GreenSize;

+   GLubyte BlueSize;

+   GLubyte AlphaSize;

+   GLubyte LuminanceSize;

+   GLubyte IntensitySize;

+};

+

+

+/**

+ * \name Bit flags used for updating material values.

+ */

+/*@{*/

+#define MAT_ATTRIB_FRONT_AMBIENT           0 

+#define MAT_ATTRIB_BACK_AMBIENT            1

+#define MAT_ATTRIB_FRONT_DIFFUSE           2 

+#define MAT_ATTRIB_BACK_DIFFUSE            3

+#define MAT_ATTRIB_FRONT_SPECULAR          4 

+#define MAT_ATTRIB_BACK_SPECULAR           5

+#define MAT_ATTRIB_FRONT_EMISSION          6

+#define MAT_ATTRIB_BACK_EMISSION           7

+#define MAT_ATTRIB_FRONT_SHININESS         8

+#define MAT_ATTRIB_BACK_SHININESS          9

+#define MAT_ATTRIB_FRONT_INDEXES           10

+#define MAT_ATTRIB_BACK_INDEXES            11

+#define MAT_ATTRIB_MAX                     12

+

+#define MAT_ATTRIB_AMBIENT(f)  (MAT_ATTRIB_FRONT_AMBIENT+(f))  

+#define MAT_ATTRIB_DIFFUSE(f)  (MAT_ATTRIB_FRONT_DIFFUSE+(f))  

+#define MAT_ATTRIB_SPECULAR(f) (MAT_ATTRIB_FRONT_SPECULAR+(f)) 

+#define MAT_ATTRIB_EMISSION(f) (MAT_ATTRIB_FRONT_EMISSION+(f)) 

+#define MAT_ATTRIB_SHININESS(f)(MAT_ATTRIB_FRONT_SHININESS+(f))

+#define MAT_ATTRIB_INDEXES(f)  (MAT_ATTRIB_FRONT_INDEXES+(f))  

+

+#define MAT_INDEX_AMBIENT  0

+#define MAT_INDEX_DIFFUSE  1

+#define MAT_INDEX_SPECULAR 2

+

+#define MAT_BIT_FRONT_AMBIENT         (1<<MAT_ATTRIB_FRONT_AMBIENT)

+#define MAT_BIT_BACK_AMBIENT          (1<<MAT_ATTRIB_BACK_AMBIENT)

+#define MAT_BIT_FRONT_DIFFUSE         (1<<MAT_ATTRIB_FRONT_DIFFUSE)

+#define MAT_BIT_BACK_DIFFUSE          (1<<MAT_ATTRIB_BACK_DIFFUSE)

+#define MAT_BIT_FRONT_SPECULAR        (1<<MAT_ATTRIB_FRONT_SPECULAR)

+#define MAT_BIT_BACK_SPECULAR         (1<<MAT_ATTRIB_BACK_SPECULAR)

+#define MAT_BIT_FRONT_EMISSION        (1<<MAT_ATTRIB_FRONT_EMISSION)

+#define MAT_BIT_BACK_EMISSION         (1<<MAT_ATTRIB_BACK_EMISSION)

+#define MAT_BIT_FRONT_SHININESS       (1<<MAT_ATTRIB_FRONT_SHININESS)

+#define MAT_BIT_BACK_SHININESS        (1<<MAT_ATTRIB_BACK_SHININESS)

+#define MAT_BIT_FRONT_INDEXES         (1<<MAT_ATTRIB_FRONT_INDEXES)

+#define MAT_BIT_BACK_INDEXES          (1<<MAT_ATTRIB_BACK_INDEXES)

+

+

+#define FRONT_MATERIAL_BITS	(MAT_BIT_FRONT_EMISSION | 	\

+				 MAT_BIT_FRONT_AMBIENT |	\

+				 MAT_BIT_FRONT_DIFFUSE | 	\

+				 MAT_BIT_FRONT_SPECULAR |	\

+				 MAT_BIT_FRONT_SHININESS | 	\

+				 MAT_BIT_FRONT_INDEXES)

+

+#define BACK_MATERIAL_BITS	(MAT_BIT_BACK_EMISSION |	\

+				 MAT_BIT_BACK_AMBIENT |		\

+				 MAT_BIT_BACK_DIFFUSE |		\

+				 MAT_BIT_BACK_SPECULAR |	\

+				 MAT_BIT_BACK_SHININESS |	\

+				 MAT_BIT_BACK_INDEXES)

+

+#define ALL_MATERIAL_BITS	(FRONT_MATERIAL_BITS | BACK_MATERIAL_BITS)

+/*@}*/

+

+

+#define EXP_TABLE_SIZE 512	/**< Specular exponent lookup table sizes */

+#define SHINE_TABLE_SIZE 256	/**< Material shininess lookup table sizes */

+

+/**

+ * Material shininess lookup table.

+ */

+struct gl_shine_tab

+{

+   struct gl_shine_tab *next, *prev;

+   GLfloat tab[SHINE_TABLE_SIZE+1];

+   GLfloat shininess;

+   GLuint refcount;

+};

+

+

+/**

+ * Light source state.

+ */

+struct gl_light

+{

+   struct gl_light *next;	/**< double linked list with sentinel */

+   struct gl_light *prev;

+

+   GLfloat Ambient[4];		/**< ambient color */

+   GLfloat Diffuse[4];		/**< diffuse color */

+   GLfloat Specular[4];		/**< specular color */

+   GLfloat EyePosition[4];	/**< position in eye coordinates */

+   GLfloat SpotDirection[4];	/**< spotlight direction in eye coordinates */

+   GLfloat SpotExponent;

+   GLfloat SpotCutoff;		/**< in degrees */

+   GLfloat _CosCutoffNeg;	/**< = cos(SpotCutoff) */

+   GLfloat _CosCutoff;		/**< = MAX(0, cos(SpotCutoff)) */

+   GLfloat ConstantAttenuation;

+   GLfloat LinearAttenuation;

+   GLfloat QuadraticAttenuation;

+   GLboolean Enabled;		/**< On/off flag */

+

+   /** 

+    * \name Derived fields

+    */

+   /*@{*/

+   GLbitfield _Flags;		/**< State */

+

+   GLfloat _Position[4];	/**< position in eye/obj coordinates */

+   GLfloat _VP_inf_norm[3];	/**< Norm direction to infinite light */

+   GLfloat _h_inf_norm[3];	/**< Norm( _VP_inf_norm + <0,0,1> ) */

+   GLfloat _NormSpotDirection[4]; /**< normalized spotlight direction */

+   GLfloat _VP_inf_spot_attenuation;

+

+   GLfloat _SpotExpTable[EXP_TABLE_SIZE][2];  /**< to replace a pow() call */

+   GLfloat _MatAmbient[2][3];	/**< material ambient * light ambient */

+   GLfloat _MatDiffuse[2][3];	/**< material diffuse * light diffuse */

+   GLfloat _MatSpecular[2][3];	/**< material spec * light specular */

+   GLfloat _dli;		/**< CI diffuse light intensity */

+   GLfloat _sli;		/**< CI specular light intensity */

+   /*@}*/

+};

+

+

+/**

+ * Light model state.

+ */

+struct gl_lightmodel

+{

+   GLfloat Ambient[4];		/**< ambient color */

+   GLboolean LocalViewer;	/**< Local (or infinite) view point? */

+   GLboolean TwoSide;		/**< Two (or one) sided lighting? */

+   GLenum ColorControl;		/**< either GL_SINGLE_COLOR

+				 *    or GL_SEPARATE_SPECULAR_COLOR */

+};

+

+

+/**

+ * Material state.

+ */

+struct gl_material

+{

+   GLfloat Attrib[MAT_ATTRIB_MAX][4];

+};

+

+

+/**

+ * Accumulation buffer attribute group (GL_ACCUM_BUFFER_BIT)

+ */

+struct gl_accum_attrib

+{

+   GLfloat ClearColor[4];	/**< Accumulation buffer clear color */

+};

+

+

+/**

+ * Color buffer attribute group (GL_COLOR_BUFFER_BIT).

+ */

+struct gl_colorbuffer_attrib

+{

+   GLuint ClearIndex;			/**< Index to use for glClear */

+   GLclampf ClearColor[4];		/**< Color to use for glClear */

+

+   GLuint IndexMask;			/**< Color index write mask */

+   GLubyte ColorMask[MAX_DRAW_BUFFERS][4];/**< Each flag is 0xff or 0x0 */

+

+   GLenum DrawBuffer[MAX_DRAW_BUFFERS];	/**< Which buffer to draw into */

+

+   /** 

+    * \name alpha testing

+    */

+   /*@{*/

+   GLboolean AlphaEnabled;		/**< Alpha test enabled flag */

+   GLenum AlphaFunc;			/**< Alpha test function */

+   GLclampf AlphaRef;			/**< Alpha reference value */

+   /*@}*/

+

+   /** 

+    * \name Blending

+    */

+   /*@{*/

+   GLbitfield BlendEnabled;		/**< Per-buffer blend enable flags */

+   GLfloat BlendColor[4];		/**< Blending color */

+   struct

+   {

+      GLenum SrcRGB;             /**< RGB blend source term */

+      GLenum DstRGB;             /**< RGB blend dest term */

+      GLenum SrcA;               /**< Alpha blend source term */

+      GLenum DstA;               /**< Alpha blend dest term */

+      GLenum EquationRGB;        /**< GL_ADD, GL_SUBTRACT, etc. */

+      GLenum EquationA;          /**< GL_ADD, GL_SUBTRACT, etc. */

+   } Blend[MAX_DRAW_BUFFERS];

+   /** Are the blend func terms currently different for each buffer/target? */

+   GLboolean _BlendFuncPerBuffer;

+   /** Are the blend equations currently different for each buffer/target? */

+   GLboolean _BlendEquationPerBuffer;

+   /*@}*/

+

+   /** 

+    * \name Logic op

+    */

+   /*@{*/

+   GLenum LogicOp;			/**< Logic operator */

+   GLboolean IndexLogicOpEnabled;	/**< Color index logic op enabled flag */

+   GLboolean ColorLogicOpEnabled;	/**< RGBA logic op enabled flag */

+   GLboolean _LogicOpEnabled;		/**< RGBA logic op + EXT_blend_logic_op enabled flag */

+   /*@}*/

+

+   GLboolean DitherFlag;		/**< Dither enable flag */

+

+   GLenum ClampFragmentColor; /**< GL_TRUE, GL_FALSE or GL_FIXED_ONLY_ARB */

+   GLenum ClampReadColor;     /**< GL_TRUE, GL_FALSE or GL_FIXED_ONLY_ARB */

+

+   GLboolean sRGBEnabled;	/**< Framebuffer sRGB blending/updating requested */

+};

+

+

+/**

+ * Current attribute group (GL_CURRENT_BIT).

+ */

+struct gl_current_attrib

+{

+   /**

+    * \name Current vertex attributes.

+    * \note Values are valid only after FLUSH_VERTICES has been called.

+    * \note Index and Edgeflag current values are stored as floats in the 

+    * SIX and SEVEN attribute slots.

+    */

+   GLfloat Attrib[VERT_ATTRIB_MAX][4];	/**< Position, color, texcoords, etc */

+

+   /**

+    * \name Current raster position attributes (always valid).

+    * \note This set of attributes is very similar to the SWvertex struct.

+    */

+   /*@{*/

+   GLfloat RasterPos[4];

+   GLfloat RasterDistance;

+   GLfloat RasterColor[4];

+   GLfloat RasterSecondaryColor[4];

+   GLfloat RasterTexCoords[MAX_TEXTURE_COORD_UNITS][4];

+   GLboolean RasterPosValid;

+   /*@}*/

+};

+

+

+/**

+ * Depth buffer attribute group (GL_DEPTH_BUFFER_BIT).

+ */

+struct gl_depthbuffer_attrib

+{

+   GLenum Func;			/**< Function for depth buffer compare */

+   GLclampd Clear;		/**< Value to clear depth buffer to */

+   GLboolean Test;		/**< Depth buffering enabled flag */

+   GLboolean Mask;		/**< Depth buffer writable? */

+   GLboolean BoundsTest;        /**< GL_EXT_depth_bounds_test */

+   GLfloat BoundsMin, BoundsMax;/**< GL_EXT_depth_bounds_test */

+};

+

+

+/**

+ * Evaluator attribute group (GL_EVAL_BIT).

+ */

+struct gl_eval_attrib

+{

+   /**

+    * \name Enable bits 

+    */

+   /*@{*/

+   GLboolean Map1Color4;

+   GLboolean Map1Index;

+   GLboolean Map1Normal;

+   GLboolean Map1TextureCoord1;

+   GLboolean Map1TextureCoord2;

+   GLboolean Map1TextureCoord3;

+   GLboolean Map1TextureCoord4;

+   GLboolean Map1Vertex3;

+   GLboolean Map1Vertex4;

+   GLboolean Map1Attrib[16];  /* GL_NV_vertex_program */

+   GLboolean Map2Color4;

+   GLboolean Map2Index;

+   GLboolean Map2Normal;

+   GLboolean Map2TextureCoord1;

+   GLboolean Map2TextureCoord2;

+   GLboolean Map2TextureCoord3;

+   GLboolean Map2TextureCoord4;

+   GLboolean Map2Vertex3;

+   GLboolean Map2Vertex4;

+   GLboolean Map2Attrib[16];  /* GL_NV_vertex_program */

+   GLboolean AutoNormal;

+   /*@}*/

+   

+   /**

+    * \name Map Grid endpoints and divisions and calculated du values

+    */

+   /*@{*/

+   GLint MapGrid1un;

+   GLfloat MapGrid1u1, MapGrid1u2, MapGrid1du;

+   GLint MapGrid2un, MapGrid2vn;

+   GLfloat MapGrid2u1, MapGrid2u2, MapGrid2du;

+   GLfloat MapGrid2v1, MapGrid2v2, MapGrid2dv;

+   /*@}*/

+};

+

+

+/**

+ * Fog attribute group (GL_FOG_BIT).

+ */

+struct gl_fog_attrib

+{

+   GLboolean Enabled;		/**< Fog enabled flag */

+   GLfloat Color[4];		/**< Fog color */

+   GLfloat Density;		/**< Density >= 0.0 */

+   GLfloat Start;		/**< Start distance in eye coords */

+   GLfloat End;			/**< End distance in eye coords */

+   GLfloat Index;		/**< Fog index */

+   GLenum Mode;			/**< Fog mode */

+   GLboolean ColorSumEnabled;

+   GLenum FogCoordinateSource;  /**< GL_EXT_fog_coord */

+   GLfloat _Scale;		/**< (End == Start) ? 1.0 : 1.0 / (End - Start) */

+};

+

+

+/**

+ * \brief Layout qualifiers for gl_FragDepth.

+ *

+ * Extension AMD_conservative_depth allows gl_FragDepth to be redeclared with

+ * a layout qualifier.

+ *

+ * \see enum ir_depth_layout

+ */

+enum gl_frag_depth_layout {

+    FRAG_DEPTH_LAYOUT_NONE, /**< No layout is specified. */

+    FRAG_DEPTH_LAYOUT_ANY,

+    FRAG_DEPTH_LAYOUT_GREATER,

+    FRAG_DEPTH_LAYOUT_LESS,

+    FRAG_DEPTH_LAYOUT_UNCHANGED

+};

+

+

+/** 

+ * Hint attribute group (GL_HINT_BIT).

+ * 

+ * Values are always one of GL_FASTEST, GL_NICEST, or GL_DONT_CARE.

+ */

+struct gl_hint_attrib

+{

+   GLenum PerspectiveCorrection;

+   GLenum PointSmooth;

+   GLenum LineSmooth;

+   GLenum PolygonSmooth;

+   GLenum Fog;

+   GLenum ClipVolumeClipping;   /**< GL_EXT_clip_volume_hint */

+   GLenum TextureCompression;   /**< GL_ARB_texture_compression */

+   GLenum GenerateMipmap;       /**< GL_SGIS_generate_mipmap */

+   GLenum FragmentShaderDerivative; /**< GL_ARB_fragment_shader */

+};

+

+/**

+ * Light state flags.

+ */

+/*@{*/

+#define LIGHT_SPOT         0x1

+#define LIGHT_LOCAL_VIEWER 0x2

+#define LIGHT_POSITIONAL   0x4

+#define LIGHT_NEED_VERTICES (LIGHT_POSITIONAL|LIGHT_LOCAL_VIEWER)

+/*@}*/

+

+

+/**

+ * Lighting attribute group (GL_LIGHT_BIT).

+ */

+struct gl_light_attrib

+{

+   struct gl_light Light[MAX_LIGHTS];	/**< Array of light sources */

+   struct gl_lightmodel Model;		/**< Lighting model */

+

+   /**

+    * Must flush FLUSH_VERTICES before referencing:

+    */

+   /*@{*/

+   struct gl_material Material; 	/**< Includes front & back values */

+   /*@}*/

+

+   GLboolean Enabled;			/**< Lighting enabled flag */

+   GLenum ShadeModel;			/**< GL_FLAT or GL_SMOOTH */

+   GLenum ProvokingVertex;              /**< GL_EXT_provoking_vertex */

+   GLenum ColorMaterialFace;		/**< GL_FRONT, BACK or FRONT_AND_BACK */

+   GLenum ColorMaterialMode;		/**< GL_AMBIENT, GL_DIFFUSE, etc */

+   GLbitfield ColorMaterialBitmask;	/**< bitmask formed from Face and Mode */

+   GLboolean ColorMaterialEnabled;

+   GLenum ClampVertexColor;

+

+   struct gl_light EnabledList;         /**< List sentinel */

+

+   /** 

+    * Derived state for optimizations: 

+    */

+   /*@{*/

+   GLboolean _NeedEyeCoords;		

+   GLboolean _NeedVertices;		/**< Use fast shader? */

+   GLbitfield _Flags;		        /**< LIGHT_* flags, see above */

+   GLfloat _BaseColor[2][3];

+   /*@}*/

+};

+

+

+/**

+ * Line attribute group (GL_LINE_BIT).

+ */

+struct gl_line_attrib

+{

+   GLboolean SmoothFlag;	/**< GL_LINE_SMOOTH enabled? */

+   GLboolean StippleFlag;	/**< GL_LINE_STIPPLE enabled? */

+   GLushort StipplePattern;	/**< Stipple pattern */

+   GLint StippleFactor;		/**< Stipple repeat factor */

+   GLfloat Width;		/**< Line width */

+};

+

+

+/**

+ * Display list attribute group (GL_LIST_BIT).

+ */

+struct gl_list_attrib

+{

+   GLuint ListBase;

+};

+

+

+/**

+ * Multisample attribute group (GL_MULTISAMPLE_BIT).

+ */

+struct gl_multisample_attrib

+{

+   GLboolean Enabled;

+   GLboolean _Enabled;   /**< true if Enabled and multisample buffer */

+   GLboolean SampleAlphaToCoverage;

+   GLboolean SampleAlphaToOne;

+   GLboolean SampleCoverage;

+   GLfloat SampleCoverageValue;

+   GLboolean SampleCoverageInvert;

+};

+

+

+/**

+ * A pixelmap (see glPixelMap)

+ */

+struct gl_pixelmap

+{

+   GLint Size;

+   GLfloat Map[MAX_PIXEL_MAP_TABLE];

+   GLubyte Map8[MAX_PIXEL_MAP_TABLE];  /**< converted to 8-bit color */

+};

+

+

+/**

+ * Collection of all pixelmaps

+ */

+struct gl_pixelmaps

+{

+   struct gl_pixelmap RtoR;  /**< i.e. GL_PIXEL_MAP_R_TO_R */

+   struct gl_pixelmap GtoG;

+   struct gl_pixelmap BtoB;

+   struct gl_pixelmap AtoA;

+   struct gl_pixelmap ItoR;

+   struct gl_pixelmap ItoG;

+   struct gl_pixelmap ItoB;

+   struct gl_pixelmap ItoA;

+   struct gl_pixelmap ItoI;

+   struct gl_pixelmap StoS;

+};

+

+

+/**

+ * Pixel attribute group (GL_PIXEL_MODE_BIT).

+ */

+struct gl_pixel_attrib

+{

+   GLenum ReadBuffer;		/**< source buffer for glRead/CopyPixels() */

+

+   /*--- Begin Pixel Transfer State ---*/

+   /* Fields are in the order in which they're applied... */

+

+   /** Scale & Bias (index shift, offset) */

+   /*@{*/

+   GLfloat RedBias, RedScale;

+   GLfloat GreenBias, GreenScale;

+   GLfloat BlueBias, BlueScale;

+   GLfloat AlphaBias, AlphaScale;

+   GLfloat DepthBias, DepthScale;

+   GLint IndexShift, IndexOffset;

+   /*@}*/

+

+   /* Pixel Maps */

+   /* Note: actual pixel maps are not part of this attrib group */

+   GLboolean MapColorFlag;

+   GLboolean MapStencilFlag;

+

+   /*--- End Pixel Transfer State ---*/

+

+   /** glPixelZoom */

+   GLfloat ZoomX, ZoomY;

+};

+

+

+/**

+ * Point attribute group (GL_POINT_BIT).

+ */

+struct gl_point_attrib

+{

+   GLboolean SmoothFlag;	/**< True if GL_POINT_SMOOTH is enabled */

+   GLfloat Size;		/**< User-specified point size */

+   GLfloat Params[3];		/**< GL_EXT_point_parameters */

+   GLfloat MinSize, MaxSize;	/**< GL_EXT_point_parameters */

+   GLfloat Threshold;		/**< GL_EXT_point_parameters */

+   GLboolean _Attenuated;	/**< True if Params != [1, 0, 0] */

+   GLboolean PointSprite;	/**< GL_NV/ARB_point_sprite */

+   GLboolean CoordReplace[MAX_TEXTURE_COORD_UNITS]; /**< GL_ARB_point_sprite*/

+   GLenum SpriteRMode;		/**< GL_NV_point_sprite (only!) */

+   GLenum SpriteOrigin;		/**< GL_ARB_point_sprite */

+};

+

+

+/**

+ * Polygon attribute group (GL_POLYGON_BIT).

+ */

+struct gl_polygon_attrib

+{

+   GLenum FrontFace;		/**< Either GL_CW or GL_CCW */

+   GLenum FrontMode;		/**< Either GL_POINT, GL_LINE or GL_FILL */

+   GLenum BackMode;		/**< Either GL_POINT, GL_LINE or GL_FILL */

+   GLboolean _FrontBit;		/**< 0=GL_CCW, 1=GL_CW */

+   GLboolean CullFlag;		/**< Culling on/off flag */

+   GLboolean SmoothFlag;	/**< True if GL_POLYGON_SMOOTH is enabled */

+   GLboolean StippleFlag;	/**< True if GL_POLYGON_STIPPLE is enabled */

+   GLenum CullFaceMode;		/**< Culling mode GL_FRONT or GL_BACK */

+   GLfloat OffsetFactor;	/**< Polygon offset factor, from user */

+   GLfloat OffsetUnits;		/**< Polygon offset units, from user */

+   GLboolean OffsetPoint;	/**< Offset in GL_POINT mode */

+   GLboolean OffsetLine;	/**< Offset in GL_LINE mode */

+   GLboolean OffsetFill;	/**< Offset in GL_FILL mode */

+};

+

+

+/**

+ * Scissor attributes (GL_SCISSOR_BIT).

+ */

+struct gl_scissor_attrib

+{

+   GLboolean Enabled;		/**< Scissor test enabled? */

+   GLint X, Y;			/**< Lower left corner of box */

+   GLsizei Width, Height;	/**< Size of box */

+};

+

+

+/**

+ * Stencil attribute group (GL_STENCIL_BUFFER_BIT).

+ *

+ * Three sets of stencil data are tracked so that OpenGL 2.0,

+ * GL_EXT_stencil_two_side, and GL_ATI_separate_stencil can all be supported

+ * simultaneously.  In each of the stencil state arrays, element 0 corresponds

+ * to GL_FRONT.  Element 1 corresponds to the OpenGL 2.0 /

+ * GL_ATI_separate_stencil GL_BACK state.  Element 2 corresponds to the

+ * GL_EXT_stencil_two_side GL_BACK state.

+ *

+ * The derived value \c _BackFace is either 1 or 2 depending on whether or

+ * not GL_STENCIL_TEST_TWO_SIDE_EXT is enabled.

+ *

+ * The derived value \c _TestTwoSide is set when the front-face and back-face

+ * stencil state are different.

+ */

+struct gl_stencil_attrib

+{

+   GLboolean Enabled;		/**< Enabled flag */

+   GLboolean TestTwoSide;	/**< GL_EXT_stencil_two_side */

+   GLubyte ActiveFace;		/**< GL_EXT_stencil_two_side (0 or 2) */

+   GLboolean _Enabled;          /**< Enabled and stencil buffer present */

+   GLboolean _TestTwoSide;

+   GLubyte _BackFace;           /**< Current back stencil state (1 or 2) */

+   GLenum Function[3];		/**< Stencil function */

+   GLenum FailFunc[3];		/**< Fail function */

+   GLenum ZPassFunc[3];		/**< Depth buffer pass function */

+   GLenum ZFailFunc[3];		/**< Depth buffer fail function */

+   GLint Ref[3];		/**< Reference value */

+   GLuint ValueMask[3];		/**< Value mask */

+   GLuint WriteMask[3];		/**< Write mask */

+   GLuint Clear;		/**< Clear value */

+};

+

+

+/**

+ * An index for each type of texture object.  These correspond to the GL

+ * texture target enums, such as GL_TEXTURE_2D, GL_TEXTURE_CUBE_MAP, etc.

+ * Note: the order is from highest priority to lowest priority.

+ */

+typedef enum

+{

+   TEXTURE_2D_ARRAY_INDEX,

+   TEXTURE_1D_ARRAY_INDEX,

+   TEXTURE_CUBE_INDEX,

+   TEXTURE_3D_INDEX,

+   TEXTURE_RECT_INDEX,

+   TEXTURE_2D_INDEX,

+   TEXTURE_1D_INDEX,

+   NUM_TEXTURE_TARGETS

+} gl_texture_index;

+

+

+/**

+ * Bit flags for each type of texture object

+ * Used for Texture.Unit[]._ReallyEnabled flags.

+ */

+/*@{*/

+#define TEXTURE_2D_ARRAY_BIT (1 << TEXTURE_2D_ARRAY_INDEX)

+#define TEXTURE_1D_ARRAY_BIT (1 << TEXTURE_1D_ARRAY_INDEX)

+#define TEXTURE_CUBE_BIT     (1 << TEXTURE_CUBE_INDEX)

+#define TEXTURE_3D_BIT       (1 << TEXTURE_3D_INDEX)

+#define TEXTURE_RECT_BIT     (1 << TEXTURE_RECT_INDEX)

+#define TEXTURE_2D_BIT       (1 << TEXTURE_2D_INDEX)

+#define TEXTURE_1D_BIT       (1 << TEXTURE_1D_INDEX)

+/*@}*/

+

+

+/**

+ * TexGenEnabled flags.

+ */

+/*@{*/

+#define S_BIT 1

+#define T_BIT 2

+#define R_BIT 4

+#define Q_BIT 8

+#define STR_BITS (S_BIT | T_BIT | R_BIT)

+/*@}*/

+

+

+/**

+ * Bit flag versions of the corresponding GL_ constants.

+ */

+/*@{*/

+#define TEXGEN_SPHERE_MAP        0x1

+#define TEXGEN_OBJ_LINEAR        0x2

+#define TEXGEN_EYE_LINEAR        0x4

+#define TEXGEN_REFLECTION_MAP_NV 0x8

+#define TEXGEN_NORMAL_MAP_NV     0x10

+

+#define TEXGEN_NEED_NORMALS      (TEXGEN_SPHERE_MAP        | \

+				  TEXGEN_REFLECTION_MAP_NV | \

+				  TEXGEN_NORMAL_MAP_NV)

+#define TEXGEN_NEED_EYE_COORD    (TEXGEN_SPHERE_MAP        | \

+				  TEXGEN_REFLECTION_MAP_NV | \

+				  TEXGEN_NORMAL_MAP_NV     | \

+				  TEXGEN_EYE_LINEAR)

+/*@}*/

+

+

+

+/** Tex-gen enabled for texture unit? */

+#define ENABLE_TEXGEN(unit) (1 << (unit))

+

+/** Non-identity texture matrix for texture unit? */

+#define ENABLE_TEXMAT(unit) (1 << (unit))

+

+

+/**

+ * Texel fetch function prototype.  We use texel fetch functions to

+ * extract RGBA, color indexes and depth components out of 1D, 2D and 3D

+ * texture images.  These functions help to isolate us from the gritty

+ * details of all the various texture image encodings.

+ * 

+ * \param texImage texture image.

+ * \param col texel column.

+ * \param row texel row.

+ * \param img texel image level/layer.

+ * \param texelOut output texel (up to 4 GLchans)

+ */

+typedef void (*FetchTexelFuncC)( const struct gl_texture_image *texImage,

+                                 GLint col, GLint row, GLint img,

+                                 GLchan *texelOut );

+

+/**

+ * As above, but returns floats.

+ * Used for depth component images and for upcoming signed/float

+ * texture images.

+ */

+typedef void (*FetchTexelFuncF)( const struct gl_texture_image *texImage,

+                                 GLint col, GLint row, GLint img,

+                                 GLfloat *texelOut );

+

+

+typedef void (*StoreTexelFunc)(struct gl_texture_image *texImage,

+                               GLint col, GLint row, GLint img,

+                               const void *texel);

+

+

+/**

+ * Texture image state.  Describes the dimensions of a texture image,

+ * the texel format and pointers to Texel Fetch functions.

+ */

+struct gl_texture_image

+{

+   GLint InternalFormat;	/**< Internal format as given by the user */

+   GLenum _BaseFormat;		/**< Either GL_RGB, GL_RGBA, GL_ALPHA,

+				 *   GL_LUMINANCE, GL_LUMINANCE_ALPHA,

+				 *   GL_INTENSITY, GL_COLOR_INDEX,

+				 *   GL_DEPTH_COMPONENT or GL_DEPTH_STENCIL_EXT

+                                 *   only. Used for choosing TexEnv arithmetic.

+				 */

+   gl_format TexFormat;         /**< The actual texture memory format */

+

+   GLuint Border;		/**< 0 or 1 */

+   GLuint Width;		/**< = 2^WidthLog2 + 2*Border */

+   GLuint Height;		/**< = 2^HeightLog2 + 2*Border */

+   GLuint Depth;		/**< = 2^DepthLog2 + 2*Border */

+   GLuint Width2;		/**< = Width - 2*Border */

+   GLuint Height2;		/**< = Height - 2*Border */

+   GLuint Depth2;		/**< = Depth - 2*Border */

+   GLuint WidthLog2;		/**< = log2(Width2) */

+   GLuint HeightLog2;		/**< = log2(Height2) */

+   GLuint DepthLog2;		/**< = log2(Depth2) */

+   GLuint MaxLog2;		/**< = MAX(WidthLog2, HeightLog2) */

+   GLfloat WidthScale;		/**< used for mipmap LOD computation */

+   GLfloat HeightScale;		/**< used for mipmap LOD computation */

+   GLfloat DepthScale;		/**< used for mipmap LOD computation */

+   GLboolean IsClientData;	/**< Data owned by client? */

+   GLboolean _IsPowerOfTwo;	/**< Are all dimensions powers of two? */

+

+   struct gl_texture_object *TexObject;  /**< Pointer back to parent object */

+

+   FetchTexelFuncC FetchTexelc;	/**< GLchan texel fetch function pointer */

+   FetchTexelFuncF FetchTexelf;	/**< Float texel fetch function pointer */

+

+   GLuint RowStride;		/**< Padded width in units of texels */

+   GLuint *ImageOffsets;        /**< if 3D texture: array [Depth] of offsets to

+                                     each 2D slice in 'Data', in texels */

+   GLvoid *Data;		/**< Image data, accessed via FetchTexel() */

+

+   /**

+    * \name For device driver:

+    */

+   /*@{*/

+   void *DriverData;		/**< Arbitrary device driver data */

+   /*@}*/

+};

+

+

+/**

+ * Indexes for cube map faces.

+ */

+typedef enum

+{

+   FACE_POS_X = 0,

+   FACE_NEG_X = 1,

+   FACE_POS_Y = 2,

+   FACE_NEG_Y = 3,

+   FACE_POS_Z = 4,

+   FACE_NEG_Z = 5,

+   MAX_FACES = 6

+} gl_face_index;

+

+

+/**

+ * Texture object state.  Contains the array of mipmap images, border color,

+ * wrap modes, filter modes, shadow/texcompare state, and the per-texture

+ * color palette.

+ */

+struct gl_texture_object

+{

+   _glthread_Mutex Mutex;	/**< for thread safety */

+   GLint RefCount;		/**< reference count */

+   GLuint Name;			/**< the user-visible texture object ID */

+   GLenum Target;               /**< GL_TEXTURE_1D, GL_TEXTURE_2D, etc. */

+   GLfloat Priority;		/**< in [0,1] */

+   union {

+      GLfloat f[4];

+      GLuint ui[4];

+      GLint i[4];

+   } BorderColor;               /**< Interpreted according to texture format */

+   GLenum WrapS;		/**< S-axis texture image wrap mode */

+   GLenum WrapT;		/**< T-axis texture image wrap mode */

+   GLenum WrapR;		/**< R-axis texture image wrap mode */

+   GLenum MinFilter;		/**< minification filter */

+   GLenum MagFilter;		/**< magnification filter */

+   GLfloat MinLod;		/**< min lambda, OpenGL 1.2 */

+   GLfloat MaxLod;		/**< max lambda, OpenGL 1.2 */

+   GLfloat LodBias;		/**< OpenGL 1.4 */

+   GLint BaseLevel;		/**< min mipmap level, OpenGL 1.2 */

+   GLint MaxLevel;		/**< max mipmap level, OpenGL 1.2 */

+   GLfloat MaxAnisotropy;	/**< GL_EXT_texture_filter_anisotropic */

+   GLenum CompareMode;		/**< GL_ARB_shadow */

+   GLenum CompareFunc;		/**< GL_ARB_shadow */

+   GLfloat CompareFailValue;    /**< GL_ARB_shadow_ambient */

+   GLenum DepthMode;		/**< GL_ARB_depth_texture */

+   GLint _MaxLevel;		/**< actual max mipmap level (q in the spec) */

+   GLfloat _MaxLambda;		/**< = _MaxLevel - BaseLevel (q - b in spec) */

+   GLint CropRect[4];           /**< GL_OES_draw_texture */

+   GLenum Swizzle[4];           /**< GL_EXT_texture_swizzle */

+   GLuint _Swizzle;             /**< same as Swizzle, but SWIZZLE_* format */

+   GLboolean GenerateMipmap;    /**< GL_SGIS_generate_mipmap */

+   GLboolean _Complete;		/**< Is texture object complete? */

+   GLboolean _RenderToTexture;  /**< Any rendering to this texture? */

+   GLboolean Purgeable;         /**< Is the buffer purgeable under memory pressure? */

+   GLenum sRGBDecode;           /**< GL_DECODE_EXT or GL_SKIP_DECODE_EXT */

+

+   /** Actual texture images, indexed by [cube face] and [mipmap level] */

+   struct gl_texture_image *Image[MAX_FACES][MAX_TEXTURE_LEVELS];

+

+   /** GL_EXT_paletted_texture */

+   struct gl_color_table Palette;

+

+   /**

+    * \name For device driver.

+    * Note: instead of attaching driver data to this pointer, it's preferable

+    * to instead use this struct as a base class for your own texture object

+    * class.  Driver->NewTextureObject() can be used to implement the

+    * allocation.

+    */

+   void *DriverData;	/**< Arbitrary device driver data */

+};

+

+

+/** Up to four combiner sources are possible with GL_NV_texture_env_combine4 */

+#define MAX_COMBINER_TERMS 4

+

+

+/**

+ * Texture combine environment state.

+ */

+struct gl_tex_env_combine_state

+{

+   GLenum ModeRGB;       /**< GL_REPLACE, GL_DECAL, GL_ADD, etc. */

+   GLenum ModeA;         /**< GL_REPLACE, GL_DECAL, GL_ADD, etc. */

+   /** Source terms: GL_PRIMARY_COLOR, GL_TEXTURE, etc */

+   GLenum SourceRGB[MAX_COMBINER_TERMS];

+   GLenum SourceA[MAX_COMBINER_TERMS];

+   /** Source operands: GL_SRC_COLOR, GL_ONE_MINUS_SRC_COLOR, etc */

+   GLenum OperandRGB[MAX_COMBINER_TERMS];

+   GLenum OperandA[MAX_COMBINER_TERMS];

+   GLuint ScaleShiftRGB; /**< 0, 1 or 2 */

+   GLuint ScaleShiftA;   /**< 0, 1 or 2 */

+   GLuint _NumArgsRGB;   /**< Number of inputs used for the RGB combiner */

+   GLuint _NumArgsA;     /**< Number of inputs used for the A combiner */

+};

+

+

+/**

+ * Texture coord generation state.

+ */

+struct gl_texgen

+{

+   GLenum Mode;         /**< GL_EYE_LINEAR, GL_SPHERE_MAP, etc */

+   GLbitfield _ModeBit; /**< TEXGEN_x bit corresponding to Mode */

+   GLfloat ObjectPlane[4];

+   GLfloat EyePlane[4];

+};

+

+

+/**

+ * Texture unit state.  Contains enable flags, texture environment/function/

+ * combiners, texgen state, pointers to current texture objects and

+ * post-filter color tables.

+ */

+struct gl_texture_unit

+{

+   GLbitfield Enabled;          /**< bitmask of TEXTURE_*_BIT flags */

+   GLbitfield _ReallyEnabled;   /**< 0 or exactly one of TEXTURE_*_BIT flags */

+

+   GLenum EnvMode;              /**< GL_MODULATE, GL_DECAL, GL_BLEND, etc. */

+   GLfloat EnvColor[4];

+

+   struct gl_texgen GenS;

+   struct gl_texgen GenT;

+   struct gl_texgen GenR;

+   struct gl_texgen GenQ;

+   GLbitfield TexGenEnabled;	/**< Bitwise-OR of [STRQ]_BIT values */

+   GLbitfield _GenFlags;	/**< Bitwise-OR of Gen[STRQ]._ModeBit */

+

+   GLfloat LodBias;		/**< for biasing mipmap levels */

+   GLenum BumpTarget;

+   GLfloat RotMatrix[4]; /* 2x2 matrix */

+

+   /** 

+    * \name GL_EXT_texture_env_combine 

+    */

+   struct gl_tex_env_combine_state Combine;

+

+   /**

+    * Derived state based on \c EnvMode and the \c BaseFormat of the

+    * currently enabled texture.

+    */

+   struct gl_tex_env_combine_state _EnvMode;

+

+   /**

+    * Currently enabled combiner state.  This will point to either

+    * \c Combine or \c _EnvMode.

+    */

+   struct gl_tex_env_combine_state *_CurrentCombine;

+

+   /** Current texture object pointers */

+   struct gl_texture_object *CurrentTex[NUM_TEXTURE_TARGETS];

+

+   /** Points to highest priority, complete and enabled texture object */

+   struct gl_texture_object *_Current;

+};

+

+

+/**

+ * Texture attribute group (GL_TEXTURE_BIT).

+ */

+struct gl_texture_attrib

+{

+   GLuint CurrentUnit;   /**< GL_ACTIVE_TEXTURE */

+   struct gl_texture_unit Unit[MAX_COMBINED_TEXTURE_IMAGE_UNITS];

+

+   struct gl_texture_object *ProxyTex[NUM_TEXTURE_TARGETS];

+

+   /** GL_ARB_seamless_cubemap */

+   GLboolean CubeMapSeamless;

+

+   /** GL_EXT_shared_texture_palette */

+   GLboolean SharedPalette;

+   struct gl_color_table Palette;

+

+   /** Texture units/samplers used by vertex or fragment texturing */

+   GLbitfield _EnabledUnits;

+

+   /** Texture coord units/sets used for fragment texturing */

+   GLbitfield _EnabledCoordUnits;

+

+   /** Texture coord units that have texgen enabled */

+   GLbitfield _TexGenEnabled;

+

+   /** Texture coord units that have non-identity matrices */

+   GLbitfield _TexMatEnabled;

+

+   /** Bitwise-OR of all Texture.Unit[i]._GenFlags */

+   GLbitfield _GenFlags;

+};

+

+

+/**

+ * Transformation attribute group (GL_TRANSFORM_BIT).

+ */

+struct gl_transform_attrib

+{

+   GLenum MatrixMode;				/**< Matrix mode */

+   GLfloat EyeUserPlane[MAX_CLIP_PLANES][4];	/**< User clip planes */

+   GLfloat _ClipUserPlane[MAX_CLIP_PLANES][4];	/**< derived */

+   GLbitfield ClipPlanesEnabled;                /**< on/off bitmask */

+   GLboolean Normalize;				/**< Normalize all normals? */

+   GLboolean RescaleNormals;			/**< GL_EXT_rescale_normal */

+   GLboolean RasterPositionUnclipped;           /**< GL_IBM_rasterpos_clip */

+   GLboolean DepthClamp;			/**< GL_ARB_depth_clamp */

+

+   GLfloat CullEyePos[4];

+   GLfloat CullObjPos[4];

+};

+

+

+/**

+ * Viewport attribute group (GL_VIEWPORT_BIT).

+ */

+struct gl_viewport_attrib

+{

+   GLint X, Y;			/**< position */

+   GLsizei Width, Height;	/**< size */

+   GLfloat Near, Far;		/**< Depth buffer range */

+   GLmatrix _WindowMap;		/**< Mapping transformation as a matrix. */

+};

+

+

+/**

+ * GL_ARB_vertex/pixel_buffer_object buffer object

+ */

+struct gl_buffer_object

+{

+   _glthread_Mutex Mutex;

+   GLint RefCount;

+   GLuint Name;

+   GLenum Usage;        /**< GL_STREAM_DRAW_ARB, GL_STREAM_READ_ARB, etc. */

+   GLsizeiptrARB Size;  /**< Size of buffer storage in bytes */

+   GLubyte *Data;       /**< Location of storage either in RAM or VRAM. */

+   /** Fields describing a mapped buffer */

+   /*@{*/

+   GLbitfield AccessFlags; /**< Mask of GL_MAP_x_BIT flags */

+   GLvoid *Pointer;     /**< User-space address of mapping */

+   GLintptr Offset;     /**< Mapped offset */

+   GLsizeiptr Length;   /**< Mapped length */

+   /*@}*/

+   GLboolean Written;   /**< Ever written to? (for debugging) */

+   GLboolean Purgeable; /**< Is the buffer purgeable under memory pressure? */

+};

+

+

+/**

+ * Client pixel packing/unpacking attributes

+ */

+struct gl_pixelstore_attrib

+{

+   GLint Alignment;

+   GLint RowLength;

+   GLint SkipPixels;

+   GLint SkipRows;

+   GLint ImageHeight;

+   GLint SkipImages;

+   GLboolean SwapBytes;

+   GLboolean LsbFirst;

+   GLboolean ClientStorage; /**< GL_APPLE_client_storage */

+   GLboolean Invert;        /**< GL_MESA_pack_invert */

+   struct gl_buffer_object *BufferObj; /**< GL_ARB_pixel_buffer_object */

+};

+

+

+/**

+ * Client vertex array attributes

+ */

+struct gl_client_array

+{

+   GLint Size;                  /**< components per element (1,2,3,4) */

+   GLenum Type;                 /**< datatype: GL_FLOAT, GL_INT, etc */

+   GLenum Format;               /**< default: GL_RGBA, but may be GL_BGRA */

+   GLsizei Stride;		/**< user-specified stride */

+   GLsizei StrideB;		/**< actual stride in bytes */

+   const GLubyte *Ptr;          /**< Points to array data */

+   GLboolean Enabled;		/**< Enabled flag is a boolean */

+   GLboolean Normalized;        /**< GL_ARB_vertex_program */

+   GLboolean Integer;           /**< Integer-valued? */

+   GLuint InstanceDivisor;      /**< GL_ARB_instanced_arrays */

+   GLuint _ElementSize;         /**< size of each element in bytes */

+

+   struct gl_buffer_object *BufferObj;/**< GL_ARB_vertex_buffer_object */

+   GLuint _MaxElement;          /**< max element index into array buffer + 1 */

+};

+

+

+/**

+ * Collection of vertex arrays.  Defined by the GL_APPLE_vertex_array_object

+ * extension, but a nice encapsulation in any case.

+ */

+struct gl_array_object

+{

+   /** Name of the array object as received from glGenVertexArrayAPPLE. */

+   GLuint Name;

+

+   GLint RefCount;

+   _glthread_Mutex Mutex;

+   GLboolean VBOonly;  /**< require all arrays to live in VBOs? */

+

+   /** Conventional vertex arrays */

+   /*@{*/

+   struct gl_client_array Vertex;

+   struct gl_client_array Weight;

+   struct gl_client_array Normal;

+   struct gl_client_array Color;

+   struct gl_client_array SecondaryColor;

+   struct gl_client_array FogCoord;

+   struct gl_client_array Index;

+   struct gl_client_array EdgeFlag;

+   struct gl_client_array TexCoord[MAX_TEXTURE_COORD_UNITS];

+   struct gl_client_array PointSize;

+   /*@}*/

+

+   /**

+    * Generic arrays for vertex programs/shaders.

+    * For NV vertex programs, these attributes alias and take priority

+    * over the conventional attribs above.  For ARB vertex programs and

+    * GLSL vertex shaders, these attributes are separate.

+    */

+   struct gl_client_array VertexAttrib[MAX_VERTEX_GENERIC_ATTRIBS];

+

+   /** Mask of _NEW_ARRAY_* values indicating which arrays are enabled */

+   GLbitfield _Enabled;

+

+   /**

+    * Min of all enabled arrays' _MaxElement.  When arrays reside inside VBOs

+    * we can determine the max legal (in bounds) glDrawElements array index.

+    */

+   GLuint _MaxElement;

+};

+

+

+/**

+ * Vertex array state

+ */

+struct gl_array_attrib

+{

+   /** Currently bound array object. See _mesa_BindVertexArrayAPPLE() */

+   struct gl_array_object *ArrayObj;

+

+   /** The default vertex array object */

+   struct gl_array_object *DefaultArrayObj;

+

+   /** Array objects (GL_ARB/APPLE_vertex_array_object) */

+   struct _mesa_HashTable *Objects;

+

+   GLint ActiveTexture;		/**< Client Active Texture */

+   GLuint LockFirst;            /**< GL_EXT_compiled_vertex_array */

+   GLuint LockCount;            /**< GL_EXT_compiled_vertex_array */

+

+   /** GL 3.1 (slightly different from GL_NV_primitive_restart) */

+   GLboolean PrimitiveRestart;

+   GLuint RestartIndex;

+

+   GLbitfield NewState;		/**< mask of _NEW_ARRAY_* values */

+   GLboolean RebindArrays; /**< whether the VBO module should rebind arrays */

+

+   /* GL_ARB_vertex_buffer_object */

+   struct gl_buffer_object *ArrayBufferObj;

+   struct gl_buffer_object *ElementArrayBufferObj;

+};

+

+

+/**

+ * Feedback buffer state

+ */

+struct gl_feedback

+{

+   GLenum Type;

+   GLbitfield _Mask;    /**< FB_* bits */

+   GLfloat *Buffer;

+   GLuint BufferSize;

+   GLuint Count;

+};

+

+

+/**

+ * Selection buffer state

+ */

+struct gl_selection

+{

+   GLuint *Buffer;	/**< selection buffer */

+   GLuint BufferSize;	/**< size of the selection buffer */

+   GLuint BufferCount;	/**< number of values in the selection buffer */

+   GLuint Hits;		/**< number of records in the selection buffer */

+   GLuint NameStackDepth; /**< name stack depth */

+   GLuint NameStack[MAX_NAME_STACK_DEPTH]; /**< name stack */

+   GLboolean HitFlag;	/**< hit flag */

+   GLfloat HitMinZ;	/**< minimum hit depth */

+   GLfloat HitMaxZ;	/**< maximum hit depth */

+};

+

+

+/**

+ * 1-D Evaluator control points

+ */

+struct gl_1d_map

+{

+   GLuint Order;	/**< Number of control points */

+   GLfloat u1, u2, du;	/**< u1, u2, 1.0/(u2-u1) */

+   GLfloat *Points;	/**< Points to contiguous control points */

+};

+

+

+/**

+ * 2-D Evaluator control points

+ */

+struct gl_2d_map

+{

+   GLuint Uorder;		/**< Number of control points in U dimension */

+   GLuint Vorder;		/**< Number of control points in V dimension */

+   GLfloat u1, u2, du;

+   GLfloat v1, v2, dv;

+   GLfloat *Points;		/**< Points to contiguous control points */

+};

+

+

+/**

+ * All evaluator control point state

+ */

+struct gl_evaluators

+{

+   /** 

+    * \name 1-D maps

+    */

+   /*@{*/

+   struct gl_1d_map Map1Vertex3;

+   struct gl_1d_map Map1Vertex4;

+   struct gl_1d_map Map1Index;

+   struct gl_1d_map Map1Color4;

+   struct gl_1d_map Map1Normal;

+   struct gl_1d_map Map1Texture1;

+   struct gl_1d_map Map1Texture2;

+   struct gl_1d_map Map1Texture3;

+   struct gl_1d_map Map1Texture4;

+   struct gl_1d_map Map1Attrib[16];  /**< GL_NV_vertex_program */

+   /*@}*/

+

+   /** 

+    * \name 2-D maps 

+    */

+   /*@{*/

+   struct gl_2d_map Map2Vertex3;

+   struct gl_2d_map Map2Vertex4;

+   struct gl_2d_map Map2Index;

+   struct gl_2d_map Map2Color4;

+   struct gl_2d_map Map2Normal;

+   struct gl_2d_map Map2Texture1;

+   struct gl_2d_map Map2Texture2;

+   struct gl_2d_map Map2Texture3;

+   struct gl_2d_map Map2Texture4;

+   struct gl_2d_map Map2Attrib[16];  /**< GL_NV_vertex_program */

+   /*@}*/

+};

+

+

+/**

+ * Names of the various vertex/fragment program register files, etc.

+ *

+ * NOTE: first four tokens must fit into 2 bits (see t_vb_arbprogram.c)

+ * All values should fit in a 4-bit field.

+ *

+ * NOTE: PROGRAM_ENV_PARAM, PROGRAM_STATE_VAR, PROGRAM_NAMED_PARAM,

+ * PROGRAM_CONSTANT, and PROGRAM_UNIFORM can all be considered to

+ * be "uniform" variables since they can only be set outside glBegin/End.

+ * They're also all stored in the same Parameters array.

+ */

+typedef enum

+{

+   PROGRAM_TEMPORARY,   /**< machine->Temporary[] */

+   PROGRAM_INPUT,       /**< machine->Inputs[] */

+   PROGRAM_OUTPUT,      /**< machine->Outputs[] */

+   PROGRAM_VARYING,     /**< machine->Inputs[]/Outputs[] */

+   PROGRAM_LOCAL_PARAM, /**< gl_program->LocalParams[] */

+   PROGRAM_ENV_PARAM,   /**< gl_program->Parameters[] */

+   PROGRAM_STATE_VAR,   /**< gl_program->Parameters[] */

+   PROGRAM_NAMED_PARAM, /**< gl_program->Parameters[] */

+   PROGRAM_CONSTANT,    /**< gl_program->Parameters[] */

+   PROGRAM_UNIFORM,     /**< gl_program->Parameters[] */

+   PROGRAM_WRITE_ONLY,  /**< A dummy, write-only register */

+   PROGRAM_ADDRESS,     /**< machine->AddressReg */

+   PROGRAM_SAMPLER,     /**< for shader samplers, compile-time only */

+   PROGRAM_SYSTEM_VALUE,/**< InstanceId, PrimitiveID, etc. */

+   PROGRAM_UNDEFINED,   /**< Invalid/TBD value */

+   PROGRAM_FILE_MAX

+} gl_register_file;

+

+

+/**

+ * If the register file is PROGRAM_SYSTEM_VALUE, the register index will be

+ * one of these values.

+ */

+typedef enum

+{

+   SYSTEM_VALUE_FRONT_FACE,  /**< Fragment shader only (not done yet) */

+   SYSTEM_VALUE_INSTANCE_ID, /**< Vertex shader only */

+   SYSTEM_VALUE_MAX          /**< Number of values */

+} gl_system_value;

+

+

+/** Vertex and fragment instructions */

+struct prog_instruction;

+struct gl_program_parameter_list;

+struct gl_uniform_list;

+

+

+/**

+ * Base class for any kind of program object

+ */

+struct gl_program

+{

+   GLuint Id;

+   GLubyte *String;  /**< Null-terminated program text */

+   GLint RefCount;

+   GLenum Target;    /**< GL_VERTEX/FRAGMENT_PROGRAM_ARB, GL_FRAGMENT_PROGRAM_NV */

+   GLenum Format;    /**< String encoding format */

+   GLboolean Resident;

+

+   struct prog_instruction *Instructions;

+

+   GLbitfield InputsRead;     /**< Bitmask of which input regs are read */

+   GLbitfield64 OutputsWritten; /**< Bitmask of which output regs are written */

+   GLbitfield SystemValuesRead;   /**< Bitmask of SYSTEM_VALUE_x inputs used */

+   GLbitfield InputFlags[MAX_PROGRAM_INPUTS];   /**< PROG_PARAM_BIT_x flags */

+   GLbitfield OutputFlags[MAX_PROGRAM_OUTPUTS]; /**< PROG_PARAM_BIT_x flags */

+   GLbitfield TexturesUsed[MAX_TEXTURE_UNITS];  /**< TEXTURE_x_BIT bitmask */

+   GLbitfield SamplersUsed;   /**< Bitfield of which samplers are used */

+   GLbitfield ShadowSamplers; /**< Texture units used for shadow sampling. */

+

+

+   /** Named parameters, constants, etc. from program text */

+   struct gl_program_parameter_list *Parameters;

+   /** Numbered local parameters */

+   GLfloat LocalParams[MAX_PROGRAM_LOCAL_PARAMS][4];

+

+   /** Vertex/fragment shader varying vars */

+   struct gl_program_parameter_list *Varying;

+   /** Vertex program user-defined attributes */

+   struct gl_program_parameter_list *Attributes;

+

+   /** Map from sampler unit to texture unit (set by glUniform1i()) */

+   GLubyte SamplerUnits[MAX_SAMPLERS];

+   /** Which texture target is being sampled (TEXTURE_1D/2D/3D/etc_INDEX) */

+   gl_texture_index SamplerTargets[MAX_SAMPLERS];

+

+   /** Bitmask of which register files are read/written with indirect

+    * addressing.  Mask of (1 << PROGRAM_x) bits.

+    */

+   GLbitfield IndirectRegisterFiles;

+

+   /** Logical counts */

+   /*@{*/

+   GLuint NumInstructions;

+   GLuint NumTemporaries;

+   GLuint NumParameters;

+   GLuint NumAttributes;

+   GLuint NumAddressRegs;

+   GLuint NumAluInstructions;

+   GLuint NumTexInstructions;

+   GLuint NumTexIndirections;

+   /*@}*/

+   /** Native, actual h/w counts */

+   /*@{*/

+   GLuint NumNativeInstructions;

+   GLuint NumNativeTemporaries;

+   GLuint NumNativeParameters;

+   GLuint NumNativeAttributes;

+   GLuint NumNativeAddressRegs;

+   GLuint NumNativeAluInstructions;

+   GLuint NumNativeTexInstructions;

+   GLuint NumNativeTexIndirections;

+   /*@}*/

+};

+

+

+/** Vertex program object */

+struct gl_vertex_program

+{

+   struct gl_program Base;   /**< base class */

+   GLboolean IsNVProgram;    /**< is this a GL_NV_vertex_program program? */

+   GLboolean IsPositionInvariant;

+};

+

+

+/** Geometry program object */

+struct gl_geometry_program

+{

+   struct gl_program Base;   /**< base class */

+

+   GLint VerticesOut;

+   GLenum InputType;  /**< GL_POINTS, GL_LINES, GL_LINES_ADJACENCY_ARB,

+                           GL_TRIANGLES, or GL_TRIANGLES_ADJACENCY_ARB */

+   GLenum OutputType; /**< GL_POINTS, GL_LINE_STRIP or GL_TRIANGLE_STRIP */

+};

+

+

+/** Fragment program object */

+struct gl_fragment_program

+{

+   struct gl_program Base;   /**< base class */

+   GLenum FogOption;

+   GLboolean UsesKill;          /**< shader uses KIL instruction */

+   GLboolean OriginUpperLeft;

+   GLboolean PixelCenterInteger;

+   enum gl_frag_depth_layout FragDepthLayout;

+};

+

+

+/**

+ * State common to vertex and fragment programs.

+ */

+struct gl_program_state

+{

+   GLint ErrorPos;                       /* GL_PROGRAM_ERROR_POSITION_ARB/NV */

+   const char *ErrorString;              /* GL_PROGRAM_ERROR_STRING_ARB/NV */

+};

+

+

+/**

+ * Context state for vertex programs.

+ */

+struct gl_vertex_program_state

+{

+   GLboolean Enabled;            /**< User-set GL_VERTEX_PROGRAM_ARB/NV flag */

+   GLboolean _Enabled;           /**< Enabled and _valid_ user program? */

+   GLboolean PointSizeEnabled;   /**< GL_VERTEX_PROGRAM_POINT_SIZE_ARB/NV */

+   GLboolean TwoSideEnabled;     /**< GL_VERTEX_PROGRAM_TWO_SIDE_ARB/NV */

+   struct gl_vertex_program *Current;  /**< User-bound vertex program */

+

+   /** Currently enabled and valid vertex program (including internal

+    * programs, user-defined vertex programs and GLSL vertex shaders).

+    * This is the program we must use when rendering.

+    */

+   struct gl_vertex_program *_Current;

+

+   GLfloat Parameters[MAX_PROGRAM_ENV_PARAMS][4]; /**< Env params */

+

+   /* For GL_NV_vertex_program only: */

+   GLenum TrackMatrix[MAX_PROGRAM_ENV_PARAMS / 4];

+   GLenum TrackMatrixTransform[MAX_PROGRAM_ENV_PARAMS / 4];

+

+   /** Should fixed-function T&L be implemented with a vertex prog? */

+   GLboolean _MaintainTnlProgram;

+

+   /** Program to emulate fixed-function T&L (see above) */

+   struct gl_vertex_program *_TnlProgram;

+

+   /** Cache of fixed-function programs */

+   struct gl_program_cache *Cache;

+

+   GLboolean _Overriden;

+};

+

+

+/**

+ * Context state for geometry programs.

+ */

+struct gl_geometry_program_state

+{

+   GLboolean Enabled;               /**< GL_ARB_GEOMETRY_SHADER4 */

+   GLboolean _Enabled;              /**< Enabled and valid program? */

+   struct gl_geometry_program *Current;  /**< user-bound geometry program */

+

+   /** Currently enabled and valid program (including internal programs

+    * and compiled shader programs).

+    */

+   struct gl_geometry_program *_Current;

+

+   GLfloat Parameters[MAX_PROGRAM_ENV_PARAMS][4]; /**< Env params */

+

+   /** Cache of fixed-function programs */

+   struct gl_program_cache *Cache;

+};

+

+/**

+ * Context state for fragment programs.

+ */

+struct gl_fragment_program_state

+{

+   GLboolean Enabled;     /**< User-set fragment program enable flag */

+   GLboolean _Enabled;    /**< Enabled and _valid_ user program? */

+   struct gl_fragment_program *Current;  /**< User-bound fragment program */

+

+   /** Currently enabled and valid fragment program (including internal

+    * programs, user-defined fragment programs and GLSL fragment shaders).

+    * This is the program we must use when rendering.

+    */

+   struct gl_fragment_program *_Current;

+

+   GLfloat Parameters[MAX_PROGRAM_ENV_PARAMS][4]; /**< Env params */

+

+   /** Should fixed-function texturing be implemented with a fragment prog? */

+   GLboolean _MaintainTexEnvProgram;

+

+   /** Program to emulate fixed-function texture env/combine (see above) */

+   struct gl_fragment_program *_TexEnvProgram;

+

+   /** Cache of fixed-function programs */

+   struct gl_program_cache *Cache;

+};

+

+

+/**

+ * ATI_fragment_shader runtime state

+ */

+#define ATI_FS_INPUT_PRIMARY 0

+#define ATI_FS_INPUT_SECONDARY 1

+

+struct atifs_instruction;

+struct atifs_setupinst;

+

+/**

+ * ATI fragment shader

+ */

+struct ati_fragment_shader

+{

+   GLuint Id;

+   GLint RefCount;

+   struct atifs_instruction *Instructions[2];

+   struct atifs_setupinst *SetupInst[2];

+   GLfloat Constants[8][4];

+   GLbitfield LocalConstDef;  /**< Indicates which constants have been set */

+   GLubyte numArithInstr[2];

+   GLubyte regsAssigned[2];

+   GLubyte NumPasses;         /**< 1 or 2 */

+   GLubyte cur_pass;

+   GLubyte last_optype;

+   GLboolean interpinp1;

+   GLboolean isValid;

+   GLuint swizzlerq;

+};

+

+/**

+ * Context state for GL_ATI_fragment_shader

+ */

+struct gl_ati_fragment_shader_state

+{

+   GLboolean Enabled;

+   GLboolean _Enabled;                  /**< enabled and valid shader? */

+   GLboolean Compiling;

+   GLfloat GlobalConstants[8][4];

+   struct ati_fragment_shader *Current;

+};

+

+

+/**

+ * Occlusion/timer query object.

+ */

+struct gl_query_object

+{

+   GLenum Target;      /**< The query target, when active */

+   GLuint Id;          /**< hash table ID/name */

+   GLuint64EXT Result; /**< the counter */

+   GLboolean Active;   /**< inside Begin/EndQuery */

+   GLboolean Ready;    /**< result is ready? */

+};

+

+

+/**

+ * Context state for query objects.

+ */

+struct gl_query_state

+{

+   struct _mesa_HashTable *QueryObjects;

+   struct gl_query_object *CurrentOcclusionObject; /* GL_ARB_occlusion_query */

+   struct gl_query_object *CurrentTimerObject;     /* GL_EXT_timer_query */

+

+   /** GL_NV_conditional_render */

+   struct gl_query_object *CondRenderQuery;

+

+   /** GL_EXT_transform_feedback */

+   struct gl_query_object *PrimitivesGenerated;

+   struct gl_query_object *PrimitivesWritten;

+

+   /** GL_ARB_timer_query */

+   struct gl_query_object *TimeElapsed;

+

+   GLenum CondRenderMode;

+};

+

+

+/** Sync object state */

+struct gl_sync_object {

+   struct simple_node link;

+   GLenum Type;               /**< GL_SYNC_FENCE */

+   GLuint Name;               /**< Fence name */

+   GLint RefCount;            /**< Reference count */

+   GLboolean DeletePending;   /**< Object was deleted while there were still

+			       * live references (e.g., sync not yet finished)

+			       */

+   GLenum SyncCondition;

+   GLbitfield Flags;          /**< Flags passed to glFenceSync */

+   GLuint StatusFlag:1;       /**< Has the sync object been signaled? */

+};

+

+

+/** Set by #pragma directives */

+struct gl_sl_pragmas

+{

+   GLboolean IgnoreOptimize;  /**< ignore #pragma optimize(on/off) ? */

+   GLboolean IgnoreDebug;     /**< ignore #pragma debug(on/off) ? */

+   GLboolean Optimize;  /**< defaults on */

+   GLboolean Debug;     /**< defaults off */

+};

+

+

+/**

+ * A GLSL vertex or fragment shader object.

+ */

+struct gl_shader

+{

+   GLenum Type;  /**< GL_FRAGMENT_SHADER || GL_VERTEX_SHADER || GL_GEOMETRY_SHADER_ARB (first field!) */

+   GLuint Name;  /**< AKA the handle */

+   GLint RefCount;  /**< Reference count */

+   GLboolean DeletePending;

+   GLboolean CompileStatus;

+   const GLchar *Source;  /**< Source code string */

+   GLuint SourceChecksum;       /**< for debug/logging purposes */

+   struct gl_program *Program;  /**< Post-compile assembly code */

+   GLchar *InfoLog;

+   struct gl_sl_pragmas Pragmas;

+

+   unsigned Version;       /**< GLSL version used for linking */

+

+   struct exec_list *ir;

+   struct glsl_symbol_table *symbols;

+

+   /** Shaders containing built-in functions that are used for linking. */

+   struct gl_shader *builtins_to_link[16];

+   unsigned num_builtins_to_link;

+};

+

+

+/**

+ * A GLSL program object.

+ * Basically a linked collection of vertex and fragment shaders.

+ */

+struct gl_shader_program

+{

+   GLenum Type;  /**< Always GL_SHADER_PROGRAM (internal token) */

+   GLuint Name;  /**< aka handle or ID */

+   GLint RefCount;  /**< Reference count */

+   GLboolean DeletePending;

+

+   GLuint NumShaders;          /**< number of attached shaders */

+   struct gl_shader **Shaders; /**< List of attached the shaders */

+

+   /** User-defined attribute bindings (glBindAttribLocation) */

+   struct gl_program_parameter_list *Attributes;

+

+   /** Transform feedback varyings */

+   struct {

+      GLenum BufferMode;

+      GLuint NumVarying;

+      GLchar **VaryingNames;  /**< Array [NumVarying] of char * */

+   } TransformFeedback;

+

+   /** Geometry shader state - copied into gl_geometry_program at link time */

+   struct {

+      GLint VerticesOut;

+      GLenum InputType;  /**< GL_POINTS, GL_LINES, GL_LINES_ADJACENCY_ARB,

+                              GL_TRIANGLES, or GL_TRIANGLES_ADJACENCY_ARB */

+      GLenum OutputType; /**< GL_POINTS, GL_LINE_STRIP or GL_TRIANGLE_STRIP */

+   } Geom;

+

+   /* post-link info: */

+   struct gl_vertex_program *VertexProgram;     /**< Linked vertex program */

+   struct gl_fragment_program *FragmentProgram; /**< Linked fragment prog */

+   struct gl_geometry_program *GeometryProgram; /**< Linked geometry prog */

+   struct gl_uniform_list *Uniforms;

+   struct gl_program_parameter_list *Varying;

+   GLboolean LinkStatus;   /**< GL_LINK_STATUS */

+   GLboolean Validated;

+   GLboolean _Used;        /**< Ever used for drawing? */

+   GLchar *InfoLog;

+

+   unsigned Version;       /**< GLSL version used for linking */

+

+   /**

+    * Per-stage shaders resulting from the first stage of linking.

+    *

+    * Set of linked shaders for this program.  The array is accessed using the

+    * \c MESA_SHADER_* defines.  Entries for non-existent stages will be

+    * \c NULL.

+    */

+   struct gl_shader *_LinkedShaders[MESA_SHADER_TYPES];

+};   

+

+

+#define GLSL_DUMP      0x1  /**< Dump shaders to stdout */

+#define GLSL_LOG       0x2  /**< Write shaders to files */

+#define GLSL_OPT       0x4  /**< Force optimizations (override pragmas) */

+#define GLSL_NO_OPT    0x8  /**< Force no optimizations (override pragmas) */

+#define GLSL_UNIFORMS 0x10  /**< Print glUniform calls */

+#define GLSL_NOP_VERT 0x20  /**< Force no-op vertex shaders */

+#define GLSL_NOP_FRAG 0x40  /**< Force no-op fragment shaders */

+#define GLSL_USE_PROG 0x80  /**< Log glUseProgram calls */

+

+

+/**

+ * Context state for GLSL vertex/fragment shaders.

+ */

+struct gl_shader_state

+{

+   /**

+    * Programs used for rendering

+    *

+    * There is a separate program set for each shader stage.  If

+    * GL_EXT_separate_shader_objects is not supported, each of these must point

+    * to \c NULL or to the same program.

+    */

+   struct gl_shader_program *CurrentVertexProgram;

+   struct gl_shader_program *CurrentGeometryProgram;

+   struct gl_shader_program *CurrentFragmentProgram;

+   struct gl_shader_program *_CurrentFragmentProgram;

+

+   /**

+    * Program used by glUniform calls.

+    *

+    * Explicitly set by \c glUseProgram and \c glActiveProgramEXT.

+    */

+   struct gl_shader_program *ActiveProgram;

+

+   void *MemPool;

+

+   GLbitfield Flags;                    /**< Mask of GLSL_x flags */

+};

+

+/**

+ * Compiler options for a single GLSL shaders type

+ */

+struct gl_shader_compiler_options

+{

+   /** Driver-selectable options: */

+   GLboolean EmitCondCodes;             /**< Use condition codes? */

+   GLboolean EmitNVTempInitialization;  /**< 0-fill NV temp registers */

+   /**

+    * Attempts to flatten all ir_if (OPCODE_IF) for GPUs that can't

+    * support control flow.

+    */

+   GLboolean EmitNoIfs;

+   GLboolean EmitNoLoops;

+   GLboolean EmitNoFunctions;

+   GLboolean EmitNoCont;                  /**< Emit CONT opcode? */

+   GLboolean EmitNoMainReturn;            /**< Emit CONT/RET opcodes? */

+   GLboolean EmitNoNoise;                 /**< Emit NOISE opcodes? */

+   GLboolean EmitNoPow;                   /**< Emit POW opcodes? */

+

+   /**

+    * \name Forms of indirect addressing the driver cannot do.

+    */

+   /*@{*/

+   GLboolean EmitNoIndirectInput;   /**< No indirect addressing of inputs */

+   GLboolean EmitNoIndirectOutput;  /**< No indirect addressing of outputs */

+   GLboolean EmitNoIndirectTemp;    /**< No indirect addressing of temps */

+   GLboolean EmitNoIndirectUniform; /**< No indirect addressing of constants */

+   /*@}*/

+

+   GLuint MaxUnrollIterations;

+

+   struct gl_sl_pragmas DefaultPragmas; /**< Default #pragma settings */

+};

+

+/**

+ * Transform feedback object state

+ */

+struct gl_transform_feedback_object

+{

+   GLuint Name;  /**< AKA the object ID */

+   GLint RefCount;

+   GLboolean Active;  /**< Is transform feedback enabled? */

+   GLboolean Paused;  /**< Is transform feedback paused? */

+

+   /** The feedback buffers */

+   GLuint BufferNames[MAX_FEEDBACK_ATTRIBS];

+   struct gl_buffer_object *Buffers[MAX_FEEDBACK_ATTRIBS];

+

+   /** Start of feedback data in dest buffer */

+   GLintptr Offset[MAX_FEEDBACK_ATTRIBS];

+   /** Max data to put into dest buffer (in bytes) */

+   GLsizeiptr Size[MAX_FEEDBACK_ATTRIBS];

+};

+

+

+/**

+ * Context state for transform feedback.

+ */

+struct gl_transform_feedback

+{

+   GLenum Mode;       /**< GL_POINTS, GL_LINES or GL_TRIANGLES */

+

+   GLboolean RasterDiscard;  /**< GL_RASTERIZER_DISCARD */

+

+   /** The general binding point (GL_TRANSFORM_FEEDBACK_BUFFER) */

+   struct gl_buffer_object *CurrentBuffer;

+

+   /** The table of all transform feedback objects */

+   struct _mesa_HashTable *Objects;

+

+   /** The current xform-fb object (GL_TRANSFORM_FEEDBACK_BINDING) */

+   struct gl_transform_feedback_object *CurrentObject;

+

+   /** The default xform-fb object (Name==0) */

+   struct gl_transform_feedback_object *DefaultObject;

+};

+

+

+

+/**

+ * State which can be shared by multiple contexts:

+ */

+struct gl_shared_state

+{

+   _glthread_Mutex Mutex;		   /**< for thread safety */

+   GLint RefCount;			   /**< Reference count */

+   struct _mesa_HashTable *DisplayList;	   /**< Display lists hash table */

+   struct _mesa_HashTable *TexObjects;	   /**< Texture objects hash table */

+

+   /** Default texture objects (shared by all texture units) */

+   struct gl_texture_object *DefaultTex[NUM_TEXTURE_TARGETS];

+

+   /** Fallback texture used when a bound texture is incomplete */

+   struct gl_texture_object *FallbackTex;

+

+   /**

+    * \name Thread safety and statechange notification for texture

+    * objects. 

+    *

+    * \todo Improve the granularity of locking.

+    */

+   /*@{*/

+   _glthread_Mutex TexMutex;		/**< texobj thread safety */

+   GLuint TextureStateStamp;	        /**< state notification for shared tex */

+   /*@}*/

+

+   /** Default buffer object for vertex arrays that aren't in VBOs */

+   struct gl_buffer_object *NullBufferObj;

+

+   /**

+    * \name Vertex/geometry/fragment programs

+    */

+   /*@{*/

+   struct _mesa_HashTable *Programs; /**< All vertex/fragment programs */

+   struct gl_vertex_program *DefaultVertexProgram;

+   struct gl_fragment_program *DefaultFragmentProgram;

+   struct gl_geometry_program *DefaultGeometryProgram;

+   /*@}*/

+

+   /* GL_ATI_fragment_shader */

+   struct _mesa_HashTable *ATIShaders;

+   struct ati_fragment_shader *DefaultFragmentShader;

+

+   struct _mesa_HashTable *BufferObjects;

+

+   /** Table of both gl_shader and gl_shader_program objects */

+   struct _mesa_HashTable *ShaderObjects;

+

+   /* GL_EXT_framebuffer_object */

+   struct _mesa_HashTable *RenderBuffers;

+   struct _mesa_HashTable *FrameBuffers;

+

+   /* GL_ARB_sync */

+   struct simple_node SyncObjects;

+

+   void *DriverData;  /**< Device driver shared state */

+};

+

+

+

+

+/**

+ * A renderbuffer stores colors or depth values or stencil values.

+ * A framebuffer object will have a collection of these.

+ * Data are read/written to the buffer with a handful of Get/Put functions.

+ *

+ * Instances of this object are allocated with the Driver's NewRenderbuffer

+ * hook.  Drivers will likely wrap this class inside a driver-specific

+ * class to simulate inheritance.

+ */

+struct gl_renderbuffer

+{

+#define RB_MAGIC 0xaabbccdd

+   int Magic; /** XXX TEMPORARY DEBUG INFO */

+   _glthread_Mutex Mutex;		   /**< for thread safety */

+   GLuint ClassID;        /**< Useful for drivers */

+   GLuint Name;

+   GLint RefCount;

+   GLuint Width, Height;

+   GLboolean Purgeable;   /**< Is the buffer purgeable under memory pressure? */

+

+   GLenum InternalFormat; /**< The user-specified format */

+   GLenum _BaseFormat;    /**< Either GL_RGB, GL_RGBA, GL_DEPTH_COMPONENT or

+                               GL_STENCIL_INDEX. */

+   gl_format Format;      /**< The actual renderbuffer memory format */

+

+   GLubyte NumSamples;

+

+   GLenum DataType;      /**< Type of values passed to the Get/Put functions */

+   GLvoid *Data;        /**< This may not be used by some kinds of RBs */

+

+   GLboolean AttachedAnytime; /**< TRUE if it was attached to a framebuffer */

+

+   /* Used to wrap one renderbuffer around another: */

+   struct gl_renderbuffer *Wrapped;

+

+   /* Delete this renderbuffer */

+   void (*Delete)(struct gl_renderbuffer *rb);

+

+   /* Allocate new storage for this renderbuffer */

+   GLboolean (*AllocStorage)(struct gl_context *ctx, struct gl_renderbuffer *rb,

+                             GLenum internalFormat,

+                             GLuint width, GLuint height);

+

+   /* Lock/Unlock are called before/after calling the Get/Put functions.

+    * Not sure this is the right place for these yet.

+   void (*Lock)(struct gl_context *ctx, struct gl_renderbuffer *rb);

+   void (*Unlock)(struct gl_context *ctx, struct gl_renderbuffer *rb);

+    */

+

+   /* Return a pointer to the element/pixel at (x,y).

+    * Should return NULL if the buffer memory can't be directly addressed.

+    */

+   void *(*GetPointer)(struct gl_context *ctx, struct gl_renderbuffer *rb,

+                       GLint x, GLint y);

+

+   /* Get/Read a row of values.

+    * The values will be of format _BaseFormat and type DataType.

+    */

+   void (*GetRow)(struct gl_context *ctx, struct gl_renderbuffer *rb, GLuint count,

+                  GLint x, GLint y, void *values);

+

+   /* Get/Read values at arbitrary locations.

+    * The values will be of format _BaseFormat and type DataType.

+    */

+   void (*GetValues)(struct gl_context *ctx, struct gl_renderbuffer *rb, GLuint count,

+                     const GLint x[], const GLint y[], void *values);

+

+   /* Put/Write a row of values.

+    * The values will be of format _BaseFormat and type DataType.

+    */

+   void (*PutRow)(struct gl_context *ctx, struct gl_renderbuffer *rb, GLuint count,

+                  GLint x, GLint y, const void *values, const GLubyte *mask);

+

+   /* Put/Write a row of RGB values.  This is a special-case routine that's

+    * only used for RGBA renderbuffers when the source data is GL_RGB. That's

+    * a common case for glDrawPixels and some triangle routines.

+    * The values will be of format GL_RGB and type DataType.

+    */

+   void (*PutRowRGB)(struct gl_context *ctx, struct gl_renderbuffer *rb, GLuint count,

+                    GLint x, GLint y, const void *values, const GLubyte *mask);

+

+

+   /* Put/Write a row of identical values.

+    * The values will be of format _BaseFormat and type DataType.

+    */

+   void (*PutMonoRow)(struct gl_context *ctx, struct gl_renderbuffer *rb, GLuint count,

+                     GLint x, GLint y, const void *value, const GLubyte *mask);

+

+   /* Put/Write values at arbitrary locations.

+    * The values will be of format _BaseFormat and type DataType.

+    */

+   void (*PutValues)(struct gl_context *ctx, struct gl_renderbuffer *rb, GLuint count,

+                     const GLint x[], const GLint y[], const void *values,

+                     const GLubyte *mask);

+   /* Put/Write identical values at arbitrary locations.

+    * The values will be of format _BaseFormat and type DataType.

+    */

+   void (*PutMonoValues)(struct gl_context *ctx, struct gl_renderbuffer *rb,

+                         GLuint count, const GLint x[], const GLint y[],

+                         const void *value, const GLubyte *mask);

+};

+

+

+/**

+ * A renderbuffer attachment points to either a texture object (and specifies

+ * a mipmap level, cube face or 3D texture slice) or points to a renderbuffer.

+ */

+struct gl_renderbuffer_attachment

+{

+   GLenum Type;  /**< \c GL_NONE or \c GL_TEXTURE or \c GL_RENDERBUFFER_EXT */

+   GLboolean Complete;

+

+   /**

+    * If \c Type is \c GL_RENDERBUFFER_EXT, this stores a pointer to the

+    * application supplied renderbuffer object.

+    */

+   struct gl_renderbuffer *Renderbuffer;

+

+   /**

+    * If \c Type is \c GL_TEXTURE, this stores a pointer to the application

+    * supplied texture object.

+    */

+   struct gl_texture_object *Texture;

+   GLuint TextureLevel; /**< Attached mipmap level. */

+   GLuint CubeMapFace;  /**< 0 .. 5, for cube map textures. */

+   GLuint Zoffset;      /**< Slice for 3D textures,  or layer for both 1D

+                         * and 2D array textures */

+};

+

+

+/**

+ * A framebuffer is a collection of renderbuffers (color, depth, stencil, etc).

+ * In C++ terms, think of this as a base class from which device drivers

+ * will make derived classes.

+ */

+struct gl_framebuffer

+{

+   _glthread_Mutex Mutex;  /**< for thread safety */

+   /**

+    * If zero, this is a window system framebuffer.  If non-zero, this

+    * is a FBO framebuffer; note that for some devices (i.e. those with

+    * a natural pixel coordinate system for FBOs that differs from the

+    * OpenGL/Mesa coordinate system), this means that the viewport,

+    * polygon face orientation, and polygon stipple will have to be inverted.

+    */

+   GLuint Name;

+

+   GLint RefCount;

+   GLboolean DeletePending;

+

+   /**

+    * The framebuffer's visual. Immutable if this is a window system buffer.

+    * Computed from attachments if user-made FBO.

+    */

+   struct gl_config Visual;

+

+   GLboolean Initialized;

+

+   GLuint Width, Height;	/**< size of frame buffer in pixels */

+

+   /** \name  Drawing bounds (Intersection of buffer size and scissor box) */

+   /*@{*/

+   GLint _Xmin, _Xmax;  /**< inclusive */

+   GLint _Ymin, _Ymax;  /**< exclusive */

+   /*@}*/

+

+   /** \name  Derived Z buffer stuff */

+   /*@{*/

+   GLuint _DepthMax;	/**< Max depth buffer value */

+   GLfloat _DepthMaxF;	/**< Float max depth buffer value */

+   GLfloat _MRD;	/**< minimum resolvable difference in Z values */

+   /*@}*/

+

+   /** One of the GL_FRAMEBUFFER_(IN)COMPLETE_* tokens */

+   GLenum _Status;

+

+   /** Integer color values */

+   GLboolean _IntegerColor;

+

+   /** Array of all renderbuffer attachments, indexed by BUFFER_* tokens. */

+   struct gl_renderbuffer_attachment Attachment[BUFFER_COUNT];

+

+   /* In unextended OpenGL these vars are part of the GL_COLOR_BUFFER

+    * attribute group and GL_PIXEL attribute group, respectively.

+    */

+   GLenum ColorDrawBuffer[MAX_DRAW_BUFFERS];

+   GLenum ColorReadBuffer;

+

+   /** Computed from ColorDraw/ReadBuffer above */

+   GLuint _NumColorDrawBuffers;

+   GLint _ColorDrawBufferIndexes[MAX_DRAW_BUFFERS]; /**< BUFFER_x or -1 */

+   GLint _ColorReadBufferIndex; /* -1 = None */

+   struct gl_renderbuffer *_ColorDrawBuffers[MAX_DRAW_BUFFERS];

+   struct gl_renderbuffer *_ColorReadBuffer;

+

+   /** The Actual depth/stencil buffers to use.  May be wrappers around the

+    * depth/stencil buffers attached above. */

+   struct gl_renderbuffer *_DepthBuffer;

+   struct gl_renderbuffer *_StencilBuffer;

+

+   /** Delete this framebuffer */

+   void (*Delete)(struct gl_framebuffer *fb);

+};

+

+

+/**

+ * Precision info for shader datatypes.  See glGetShaderPrecisionFormat().

+ */

+struct gl_precision

+{

+   GLushort RangeMin;   /**< min value exponent */

+   GLushort RangeMax;   /**< max value exponent */

+   GLushort Precision;  /**< number of mantissa bits */

+};

+

+

+/**

+ * Limits for vertex, geometry and fragment programs/shaders.

+ */

+struct gl_program_constants

+{

+   /* logical limits */

+   GLuint MaxInstructions;

+   GLuint MaxAluInstructions;

+   GLuint MaxTexInstructions;

+   GLuint MaxTexIndirections;

+   GLuint MaxAttribs;

+   GLuint MaxTemps;

+   GLuint MaxAddressRegs;

+   GLuint MaxAddressOffset;  /**< [-MaxAddressOffset, MaxAddressOffset-1] */

+   GLuint MaxParameters;

+   GLuint MaxLocalParams;

+   GLuint MaxEnvParams;

+   /* native/hardware limits */

+   GLuint MaxNativeInstructions;

+   GLuint MaxNativeAluInstructions;

+   GLuint MaxNativeTexInstructions;

+   GLuint MaxNativeTexIndirections;

+   GLuint MaxNativeAttribs;

+   GLuint MaxNativeTemps;

+   GLuint MaxNativeAddressRegs;

+   GLuint MaxNativeParameters;

+   /* For shaders */

+   GLuint MaxUniformComponents;  /**< Usually == MaxParameters * 4 */

+   /* ES 2.0 and GL_ARB_ES2_compatibility */

+   struct gl_precision LowFloat, MediumFloat, HighFloat;

+   struct gl_precision LowInt, MediumInt, HighInt;

+};

+

+

+/**

+ * Constants which may be overridden by device driver during context creation

+ * but are never changed after that.

+ */

+struct gl_constants

+{

+   GLint MaxTextureMbytes;      /**< Max memory per image, in MB */

+   GLint MaxTextureLevels;      /**< Max mipmap levels. */ 

+   GLint Max3DTextureLevels;    /**< Max mipmap levels for 3D textures */

+   GLint MaxCubeTextureLevels;  /**< Max mipmap levels for cube textures */

+   GLint MaxArrayTextureLayers; /**< Max layers in array textures */

+   GLint MaxTextureRectSize;    /**< Max rectangle texture size, in pixes */

+   GLuint MaxTextureCoordUnits;

+   GLuint MaxTextureImageUnits;

+   GLuint MaxVertexTextureImageUnits;

+   GLuint MaxCombinedTextureImageUnits;

+   GLuint MaxGeometryTextureImageUnits;

+   GLuint MaxTextureUnits;           /**< = MIN(CoordUnits, ImageUnits) */

+   GLfloat MaxTextureMaxAnisotropy;  /**< GL_EXT_texture_filter_anisotropic */

+   GLfloat MaxTextureLodBias;        /**< GL_EXT_texture_lod_bias */

+

+   GLuint MaxArrayLockSize;

+

+   GLint SubPixelBits;

+

+   GLfloat MinPointSize, MaxPointSize;	     /**< aliased */

+   GLfloat MinPointSizeAA, MaxPointSizeAA;   /**< antialiased */

+   GLfloat PointSizeGranularity;

+   GLfloat MinLineWidth, MaxLineWidth;       /**< aliased */

+   GLfloat MinLineWidthAA, MaxLineWidthAA;   /**< antialiased */

+   GLfloat LineWidthGranularity;

+

+   GLuint MaxColorTableSize;

+

+   GLuint MaxClipPlanes;

+   GLuint MaxLights;

+   GLfloat MaxShininess;                     /**< GL_NV_light_max_exponent */

+   GLfloat MaxSpotExponent;                  /**< GL_NV_light_max_exponent */

+

+   GLuint MaxViewportWidth, MaxViewportHeight;

+

+   struct gl_program_constants VertexProgram;   /**< GL_ARB_vertex_program */

+   struct gl_program_constants FragmentProgram; /**< GL_ARB_fragment_program */

+   struct gl_program_constants GeometryProgram;  /**< GL_ARB_geometry_shader4 */

+   GLuint MaxProgramMatrices;

+   GLuint MaxProgramMatrixStackDepth;

+

+   /** vertex array / buffer object bounds checking */

+   GLboolean CheckArrayBounds;

+

+   GLuint MaxDrawBuffers;    /**< GL_ARB_draw_buffers */

+

+   GLuint MaxColorAttachments;   /**< GL_EXT_framebuffer_object */

+   GLuint MaxRenderbufferSize;   /**< GL_EXT_framebuffer_object */

+   GLuint MaxSamples;            /**< GL_ARB_framebuffer_object */

+

+   /** Number of varying vectors between vertex and fragment shaders */

+   GLuint MaxVarying;

+   GLuint MaxVertexVaryingComponents;   /**< Between vert and geom shader */

+   GLuint MaxGeometryVaryingComponents; /**< Between geom and frag shader */

+

+   /** GL_ARB_geometry_shader4 */

+   GLuint MaxGeometryOutputVertices;

+   GLuint MaxGeometryTotalOutputComponents;

+

+   GLuint GLSLVersion;  /**< GLSL version supported (ex: 120 = 1.20) */

+

+   /** Which texture units support GL_ATI_envmap_bumpmap as targets */

+   GLbitfield SupportedBumpUnits;

+

+   /**

+    * Maximum amount of time, measured in nanseconds, that the server can wait.

+    */

+   GLuint64 MaxServerWaitTimeout;

+

+   /** GL_EXT_provoking_vertex */

+   GLboolean QuadsFollowProvokingVertexConvention;

+

+   /** OpenGL version 3.0 */

+   GLbitfield ContextFlags;  /**< Ex: GL_CONTEXT_FLAG_FORWARD_COMPATIBLE_BIT */

+

+   /** OpenGL version 3.2 */

+   GLbitfield ProfileMask;   /**< Mask of CONTEXT_x_PROFILE_BIT */

+

+   /** GL_EXT_transform_feedback */

+   GLuint MaxTransformFeedbackSeparateAttribs;

+   GLuint MaxTransformFeedbackSeparateComponents;

+   GLuint MaxTransformFeedbackInterleavedComponents;

+

+   /** GL_EXT_gpu_shader4 */

+   GLint MinProgramTexelOffset, MaxProgramTexelOffset;

+

+   /* GL_EXT_framebuffer_sRGB */

+   GLboolean sRGBCapable; /* can enable sRGB blend/update on FBOs */

+};

+

+

+/**

+ * Enable flag for each OpenGL extension.  Different device drivers will

+ * enable different extensions at runtime.

+ */

+struct gl_extensions

+{

+   GLboolean dummy;  /* don't remove this! */

+   GLboolean dummy_true;  /* Set true by _mesa_init_extensions(). */

+   GLboolean dummy_false; /* Set false by _mesa_init_extensions(). */

+   GLboolean ARB_ES2_compatibility;

+   GLboolean ARB_blend_func_extended;

+   GLboolean ARB_copy_buffer;

+   GLboolean ARB_depth_buffer_float;

+   GLboolean ARB_depth_clamp;

+   GLboolean ARB_depth_texture;

+   GLboolean ARB_draw_buffers;

+   GLboolean ARB_draw_buffers_blend;

+   GLboolean ARB_draw_elements_base_vertex;

+   GLboolean ARB_draw_instanced;

+   GLboolean ARB_fragment_coord_conventions;

+   GLboolean ARB_fragment_program;

+   GLboolean ARB_fragment_program_shadow;

+   GLboolean ARB_fragment_shader;

+   GLboolean ARB_framebuffer_object;

+   GLboolean ARB_explicit_attrib_location;

+   GLboolean ARB_geometry_shader4;

+   GLboolean ARB_half_float_pixel;

+   GLboolean ARB_half_float_vertex;

+   GLboolean ARB_instanced_arrays;

+   GLboolean ARB_map_buffer_range;

+   GLboolean ARB_multisample;

+   GLboolean ARB_multitexture;

+   GLboolean ARB_occlusion_query;

+   GLboolean ARB_occlusion_query2;

+   GLboolean ARB_point_sprite;

+   GLboolean ARB_sampler_objects;

+   GLboolean ARB_seamless_cube_map;

+   GLboolean ARB_shader_objects;

+   GLboolean ARB_shader_stencil_export;

+   GLboolean ARB_shading_language_100;

+   GLboolean ARB_shadow;

+   GLboolean ARB_shadow_ambient;

+   GLboolean ARB_sync;

+   GLboolean ARB_texture_border_clamp;

+   GLboolean ARB_texture_buffer_object;

+   GLboolean ARB_texture_compression;

+   GLboolean ARB_texture_compression_rgtc;

+   GLboolean ARB_texture_cube_map;

+   GLboolean ARB_texture_env_combine;

+   GLboolean ARB_texture_env_crossbar;

+   GLboolean ARB_texture_env_dot3;

+   GLboolean ARB_texture_float;

+   GLboolean ARB_texture_mirrored_repeat;

+   GLboolean ARB_texture_multisample;

+   GLboolean ARB_texture_non_power_of_two;

+   GLboolean ARB_texture_rg;

+   GLboolean ARB_texture_rgb10_a2ui;

+   GLboolean ARB_timer_query;

+   GLboolean ARB_transform_feedback2;

+   GLboolean ARB_transpose_matrix;

+   GLboolean ARB_uniform_buffer_object;

+   GLboolean ARB_vertex_array_object;

+   GLboolean ARB_vertex_buffer_object;

+   GLboolean ARB_vertex_program;

+   GLboolean ARB_vertex_shader;

+   GLboolean ARB_vertex_type_2_10_10_10_rev;

+   GLboolean ARB_window_pos;

+   GLboolean EXT_abgr;

+   GLboolean EXT_bgra;

+   GLboolean EXT_blend_color;

+   GLboolean EXT_blend_equation_separate;

+   GLboolean EXT_blend_func_separate;

+   GLboolean EXT_blend_logic_op;

+   GLboolean EXT_blend_minmax;

+   GLboolean EXT_blend_subtract;

+   GLboolean EXT_clip_volume_hint;

+   GLboolean EXT_compiled_vertex_array;

+   GLboolean EXT_copy_texture;

+   GLboolean EXT_depth_bounds_test;

+   GLboolean EXT_draw_buffers2;

+   GLboolean EXT_draw_range_elements;

+   GLboolean EXT_fog_coord;

+   GLboolean EXT_framebuffer_blit;

+   GLboolean EXT_framebuffer_multisample;

+   GLboolean EXT_framebuffer_object;

+   GLboolean EXT_framebuffer_sRGB;

+   GLboolean EXT_gpu_program_parameters;

+   GLboolean EXT_gpu_shader4;

+   GLboolean EXT_multi_draw_arrays;

+   GLboolean EXT_paletted_texture;

+   GLboolean EXT_packed_depth_stencil;

+   GLboolean EXT_packed_float;

+   GLboolean EXT_packed_pixels;

+   GLboolean EXT_pixel_buffer_object;

+   GLboolean EXT_point_parameters;

+   GLboolean EXT_polygon_offset;

+   GLboolean EXT_provoking_vertex;

+   GLboolean EXT_rescale_normal;

+   GLboolean EXT_shadow_funcs;

+   GLboolean EXT_secondary_color;

+   GLboolean EXT_separate_shader_objects;

+   GLboolean EXT_separate_specular_color;

+   GLboolean EXT_shared_texture_palette;

+   GLboolean EXT_stencil_wrap;

+   GLboolean EXT_stencil_two_side;

+   GLboolean EXT_subtexture;

+   GLboolean EXT_texture;

+   GLboolean EXT_texture_object;

+   GLboolean EXT_texture3D;

+   GLboolean EXT_texture_array;

+   GLboolean EXT_texture_compression_latc;

+   GLboolean EXT_texture_compression_s3tc;

+   GLboolean EXT_texture_env_add;

+   GLboolean EXT_texture_env_combine;

+   GLboolean EXT_texture_env_dot3;

+   GLboolean EXT_texture_filter_anisotropic;

+   GLboolean EXT_texture_integer;

+   GLboolean EXT_texture_lod_bias;

+   GLboolean EXT_texture_mirror_clamp;

+   GLboolean EXT_texture_shared_exponent;

+   GLboolean EXT_texture_sRGB;

+   GLboolean EXT_texture_sRGB_decode;

+   GLboolean EXT_texture_swizzle;

+   GLboolean EXT_transform_feedback;

+   GLboolean EXT_timer_query;

+   GLboolean EXT_vertex_array;

+   GLboolean EXT_vertex_array_bgra;

+   GLboolean EXT_vertex_array_set;

+   GLboolean OES_standard_derivatives;

+   /* vendor extensions */

+   GLboolean AMD_conservative_depth;

+   GLboolean APPLE_client_storage;

+   GLboolean APPLE_packed_pixels;

+   GLboolean APPLE_vertex_array_object;

+   GLboolean APPLE_object_purgeable;

+   GLboolean ATI_envmap_bumpmap;

+   GLboolean ATI_texture_compression_3dc;

+   GLboolean ATI_texture_mirror_once;

+   GLboolean ATI_texture_env_combine3;

+   GLboolean ATI_fragment_shader;

+   GLboolean ATI_separate_stencil;

+   GLboolean IBM_rasterpos_clip;

+   GLboolean IBM_multimode_draw_arrays;

+   GLboolean MESA_pack_invert;

+   GLboolean MESA_resize_buffers;

+   GLboolean MESA_ycbcr_texture;

+   GLboolean MESA_texture_array;

+   GLboolean MESA_texture_signed_rgba;

+   GLboolean NV_blend_square;

+   GLboolean NV_conditional_render;

+   GLboolean NV_fragment_program;

+   GLboolean NV_fragment_program_option;

+   GLboolean NV_light_max_exponent;

+   GLboolean NV_point_sprite;

+   GLboolean NV_primitive_restart;

+   GLboolean NV_texgen_reflection;

+   GLboolean NV_texture_env_combine4;

+   GLboolean NV_texture_rectangle;

+   GLboolean NV_vertex_program;

+   GLboolean NV_vertex_program1_1;

+   GLboolean OES_read_format;

+   GLboolean SGIS_generate_mipmap;

+   GLboolean SGIS_texture_edge_clamp;

+   GLboolean SGIS_texture_lod;

+   GLboolean TDFX_texture_compression_FXT1;

+   GLboolean S3_s3tc;

+   GLboolean OES_EGL_image;

+   GLboolean OES_draw_texture;

+   GLboolean EXT_texture_format_BGRA8888;

+   GLboolean extension_sentinel;

+   /** The extension string */

+   const GLubyte *String;

+   /** Number of supported extensions */

+   GLuint Count;

+};

+

+

+/**

+ * A stack of matrices (projection, modelview, color, texture, etc).

+ */

+struct gl_matrix_stack

+{

+   GLmatrix *Top;      /**< points into Stack */

+   GLmatrix *Stack;    /**< array [MaxDepth] of GLmatrix */

+   GLuint Depth;       /**< 0 <= Depth < MaxDepth */

+   GLuint MaxDepth;    /**< size of Stack[] array */

+   GLuint DirtyFlag;   /**< _NEW_MODELVIEW or _NEW_PROJECTION, for example */

+};

+

+

+/**

+ * \name Bits for image transfer operations 

+ * \sa __struct gl_contextRec::ImageTransferState.

+ */

+/*@{*/

+#define IMAGE_SCALE_BIAS_BIT                      0x1

+#define IMAGE_SHIFT_OFFSET_BIT                    0x2

+#define IMAGE_MAP_COLOR_BIT                       0x4

+#define IMAGE_CLAMP_BIT                           0x800

+

+

+/** Pixel Transfer ops */

+#define IMAGE_BITS (IMAGE_SCALE_BIAS_BIT |			\

+		    IMAGE_SHIFT_OFFSET_BIT |			\

+		    IMAGE_MAP_COLOR_BIT)

+

+/**

+ * \name Bits to indicate what state has changed.  

+ */

+/*@{*/

+#define _NEW_MODELVIEW         (1 << 0)   /**< gl_context::ModelView */

+#define _NEW_PROJECTION        (1 << 1)   /**< gl_context::Projection */

+#define _NEW_TEXTURE_MATRIX    (1 << 2)   /**< gl_context::TextureMatrix */

+#define _NEW_COLOR             (1 << 3)   /**< gl_context::Color */

+#define _NEW_DEPTH             (1 << 4)   /**< gl_context::Depth */

+#define _NEW_EVAL              (1 << 5)   /**< gl_context::Eval, EvalMap */

+#define _NEW_FOG               (1 << 6)   /**< gl_context::Fog */

+#define _NEW_HINT              (1 << 7)   /**< gl_context::Hint */

+#define _NEW_LIGHT             (1 << 8)   /**< gl_context::Light */

+#define _NEW_LINE              (1 << 9)   /**< gl_context::Line */

+#define _NEW_PIXEL             (1 << 10)  /**< gl_context::Pixel */

+#define _NEW_POINT             (1 << 11)  /**< gl_context::Point */

+#define _NEW_POLYGON           (1 << 12)  /**< gl_context::Polygon */

+#define _NEW_POLYGONSTIPPLE    (1 << 13)  /**< gl_context::PolygonStipple */

+#define _NEW_SCISSOR           (1 << 14)  /**< gl_context::Scissor */

+#define _NEW_STENCIL           (1 << 15)  /**< gl_context::Stencil */

+#define _NEW_TEXTURE           (1 << 16)  /**< gl_context::Texture */

+#define _NEW_TRANSFORM         (1 << 17)  /**< gl_context::Transform */

+#define _NEW_VIEWPORT          (1 << 18)  /**< gl_context::Viewport */

+#define _NEW_PACKUNPACK        (1 << 19)  /**< gl_context::Pack, Unpack */

+#define _NEW_ARRAY             (1 << 20)  /**< gl_context::Array */

+#define _NEW_RENDERMODE        (1 << 21)  /**< gl_context::RenderMode, etc */

+#define _NEW_BUFFERS           (1 << 22)  /**< gl_context::Visual, DrawBuffer, */

+#define _NEW_CURRENT_ATTRIB    (1 << 23)  /**< gl_context::Current */

+#define _NEW_MULTISAMPLE       (1 << 24)  /**< gl_context::Multisample */

+#define _NEW_TRACK_MATRIX      (1 << 25)  /**< gl_context::VertexProgram */

+#define _NEW_PROGRAM           (1 << 26)  /**< New program/shader state */

+#define _NEW_PROGRAM_CONSTANTS (1 << 27)

+#define _NEW_BUFFER_OBJECT     (1 << 28)

+#define _NEW_ALL ~0

+/*@}*/

+

+

+/**

+ * \name Bits to track array state changes 

+ *

+ * Also used to summarize array enabled.

+ */

+/*@{*/

+#define _NEW_ARRAY_VERTEX           VERT_BIT_POS

+#define _NEW_ARRAY_WEIGHT           VERT_BIT_WEIGHT

+#define _NEW_ARRAY_NORMAL           VERT_BIT_NORMAL

+#define _NEW_ARRAY_COLOR0           VERT_BIT_COLOR0

+#define _NEW_ARRAY_COLOR1           VERT_BIT_COLOR1

+#define _NEW_ARRAY_FOGCOORD         VERT_BIT_FOG

+#define _NEW_ARRAY_INDEX            VERT_BIT_COLOR_INDEX

+#define _NEW_ARRAY_EDGEFLAG         VERT_BIT_EDGEFLAG

+#define _NEW_ARRAY_POINT_SIZE       VERT_BIT_COLOR_INDEX  /* aliased */

+#define _NEW_ARRAY_TEXCOORD_0       VERT_BIT_TEX0

+#define _NEW_ARRAY_TEXCOORD_1       VERT_BIT_TEX1

+#define _NEW_ARRAY_TEXCOORD_2       VERT_BIT_TEX2

+#define _NEW_ARRAY_TEXCOORD_3       VERT_BIT_TEX3

+#define _NEW_ARRAY_TEXCOORD_4       VERT_BIT_TEX4

+#define _NEW_ARRAY_TEXCOORD_5       VERT_BIT_TEX5

+#define _NEW_ARRAY_TEXCOORD_6       VERT_BIT_TEX6

+#define _NEW_ARRAY_TEXCOORD_7       VERT_BIT_TEX7

+#define _NEW_ARRAY_ATTRIB_0         VERT_BIT_GENERIC0  /* start at bit 16 */

+#define _NEW_ARRAY_ALL              0xffffffff

+

+

+#define _NEW_ARRAY_TEXCOORD(i) (_NEW_ARRAY_TEXCOORD_0 << (i))

+#define _NEW_ARRAY_ATTRIB(i) (_NEW_ARRAY_ATTRIB_0 << (i))

+/*@}*/

+

+

+

+/**

+ * \name A bunch of flags that we think might be useful to drivers.

+ * 

+ * Set in the __struct gl_contextRec::_TriangleCaps bitfield.

+ */

+/*@{*/

+#define DD_FLATSHADE                0x1

+#define DD_SEPARATE_SPECULAR        0x2

+#define DD_TRI_CULL_FRONT_BACK      0x4 /* special case on some hw */

+#define DD_TRI_LIGHT_TWOSIDE        0x8

+#define DD_TRI_UNFILLED             0x10

+#define DD_TRI_SMOOTH               0x20

+#define DD_TRI_STIPPLE              0x40

+#define DD_TRI_OFFSET               0x80

+#define DD_LINE_SMOOTH              0x100

+#define DD_LINE_STIPPLE             0x200

+#define DD_POINT_SMOOTH             0x400

+#define DD_POINT_ATTEN              0x800

+#define DD_TRI_TWOSTENCIL           0x1000

+/*@}*/

+

+

+/**

+ * \name Define the state changes under which each of these bits might change

+ */

+/*@{*/

+#define _DD_NEW_FLATSHADE                _NEW_LIGHT

+#define _DD_NEW_SEPARATE_SPECULAR        (_NEW_LIGHT | _NEW_FOG | _NEW_PROGRAM)

+#define _DD_NEW_TRI_CULL_FRONT_BACK      _NEW_POLYGON

+#define _DD_NEW_TRI_LIGHT_TWOSIDE        _NEW_LIGHT

+#define _DD_NEW_TRI_UNFILLED             _NEW_POLYGON

+#define _DD_NEW_TRI_SMOOTH               _NEW_POLYGON

+#define _DD_NEW_TRI_STIPPLE              _NEW_POLYGON

+#define _DD_NEW_TRI_OFFSET               _NEW_POLYGON

+#define _DD_NEW_LINE_SMOOTH              _NEW_LINE

+#define _DD_NEW_LINE_STIPPLE             _NEW_LINE

+#define _DD_NEW_LINE_WIDTH               _NEW_LINE

+#define _DD_NEW_POINT_SMOOTH             _NEW_POINT

+#define _DD_NEW_POINT_SIZE               _NEW_POINT

+#define _DD_NEW_POINT_ATTEN              _NEW_POINT

+/*@}*/

+

+

+/**

+ * Composite state flags

+ */

+/*@{*/

+#define _MESA_NEW_NEED_EYE_COORDS         (_NEW_LIGHT |		\

+                                           _NEW_TEXTURE |	\

+                                           _NEW_POINT |		\

+                                           _NEW_PROGRAM |	\

+                                           _NEW_MODELVIEW)

+

+#define _MESA_NEW_NEED_NORMALS            (_NEW_LIGHT |		\

+                                           _NEW_TEXTURE)

+

+#define _MESA_NEW_TRANSFER_STATE          (_NEW_PIXEL)

+/*@}*/

+

+

+

+

+/* This has to be included here. */

+#include "dd.h"

+

+

+/**

+ * Display list flags.

+ * Strictly this is a tnl-private concept, but it doesn't seem

+ * worthwhile adding a tnl private structure just to hold this one bit

+ * of information:

+ */

+#define DLIST_DANGLING_REFS     0x1 

+

+

+/** Opaque declaration of display list payload data type */

+union gl_dlist_node;

+

+

+/**

+ * Provide a location where information about a display list can be

+ * collected.  Could be extended with driverPrivate structures,

+ * etc. in the future.

+ */

+struct gl_display_list

+{

+   GLuint Name;

+   GLbitfield Flags;  /**< DLIST_x flags */

+   /** The dlist commands are in a linked list of nodes */

+   union gl_dlist_node *Head;

+};

+

+

+/**

+ * State used during display list compilation and execution.

+ */

+struct gl_dlist_state

+{

+   GLuint CallDepth;		/**< Current recursion calling depth */

+

+   struct gl_display_list *CurrentList; /**< List currently being compiled */

+   union gl_dlist_node *CurrentBlock; /**< Pointer to current block of nodes */

+   GLuint CurrentPos;		/**< Index into current block of nodes */

+

+   GLvertexformat ListVtxfmt;

+

+   GLubyte ActiveAttribSize[VERT_ATTRIB_MAX];

+   GLfloat CurrentAttrib[VERT_ATTRIB_MAX][4];

+   

+   GLubyte ActiveMaterialSize[MAT_ATTRIB_MAX];

+   GLfloat CurrentMaterial[MAT_ATTRIB_MAX][4];

+

+   GLubyte ActiveIndex;

+   GLfloat CurrentIndex;

+   

+   GLubyte ActiveEdgeFlag;

+   GLboolean CurrentEdgeFlag;

+

+   struct {

+      /* State known to have been set by the currently-compiling display

+       * list.  Used to eliminate some redundant state changes.

+       */

+      GLenum ShadeModel;

+   } Current;

+};

+

+

+/**

+ * Enum for the OpenGL APIs we know about and may support.

+ */

+typedef enum

+{

+   API_OPENGL,

+   API_OPENGLES,

+   API_OPENGLES2

+} gl_api;

+

+

+/**

+ * Mesa rendering context.

+ *

+ * This is the central context data structure for Mesa.  Almost all

+ * OpenGL state is contained in this structure.

+ * Think of this as a base class from which device drivers will derive

+ * sub classes.

+ *

+ * The struct gl_context typedef names this structure.

+ */

+struct gl_context

+{

+   /** State possibly shared with other contexts in the address space */

+   struct gl_shared_state *Shared;

+

+   /** \name API function pointer tables */

+   /*@{*/

+   gl_api API;

+   struct _glapi_table *Save;	/**< Display list save functions */

+   struct _glapi_table *Exec;	/**< Execute functions */

+   struct _glapi_table *CurrentDispatch;  /**< == Save or Exec !! */

+   /*@}*/

+

+   struct gl_config Visual;

+   struct gl_framebuffer *DrawBuffer;	/**< buffer for writing */

+   struct gl_framebuffer *ReadBuffer;	/**< buffer for reading */

+   struct gl_framebuffer *WinSysDrawBuffer;  /**< set with MakeCurrent */

+   struct gl_framebuffer *WinSysReadBuffer;  /**< set with MakeCurrent */

+

+   /**

+    * Device driver function pointer table

+    */

+   struct dd_function_table Driver;

+

+   void *DriverCtx;	/**< Points to device driver context/state */

+

+   /** Core/Driver constants */

+   struct gl_constants Const;

+

+   /** \name The various 4x4 matrix stacks */

+   /*@{*/

+   struct gl_matrix_stack ModelviewMatrixStack;

+   struct gl_matrix_stack ProjectionMatrixStack;

+   struct gl_matrix_stack TextureMatrixStack[MAX_TEXTURE_UNITS];

+   struct gl_matrix_stack ProgramMatrixStack[MAX_PROGRAM_MATRICES];

+   struct gl_matrix_stack *CurrentStack; /**< Points to one of the above stacks */

+   /*@}*/

+

+   /** Combined modelview and projection matrix */

+   GLmatrix _ModelProjectMatrix;

+

+   /** \name Display lists */

+   struct gl_dlist_state ListState;

+

+   GLboolean ExecuteFlag;	/**< Execute GL commands? */

+   GLboolean CompileFlag;	/**< Compile GL commands into display list? */

+

+   /** Extension information */

+   struct gl_extensions Extensions;

+

+   /** Version info */

+   GLuint VersionMajor, VersionMinor;

+   char *VersionString;

+

+   /** \name State attribute stack (for glPush/PopAttrib) */

+   /*@{*/

+   GLuint AttribStackDepth;

+   struct gl_attrib_node *AttribStack[MAX_ATTRIB_STACK_DEPTH];

+   /*@}*/

+

+   /** \name Renderer attribute groups

+    * 

+    * We define a struct for each attribute group to make pushing and popping

+    * attributes easy.  Also it's a good organization.

+    */

+   /*@{*/

+   struct gl_accum_attrib	Accum;		/**< Accum buffer attributes */

+   struct gl_colorbuffer_attrib	Color;		/**< Color buffer attributes */

+   struct gl_current_attrib	Current;	/**< Current attributes */

+   struct gl_depthbuffer_attrib	Depth;		/**< Depth buffer attributes */

+   struct gl_eval_attrib	Eval;		/**< Eval attributes */

+   struct gl_fog_attrib		Fog;		/**< Fog attributes */

+   struct gl_hint_attrib	Hint;		/**< Hint attributes */

+   struct gl_light_attrib	Light;		/**< Light attributes */

+   struct gl_line_attrib	Line;		/**< Line attributes */

+   struct gl_list_attrib	List;		/**< List attributes */

+   struct gl_multisample_attrib Multisample;

+   struct gl_pixel_attrib	Pixel;		/**< Pixel attributes */

+   struct gl_point_attrib	Point;		/**< Point attributes */

+   struct gl_polygon_attrib	Polygon;	/**< Polygon attributes */

+   GLuint PolygonStipple[32];			/**< Polygon stipple */

+   struct gl_scissor_attrib	Scissor;	/**< Scissor attributes */

+   struct gl_stencil_attrib	Stencil;	/**< Stencil buffer attributes */

+   struct gl_texture_attrib	Texture;	/**< Texture attributes */

+   struct gl_transform_attrib	Transform;	/**< Transformation attributes */

+   struct gl_viewport_attrib	Viewport;	/**< Viewport attributes */

+   /*@}*/

+

+   /** \name Client attribute stack */

+   /*@{*/

+   GLuint ClientAttribStackDepth;

+   struct gl_attrib_node *ClientAttribStack[MAX_CLIENT_ATTRIB_STACK_DEPTH];

+   /*@}*/

+

+   /** \name Client attribute groups */

+   /*@{*/

+   struct gl_array_attrib	Array;	/**< Vertex arrays */

+   struct gl_pixelstore_attrib	Pack;	/**< Pixel packing */

+   struct gl_pixelstore_attrib	Unpack;	/**< Pixel unpacking */

+   struct gl_pixelstore_attrib	DefaultPacking;	/**< Default params */

+   /*@}*/

+

+   /** \name Other assorted state (not pushed/popped on attribute stack) */

+   /*@{*/

+   struct gl_pixelmaps          PixelMaps;

+

+   struct gl_evaluators EvalMap;   /**< All evaluators */

+   struct gl_feedback   Feedback;  /**< Feedback */

+   struct gl_selection  Select;    /**< Selection */

+

+   struct gl_program_state Program;  /**< general program state */

+   struct gl_vertex_program_state VertexProgram;

+   struct gl_fragment_program_state FragmentProgram;

+   struct gl_geometry_program_state GeometryProgram;

+   struct gl_ati_fragment_shader_state ATIFragmentShader;

+

+   struct gl_shader_state Shader; /**< GLSL shader object state */

+   struct gl_shader_compiler_options ShaderCompilerOptions[MESA_SHADER_TYPES];

+

+   struct gl_query_state Query;  /**< occlusion, timer queries */

+

+   struct gl_transform_feedback TransformFeedback;

+

+   struct gl_buffer_object *CopyReadBuffer; /**< GL_ARB_copy_buffer */

+   struct gl_buffer_object *CopyWriteBuffer; /**< GL_ARB_copy_buffer */

+   /*@}*/

+

+   struct gl_meta_state *Meta;  /**< for "meta" operations */

+

+   /* GL_EXT_framebuffer_object */

+   struct gl_renderbuffer *CurrentRenderbuffer;

+

+   GLenum ErrorValue;        /**< Last error code */

+

+   /**

+    * Recognize and silence repeated error debug messages in buggy apps.

+    */

+   const char *ErrorDebugFmtString;

+   GLuint ErrorDebugCount;

+

+   GLenum RenderMode;        /**< either GL_RENDER, GL_SELECT, GL_FEEDBACK */

+   GLbitfield NewState;      /**< bitwise-or of _NEW_* flags */

+

+   GLboolean ViewportInitialized;  /**< has viewport size been initialized? */

+

+   GLbitfield varying_vp_inputs;  /**< mask of VERT_BIT_* flags */

+

+   /** \name Derived state */

+   /*@{*/

+   /** Bitwise-or of DD_* flags.  Note that this bitfield may be used before

+    * state validation so they need to always be current.

+    */

+   GLbitfield _TriangleCaps;

+   GLbitfield _ImageTransferState;/**< bitwise-or of IMAGE_*_BIT flags */

+   GLfloat _EyeZDir[3];

+   GLfloat _ModelViewInvScale;

+   GLboolean _NeedEyeCoords;

+   GLboolean _ForceEyeCoords; 

+

+   GLuint TextureStateTimestamp; /**< detect changes to shared state */

+

+   struct gl_shine_tab *_ShineTable[2]; /**< Active shine tables */

+   struct gl_shine_tab *_ShineTabList;  /**< MRU list of inactive shine tables */

+   /**@}*/

+

+   struct gl_list_extensions *ListExt; /**< driver dlist extensions */

+

+   /** \name For debugging/development only */

+   /*@{*/

+   GLboolean FirstTimeCurrent;

+   /*@}*/

+

+   /** software compression/decompression supported or not */

+   GLboolean Mesa_DXTn;

+

+   GLboolean TextureFormatSupported[MESA_FORMAT_COUNT];

+

+   /** 

+    * Use dp4 (rather than mul/mad) instructions for position

+    * transformation?

+    */

+   GLboolean mvp_with_dp4;

+

+   /**

+    * \name Hooks for module contexts.  

+    *

+    * These will eventually live in the driver or elsewhere.

+    */

+   /*@{*/

+   void *swrast_context;

+   void *swsetup_context;

+   void *swtnl_context;

+   void *swtnl_im;

+   struct st_context *st;

+   void *aelt_context;

+   /*@}*/

+};

+

+

+#ifdef DEBUG

+extern int MESA_VERBOSE;

+extern int MESA_DEBUG_FLAGS;

+# define MESA_FUNCTION __FUNCTION__

+#else

+# define MESA_VERBOSE 0

+# define MESA_DEBUG_FLAGS 0

+# define MESA_FUNCTION "a function"

+# ifndef NDEBUG

+#  define NDEBUG

+# endif

+#endif

+

+

+/** The MESA_VERBOSE var is a bitmask of these flags */

+enum _verbose

+{

+   VERBOSE_VARRAY		= 0x0001,

+   VERBOSE_TEXTURE		= 0x0002,

+   VERBOSE_MATERIAL		= 0x0004,

+   VERBOSE_PIPELINE		= 0x0008,

+   VERBOSE_DRIVER		= 0x0010,

+   VERBOSE_STATE		= 0x0020,

+   VERBOSE_API			= 0x0040,

+   VERBOSE_DISPLAY_LIST		= 0x0100,

+   VERBOSE_LIGHTING		= 0x0200,

+   VERBOSE_PRIMS		= 0x0400,

+   VERBOSE_VERTS		= 0x0800,

+   VERBOSE_DISASSEM		= 0x1000,

+   VERBOSE_DRAW                 = 0x2000,

+   VERBOSE_SWAPBUFFERS          = 0x4000

+};

+

+

+/** The MESA_DEBUG_FLAGS var is a bitmask of these flags */

+enum _debug

+{

+   DEBUG_ALWAYS_FLUSH		= 0x1

+};

+

+

+

+#endif /* MTYPES_H */

diff --git a/mesalib/src/mesa/main/queryobj.c b/mesalib/src/mesa/main/queryobj.c
index fa35c6ce5..25ec31fd4 100644
--- a/mesalib/src/mesa/main/queryobj.c
+++ b/mesalib/src/mesa/main/queryobj.c
@@ -1,623 +1,624 @@
-/*
- * Mesa 3-D graphics library
- * Version:  7.1
- *
- * Copyright (C) 1999-2007  Brian Paul   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.
- */
-
-
-#include "glheader.h"
-#include "context.h"
-#include "enums.h"
-#include "hash.h"
-#include "imports.h"
-#include "queryobj.h"
-#include "mfeatures.h"
-#include "mtypes.h"
-#include "main/dispatch.h"
-
-
-#if FEATURE_queryobj
-
-
-/**
- * Allocate a new query object.  This is a fallback routine called via
- * ctx->Driver.NewQueryObject().
- * \param ctx - rendering context
- * \param id - the new object's ID
- * \return pointer to new query_object object or NULL if out of memory.
- */
-static struct gl_query_object *
-_mesa_new_query_object(struct gl_context *ctx, GLuint id)
-{
-   struct gl_query_object *q = MALLOC_STRUCT(gl_query_object);
-   (void) ctx;
-   if (q) {
-      q->Id = id;
-      q->Result = 0;
-      q->Active = GL_FALSE;
-      q->Ready = GL_TRUE;   /* correct, see spec */
-   }
-   return q;
-}
-
-
-/**
- * Begin a query.  Software driver fallback.
- * Called via ctx->Driver.BeginQuery().
- */
-static void
-_mesa_begin_query(struct gl_context *ctx, struct gl_query_object *q)
-{
-   /* no-op */
-}
-
-
-/**
- * End a query.  Software driver fallback.
- * Called via ctx->Driver.EndQuery().
- */
-static void
-_mesa_end_query(struct gl_context *ctx, struct gl_query_object *q)
-{
-   q->Ready = GL_TRUE;
-}
-
-
-/**
- * Wait for query to complete.  Software driver fallback.
- * Called via ctx->Driver.WaitQuery().
- */
-static void
-_mesa_wait_query(struct gl_context *ctx, struct gl_query_object *q)
-{
-   /* For software drivers, _mesa_end_query() should have completed the query.
-    * For real hardware, implement a proper WaitQuery() driver function,
-    * which may require issuing a flush.
-    */
-   assert(q->Ready);
-}
-
-
-/**
- * Check if a query results are ready.  Software driver fallback.
- * Called via ctx->Driver.CheckQuery().
- */
-static void
-_mesa_check_query(struct gl_context *ctx, struct gl_query_object *q)
-{
-   /* No-op for sw rendering.
-    * HW drivers may need to flush at this time.
-    */
-}
-
-
-/**
- * Delete a query object.  Called via ctx->Driver.DeleteQuery().
- * Not removed from hash table here.
- */
-static void
-_mesa_delete_query(struct gl_context *ctx, struct gl_query_object *q)
-{
-   free(q);
-}
-
-
-void
-_mesa_init_query_object_functions(struct dd_function_table *driver)
-{
-   driver->NewQueryObject = _mesa_new_query_object;
-   driver->DeleteQuery = _mesa_delete_query;
-   driver->BeginQuery = _mesa_begin_query;
-   driver->EndQuery = _mesa_end_query;
-   driver->WaitQuery = _mesa_wait_query;
-   driver->CheckQuery = _mesa_check_query;
-}
-
-
-/**
- * Return pointer to the query object binding point for the given target.
- * \return NULL if invalid target, else the address of binding point
- */
-static struct gl_query_object **
-get_query_binding_point(struct gl_context *ctx, GLenum target)
-{
-   switch (target) {
-   case GL_SAMPLES_PASSED_ARB:
-      if (ctx->Extensions.ARB_occlusion_query)
-         return &ctx->Query.CurrentOcclusionObject;
-      else
-         return NULL;
-   case GL_ANY_SAMPLES_PASSED:
-      if (ctx->Extensions.ARB_occlusion_query2)
-         return &ctx->Query.CurrentOcclusionObject;
-      else
-         return NULL;
-   case GL_TIME_ELAPSED_EXT:
-      if (ctx->Extensions.EXT_timer_query)
-         return &ctx->Query.CurrentTimerObject;
-      else
-         return NULL;
-#if FEATURE_EXT_transform_feedback
-   case GL_PRIMITIVES_GENERATED:
-      if (ctx->Extensions.EXT_transform_feedback)
-         return &ctx->Query.PrimitivesGenerated;
-      else
-         return NULL;
-   case GL_TRANSFORM_FEEDBACK_PRIMITIVES_WRITTEN:
-      if (ctx->Extensions.EXT_transform_feedback)
-         return &ctx->Query.PrimitivesWritten;
-      else
-         return NULL;
-#endif
-   default:
-      return NULL;
-   }
-}
-
-
-void GLAPIENTRY
-_mesa_GenQueriesARB(GLsizei n, GLuint *ids)
-{
-   GLuint first;
-   GET_CURRENT_CONTEXT(ctx);
-   ASSERT_OUTSIDE_BEGIN_END(ctx);
-
-   if (MESA_VERBOSE & VERBOSE_API)
-      _mesa_debug(ctx, "glGenQueries(%d)\n", n);
-
-   if (n < 0) {
-      _mesa_error(ctx, GL_INVALID_VALUE, "glGenQueriesARB(n < 0)");
-      return;
-   }
-
-   /* No query objects can be active at this time! */
-   if (ctx->Query.CurrentOcclusionObject ||
-       ctx->Query.CurrentTimerObject) {
-      _mesa_error(ctx, GL_INVALID_OPERATION, "glGenQueriesARB");
-      return;
-   }
-
-   first = _mesa_HashFindFreeKeyBlock(ctx->Query.QueryObjects, n);
-   if (first) {
-      GLsizei i;
-      for (i = 0; i < n; i++) {
-         struct gl_query_object *q
-            = ctx->Driver.NewQueryObject(ctx, first + i);
-         if (!q) {
-            _mesa_error(ctx, GL_OUT_OF_MEMORY, "glGenQueriesARB");
-            return;
-         }
-         ids[i] = first + i;
-         _mesa_HashInsert(ctx->Query.QueryObjects, first + i, q);
-      }
-   }
-}
-
-
-void GLAPIENTRY
-_mesa_DeleteQueriesARB(GLsizei n, const GLuint *ids)
-{
-   GLint i;
-   GET_CURRENT_CONTEXT(ctx);
-   ASSERT_OUTSIDE_BEGIN_END(ctx);
-
-   if (MESA_VERBOSE & VERBOSE_API)
-      _mesa_debug(ctx, "glDeleeteQueries(%d)\n", n);
-
-   if (n < 0) {
-      _mesa_error(ctx, GL_INVALID_VALUE, "glDeleteQueriesARB(n < 0)");
-      return;
-   }
-
-   /* No query objects can be active at this time! */
-   if (ctx->Query.CurrentOcclusionObject ||
-       ctx->Query.CurrentTimerObject) {
-      _mesa_error(ctx, GL_INVALID_OPERATION, "glDeleteQueriesARB");
-      return;
-   }
-
-   for (i = 0; i < n; i++) {
-      if (ids[i] > 0) {
-         struct gl_query_object *q = _mesa_lookup_query_object(ctx, ids[i]);
-         if (q) {
-            ASSERT(!q->Active); /* should be caught earlier */
-            _mesa_HashRemove(ctx->Query.QueryObjects, ids[i]);
-            ctx->Driver.DeleteQuery(ctx, q);
-         }
-      }
-   }
-}
-
-
-GLboolean GLAPIENTRY
-_mesa_IsQueryARB(GLuint id)
-{
-   GET_CURRENT_CONTEXT(ctx);
-   ASSERT_OUTSIDE_BEGIN_END_WITH_RETVAL(ctx, GL_FALSE);
-
-   if (MESA_VERBOSE & VERBOSE_API)
-      _mesa_debug(ctx, "glIsQuery(%u)\n", id);
-
-   if (id && _mesa_lookup_query_object(ctx, id))
-      return GL_TRUE;
-   else
-      return GL_FALSE;
-}
-
-
-static void GLAPIENTRY
-_mesa_BeginQueryARB(GLenum target, GLuint id)
-{
-   struct gl_query_object *q, **bindpt;
-   GET_CURRENT_CONTEXT(ctx);
-   ASSERT_OUTSIDE_BEGIN_END(ctx);
-
-   if (MESA_VERBOSE & VERBOSE_API)
-      _mesa_debug(ctx, "glBeginQuery(%s, %u)\n",
-                  _mesa_lookup_enum_by_nr(target), id);
-
-   FLUSH_VERTICES(ctx, _NEW_DEPTH);
-
-   bindpt = get_query_binding_point(ctx, target);
-   if (!bindpt) {
-      _mesa_error(ctx, GL_INVALID_ENUM, "glBeginQueryARB(target)");
-      return;
-   }
-
-   if (id == 0) {
-      _mesa_error(ctx, GL_INVALID_OPERATION, "glBeginQueryARB(id==0)");
-      return;
-   }
-
-   q = _mesa_lookup_query_object(ctx, id);
-   if (!q) {
-      /* create new object */
-      q = ctx->Driver.NewQueryObject(ctx, id);
-      if (!q) {
-         _mesa_error(ctx, GL_OUT_OF_MEMORY, "glBeginQueryARB");
-         return;
-      }
-      _mesa_HashInsert(ctx->Query.QueryObjects, id, q);
-   }
-   else {
-      /* pre-existing object */
-      if (q->Active) {
-         _mesa_error(ctx, GL_INVALID_OPERATION,
-                     "glBeginQueryARB(query already active)");
-         return;
-      }
-   }
-
-   q->Target = target;
-   q->Active = GL_TRUE;
-   q->Result = 0;
-   q->Ready = GL_FALSE;
-
-   /* XXX should probably refcount query objects */
-   *bindpt = q;
-
-   ctx->Driver.BeginQuery(ctx, q);
-}
-
-
-static void GLAPIENTRY
-_mesa_EndQueryARB(GLenum target)
-{
-   struct gl_query_object *q, **bindpt;
-   GET_CURRENT_CONTEXT(ctx);
-   ASSERT_OUTSIDE_BEGIN_END(ctx);
-
-   if (MESA_VERBOSE & VERBOSE_API)
-      _mesa_debug(ctx, "glEndQuery(%s)\n", _mesa_lookup_enum_by_nr(target));
-
-   FLUSH_VERTICES(ctx, _NEW_DEPTH);
-
-   bindpt = get_query_binding_point(ctx, target);
-   if (!bindpt) {
-      _mesa_error(ctx, GL_INVALID_ENUM, "glEndQueryARB(target)");
-      return;
-   }
-
-   /* XXX should probably refcount query objects */
-   q = *bindpt;
-   *bindpt = NULL;
-
-   if (!q || !q->Active) {
-      _mesa_error(ctx, GL_INVALID_OPERATION,
-                  "glEndQueryARB(no matching glBeginQueryARB)");
-      return;
-   }
-
-   q->Active = GL_FALSE;
-   ctx->Driver.EndQuery(ctx, q);
-}
-
-
-void GLAPIENTRY
-_mesa_GetQueryivARB(GLenum target, GLenum pname, GLint *params)
-{
-   struct gl_query_object *q, **bindpt;
-   GET_CURRENT_CONTEXT(ctx);
-   ASSERT_OUTSIDE_BEGIN_END(ctx);
-
-   if (MESA_VERBOSE & VERBOSE_API)
-      _mesa_debug(ctx, "glGetQueryiv(%s, %s)\n",
-                  _mesa_lookup_enum_by_nr(target),
-                  _mesa_lookup_enum_by_nr(pname));
-
-   bindpt = get_query_binding_point(ctx, target);
-   if (!bindpt) {
-      _mesa_error(ctx, GL_INVALID_ENUM, "glGetQueryARB(target)");
-      return;
-   }
-
-   q = *bindpt;
-
-   switch (pname) {
-      case GL_QUERY_COUNTER_BITS_ARB:
-         *params = 8 * sizeof(q->Result);
-         break;
-      case GL_CURRENT_QUERY_ARB:
-         *params = q ? q->Id : 0;
-         break;
-      default:
-         _mesa_error(ctx, GL_INVALID_ENUM, "glGetQueryivARB(pname)");
-         return;
-   }
-}
-
-
-void GLAPIENTRY
-_mesa_GetQueryObjectivARB(GLuint id, GLenum pname, GLint *params)
-{
-   struct gl_query_object *q = NULL;
-   GET_CURRENT_CONTEXT(ctx);
-   ASSERT_OUTSIDE_BEGIN_END(ctx);
-
-   if (MESA_VERBOSE & VERBOSE_API)
-      _mesa_debug(ctx, "glGetQueryObjectiv(%u, %s)\n", id,
-                  _mesa_lookup_enum_by_nr(pname));
-
-   if (id)
-      q = _mesa_lookup_query_object(ctx, id);
-
-   if (!q || q->Active) {
-      _mesa_error(ctx, GL_INVALID_OPERATION,
-                  "glGetQueryObjectivARB(id=%d is invalid or active)", id);
-      return;
-   }
-
-   switch (pname) {
-      case GL_QUERY_RESULT_ARB:
-         if (!q->Ready)
-            ctx->Driver.WaitQuery(ctx, q);
-         /* if result is too large for returned type, clamp to max value */
-         if (q->Target == GL_ANY_SAMPLES_PASSED) {
-            if (q->Result)
-               *params = GL_TRUE;
-            else
-               *params = GL_FALSE;
-         } else {
-            if (q->Result > 0x7fffffff) {
-               *params = 0x7fffffff;
-            }
-            else {
-               *params = (GLint)q->Result;
-            }
-         }
-         break;
-      case GL_QUERY_RESULT_AVAILABLE_ARB:
-	 if (!q->Ready)
-	    ctx->Driver.CheckQuery( ctx, q );
-         *params = q->Ready;
-         break;
-      default:
-         _mesa_error(ctx, GL_INVALID_ENUM, "glGetQueryObjectivARB(pname)");
-         return;
-   }
-}
-
-
-void GLAPIENTRY
-_mesa_GetQueryObjectuivARB(GLuint id, GLenum pname, GLuint *params)
-{
-   struct gl_query_object *q = NULL;
-   GET_CURRENT_CONTEXT(ctx);
-   ASSERT_OUTSIDE_BEGIN_END(ctx);
-
-   if (MESA_VERBOSE & VERBOSE_API)
-      _mesa_debug(ctx, "glGetQueryObjectuiv(%u, %s)\n", id,
-                  _mesa_lookup_enum_by_nr(pname));
-
-   if (id)
-      q = _mesa_lookup_query_object(ctx, id);
-
-   if (!q || q->Active) {
-      _mesa_error(ctx, GL_INVALID_OPERATION,
-                  "glGetQueryObjectuivARB(id=%d is invalid or active)", id);
-      return;
-   }
-
-   switch (pname) {
-      case GL_QUERY_RESULT_ARB:
-         if (!q->Ready)
-            ctx->Driver.WaitQuery(ctx, q);
-         /* if result is too large for returned type, clamp to max value */
-         if (q->Target == GL_ANY_SAMPLES_PASSED) {
-            if (q->Result)
-               *params = GL_TRUE;
-            else
-               *params = GL_FALSE;
-         } else {
-            if (q->Result > 0xffffffff) {
-               *params = 0xffffffff;
-            }
-            else {
-               *params = (GLuint)q->Result;
-            }
-         }
-         break;
-      case GL_QUERY_RESULT_AVAILABLE_ARB:
-	 if (!q->Ready)
-	    ctx->Driver.CheckQuery( ctx, q );
-         *params = q->Ready;
-         break;
-      default:
-         _mesa_error(ctx, GL_INVALID_ENUM, "glGetQueryObjectuivARB(pname)");
-         return;
-   }
-}
-
-
-/**
- * New with GL_EXT_timer_query
- */
-static void GLAPIENTRY
-_mesa_GetQueryObjecti64vEXT(GLuint id, GLenum pname, GLint64EXT *params)
-{
-   struct gl_query_object *q = NULL;
-   GET_CURRENT_CONTEXT(ctx);
-   ASSERT_OUTSIDE_BEGIN_END(ctx);
-
-   if (MESA_VERBOSE & VERBOSE_API)
-      _mesa_debug(ctx, "glGetQueryObjecti64v(%u, %s)\n", id,
-                  _mesa_lookup_enum_by_nr(pname));
-
-   if (id)
-      q = _mesa_lookup_query_object(ctx, id);
-
-   if (!q || q->Active) {
-      _mesa_error(ctx, GL_INVALID_OPERATION,
-                  "glGetQueryObjectui64vARB(id=%d is invalid or active)", id);
-      return;
-   }
-
-   switch (pname) {
-      case GL_QUERY_RESULT_ARB:
-         if (!q->Ready)
-            ctx->Driver.WaitQuery(ctx, q);
-         *params = q->Result;
-         break;
-      case GL_QUERY_RESULT_AVAILABLE_ARB:
-	 if (!q->Ready)
-	    ctx->Driver.CheckQuery( ctx, q );
-         *params = q->Ready;
-         break;
-      default:
-         _mesa_error(ctx, GL_INVALID_ENUM, "glGetQueryObjecti64vARB(pname)");
-         return;
-   }
-}
-
-
-/**
- * New with GL_EXT_timer_query
- */
-static void GLAPIENTRY
-_mesa_GetQueryObjectui64vEXT(GLuint id, GLenum pname, GLuint64EXT *params)
-{
-   struct gl_query_object *q = NULL;
-   GET_CURRENT_CONTEXT(ctx);
-   ASSERT_OUTSIDE_BEGIN_END(ctx);
-
-   if (MESA_VERBOSE & VERBOSE_API)
-      _mesa_debug(ctx, "glGetQueryObjectui64v(%u, %s)\n", id,
-                  _mesa_lookup_enum_by_nr(pname));
-
-   if (id)
-      q = _mesa_lookup_query_object(ctx, id);
-
-   if (!q || q->Active) {
-      _mesa_error(ctx, GL_INVALID_OPERATION,
-                  "glGetQueryObjectuui64vARB(id=%d is invalid or active)", id);
-      return;
-   }
-
-   switch (pname) {
-      case GL_QUERY_RESULT_ARB:
-         if (!q->Ready)
-            ctx->Driver.WaitQuery(ctx, q);
-         *params = q->Result;
-         break;
-      case GL_QUERY_RESULT_AVAILABLE_ARB:
-	 if (!q->Ready)
-	    ctx->Driver.CheckQuery( ctx, q );
-         *params = q->Ready;
-         break;
-      default:
-         _mesa_error(ctx, GL_INVALID_ENUM, "glGetQueryObjectui64vARB(pname)");
-         return;
-   }
-}
-
-
-void
-_mesa_init_queryobj_dispatch(struct _glapi_table *disp)
-{
-   SET_GenQueriesARB(disp, _mesa_GenQueriesARB);
-   SET_DeleteQueriesARB(disp, _mesa_DeleteQueriesARB);
-   SET_IsQueryARB(disp, _mesa_IsQueryARB);
-   SET_BeginQueryARB(disp, _mesa_BeginQueryARB);
-   SET_EndQueryARB(disp, _mesa_EndQueryARB);
-   SET_GetQueryivARB(disp, _mesa_GetQueryivARB);
-   SET_GetQueryObjectivARB(disp, _mesa_GetQueryObjectivARB);
-   SET_GetQueryObjectuivARB(disp, _mesa_GetQueryObjectuivARB);
-
-   SET_GetQueryObjecti64vEXT(disp, _mesa_GetQueryObjecti64vEXT);
-   SET_GetQueryObjectui64vEXT(disp, _mesa_GetQueryObjectui64vEXT);
-}
-
-
-#endif /* FEATURE_queryobj */
-
-
-/**
- * Allocate/init the context state related to query objects.
- */
-void
-_mesa_init_queryobj(struct gl_context *ctx)
-{
-   ctx->Query.QueryObjects = _mesa_NewHashTable();
-   ctx->Query.CurrentOcclusionObject = NULL;
-}
-
-
-/**
- * Callback for deleting a query object.  Called by _mesa_HashDeleteAll().
- */
-static void
-delete_queryobj_cb(GLuint id, void *data, void *userData)
-{
-   struct gl_query_object *q= (struct gl_query_object *) data;
-   struct gl_context *ctx = (struct gl_context *)userData;
-   ctx->Driver.DeleteQuery(ctx, q);
-}
-
-
-/**
- * Free the context state related to query objects.
- */
-void
-_mesa_free_queryobj_data(struct gl_context *ctx)
-{
-   _mesa_HashDeleteAll(ctx->Query.QueryObjects, delete_queryobj_cb, ctx);
-   _mesa_DeleteHashTable(ctx->Query.QueryObjects);
-}
+/*

+ * Mesa 3-D graphics library

+ * Version:  7.1

+ *

+ * Copyright (C) 1999-2007  Brian Paul   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.

+ */

+

+

+#include "glheader.h"

+#include "context.h"

+#include "enums.h"

+#include "hash.h"

+#include "imports.h"

+#include "queryobj.h"

+#include "mfeatures.h"

+#include "mtypes.h"

+#include "main/dispatch.h"

+

+

+#if FEATURE_queryobj

+

+

+/**

+ * Allocate a new query object.  This is a fallback routine called via

+ * ctx->Driver.NewQueryObject().

+ * \param ctx - rendering context

+ * \param id - the new object's ID

+ * \return pointer to new query_object object or NULL if out of memory.

+ */

+static struct gl_query_object *

+_mesa_new_query_object(struct gl_context *ctx, GLuint id)

+{

+   struct gl_query_object *q = MALLOC_STRUCT(gl_query_object);

+   (void) ctx;

+   if (q) {

+      q->Id = id;

+      q->Result = 0;

+      q->Active = GL_FALSE;

+      q->Ready = GL_TRUE;   /* correct, see spec */

+   }

+   return q;

+}

+

+

+/**

+ * Begin a query.  Software driver fallback.

+ * Called via ctx->Driver.BeginQuery().

+ */

+static void

+_mesa_begin_query(struct gl_context *ctx, struct gl_query_object *q)

+{

+   /* no-op */

+}

+

+

+/**

+ * End a query.  Software driver fallback.

+ * Called via ctx->Driver.EndQuery().

+ */

+static void

+_mesa_end_query(struct gl_context *ctx, struct gl_query_object *q)

+{

+   q->Ready = GL_TRUE;

+}

+

+

+/**

+ * Wait for query to complete.  Software driver fallback.

+ * Called via ctx->Driver.WaitQuery().

+ */

+static void

+_mesa_wait_query(struct gl_context *ctx, struct gl_query_object *q)

+{

+   /* For software drivers, _mesa_end_query() should have completed the query.

+    * For real hardware, implement a proper WaitQuery() driver function,

+    * which may require issuing a flush.

+    */

+   assert(q->Ready);

+}

+

+

+/**

+ * Check if a query results are ready.  Software driver fallback.

+ * Called via ctx->Driver.CheckQuery().

+ */

+static void

+_mesa_check_query(struct gl_context *ctx, struct gl_query_object *q)

+{

+   /* No-op for sw rendering.

+    * HW drivers may need to flush at this time.

+    */

+}

+

+

+/**

+ * Delete a query object.  Called via ctx->Driver.DeleteQuery().

+ * Not removed from hash table here.

+ */

+static void

+_mesa_delete_query(struct gl_context *ctx, struct gl_query_object *q)

+{

+   free(q);

+}

+

+

+void

+_mesa_init_query_object_functions(struct dd_function_table *driver)

+{

+   driver->NewQueryObject = _mesa_new_query_object;

+   driver->DeleteQuery = _mesa_delete_query;

+   driver->BeginQuery = _mesa_begin_query;

+   driver->EndQuery = _mesa_end_query;

+   driver->WaitQuery = _mesa_wait_query;

+   driver->CheckQuery = _mesa_check_query;

+}

+

+

+/**

+ * Return pointer to the query object binding point for the given target.

+ * \return NULL if invalid target, else the address of binding point

+ */

+static struct gl_query_object **

+get_query_binding_point(struct gl_context *ctx, GLenum target)

+{

+   switch (target) {

+   case GL_SAMPLES_PASSED_ARB:

+      if (ctx->Extensions.ARB_occlusion_query)

+         return &ctx->Query.CurrentOcclusionObject;

+      else

+         return NULL;

+   case GL_ANY_SAMPLES_PASSED:

+      if (ctx->Extensions.ARB_occlusion_query2)

+         return &ctx->Query.CurrentOcclusionObject;

+      else

+         return NULL;

+   case GL_TIME_ELAPSED_EXT:

+      if (ctx->Extensions.EXT_timer_query)

+         return &ctx->Query.CurrentTimerObject;

+      else

+         return NULL;

+#if FEATURE_EXT_transform_feedback

+   case GL_PRIMITIVES_GENERATED:

+      if (ctx->Extensions.EXT_transform_feedback)

+         return &ctx->Query.PrimitivesGenerated;

+      else

+         return NULL;

+   case GL_TRANSFORM_FEEDBACK_PRIMITIVES_WRITTEN:

+      if (ctx->Extensions.EXT_transform_feedback)

+         return &ctx->Query.PrimitivesWritten;

+      else

+         return NULL;

+#endif

+   default:

+      return NULL;

+   }

+}

+

+

+void GLAPIENTRY

+_mesa_GenQueriesARB(GLsizei n, GLuint *ids)

+{

+   GLuint first;

+   GET_CURRENT_CONTEXT(ctx);

+   ASSERT_OUTSIDE_BEGIN_END(ctx);

+

+   if (MESA_VERBOSE & VERBOSE_API)

+      _mesa_debug(ctx, "glGenQueries(%d)\n", n);

+

+   if (n < 0) {

+      _mesa_error(ctx, GL_INVALID_VALUE, "glGenQueriesARB(n < 0)");

+      return;

+   }

+

+   /* No query objects can be active at this time! */

+   if (ctx->Query.CurrentOcclusionObject ||

+       ctx->Query.CurrentTimerObject) {

+      _mesa_error(ctx, GL_INVALID_OPERATION, "glGenQueriesARB");

+      return;

+   }

+

+   first = _mesa_HashFindFreeKeyBlock(ctx->Query.QueryObjects, n);

+   if (first) {

+      GLsizei i;

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

+         struct gl_query_object *q

+            = ctx->Driver.NewQueryObject(ctx, first + i);

+         if (!q) {

+            _mesa_error(ctx, GL_OUT_OF_MEMORY, "glGenQueriesARB");

+            return;

+         }

+         ids[i] = first + i;

+         _mesa_HashInsert(ctx->Query.QueryObjects, first + i, q);

+      }

+   }

+}

+

+

+void GLAPIENTRY

+_mesa_DeleteQueriesARB(GLsizei n, const GLuint *ids)

+{

+   GLint i;

+   GET_CURRENT_CONTEXT(ctx);

+   ASSERT_OUTSIDE_BEGIN_END(ctx);

+   FLUSH_VERTICES(ctx, 0);

+

+   if (MESA_VERBOSE & VERBOSE_API)

+      _mesa_debug(ctx, "glDeleeteQueries(%d)\n", n);

+

+   if (n < 0) {

+      _mesa_error(ctx, GL_INVALID_VALUE, "glDeleteQueriesARB(n < 0)");

+      return;

+   }

+

+   /* No query objects can be active at this time! */

+   if (ctx->Query.CurrentOcclusionObject ||

+       ctx->Query.CurrentTimerObject) {

+      _mesa_error(ctx, GL_INVALID_OPERATION, "glDeleteQueriesARB");

+      return;

+   }

+

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

+      if (ids[i] > 0) {

+         struct gl_query_object *q = _mesa_lookup_query_object(ctx, ids[i]);

+         if (q) {

+            ASSERT(!q->Active); /* should be caught earlier */

+            _mesa_HashRemove(ctx->Query.QueryObjects, ids[i]);

+            ctx->Driver.DeleteQuery(ctx, q);

+         }

+      }

+   }

+}

+

+

+GLboolean GLAPIENTRY

+_mesa_IsQueryARB(GLuint id)

+{

+   GET_CURRENT_CONTEXT(ctx);

+   ASSERT_OUTSIDE_BEGIN_END_WITH_RETVAL(ctx, GL_FALSE);

+

+   if (MESA_VERBOSE & VERBOSE_API)

+      _mesa_debug(ctx, "glIsQuery(%u)\n", id);

+

+   if (id && _mesa_lookup_query_object(ctx, id))

+      return GL_TRUE;

+   else

+      return GL_FALSE;

+}

+

+

+static void GLAPIENTRY

+_mesa_BeginQueryARB(GLenum target, GLuint id)

+{

+   struct gl_query_object *q, **bindpt;

+   GET_CURRENT_CONTEXT(ctx);

+   ASSERT_OUTSIDE_BEGIN_END(ctx);

+

+   if (MESA_VERBOSE & VERBOSE_API)

+      _mesa_debug(ctx, "glBeginQuery(%s, %u)\n",

+                  _mesa_lookup_enum_by_nr(target), id);

+

+   FLUSH_VERTICES(ctx, _NEW_DEPTH);

+

+   bindpt = get_query_binding_point(ctx, target);

+   if (!bindpt) {

+      _mesa_error(ctx, GL_INVALID_ENUM, "glBeginQueryARB(target)");

+      return;

+   }

+

+   if (id == 0) {

+      _mesa_error(ctx, GL_INVALID_OPERATION, "glBeginQueryARB(id==0)");

+      return;

+   }

+

+   q = _mesa_lookup_query_object(ctx, id);

+   if (!q) {

+      /* create new object */

+      q = ctx->Driver.NewQueryObject(ctx, id);

+      if (!q) {

+         _mesa_error(ctx, GL_OUT_OF_MEMORY, "glBeginQueryARB");

+         return;

+      }

+      _mesa_HashInsert(ctx->Query.QueryObjects, id, q);

+   }

+   else {

+      /* pre-existing object */

+      if (q->Active) {

+         _mesa_error(ctx, GL_INVALID_OPERATION,

+                     "glBeginQueryARB(query already active)");

+         return;

+      }

+   }

+

+   q->Target = target;

+   q->Active = GL_TRUE;

+   q->Result = 0;

+   q->Ready = GL_FALSE;

+

+   /* XXX should probably refcount query objects */

+   *bindpt = q;

+

+   ctx->Driver.BeginQuery(ctx, q);

+}

+

+

+static void GLAPIENTRY

+_mesa_EndQueryARB(GLenum target)

+{

+   struct gl_query_object *q, **bindpt;

+   GET_CURRENT_CONTEXT(ctx);

+   ASSERT_OUTSIDE_BEGIN_END(ctx);

+

+   if (MESA_VERBOSE & VERBOSE_API)

+      _mesa_debug(ctx, "glEndQuery(%s)\n", _mesa_lookup_enum_by_nr(target));

+

+   FLUSH_VERTICES(ctx, _NEW_DEPTH);

+

+   bindpt = get_query_binding_point(ctx, target);

+   if (!bindpt) {

+      _mesa_error(ctx, GL_INVALID_ENUM, "glEndQueryARB(target)");

+      return;

+   }

+

+   /* XXX should probably refcount query objects */

+   q = *bindpt;

+   *bindpt = NULL;

+

+   if (!q || !q->Active) {

+      _mesa_error(ctx, GL_INVALID_OPERATION,

+                  "glEndQueryARB(no matching glBeginQueryARB)");

+      return;

+   }

+

+   q->Active = GL_FALSE;

+   ctx->Driver.EndQuery(ctx, q);

+}

+

+

+void GLAPIENTRY

+_mesa_GetQueryivARB(GLenum target, GLenum pname, GLint *params)

+{

+   struct gl_query_object *q, **bindpt;

+   GET_CURRENT_CONTEXT(ctx);

+   ASSERT_OUTSIDE_BEGIN_END(ctx);

+

+   if (MESA_VERBOSE & VERBOSE_API)

+      _mesa_debug(ctx, "glGetQueryiv(%s, %s)\n",

+                  _mesa_lookup_enum_by_nr(target),

+                  _mesa_lookup_enum_by_nr(pname));

+

+   bindpt = get_query_binding_point(ctx, target);

+   if (!bindpt) {

+      _mesa_error(ctx, GL_INVALID_ENUM, "glGetQueryARB(target)");

+      return;

+   }

+

+   q = *bindpt;

+

+   switch (pname) {

+      case GL_QUERY_COUNTER_BITS_ARB:

+         *params = 8 * sizeof(q->Result);

+         break;

+      case GL_CURRENT_QUERY_ARB:

+         *params = q ? q->Id : 0;

+         break;

+      default:

+         _mesa_error(ctx, GL_INVALID_ENUM, "glGetQueryivARB(pname)");

+         return;

+   }

+}

+

+

+void GLAPIENTRY

+_mesa_GetQueryObjectivARB(GLuint id, GLenum pname, GLint *params)

+{

+   struct gl_query_object *q = NULL;

+   GET_CURRENT_CONTEXT(ctx);

+   ASSERT_OUTSIDE_BEGIN_END(ctx);

+

+   if (MESA_VERBOSE & VERBOSE_API)

+      _mesa_debug(ctx, "glGetQueryObjectiv(%u, %s)\n", id,

+                  _mesa_lookup_enum_by_nr(pname));

+

+   if (id)

+      q = _mesa_lookup_query_object(ctx, id);

+

+   if (!q || q->Active) {

+      _mesa_error(ctx, GL_INVALID_OPERATION,

+                  "glGetQueryObjectivARB(id=%d is invalid or active)", id);

+      return;

+   }

+

+   switch (pname) {

+      case GL_QUERY_RESULT_ARB:

+         if (!q->Ready)

+            ctx->Driver.WaitQuery(ctx, q);

+         /* if result is too large for returned type, clamp to max value */

+         if (q->Target == GL_ANY_SAMPLES_PASSED) {

+            if (q->Result)

+               *params = GL_TRUE;

+            else

+               *params = GL_FALSE;

+         } else {

+            if (q->Result > 0x7fffffff) {

+               *params = 0x7fffffff;

+            }

+            else {

+               *params = (GLint)q->Result;

+            }

+         }

+         break;

+      case GL_QUERY_RESULT_AVAILABLE_ARB:

+	 if (!q->Ready)

+	    ctx->Driver.CheckQuery( ctx, q );

+         *params = q->Ready;

+         break;

+      default:

+         _mesa_error(ctx, GL_INVALID_ENUM, "glGetQueryObjectivARB(pname)");

+         return;

+   }

+}

+

+

+void GLAPIENTRY

+_mesa_GetQueryObjectuivARB(GLuint id, GLenum pname, GLuint *params)

+{

+   struct gl_query_object *q = NULL;

+   GET_CURRENT_CONTEXT(ctx);

+   ASSERT_OUTSIDE_BEGIN_END(ctx);

+

+   if (MESA_VERBOSE & VERBOSE_API)

+      _mesa_debug(ctx, "glGetQueryObjectuiv(%u, %s)\n", id,

+                  _mesa_lookup_enum_by_nr(pname));

+

+   if (id)

+      q = _mesa_lookup_query_object(ctx, id);

+

+   if (!q || q->Active) {

+      _mesa_error(ctx, GL_INVALID_OPERATION,

+                  "glGetQueryObjectuivARB(id=%d is invalid or active)", id);

+      return;

+   }

+

+   switch (pname) {

+      case GL_QUERY_RESULT_ARB:

+         if (!q->Ready)

+            ctx->Driver.WaitQuery(ctx, q);

+         /* if result is too large for returned type, clamp to max value */

+         if (q->Target == GL_ANY_SAMPLES_PASSED) {

+            if (q->Result)

+               *params = GL_TRUE;

+            else

+               *params = GL_FALSE;

+         } else {

+            if (q->Result > 0xffffffff) {

+               *params = 0xffffffff;

+            }

+            else {

+               *params = (GLuint)q->Result;

+            }

+         }

+         break;

+      case GL_QUERY_RESULT_AVAILABLE_ARB:

+	 if (!q->Ready)

+	    ctx->Driver.CheckQuery( ctx, q );

+         *params = q->Ready;

+         break;

+      default:

+         _mesa_error(ctx, GL_INVALID_ENUM, "glGetQueryObjectuivARB(pname)");

+         return;

+   }

+}

+

+

+/**

+ * New with GL_EXT_timer_query

+ */

+static void GLAPIENTRY

+_mesa_GetQueryObjecti64vEXT(GLuint id, GLenum pname, GLint64EXT *params)

+{

+   struct gl_query_object *q = NULL;

+   GET_CURRENT_CONTEXT(ctx);

+   ASSERT_OUTSIDE_BEGIN_END(ctx);

+

+   if (MESA_VERBOSE & VERBOSE_API)

+      _mesa_debug(ctx, "glGetQueryObjecti64v(%u, %s)\n", id,

+                  _mesa_lookup_enum_by_nr(pname));

+

+   if (id)

+      q = _mesa_lookup_query_object(ctx, id);

+

+   if (!q || q->Active) {

+      _mesa_error(ctx, GL_INVALID_OPERATION,

+                  "glGetQueryObjectui64vARB(id=%d is invalid or active)", id);

+      return;

+   }

+

+   switch (pname) {

+      case GL_QUERY_RESULT_ARB:

+         if (!q->Ready)

+            ctx->Driver.WaitQuery(ctx, q);

+         *params = q->Result;

+         break;

+      case GL_QUERY_RESULT_AVAILABLE_ARB:

+	 if (!q->Ready)

+	    ctx->Driver.CheckQuery( ctx, q );

+         *params = q->Ready;

+         break;

+      default:

+         _mesa_error(ctx, GL_INVALID_ENUM, "glGetQueryObjecti64vARB(pname)");

+         return;

+   }

+}

+

+

+/**

+ * New with GL_EXT_timer_query

+ */

+static void GLAPIENTRY

+_mesa_GetQueryObjectui64vEXT(GLuint id, GLenum pname, GLuint64EXT *params)

+{

+   struct gl_query_object *q = NULL;

+   GET_CURRENT_CONTEXT(ctx);

+   ASSERT_OUTSIDE_BEGIN_END(ctx);

+

+   if (MESA_VERBOSE & VERBOSE_API)

+      _mesa_debug(ctx, "glGetQueryObjectui64v(%u, %s)\n", id,

+                  _mesa_lookup_enum_by_nr(pname));

+

+   if (id)

+      q = _mesa_lookup_query_object(ctx, id);

+

+   if (!q || q->Active) {

+      _mesa_error(ctx, GL_INVALID_OPERATION,

+                  "glGetQueryObjectuui64vARB(id=%d is invalid or active)", id);

+      return;

+   }

+

+   switch (pname) {

+      case GL_QUERY_RESULT_ARB:

+         if (!q->Ready)

+            ctx->Driver.WaitQuery(ctx, q);

+         *params = q->Result;

+         break;

+      case GL_QUERY_RESULT_AVAILABLE_ARB:

+	 if (!q->Ready)

+	    ctx->Driver.CheckQuery( ctx, q );

+         *params = q->Ready;

+         break;

+      default:

+         _mesa_error(ctx, GL_INVALID_ENUM, "glGetQueryObjectui64vARB(pname)");

+         return;

+   }

+}

+

+

+void

+_mesa_init_queryobj_dispatch(struct _glapi_table *disp)

+{

+   SET_GenQueriesARB(disp, _mesa_GenQueriesARB);

+   SET_DeleteQueriesARB(disp, _mesa_DeleteQueriesARB);

+   SET_IsQueryARB(disp, _mesa_IsQueryARB);

+   SET_BeginQueryARB(disp, _mesa_BeginQueryARB);

+   SET_EndQueryARB(disp, _mesa_EndQueryARB);

+   SET_GetQueryivARB(disp, _mesa_GetQueryivARB);

+   SET_GetQueryObjectivARB(disp, _mesa_GetQueryObjectivARB);

+   SET_GetQueryObjectuivARB(disp, _mesa_GetQueryObjectuivARB);

+

+   SET_GetQueryObjecti64vEXT(disp, _mesa_GetQueryObjecti64vEXT);

+   SET_GetQueryObjectui64vEXT(disp, _mesa_GetQueryObjectui64vEXT);

+}

+

+

+#endif /* FEATURE_queryobj */

+

+

+/**

+ * Allocate/init the context state related to query objects.

+ */

+void

+_mesa_init_queryobj(struct gl_context *ctx)

+{

+   ctx->Query.QueryObjects = _mesa_NewHashTable();

+   ctx->Query.CurrentOcclusionObject = NULL;

+}

+

+

+/**

+ * Callback for deleting a query object.  Called by _mesa_HashDeleteAll().

+ */

+static void

+delete_queryobj_cb(GLuint id, void *data, void *userData)

+{

+   struct gl_query_object *q= (struct gl_query_object *) data;

+   struct gl_context *ctx = (struct gl_context *)userData;

+   ctx->Driver.DeleteQuery(ctx, q);

+}

+

+

+/**

+ * Free the context state related to query objects.

+ */

+void

+_mesa_free_queryobj_data(struct gl_context *ctx)

+{

+   _mesa_HashDeleteAll(ctx->Query.QueryObjects, delete_queryobj_cb, ctx);

+   _mesa_DeleteHashTable(ctx->Query.QueryObjects);

+}

diff --git a/mesalib/src/mesa/main/shaderapi.c b/mesalib/src/mesa/main/shaderapi.c
index 11b0f884f..3609577b7 100644
--- a/mesalib/src/mesa/main/shaderapi.c
+++ b/mesalib/src/mesa/main/shaderapi.c
@@ -1,1942 +1,1945 @@
-/*
- * Mesa 3-D graphics library
- *
- * Copyright (C) 2004-2008  Brian Paul   All Rights Reserved.
- * Copyright (C) 2009-2010  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 shaderapi.c
- * \author Brian Paul
- *
- * Implementation of GLSL-related API functions.
- * The glUniform* functions are in uniforms.c
- *
- *
- * XXX things to do:
- * 1. Check that the right error code is generated for all _mesa_error() calls.
- * 2. Insert FLUSH_VERTICES calls in various places
- */
-
-
-#include "main/glheader.h"
-#include "main/context.h"
-#include "main/dispatch.h"
-#include "main/enums.h"
-#include "main/hash.h"
-#include "main/mfeatures.h"
-#include "main/mtypes.h"
-#include "main/shaderapi.h"
-#include "main/shaderobj.h"
-#include "program/program.h"
-#include "program/prog_parameter.h"
-#include "program/prog_uniform.h"
-#include "ralloc.h"
-#include <stdbool.h>
-#include "../glsl/glsl_parser_extras.h"
-
-/** Define this to enable shader substitution (see below) */
-#define SHADER_SUBST 0
-
-
-/**
- * Return mask of GLSL_x flags by examining the MESA_GLSL env var.
- */
-static GLbitfield
-get_shader_flags(void)
-{
-   GLbitfield flags = 0x0;
-   const char *env = _mesa_getenv("MESA_GLSL");
-
-   if (env) {
-      if (strstr(env, "dump"))
-         flags |= GLSL_DUMP;
-      if (strstr(env, "log"))
-         flags |= GLSL_LOG;
-      if (strstr(env, "nopvert"))
-         flags |= GLSL_NOP_VERT;
-      if (strstr(env, "nopfrag"))
-         flags |= GLSL_NOP_FRAG;
-      if (strstr(env, "nopt"))
-         flags |= GLSL_NO_OPT;
-      else if (strstr(env, "opt"))
-         flags |= GLSL_OPT;
-      if (strstr(env, "uniform"))
-         flags |= GLSL_UNIFORMS;
-      if (strstr(env, "useprog"))
-         flags |= GLSL_USE_PROG;
-   }
-
-   return flags;
-}
-
-
-/**
- * Initialize context's shader state.
- */
-void
-_mesa_init_shader_state(struct gl_context *ctx)
-{
-   /* Device drivers may override these to control what kind of instructions
-    * are generated by the GLSL compiler.
-    */
-   struct gl_shader_compiler_options options;
-   gl_shader_type sh;
-
-   memset(&options, 0, sizeof(options));
-   options.MaxUnrollIterations = 32;
-
-   /* Default pragma settings */
-   options.DefaultPragmas.Optimize = GL_TRUE;
-
-   for (sh = 0; sh < MESA_SHADER_TYPES; ++sh)
-      memcpy(&ctx->ShaderCompilerOptions[sh], &options, sizeof(options));
-
-   ctx->Shader.Flags = get_shader_flags();
-}
-
-
-/**
- * Free the per-context shader-related state.
- */
-void
-_mesa_free_shader_state(struct gl_context *ctx)
-{
-   _mesa_reference_shader_program(ctx, &ctx->Shader.CurrentVertexProgram, NULL);
-   _mesa_reference_shader_program(ctx, &ctx->Shader.CurrentGeometryProgram,
-				  NULL);
-   _mesa_reference_shader_program(ctx, &ctx->Shader.CurrentFragmentProgram,
-				  NULL);
-   _mesa_reference_shader_program(ctx, &ctx->Shader.ActiveProgram, NULL);
-}
-
-
-/**
- * Return the size of the given GLSL datatype, in floats (components).
- */
-GLint
-_mesa_sizeof_glsl_type(GLenum type)
-{
-   switch (type) {
-   case GL_FLOAT:
-   case GL_INT:
-   case GL_BOOL:
-   case GL_SAMPLER_1D:
-   case GL_SAMPLER_2D:
-   case GL_SAMPLER_3D:
-   case GL_SAMPLER_CUBE:
-   case GL_SAMPLER_1D_SHADOW:
-   case GL_SAMPLER_2D_SHADOW:
-   case GL_SAMPLER_2D_RECT_ARB:
-   case GL_SAMPLER_2D_RECT_SHADOW_ARB:
-   case GL_SAMPLER_1D_ARRAY_EXT:
-   case GL_SAMPLER_2D_ARRAY_EXT:
-   case GL_SAMPLER_1D_ARRAY_SHADOW_EXT:
-   case GL_SAMPLER_2D_ARRAY_SHADOW_EXT:
-   case GL_SAMPLER_CUBE_SHADOW_EXT:
-      return 1;
-   case GL_FLOAT_VEC2:
-   case GL_INT_VEC2:
-   case GL_UNSIGNED_INT_VEC2:
-   case GL_BOOL_VEC2:
-      return 2;
-   case GL_FLOAT_VEC3:
-   case GL_INT_VEC3:
-   case GL_UNSIGNED_INT_VEC3:
-   case GL_BOOL_VEC3:
-      return 3;
-   case GL_FLOAT_VEC4:
-   case GL_INT_VEC4:
-   case GL_UNSIGNED_INT_VEC4:
-   case GL_BOOL_VEC4:
-      return 4;
-   case GL_FLOAT_MAT2:
-   case GL_FLOAT_MAT2x3:
-   case GL_FLOAT_MAT2x4:
-      return 8; /* two float[4] vectors */
-   case GL_FLOAT_MAT3:
-   case GL_FLOAT_MAT3x2:
-   case GL_FLOAT_MAT3x4:
-      return 12; /* three float[4] vectors */
-   case GL_FLOAT_MAT4:
-   case GL_FLOAT_MAT4x2:
-   case GL_FLOAT_MAT4x3:
-      return 16;  /* four float[4] vectors */
-   default:
-      _mesa_problem(NULL, "Invalid type in _mesa_sizeof_glsl_type()");
-      return 1;
-   }
-}
-
-
-/**
- * Copy string from <src> to <dst>, up to maxLength characters, returning
- * length of <dst> in <length>.
- * \param src  the strings source
- * \param maxLength  max chars to copy
- * \param length  returns number of chars copied
- * \param dst  the string destination
- */
-void
-_mesa_copy_string(GLchar *dst, GLsizei maxLength,
-                  GLsizei *length, const GLchar *src)
-{
-   GLsizei len;
-   for (len = 0; len < maxLength - 1 && src && src[len]; len++)
-      dst[len] = src[len];
-   if (maxLength > 0)
-      dst[len] = 0;
-   if (length)
-      *length = len;
-}
-
-
-
-/**
- * Confirm that the a shader type is valid and supported by the implementation
- *
- * \param ctx   Current GL context
- * \param type  Shader target
- *
- */
-static bool
-validate_shader_target(const struct gl_context *ctx, GLenum type)
-{
-   switch (type) {
-#if FEATURE_ARB_fragment_shader
-   case GL_FRAGMENT_SHADER:
-      return ctx->Extensions.ARB_fragment_shader;
-#endif
-#if FEATURE_ARB_vertex_shader
-   case GL_VERTEX_SHADER:
-      return ctx->Extensions.ARB_vertex_shader;
-#endif
-#if FEATURE_ARB_geometry_shader4
-   case GL_GEOMETRY_SHADER_ARB:
-      return ctx->Extensions.ARB_geometry_shader4;
-#endif
-   default:
-      return false;
-   }
-}
-
-
-/**
- * Find the length of the longest transform feedback varying name
- * which was specified with glTransformFeedbackVaryings().
- */
-static GLint
-longest_feedback_varying_name(const struct gl_shader_program *shProg)
-{
-   GLuint i;
-   GLint max = 0;
-   for (i = 0; i < shProg->TransformFeedback.NumVarying; i++) {
-      GLint len = strlen(shProg->TransformFeedback.VaryingNames[i]);
-      if (len > max)
-         max = len;
-   }
-   return max;
-}
-
-
-
-static GLboolean
-is_program(struct gl_context *ctx, GLuint name)
-{
-   struct gl_shader_program *shProg = _mesa_lookup_shader_program(ctx, name);
-   return shProg ? GL_TRUE : GL_FALSE;
-}
-
-
-static GLboolean
-is_shader(struct gl_context *ctx, GLuint name)
-{
-   struct gl_shader *shader = _mesa_lookup_shader(ctx, name);
-   return shader ? GL_TRUE : GL_FALSE;
-}
-
-
-/**
- * Attach shader to a shader program.
- */
-static void
-attach_shader(struct gl_context *ctx, GLuint program, GLuint shader)
-{
-   struct gl_shader_program *shProg;
-   struct gl_shader *sh;
-   GLuint i, n;
-
-   shProg = _mesa_lookup_shader_program_err(ctx, program, "glAttachShader");
-   if (!shProg)
-      return;
-
-   sh = _mesa_lookup_shader_err(ctx, shader, "glAttachShader");
-   if (!sh) {
-      return;
-   }
-
-   n = shProg->NumShaders;
-   for (i = 0; i < n; i++) {
-      if (shProg->Shaders[i] == sh) {
-         /* The shader is already attched to this program.  The
-          * GL_ARB_shader_objects spec says:
-          *
-          *     "The error INVALID_OPERATION is generated by AttachObjectARB
-          *     if <obj> is already attached to <containerObj>."
-          */
-         _mesa_error(ctx, GL_INVALID_OPERATION, "glAttachShader");
-         return;
-      }
-   }
-
-   /* grow list */
-   shProg->Shaders = (struct gl_shader **)
-      _mesa_realloc(shProg->Shaders,
-                    n * sizeof(struct gl_shader *),
-                    (n + 1) * sizeof(struct gl_shader *));
-   if (!shProg->Shaders) {
-      _mesa_error(ctx, GL_OUT_OF_MEMORY, "glAttachShader");
-      return;
-   }
-
-   /* append */
-   shProg->Shaders[n] = NULL; /* since realloc() didn't zero the new space */
-   _mesa_reference_shader(ctx, &shProg->Shaders[n], sh);
-   shProg->NumShaders++;
-}
-
-
-static GLint
-get_attrib_location(struct gl_context *ctx, GLuint program, const GLchar *name)
-{
-   struct gl_shader_program *shProg
-      = _mesa_lookup_shader_program_err(ctx, program, "glGetAttribLocation");
-
-   if (!shProg) {
-      return -1;
-   }
-
-   if (!shProg->LinkStatus) {
-      _mesa_error(ctx, GL_INVALID_OPERATION,
-                  "glGetAttribLocation(program not linked)");
-      return -1;
-   }
-
-   if (!name)
-      return -1;
-
-   if (shProg->VertexProgram) {
-      const struct gl_program_parameter_list *attribs =
-         shProg->VertexProgram->Base.Attributes;
-      if (attribs) {
-         GLint i = _mesa_lookup_parameter_index(attribs, -1, name);
-         if (i >= 0) {
-            return attribs->Parameters[i].StateIndexes[0];
-         }
-      }
-   }
-   return -1;
-}
-
-
-static void
-bind_attrib_location(struct gl_context *ctx, GLuint program, GLuint index,
-                     const GLchar *name)
-{
-   struct gl_shader_program *shProg;
-   const GLint size = -1; /* unknown size */
-   GLint i, oldIndex;
-   GLenum datatype = GL_FLOAT_VEC4;
-
-   shProg = _mesa_lookup_shader_program_err(ctx, program,
-                                            "glBindAttribLocation");
-   if (!shProg) {
-      return;
-   }
-
-   if (!name)
-      return;
-
-   if (strncmp(name, "gl_", 3) == 0) {
-      _mesa_error(ctx, GL_INVALID_OPERATION,
-                  "glBindAttribLocation(illegal name)");
-      return;
-   }
-
-   if (index >= ctx->Const.VertexProgram.MaxAttribs) {
-      _mesa_error(ctx, GL_INVALID_VALUE, "glBindAttribLocation(index)");
-      return;
-   }
-
-   if (shProg->LinkStatus) {
-      /* get current index/location for the attribute */
-      oldIndex = get_attrib_location(ctx, program, name);
-   }
-   else {
-      oldIndex = -1;
-   }
-
-   /* this will replace the current value if it's already in the list */
-   i = _mesa_add_attribute(shProg->Attributes, name, size, datatype, index);
-   if (i < 0) {
-      _mesa_error(ctx, GL_OUT_OF_MEMORY, "glBindAttribLocation");
-      return;
-   }
-
-   /*
-    * Note that this attribute binding won't go into effect until
-    * glLinkProgram is called again.
-    */
-}
-
-
-static void
-bind_frag_data_location(struct gl_context *ctx, GLuint program,
-                        GLuint colorNumber, const GLchar *name)
-{
-   _mesa_problem(ctx, "bind_frag_data_location() not implemented yet");
-}
-
-
-static GLuint
-create_shader(struct gl_context *ctx, GLenum type)
-{
-   struct gl_shader *sh;
-   GLuint name;
-
-   if (!validate_shader_target(ctx, type)) {
-      _mesa_error(ctx, GL_INVALID_ENUM, "CreateShader(type)");
-      return 0;
-   }
-
-   name = _mesa_HashFindFreeKeyBlock(ctx->Shared->ShaderObjects, 1);
-   sh = ctx->Driver.NewShader(ctx, name, type);
-   _mesa_HashInsert(ctx->Shared->ShaderObjects, name, sh);
-
-   return name;
-}
-
-
-static GLuint 
-create_shader_program(struct gl_context *ctx)
-{
-   GLuint name;
-   struct gl_shader_program *shProg;
-
-   name = _mesa_HashFindFreeKeyBlock(ctx->Shared->ShaderObjects, 1);
-
-   shProg = ctx->Driver.NewShaderProgram(ctx, name);
-
-   _mesa_HashInsert(ctx->Shared->ShaderObjects, name, shProg);
-
-   assert(shProg->RefCount == 1);
-
-   return name;
-}
-
-
-/**
- * Named w/ "2" to indicate OpenGL 2.x vs GL_ARB_fragment_programs's
- * DeleteProgramARB.
- */
-static void
-delete_shader_program(struct gl_context *ctx, GLuint name)
-{
-   /*
-    * NOTE: deleting shaders/programs works a bit differently than
-    * texture objects (and buffer objects, etc).  Shader/program
-    * handles/IDs exist in the hash table until the object is really
-    * deleted (refcount==0).  With texture objects, the handle/ID is
-    * removed from the hash table in glDeleteTextures() while the tex
-    * object itself might linger until its refcount goes to zero.
-    */
-   struct gl_shader_program *shProg;
-
-   shProg = _mesa_lookup_shader_program_err(ctx, name, "glDeleteProgram");
-   if (!shProg)
-      return;
-
-   shProg->DeletePending = GL_TRUE;
-
-   /* effectively, decr shProg's refcount */
-   _mesa_reference_shader_program(ctx, &shProg, NULL);
-}
-
-
-static void
-delete_shader(struct gl_context *ctx, GLuint shader)
-{
-   struct gl_shader *sh;
-
-   sh = _mesa_lookup_shader_err(ctx, shader, "glDeleteShader");
-   if (!sh)
-      return;
-
-   sh->DeletePending = GL_TRUE;
-
-   /* effectively, decr sh's refcount */
-   _mesa_reference_shader(ctx, &sh, NULL);
-}
-
-
-static void
-detach_shader(struct gl_context *ctx, GLuint program, GLuint shader)
-{
-   struct gl_shader_program *shProg;
-   GLuint n;
-   GLuint i, j;
-
-   shProg = _mesa_lookup_shader_program_err(ctx, program, "glDetachShader");
-   if (!shProg)
-      return;
-
-   n = shProg->NumShaders;
-
-   for (i = 0; i < n; i++) {
-      if (shProg->Shaders[i]->Name == shader) {
-         /* found it */
-         struct gl_shader **newList;
-
-         /* release */
-         _mesa_reference_shader(ctx, &shProg->Shaders[i], NULL);
-
-         /* alloc new, smaller array */
-         newList = (struct gl_shader **)
-            malloc((n - 1) * sizeof(struct gl_shader *));
-         if (!newList) {
-            _mesa_error(ctx, GL_OUT_OF_MEMORY, "glDetachShader");
-            return;
-         }
-         for (j = 0; j < i; j++) {
-            newList[j] = shProg->Shaders[j];
-         }
-         while (++i < n)
-            newList[j++] = shProg->Shaders[i];
-         free(shProg->Shaders);
-
-         shProg->Shaders = newList;
-         shProg->NumShaders = n - 1;
-
-#ifdef DEBUG
-         /* sanity check */
-         {
-            for (j = 0; j < shProg->NumShaders; j++) {
-               assert(shProg->Shaders[j]->Type == GL_VERTEX_SHADER ||
-                      shProg->Shaders[j]->Type == GL_FRAGMENT_SHADER);
-               assert(shProg->Shaders[j]->RefCount > 0);
-            }
-         }
-#endif
-
-         return;
-      }
-   }
-
-   /* not found */
-   {
-      GLenum err;
-      if (is_shader(ctx, shader))
-         err = GL_INVALID_OPERATION;
-      else if (is_program(ctx, shader))
-         err = GL_INVALID_OPERATION;
-      else
-         err = GL_INVALID_VALUE;
-      _mesa_error(ctx, err, "glDetachProgram(shader)");
-      return;
-   }
-}
-
-
-static void
-get_active_attrib(struct gl_context *ctx, GLuint program, GLuint index,
-                  GLsizei maxLength, GLsizei *length, GLint *size,
-                  GLenum *type, GLchar *nameOut)
-{
-   const struct gl_program_parameter_list *attribs = NULL;
-   struct gl_shader_program *shProg;
-
-   shProg = _mesa_lookup_shader_program_err(ctx, program, "glGetActiveAttrib");
-   if (!shProg)
-      return;
-
-   if (shProg->VertexProgram)
-      attribs = shProg->VertexProgram->Base.Attributes;
-
-   if (!attribs || index >= attribs->NumParameters) {
-      _mesa_error(ctx, GL_INVALID_VALUE, "glGetActiveAttrib(index)");
-      return;
-   }
-
-   _mesa_copy_string(nameOut, maxLength, length,
-                     attribs->Parameters[index].Name);
-
-   if (size)
-      *size = attribs->Parameters[index].Size
-         / _mesa_sizeof_glsl_type(attribs->Parameters[index].DataType);
-
-   if (type)
-      *type = attribs->Parameters[index].DataType;
-}
-
-
-/**
- * Return list of shaders attached to shader program.
- */
-static void
-get_attached_shaders(struct gl_context *ctx, GLuint program, GLsizei maxCount,
-                     GLsizei *count, GLuint *obj)
-{
-   struct gl_shader_program *shProg =
-      _mesa_lookup_shader_program_err(ctx, program, "glGetAttachedShaders");
-   if (shProg) {
-      GLuint i;
-      for (i = 0; i < (GLuint) maxCount && i < shProg->NumShaders; i++) {
-         obj[i] = shProg->Shaders[i]->Name;
-      }
-      if (count)
-         *count = i;
-   }
-}
-
-
-static GLint
-get_frag_data_location(struct gl_context *ctx, GLuint program,
-                       const GLchar *name)
-{
-   _mesa_problem(ctx, "get_frag_data_location() not implemented yet");
-   return -1;
-}
-
-
-
-/**
- * glGetHandleARB() - return ID/name of currently bound shader program.
- */
-static GLuint
-get_handle(struct gl_context *ctx, GLenum pname)
-{
-   if (pname == GL_PROGRAM_OBJECT_ARB) {
-      if (ctx->Shader.ActiveProgram)
-         return ctx->Shader.ActiveProgram->Name;
-      else
-         return 0;
-   }
-   else {
-      _mesa_error(ctx, GL_INVALID_ENUM, "glGetHandleARB");
-      return 0;
-   }
-}
-
-
-/**
- * glGetProgramiv() - get shader program state.
- * Note that this is for GLSL shader programs, not ARB vertex/fragment
- * programs (see glGetProgramivARB).
- */
-static void
-get_programiv(struct gl_context *ctx, GLuint program, GLenum pname, GLint *params)
-{
-   const struct gl_program_parameter_list *attribs;
-   struct gl_shader_program *shProg
-      = _mesa_lookup_shader_program(ctx, program);
-
-   if (!shProg) {
-      _mesa_error(ctx, GL_INVALID_VALUE, "glGetProgramiv(program)");
-      return;
-   }
-
-   if (shProg->VertexProgram)
-      attribs = shProg->VertexProgram->Base.Attributes;
-   else
-      attribs = NULL;
-
-   switch (pname) {
-   case GL_DELETE_STATUS:
-      *params = shProg->DeletePending;
-      break; 
-   case GL_LINK_STATUS:
-      *params = shProg->LinkStatus;
-      break;
-   case GL_VALIDATE_STATUS:
-      *params = shProg->Validated;
-      break;
-   case GL_INFO_LOG_LENGTH:
-      *params = shProg->InfoLog ? strlen(shProg->InfoLog) + 1 : 0;
-      break;
-   case GL_ATTACHED_SHADERS:
-      *params = shProg->NumShaders;
-      break;
-   case GL_ACTIVE_ATTRIBUTES:
-      *params = attribs ? attribs->NumParameters : 0;
-      break;
-   case GL_ACTIVE_ATTRIBUTE_MAX_LENGTH:
-      *params = _mesa_longest_parameter_name(attribs, PROGRAM_INPUT) + 1;
-      break;
-   case GL_ACTIVE_UNIFORMS:
-      *params = shProg->Uniforms ? shProg->Uniforms->NumUniforms : 0;
-      break;
-   case GL_ACTIVE_UNIFORM_MAX_LENGTH:
-      *params = _mesa_longest_uniform_name(shProg->Uniforms);
-      if (*params > 0)
-         (*params)++;  /* add one for terminating zero */
-      break;
-   case GL_PROGRAM_BINARY_LENGTH_OES:
-      *params = 0;
-      break;
-#if FEATURE_EXT_transform_feedback
-   case GL_TRANSFORM_FEEDBACK_VARYINGS:
-      *params = shProg->TransformFeedback.NumVarying;
-      break;
-   case GL_TRANSFORM_FEEDBACK_VARYING_MAX_LENGTH:
-      *params = longest_feedback_varying_name(shProg) + 1;
-      break;
-   case GL_TRANSFORM_FEEDBACK_BUFFER_MODE:
-      *params = shProg->TransformFeedback.BufferMode;
-      break;
-#endif
-#if FEATURE_ARB_geometry_shader4
-   case GL_GEOMETRY_VERTICES_OUT_ARB:
-      *params = shProg->Geom.VerticesOut;
-      break;
-   case GL_GEOMETRY_INPUT_TYPE_ARB:
-      *params = shProg->Geom.InputType;
-      break;
-   case GL_GEOMETRY_OUTPUT_TYPE_ARB:
-      *params = shProg->Geom.OutputType;
-      break;
-#endif
-   default:
-      _mesa_error(ctx, GL_INVALID_ENUM, "glGetProgramiv(pname)");
-      return;
-   }
-}
-
-
-/**
- * glGetShaderiv() - get GLSL shader state
- */
-static void
-get_shaderiv(struct gl_context *ctx, GLuint name, GLenum pname, GLint *params)
-{
-   struct gl_shader *shader =
-      _mesa_lookup_shader_err(ctx, name, "glGetShaderiv");
-
-   if (!shader) {
-      return;
-   }
-
-   switch (pname) {
-   case GL_SHADER_TYPE:
-      *params = shader->Type;
-      break;
-   case GL_DELETE_STATUS:
-      *params = shader->DeletePending;
-      break;
-   case GL_COMPILE_STATUS:
-      *params = shader->CompileStatus;
-      break;
-   case GL_INFO_LOG_LENGTH:
-      *params = shader->InfoLog ? strlen(shader->InfoLog) + 1 : 0;
-      break;
-   case GL_SHADER_SOURCE_LENGTH:
-      *params = shader->Source ? strlen((char *) shader->Source) + 1 : 0;
-      break;
-   default:
-      _mesa_error(ctx, GL_INVALID_ENUM, "glGetShaderiv(pname)");
-      return;
-   }
-}
-
-
-static void
-get_program_info_log(struct gl_context *ctx, GLuint program, GLsizei bufSize,
-                     GLsizei *length, GLchar *infoLog)
-{
-   struct gl_shader_program *shProg
-      = _mesa_lookup_shader_program(ctx, program);
-   if (!shProg) {
-      _mesa_error(ctx, GL_INVALID_VALUE, "glGetProgramInfoLog(program)");
-      return;
-   }
-   _mesa_copy_string(infoLog, bufSize, length, shProg->InfoLog);
-}
-
-
-static void
-get_shader_info_log(struct gl_context *ctx, GLuint shader, GLsizei bufSize,
-                    GLsizei *length, GLchar *infoLog)
-{
-   struct gl_shader *sh = _mesa_lookup_shader(ctx, shader);
-   if (!sh) {
-      _mesa_error(ctx, GL_INVALID_VALUE, "glGetShaderInfoLog(shader)");
-      return;
-   }
-   _mesa_copy_string(infoLog, bufSize, length, sh->InfoLog);
-}
-
-
-/**
- * Return shader source code.
- */
-static void
-get_shader_source(struct gl_context *ctx, GLuint shader, GLsizei maxLength,
-                  GLsizei *length, GLchar *sourceOut)
-{
-   struct gl_shader *sh;
-   sh = _mesa_lookup_shader_err(ctx, shader, "glGetShaderSource");
-   if (!sh) {
-      return;
-   }
-   _mesa_copy_string(sourceOut, maxLength, length, sh->Source);
-}
-
-
-/**
- * Set/replace shader source code.
- */
-static void
-shader_source(struct gl_context *ctx, GLuint shader, const GLchar *source)
-{
-   struct gl_shader *sh;
-
-   sh = _mesa_lookup_shader_err(ctx, shader, "glShaderSource");
-   if (!sh)
-      return;
-
-   /* free old shader source string and install new one */
-   if (sh->Source) {
-      free((void *) sh->Source);
-   }
-   sh->Source = source;
-   sh->CompileStatus = GL_FALSE;
-#ifdef DEBUG
-   sh->SourceChecksum = _mesa_str_checksum(sh->Source);
-#endif
-}
-
-
-/**
- * Compile a shader.
- */
-static void
-compile_shader(struct gl_context *ctx, GLuint shaderObj)
-{
-   struct gl_shader *sh;
-   struct gl_shader_compiler_options *options;
-
-   sh = _mesa_lookup_shader_err(ctx, shaderObj, "glCompileShader");
-   if (!sh)
-      return;
-
-   options = &ctx->ShaderCompilerOptions[_mesa_shader_type_to_index(sh->Type)];
-
-   /* set default pragma state for shader */
-   sh->Pragmas = options->DefaultPragmas;
-
-   /* this call will set the sh->CompileStatus field to indicate if
-    * compilation was successful.
-    */
-   _mesa_glsl_compile_shader(ctx, sh);
-}
-
-
-/**
- * Link a program's shaders.
- */
-static void
-link_program(struct gl_context *ctx, GLuint program)
-{
-   struct gl_shader_program *shProg;
-   struct gl_transform_feedback_object *obj =
-      ctx->TransformFeedback.CurrentObject;
-
-   shProg = _mesa_lookup_shader_program_err(ctx, program, "glLinkProgram");
-   if (!shProg)
-      return;
-
-   if (obj->Active
-       && (shProg == ctx->Shader.CurrentVertexProgram
-	   || shProg == ctx->Shader.CurrentGeometryProgram
-	   || shProg == ctx->Shader.CurrentFragmentProgram)) {
-      _mesa_error(ctx, GL_INVALID_OPERATION,
-                  "glLinkProgram(transform feedback active");
-      return;
-   }
-
-   FLUSH_VERTICES(ctx, _NEW_PROGRAM);
-
-   _mesa_glsl_link_shader(ctx, shProg);
-
-   /* debug code */
-   if (0) {
-      GLuint i;
-
-      printf("Link %u shaders in program %u: %s\n",
-                   shProg->NumShaders, shProg->Name,
-                   shProg->LinkStatus ? "Success" : "Failed");
-
-      for (i = 0; i < shProg->NumShaders; i++) {
-         printf(" shader %u, type 0x%x\n",
-                      shProg->Shaders[i]->Name,
-                      shProg->Shaders[i]->Type);
-      }
-   }
-}
-
-
-/**
- * Print basic shader info (for debug).
- */
-static void
-print_shader_info(const struct gl_shader_program *shProg)
-{
-   GLuint i;
-
-   printf("Mesa: glUseProgram(%u)\n", shProg->Name);
-   for (i = 0; i < shProg->NumShaders; i++) {
-      const char *s;
-      switch (shProg->Shaders[i]->Type) {
-      case GL_VERTEX_SHADER:
-         s = "vertex";
-         break;
-      case GL_FRAGMENT_SHADER:
-         s = "fragment";
-         break;
-      case GL_GEOMETRY_SHADER:
-         s = "geometry";
-         break;
-      default:
-         s = "";
-      }
-      printf("  %s shader %u, checksum %u\n", s, 
-	     shProg->Shaders[i]->Name,
-	     shProg->Shaders[i]->SourceChecksum);
-   }
-   if (shProg->VertexProgram)
-      printf("  vert prog %u\n", shProg->VertexProgram->Base.Id);
-   if (shProg->FragmentProgram)
-      printf("  frag prog %u\n", shProg->FragmentProgram->Base.Id);
-}
-
-
-/**
- * Use the named shader program for subsequent glUniform calls
- */
-void
-_mesa_active_program(struct gl_context *ctx, struct gl_shader_program *shProg,
-		     const char *caller)
-{
-   if ((shProg != NULL) && !shProg->LinkStatus) {
-      _mesa_error(ctx, GL_INVALID_OPERATION,
-		  "%s(program %u not linked)", caller, shProg->Name);
-      return;
-   }
-
-   if (ctx->Shader.ActiveProgram != shProg) {
-      _mesa_reference_shader_program(ctx, &ctx->Shader.ActiveProgram, shProg);
-   }
-}
-
-/**
- */
-static bool
-use_shader_program(struct gl_context *ctx, GLenum type,
-		   struct gl_shader_program *shProg)
-{
-   struct gl_shader_program **target;
-
-   switch (type) {
-#if FEATURE_ARB_vertex_shader
-   case GL_VERTEX_SHADER:
-      target = &ctx->Shader.CurrentVertexProgram;
-      if ((shProg == NULL)
-	  || (shProg->_LinkedShaders[MESA_SHADER_VERTEX] == NULL)) {
-	 shProg = NULL;
-      }
-      break;
-#endif
-#if FEATURE_ARB_geometry_shader4
-   case GL_GEOMETRY_SHADER_ARB:
-      target = &ctx->Shader.CurrentGeometryProgram;
-      if ((shProg == NULL)
-	  || (shProg->_LinkedShaders[MESA_SHADER_GEOMETRY] == NULL)) {
-	 shProg = NULL;
-      }
-      break;
-#endif
-#if FEATURE_ARB_fragment_shader
-   case GL_FRAGMENT_SHADER:
-      target = &ctx->Shader.CurrentFragmentProgram;
-      if ((shProg == NULL)
-	  || (shProg->_LinkedShaders[MESA_SHADER_FRAGMENT] == NULL)) {
-	 shProg = NULL;
-      }
-      break;
-#endif
-   default:
-      return false;
-   }
-
-   if (*target != shProg) {
-      FLUSH_VERTICES(ctx, _NEW_PROGRAM | _NEW_PROGRAM_CONSTANTS);
-      _mesa_reference_shader_program(ctx, target, shProg);
-      return true;
-   }
-
-   return false;
-}
-
-/**
- * Use the named shader program for subsequent rendering.
- */
-void
-_mesa_use_program(struct gl_context *ctx, struct gl_shader_program *shProg)
-{
-   use_shader_program(ctx, GL_VERTEX_SHADER, shProg);
-   use_shader_program(ctx, GL_GEOMETRY_SHADER_ARB, shProg);
-   use_shader_program(ctx, GL_FRAGMENT_SHADER, shProg);
-   _mesa_active_program(ctx, shProg, "glUseProgram");
-
-   if (ctx->Driver.UseProgram)
-      ctx->Driver.UseProgram(ctx, shProg);
-}
-
-
-/**
- * Validate a program's samplers.
- * Specifically, check that there aren't two samplers of different types
- * pointing to the same texture unit.
- * \return GL_TRUE if valid, GL_FALSE if invalid
- */
-static GLboolean
-validate_samplers(const struct gl_program *prog, char *errMsg)
-{
-   static const char *targetName[] = {
-      "TEXTURE_2D_ARRAY",
-      "TEXTURE_1D_ARRAY",
-      "TEXTURE_CUBE",
-      "TEXTURE_3D",
-      "TEXTURE_RECT",
-      "TEXTURE_2D",
-      "TEXTURE_1D",
-   };
-   GLint targetUsed[MAX_TEXTURE_IMAGE_UNITS];
-   GLbitfield samplersUsed = prog->SamplersUsed;
-   GLuint i;
-
-   assert(Elements(targetName) == NUM_TEXTURE_TARGETS);
-
-   if (samplersUsed == 0x0)
-      return GL_TRUE;
-
-   for (i = 0; i < Elements(targetUsed); i++)
-      targetUsed[i] = -1;
-
-   /* walk over bits which are set in 'samplers' */
-   while (samplersUsed) {
-      GLuint unit;
-      gl_texture_index target;
-      GLint sampler = _mesa_ffs(samplersUsed) - 1;
-      assert(sampler >= 0);
-      assert(sampler < MAX_TEXTURE_IMAGE_UNITS);
-      unit = prog->SamplerUnits[sampler];
-      target = prog->SamplerTargets[sampler];
-      if (targetUsed[unit] != -1 && targetUsed[unit] != (int) target) {
-         _mesa_snprintf(errMsg, 100,
-		  "Texture unit %d is accessed both as %s and %s",
-		  unit, targetName[targetUsed[unit]], targetName[target]);
-         return GL_FALSE;
-      }
-      targetUsed[unit] = target;
-      samplersUsed ^= (1 << sampler);
-   }
-
-   return GL_TRUE;
-}
-
-
-/**
- * Do validation of the given shader program.
- * \param errMsg  returns error message if validation fails.
- * \return GL_TRUE if valid, GL_FALSE if invalid (and set errMsg)
- */
-static GLboolean
-validate_shader_program(const struct gl_shader_program *shProg,
-                        char *errMsg)
-{
-   const struct gl_vertex_program *vp = shProg->VertexProgram;
-   const struct gl_fragment_program *fp = shProg->FragmentProgram;
-
-   if (!shProg->LinkStatus) {
-      return GL_FALSE;
-   }
-
-   /* From the GL spec, a program is invalid if any of these are true:
-
-     any two active samplers in the current program object are of
-     different types, but refer to the same texture image unit,
-
-     any active sampler in the current program object refers to a texture
-     image unit where fixed-function fragment processing accesses a
-     texture target that does not match the sampler type, or 
-
-     the sum of the number of active samplers in the program and the
-     number of texture image units enabled for fixed-function fragment
-     processing exceeds the combined limit on the total number of texture
-     image units allowed.
-   */
-
-
-   /*
-    * Check: any two active samplers in the current program object are of
-    * different types, but refer to the same texture image unit,
-    */
-   if (vp && !validate_samplers(&vp->Base, errMsg)) {
-      return GL_FALSE;
-   }
-   if (fp && !validate_samplers(&fp->Base, errMsg)) {
-      return GL_FALSE;
-   }
-
-   return GL_TRUE;
-}
-
-
-/**
- * Called via glValidateProgram()
- */
-static void
-validate_program(struct gl_context *ctx, GLuint program)
-{
-   struct gl_shader_program *shProg;
-   char errMsg[100];
-
-   shProg = _mesa_lookup_shader_program_err(ctx, program, "glValidateProgram");
-   if (!shProg) {
-      return;
-   }
-
-   shProg->Validated = validate_shader_program(shProg, errMsg);
-   if (!shProg->Validated) {
-      /* update info log */
-      if (shProg->InfoLog) {
-         ralloc_free(shProg->InfoLog);
-      }
-      shProg->InfoLog = ralloc_strdup(shProg, errMsg);
-   }
-}
-
-
-
-void GLAPIENTRY
-_mesa_AttachObjectARB(GLhandleARB program, GLhandleARB shader)
-{
-   GET_CURRENT_CONTEXT(ctx);
-   attach_shader(ctx, program, shader);
-}
-
-
-void GLAPIENTRY
-_mesa_AttachShader(GLuint program, GLuint shader)
-{
-   GET_CURRENT_CONTEXT(ctx);
-   attach_shader(ctx, program, shader);
-}
-
-
-void GLAPIENTRY
-_mesa_BindAttribLocationARB(GLhandleARB program, GLuint index,
-                            const GLcharARB *name)
-{
-   GET_CURRENT_CONTEXT(ctx);
-   bind_attrib_location(ctx, program, index, name);
-}
-
-
-/* GL_EXT_gpu_shader4, GL3 */
-void GLAPIENTRY
-_mesa_BindFragDataLocation(GLuint program, GLuint colorNumber,
-                           const GLchar *name)
-{
-   GET_CURRENT_CONTEXT(ctx);
-   bind_frag_data_location(ctx, program, colorNumber, name);
-}
-
-
-void GLAPIENTRY
-_mesa_CompileShaderARB(GLhandleARB shaderObj)
-{
-   GET_CURRENT_CONTEXT(ctx);
-   if (MESA_VERBOSE & VERBOSE_API)
-      _mesa_debug(ctx, "glCompileShader %u\n", shaderObj);
-   compile_shader(ctx, shaderObj);
-}
-
-
-GLuint GLAPIENTRY
-_mesa_CreateShader(GLenum type)
-{
-   GET_CURRENT_CONTEXT(ctx);
-   if (MESA_VERBOSE & VERBOSE_API)
-      _mesa_debug(ctx, "glCreateShader %s\n", _mesa_lookup_enum_by_nr(type));
-   return create_shader(ctx, type);
-}
-
-
-GLhandleARB GLAPIENTRY
-_mesa_CreateShaderObjectARB(GLenum type)
-{
-   GET_CURRENT_CONTEXT(ctx);
-   return create_shader(ctx, type);
-}
-
-
-GLuint GLAPIENTRY
-_mesa_CreateProgram(void)
-{
-   GET_CURRENT_CONTEXT(ctx);
-   if (MESA_VERBOSE & VERBOSE_API)
-      _mesa_debug(ctx, "glCreateProgram\n");
-   return create_shader_program(ctx);
-}
-
-
-GLhandleARB GLAPIENTRY
-_mesa_CreateProgramObjectARB(void)
-{
-   GET_CURRENT_CONTEXT(ctx);
-   return create_shader_program(ctx);
-}
-
-
-void GLAPIENTRY
-_mesa_DeleteObjectARB(GLhandleARB obj)
-{
-   if (MESA_VERBOSE & VERBOSE_API) {
-      GET_CURRENT_CONTEXT(ctx);
-      _mesa_debug(ctx, "glDeleteObjectARB(%u)\n", obj);
-   }
-
-   if (obj) {
-      GET_CURRENT_CONTEXT(ctx);
-      if (is_program(ctx, obj)) {
-         delete_shader_program(ctx, obj);
-      }
-      else if (is_shader(ctx, obj)) {
-         delete_shader(ctx, obj);
-      }
-      else {
-         /* error? */
-      }
-   }
-}
-
-
-void GLAPIENTRY
-_mesa_DeleteProgram(GLuint name)
-{
-   if (name) {
-      GET_CURRENT_CONTEXT(ctx);
-      delete_shader_program(ctx, name);
-   }
-}
-
-
-void GLAPIENTRY
-_mesa_DeleteShader(GLuint name)
-{
-   if (name) {
-      GET_CURRENT_CONTEXT(ctx);
-      delete_shader(ctx, name);
-   }
-}
-
-
-void GLAPIENTRY
-_mesa_DetachObjectARB(GLhandleARB program, GLhandleARB shader)
-{
-   GET_CURRENT_CONTEXT(ctx);
-   detach_shader(ctx, program, shader);
-}
-
-
-void GLAPIENTRY
-_mesa_DetachShader(GLuint program, GLuint shader)
-{
-   GET_CURRENT_CONTEXT(ctx);
-   detach_shader(ctx, program, shader);
-}
-
-
-void GLAPIENTRY
-_mesa_GetActiveAttribARB(GLhandleARB program, GLuint index,
-                         GLsizei maxLength, GLsizei * length, GLint * size,
-                         GLenum * type, GLcharARB * name)
-{
-   GET_CURRENT_CONTEXT(ctx);
-   get_active_attrib(ctx, program, index, maxLength, length, size, type, name);
-}
-
-
-void GLAPIENTRY
-_mesa_GetAttachedObjectsARB(GLhandleARB container, GLsizei maxCount,
-                            GLsizei * count, GLhandleARB * obj)
-{
-   GET_CURRENT_CONTEXT(ctx);
-   get_attached_shaders(ctx, container, maxCount, count, obj);
-}
-
-
-void GLAPIENTRY
-_mesa_GetAttachedShaders(GLuint program, GLsizei maxCount,
-                         GLsizei *count, GLuint *obj)
-{
-   GET_CURRENT_CONTEXT(ctx);
-   get_attached_shaders(ctx, program, maxCount, count, obj);
-}
-
-
-GLint GLAPIENTRY
-_mesa_GetAttribLocationARB(GLhandleARB program, const GLcharARB * name)
-{
-   GET_CURRENT_CONTEXT(ctx);
-   return get_attrib_location(ctx, program, name);
-}
-
-
-/* GL_EXT_gpu_shader4, GL3 */
-GLint GLAPIENTRY
-_mesa_GetFragDataLocation(GLuint program, const GLchar *name)
-{
-   GET_CURRENT_CONTEXT(ctx);
-   return get_frag_data_location(ctx, program, name);
-}
-
-
-
-void GLAPIENTRY
-_mesa_GetInfoLogARB(GLhandleARB object, GLsizei maxLength, GLsizei * length,
-                    GLcharARB * infoLog)
-{
-   GET_CURRENT_CONTEXT(ctx);
-   if (is_program(ctx, object)) {
-      get_program_info_log(ctx, object, maxLength, length, infoLog);
-   }
-   else if (is_shader(ctx, object)) {
-      get_shader_info_log(ctx, object, maxLength, length, infoLog);
-   }
-   else {
-      _mesa_error(ctx, GL_INVALID_OPERATION, "glGetInfoLogARB");
-   }
-}
-
-
-void GLAPIENTRY
-_mesa_GetObjectParameterivARB(GLhandleARB object, GLenum pname, GLint *params)
-{
-   GET_CURRENT_CONTEXT(ctx);
-   /* Implement in terms of GetProgramiv, GetShaderiv */
-   if (is_program(ctx, object)) {
-      if (pname == GL_OBJECT_TYPE_ARB) {
-	 *params = GL_PROGRAM_OBJECT_ARB;
-      }
-      else {
-	 get_programiv(ctx, object, pname, params);
-      }
-   }
-   else if (is_shader(ctx, object)) {
-      if (pname == GL_OBJECT_TYPE_ARB) {
-	 *params = GL_SHADER_OBJECT_ARB;
-      }
-      else {
-	 get_shaderiv(ctx, object, pname, params);
-      }
-   }
-   else {
-      _mesa_error(ctx, GL_INVALID_VALUE, "glGetObjectParameterivARB");
-   }
-}
-
-
-void GLAPIENTRY
-_mesa_GetObjectParameterfvARB(GLhandleARB object, GLenum pname,
-                              GLfloat *params)
-{
-   GLint iparams[1];  /* XXX is one element enough? */
-   _mesa_GetObjectParameterivARB(object, pname, iparams);
-   params[0] = (GLfloat) iparams[0];
-}
-
-
-void GLAPIENTRY
-_mesa_GetProgramiv(GLuint program, GLenum pname, GLint *params)
-{
-   GET_CURRENT_CONTEXT(ctx);
-   get_programiv(ctx, program, pname, params);
-}
-
-
-void GLAPIENTRY
-_mesa_GetShaderiv(GLuint shader, GLenum pname, GLint *params)
-{
-   GET_CURRENT_CONTEXT(ctx);
-   get_shaderiv(ctx, shader, pname, params);
-}
-
-
-void GLAPIENTRY
-_mesa_GetProgramInfoLog(GLuint program, GLsizei bufSize,
-                        GLsizei *length, GLchar *infoLog)
-{
-   GET_CURRENT_CONTEXT(ctx);
-   get_program_info_log(ctx, program, bufSize, length, infoLog);
-}
-
-
-void GLAPIENTRY
-_mesa_GetShaderInfoLog(GLuint shader, GLsizei bufSize,
-                       GLsizei *length, GLchar *infoLog)
-{
-   GET_CURRENT_CONTEXT(ctx);
-   get_shader_info_log(ctx, shader, bufSize, length, infoLog);
-}
-
-
-void GLAPIENTRY
-_mesa_GetShaderSourceARB(GLhandleARB shader, GLsizei maxLength,
-                         GLsizei *length, GLcharARB *sourceOut)
-{
-   GET_CURRENT_CONTEXT(ctx);
-   get_shader_source(ctx, shader, maxLength, length, sourceOut);
-}
-
-
-GLhandleARB GLAPIENTRY
-_mesa_GetHandleARB(GLenum pname)
-{
-   GET_CURRENT_CONTEXT(ctx);
-   return get_handle(ctx, pname);
-}
-
-
-GLboolean GLAPIENTRY
-_mesa_IsProgram(GLuint name)
-{
-   GET_CURRENT_CONTEXT(ctx);
-   return is_program(ctx, name);
-}
-
-
-GLboolean GLAPIENTRY
-_mesa_IsShader(GLuint name)
-{
-   GET_CURRENT_CONTEXT(ctx);
-   return is_shader(ctx, name);
-}
-
-
-void GLAPIENTRY
-_mesa_LinkProgramARB(GLhandleARB programObj)
-{
-   GET_CURRENT_CONTEXT(ctx);
-   link_program(ctx, programObj);
-}
-
-
-
-/**
- * Read shader source code from a file.
- * Useful for debugging to override an app's shader.
- */
-static GLcharARB *
-read_shader(const char *fname)
-{
-   const int max = 50*1000;
-   FILE *f = fopen(fname, "r");
-   GLcharARB *buffer, *shader;
-   int len;
-
-   if (!f) {
-      return NULL;
-   }
-
-   buffer = (char *) malloc(max);
-   len = fread(buffer, 1, max, f);
-   buffer[len] = 0;
-
-   fclose(f);
-
-   shader = _mesa_strdup(buffer);
-   free(buffer);
-
-   return shader;
-}
-
-
-/**
- * Called via glShaderSource() and glShaderSourceARB() API functions.
- * Basically, concatenate the source code strings into one long string
- * and pass it to _mesa_shader_source().
- */
-void GLAPIENTRY
-_mesa_ShaderSourceARB(GLhandleARB shaderObj, GLsizei count,
-                      const GLcharARB ** string, const GLint * length)
-{
-   GET_CURRENT_CONTEXT(ctx);
-   GLint *offsets;
-   GLsizei i, totalLength;
-   GLcharARB *source;
-   GLuint checksum;
-
-   if (!shaderObj || string == NULL) {
-      _mesa_error(ctx, GL_INVALID_VALUE, "glShaderSourceARB");
-      return;
-   }
-
-   /*
-    * This array holds offsets of where the appropriate string ends, thus the
-    * last element will be set to the total length of the source code.
-    */
-   offsets = (GLint *) malloc(count * sizeof(GLint));
-   if (offsets == NULL) {
-      _mesa_error(ctx, GL_OUT_OF_MEMORY, "glShaderSourceARB");
-      return;
-   }
-
-   for (i = 0; i < count; i++) {
-      if (string[i] == NULL) {
-         free((GLvoid *) offsets);
-         _mesa_error(ctx, GL_INVALID_OPERATION, "glShaderSourceARB(null string)");
-         return;
-      }
-      if (length == NULL || length[i] < 0)
-         offsets[i] = strlen(string[i]);
-      else
-         offsets[i] = length[i];
-      /* accumulate string lengths */
-      if (i > 0)
-         offsets[i] += offsets[i - 1];
-   }
-
-   /* Total length of source string is sum off all strings plus two.
-    * One extra byte for terminating zero, another extra byte to silence
-    * valgrind warnings in the parser/grammer code.
-    */
-   totalLength = offsets[count - 1] + 2;
-   source = (GLcharARB *) malloc(totalLength * sizeof(GLcharARB));
-   if (source == NULL) {
-      free((GLvoid *) offsets);
-      _mesa_error(ctx, GL_OUT_OF_MEMORY, "glShaderSourceARB");
-      return;
-   }
-
-   for (i = 0; i < count; i++) {
-      GLint start = (i > 0) ? offsets[i - 1] : 0;
-      memcpy(source + start, string[i],
-             (offsets[i] - start) * sizeof(GLcharARB));
-   }
-   source[totalLength - 1] = '\0';
-   source[totalLength - 2] = '\0';
-
-   if (SHADER_SUBST) {
-      /* Compute the shader's source code checksum then try to open a file
-       * named newshader_<CHECKSUM>.  If it exists, use it in place of the
-       * original shader source code.  For debugging.
-       */
-      char filename[100];
-      GLcharARB *newSource;
-
-      checksum = _mesa_str_checksum(source);
-
-      _mesa_snprintf(filename, sizeof(filename), "newshader_%d", checksum);
-
-      newSource = read_shader(filename);
-      if (newSource) {
-         fprintf(stderr, "Mesa: Replacing shader %u chksum=%d with %s\n",
-                       shaderObj, checksum, filename);
-         free(source);
-         source = newSource;
-      }
-   }      
-
-   shader_source(ctx, shaderObj, source);
-
-   if (SHADER_SUBST) {
-      struct gl_shader *sh = _mesa_lookup_shader(ctx, shaderObj);
-      if (sh)
-         sh->SourceChecksum = checksum; /* save original checksum */
-   }
-
-   free(offsets);
-}
-
-
-void GLAPIENTRY
-_mesa_UseProgramObjectARB(GLhandleARB program)
-{
-   GET_CURRENT_CONTEXT(ctx);
-   struct gl_shader_program *shProg;
-   struct gl_transform_feedback_object *obj =
-      ctx->TransformFeedback.CurrentObject;
-
-   if (obj->Active) {
-      _mesa_error(ctx, GL_INVALID_OPERATION,
-                  "glUseProgram(transform feedback active)");
-      return;
-   }
-
-   if (program) {
-      shProg = _mesa_lookup_shader_program_err(ctx, program, "glUseProgram");
-      if (!shProg) {
-         return;
-      }
-      if (!shProg->LinkStatus) {
-         _mesa_error(ctx, GL_INVALID_OPERATION,
-                     "glUseProgram(program %u not linked)", program);
-         return;
-      }
-
-      /* debug code */
-      if (ctx->Shader.Flags & GLSL_USE_PROG) {
-         print_shader_info(shProg);
-      }
-   }
-   else {
-      shProg = NULL;
-   }
-
-   _mesa_use_program(ctx, shProg);
-}
-
-
-void GLAPIENTRY
-_mesa_ValidateProgramARB(GLhandleARB program)
-{
-   GET_CURRENT_CONTEXT(ctx);
-   validate_program(ctx, program);
-}
-
-#ifdef FEATURE_ES2
-
-void GLAPIENTRY
-_mesa_GetShaderPrecisionFormat(GLenum shadertype, GLenum precisiontype,
-                               GLint* range, GLint* precision)
-{
-   const struct gl_program_constants *limits;
-   const struct gl_precision *p;
-   GET_CURRENT_CONTEXT(ctx);
-
-   switch (shadertype) {
-   case GL_VERTEX_SHADER:
-      limits = &ctx->Const.VertexProgram;
-      break;
-   case GL_FRAGMENT_SHADER:
-      limits = &ctx->Const.FragmentProgram;
-      break;
-   default:
-      _mesa_error(ctx, GL_INVALID_ENUM,
-                  "glGetShaderPrecisionFormat(shadertype)");
-      return;
-   }
-
-   switch (precisiontype) {
-   case GL_LOW_FLOAT:
-      p = &limits->LowFloat;
-      break;
-   case GL_MEDIUM_FLOAT:
-      p = &limits->MediumFloat;
-      break;
-   case GL_HIGH_FLOAT:
-      p = &limits->HighFloat;
-      break;
-   case GL_LOW_INT:
-      p = &limits->LowInt;
-      break;
-   case GL_MEDIUM_INT:
-      p = &limits->MediumInt;
-      break;
-   case GL_HIGH_INT:
-      p = &limits->HighInt;
-      break;
-   default:
-      _mesa_error(ctx, GL_INVALID_ENUM,
-                  "glGetShaderPrecisionFormat(precisiontype)");
-      return;
-   }
-
-   range[0] = p->RangeMin;
-   range[1] = p->RangeMax;
-   precision[0] = p->Precision;
-}
-
-
-void GLAPIENTRY
-_mesa_ReleaseShaderCompiler(void)
-{
-   _mesa_destroy_shader_compiler_caches();
-}
-
-
-void GLAPIENTRY
-_mesa_ShaderBinary(GLint n, const GLuint* shaders, GLenum binaryformat,
-                   const void* binary, GLint length)
-{
-   GET_CURRENT_CONTEXT(ctx);
-   (void) n;
-   (void) shaders;
-   (void) binaryformat;
-   (void) binary;
-   (void) length;
-   _mesa_error(ctx, GL_INVALID_OPERATION, __FUNCTION__);
-}
-
-#endif /* FEATURE_ES2 */
-
-
-#if FEATURE_ARB_geometry_shader4
-
-void GLAPIENTRY
-_mesa_ProgramParameteriARB(GLuint program, GLenum pname,
-                           GLint value)
-{
-   struct gl_shader_program *shProg;
-   GET_CURRENT_CONTEXT(ctx);
-
-   ASSERT_OUTSIDE_BEGIN_END(ctx);
-
-   shProg = _mesa_lookup_shader_program_err(ctx, program,
-                                            "glProgramParameteri");
-   if (!shProg)
-      return;
-
-   switch (pname) {
-   case GL_GEOMETRY_VERTICES_OUT_ARB:
-      if (value < 1 ||
-          (unsigned) value > ctx->Const.GeometryProgram.MaxGeometryOutputVertices) {
-         _mesa_error(ctx, GL_INVALID_VALUE,
-                     "glProgramParameteri(GL_GEOMETRY_VERTICES_OUT_ARB=%d",
-                     value);
-         return;
-      }
-      shProg->Geom.VerticesOut = value;
-      break;
-   case GL_GEOMETRY_INPUT_TYPE_ARB:
-      switch (value) {
-      case GL_POINTS:
-      case GL_LINES:
-      case GL_LINES_ADJACENCY_ARB:
-      case GL_TRIANGLES:
-      case GL_TRIANGLES_ADJACENCY_ARB:
-         shProg->Geom.InputType = value;
-         break;
-      default:
-         _mesa_error(ctx, GL_INVALID_VALUE,
-                     "glProgramParameteri(geometry input type = %s",
-                     _mesa_lookup_enum_by_nr(value));
-         return;
-      }
-      break;
-   case GL_GEOMETRY_OUTPUT_TYPE_ARB:
-      switch (value) {
-      case GL_POINTS:
-      case GL_LINE_STRIP:
-      case GL_TRIANGLE_STRIP:
-         shProg->Geom.OutputType = value;
-         break;
-      default:
-         _mesa_error(ctx, GL_INVALID_VALUE,
-                     "glProgramParameteri(geometry output type = %s",
-                     _mesa_lookup_enum_by_nr(value));
-         return;
-      }
-      break;
-   default:
-      _mesa_error(ctx, GL_INVALID_ENUM, "glProgramParameteriARB(pname=%s)",
-                  _mesa_lookup_enum_by_nr(pname));
-      break;
-   }
-}
-
-#endif
-
-void
-_mesa_use_shader_program(struct gl_context *ctx, GLenum type,
-			 struct gl_shader_program *shProg)
-{
-   use_shader_program(ctx, type, shProg);
-
-   if (ctx->Driver.UseProgram)
-      ctx->Driver.UseProgram(ctx, shProg);
-}
-
-void GLAPIENTRY
-_mesa_UseShaderProgramEXT(GLenum type, GLuint program)
-{
-   GET_CURRENT_CONTEXT(ctx);
-   struct gl_shader_program *shProg = NULL;
-
-   if (!validate_shader_target(ctx, type)) {
-      _mesa_error(ctx, GL_INVALID_ENUM, "glUseShaderProgramEXT(type)");
-      return;
-   }
-
-   if (ctx->TransformFeedback.CurrentObject->Active) {
-      _mesa_error(ctx, GL_INVALID_OPERATION,
-                  "glUseShaderProgramEXT(transform feedback is active)");
-      return;
-   }
-
-   if (program) {
-      shProg = _mesa_lookup_shader_program_err(ctx, program,
-					       "glUseShaderProgramEXT");
-      if (shProg == NULL)
-	 return;
-
-      if (!shProg->LinkStatus) {
-	 _mesa_error(ctx, GL_INVALID_OPERATION,
-		     "glUseShaderProgramEXT(program not linked)");
-	 return;
-      }
-   }
-
-   _mesa_use_shader_program(ctx, type, shProg);
-}
-
-void GLAPIENTRY
-_mesa_ActiveProgramEXT(GLuint program)
-{
-   GET_CURRENT_CONTEXT(ctx);
-   struct gl_shader_program *shProg = (program != 0)
-      ? _mesa_lookup_shader_program_err(ctx, program, "glActiveProgramEXT")
-      : NULL;
-
-   _mesa_active_program(ctx, shProg, "glActiveProgramEXT");
-   return;
-}
-
-GLuint GLAPIENTRY
-_mesa_CreateShaderProgramEXT(GLenum type, const GLchar *string)
-{
-   GET_CURRENT_CONTEXT(ctx);
-   const GLuint shader = create_shader(ctx, type);
-   GLuint program = 0;
-
-   if (shader) {
-      shader_source(ctx, shader, _mesa_strdup(string));
-      compile_shader(ctx, shader);
-
-      program = create_shader_program(ctx);
-      if (program) {
-	 struct gl_shader_program *shProg;
-	 struct gl_shader *sh;
-	 GLint compiled = GL_FALSE;
-
-	 shProg = _mesa_lookup_shader_program(ctx, program);
-	 sh = _mesa_lookup_shader(ctx, shader);
-
-	 get_shaderiv(ctx, shader, GL_COMPILE_STATUS, &compiled);
-	 if (compiled) {
-	    attach_shader(ctx, program, shader);
-	    link_program(ctx, program);
-	    detach_shader(ctx, program, shader);
-
-#if 0
-	    /* Possibly... */
-	    if (active-user-defined-varyings-in-linked-program) {
-	       append-error-to-info-log;
-	       shProg->LinkStatus = GL_FALSE;
-	    }
-#endif
-	 }
-
-	 ralloc_strcat(&shProg->InfoLog, sh->InfoLog);
-      }
-
-      delete_shader(ctx, shader);
-   }
-
-   return program;
-}
-
-/**
- * Plug in shader-related functions into API dispatch table.
- */
-void
-_mesa_init_shader_dispatch(struct _glapi_table *exec)
-{
-#if FEATURE_GL
-   /* GL_ARB_vertex/fragment_shader */
-   SET_DeleteObjectARB(exec, _mesa_DeleteObjectARB);
-   SET_GetHandleARB(exec, _mesa_GetHandleARB);
-   SET_DetachObjectARB(exec, _mesa_DetachObjectARB);
-   SET_CreateShaderObjectARB(exec, _mesa_CreateShaderObjectARB);
-   SET_ShaderSourceARB(exec, _mesa_ShaderSourceARB);
-   SET_CompileShaderARB(exec, _mesa_CompileShaderARB);
-   SET_CreateProgramObjectARB(exec, _mesa_CreateProgramObjectARB);
-   SET_AttachObjectARB(exec, _mesa_AttachObjectARB);
-   SET_LinkProgramARB(exec, _mesa_LinkProgramARB);
-   SET_UseProgramObjectARB(exec, _mesa_UseProgramObjectARB);
-   SET_ValidateProgramARB(exec, _mesa_ValidateProgramARB);
-   SET_GetObjectParameterfvARB(exec, _mesa_GetObjectParameterfvARB);
-   SET_GetObjectParameterivARB(exec, _mesa_GetObjectParameterivARB);
-   SET_GetInfoLogARB(exec, _mesa_GetInfoLogARB);
-   SET_GetAttachedObjectsARB(exec, _mesa_GetAttachedObjectsARB);
-   SET_GetShaderSourceARB(exec, _mesa_GetShaderSourceARB);
-
-   /* OpenGL 2.0 */
-   SET_AttachShader(exec, _mesa_AttachShader);
-   SET_CreateProgram(exec, _mesa_CreateProgram);
-   SET_CreateShader(exec, _mesa_CreateShader);
-   SET_DeleteProgram(exec, _mesa_DeleteProgram);
-   SET_DeleteShader(exec, _mesa_DeleteShader);
-   SET_DetachShader(exec, _mesa_DetachShader);
-   SET_GetAttachedShaders(exec, _mesa_GetAttachedShaders);
-   SET_GetProgramiv(exec, _mesa_GetProgramiv);
-   SET_GetProgramInfoLog(exec, _mesa_GetProgramInfoLog);
-   SET_GetShaderiv(exec, _mesa_GetShaderiv);
-   SET_GetShaderInfoLog(exec, _mesa_GetShaderInfoLog);
-   SET_IsProgram(exec, _mesa_IsProgram);
-   SET_IsShader(exec, _mesa_IsShader);
-
-#if FEATURE_ARB_vertex_shader
-   SET_BindAttribLocationARB(exec, _mesa_BindAttribLocationARB);
-   SET_GetActiveAttribARB(exec, _mesa_GetActiveAttribARB);
-   SET_GetAttribLocationARB(exec, _mesa_GetAttribLocationARB);
-#endif
-
-#if FEATURE_ARB_geometry_shader4
-   SET_ProgramParameteriARB(exec, _mesa_ProgramParameteriARB);
-#endif
-
-   SET_UseShaderProgramEXT(exec, _mesa_UseShaderProgramEXT);
-   SET_ActiveProgramEXT(exec, _mesa_ActiveProgramEXT);
-   SET_CreateShaderProgramEXT(exec, _mesa_CreateShaderProgramEXT);
-
-   /* GL_EXT_gpu_shader4 / GL 3.0 */
-   SET_BindFragDataLocationEXT(exec, _mesa_BindFragDataLocation);
-   SET_GetFragDataLocationEXT(exec, _mesa_GetFragDataLocation);
-
-   /* GL_ARB_ES2_compatibility */
-   SET_ReleaseShaderCompiler(exec, _mesa_ReleaseShaderCompiler);
-   SET_GetShaderPrecisionFormat(exec, _mesa_GetShaderPrecisionFormat);
-
-#endif /* FEATURE_GL */
-}
-
+/*

+ * Mesa 3-D graphics library

+ *

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

+ * Copyright (C) 2009-2010  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 shaderapi.c

+ * \author Brian Paul

+ *

+ * Implementation of GLSL-related API functions.

+ * The glUniform* functions are in uniforms.c

+ *

+ *

+ * XXX things to do:

+ * 1. Check that the right error code is generated for all _mesa_error() calls.

+ * 2. Insert FLUSH_VERTICES calls in various places

+ */

+

+

+#include "main/glheader.h"

+#include "main/context.h"

+#include "main/dispatch.h"

+#include "main/enums.h"

+#include "main/hash.h"

+#include "main/mfeatures.h"

+#include "main/mtypes.h"

+#include "main/shaderapi.h"

+#include "main/shaderobj.h"

+#include "program/program.h"

+#include "program/prog_parameter.h"

+#include "program/prog_uniform.h"

+#include "ralloc.h"

+#include <stdbool.h>

+#include "../glsl/glsl_parser_extras.h"

+

+/** Define this to enable shader substitution (see below) */

+#define SHADER_SUBST 0

+

+

+/**

+ * Return mask of GLSL_x flags by examining the MESA_GLSL env var.

+ */

+static GLbitfield

+get_shader_flags(void)

+{

+   GLbitfield flags = 0x0;

+   const char *env = _mesa_getenv("MESA_GLSL");

+

+   if (env) {

+      if (strstr(env, "dump"))

+         flags |= GLSL_DUMP;

+      if (strstr(env, "log"))

+         flags |= GLSL_LOG;

+      if (strstr(env, "nopvert"))

+         flags |= GLSL_NOP_VERT;

+      if (strstr(env, "nopfrag"))

+         flags |= GLSL_NOP_FRAG;

+      if (strstr(env, "nopt"))

+         flags |= GLSL_NO_OPT;

+      else if (strstr(env, "opt"))

+         flags |= GLSL_OPT;

+      if (strstr(env, "uniform"))

+         flags |= GLSL_UNIFORMS;

+      if (strstr(env, "useprog"))

+         flags |= GLSL_USE_PROG;

+   }

+

+   return flags;

+}

+

+

+/**

+ * Initialize context's shader state.

+ */

+void

+_mesa_init_shader_state(struct gl_context *ctx)

+{

+   /* Device drivers may override these to control what kind of instructions

+    * are generated by the GLSL compiler.

+    */

+   struct gl_shader_compiler_options options;

+   gl_shader_type sh;

+

+   memset(&options, 0, sizeof(options));

+   options.MaxUnrollIterations = 32;

+

+   /* Default pragma settings */

+   options.DefaultPragmas.Optimize = GL_TRUE;

+

+   for (sh = 0; sh < MESA_SHADER_TYPES; ++sh)

+      memcpy(&ctx->ShaderCompilerOptions[sh], &options, sizeof(options));

+

+   ctx->Shader.Flags = get_shader_flags();

+}

+

+

+/**

+ * Free the per-context shader-related state.

+ */

+void

+_mesa_free_shader_state(struct gl_context *ctx)

+{

+   _mesa_reference_shader_program(ctx, &ctx->Shader.CurrentVertexProgram, NULL);

+   _mesa_reference_shader_program(ctx, &ctx->Shader.CurrentGeometryProgram,

+				  NULL);

+   _mesa_reference_shader_program(ctx, &ctx->Shader.CurrentFragmentProgram,

+				  NULL);

+   _mesa_reference_shader_program(ctx, &ctx->Shader.ActiveProgram, NULL);

+}

+

+

+/**

+ * Return the size of the given GLSL datatype, in floats (components).

+ */

+GLint

+_mesa_sizeof_glsl_type(GLenum type)

+{

+   switch (type) {

+   case GL_FLOAT:

+   case GL_INT:

+   case GL_BOOL:

+   case GL_SAMPLER_1D:

+   case GL_SAMPLER_2D:

+   case GL_SAMPLER_3D:

+   case GL_SAMPLER_CUBE:

+   case GL_SAMPLER_1D_SHADOW:

+   case GL_SAMPLER_2D_SHADOW:

+   case GL_SAMPLER_2D_RECT_ARB:

+   case GL_SAMPLER_2D_RECT_SHADOW_ARB:

+   case GL_SAMPLER_1D_ARRAY_EXT:

+   case GL_SAMPLER_2D_ARRAY_EXT:

+   case GL_SAMPLER_1D_ARRAY_SHADOW_EXT:

+   case GL_SAMPLER_2D_ARRAY_SHADOW_EXT:

+   case GL_SAMPLER_CUBE_SHADOW_EXT:

+      return 1;

+   case GL_FLOAT_VEC2:

+   case GL_INT_VEC2:

+   case GL_UNSIGNED_INT_VEC2:

+   case GL_BOOL_VEC2:

+      return 2;

+   case GL_FLOAT_VEC3:

+   case GL_INT_VEC3:

+   case GL_UNSIGNED_INT_VEC3:

+   case GL_BOOL_VEC3:

+      return 3;

+   case GL_FLOAT_VEC4:

+   case GL_INT_VEC4:

+   case GL_UNSIGNED_INT_VEC4:

+   case GL_BOOL_VEC4:

+      return 4;

+   case GL_FLOAT_MAT2:

+   case GL_FLOAT_MAT2x3:

+   case GL_FLOAT_MAT2x4:

+      return 8; /* two float[4] vectors */

+   case GL_FLOAT_MAT3:

+   case GL_FLOAT_MAT3x2:

+   case GL_FLOAT_MAT3x4:

+      return 12; /* three float[4] vectors */

+   case GL_FLOAT_MAT4:

+   case GL_FLOAT_MAT4x2:

+   case GL_FLOAT_MAT4x3:

+      return 16;  /* four float[4] vectors */

+   default:

+      _mesa_problem(NULL, "Invalid type in _mesa_sizeof_glsl_type()");

+      return 1;

+   }

+}

+

+

+/**

+ * Copy string from <src> to <dst>, up to maxLength characters, returning

+ * length of <dst> in <length>.

+ * \param src  the strings source

+ * \param maxLength  max chars to copy

+ * \param length  returns number of chars copied

+ * \param dst  the string destination

+ */

+void

+_mesa_copy_string(GLchar *dst, GLsizei maxLength,

+                  GLsizei *length, const GLchar *src)

+{

+   GLsizei len;

+   for (len = 0; len < maxLength - 1 && src && src[len]; len++)

+      dst[len] = src[len];

+   if (maxLength > 0)

+      dst[len] = 0;

+   if (length)

+      *length = len;

+}

+

+

+

+/**

+ * Confirm that the a shader type is valid and supported by the implementation

+ *

+ * \param ctx   Current GL context

+ * \param type  Shader target

+ *

+ */

+static bool

+validate_shader_target(const struct gl_context *ctx, GLenum type)

+{

+   switch (type) {

+#if FEATURE_ARB_fragment_shader

+   case GL_FRAGMENT_SHADER:

+      return ctx->Extensions.ARB_fragment_shader;

+#endif

+#if FEATURE_ARB_vertex_shader

+   case GL_VERTEX_SHADER:

+      return ctx->Extensions.ARB_vertex_shader;

+#endif

+#if FEATURE_ARB_geometry_shader4

+   case GL_GEOMETRY_SHADER_ARB:

+      return ctx->Extensions.ARB_geometry_shader4;

+#endif

+   default:

+      return false;

+   }

+}

+

+

+/**

+ * Find the length of the longest transform feedback varying name

+ * which was specified with glTransformFeedbackVaryings().

+ */

+static GLint

+longest_feedback_varying_name(const struct gl_shader_program *shProg)

+{

+   GLuint i;

+   GLint max = 0;

+   for (i = 0; i < shProg->TransformFeedback.NumVarying; i++) {

+      GLint len = strlen(shProg->TransformFeedback.VaryingNames[i]);

+      if (len > max)

+         max = len;

+   }

+   return max;

+}

+

+

+

+static GLboolean

+is_program(struct gl_context *ctx, GLuint name)

+{

+   struct gl_shader_program *shProg = _mesa_lookup_shader_program(ctx, name);

+   return shProg ? GL_TRUE : GL_FALSE;

+}

+

+

+static GLboolean

+is_shader(struct gl_context *ctx, GLuint name)

+{

+   struct gl_shader *shader = _mesa_lookup_shader(ctx, name);

+   return shader ? GL_TRUE : GL_FALSE;

+}

+

+

+/**

+ * Attach shader to a shader program.

+ */

+static void

+attach_shader(struct gl_context *ctx, GLuint program, GLuint shader)

+{

+   struct gl_shader_program *shProg;

+   struct gl_shader *sh;

+   GLuint i, n;

+

+   shProg = _mesa_lookup_shader_program_err(ctx, program, "glAttachShader");

+   if (!shProg)

+      return;

+

+   sh = _mesa_lookup_shader_err(ctx, shader, "glAttachShader");

+   if (!sh) {

+      return;

+   }

+

+   n = shProg->NumShaders;

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

+      if (shProg->Shaders[i] == sh) {

+         /* The shader is already attched to this program.  The

+          * GL_ARB_shader_objects spec says:

+          *

+          *     "The error INVALID_OPERATION is generated by AttachObjectARB

+          *     if <obj> is already attached to <containerObj>."

+          */

+         _mesa_error(ctx, GL_INVALID_OPERATION, "glAttachShader");

+         return;

+      }

+   }

+

+   /* grow list */

+   shProg->Shaders = (struct gl_shader **)

+      _mesa_realloc(shProg->Shaders,

+                    n * sizeof(struct gl_shader *),

+                    (n + 1) * sizeof(struct gl_shader *));

+   if (!shProg->Shaders) {

+      _mesa_error(ctx, GL_OUT_OF_MEMORY, "glAttachShader");

+      return;

+   }

+

+   /* append */

+   shProg->Shaders[n] = NULL; /* since realloc() didn't zero the new space */

+   _mesa_reference_shader(ctx, &shProg->Shaders[n], sh);

+   shProg->NumShaders++;

+}

+

+

+static GLint

+get_attrib_location(struct gl_context *ctx, GLuint program, const GLchar *name)

+{

+   struct gl_shader_program *shProg

+      = _mesa_lookup_shader_program_err(ctx, program, "glGetAttribLocation");

+

+   if (!shProg) {

+      return -1;

+   }

+

+   if (!shProg->LinkStatus) {

+      _mesa_error(ctx, GL_INVALID_OPERATION,

+                  "glGetAttribLocation(program not linked)");

+      return -1;

+   }

+

+   if (!name)

+      return -1;

+

+   if (shProg->VertexProgram) {

+      const struct gl_program_parameter_list *attribs =

+         shProg->VertexProgram->Base.Attributes;

+      if (attribs) {

+         GLint i = _mesa_lookup_parameter_index(attribs, -1, name);

+         if (i >= 0) {

+            return attribs->Parameters[i].StateIndexes[0];

+         }

+      }

+   }

+   return -1;

+}

+

+

+static void

+bind_attrib_location(struct gl_context *ctx, GLuint program, GLuint index,

+                     const GLchar *name)

+{

+   struct gl_shader_program *shProg;

+   const GLint size = -1; /* unknown size */

+   GLint i, oldIndex;

+   GLenum datatype = GL_FLOAT_VEC4;

+

+   shProg = _mesa_lookup_shader_program_err(ctx, program,

+                                            "glBindAttribLocation");

+   if (!shProg) {

+      return;

+   }

+

+   if (!name)

+      return;

+

+   if (strncmp(name, "gl_", 3) == 0) {

+      _mesa_error(ctx, GL_INVALID_OPERATION,

+                  "glBindAttribLocation(illegal name)");

+      return;

+   }

+

+   if (index >= ctx->Const.VertexProgram.MaxAttribs) {

+      _mesa_error(ctx, GL_INVALID_VALUE, "glBindAttribLocation(index)");

+      return;

+   }

+

+   if (shProg->LinkStatus) {

+      /* get current index/location for the attribute */

+      oldIndex = get_attrib_location(ctx, program, name);

+   }

+   else {

+      oldIndex = -1;

+   }

+

+   /* this will replace the current value if it's already in the list */

+   i = _mesa_add_attribute(shProg->Attributes, name, size, datatype, index);

+   if (i < 0) {

+      _mesa_error(ctx, GL_OUT_OF_MEMORY, "glBindAttribLocation");

+      return;

+   }

+

+   /*

+    * Note that this attribute binding won't go into effect until

+    * glLinkProgram is called again.

+    */

+}

+

+

+static void

+bind_frag_data_location(struct gl_context *ctx, GLuint program,

+                        GLuint colorNumber, const GLchar *name)

+{

+   _mesa_problem(ctx, "bind_frag_data_location() not implemented yet");

+}

+

+

+static GLuint

+create_shader(struct gl_context *ctx, GLenum type)

+{

+   struct gl_shader *sh;

+   GLuint name;

+

+   if (!validate_shader_target(ctx, type)) {

+      _mesa_error(ctx, GL_INVALID_ENUM, "CreateShader(type)");

+      return 0;

+   }

+

+   name = _mesa_HashFindFreeKeyBlock(ctx->Shared->ShaderObjects, 1);

+   sh = ctx->Driver.NewShader(ctx, name, type);

+   _mesa_HashInsert(ctx->Shared->ShaderObjects, name, sh);

+

+   return name;

+}

+

+

+static GLuint 

+create_shader_program(struct gl_context *ctx)

+{

+   GLuint name;

+   struct gl_shader_program *shProg;

+

+   name = _mesa_HashFindFreeKeyBlock(ctx->Shared->ShaderObjects, 1);

+

+   shProg = ctx->Driver.NewShaderProgram(ctx, name);

+

+   _mesa_HashInsert(ctx->Shared->ShaderObjects, name, shProg);

+

+   assert(shProg->RefCount == 1);

+

+   return name;

+}

+

+

+/**

+ * Named w/ "2" to indicate OpenGL 2.x vs GL_ARB_fragment_programs's

+ * DeleteProgramARB.

+ */

+static void

+delete_shader_program(struct gl_context *ctx, GLuint name)

+{

+   /*

+    * NOTE: deleting shaders/programs works a bit differently than

+    * texture objects (and buffer objects, etc).  Shader/program

+    * handles/IDs exist in the hash table until the object is really

+    * deleted (refcount==0).  With texture objects, the handle/ID is

+    * removed from the hash table in glDeleteTextures() while the tex

+    * object itself might linger until its refcount goes to zero.

+    */

+   struct gl_shader_program *shProg;

+

+   shProg = _mesa_lookup_shader_program_err(ctx, name, "glDeleteProgram");

+   if (!shProg)

+      return;

+

+   shProg->DeletePending = GL_TRUE;

+

+   /* effectively, decr shProg's refcount */

+   _mesa_reference_shader_program(ctx, &shProg, NULL);

+}

+

+

+static void

+delete_shader(struct gl_context *ctx, GLuint shader)

+{

+   struct gl_shader *sh;

+

+   sh = _mesa_lookup_shader_err(ctx, shader, "glDeleteShader");

+   if (!sh)

+      return;

+

+   sh->DeletePending = GL_TRUE;

+

+   /* effectively, decr sh's refcount */

+   _mesa_reference_shader(ctx, &sh, NULL);

+}

+

+

+static void

+detach_shader(struct gl_context *ctx, GLuint program, GLuint shader)

+{

+   struct gl_shader_program *shProg;

+   GLuint n;

+   GLuint i, j;

+

+   shProg = _mesa_lookup_shader_program_err(ctx, program, "glDetachShader");

+   if (!shProg)

+      return;

+

+   n = shProg->NumShaders;

+

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

+      if (shProg->Shaders[i]->Name == shader) {

+         /* found it */

+         struct gl_shader **newList;

+

+         /* release */

+         _mesa_reference_shader(ctx, &shProg->Shaders[i], NULL);

+

+         /* alloc new, smaller array */

+         newList = (struct gl_shader **)

+            malloc((n - 1) * sizeof(struct gl_shader *));

+         if (!newList) {

+            _mesa_error(ctx, GL_OUT_OF_MEMORY, "glDetachShader");

+            return;

+         }

+         for (j = 0; j < i; j++) {

+            newList[j] = shProg->Shaders[j];

+         }

+         while (++i < n)

+            newList[j++] = shProg->Shaders[i];

+         free(shProg->Shaders);

+

+         shProg->Shaders = newList;

+         shProg->NumShaders = n - 1;

+

+#ifdef DEBUG

+         /* sanity check */

+         {

+            for (j = 0; j < shProg->NumShaders; j++) {

+               assert(shProg->Shaders[j]->Type == GL_VERTEX_SHADER ||

+                      shProg->Shaders[j]->Type == GL_FRAGMENT_SHADER);

+               assert(shProg->Shaders[j]->RefCount > 0);

+            }

+         }

+#endif

+

+         return;

+      }

+   }

+

+   /* not found */

+   {

+      GLenum err;

+      if (is_shader(ctx, shader))

+         err = GL_INVALID_OPERATION;

+      else if (is_program(ctx, shader))

+         err = GL_INVALID_OPERATION;

+      else

+         err = GL_INVALID_VALUE;

+      _mesa_error(ctx, err, "glDetachProgram(shader)");

+      return;

+   }

+}

+

+

+static void

+get_active_attrib(struct gl_context *ctx, GLuint program, GLuint index,

+                  GLsizei maxLength, GLsizei *length, GLint *size,

+                  GLenum *type, GLchar *nameOut)

+{

+   const struct gl_program_parameter_list *attribs = NULL;

+   struct gl_shader_program *shProg;

+

+   shProg = _mesa_lookup_shader_program_err(ctx, program, "glGetActiveAttrib");

+   if (!shProg)

+      return;

+

+   if (shProg->VertexProgram)

+      attribs = shProg->VertexProgram->Base.Attributes;

+

+   if (!attribs || index >= attribs->NumParameters) {

+      _mesa_error(ctx, GL_INVALID_VALUE, "glGetActiveAttrib(index)");

+      return;

+   }

+

+   _mesa_copy_string(nameOut, maxLength, length,

+                     attribs->Parameters[index].Name);

+

+   if (size)

+      *size = attribs->Parameters[index].Size

+         / _mesa_sizeof_glsl_type(attribs->Parameters[index].DataType);

+

+   if (type)

+      *type = attribs->Parameters[index].DataType;

+}

+

+

+/**

+ * Return list of shaders attached to shader program.

+ */

+static void

+get_attached_shaders(struct gl_context *ctx, GLuint program, GLsizei maxCount,

+                     GLsizei *count, GLuint *obj)

+{

+   struct gl_shader_program *shProg =

+      _mesa_lookup_shader_program_err(ctx, program, "glGetAttachedShaders");

+   if (shProg) {

+      GLuint i;

+      for (i = 0; i < (GLuint) maxCount && i < shProg->NumShaders; i++) {

+         obj[i] = shProg->Shaders[i]->Name;

+      }

+      if (count)

+         *count = i;

+   }

+}

+

+

+static GLint

+get_frag_data_location(struct gl_context *ctx, GLuint program,

+                       const GLchar *name)

+{

+   _mesa_problem(ctx, "get_frag_data_location() not implemented yet");

+   return -1;

+}

+

+

+

+/**

+ * glGetHandleARB() - return ID/name of currently bound shader program.

+ */

+static GLuint

+get_handle(struct gl_context *ctx, GLenum pname)

+{

+   if (pname == GL_PROGRAM_OBJECT_ARB) {

+      if (ctx->Shader.ActiveProgram)

+         return ctx->Shader.ActiveProgram->Name;

+      else

+         return 0;

+   }

+   else {

+      _mesa_error(ctx, GL_INVALID_ENUM, "glGetHandleARB");

+      return 0;

+   }

+}

+

+

+/**

+ * glGetProgramiv() - get shader program state.

+ * Note that this is for GLSL shader programs, not ARB vertex/fragment

+ * programs (see glGetProgramivARB).

+ */

+static void

+get_programiv(struct gl_context *ctx, GLuint program, GLenum pname, GLint *params)

+{

+   const struct gl_program_parameter_list *attribs;

+   struct gl_shader_program *shProg

+      = _mesa_lookup_shader_program(ctx, program);

+

+   if (!shProg) {

+      _mesa_error(ctx, GL_INVALID_VALUE, "glGetProgramiv(program)");

+      return;

+   }

+

+   if (shProg->VertexProgram)

+      attribs = shProg->VertexProgram->Base.Attributes;

+   else

+      attribs = NULL;

+

+   switch (pname) {

+   case GL_DELETE_STATUS:

+      *params = shProg->DeletePending;

+      break; 

+   case GL_LINK_STATUS:

+      *params = shProg->LinkStatus;

+      break;

+   case GL_VALIDATE_STATUS:

+      *params = shProg->Validated;

+      break;

+   case GL_INFO_LOG_LENGTH:

+      *params = shProg->InfoLog ? strlen(shProg->InfoLog) + 1 : 0;

+      break;

+   case GL_ATTACHED_SHADERS:

+      *params = shProg->NumShaders;

+      break;

+   case GL_ACTIVE_ATTRIBUTES:

+      *params = attribs ? attribs->NumParameters : 0;

+      break;

+   case GL_ACTIVE_ATTRIBUTE_MAX_LENGTH:

+      *params = _mesa_longest_parameter_name(attribs, PROGRAM_INPUT) + 1;

+      break;

+   case GL_ACTIVE_UNIFORMS:

+      *params = shProg->Uniforms ? shProg->Uniforms->NumUniforms : 0;

+      break;

+   case GL_ACTIVE_UNIFORM_MAX_LENGTH:

+      *params = _mesa_longest_uniform_name(shProg->Uniforms);

+      if (*params > 0)

+         (*params)++;  /* add one for terminating zero */

+      break;

+   case GL_PROGRAM_BINARY_LENGTH_OES:

+      *params = 0;

+      break;

+#if FEATURE_EXT_transform_feedback

+   case GL_TRANSFORM_FEEDBACK_VARYINGS:

+      *params = shProg->TransformFeedback.NumVarying;

+      break;

+   case GL_TRANSFORM_FEEDBACK_VARYING_MAX_LENGTH:

+      *params = longest_feedback_varying_name(shProg) + 1;

+      break;

+   case GL_TRANSFORM_FEEDBACK_BUFFER_MODE:

+      *params = shProg->TransformFeedback.BufferMode;

+      break;

+#endif

+#if FEATURE_ARB_geometry_shader4

+   case GL_GEOMETRY_VERTICES_OUT_ARB:

+      *params = shProg->Geom.VerticesOut;

+      break;

+   case GL_GEOMETRY_INPUT_TYPE_ARB:

+      *params = shProg->Geom.InputType;

+      break;

+   case GL_GEOMETRY_OUTPUT_TYPE_ARB:

+      *params = shProg->Geom.OutputType;

+      break;

+#endif

+   default:

+      _mesa_error(ctx, GL_INVALID_ENUM, "glGetProgramiv(pname)");

+      return;

+   }

+}

+

+

+/**

+ * glGetShaderiv() - get GLSL shader state

+ */

+static void

+get_shaderiv(struct gl_context *ctx, GLuint name, GLenum pname, GLint *params)

+{

+   struct gl_shader *shader =

+      _mesa_lookup_shader_err(ctx, name, "glGetShaderiv");

+

+   if (!shader) {

+      return;

+   }

+

+   switch (pname) {

+   case GL_SHADER_TYPE:

+      *params = shader->Type;

+      break;

+   case GL_DELETE_STATUS:

+      *params = shader->DeletePending;

+      break;

+   case GL_COMPILE_STATUS:

+      *params = shader->CompileStatus;

+      break;

+   case GL_INFO_LOG_LENGTH:

+      *params = shader->InfoLog ? strlen(shader->InfoLog) + 1 : 0;

+      break;

+   case GL_SHADER_SOURCE_LENGTH:

+      *params = shader->Source ? strlen((char *) shader->Source) + 1 : 0;

+      break;

+   default:

+      _mesa_error(ctx, GL_INVALID_ENUM, "glGetShaderiv(pname)");

+      return;

+   }

+}

+

+

+static void

+get_program_info_log(struct gl_context *ctx, GLuint program, GLsizei bufSize,

+                     GLsizei *length, GLchar *infoLog)

+{

+   struct gl_shader_program *shProg

+      = _mesa_lookup_shader_program(ctx, program);

+   if (!shProg) {

+      _mesa_error(ctx, GL_INVALID_VALUE, "glGetProgramInfoLog(program)");

+      return;

+   }

+   _mesa_copy_string(infoLog, bufSize, length, shProg->InfoLog);

+}

+

+

+static void

+get_shader_info_log(struct gl_context *ctx, GLuint shader, GLsizei bufSize,

+                    GLsizei *length, GLchar *infoLog)

+{

+   struct gl_shader *sh = _mesa_lookup_shader(ctx, shader);

+   if (!sh) {

+      _mesa_error(ctx, GL_INVALID_VALUE, "glGetShaderInfoLog(shader)");

+      return;

+   }

+   _mesa_copy_string(infoLog, bufSize, length, sh->InfoLog);

+}

+

+

+/**

+ * Return shader source code.

+ */

+static void

+get_shader_source(struct gl_context *ctx, GLuint shader, GLsizei maxLength,

+                  GLsizei *length, GLchar *sourceOut)

+{

+   struct gl_shader *sh;

+   sh = _mesa_lookup_shader_err(ctx, shader, "glGetShaderSource");

+   if (!sh) {

+      return;

+   }

+   _mesa_copy_string(sourceOut, maxLength, length, sh->Source);

+}

+

+

+/**

+ * Set/replace shader source code.

+ */

+static void

+shader_source(struct gl_context *ctx, GLuint shader, const GLchar *source)

+{

+   struct gl_shader *sh;

+

+   sh = _mesa_lookup_shader_err(ctx, shader, "glShaderSource");

+   if (!sh)

+      return;

+

+   /* free old shader source string and install new one */

+   if (sh->Source) {

+      free((void *) sh->Source);

+   }

+   sh->Source = source;

+   sh->CompileStatus = GL_FALSE;

+#ifdef DEBUG

+   sh->SourceChecksum = _mesa_str_checksum(sh->Source);

+#endif

+}

+

+

+/**

+ * Compile a shader.

+ */

+static void

+compile_shader(struct gl_context *ctx, GLuint shaderObj)

+{

+   struct gl_shader *sh;

+   struct gl_shader_compiler_options *options;

+

+   sh = _mesa_lookup_shader_err(ctx, shaderObj, "glCompileShader");

+   if (!sh)

+      return;

+

+   options = &ctx->ShaderCompilerOptions[_mesa_shader_type_to_index(sh->Type)];

+

+   /* set default pragma state for shader */

+   sh->Pragmas = options->DefaultPragmas;

+

+   /* this call will set the sh->CompileStatus field to indicate if

+    * compilation was successful.

+    */

+   _mesa_glsl_compile_shader(ctx, sh);

+}

+

+

+/**

+ * Link a program's shaders.

+ */

+static void

+link_program(struct gl_context *ctx, GLuint program)

+{

+   struct gl_shader_program *shProg;

+   struct gl_transform_feedback_object *obj =

+      ctx->TransformFeedback.CurrentObject;

+

+   shProg = _mesa_lookup_shader_program_err(ctx, program, "glLinkProgram");

+   if (!shProg)

+      return;

+

+   if (obj->Active

+       && (shProg == ctx->Shader.CurrentVertexProgram

+	   || shProg == ctx->Shader.CurrentGeometryProgram

+	   || shProg == ctx->Shader.CurrentFragmentProgram)) {

+      _mesa_error(ctx, GL_INVALID_OPERATION,

+                  "glLinkProgram(transform feedback active");

+      return;

+   }

+

+   FLUSH_VERTICES(ctx, _NEW_PROGRAM);

+

+   _mesa_glsl_link_shader(ctx, shProg);

+

+   /* debug code */

+   if (0) {

+      GLuint i;

+

+      printf("Link %u shaders in program %u: %s\n",

+                   shProg->NumShaders, shProg->Name,

+                   shProg->LinkStatus ? "Success" : "Failed");

+

+      for (i = 0; i < shProg->NumShaders; i++) {

+         printf(" shader %u, type 0x%x\n",

+                      shProg->Shaders[i]->Name,

+                      shProg->Shaders[i]->Type);

+      }

+   }

+}

+

+

+/**

+ * Print basic shader info (for debug).

+ */

+static void

+print_shader_info(const struct gl_shader_program *shProg)

+{

+   GLuint i;

+

+   printf("Mesa: glUseProgram(%u)\n", shProg->Name);

+   for (i = 0; i < shProg->NumShaders; i++) {

+      const char *s;

+      switch (shProg->Shaders[i]->Type) {

+      case GL_VERTEX_SHADER:

+         s = "vertex";

+         break;

+      case GL_FRAGMENT_SHADER:

+         s = "fragment";

+         break;

+      case GL_GEOMETRY_SHADER:

+         s = "geometry";

+         break;

+      default:

+         s = "";

+      }

+      printf("  %s shader %u, checksum %u\n", s, 

+	     shProg->Shaders[i]->Name,

+	     shProg->Shaders[i]->SourceChecksum);

+   }

+   if (shProg->VertexProgram)

+      printf("  vert prog %u\n", shProg->VertexProgram->Base.Id);

+   if (shProg->FragmentProgram)

+      printf("  frag prog %u\n", shProg->FragmentProgram->Base.Id);

+}

+

+

+/**

+ * Use the named shader program for subsequent glUniform calls

+ */

+void

+_mesa_active_program(struct gl_context *ctx, struct gl_shader_program *shProg,

+		     const char *caller)

+{

+   if ((shProg != NULL) && !shProg->LinkStatus) {

+      _mesa_error(ctx, GL_INVALID_OPERATION,

+		  "%s(program %u not linked)", caller, shProg->Name);

+      return;

+   }

+

+   if (ctx->Shader.ActiveProgram != shProg) {

+      _mesa_reference_shader_program(ctx, &ctx->Shader.ActiveProgram, shProg);

+   }

+}

+

+/**

+ */

+static bool

+use_shader_program(struct gl_context *ctx, GLenum type,

+		   struct gl_shader_program *shProg)

+{

+   struct gl_shader_program **target;

+

+   switch (type) {

+#if FEATURE_ARB_vertex_shader

+   case GL_VERTEX_SHADER:

+      target = &ctx->Shader.CurrentVertexProgram;

+      if ((shProg == NULL)

+	  || (shProg->_LinkedShaders[MESA_SHADER_VERTEX] == NULL)) {

+	 shProg = NULL;

+      }

+      break;

+#endif

+#if FEATURE_ARB_geometry_shader4

+   case GL_GEOMETRY_SHADER_ARB:

+      target = &ctx->Shader.CurrentGeometryProgram;

+      if ((shProg == NULL)

+	  || (shProg->_LinkedShaders[MESA_SHADER_GEOMETRY] == NULL)) {

+	 shProg = NULL;

+      }

+      break;

+#endif

+#if FEATURE_ARB_fragment_shader

+   case GL_FRAGMENT_SHADER:

+      target = &ctx->Shader.CurrentFragmentProgram;

+      if ((shProg == NULL)

+	  || (shProg->_LinkedShaders[MESA_SHADER_FRAGMENT] == NULL)) {

+	 shProg = NULL;

+      }

+      break;

+#endif

+   default:

+      return false;

+   }

+

+   if (*target != shProg) {

+      FLUSH_VERTICES(ctx, _NEW_PROGRAM | _NEW_PROGRAM_CONSTANTS);

+      _mesa_reference_shader_program(ctx, target, shProg);

+      return true;

+   }

+

+   return false;

+}

+

+/**

+ * Use the named shader program for subsequent rendering.

+ */

+void

+_mesa_use_program(struct gl_context *ctx, struct gl_shader_program *shProg)

+{

+   use_shader_program(ctx, GL_VERTEX_SHADER, shProg);

+   use_shader_program(ctx, GL_GEOMETRY_SHADER_ARB, shProg);

+   use_shader_program(ctx, GL_FRAGMENT_SHADER, shProg);

+   _mesa_active_program(ctx, shProg, "glUseProgram");

+

+   if (ctx->Driver.UseProgram)

+      ctx->Driver.UseProgram(ctx, shProg);

+}

+

+

+/**

+ * Validate a program's samplers.

+ * Specifically, check that there aren't two samplers of different types

+ * pointing to the same texture unit.

+ * \return GL_TRUE if valid, GL_FALSE if invalid

+ */

+static GLboolean

+validate_samplers(const struct gl_program *prog, char *errMsg)

+{

+   static const char *targetName[] = {

+      "TEXTURE_2D_ARRAY",

+      "TEXTURE_1D_ARRAY",

+      "TEXTURE_CUBE",

+      "TEXTURE_3D",

+      "TEXTURE_RECT",

+      "TEXTURE_2D",

+      "TEXTURE_1D",

+   };

+   GLint targetUsed[MAX_TEXTURE_IMAGE_UNITS];

+   GLbitfield samplersUsed = prog->SamplersUsed;

+   GLuint i;

+

+   assert(Elements(targetName) == NUM_TEXTURE_TARGETS);

+

+   if (samplersUsed == 0x0)

+      return GL_TRUE;

+

+   for (i = 0; i < Elements(targetUsed); i++)

+      targetUsed[i] = -1;

+

+   /* walk over bits which are set in 'samplers' */

+   while (samplersUsed) {

+      GLuint unit;

+      gl_texture_index target;

+      GLint sampler = _mesa_ffs(samplersUsed) - 1;

+      assert(sampler >= 0);

+      assert(sampler < MAX_TEXTURE_IMAGE_UNITS);

+      unit = prog->SamplerUnits[sampler];

+      target = prog->SamplerTargets[sampler];

+      if (targetUsed[unit] != -1 && targetUsed[unit] != (int) target) {

+         _mesa_snprintf(errMsg, 100,

+		  "Texture unit %d is accessed both as %s and %s",

+		  unit, targetName[targetUsed[unit]], targetName[target]);

+         return GL_FALSE;

+      }

+      targetUsed[unit] = target;

+      samplersUsed ^= (1 << sampler);

+   }

+

+   return GL_TRUE;

+}

+

+

+/**

+ * Do validation of the given shader program.

+ * \param errMsg  returns error message if validation fails.

+ * \return GL_TRUE if valid, GL_FALSE if invalid (and set errMsg)

+ */

+static GLboolean

+validate_shader_program(const struct gl_shader_program *shProg,

+                        char *errMsg)

+{

+   const struct gl_vertex_program *vp = shProg->VertexProgram;

+   const struct gl_fragment_program *fp = shProg->FragmentProgram;

+

+   if (!shProg->LinkStatus) {

+      return GL_FALSE;

+   }

+

+   /* From the GL spec, a program is invalid if any of these are true:

+

+     any two active samplers in the current program object are of

+     different types, but refer to the same texture image unit,

+

+     any active sampler in the current program object refers to a texture

+     image unit where fixed-function fragment processing accesses a

+     texture target that does not match the sampler type, or 

+

+     the sum of the number of active samplers in the program and the

+     number of texture image units enabled for fixed-function fragment

+     processing exceeds the combined limit on the total number of texture

+     image units allowed.

+   */

+

+

+   /*

+    * Check: any two active samplers in the current program object are of

+    * different types, but refer to the same texture image unit,

+    */

+   if (vp && !validate_samplers(&vp->Base, errMsg)) {

+      return GL_FALSE;

+   }

+   if (fp && !validate_samplers(&fp->Base, errMsg)) {

+      return GL_FALSE;

+   }

+

+   return GL_TRUE;

+}

+

+

+/**

+ * Called via glValidateProgram()

+ */

+static void

+validate_program(struct gl_context *ctx, GLuint program)

+{

+   struct gl_shader_program *shProg;

+   char errMsg[100];

+

+   shProg = _mesa_lookup_shader_program_err(ctx, program, "glValidateProgram");

+   if (!shProg) {

+      return;

+   }

+

+   shProg->Validated = validate_shader_program(shProg, errMsg);

+   if (!shProg->Validated) {

+      /* update info log */

+      if (shProg->InfoLog) {

+         ralloc_free(shProg->InfoLog);

+      }

+      shProg->InfoLog = ralloc_strdup(shProg, errMsg);

+   }

+}

+

+

+

+void GLAPIENTRY

+_mesa_AttachObjectARB(GLhandleARB program, GLhandleARB shader)

+{

+   GET_CURRENT_CONTEXT(ctx);

+   attach_shader(ctx, program, shader);

+}

+

+

+void GLAPIENTRY

+_mesa_AttachShader(GLuint program, GLuint shader)

+{

+   GET_CURRENT_CONTEXT(ctx);

+   attach_shader(ctx, program, shader);

+}

+

+

+void GLAPIENTRY

+_mesa_BindAttribLocationARB(GLhandleARB program, GLuint index,

+                            const GLcharARB *name)

+{

+   GET_CURRENT_CONTEXT(ctx);

+   bind_attrib_location(ctx, program, index, name);

+}

+

+

+/* GL_EXT_gpu_shader4, GL3 */

+void GLAPIENTRY

+_mesa_BindFragDataLocation(GLuint program, GLuint colorNumber,

+                           const GLchar *name)

+{

+   GET_CURRENT_CONTEXT(ctx);

+   bind_frag_data_location(ctx, program, colorNumber, name);

+}

+

+

+void GLAPIENTRY

+_mesa_CompileShaderARB(GLhandleARB shaderObj)

+{

+   GET_CURRENT_CONTEXT(ctx);

+   if (MESA_VERBOSE & VERBOSE_API)

+      _mesa_debug(ctx, "glCompileShader %u\n", shaderObj);

+   compile_shader(ctx, shaderObj);

+}

+

+

+GLuint GLAPIENTRY

+_mesa_CreateShader(GLenum type)

+{

+   GET_CURRENT_CONTEXT(ctx);

+   if (MESA_VERBOSE & VERBOSE_API)

+      _mesa_debug(ctx, "glCreateShader %s\n", _mesa_lookup_enum_by_nr(type));

+   return create_shader(ctx, type);

+}

+

+

+GLhandleARB GLAPIENTRY

+_mesa_CreateShaderObjectARB(GLenum type)

+{

+   GET_CURRENT_CONTEXT(ctx);

+   return create_shader(ctx, type);

+}

+

+

+GLuint GLAPIENTRY

+_mesa_CreateProgram(void)

+{

+   GET_CURRENT_CONTEXT(ctx);

+   if (MESA_VERBOSE & VERBOSE_API)

+      _mesa_debug(ctx, "glCreateProgram\n");

+   return create_shader_program(ctx);

+}

+

+

+GLhandleARB GLAPIENTRY

+_mesa_CreateProgramObjectARB(void)

+{

+   GET_CURRENT_CONTEXT(ctx);

+   return create_shader_program(ctx);

+}

+

+

+void GLAPIENTRY

+_mesa_DeleteObjectARB(GLhandleARB obj)

+{

+   if (MESA_VERBOSE & VERBOSE_API) {

+      GET_CURRENT_CONTEXT(ctx);

+      _mesa_debug(ctx, "glDeleteObjectARB(%u)\n", obj);

+   }

+

+   if (obj) {

+      GET_CURRENT_CONTEXT(ctx);

+      FLUSH_VERTICES(ctx, 0);

+      if (is_program(ctx, obj)) {

+         delete_shader_program(ctx, obj);

+      }

+      else if (is_shader(ctx, obj)) {

+         delete_shader(ctx, obj);

+      }

+      else {

+         /* error? */

+      }

+   }

+}

+

+

+void GLAPIENTRY

+_mesa_DeleteProgram(GLuint name)

+{

+   if (name) {

+      GET_CURRENT_CONTEXT(ctx);

+      FLUSH_VERTICES(ctx, 0);

+      delete_shader_program(ctx, name);

+   }

+}

+

+

+void GLAPIENTRY

+_mesa_DeleteShader(GLuint name)

+{

+   if (name) {

+      GET_CURRENT_CONTEXT(ctx);

+      FLUSH_VERTICES(ctx, 0);

+      delete_shader(ctx, name);

+   }

+}

+

+

+void GLAPIENTRY

+_mesa_DetachObjectARB(GLhandleARB program, GLhandleARB shader)

+{

+   GET_CURRENT_CONTEXT(ctx);

+   detach_shader(ctx, program, shader);

+}

+

+

+void GLAPIENTRY

+_mesa_DetachShader(GLuint program, GLuint shader)

+{

+   GET_CURRENT_CONTEXT(ctx);

+   detach_shader(ctx, program, shader);

+}

+

+

+void GLAPIENTRY

+_mesa_GetActiveAttribARB(GLhandleARB program, GLuint index,

+                         GLsizei maxLength, GLsizei * length, GLint * size,

+                         GLenum * type, GLcharARB * name)

+{

+   GET_CURRENT_CONTEXT(ctx);

+   get_active_attrib(ctx, program, index, maxLength, length, size, type, name);

+}

+

+

+void GLAPIENTRY

+_mesa_GetAttachedObjectsARB(GLhandleARB container, GLsizei maxCount,

+                            GLsizei * count, GLhandleARB * obj)

+{

+   GET_CURRENT_CONTEXT(ctx);

+   get_attached_shaders(ctx, container, maxCount, count, obj);

+}

+

+

+void GLAPIENTRY

+_mesa_GetAttachedShaders(GLuint program, GLsizei maxCount,

+                         GLsizei *count, GLuint *obj)

+{

+   GET_CURRENT_CONTEXT(ctx);

+   get_attached_shaders(ctx, program, maxCount, count, obj);

+}

+

+

+GLint GLAPIENTRY

+_mesa_GetAttribLocationARB(GLhandleARB program, const GLcharARB * name)

+{

+   GET_CURRENT_CONTEXT(ctx);

+   return get_attrib_location(ctx, program, name);

+}

+

+

+/* GL_EXT_gpu_shader4, GL3 */

+GLint GLAPIENTRY

+_mesa_GetFragDataLocation(GLuint program, const GLchar *name)

+{

+   GET_CURRENT_CONTEXT(ctx);

+   return get_frag_data_location(ctx, program, name);

+}

+

+

+

+void GLAPIENTRY

+_mesa_GetInfoLogARB(GLhandleARB object, GLsizei maxLength, GLsizei * length,

+                    GLcharARB * infoLog)

+{

+   GET_CURRENT_CONTEXT(ctx);

+   if (is_program(ctx, object)) {

+      get_program_info_log(ctx, object, maxLength, length, infoLog);

+   }

+   else if (is_shader(ctx, object)) {

+      get_shader_info_log(ctx, object, maxLength, length, infoLog);

+   }

+   else {

+      _mesa_error(ctx, GL_INVALID_OPERATION, "glGetInfoLogARB");

+   }

+}

+

+

+void GLAPIENTRY

+_mesa_GetObjectParameterivARB(GLhandleARB object, GLenum pname, GLint *params)

+{

+   GET_CURRENT_CONTEXT(ctx);

+   /* Implement in terms of GetProgramiv, GetShaderiv */

+   if (is_program(ctx, object)) {

+      if (pname == GL_OBJECT_TYPE_ARB) {

+	 *params = GL_PROGRAM_OBJECT_ARB;

+      }

+      else {

+	 get_programiv(ctx, object, pname, params);

+      }

+   }

+   else if (is_shader(ctx, object)) {

+      if (pname == GL_OBJECT_TYPE_ARB) {

+	 *params = GL_SHADER_OBJECT_ARB;

+      }

+      else {

+	 get_shaderiv(ctx, object, pname, params);

+      }

+   }

+   else {

+      _mesa_error(ctx, GL_INVALID_VALUE, "glGetObjectParameterivARB");

+   }

+}

+

+

+void GLAPIENTRY

+_mesa_GetObjectParameterfvARB(GLhandleARB object, GLenum pname,

+                              GLfloat *params)

+{

+   GLint iparams[1];  /* XXX is one element enough? */

+   _mesa_GetObjectParameterivARB(object, pname, iparams);

+   params[0] = (GLfloat) iparams[0];

+}

+

+

+void GLAPIENTRY

+_mesa_GetProgramiv(GLuint program, GLenum pname, GLint *params)

+{

+   GET_CURRENT_CONTEXT(ctx);

+   get_programiv(ctx, program, pname, params);

+}

+

+

+void GLAPIENTRY

+_mesa_GetShaderiv(GLuint shader, GLenum pname, GLint *params)

+{

+   GET_CURRENT_CONTEXT(ctx);

+   get_shaderiv(ctx, shader, pname, params);

+}

+

+

+void GLAPIENTRY

+_mesa_GetProgramInfoLog(GLuint program, GLsizei bufSize,

+                        GLsizei *length, GLchar *infoLog)

+{

+   GET_CURRENT_CONTEXT(ctx);

+   get_program_info_log(ctx, program, bufSize, length, infoLog);

+}

+

+

+void GLAPIENTRY

+_mesa_GetShaderInfoLog(GLuint shader, GLsizei bufSize,

+                       GLsizei *length, GLchar *infoLog)

+{

+   GET_CURRENT_CONTEXT(ctx);

+   get_shader_info_log(ctx, shader, bufSize, length, infoLog);

+}

+

+

+void GLAPIENTRY

+_mesa_GetShaderSourceARB(GLhandleARB shader, GLsizei maxLength,

+                         GLsizei *length, GLcharARB *sourceOut)

+{

+   GET_CURRENT_CONTEXT(ctx);

+   get_shader_source(ctx, shader, maxLength, length, sourceOut);

+}

+

+

+GLhandleARB GLAPIENTRY

+_mesa_GetHandleARB(GLenum pname)

+{

+   GET_CURRENT_CONTEXT(ctx);

+   return get_handle(ctx, pname);

+}

+

+

+GLboolean GLAPIENTRY

+_mesa_IsProgram(GLuint name)

+{

+   GET_CURRENT_CONTEXT(ctx);

+   return is_program(ctx, name);

+}

+

+

+GLboolean GLAPIENTRY

+_mesa_IsShader(GLuint name)

+{

+   GET_CURRENT_CONTEXT(ctx);

+   return is_shader(ctx, name);

+}

+

+

+void GLAPIENTRY

+_mesa_LinkProgramARB(GLhandleARB programObj)

+{

+   GET_CURRENT_CONTEXT(ctx);

+   link_program(ctx, programObj);

+}

+

+

+

+/**

+ * Read shader source code from a file.

+ * Useful for debugging to override an app's shader.

+ */

+static GLcharARB *

+read_shader(const char *fname)

+{

+   const int max = 50*1000;

+   FILE *f = fopen(fname, "r");

+   GLcharARB *buffer, *shader;

+   int len;

+

+   if (!f) {

+      return NULL;

+   }

+

+   buffer = (char *) malloc(max);

+   len = fread(buffer, 1, max, f);

+   buffer[len] = 0;

+

+   fclose(f);

+

+   shader = _mesa_strdup(buffer);

+   free(buffer);

+

+   return shader;

+}

+

+

+/**

+ * Called via glShaderSource() and glShaderSourceARB() API functions.

+ * Basically, concatenate the source code strings into one long string

+ * and pass it to _mesa_shader_source().

+ */

+void GLAPIENTRY

+_mesa_ShaderSourceARB(GLhandleARB shaderObj, GLsizei count,

+                      const GLcharARB ** string, const GLint * length)

+{

+   GET_CURRENT_CONTEXT(ctx);

+   GLint *offsets;

+   GLsizei i, totalLength;

+   GLcharARB *source;

+   GLuint checksum;

+

+   if (!shaderObj || string == NULL) {

+      _mesa_error(ctx, GL_INVALID_VALUE, "glShaderSourceARB");

+      return;

+   }

+

+   /*

+    * This array holds offsets of where the appropriate string ends, thus the

+    * last element will be set to the total length of the source code.

+    */

+   offsets = (GLint *) malloc(count * sizeof(GLint));

+   if (offsets == NULL) {

+      _mesa_error(ctx, GL_OUT_OF_MEMORY, "glShaderSourceARB");

+      return;

+   }

+

+   for (i = 0; i < count; i++) {

+      if (string[i] == NULL) {

+         free((GLvoid *) offsets);

+         _mesa_error(ctx, GL_INVALID_OPERATION, "glShaderSourceARB(null string)");

+         return;

+      }

+      if (length == NULL || length[i] < 0)

+         offsets[i] = strlen(string[i]);

+      else

+         offsets[i] = length[i];

+      /* accumulate string lengths */

+      if (i > 0)

+         offsets[i] += offsets[i - 1];

+   }

+

+   /* Total length of source string is sum off all strings plus two.

+    * One extra byte for terminating zero, another extra byte to silence

+    * valgrind warnings in the parser/grammer code.

+    */

+   totalLength = offsets[count - 1] + 2;

+   source = (GLcharARB *) malloc(totalLength * sizeof(GLcharARB));

+   if (source == NULL) {

+      free((GLvoid *) offsets);

+      _mesa_error(ctx, GL_OUT_OF_MEMORY, "glShaderSourceARB");

+      return;

+   }

+

+   for (i = 0; i < count; i++) {

+      GLint start = (i > 0) ? offsets[i - 1] : 0;

+      memcpy(source + start, string[i],

+             (offsets[i] - start) * sizeof(GLcharARB));

+   }

+   source[totalLength - 1] = '\0';

+   source[totalLength - 2] = '\0';

+

+   if (SHADER_SUBST) {

+      /* Compute the shader's source code checksum then try to open a file

+       * named newshader_<CHECKSUM>.  If it exists, use it in place of the

+       * original shader source code.  For debugging.

+       */

+      char filename[100];

+      GLcharARB *newSource;

+

+      checksum = _mesa_str_checksum(source);

+

+      _mesa_snprintf(filename, sizeof(filename), "newshader_%d", checksum);

+

+      newSource = read_shader(filename);

+      if (newSource) {

+         fprintf(stderr, "Mesa: Replacing shader %u chksum=%d with %s\n",

+                       shaderObj, checksum, filename);

+         free(source);

+         source = newSource;

+      }

+   }      

+

+   shader_source(ctx, shaderObj, source);

+

+   if (SHADER_SUBST) {

+      struct gl_shader *sh = _mesa_lookup_shader(ctx, shaderObj);

+      if (sh)

+         sh->SourceChecksum = checksum; /* save original checksum */

+   }

+

+   free(offsets);

+}

+

+

+void GLAPIENTRY

+_mesa_UseProgramObjectARB(GLhandleARB program)

+{

+   GET_CURRENT_CONTEXT(ctx);

+   struct gl_shader_program *shProg;

+   struct gl_transform_feedback_object *obj =

+      ctx->TransformFeedback.CurrentObject;

+

+   if (obj->Active) {

+      _mesa_error(ctx, GL_INVALID_OPERATION,

+                  "glUseProgram(transform feedback active)");

+      return;

+   }

+

+   if (program) {

+      shProg = _mesa_lookup_shader_program_err(ctx, program, "glUseProgram");

+      if (!shProg) {

+         return;

+      }

+      if (!shProg->LinkStatus) {

+         _mesa_error(ctx, GL_INVALID_OPERATION,

+                     "glUseProgram(program %u not linked)", program);

+         return;

+      }

+

+      /* debug code */

+      if (ctx->Shader.Flags & GLSL_USE_PROG) {

+         print_shader_info(shProg);

+      }

+   }

+   else {

+      shProg = NULL;

+   }

+

+   _mesa_use_program(ctx, shProg);

+}

+

+

+void GLAPIENTRY

+_mesa_ValidateProgramARB(GLhandleARB program)

+{

+   GET_CURRENT_CONTEXT(ctx);

+   validate_program(ctx, program);

+}

+

+#ifdef FEATURE_ES2

+

+void GLAPIENTRY

+_mesa_GetShaderPrecisionFormat(GLenum shadertype, GLenum precisiontype,

+                               GLint* range, GLint* precision)

+{

+   const struct gl_program_constants *limits;

+   const struct gl_precision *p;

+   GET_CURRENT_CONTEXT(ctx);

+

+   switch (shadertype) {

+   case GL_VERTEX_SHADER:

+      limits = &ctx->Const.VertexProgram;

+      break;

+   case GL_FRAGMENT_SHADER:

+      limits = &ctx->Const.FragmentProgram;

+      break;

+   default:

+      _mesa_error(ctx, GL_INVALID_ENUM,

+                  "glGetShaderPrecisionFormat(shadertype)");

+      return;

+   }

+

+   switch (precisiontype) {

+   case GL_LOW_FLOAT:

+      p = &limits->LowFloat;

+      break;

+   case GL_MEDIUM_FLOAT:

+      p = &limits->MediumFloat;

+      break;

+   case GL_HIGH_FLOAT:

+      p = &limits->HighFloat;

+      break;

+   case GL_LOW_INT:

+      p = &limits->LowInt;

+      break;

+   case GL_MEDIUM_INT:

+      p = &limits->MediumInt;

+      break;

+   case GL_HIGH_INT:

+      p = &limits->HighInt;

+      break;

+   default:

+      _mesa_error(ctx, GL_INVALID_ENUM,

+                  "glGetShaderPrecisionFormat(precisiontype)");

+      return;

+   }

+

+   range[0] = p->RangeMin;

+   range[1] = p->RangeMax;

+   precision[0] = p->Precision;

+}

+

+

+void GLAPIENTRY

+_mesa_ReleaseShaderCompiler(void)

+{

+   _mesa_destroy_shader_compiler_caches();

+}

+

+

+void GLAPIENTRY

+_mesa_ShaderBinary(GLint n, const GLuint* shaders, GLenum binaryformat,

+                   const void* binary, GLint length)

+{

+   GET_CURRENT_CONTEXT(ctx);

+   (void) n;

+   (void) shaders;

+   (void) binaryformat;

+   (void) binary;

+   (void) length;

+   _mesa_error(ctx, GL_INVALID_OPERATION, __FUNCTION__);

+}

+

+#endif /* FEATURE_ES2 */

+

+

+#if FEATURE_ARB_geometry_shader4

+

+void GLAPIENTRY

+_mesa_ProgramParameteriARB(GLuint program, GLenum pname,

+                           GLint value)

+{

+   struct gl_shader_program *shProg;

+   GET_CURRENT_CONTEXT(ctx);

+

+   ASSERT_OUTSIDE_BEGIN_END(ctx);

+

+   shProg = _mesa_lookup_shader_program_err(ctx, program,

+                                            "glProgramParameteri");

+   if (!shProg)

+      return;

+

+   switch (pname) {

+   case GL_GEOMETRY_VERTICES_OUT_ARB:

+      if (value < 1 ||

+          (unsigned) value > ctx->Const.MaxGeometryOutputVertices) {

+         _mesa_error(ctx, GL_INVALID_VALUE,

+                     "glProgramParameteri(GL_GEOMETRY_VERTICES_OUT_ARB=%d",

+                     value);

+         return;

+      }

+      shProg->Geom.VerticesOut = value;

+      break;

+   case GL_GEOMETRY_INPUT_TYPE_ARB:

+      switch (value) {

+      case GL_POINTS:

+      case GL_LINES:

+      case GL_LINES_ADJACENCY_ARB:

+      case GL_TRIANGLES:

+      case GL_TRIANGLES_ADJACENCY_ARB:

+         shProg->Geom.InputType = value;

+         break;

+      default:

+         _mesa_error(ctx, GL_INVALID_VALUE,

+                     "glProgramParameteri(geometry input type = %s",

+                     _mesa_lookup_enum_by_nr(value));

+         return;

+      }

+      break;

+   case GL_GEOMETRY_OUTPUT_TYPE_ARB:

+      switch (value) {

+      case GL_POINTS:

+      case GL_LINE_STRIP:

+      case GL_TRIANGLE_STRIP:

+         shProg->Geom.OutputType = value;

+         break;

+      default:

+         _mesa_error(ctx, GL_INVALID_VALUE,

+                     "glProgramParameteri(geometry output type = %s",

+                     _mesa_lookup_enum_by_nr(value));

+         return;

+      }

+      break;

+   default:

+      _mesa_error(ctx, GL_INVALID_ENUM, "glProgramParameteriARB(pname=%s)",

+                  _mesa_lookup_enum_by_nr(pname));

+      break;

+   }

+}

+

+#endif

+

+void

+_mesa_use_shader_program(struct gl_context *ctx, GLenum type,

+			 struct gl_shader_program *shProg)

+{

+   use_shader_program(ctx, type, shProg);

+

+   if (ctx->Driver.UseProgram)

+      ctx->Driver.UseProgram(ctx, shProg);

+}

+

+void GLAPIENTRY

+_mesa_UseShaderProgramEXT(GLenum type, GLuint program)

+{

+   GET_CURRENT_CONTEXT(ctx);

+   struct gl_shader_program *shProg = NULL;

+

+   if (!validate_shader_target(ctx, type)) {

+      _mesa_error(ctx, GL_INVALID_ENUM, "glUseShaderProgramEXT(type)");

+      return;

+   }

+

+   if (ctx->TransformFeedback.CurrentObject->Active) {

+      _mesa_error(ctx, GL_INVALID_OPERATION,

+                  "glUseShaderProgramEXT(transform feedback is active)");

+      return;

+   }

+

+   if (program) {

+      shProg = _mesa_lookup_shader_program_err(ctx, program,

+					       "glUseShaderProgramEXT");

+      if (shProg == NULL)

+	 return;

+

+      if (!shProg->LinkStatus) {

+	 _mesa_error(ctx, GL_INVALID_OPERATION,

+		     "glUseShaderProgramEXT(program not linked)");

+	 return;

+      }

+   }

+

+   _mesa_use_shader_program(ctx, type, shProg);

+}

+

+void GLAPIENTRY

+_mesa_ActiveProgramEXT(GLuint program)

+{

+   GET_CURRENT_CONTEXT(ctx);

+   struct gl_shader_program *shProg = (program != 0)

+      ? _mesa_lookup_shader_program_err(ctx, program, "glActiveProgramEXT")

+      : NULL;

+

+   _mesa_active_program(ctx, shProg, "glActiveProgramEXT");

+   return;

+}

+

+GLuint GLAPIENTRY

+_mesa_CreateShaderProgramEXT(GLenum type, const GLchar *string)

+{

+   GET_CURRENT_CONTEXT(ctx);

+   const GLuint shader = create_shader(ctx, type);

+   GLuint program = 0;

+

+   if (shader) {

+      shader_source(ctx, shader, _mesa_strdup(string));

+      compile_shader(ctx, shader);

+

+      program = create_shader_program(ctx);

+      if (program) {

+	 struct gl_shader_program *shProg;

+	 struct gl_shader *sh;

+	 GLint compiled = GL_FALSE;

+

+	 shProg = _mesa_lookup_shader_program(ctx, program);

+	 sh = _mesa_lookup_shader(ctx, shader);

+

+	 get_shaderiv(ctx, shader, GL_COMPILE_STATUS, &compiled);

+	 if (compiled) {

+	    attach_shader(ctx, program, shader);

+	    link_program(ctx, program);

+	    detach_shader(ctx, program, shader);

+

+#if 0

+	    /* Possibly... */

+	    if (active-user-defined-varyings-in-linked-program) {

+	       append-error-to-info-log;

+	       shProg->LinkStatus = GL_FALSE;

+	    }

+#endif

+	 }

+

+	 ralloc_strcat(&shProg->InfoLog, sh->InfoLog);

+      }

+

+      delete_shader(ctx, shader);

+   }

+

+   return program;

+}

+

+/**

+ * Plug in shader-related functions into API dispatch table.

+ */

+void

+_mesa_init_shader_dispatch(struct _glapi_table *exec)

+{

+#if FEATURE_GL

+   /* GL_ARB_vertex/fragment_shader */

+   SET_DeleteObjectARB(exec, _mesa_DeleteObjectARB);

+   SET_GetHandleARB(exec, _mesa_GetHandleARB);

+   SET_DetachObjectARB(exec, _mesa_DetachObjectARB);

+   SET_CreateShaderObjectARB(exec, _mesa_CreateShaderObjectARB);

+   SET_ShaderSourceARB(exec, _mesa_ShaderSourceARB);

+   SET_CompileShaderARB(exec, _mesa_CompileShaderARB);

+   SET_CreateProgramObjectARB(exec, _mesa_CreateProgramObjectARB);

+   SET_AttachObjectARB(exec, _mesa_AttachObjectARB);

+   SET_LinkProgramARB(exec, _mesa_LinkProgramARB);

+   SET_UseProgramObjectARB(exec, _mesa_UseProgramObjectARB);

+   SET_ValidateProgramARB(exec, _mesa_ValidateProgramARB);

+   SET_GetObjectParameterfvARB(exec, _mesa_GetObjectParameterfvARB);

+   SET_GetObjectParameterivARB(exec, _mesa_GetObjectParameterivARB);

+   SET_GetInfoLogARB(exec, _mesa_GetInfoLogARB);

+   SET_GetAttachedObjectsARB(exec, _mesa_GetAttachedObjectsARB);

+   SET_GetShaderSourceARB(exec, _mesa_GetShaderSourceARB);

+

+   /* OpenGL 2.0 */

+   SET_AttachShader(exec, _mesa_AttachShader);

+   SET_CreateProgram(exec, _mesa_CreateProgram);

+   SET_CreateShader(exec, _mesa_CreateShader);

+   SET_DeleteProgram(exec, _mesa_DeleteProgram);

+   SET_DeleteShader(exec, _mesa_DeleteShader);

+   SET_DetachShader(exec, _mesa_DetachShader);

+   SET_GetAttachedShaders(exec, _mesa_GetAttachedShaders);

+   SET_GetProgramiv(exec, _mesa_GetProgramiv);

+   SET_GetProgramInfoLog(exec, _mesa_GetProgramInfoLog);

+   SET_GetShaderiv(exec, _mesa_GetShaderiv);

+   SET_GetShaderInfoLog(exec, _mesa_GetShaderInfoLog);

+   SET_IsProgram(exec, _mesa_IsProgram);

+   SET_IsShader(exec, _mesa_IsShader);

+

+#if FEATURE_ARB_vertex_shader

+   SET_BindAttribLocationARB(exec, _mesa_BindAttribLocationARB);

+   SET_GetActiveAttribARB(exec, _mesa_GetActiveAttribARB);

+   SET_GetAttribLocationARB(exec, _mesa_GetAttribLocationARB);

+#endif

+

+#if FEATURE_ARB_geometry_shader4

+   SET_ProgramParameteriARB(exec, _mesa_ProgramParameteriARB);

+#endif

+

+   SET_UseShaderProgramEXT(exec, _mesa_UseShaderProgramEXT);

+   SET_ActiveProgramEXT(exec, _mesa_ActiveProgramEXT);

+   SET_CreateShaderProgramEXT(exec, _mesa_CreateShaderProgramEXT);

+

+   /* GL_EXT_gpu_shader4 / GL 3.0 */

+   SET_BindFragDataLocationEXT(exec, _mesa_BindFragDataLocation);

+   SET_GetFragDataLocationEXT(exec, _mesa_GetFragDataLocation);

+

+   /* GL_ARB_ES2_compatibility */

+   SET_ReleaseShaderCompiler(exec, _mesa_ReleaseShaderCompiler);

+   SET_GetShaderPrecisionFormat(exec, _mesa_GetShaderPrecisionFormat);

+

+#endif /* FEATURE_GL */

+}

+

diff --git a/mesalib/src/mesa/main/shaderobj.c b/mesalib/src/mesa/main/shaderobj.c
index 1d7584559..06a2f53af 100644
--- a/mesalib/src/mesa/main/shaderobj.c
+++ b/mesalib/src/mesa/main/shaderobj.c
@@ -1,413 +1,415 @@
-/*
- * Mesa 3-D graphics library
- *
- * Copyright (C) 2004-2008  Brian Paul   All Rights Reserved.
- * Copyright (C) 2009-2010  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 shaderobj.c
- * \author Brian Paul
- *
- */
-
-
-#include "main/glheader.h"
-#include "main/context.h"
-#include "main/hash.h"
-#include "main/mfeatures.h"
-#include "main/mtypes.h"
-#include "main/shaderobj.h"
-#include "program/program.h"
-#include "program/prog_parameter.h"
-#include "program/prog_uniform.h"
-#include "ralloc.h"
-
-/**********************************************************************/
-/*** Shader object functions                                        ***/
-/**********************************************************************/
-
-
-/**
- * Set ptr to point to sh.
- * If ptr is pointing to another shader, decrement its refcount (and delete
- * if refcount hits zero).
- * Then set ptr to point to sh, incrementing its refcount.
- */
-void
-_mesa_reference_shader(struct gl_context *ctx, struct gl_shader **ptr,
-                       struct gl_shader *sh)
-{
-   assert(ptr);
-   if (*ptr == sh) {
-      /* no-op */
-      return;
-   }
-   if (*ptr) {
-      /* Unreference the old shader */
-      GLboolean deleteFlag = GL_FALSE;
-      struct gl_shader *old = *ptr;
-
-      ASSERT(old->RefCount > 0);
-      old->RefCount--;
-      /*printf("SHADER DECR %p (%d) to %d\n",
-        (void*) old, old->Name, old->RefCount);*/
-      deleteFlag = (old->RefCount == 0);
-
-      if (deleteFlag) {
-         _mesa_HashRemove(ctx->Shared->ShaderObjects, old->Name);
-         ctx->Driver.DeleteShader(ctx, old);
-      }
-
-      *ptr = NULL;
-   }
-   assert(!*ptr);
-
-   if (sh) {
-      /* reference new */
-      sh->RefCount++;
-      /*printf("SHADER INCR %p (%d) to %d\n",
-        (void*) sh, sh->Name, sh->RefCount);*/
-      *ptr = sh;
-   }
-}
-
-void
-_mesa_init_shader(struct gl_context *ctx, struct gl_shader *shader)
-{
-   shader->RefCount = 1;
-}
-
-/**
- * Allocate a new gl_shader object, initialize it.
- * Called via ctx->Driver.NewShader()
- */
-struct gl_shader *
-_mesa_new_shader(struct gl_context *ctx, GLuint name, GLenum type)
-{
-   struct gl_shader *shader;
-   assert(type == GL_FRAGMENT_SHADER || type == GL_VERTEX_SHADER ||
-          type == GL_GEOMETRY_SHADER_ARB);
-   shader = rzalloc(NULL, struct gl_shader);
-   if (shader) {
-      shader->Type = type;
-      shader->Name = name;
-      _mesa_init_shader(ctx, shader);
-   }
-   return shader;
-}
-
-
-/**
- * Delete a shader object.
- * Called via ctx->Driver.DeleteShader().
- */
-static void
-_mesa_delete_shader(struct gl_context *ctx, struct gl_shader *sh)
-{
-   if (sh->Source)
-      free((void *) sh->Source);
-   _mesa_reference_program(ctx, &sh->Program, NULL);
-   ralloc_free(sh);
-}
-
-
-/**
- * Lookup a GLSL shader object.
- */
-struct gl_shader *
-_mesa_lookup_shader(struct gl_context *ctx, GLuint name)
-{
-   if (name) {
-      struct gl_shader *sh = (struct gl_shader *)
-         _mesa_HashLookup(ctx->Shared->ShaderObjects, name);
-      /* Note that both gl_shader and gl_shader_program objects are kept
-       * in the same hash table.  Check the object's type to be sure it's
-       * what we're expecting.
-       */
-      if (sh && sh->Type == GL_SHADER_PROGRAM_MESA) {
-         return NULL;
-      }
-      return sh;
-   }
-   return NULL;
-}
-
-
-/**
- * As above, but record an error if shader is not found.
- */
-struct gl_shader *
-_mesa_lookup_shader_err(struct gl_context *ctx, GLuint name, const char *caller)
-{
-   if (!name) {
-      _mesa_error(ctx, GL_INVALID_VALUE, "%s", caller);
-      return NULL;
-   }
-   else {
-      struct gl_shader *sh = (struct gl_shader *)
-         _mesa_HashLookup(ctx->Shared->ShaderObjects, name);
-      if (!sh) {
-         _mesa_error(ctx, GL_INVALID_VALUE, "%s", caller);
-         return NULL;
-      }
-      if (sh->Type == GL_SHADER_PROGRAM_MESA) {
-         _mesa_error(ctx, GL_INVALID_OPERATION, "%s", caller);
-         return NULL;
-      }
-      return sh;
-   }
-}
-
-
-
-/**********************************************************************/
-/*** Shader Program object functions                                ***/
-/**********************************************************************/
-
-
-/**
- * Set ptr to point to shProg.
- * If ptr is pointing to another object, decrement its refcount (and delete
- * if refcount hits zero).
- * Then set ptr to point to shProg, incrementing its refcount.
- */
-void
-_mesa_reference_shader_program(struct gl_context *ctx,
-                               struct gl_shader_program **ptr,
-                               struct gl_shader_program *shProg)
-{
-   assert(ptr);
-   if (*ptr == shProg) {
-      /* no-op */
-      return;
-   }
-   if (*ptr) {
-      /* Unreference the old shader program */
-      GLboolean deleteFlag = GL_FALSE;
-      struct gl_shader_program *old = *ptr;
-
-      ASSERT(old->RefCount > 0);
-      old->RefCount--;
-#if 0
-      printf("ShaderProgram %p ID=%u  RefCount-- to %d\n",
-             (void *) old, old->Name, old->RefCount);
-#endif
-      deleteFlag = (old->RefCount == 0);
-
-      if (deleteFlag) {
-         _mesa_HashRemove(ctx->Shared->ShaderObjects, old->Name);
-         ctx->Driver.DeleteShaderProgram(ctx, old);
-      }
-
-      *ptr = NULL;
-   }
-   assert(!*ptr);
-
-   if (shProg) {
-      shProg->RefCount++;
-#if 0
-      printf("ShaderProgram %p ID=%u  RefCount++ to %d\n",
-             (void *) shProg, shProg->Name, shProg->RefCount);
-#endif
-      *ptr = shProg;
-   }
-}
-
-void
-_mesa_init_shader_program(struct gl_context *ctx, struct gl_shader_program *prog)
-{
-   prog->Type = GL_SHADER_PROGRAM_MESA;
-   prog->RefCount = 1;
-   prog->Attributes = _mesa_new_parameter_list();
-#if FEATURE_ARB_geometry_shader4
-   prog->Geom.VerticesOut = 0;
-   prog->Geom.InputType = GL_TRIANGLES;
-   prog->Geom.OutputType = GL_TRIANGLE_STRIP;
-#endif
-}
-
-/**
- * Allocate a new gl_shader_program object, initialize it.
- * Called via ctx->Driver.NewShaderProgram()
- */
-static struct gl_shader_program *
-_mesa_new_shader_program(struct gl_context *ctx, GLuint name)
-{
-   struct gl_shader_program *shProg;
-   shProg = rzalloc(NULL, struct gl_shader_program);
-   if (shProg) {
-      shProg->Name = name;
-      _mesa_init_shader_program(ctx, shProg);
-   }
-   return shProg;
-}
-
-
-/**
- * Clear (free) the shader program state that gets produced by linking.
- */
-void
-_mesa_clear_shader_program_data(struct gl_context *ctx,
-                                struct gl_shader_program *shProg)
-{
-   _mesa_reference_vertprog(ctx, &shProg->VertexProgram, NULL);
-   _mesa_reference_fragprog(ctx, &shProg->FragmentProgram, NULL);
-   _mesa_reference_geomprog(ctx, &shProg->GeometryProgram, NULL);
-
-   if (shProg->Uniforms) {
-      _mesa_free_uniform_list(shProg->Uniforms);
-      shProg->Uniforms = NULL;
-   }
-
-   if (shProg->Varying) {
-      _mesa_free_parameter_list(shProg->Varying);
-      shProg->Varying = NULL;
-   }
-}
-
-
-/**
- * Free all the data that hangs off a shader program object, but not the
- * object itself.
- */
-void
-_mesa_free_shader_program_data(struct gl_context *ctx,
-                               struct gl_shader_program *shProg)
-{
-   GLuint i;
-   gl_shader_type sh;
-
-   assert(shProg->Type == GL_SHADER_PROGRAM_MESA);
-
-   _mesa_clear_shader_program_data(ctx, shProg);
-
-   if (shProg->Attributes) {
-      _mesa_free_parameter_list(shProg->Attributes);
-      shProg->Attributes = NULL;
-   }
-
-   /* detach shaders */
-   for (i = 0; i < shProg->NumShaders; i++) {
-      _mesa_reference_shader(ctx, &shProg->Shaders[i], NULL);
-   }
-   shProg->NumShaders = 0;
-
-   if (shProg->Shaders) {
-      free(shProg->Shaders);
-      shProg->Shaders = NULL;
-   }
-
-   if (shProg->InfoLog) {
-      ralloc_free(shProg->InfoLog);
-      shProg->InfoLog = NULL;
-   }
-
-   /* Transform feedback varying vars */
-   for (i = 0; i < shProg->TransformFeedback.NumVarying; i++) {
-      free(shProg->TransformFeedback.VaryingNames[i]);
-   }
-   free(shProg->TransformFeedback.VaryingNames);
-   shProg->TransformFeedback.VaryingNames = NULL;
-   shProg->TransformFeedback.NumVarying = 0;
-
-
-   for (sh = 0; sh < MESA_SHADER_TYPES; sh++) {
-      if (shProg->_LinkedShaders[sh] != NULL) {
-	 ctx->Driver.DeleteShader(ctx, shProg->_LinkedShaders[sh]);
-	 shProg->_LinkedShaders[sh] = NULL;
-      }
-   }
-}
-
-
-/**
- * Free/delete a shader program object.
- * Called via ctx->Driver.DeleteShaderProgram().
- */
-static void
-_mesa_delete_shader_program(struct gl_context *ctx, struct gl_shader_program *shProg)
-{
-   _mesa_free_shader_program_data(ctx, shProg);
-
-   ralloc_free(shProg);
-}
-
-
-/**
- * Lookup a GLSL program object.
- */
-struct gl_shader_program *
-_mesa_lookup_shader_program(struct gl_context *ctx, GLuint name)
-{
-   struct gl_shader_program *shProg;
-   if (name) {
-      shProg = (struct gl_shader_program *)
-         _mesa_HashLookup(ctx->Shared->ShaderObjects, name);
-      /* Note that both gl_shader and gl_shader_program objects are kept
-       * in the same hash table.  Check the object's type to be sure it's
-       * what we're expecting.
-       */
-      if (shProg && shProg->Type != GL_SHADER_PROGRAM_MESA) {
-         return NULL;
-      }
-      return shProg;
-   }
-   return NULL;
-}
-
-
-/**
- * As above, but record an error if program is not found.
- */
-struct gl_shader_program *
-_mesa_lookup_shader_program_err(struct gl_context *ctx, GLuint name,
-                                const char *caller)
-{
-   if (!name) {
-      _mesa_error(ctx, GL_INVALID_VALUE, "%s", caller);
-      return NULL;
-   }
-   else {
-      struct gl_shader_program *shProg = (struct gl_shader_program *)
-         _mesa_HashLookup(ctx->Shared->ShaderObjects, name);
-      if (!shProg) {
-         _mesa_error(ctx, GL_INVALID_VALUE, "%s", caller);
-         return NULL;
-      }
-      if (shProg->Type != GL_SHADER_PROGRAM_MESA) {
-         _mesa_error(ctx, GL_INVALID_OPERATION, "%s", caller);
-         return NULL;
-      }
-      return shProg;
-   }
-}
-
-
-void
-_mesa_init_shader_object_functions(struct dd_function_table *driver)
-{
-   driver->NewShader = _mesa_new_shader;
-   driver->DeleteShader = _mesa_delete_shader;
-   driver->NewShaderProgram = _mesa_new_shader_program;
-   driver->DeleteShaderProgram = _mesa_delete_shader_program;
-   driver->CompileShader = _mesa_ir_compile_shader;
-   driver->LinkShader = _mesa_ir_link_shader;
-}
+/*

+ * Mesa 3-D graphics library

+ *

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

+ * Copyright (C) 2009-2010  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 shaderobj.c

+ * \author Brian Paul

+ *

+ */

+

+

+#include "main/glheader.h"

+#include "main/context.h"

+#include "main/hash.h"

+#include "main/mfeatures.h"

+#include "main/mtypes.h"

+#include "main/shaderobj.h"

+#include "program/program.h"

+#include "program/prog_parameter.h"

+#include "program/prog_uniform.h"

+#include "ralloc.h"

+

+/**********************************************************************/

+/*** Shader object functions                                        ***/

+/**********************************************************************/

+

+

+/**

+ * Set ptr to point to sh.

+ * If ptr is pointing to another shader, decrement its refcount (and delete

+ * if refcount hits zero).

+ * Then set ptr to point to sh, incrementing its refcount.

+ */

+void

+_mesa_reference_shader(struct gl_context *ctx, struct gl_shader **ptr,

+                       struct gl_shader *sh)

+{

+   assert(ptr);

+   if (*ptr == sh) {

+      /* no-op */

+      return;

+   }

+   if (*ptr) {

+      /* Unreference the old shader */

+      GLboolean deleteFlag = GL_FALSE;

+      struct gl_shader *old = *ptr;

+

+      ASSERT(old->RefCount > 0);

+      old->RefCount--;

+      /*printf("SHADER DECR %p (%d) to %d\n",

+        (void*) old, old->Name, old->RefCount);*/

+      deleteFlag = (old->RefCount == 0);

+

+      if (deleteFlag) {

+	 if (old->Name != 0)

+	    _mesa_HashRemove(ctx->Shared->ShaderObjects, old->Name);

+         ctx->Driver.DeleteShader(ctx, old);

+      }

+

+      *ptr = NULL;

+   }

+   assert(!*ptr);

+

+   if (sh) {

+      /* reference new */

+      sh->RefCount++;

+      /*printf("SHADER INCR %p (%d) to %d\n",

+        (void*) sh, sh->Name, sh->RefCount);*/

+      *ptr = sh;

+   }

+}

+

+void

+_mesa_init_shader(struct gl_context *ctx, struct gl_shader *shader)

+{

+   shader->RefCount = 1;

+}

+

+/**

+ * Allocate a new gl_shader object, initialize it.

+ * Called via ctx->Driver.NewShader()

+ */

+struct gl_shader *

+_mesa_new_shader(struct gl_context *ctx, GLuint name, GLenum type)

+{

+   struct gl_shader *shader;

+   assert(type == GL_FRAGMENT_SHADER || type == GL_VERTEX_SHADER ||

+          type == GL_GEOMETRY_SHADER_ARB);

+   shader = rzalloc(NULL, struct gl_shader);

+   if (shader) {

+      shader->Type = type;

+      shader->Name = name;

+      _mesa_init_shader(ctx, shader);

+   }

+   return shader;

+}

+

+

+/**

+ * Delete a shader object.

+ * Called via ctx->Driver.DeleteShader().

+ */

+static void

+_mesa_delete_shader(struct gl_context *ctx, struct gl_shader *sh)

+{

+   if (sh->Source)

+      free((void *) sh->Source);

+   _mesa_reference_program(ctx, &sh->Program, NULL);

+   ralloc_free(sh);

+}

+

+

+/**

+ * Lookup a GLSL shader object.

+ */

+struct gl_shader *

+_mesa_lookup_shader(struct gl_context *ctx, GLuint name)

+{

+   if (name) {

+      struct gl_shader *sh = (struct gl_shader *)

+         _mesa_HashLookup(ctx->Shared->ShaderObjects, name);

+      /* Note that both gl_shader and gl_shader_program objects are kept

+       * in the same hash table.  Check the object's type to be sure it's

+       * what we're expecting.

+       */

+      if (sh && sh->Type == GL_SHADER_PROGRAM_MESA) {

+         return NULL;

+      }

+      return sh;

+   }

+   return NULL;

+}

+

+

+/**

+ * As above, but record an error if shader is not found.

+ */

+struct gl_shader *

+_mesa_lookup_shader_err(struct gl_context *ctx, GLuint name, const char *caller)

+{

+   if (!name) {

+      _mesa_error(ctx, GL_INVALID_VALUE, "%s", caller);

+      return NULL;

+   }

+   else {

+      struct gl_shader *sh = (struct gl_shader *)

+         _mesa_HashLookup(ctx->Shared->ShaderObjects, name);

+      if (!sh) {

+         _mesa_error(ctx, GL_INVALID_VALUE, "%s", caller);

+         return NULL;

+      }

+      if (sh->Type == GL_SHADER_PROGRAM_MESA) {

+         _mesa_error(ctx, GL_INVALID_OPERATION, "%s", caller);

+         return NULL;

+      }

+      return sh;

+   }

+}

+

+

+

+/**********************************************************************/

+/*** Shader Program object functions                                ***/

+/**********************************************************************/

+

+

+/**

+ * Set ptr to point to shProg.

+ * If ptr is pointing to another object, decrement its refcount (and delete

+ * if refcount hits zero).

+ * Then set ptr to point to shProg, incrementing its refcount.

+ */

+void

+_mesa_reference_shader_program(struct gl_context *ctx,

+                               struct gl_shader_program **ptr,

+                               struct gl_shader_program *shProg)

+{

+   assert(ptr);

+   if (*ptr == shProg) {

+      /* no-op */

+      return;

+   }

+   if (*ptr) {

+      /* Unreference the old shader program */

+      GLboolean deleteFlag = GL_FALSE;

+      struct gl_shader_program *old = *ptr;

+

+      ASSERT(old->RefCount > 0);

+      old->RefCount--;

+#if 0

+      printf("ShaderProgram %p ID=%u  RefCount-- to %d\n",

+             (void *) old, old->Name, old->RefCount);

+#endif

+      deleteFlag = (old->RefCount == 0);

+

+      if (deleteFlag) {

+	 if (old->Name != 0)

+	    _mesa_HashRemove(ctx->Shared->ShaderObjects, old->Name);

+         ctx->Driver.DeleteShaderProgram(ctx, old);

+      }

+

+      *ptr = NULL;

+   }

+   assert(!*ptr);

+

+   if (shProg) {

+      shProg->RefCount++;

+#if 0

+      printf("ShaderProgram %p ID=%u  RefCount++ to %d\n",

+             (void *) shProg, shProg->Name, shProg->RefCount);

+#endif

+      *ptr = shProg;

+   }

+}

+

+void

+_mesa_init_shader_program(struct gl_context *ctx, struct gl_shader_program *prog)

+{

+   prog->Type = GL_SHADER_PROGRAM_MESA;

+   prog->RefCount = 1;

+   prog->Attributes = _mesa_new_parameter_list();

+#if FEATURE_ARB_geometry_shader4

+   prog->Geom.VerticesOut = 0;

+   prog->Geom.InputType = GL_TRIANGLES;

+   prog->Geom.OutputType = GL_TRIANGLE_STRIP;

+#endif

+}

+

+/**

+ * Allocate a new gl_shader_program object, initialize it.

+ * Called via ctx->Driver.NewShaderProgram()

+ */

+static struct gl_shader_program *

+_mesa_new_shader_program(struct gl_context *ctx, GLuint name)

+{

+   struct gl_shader_program *shProg;

+   shProg = rzalloc(NULL, struct gl_shader_program);

+   if (shProg) {

+      shProg->Name = name;

+      _mesa_init_shader_program(ctx, shProg);

+   }

+   return shProg;

+}

+

+

+/**

+ * Clear (free) the shader program state that gets produced by linking.

+ */

+void

+_mesa_clear_shader_program_data(struct gl_context *ctx,

+                                struct gl_shader_program *shProg)

+{

+   _mesa_reference_vertprog(ctx, &shProg->VertexProgram, NULL);

+   _mesa_reference_fragprog(ctx, &shProg->FragmentProgram, NULL);

+   _mesa_reference_geomprog(ctx, &shProg->GeometryProgram, NULL);

+

+   if (shProg->Uniforms) {

+      _mesa_free_uniform_list(shProg->Uniforms);

+      shProg->Uniforms = NULL;

+   }

+

+   if (shProg->Varying) {

+      _mesa_free_parameter_list(shProg->Varying);

+      shProg->Varying = NULL;

+   }

+}

+

+

+/**

+ * Free all the data that hangs off a shader program object, but not the

+ * object itself.

+ */

+void

+_mesa_free_shader_program_data(struct gl_context *ctx,

+                               struct gl_shader_program *shProg)

+{

+   GLuint i;

+   gl_shader_type sh;

+

+   assert(shProg->Type == GL_SHADER_PROGRAM_MESA);

+

+   _mesa_clear_shader_program_data(ctx, shProg);

+

+   if (shProg->Attributes) {

+      _mesa_free_parameter_list(shProg->Attributes);

+      shProg->Attributes = NULL;

+   }

+

+   /* detach shaders */

+   for (i = 0; i < shProg->NumShaders; i++) {

+      _mesa_reference_shader(ctx, &shProg->Shaders[i], NULL);

+   }

+   shProg->NumShaders = 0;

+

+   if (shProg->Shaders) {

+      free(shProg->Shaders);

+      shProg->Shaders = NULL;

+   }

+

+   if (shProg->InfoLog) {

+      ralloc_free(shProg->InfoLog);

+      shProg->InfoLog = NULL;

+   }

+

+   /* Transform feedback varying vars */

+   for (i = 0; i < shProg->TransformFeedback.NumVarying; i++) {

+      free(shProg->TransformFeedback.VaryingNames[i]);

+   }

+   free(shProg->TransformFeedback.VaryingNames);

+   shProg->TransformFeedback.VaryingNames = NULL;

+   shProg->TransformFeedback.NumVarying = 0;

+

+

+   for (sh = 0; sh < MESA_SHADER_TYPES; sh++) {

+      if (shProg->_LinkedShaders[sh] != NULL) {

+	 ctx->Driver.DeleteShader(ctx, shProg->_LinkedShaders[sh]);

+	 shProg->_LinkedShaders[sh] = NULL;

+      }

+   }

+}

+

+

+/**

+ * Free/delete a shader program object.

+ * Called via ctx->Driver.DeleteShaderProgram().

+ */

+static void

+_mesa_delete_shader_program(struct gl_context *ctx, struct gl_shader_program *shProg)

+{

+   _mesa_free_shader_program_data(ctx, shProg);

+

+   ralloc_free(shProg);

+}

+

+

+/**

+ * Lookup a GLSL program object.

+ */

+struct gl_shader_program *

+_mesa_lookup_shader_program(struct gl_context *ctx, GLuint name)

+{

+   struct gl_shader_program *shProg;

+   if (name) {

+      shProg = (struct gl_shader_program *)

+         _mesa_HashLookup(ctx->Shared->ShaderObjects, name);

+      /* Note that both gl_shader and gl_shader_program objects are kept

+       * in the same hash table.  Check the object's type to be sure it's

+       * what we're expecting.

+       */

+      if (shProg && shProg->Type != GL_SHADER_PROGRAM_MESA) {

+         return NULL;

+      }

+      return shProg;

+   }

+   return NULL;

+}

+

+

+/**

+ * As above, but record an error if program is not found.

+ */

+struct gl_shader_program *

+_mesa_lookup_shader_program_err(struct gl_context *ctx, GLuint name,

+                                const char *caller)

+{

+   if (!name) {

+      _mesa_error(ctx, GL_INVALID_VALUE, "%s", caller);

+      return NULL;

+   }

+   else {

+      struct gl_shader_program *shProg = (struct gl_shader_program *)

+         _mesa_HashLookup(ctx->Shared->ShaderObjects, name);

+      if (!shProg) {

+         _mesa_error(ctx, GL_INVALID_VALUE, "%s", caller);

+         return NULL;

+      }

+      if (shProg->Type != GL_SHADER_PROGRAM_MESA) {

+         _mesa_error(ctx, GL_INVALID_OPERATION, "%s", caller);

+         return NULL;

+      }

+      return shProg;

+   }

+}

+

+

+void

+_mesa_init_shader_object_functions(struct dd_function_table *driver)

+{

+   driver->NewShader = _mesa_new_shader;

+   driver->DeleteShader = _mesa_delete_shader;

+   driver->NewShaderProgram = _mesa_new_shader_program;

+   driver->DeleteShaderProgram = _mesa_delete_shader_program;

+   driver->CompileShader = _mesa_ir_compile_shader;

+   driver->LinkShader = _mesa_ir_link_shader;

+}

diff --git a/mesalib/src/mesa/main/state.c b/mesalib/src/mesa/main/state.c
index 502c42929..5651e3263 100644
--- a/mesalib/src/mesa/main/state.c
+++ b/mesalib/src/mesa/main/state.c
@@ -1,734 +1,743 @@
-/*
- * Mesa 3-D graphics library
- * Version:  7.3
- *
- * Copyright (C) 1999-2008  Brian Paul   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 state.c
- * State management.
- * 
- * This file manages recalculation of derived values in struct gl_context.
- */
-
-
-#include "glheader.h"
-#include "mtypes.h"
-#include "context.h"
-#include "debug.h"
-#include "macros.h"
-#include "ffvertex_prog.h"
-#include "framebuffer.h"
-#include "light.h"
-#include "matrix.h"
-#include "pixel.h"
-#include "program/program.h"
-#include "program/prog_parameter.h"
-#include "state.h"
-#include "stencil.h"
-#include "texenvprogram.h"
-#include "texobj.h"
-#include "texstate.h"
-
-
-static void
-update_separate_specular(struct gl_context *ctx)
-{
-   if (NEED_SECONDARY_COLOR(ctx))
-      ctx->_TriangleCaps |= DD_SEPARATE_SPECULAR;
-   else
-      ctx->_TriangleCaps &= ~DD_SEPARATE_SPECULAR;
-}
-
-
-/**
- * Compute the index of the last array element that can be safely accessed
- * in a vertex array.  We can really only do this when the array lives in
- * a VBO.
- * The array->_MaxElement field will be updated.
- * Later in glDrawArrays/Elements/etc we can do some bounds checking.
- */
-static void
-compute_max_element(struct gl_client_array *array)
-{
-   assert(array->Enabled);
-   if (array->BufferObj->Name) {
-      GLsizeiptrARB offset = (GLsizeiptrARB) array->Ptr;
-      GLsizeiptrARB obj_size = (GLsizeiptrARB) array->BufferObj->Size;
-
-      if (offset < obj_size) {
-	 array->_MaxElement = (obj_size - offset +
-			       array->StrideB -
-			       array->_ElementSize) / array->StrideB;
-      } else {
-	 array->_MaxElement = 0;
-      }
-   }
-   else {
-      /* user-space array, no idea how big it is */
-      array->_MaxElement = 2 * 1000 * 1000 * 1000; /* just a big number */
-   }
-}
-
-
-/**
- * Helper for update_arrays().
- * \return  min(current min, array->_MaxElement).
- */
-static GLuint
-update_min(GLuint min, struct gl_client_array *array)
-{
-   compute_max_element(array);
-   return MIN2(min, array->_MaxElement);
-}
-
-
-/**
- * Update ctx->Array._MaxElement (the max legal index into all enabled arrays).
- * Need to do this upon new array state or new buffer object state.
- */
-static void
-update_arrays( struct gl_context *ctx )
-{
-   struct gl_array_object *arrayObj = ctx->Array.ArrayObj;
-   GLuint i, min = ~0;
-
-   /* find min of _MaxElement values for all enabled arrays */
-
-   /* 0 */
-   if (ctx->VertexProgram._Current
-       && arrayObj->VertexAttrib[VERT_ATTRIB_POS].Enabled) {
-      min = update_min(min, &arrayObj->VertexAttrib[VERT_ATTRIB_POS]);
-   }
-   else if (arrayObj->Vertex.Enabled) {
-      min = update_min(min, &arrayObj->Vertex);
-   }
-
-   /* 1 */
-   if (ctx->VertexProgram._Enabled
-       && arrayObj->VertexAttrib[VERT_ATTRIB_WEIGHT].Enabled) {
-      min = update_min(min, &arrayObj->VertexAttrib[VERT_ATTRIB_WEIGHT]);
-   }
-   /* no conventional vertex weight array */
-
-   /* 2 */
-   if (ctx->VertexProgram._Enabled
-       && arrayObj->VertexAttrib[VERT_ATTRIB_NORMAL].Enabled) {
-      min = update_min(min, &arrayObj->VertexAttrib[VERT_ATTRIB_NORMAL]);
-   }
-   else if (arrayObj->Normal.Enabled) {
-      min = update_min(min, &arrayObj->Normal);
-   }
-
-   /* 3 */
-   if (ctx->VertexProgram._Enabled
-       && arrayObj->VertexAttrib[VERT_ATTRIB_COLOR0].Enabled) {
-      min = update_min(min, &arrayObj->VertexAttrib[VERT_ATTRIB_COLOR0]);
-   }
-   else if (arrayObj->Color.Enabled) {
-      min = update_min(min, &arrayObj->Color);
-   }
-
-   /* 4 */
-   if (ctx->VertexProgram._Enabled
-       && arrayObj->VertexAttrib[VERT_ATTRIB_COLOR1].Enabled) {
-      min = update_min(min, &arrayObj->VertexAttrib[VERT_ATTRIB_COLOR1]);
-   }
-   else if (arrayObj->SecondaryColor.Enabled) {
-      min = update_min(min, &arrayObj->SecondaryColor);
-   }
-
-   /* 5 */
-   if (ctx->VertexProgram._Enabled
-       && arrayObj->VertexAttrib[VERT_ATTRIB_FOG].Enabled) {
-      min = update_min(min, &arrayObj->VertexAttrib[VERT_ATTRIB_FOG]);
-   }
-   else if (arrayObj->FogCoord.Enabled) {
-      min = update_min(min, &arrayObj->FogCoord);
-   }
-
-   /* 6 */
-   if (ctx->VertexProgram._Enabled
-       && arrayObj->VertexAttrib[VERT_ATTRIB_COLOR_INDEX].Enabled) {
-      min = update_min(min, &arrayObj->VertexAttrib[VERT_ATTRIB_COLOR_INDEX]);
-   }
-   else if (arrayObj->Index.Enabled) {
-      min = update_min(min, &arrayObj->Index);
-   }
-
-   /* 7 */
-   if (ctx->VertexProgram._Enabled
-       && arrayObj->VertexAttrib[VERT_ATTRIB_EDGEFLAG].Enabled) {
-      min = update_min(min, &arrayObj->VertexAttrib[VERT_ATTRIB_EDGEFLAG]);
-   }
-
-   /* 8..15 */
-   for (i = VERT_ATTRIB_TEX0; i <= VERT_ATTRIB_TEX7; i++) {
-      if (ctx->VertexProgram._Enabled
-          && arrayObj->VertexAttrib[i].Enabled) {
-         min = update_min(min, &arrayObj->VertexAttrib[i]);
-      }
-      else if (i - VERT_ATTRIB_TEX0 < ctx->Const.MaxTextureCoordUnits
-               && arrayObj->TexCoord[i - VERT_ATTRIB_TEX0].Enabled) {
-         min = update_min(min, &arrayObj->TexCoord[i - VERT_ATTRIB_TEX0]);
-      }
-   }
-
-   /* 16..31 */
-   if (ctx->VertexProgram._Current) {
-      for (i = 0; i < Elements(arrayObj->VertexAttrib); i++) {
-         if (arrayObj->VertexAttrib[i].Enabled) {
-            min = update_min(min, &arrayObj->VertexAttrib[i]);
-         }
-      }
-   }
-
-   if (arrayObj->EdgeFlag.Enabled) {
-      min = update_min(min, &arrayObj->EdgeFlag);
-   }
-
-   /* _MaxElement is one past the last legal array element */
-   arrayObj->_MaxElement = min;
-}
-
-
-/**
- * Update the following fields:
- *   ctx->VertexProgram._Enabled
- *   ctx->FragmentProgram._Enabled
- *   ctx->ATIFragmentShader._Enabled
- * This needs to be done before texture state validation.
- */
-static void
-update_program_enables(struct gl_context *ctx)
-{
-   /* These _Enabled flags indicate if the program is enabled AND valid. */
-   ctx->VertexProgram._Enabled = ctx->VertexProgram.Enabled
-      && ctx->VertexProgram.Current->Base.Instructions;
-   ctx->FragmentProgram._Enabled = ctx->FragmentProgram.Enabled
-      && ctx->FragmentProgram.Current->Base.Instructions;
-   ctx->ATIFragmentShader._Enabled = ctx->ATIFragmentShader.Enabled
-      && ctx->ATIFragmentShader.Current->Instructions[0];
-}
-
-
-/**
- * Update vertex/fragment program state.  In particular, update these fields:
- *   ctx->VertexProgram._Current
- *   ctx->VertexProgram._TnlProgram,
- * These point to the highest priority enabled vertex/fragment program or are
- * NULL if fixed-function processing is to be done.
- *
- * This function needs to be called after texture state validation in case
- * we're generating a fragment program from fixed-function texture state.
- *
- * \return bitfield which will indicate _NEW_PROGRAM state if a new vertex
- * or fragment program is being used.
- */
-static GLbitfield
-update_program(struct gl_context *ctx)
-{
-   const struct gl_shader_program *vsProg = ctx->Shader.CurrentVertexProgram;
-   const struct gl_shader_program *gsProg = ctx->Shader.CurrentGeometryProgram;
-   const struct gl_shader_program *fsProg = ctx->Shader.CurrentFragmentProgram;
-   const struct gl_vertex_program *prevVP = ctx->VertexProgram._Current;
-   const struct gl_fragment_program *prevFP = ctx->FragmentProgram._Current;
-   const struct gl_geometry_program *prevGP = ctx->GeometryProgram._Current;
-   GLbitfield new_state = 0x0;
-
-   /*
-    * Set the ctx->VertexProgram._Current and ctx->FragmentProgram._Current
-    * pointers to the programs that should be used for rendering.  If either
-    * is NULL, use fixed-function code paths.
-    *
-    * These programs may come from several sources.  The priority is as
-    * follows:
-    *   1. OpenGL 2.0/ARB vertex/fragment shaders
-    *   2. ARB/NV vertex/fragment programs
-    *   3. Programs derived from fixed-function state.
-    *
-    * Note: it's possible for a vertex shader to get used with a fragment
-    * program (and vice versa) here, but in practice that shouldn't ever
-    * come up, or matter.
-    */
-
-   if (fsProg && fsProg->LinkStatus && fsProg->FragmentProgram) {
-      /* Use shader programs */
-      _mesa_reference_fragprog(ctx, &ctx->FragmentProgram._Current,
-                               fsProg->FragmentProgram);
-   }
-   else if (ctx->FragmentProgram._Enabled) {
-      /* use user-defined vertex program */
-      _mesa_reference_fragprog(ctx, &ctx->FragmentProgram._Current,
-                               ctx->FragmentProgram.Current);
-   }
-   else if (ctx->FragmentProgram._MaintainTexEnvProgram) {
-      /* Use fragment program generated from fixed-function state.
-       */
-      _mesa_reference_fragprog(ctx, &ctx->FragmentProgram._Current,
-                               _mesa_get_fixed_func_fragment_program(ctx));
-      _mesa_reference_fragprog(ctx, &ctx->FragmentProgram._TexEnvProgram,
-                               ctx->FragmentProgram._Current);
-   }
-   else {
-      /* no fragment program */
-      _mesa_reference_fragprog(ctx, &ctx->FragmentProgram._Current, NULL);
-   }
-
-   if (gsProg && gsProg->LinkStatus && gsProg->GeometryProgram) {
-      /* Use shader programs */
-      _mesa_reference_geomprog(ctx, &ctx->GeometryProgram._Current,
-                               gsProg->GeometryProgram);
-   } else {
-      /* no fragment program */
-      _mesa_reference_geomprog(ctx, &ctx->GeometryProgram._Current, NULL);
-   }
-
-   /* Examine vertex program after fragment program as
-    * _mesa_get_fixed_func_vertex_program() needs to know active
-    * fragprog inputs.
-    */
-   if (vsProg && vsProg->LinkStatus && vsProg->VertexProgram) {
-      /* Use shader programs */
-      _mesa_reference_vertprog(ctx, &ctx->VertexProgram._Current,
-                            vsProg->VertexProgram);
-   }
-   else if (ctx->VertexProgram._Enabled) {
-      /* use user-defined vertex program */
-      _mesa_reference_vertprog(ctx, &ctx->VertexProgram._Current,
-                               ctx->VertexProgram.Current);
-   }
-   else if (ctx->VertexProgram._MaintainTnlProgram) {
-      /* Use vertex program generated from fixed-function state.
-       */
-      _mesa_reference_vertprog(ctx, &ctx->VertexProgram._Current,
-                               _mesa_get_fixed_func_vertex_program(ctx));
-      _mesa_reference_vertprog(ctx, &ctx->VertexProgram._TnlProgram,
-                               ctx->VertexProgram._Current);
-   }
-   else {
-      /* no vertex program */
-      _mesa_reference_vertprog(ctx, &ctx->VertexProgram._Current, NULL);
-   }
-
-   /* Let the driver know what's happening:
-    */
-   if (ctx->FragmentProgram._Current != prevFP) {
-      new_state |= _NEW_PROGRAM;
-      if (ctx->Driver.BindProgram) {
-         ctx->Driver.BindProgram(ctx, GL_FRAGMENT_PROGRAM_ARB,
-                          (struct gl_program *) ctx->FragmentProgram._Current);
-      }
-   }
-
-   if (ctx->GeometryProgram._Current != prevGP) {
-      new_state |= _NEW_PROGRAM;
-      if (ctx->Driver.BindProgram) {
-         ctx->Driver.BindProgram(ctx, MESA_GEOMETRY_PROGRAM,
-                            (struct gl_program *) ctx->GeometryProgram._Current);
-      }
-   }
-
-   if (ctx->VertexProgram._Current != prevVP) {
-      new_state |= _NEW_PROGRAM;
-      if (ctx->Driver.BindProgram) {
-         ctx->Driver.BindProgram(ctx, GL_VERTEX_PROGRAM_ARB,
-                            (struct gl_program *) ctx->VertexProgram._Current);
-      }
-   }
-
-   return new_state;
-}
-
-
-/**
- * Examine shader constants and return either _NEW_PROGRAM_CONSTANTS or 0.
- */
-static GLbitfield
-update_program_constants(struct gl_context *ctx)
-{
-   GLbitfield new_state = 0x0;
-
-   if (ctx->FragmentProgram._Current) {
-      const struct gl_program_parameter_list *params =
-         ctx->FragmentProgram._Current->Base.Parameters;
-      if (params && params->StateFlags & ctx->NewState) {
-         new_state |= _NEW_PROGRAM_CONSTANTS;
-      }
-   }
-
-   if (ctx->GeometryProgram._Current) {
-      const struct gl_program_parameter_list *params =
-         ctx->GeometryProgram._Current->Base.Parameters;
-      /*FIXME: StateFlags is always 0 because we have unnamed constant
-       *       not state changes */
-      if (params /*&& params->StateFlags & ctx->NewState*/) {
-         new_state |= _NEW_PROGRAM_CONSTANTS;
-      }
-   }
-
-   if (ctx->VertexProgram._Current) {
-      const struct gl_program_parameter_list *params =
-         ctx->VertexProgram._Current->Base.Parameters;
-      if (params && params->StateFlags & ctx->NewState) {
-         new_state |= _NEW_PROGRAM_CONSTANTS;
-      }
-   }
-
-   return new_state;
-}
-
-
-
-
-static void
-update_viewport_matrix(struct gl_context *ctx)
-{
-   const GLfloat depthMax = ctx->DrawBuffer->_DepthMaxF;
-
-   ASSERT(depthMax > 0);
-
-   /* Compute scale and bias values. This is really driver-specific
-    * and should be maintained elsewhere if at all.
-    * NOTE: RasterPos uses this.
-    */
-   _math_matrix_viewport(&ctx->Viewport._WindowMap,
-                         ctx->Viewport.X, ctx->Viewport.Y,
-                         ctx->Viewport.Width, ctx->Viewport.Height,
-                         ctx->Viewport.Near, ctx->Viewport.Far,
-                         depthMax);
-}
-
-
-/**
- * Update derived multisample state.
- */
-static void
-update_multisample(struct gl_context *ctx)
-{
-   ctx->Multisample._Enabled = GL_FALSE;
-   if (ctx->Multisample.Enabled &&
-       ctx->DrawBuffer &&
-       ctx->DrawBuffer->Visual.sampleBuffers)
-      ctx->Multisample._Enabled = GL_TRUE;
-}
-
-
-/**
- * Update derived color/blend/logicop state.
- */
-static void
-update_color(struct gl_context *ctx)
-{
-   /* This is needed to support 1.1's RGB logic ops AND
-    * 1.0's blending logicops.
-    */
-   ctx->Color._LogicOpEnabled = RGBA_LOGICOP_ENABLED(ctx);
-}
-
-
-/*
- * Check polygon state and set DD_TRI_CULL_FRONT_BACK and/or DD_TRI_OFFSET
- * in ctx->_TriangleCaps if needed.
- */
-static void
-update_polygon(struct gl_context *ctx)
-{
-   ctx->_TriangleCaps &= ~(DD_TRI_CULL_FRONT_BACK | DD_TRI_OFFSET);
-
-   if (ctx->Polygon.CullFlag && ctx->Polygon.CullFaceMode == GL_FRONT_AND_BACK)
-      ctx->_TriangleCaps |= DD_TRI_CULL_FRONT_BACK;
-
-   if (   ctx->Polygon.OffsetPoint
-       || ctx->Polygon.OffsetLine
-       || ctx->Polygon.OffsetFill)
-      ctx->_TriangleCaps |= DD_TRI_OFFSET;
-}
-
-
-/**
- * Update the ctx->_TriangleCaps bitfield.
- * XXX that bitfield should really go away someday!
- * This function must be called after other update_*() functions since
- * there are dependencies on some other derived values.
- */
-#if 0
-static void
-update_tricaps(struct gl_context *ctx, GLbitfield new_state)
-{
-   ctx->_TriangleCaps = 0;
-
-   /*
-    * Points
-    */
-   if (1/*new_state & _NEW_POINT*/) {
-      if (ctx->Point.SmoothFlag)
-         ctx->_TriangleCaps |= DD_POINT_SMOOTH;
-      if (ctx->Point._Attenuated)
-         ctx->_TriangleCaps |= DD_POINT_ATTEN;
-   }
-
-   /*
-    * Lines
-    */
-   if (1/*new_state & _NEW_LINE*/) {
-      if (ctx->Line.SmoothFlag)
-         ctx->_TriangleCaps |= DD_LINE_SMOOTH;
-      if (ctx->Line.StippleFlag)
-         ctx->_TriangleCaps |= DD_LINE_STIPPLE;
-   }
-
-   /*
-    * Polygons
-    */
-   if (1/*new_state & _NEW_POLYGON*/) {
-      if (ctx->Polygon.SmoothFlag)
-         ctx->_TriangleCaps |= DD_TRI_SMOOTH;
-      if (ctx->Polygon.StippleFlag)
-         ctx->_TriangleCaps |= DD_TRI_STIPPLE;
-      if (ctx->Polygon.FrontMode != GL_FILL
-          || ctx->Polygon.BackMode != GL_FILL)
-         ctx->_TriangleCaps |= DD_TRI_UNFILLED;
-      if (ctx->Polygon.CullFlag
-          && ctx->Polygon.CullFaceMode == GL_FRONT_AND_BACK)
-         ctx->_TriangleCaps |= DD_TRI_CULL_FRONT_BACK;
-      if (ctx->Polygon.OffsetPoint ||
-          ctx->Polygon.OffsetLine ||
-          ctx->Polygon.OffsetFill)
-         ctx->_TriangleCaps |= DD_TRI_OFFSET;
-   }
-
-   /*
-    * Lighting and shading
-    */
-   if (ctx->Light.Enabled && ctx->Light.Model.TwoSide)
-      ctx->_TriangleCaps |= DD_TRI_LIGHT_TWOSIDE;
-   if (ctx->Light.ShadeModel == GL_FLAT)
-      ctx->_TriangleCaps |= DD_FLATSHADE;
-   if (NEED_SECONDARY_COLOR(ctx))
-      ctx->_TriangleCaps |= DD_SEPARATE_SPECULAR;
-
-   /*
-    * Stencil
-    */
-   if (ctx->Stencil._TestTwoSide)
-      ctx->_TriangleCaps |= DD_TRI_TWOSTENCIL;
-}
-#endif
-
-
-/**
- * Compute derived GL state.
- * If __struct gl_contextRec::NewState is non-zero then this function \b must
- * be called before rendering anything.
- *
- * Calls dd_function_table::UpdateState to perform any internal state
- * management necessary.
- * 
- * \sa _mesa_update_modelview_project(), _mesa_update_texture(),
- * _mesa_update_buffer_bounds(),
- * _mesa_update_lighting() and _mesa_update_tnl_spaces().
- */
-void
-_mesa_update_state_locked( struct gl_context *ctx )
-{
-   GLbitfield new_state = ctx->NewState;
-   GLbitfield prog_flags = _NEW_PROGRAM;
-   GLbitfield new_prog_state = 0x0;
-
-   if (new_state == _NEW_CURRENT_ATTRIB) 
-      goto out;
-
-   if (MESA_VERBOSE & VERBOSE_STATE)
-      _mesa_print_state("_mesa_update_state", new_state);
-
-   /* Determine which state flags effect vertex/fragment program state */
-   if (ctx->FragmentProgram._MaintainTexEnvProgram) {
-      prog_flags |= (_NEW_BUFFERS | _NEW_TEXTURE | _NEW_FOG |
-		     _NEW_ARRAY | _NEW_LIGHT | _NEW_POINT | _NEW_RENDERMODE |
-		     _NEW_PROGRAM);
-   }
-   if (ctx->VertexProgram._MaintainTnlProgram) {
-      prog_flags |= (_NEW_ARRAY | _NEW_TEXTURE | _NEW_TEXTURE_MATRIX |
-                     _NEW_TRANSFORM | _NEW_POINT |
-                     _NEW_FOG | _NEW_LIGHT |
-                     _MESA_NEW_NEED_EYE_COORDS);
-   }
-
-   /*
-    * Now update derived state info
-    */
-
-   if (new_state & prog_flags)
-      update_program_enables( ctx );
-
-   if (new_state & (_NEW_MODELVIEW|_NEW_PROJECTION))
-      _mesa_update_modelview_project( ctx, new_state );
-
-   if (new_state & (_NEW_PROGRAM|_NEW_TEXTURE|_NEW_TEXTURE_MATRIX))
-      _mesa_update_texture( ctx, new_state );
-
-   if (new_state & _NEW_BUFFERS)
-      _mesa_update_framebuffer(ctx);
-
-   if (new_state & (_NEW_SCISSOR | _NEW_BUFFERS | _NEW_VIEWPORT))
-      _mesa_update_draw_buffer_bounds( ctx );
-
-   if (new_state & _NEW_POLYGON)
-      update_polygon( ctx );
-
-   if (new_state & _NEW_LIGHT)
-      _mesa_update_lighting( ctx );
-
-   if (new_state & (_NEW_STENCIL | _NEW_BUFFERS))
-      _mesa_update_stencil( ctx );
-
-   if (new_state & _MESA_NEW_TRANSFER_STATE)
-      _mesa_update_pixel( ctx, new_state );
-
-   if (new_state & _DD_NEW_SEPARATE_SPECULAR)
-      update_separate_specular( ctx );
-
-   if (new_state & (_NEW_BUFFERS | _NEW_VIEWPORT))
-      update_viewport_matrix(ctx);
-
-   if (new_state & _NEW_MULTISAMPLE)
-      update_multisample( ctx );
-
-   if (new_state & _NEW_COLOR)
-      update_color( ctx );
-
-#if 0
-   if (new_state & (_NEW_POINT | _NEW_LINE | _NEW_POLYGON | _NEW_LIGHT
-                    | _NEW_STENCIL | _DD_NEW_SEPARATE_SPECULAR))
-      update_tricaps( ctx, new_state );
-#endif
-
-   /* ctx->_NeedEyeCoords is now up to date.
-    *
-    * If the truth value of this variable has changed, update for the
-    * new lighting space and recompute the positions of lights and the
-    * normal transform.
-    *
-    * If the lighting space hasn't changed, may still need to recompute
-    * light positions & normal transforms for other reasons.
-    */
-   if (new_state & _MESA_NEW_NEED_EYE_COORDS) 
-      _mesa_update_tnl_spaces( ctx, new_state );
-
-   if (new_state & prog_flags) {
-      /* When we generate programs from fixed-function vertex/fragment state
-       * this call may generate/bind a new program.  If so, we need to
-       * propogate the _NEW_PROGRAM flag to the driver.
-       */
-      new_prog_state |= update_program( ctx );
-   }
-
-   if (new_state & (_NEW_ARRAY | _NEW_PROGRAM | _NEW_BUFFER_OBJECT))
-      update_arrays( ctx );
-
- out:
-   new_prog_state |= update_program_constants(ctx);
-
-   /*
-    * Give the driver a chance to act upon the new_state flags.
-    * The driver might plug in different span functions, for example.
-    * Also, this is where the driver can invalidate the state of any
-    * active modules (such as swrast_setup, swrast, tnl, etc).
-    *
-    * Set ctx->NewState to zero to avoid recursion if
-    * Driver.UpdateState() has to call FLUSH_VERTICES().  (fixed?)
-    */
-   new_state = ctx->NewState | new_prog_state;
-   ctx->NewState = 0;
-   ctx->Driver.UpdateState(ctx, new_state);
-   ctx->Array.NewState = 0;
-   if (!ctx->Array.RebindArrays)
-      ctx->Array.RebindArrays = (new_state & (_NEW_ARRAY | _NEW_PROGRAM)) != 0;
-}
-
-
-/* This is the usual entrypoint for state updates:
- */
-void
-_mesa_update_state( struct gl_context *ctx )
-{
-   _mesa_lock_context_textures(ctx);
-   _mesa_update_state_locked(ctx);
-   _mesa_unlock_context_textures(ctx);
-}
-
-
-
-
-/**
- * Want to figure out which fragment program inputs are actually
- * constant/current values from ctx->Current.  These should be
- * referenced as a tracked state variable rather than a fragment
- * program input, to save the overhead of putting a constant value in
- * every submitted vertex, transferring it to hardware, interpolating
- * it across the triangle, etc...
- *
- * When there is a VP bound, just use vp->outputs.  But when we're
- * generating vp from fixed function state, basically want to
- * calculate:
- *
- * vp_out_2_fp_in( vp_in_2_vp_out( varying_inputs ) | 
- *                 potential_vp_outputs )
- *
- * Where potential_vp_outputs is calculated by looking at enabled
- * texgen, etc.
- * 
- * The generated fragment program should then only declare inputs that
- * may vary or otherwise differ from the ctx->Current values.
- * Otherwise, the fp should track them as state values instead.
- */
-void
-_mesa_set_varying_vp_inputs( struct gl_context *ctx,
-                             GLbitfield varying_inputs )
-{
-   if (ctx->varying_vp_inputs != varying_inputs) {
-      ctx->varying_vp_inputs = varying_inputs;
-      ctx->NewState |= _NEW_ARRAY;
-      /*printf("%s %x\n", __FUNCTION__, varying_inputs);*/
-   }
-}
-
-
-/**
- * Used by drivers to tell core Mesa that the driver is going to
- * install/ use its own vertex program.  In particular, this will
- * prevent generated fragment programs from using state vars instead
- * of ordinary varyings/inputs.
- */
-void
-_mesa_set_vp_override(struct gl_context *ctx, GLboolean flag)
-{
-   if (ctx->VertexProgram._Overriden != flag) {
-      ctx->VertexProgram._Overriden = flag;
-
-      /* Set one of the bits which will trigger fragment program
-       * regeneration:
-       */
-      ctx->NewState |= _NEW_PROGRAM;
-   }
-}
+/*

+ * Mesa 3-D graphics library

+ * Version:  7.3

+ *

+ * Copyright (C) 1999-2008  Brian Paul   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 state.c

+ * State management.

+ * 

+ * This file manages recalculation of derived values in struct gl_context.

+ */

+

+

+#include "glheader.h"

+#include "mtypes.h"

+#include "context.h"

+#include "debug.h"

+#include "macros.h"

+#include "ffvertex_prog.h"

+#include "framebuffer.h"

+#include "light.h"

+#include "matrix.h"

+#include "pixel.h"

+#include "program/program.h"

+#include "program/prog_parameter.h"

+#include "shaderobj.h"

+#include "state.h"

+#include "stencil.h"

+#include "texenvprogram.h"

+#include "texobj.h"

+#include "texstate.h"

+

+

+static void

+update_separate_specular(struct gl_context *ctx)

+{

+   if (_mesa_need_secondary_color(ctx))

+      ctx->_TriangleCaps |= DD_SEPARATE_SPECULAR;

+   else

+      ctx->_TriangleCaps &= ~DD_SEPARATE_SPECULAR;

+}

+

+

+/**

+ * Compute the index of the last array element that can be safely accessed

+ * in a vertex array.  We can really only do this when the array lives in

+ * a VBO.

+ * The array->_MaxElement field will be updated.

+ * Later in glDrawArrays/Elements/etc we can do some bounds checking.

+ */

+static void

+compute_max_element(struct gl_client_array *array)

+{

+   assert(array->Enabled);

+   if (array->BufferObj->Name) {

+      GLsizeiptrARB offset = (GLsizeiptrARB) array->Ptr;

+      GLsizeiptrARB obj_size = (GLsizeiptrARB) array->BufferObj->Size;

+

+      if (offset < obj_size) {

+	 array->_MaxElement = (obj_size - offset +

+			       array->StrideB -

+			       array->_ElementSize) / array->StrideB;

+      } else {

+	 array->_MaxElement = 0;

+      }

+   }

+   else {

+      /* user-space array, no idea how big it is */

+      array->_MaxElement = 2 * 1000 * 1000 * 1000; /* just a big number */

+   }

+}

+

+

+/**

+ * Helper for update_arrays().

+ * \return  min(current min, array->_MaxElement).

+ */

+static GLuint

+update_min(GLuint min, struct gl_client_array *array)

+{

+   compute_max_element(array);

+   return MIN2(min, array->_MaxElement);

+}

+

+

+/**

+ * Update ctx->Array._MaxElement (the max legal index into all enabled arrays).

+ * Need to do this upon new array state or new buffer object state.

+ */

+static void

+update_arrays( struct gl_context *ctx )

+{

+   struct gl_array_object *arrayObj = ctx->Array.ArrayObj;

+   GLuint i, min = ~0;

+

+   /* find min of _MaxElement values for all enabled arrays */

+

+   /* 0 */

+   if (ctx->VertexProgram._Current

+       && arrayObj->VertexAttrib[VERT_ATTRIB_POS].Enabled) {

+      min = update_min(min, &arrayObj->VertexAttrib[VERT_ATTRIB_POS]);

+   }

+   else if (arrayObj->Vertex.Enabled) {

+      min = update_min(min, &arrayObj->Vertex);

+   }

+

+   /* 1 */

+   if (ctx->VertexProgram._Enabled

+       && arrayObj->VertexAttrib[VERT_ATTRIB_WEIGHT].Enabled) {

+      min = update_min(min, &arrayObj->VertexAttrib[VERT_ATTRIB_WEIGHT]);

+   }

+   /* no conventional vertex weight array */

+

+   /* 2 */

+   if (ctx->VertexProgram._Enabled

+       && arrayObj->VertexAttrib[VERT_ATTRIB_NORMAL].Enabled) {

+      min = update_min(min, &arrayObj->VertexAttrib[VERT_ATTRIB_NORMAL]);

+   }

+   else if (arrayObj->Normal.Enabled) {

+      min = update_min(min, &arrayObj->Normal);

+   }

+

+   /* 3 */

+   if (ctx->VertexProgram._Enabled

+       && arrayObj->VertexAttrib[VERT_ATTRIB_COLOR0].Enabled) {

+      min = update_min(min, &arrayObj->VertexAttrib[VERT_ATTRIB_COLOR0]);

+   }

+   else if (arrayObj->Color.Enabled) {

+      min = update_min(min, &arrayObj->Color);

+   }

+

+   /* 4 */

+   if (ctx->VertexProgram._Enabled

+       && arrayObj->VertexAttrib[VERT_ATTRIB_COLOR1].Enabled) {

+      min = update_min(min, &arrayObj->VertexAttrib[VERT_ATTRIB_COLOR1]);

+   }

+   else if (arrayObj->SecondaryColor.Enabled) {

+      min = update_min(min, &arrayObj->SecondaryColor);

+   }

+

+   /* 5 */

+   if (ctx->VertexProgram._Enabled

+       && arrayObj->VertexAttrib[VERT_ATTRIB_FOG].Enabled) {

+      min = update_min(min, &arrayObj->VertexAttrib[VERT_ATTRIB_FOG]);

+   }

+   else if (arrayObj->FogCoord.Enabled) {

+      min = update_min(min, &arrayObj->FogCoord);

+   }

+

+   /* 6 */

+   if (ctx->VertexProgram._Enabled

+       && arrayObj->VertexAttrib[VERT_ATTRIB_COLOR_INDEX].Enabled) {

+      min = update_min(min, &arrayObj->VertexAttrib[VERT_ATTRIB_COLOR_INDEX]);

+   }

+   else if (arrayObj->Index.Enabled) {

+      min = update_min(min, &arrayObj->Index);

+   }

+

+   /* 7 */

+   if (ctx->VertexProgram._Enabled

+       && arrayObj->VertexAttrib[VERT_ATTRIB_EDGEFLAG].Enabled) {

+      min = update_min(min, &arrayObj->VertexAttrib[VERT_ATTRIB_EDGEFLAG]);

+   }

+

+   /* 8..15 */

+   for (i = VERT_ATTRIB_TEX0; i <= VERT_ATTRIB_TEX7; i++) {

+      if (ctx->VertexProgram._Enabled

+          && arrayObj->VertexAttrib[i].Enabled) {

+         min = update_min(min, &arrayObj->VertexAttrib[i]);

+      }

+      else if (i - VERT_ATTRIB_TEX0 < ctx->Const.MaxTextureCoordUnits

+               && arrayObj->TexCoord[i - VERT_ATTRIB_TEX0].Enabled) {

+         min = update_min(min, &arrayObj->TexCoord[i - VERT_ATTRIB_TEX0]);

+      }

+   }

+

+   /* 16..31 */

+   if (ctx->VertexProgram._Current) {

+      for (i = 0; i < Elements(arrayObj->VertexAttrib); i++) {

+         if (arrayObj->VertexAttrib[i].Enabled) {

+            min = update_min(min, &arrayObj->VertexAttrib[i]);

+         }

+      }

+   }

+

+   if (arrayObj->EdgeFlag.Enabled) {

+      min = update_min(min, &arrayObj->EdgeFlag);

+   }

+

+   /* _MaxElement is one past the last legal array element */

+   arrayObj->_MaxElement = min;

+}

+

+

+/**

+ * Update the following fields:

+ *   ctx->VertexProgram._Enabled

+ *   ctx->FragmentProgram._Enabled

+ *   ctx->ATIFragmentShader._Enabled

+ * This needs to be done before texture state validation.

+ */

+static void

+update_program_enables(struct gl_context *ctx)

+{

+   /* These _Enabled flags indicate if the program is enabled AND valid. */

+   ctx->VertexProgram._Enabled = ctx->VertexProgram.Enabled

+      && ctx->VertexProgram.Current->Base.Instructions;

+   ctx->FragmentProgram._Enabled = ctx->FragmentProgram.Enabled

+      && ctx->FragmentProgram.Current->Base.Instructions;

+   ctx->ATIFragmentShader._Enabled = ctx->ATIFragmentShader.Enabled

+      && ctx->ATIFragmentShader.Current->Instructions[0];

+}

+

+

+/**

+ * Update vertex/fragment program state.  In particular, update these fields:

+ *   ctx->VertexProgram._Current

+ *   ctx->VertexProgram._TnlProgram,

+ * These point to the highest priority enabled vertex/fragment program or are

+ * NULL if fixed-function processing is to be done.

+ *

+ * This function needs to be called after texture state validation in case

+ * we're generating a fragment program from fixed-function texture state.

+ *

+ * \return bitfield which will indicate _NEW_PROGRAM state if a new vertex

+ * or fragment program is being used.

+ */

+static GLbitfield

+update_program(struct gl_context *ctx)

+{

+   const struct gl_shader_program *vsProg = ctx->Shader.CurrentVertexProgram;

+   const struct gl_shader_program *gsProg = ctx->Shader.CurrentGeometryProgram;

+   struct gl_shader_program *fsProg = ctx->Shader.CurrentFragmentProgram;

+   const struct gl_vertex_program *prevVP = ctx->VertexProgram._Current;

+   const struct gl_fragment_program *prevFP = ctx->FragmentProgram._Current;

+   const struct gl_geometry_program *prevGP = ctx->GeometryProgram._Current;

+   GLbitfield new_state = 0x0;

+

+   /*

+    * Set the ctx->VertexProgram._Current and ctx->FragmentProgram._Current

+    * pointers to the programs that should be used for rendering.  If either

+    * is NULL, use fixed-function code paths.

+    *

+    * These programs may come from several sources.  The priority is as

+    * follows:

+    *   1. OpenGL 2.0/ARB vertex/fragment shaders

+    *   2. ARB/NV vertex/fragment programs

+    *   3. Programs derived from fixed-function state.

+    *

+    * Note: it's possible for a vertex shader to get used with a fragment

+    * program (and vice versa) here, but in practice that shouldn't ever

+    * come up, or matter.

+    */

+

+   if (fsProg && fsProg->LinkStatus && fsProg->FragmentProgram) {

+      /* Use shader programs */

+      _mesa_reference_fragprog(ctx, &ctx->FragmentProgram._Current,

+                               fsProg->FragmentProgram);

+      _mesa_reference_shader_program(ctx, &ctx->Shader._CurrentFragmentProgram,

+				     fsProg);

+   }

+   else if (ctx->FragmentProgram._Enabled) {

+      /* use user-defined fragment program */

+      _mesa_reference_fragprog(ctx, &ctx->FragmentProgram._Current,

+                               ctx->FragmentProgram.Current);

+      _mesa_reference_shader_program(ctx, &ctx->Shader._CurrentFragmentProgram,

+				     NULL);

+   }

+   else if (ctx->FragmentProgram._MaintainTexEnvProgram) {

+      /* Use fragment program generated from fixed-function state.

+       */

+      struct gl_shader_program *f = _mesa_get_fixed_func_fragment_program(ctx);

+      _mesa_reference_shader_program(ctx,

+				     &ctx->Shader._CurrentFragmentProgram, f);

+

+      _mesa_reference_fragprog(ctx, &ctx->FragmentProgram._Current,

+                               f->FragmentProgram);

+   }

+   else {

+      /* no fragment program */

+      _mesa_reference_fragprog(ctx, &ctx->FragmentProgram._Current, NULL);

+      _mesa_reference_shader_program(ctx, &ctx->Shader._CurrentFragmentProgram,

+				     NULL);

+   }

+

+   if (gsProg && gsProg->LinkStatus && gsProg->GeometryProgram) {

+      /* Use shader programs */

+      _mesa_reference_geomprog(ctx, &ctx->GeometryProgram._Current,

+                               gsProg->GeometryProgram);

+   } else {

+      /* no fragment program */

+      _mesa_reference_geomprog(ctx, &ctx->GeometryProgram._Current, NULL);

+   }

+

+   /* Examine vertex program after fragment program as

+    * _mesa_get_fixed_func_vertex_program() needs to know active

+    * fragprog inputs.

+    */

+   if (vsProg && vsProg->LinkStatus && vsProg->VertexProgram) {

+      /* Use shader programs */

+      _mesa_reference_vertprog(ctx, &ctx->VertexProgram._Current,

+                            vsProg->VertexProgram);

+   }

+   else if (ctx->VertexProgram._Enabled) {

+      /* use user-defined vertex program */

+      _mesa_reference_vertprog(ctx, &ctx->VertexProgram._Current,

+                               ctx->VertexProgram.Current);

+   }

+   else if (ctx->VertexProgram._MaintainTnlProgram) {

+      /* Use vertex program generated from fixed-function state.

+       */

+      _mesa_reference_vertprog(ctx, &ctx->VertexProgram._Current,

+                               _mesa_get_fixed_func_vertex_program(ctx));

+      _mesa_reference_vertprog(ctx, &ctx->VertexProgram._TnlProgram,

+                               ctx->VertexProgram._Current);

+   }

+   else {

+      /* no vertex program */

+      _mesa_reference_vertprog(ctx, &ctx->VertexProgram._Current, NULL);

+   }

+

+   /* Let the driver know what's happening:

+    */

+   if (ctx->FragmentProgram._Current != prevFP) {

+      new_state |= _NEW_PROGRAM;

+      if (ctx->Driver.BindProgram) {

+         ctx->Driver.BindProgram(ctx, GL_FRAGMENT_PROGRAM_ARB,

+                          (struct gl_program *) ctx->FragmentProgram._Current);

+      }

+   }

+

+   if (ctx->GeometryProgram._Current != prevGP) {

+      new_state |= _NEW_PROGRAM;

+      if (ctx->Driver.BindProgram) {

+         ctx->Driver.BindProgram(ctx, MESA_GEOMETRY_PROGRAM,

+                            (struct gl_program *) ctx->GeometryProgram._Current);

+      }

+   }

+

+   if (ctx->VertexProgram._Current != prevVP) {

+      new_state |= _NEW_PROGRAM;

+      if (ctx->Driver.BindProgram) {

+         ctx->Driver.BindProgram(ctx, GL_VERTEX_PROGRAM_ARB,

+                            (struct gl_program *) ctx->VertexProgram._Current);

+      }

+   }

+

+   return new_state;

+}

+

+

+/**

+ * Examine shader constants and return either _NEW_PROGRAM_CONSTANTS or 0.

+ */

+static GLbitfield

+update_program_constants(struct gl_context *ctx)

+{

+   GLbitfield new_state = 0x0;

+

+   if (ctx->FragmentProgram._Current) {

+      const struct gl_program_parameter_list *params =

+         ctx->FragmentProgram._Current->Base.Parameters;

+      if (params && params->StateFlags & ctx->NewState) {

+         new_state |= _NEW_PROGRAM_CONSTANTS;

+      }

+   }

+

+   if (ctx->GeometryProgram._Current) {

+      const struct gl_program_parameter_list *params =

+         ctx->GeometryProgram._Current->Base.Parameters;

+      /*FIXME: StateFlags is always 0 because we have unnamed constant

+       *       not state changes */

+      if (params /*&& params->StateFlags & ctx->NewState*/) {

+         new_state |= _NEW_PROGRAM_CONSTANTS;

+      }

+   }

+

+   if (ctx->VertexProgram._Current) {

+      const struct gl_program_parameter_list *params =

+         ctx->VertexProgram._Current->Base.Parameters;

+      if (params && params->StateFlags & ctx->NewState) {

+         new_state |= _NEW_PROGRAM_CONSTANTS;

+      }

+   }

+

+   return new_state;

+}

+

+

+

+

+static void

+update_viewport_matrix(struct gl_context *ctx)

+{

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

+

+   ASSERT(depthMax > 0);

+

+   /* Compute scale and bias values. This is really driver-specific

+    * and should be maintained elsewhere if at all.

+    * NOTE: RasterPos uses this.

+    */

+   _math_matrix_viewport(&ctx->Viewport._WindowMap,

+                         ctx->Viewport.X, ctx->Viewport.Y,

+                         ctx->Viewport.Width, ctx->Viewport.Height,

+                         ctx->Viewport.Near, ctx->Viewport.Far,

+                         depthMax);

+}

+

+

+/**

+ * Update derived multisample state.

+ */

+static void

+update_multisample(struct gl_context *ctx)

+{

+   ctx->Multisample._Enabled = GL_FALSE;

+   if (ctx->Multisample.Enabled &&

+       ctx->DrawBuffer &&

+       ctx->DrawBuffer->Visual.sampleBuffers)

+      ctx->Multisample._Enabled = GL_TRUE;

+}

+

+

+/**

+ * Update derived color/blend/logicop state.

+ */

+static void

+update_color(struct gl_context *ctx)

+{

+   /* This is needed to support 1.1's RGB logic ops AND

+    * 1.0's blending logicops.

+    */

+   ctx->Color._LogicOpEnabled = _mesa_rgba_logicop_enabled(ctx);

+}

+

+

+/*

+ * Check polygon state and set DD_TRI_CULL_FRONT_BACK and/or DD_TRI_OFFSET

+ * in ctx->_TriangleCaps if needed.

+ */

+static void

+update_polygon(struct gl_context *ctx)

+{

+   ctx->_TriangleCaps &= ~(DD_TRI_CULL_FRONT_BACK | DD_TRI_OFFSET);

+

+   if (ctx->Polygon.CullFlag && ctx->Polygon.CullFaceMode == GL_FRONT_AND_BACK)

+      ctx->_TriangleCaps |= DD_TRI_CULL_FRONT_BACK;

+

+   if (   ctx->Polygon.OffsetPoint

+       || ctx->Polygon.OffsetLine

+       || ctx->Polygon.OffsetFill)

+      ctx->_TriangleCaps |= DD_TRI_OFFSET;

+}

+

+

+/**

+ * Update the ctx->_TriangleCaps bitfield.

+ * XXX that bitfield should really go away someday!

+ * This function must be called after other update_*() functions since

+ * there are dependencies on some other derived values.

+ */

+#if 0

+static void

+update_tricaps(struct gl_context *ctx, GLbitfield new_state)

+{

+   ctx->_TriangleCaps = 0;

+

+   /*

+    * Points

+    */

+   if (1/*new_state & _NEW_POINT*/) {

+      if (ctx->Point.SmoothFlag)

+         ctx->_TriangleCaps |= DD_POINT_SMOOTH;

+      if (ctx->Point._Attenuated)

+         ctx->_TriangleCaps |= DD_POINT_ATTEN;

+   }

+

+   /*

+    * Lines

+    */

+   if (1/*new_state & _NEW_LINE*/) {

+      if (ctx->Line.SmoothFlag)

+         ctx->_TriangleCaps |= DD_LINE_SMOOTH;

+      if (ctx->Line.StippleFlag)

+         ctx->_TriangleCaps |= DD_LINE_STIPPLE;

+   }

+

+   /*

+    * Polygons

+    */

+   if (1/*new_state & _NEW_POLYGON*/) {

+      if (ctx->Polygon.SmoothFlag)

+         ctx->_TriangleCaps |= DD_TRI_SMOOTH;

+      if (ctx->Polygon.StippleFlag)

+         ctx->_TriangleCaps |= DD_TRI_STIPPLE;

+      if (ctx->Polygon.FrontMode != GL_FILL

+          || ctx->Polygon.BackMode != GL_FILL)

+         ctx->_TriangleCaps |= DD_TRI_UNFILLED;

+      if (ctx->Polygon.CullFlag

+          && ctx->Polygon.CullFaceMode == GL_FRONT_AND_BACK)

+         ctx->_TriangleCaps |= DD_TRI_CULL_FRONT_BACK;

+      if (ctx->Polygon.OffsetPoint ||

+          ctx->Polygon.OffsetLine ||

+          ctx->Polygon.OffsetFill)

+         ctx->_TriangleCaps |= DD_TRI_OFFSET;

+   }

+

+   /*

+    * Lighting and shading

+    */

+   if (ctx->Light.Enabled && ctx->Light.Model.TwoSide)

+      ctx->_TriangleCaps |= DD_TRI_LIGHT_TWOSIDE;

+   if (ctx->Light.ShadeModel == GL_FLAT)

+      ctx->_TriangleCaps |= DD_FLATSHADE;

+   if (_mesa_need_secondary_color(ctx))

+      ctx->_TriangleCaps |= DD_SEPARATE_SPECULAR;

+

+   /*

+    * Stencil

+    */

+   if (ctx->Stencil._TestTwoSide)

+      ctx->_TriangleCaps |= DD_TRI_TWOSTENCIL;

+}

+#endif

+

+

+/**

+ * Compute derived GL state.

+ * If __struct gl_contextRec::NewState is non-zero then this function \b must

+ * be called before rendering anything.

+ *

+ * Calls dd_function_table::UpdateState to perform any internal state

+ * management necessary.

+ * 

+ * \sa _mesa_update_modelview_project(), _mesa_update_texture(),

+ * _mesa_update_buffer_bounds(),

+ * _mesa_update_lighting() and _mesa_update_tnl_spaces().

+ */

+void

+_mesa_update_state_locked( struct gl_context *ctx )

+{

+   GLbitfield new_state = ctx->NewState;

+   GLbitfield prog_flags = _NEW_PROGRAM;

+   GLbitfield new_prog_state = 0x0;

+

+   if (new_state == _NEW_CURRENT_ATTRIB) 

+      goto out;

+

+   if (MESA_VERBOSE & VERBOSE_STATE)

+      _mesa_print_state("_mesa_update_state", new_state);

+

+   /* Determine which state flags effect vertex/fragment program state */

+   if (ctx->FragmentProgram._MaintainTexEnvProgram) {

+      prog_flags |= (_NEW_BUFFERS | _NEW_TEXTURE | _NEW_FOG |

+		     _NEW_ARRAY | _NEW_LIGHT | _NEW_POINT | _NEW_RENDERMODE |

+		     _NEW_PROGRAM);

+   }

+   if (ctx->VertexProgram._MaintainTnlProgram) {

+      prog_flags |= (_NEW_ARRAY | _NEW_TEXTURE | _NEW_TEXTURE_MATRIX |

+                     _NEW_TRANSFORM | _NEW_POINT |

+                     _NEW_FOG | _NEW_LIGHT |

+                     _MESA_NEW_NEED_EYE_COORDS);

+   }

+

+   /*

+    * Now update derived state info

+    */

+

+   if (new_state & prog_flags)

+      update_program_enables( ctx );

+

+   if (new_state & (_NEW_MODELVIEW|_NEW_PROJECTION))

+      _mesa_update_modelview_project( ctx, new_state );

+

+   if (new_state & (_NEW_PROGRAM|_NEW_TEXTURE|_NEW_TEXTURE_MATRIX))

+      _mesa_update_texture( ctx, new_state );

+

+   if (new_state & _NEW_BUFFERS)

+      _mesa_update_framebuffer(ctx);

+

+   if (new_state & (_NEW_SCISSOR | _NEW_BUFFERS | _NEW_VIEWPORT))

+      _mesa_update_draw_buffer_bounds( ctx );

+

+   if (new_state & _NEW_POLYGON)

+      update_polygon( ctx );

+

+   if (new_state & _NEW_LIGHT)

+      _mesa_update_lighting( ctx );

+

+   if (new_state & (_NEW_STENCIL | _NEW_BUFFERS))

+      _mesa_update_stencil( ctx );

+

+   if (new_state & _MESA_NEW_TRANSFER_STATE)

+      _mesa_update_pixel( ctx, new_state );

+

+   if (new_state & _DD_NEW_SEPARATE_SPECULAR)

+      update_separate_specular( ctx );

+

+   if (new_state & (_NEW_BUFFERS | _NEW_VIEWPORT))

+      update_viewport_matrix(ctx);

+

+   if (new_state & _NEW_MULTISAMPLE)

+      update_multisample( ctx );

+

+   if (new_state & _NEW_COLOR)

+      update_color( ctx );

+

+#if 0

+   if (new_state & (_NEW_POINT | _NEW_LINE | _NEW_POLYGON | _NEW_LIGHT

+                    | _NEW_STENCIL | _DD_NEW_SEPARATE_SPECULAR))

+      update_tricaps( ctx, new_state );

+#endif

+

+   /* ctx->_NeedEyeCoords is now up to date.

+    *

+    * If the truth value of this variable has changed, update for the

+    * new lighting space and recompute the positions of lights and the

+    * normal transform.

+    *

+    * If the lighting space hasn't changed, may still need to recompute

+    * light positions & normal transforms for other reasons.

+    */

+   if (new_state & _MESA_NEW_NEED_EYE_COORDS) 

+      _mesa_update_tnl_spaces( ctx, new_state );

+

+   if (new_state & prog_flags) {

+      /* When we generate programs from fixed-function vertex/fragment state

+       * this call may generate/bind a new program.  If so, we need to

+       * propogate the _NEW_PROGRAM flag to the driver.

+       */

+      new_prog_state |= update_program( ctx );

+   }

+

+   if (new_state & (_NEW_ARRAY | _NEW_PROGRAM | _NEW_BUFFER_OBJECT))

+      update_arrays( ctx );

+

+ out:

+   new_prog_state |= update_program_constants(ctx);

+

+   /*

+    * Give the driver a chance to act upon the new_state flags.

+    * The driver might plug in different span functions, for example.

+    * Also, this is where the driver can invalidate the state of any

+    * active modules (such as swrast_setup, swrast, tnl, etc).

+    *

+    * Set ctx->NewState to zero to avoid recursion if

+    * Driver.UpdateState() has to call FLUSH_VERTICES().  (fixed?)

+    */

+   new_state = ctx->NewState | new_prog_state;

+   ctx->NewState = 0;

+   ctx->Driver.UpdateState(ctx, new_state);

+   ctx->Array.NewState = 0;

+   if (!ctx->Array.RebindArrays)

+      ctx->Array.RebindArrays = (new_state & (_NEW_ARRAY | _NEW_PROGRAM)) != 0;

+}

+

+

+/* This is the usual entrypoint for state updates:

+ */

+void

+_mesa_update_state( struct gl_context *ctx )

+{

+   _mesa_lock_context_textures(ctx);

+   _mesa_update_state_locked(ctx);

+   _mesa_unlock_context_textures(ctx);

+}

+

+

+

+

+/**

+ * Want to figure out which fragment program inputs are actually

+ * constant/current values from ctx->Current.  These should be

+ * referenced as a tracked state variable rather than a fragment

+ * program input, to save the overhead of putting a constant value in

+ * every submitted vertex, transferring it to hardware, interpolating

+ * it across the triangle, etc...

+ *

+ * When there is a VP bound, just use vp->outputs.  But when we're

+ * generating vp from fixed function state, basically want to

+ * calculate:

+ *

+ * vp_out_2_fp_in( vp_in_2_vp_out( varying_inputs ) | 

+ *                 potential_vp_outputs )

+ *

+ * Where potential_vp_outputs is calculated by looking at enabled

+ * texgen, etc.

+ * 

+ * The generated fragment program should then only declare inputs that

+ * may vary or otherwise differ from the ctx->Current values.

+ * Otherwise, the fp should track them as state values instead.

+ */

+void

+_mesa_set_varying_vp_inputs( struct gl_context *ctx,

+                             GLbitfield varying_inputs )

+{

+   if (ctx->varying_vp_inputs != varying_inputs) {

+      ctx->varying_vp_inputs = varying_inputs;

+      ctx->NewState |= _NEW_ARRAY;

+      /*printf("%s %x\n", __FUNCTION__, varying_inputs);*/

+   }

+}

+

+

+/**

+ * Used by drivers to tell core Mesa that the driver is going to

+ * install/ use its own vertex program.  In particular, this will

+ * prevent generated fragment programs from using state vars instead

+ * of ordinary varyings/inputs.

+ */

+void

+_mesa_set_vp_override(struct gl_context *ctx, GLboolean flag)

+{

+   if (ctx->VertexProgram._Overriden != flag) {

+      ctx->VertexProgram._Overriden = flag;

+

+      /* Set one of the bits which will trigger fragment program

+       * regeneration:

+       */

+      ctx->NewState |= _NEW_PROGRAM;

+   }

+}

diff --git a/mesalib/src/mesa/main/state.h b/mesalib/src/mesa/main/state.h
index 6714196dc..31573fe5b 100644
--- a/mesalib/src/mesa/main/state.h
+++ b/mesalib/src/mesa/main/state.h
@@ -46,4 +46,43 @@ extern void
 _mesa_set_vp_override(struct gl_context *ctx, GLboolean flag);

 

 

+/**

+ * Is the secondary color needed?

+ */

+static INLINE GLboolean

+_mesa_need_secondary_color(const struct gl_context *ctx)

+{

+   if (ctx->Light.Enabled &&

+       ctx->Light.Model.ColorControl == GL_SEPARATE_SPECULAR_COLOR)

+       return GL_TRUE;

+

+   if (ctx->Fog.ColorSumEnabled)

+      return GL_TRUE;

+

+   if (ctx->VertexProgram._Current &&

+       (ctx->VertexProgram._Current != ctx->VertexProgram._TnlProgram) &&

+       (ctx->VertexProgram._Current->Base.InputsRead & VERT_BIT_COLOR1))

+      return GL_TRUE;

+

+   if (ctx->FragmentProgram._Current &&

+       (ctx->FragmentProgram._Current != ctx->FragmentProgram._TexEnvProgram) &&

+       (ctx->FragmentProgram._Current->Base.InputsRead & FRAG_BIT_COL1))

+      return GL_TRUE;

+

+   return GL_FALSE;

+}

+

+

+/**

+ * Is RGBA LogicOp enabled?

+ */

+static INLINE GLboolean

+_mesa_rgba_logicop_enabled(const struct gl_context *ctx)

+{

+   return ctx->Color.ColorLogicOpEnabled ||

+      (ctx->Color.BlendEnabled && ctx->Color.Blend[0].EquationRGB == GL_LOGIC_OP);

+}

+

+

+

 #endif

diff --git a/mesalib/src/mesa/main/texenvprogram.c b/mesalib/src/mesa/main/texenvprogram.c
deleted file mode 100644
index c30fe9616..000000000
--- a/mesalib/src/mesa/main/texenvprogram.c
+++ /dev/null
@@ -1,1618 +0,0 @@
-/**************************************************************************

- * 

- * Copyright 2007 Tungsten Graphics, Inc., Cedar Park, Texas.

- * All Rights Reserved.

- * Copyright 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, sub license, 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 (including the

- * next paragraph) 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 NON-INFRINGEMENT.

- * IN NO EVENT SHALL TUNGSTEN GRAPHICS AND/OR ITS SUPPLIERS 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.

- * 

- **************************************************************************/

-

-#include "glheader.h"

-#include "imports.h"

-#include "mtypes.h"

-#include "program/program.h"

-#include "program/prog_parameter.h"

-#include "program/prog_cache.h"

-#include "program/prog_instruction.h"

-#include "program/prog_print.h"

-#include "program/prog_statevars.h"

-#include "program/programopt.h"

-#include "texenvprogram.h"

-

-

-/*

- * Note on texture units:

- *

- * The number of texture units supported by fixed-function fragment

- * processing is MAX_TEXTURE_COORD_UNITS, not MAX_TEXTURE_IMAGE_UNITS.

- * That's because there's a one-to-one correspondence between texture

- * coordinates and samplers in fixed-function processing.

- *

- * Since fixed-function vertex processing is limited to MAX_TEXTURE_COORD_UNITS

- * sets of texcoords, so is fixed-function fragment processing.

- *

- * We can safely use ctx->Const.MaxTextureUnits for loop bounds.

- */

-

-

-struct texenvprog_cache_item

-{

-   GLuint hash;

-   void *key;

-   struct gl_fragment_program *data;

-   struct texenvprog_cache_item *next;

-};

-

-static GLboolean

-texenv_doing_secondary_color(struct gl_context *ctx)

-{

-   if (ctx->Light.Enabled &&

-       (ctx->Light.Model.ColorControl == GL_SEPARATE_SPECULAR_COLOR))

-      return GL_TRUE;

-

-   if (ctx->Fog.ColorSumEnabled)

-      return GL_TRUE;

-

-   return GL_FALSE;

-}

-

-/**

- * Up to nine instructions per tex unit, plus fog, specular color.

- */

-#define MAX_INSTRUCTIONS ((MAX_TEXTURE_COORD_UNITS * 9) + 12)

-

-#define DISASSEM (MESA_VERBOSE & VERBOSE_DISASSEM)

-

-struct mode_opt {

-#ifdef __GNUC__

-   __extension__ GLubyte Source:4;  /**< SRC_x */

-   __extension__ GLubyte Operand:3; /**< OPR_x */

-#else

-   GLubyte Source;  /**< SRC_x */

-   GLubyte Operand; /**< OPR_x */

-#endif

-};

-

-struct state_key {

-   GLuint nr_enabled_units:8;

-   GLuint enabled_units:8;

-   GLuint separate_specular:1;

-   GLuint fog_enabled:1;

-   GLuint fog_mode:2;          /**< FOG_x */

-   GLuint inputs_available:12;

-   GLuint num_draw_buffers:4;

-

-   /* NOTE: This array of structs must be last! (see "keySize" below) */

-   struct {

-      GLuint enabled:1;

-      GLuint source_index:3;   /**< TEXTURE_x_INDEX */

-      GLuint shadow:1;

-      GLuint ScaleShiftRGB:2;

-      GLuint ScaleShiftA:2;

-

-      GLuint NumArgsRGB:3;  /**< up to MAX_COMBINER_TERMS */

-      GLuint ModeRGB:5;     /**< MODE_x */

-

-      GLuint NumArgsA:3;  /**< up to MAX_COMBINER_TERMS */

-      GLuint ModeA:5;     /**< MODE_x */

-

-      GLuint texture_cyl_wrap:1; /**< For gallium test/debug only */

-

-      struct mode_opt OptRGB[MAX_COMBINER_TERMS];

-      struct mode_opt OptA[MAX_COMBINER_TERMS];

-   } unit[MAX_TEXTURE_UNITS];

-};

-

-#define FOG_LINEAR  0

-#define FOG_EXP     1

-#define FOG_EXP2    2

-#define FOG_UNKNOWN 3

-

-static GLuint translate_fog_mode( GLenum mode )

-{

-   switch (mode) {

-   case GL_LINEAR: return FOG_LINEAR;

-   case GL_EXP: return FOG_EXP;

-   case GL_EXP2: return FOG_EXP2;

-   default: return FOG_UNKNOWN;

-   }

-}

-

-#define OPR_SRC_COLOR           0

-#define OPR_ONE_MINUS_SRC_COLOR 1

-#define OPR_SRC_ALPHA           2

-#define OPR_ONE_MINUS_SRC_ALPHA	3

-#define OPR_ZERO                4

-#define OPR_ONE                 5

-#define OPR_UNKNOWN             7

-

-static GLuint translate_operand( GLenum operand )

-{

-   switch (operand) {

-   case GL_SRC_COLOR: return OPR_SRC_COLOR;

-   case GL_ONE_MINUS_SRC_COLOR: return OPR_ONE_MINUS_SRC_COLOR;

-   case GL_SRC_ALPHA: return OPR_SRC_ALPHA;

-   case GL_ONE_MINUS_SRC_ALPHA: return OPR_ONE_MINUS_SRC_ALPHA;

-   case GL_ZERO: return OPR_ZERO;

-   case GL_ONE: return OPR_ONE;

-   default:

-      assert(0);

-      return OPR_UNKNOWN;

-   }

-}

-

-#define SRC_TEXTURE  0

-#define SRC_TEXTURE0 1

-#define SRC_TEXTURE1 2

-#define SRC_TEXTURE2 3

-#define SRC_TEXTURE3 4

-#define SRC_TEXTURE4 5

-#define SRC_TEXTURE5 6

-#define SRC_TEXTURE6 7

-#define SRC_TEXTURE7 8

-#define SRC_CONSTANT 9

-#define SRC_PRIMARY_COLOR 10

-#define SRC_PREVIOUS 11

-#define SRC_ZERO     12

-#define SRC_UNKNOWN  15

-

-static GLuint translate_source( GLenum src )

-{

-   switch (src) {

-   case GL_TEXTURE: return SRC_TEXTURE;

-   case GL_TEXTURE0:

-   case GL_TEXTURE1:

-   case GL_TEXTURE2:

-   case GL_TEXTURE3:

-   case GL_TEXTURE4:

-   case GL_TEXTURE5:

-   case GL_TEXTURE6:

-   case GL_TEXTURE7: return SRC_TEXTURE0 + (src - GL_TEXTURE0);

-   case GL_CONSTANT: return SRC_CONSTANT;

-   case GL_PRIMARY_COLOR: return SRC_PRIMARY_COLOR;

-   case GL_PREVIOUS: return SRC_PREVIOUS;

-   case GL_ZERO:

-      return SRC_ZERO;

-   default:

-      assert(0);

-      return SRC_UNKNOWN;

-   }

-}

-

-#define MODE_REPLACE                     0  /* r = a0 */

-#define MODE_MODULATE                    1  /* r = a0 * a1 */

-#define MODE_ADD                         2  /* r = a0 + a1 */

-#define MODE_ADD_SIGNED                  3  /* r = a0 + a1 - 0.5 */

-#define MODE_INTERPOLATE                 4  /* r = a0 * a2 + a1 * (1 - a2) */

-#define MODE_SUBTRACT                    5  /* r = a0 - a1 */

-#define MODE_DOT3_RGB                    6  /* r = a0 . a1 */

-#define MODE_DOT3_RGB_EXT                7  /* r = a0 . a1 */

-#define MODE_DOT3_RGBA                   8  /* r = a0 . a1 */

-#define MODE_DOT3_RGBA_EXT               9  /* r = a0 . a1 */

-#define MODE_MODULATE_ADD_ATI           10  /* r = a0 * a2 + a1 */

-#define MODE_MODULATE_SIGNED_ADD_ATI    11  /* r = a0 * a2 + a1 - 0.5 */

-#define MODE_MODULATE_SUBTRACT_ATI      12  /* r = a0 * a2 - a1 */

-#define MODE_ADD_PRODUCTS               13  /* r = a0 * a1 + a2 * a3 */

-#define MODE_ADD_PRODUCTS_SIGNED        14  /* r = a0 * a1 + a2 * a3 - 0.5 */

-#define MODE_BUMP_ENVMAP_ATI            15  /* special */

-#define MODE_UNKNOWN                    16

-

-/**

- * Translate GL combiner state into a MODE_x value

- */

-static GLuint translate_mode( GLenum envMode, GLenum mode )

-{

-   switch (mode) {

-   case GL_REPLACE: return MODE_REPLACE;

-   case GL_MODULATE: return MODE_MODULATE;

-   case GL_ADD:

-      if (envMode == GL_COMBINE4_NV)

-         return MODE_ADD_PRODUCTS;

-      else

-         return MODE_ADD;

-   case GL_ADD_SIGNED:

-      if (envMode == GL_COMBINE4_NV)

-         return MODE_ADD_PRODUCTS_SIGNED;

-      else

-         return MODE_ADD_SIGNED;

-   case GL_INTERPOLATE: return MODE_INTERPOLATE;

-   case GL_SUBTRACT: return MODE_SUBTRACT;

-   case GL_DOT3_RGB: return MODE_DOT3_RGB;

-   case GL_DOT3_RGB_EXT: return MODE_DOT3_RGB_EXT;

-   case GL_DOT3_RGBA: return MODE_DOT3_RGBA;

-   case GL_DOT3_RGBA_EXT: return MODE_DOT3_RGBA_EXT;

-   case GL_MODULATE_ADD_ATI: return MODE_MODULATE_ADD_ATI;

-   case GL_MODULATE_SIGNED_ADD_ATI: return MODE_MODULATE_SIGNED_ADD_ATI;

-   case GL_MODULATE_SUBTRACT_ATI: return MODE_MODULATE_SUBTRACT_ATI;

-   case GL_BUMP_ENVMAP_ATI: return MODE_BUMP_ENVMAP_ATI;

-   default:

-      assert(0);

-      return MODE_UNKNOWN;

-   }

-}

-

-

-/**

- * Do we need to clamp the results of the given texture env/combine mode?

- * If the inputs to the mode are in [0,1] we don't always have to clamp

- * the results.

- */

-static GLboolean

-need_saturate( GLuint mode )

-{

-   switch (mode) {

-   case MODE_REPLACE:

-   case MODE_MODULATE:

-   case MODE_INTERPOLATE:

-      return GL_FALSE;

-   case MODE_ADD:

-   case MODE_ADD_SIGNED:

-   case MODE_SUBTRACT:

-   case MODE_DOT3_RGB:

-   case MODE_DOT3_RGB_EXT:

-   case MODE_DOT3_RGBA:

-   case MODE_DOT3_RGBA_EXT:

-   case MODE_MODULATE_ADD_ATI:

-   case MODE_MODULATE_SIGNED_ADD_ATI:

-   case MODE_MODULATE_SUBTRACT_ATI:

-   case MODE_ADD_PRODUCTS:

-   case MODE_ADD_PRODUCTS_SIGNED:

-   case MODE_BUMP_ENVMAP_ATI:

-      return GL_TRUE;

-   default:

-      assert(0);

-      return GL_FALSE;

-   }

-}

-

-

-

-/**

- * Translate TEXTURE_x_BIT to TEXTURE_x_INDEX.

- */

-static GLuint translate_tex_src_bit( GLbitfield bit )

-{

-   ASSERT(bit);

-   return _mesa_ffs(bit) - 1;

-}

-

-

-#define VERT_BIT_TEX_ANY    (0xff << VERT_ATTRIB_TEX0)

-#define VERT_RESULT_TEX_ANY (0xff << VERT_RESULT_TEX0)

-

-/**

- * Identify all possible varying inputs.  The fragment program will

- * never reference non-varying inputs, but will track them via state

- * constants instead.

- *

- * This function figures out all the inputs that the fragment program

- * has access to.  The bitmask is later reduced to just those which

- * are actually referenced.

- */

-static GLbitfield get_fp_input_mask( struct gl_context *ctx )

-{

-   /* _NEW_PROGRAM */

-   const GLboolean vertexShader =

-      (ctx->Shader.CurrentVertexProgram &&

-       ctx->Shader.CurrentVertexProgram->LinkStatus &&

-       ctx->Shader.CurrentVertexProgram->VertexProgram);

-   const GLboolean vertexProgram = ctx->VertexProgram._Enabled;

-   GLbitfield fp_inputs = 0x0;

-

-   if (ctx->VertexProgram._Overriden) {

-      /* Somebody's messing with the vertex program and we don't have

-       * a clue what's happening.  Assume that it could be producing

-       * all possible outputs.

-       */

-      fp_inputs = ~0;

-   }

-   else if (ctx->RenderMode == GL_FEEDBACK) {

-      /* _NEW_RENDERMODE */

-      fp_inputs = (FRAG_BIT_COL0 | FRAG_BIT_TEX0);

-   }

-   else if (!(vertexProgram || vertexShader) ||

-            !ctx->VertexProgram._Current) {

-      /* Fixed function vertex logic */

-      /* _NEW_ARRAY */

-      GLbitfield varying_inputs = ctx->varying_vp_inputs;

-

-      /* These get generated in the setup routine regardless of the

-       * vertex program:

-       */

-      /* _NEW_POINT */

-      if (ctx->Point.PointSprite)

-         varying_inputs |= FRAG_BITS_TEX_ANY;

-

-      /* First look at what values may be computed by the generated

-       * vertex program:

-       */

-      /* _NEW_LIGHT */

-      if (ctx->Light.Enabled) {

-         fp_inputs |= FRAG_BIT_COL0;

-

-         if (texenv_doing_secondary_color(ctx))

-            fp_inputs |= FRAG_BIT_COL1;

-      }

-

-      /* _NEW_TEXTURE */

-      fp_inputs |= (ctx->Texture._TexGenEnabled |

-                    ctx->Texture._TexMatEnabled) << FRAG_ATTRIB_TEX0;

-

-      /* Then look at what might be varying as a result of enabled

-       * arrays, etc:

-       */

-      if (varying_inputs & VERT_BIT_COLOR0)

-         fp_inputs |= FRAG_BIT_COL0;

-      if (varying_inputs & VERT_BIT_COLOR1)

-         fp_inputs |= FRAG_BIT_COL1;

-

-      fp_inputs |= (((varying_inputs & VERT_BIT_TEX_ANY) >> VERT_ATTRIB_TEX0) 

-                    << FRAG_ATTRIB_TEX0);

-

-   }

-   else {

-      /* calculate from vp->outputs */

-      struct gl_vertex_program *vprog;

-      GLbitfield64 vp_outputs;

-

-      /* Choose GLSL vertex shader over ARB vertex program.  Need this

-       * since vertex shader state validation comes after fragment state

-       * validation (see additional comments in state.c).

-       */

-      if (vertexShader)

-         vprog = ctx->Shader.CurrentVertexProgram->VertexProgram;

-      else

-         vprog = ctx->VertexProgram.Current;

-

-      vp_outputs = vprog->Base.OutputsWritten;

-

-      /* These get generated in the setup routine regardless of the

-       * vertex program:

-       */

-      /* _NEW_POINT */

-      if (ctx->Point.PointSprite)

-         vp_outputs |= FRAG_BITS_TEX_ANY;

-

-      if (vp_outputs & (1 << VERT_RESULT_COL0))

-         fp_inputs |= FRAG_BIT_COL0;

-      if (vp_outputs & (1 << VERT_RESULT_COL1))

-         fp_inputs |= FRAG_BIT_COL1;

-

-      fp_inputs |= (((vp_outputs & VERT_RESULT_TEX_ANY) >> VERT_RESULT_TEX0) 

-                    << FRAG_ATTRIB_TEX0);

-   }

-   

-   return fp_inputs;

-}

-

-

-/**

- * Examine current texture environment state and generate a unique

- * key to identify it.

- */

-static GLuint make_state_key( struct gl_context *ctx,  struct state_key *key )

-{

-   GLuint i, j;

-   GLbitfield inputs_referenced = FRAG_BIT_COL0;

-   const GLbitfield inputs_available = get_fp_input_mask( ctx );

-   GLuint keySize;

-

-   memset(key, 0, sizeof(*key));

-

-   /* _NEW_TEXTURE */

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

-      const struct gl_texture_unit *texUnit = &ctx->Texture.Unit[i];

-      const struct gl_texture_object *texObj = texUnit->_Current;

-      const struct gl_tex_env_combine_state *comb = texUnit->_CurrentCombine;

-      GLenum format;

-

-      if (!texUnit->_ReallyEnabled || !texUnit->Enabled)

-         continue;

-

-      format = texObj->Image[0][texObj->BaseLevel]->_BaseFormat;

-

-      key->unit[i].enabled = 1;

-      key->enabled_units |= (1<<i);

-      key->nr_enabled_units = i + 1;

-      inputs_referenced |= FRAG_BIT_TEX(i);

-

-      key->unit[i].source_index =

-         translate_tex_src_bit(texUnit->_ReallyEnabled);

-

-      key->unit[i].shadow = ((texObj->CompareMode == GL_COMPARE_R_TO_TEXTURE) &&

-                             ((format == GL_DEPTH_COMPONENT) || 

-                              (format == GL_DEPTH_STENCIL_EXT)));

-

-      key->unit[i].NumArgsRGB = comb->_NumArgsRGB;

-      key->unit[i].NumArgsA = comb->_NumArgsA;

-

-      key->unit[i].ModeRGB =

-	 translate_mode(texUnit->EnvMode, comb->ModeRGB);

-      key->unit[i].ModeA =

-	 translate_mode(texUnit->EnvMode, comb->ModeA);

-

-      key->unit[i].ScaleShiftRGB = comb->ScaleShiftRGB;

-      key->unit[i].ScaleShiftA = comb->ScaleShiftA;

-

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

-         key->unit[i].OptRGB[j].Operand = translate_operand(comb->OperandRGB[j]);

-         key->unit[i].OptA[j].Operand = translate_operand(comb->OperandA[j]);

-         key->unit[i].OptRGB[j].Source = translate_source(comb->SourceRGB[j]);

-         key->unit[i].OptA[j].Source = translate_source(comb->SourceA[j]);

-      }

-

-      if (key->unit[i].ModeRGB == MODE_BUMP_ENVMAP_ATI) {

-         /* requires some special translation */

-         key->unit[i].NumArgsRGB = 2;

-         key->unit[i].ScaleShiftRGB = 0;

-         key->unit[i].OptRGB[0].Operand = OPR_SRC_COLOR;

-         key->unit[i].OptRGB[0].Source = SRC_TEXTURE;

-         key->unit[i].OptRGB[1].Operand = OPR_SRC_COLOR;

-         key->unit[i].OptRGB[1].Source = texUnit->BumpTarget - GL_TEXTURE0 + SRC_TEXTURE0;

-       }

-

-      /* this is a back-door for enabling cylindrical texture wrap mode */

-      if (texObj->Priority == 0.125)

-         key->unit[i].texture_cyl_wrap = 1;

-   }

-

-   /* _NEW_LIGHT | _NEW_FOG */

-   if (texenv_doing_secondary_color(ctx)) {

-      key->separate_specular = 1;

-      inputs_referenced |= FRAG_BIT_COL1;

-   }

-

-   /* _NEW_FOG */

-   if (ctx->Fog.Enabled) {

-      key->fog_enabled = 1;

-      key->fog_mode = translate_fog_mode(ctx->Fog.Mode);

-      inputs_referenced |= FRAG_BIT_FOGC; /* maybe */

-   }

-

-   /* _NEW_BUFFERS */

-   key->num_draw_buffers = ctx->DrawBuffer->_NumColorDrawBuffers;

-

-   key->inputs_available = (inputs_available & inputs_referenced);

-

-   /* compute size of state key, ignoring unused texture units */

-   keySize = sizeof(*key) - sizeof(key->unit)

-      + key->nr_enabled_units * sizeof(key->unit[0]);

-

-   return keySize;

-}

-

-

-/**

- * Use uregs to represent registers internally, translate to Mesa's

- * expected formats on emit.  

- *

- * NOTE: These are passed by value extensively in this file rather

- * than as usual by pointer reference.  If this disturbs you, try

- * remembering they are just 32bits in size.

- *

- * GCC is smart enough to deal with these dword-sized structures in

- * much the same way as if I had defined them as dwords and was using

- * macros to access and set the fields.  This is much nicer and easier

- * to evolve.

- */

-struct ureg {

-   GLuint file:4;

-   GLuint idx:8;

-   GLuint negatebase:1;

-   GLuint swz:12;

-   GLuint pad:7;

-};

-

-static const struct ureg undef = { 

-   PROGRAM_UNDEFINED,

-   ~0,

-   0,

-   0,

-   0

-};

-

-

-/** State used to build the fragment program:

- */

-struct texenv_fragment_program {

-   struct gl_fragment_program *program;

-   struct state_key *state;

-

-   GLbitfield alu_temps;	/**< Track texture indirections, see spec. */

-   GLbitfield temps_output;	/**< Track texture indirections, see spec. */

-   GLbitfield temp_in_use;	/**< Tracks temporary regs which are in use. */

-   GLboolean error;

-

-   struct ureg src_texture[MAX_TEXTURE_COORD_UNITS];   

-   /* Reg containing each texture unit's sampled texture color,

-    * else undef.

-    */

-

-   struct ureg texcoord_tex[MAX_TEXTURE_COORD_UNITS];

-   /* Reg containing texcoord for a texture unit,

-    * needed for bump mapping, else undef.

-    */

-

-   struct ureg src_previous;	/**< Reg containing color from previous 

-				 * stage.  May need to be decl'd.

-				 */

-

-   GLuint last_tex_stage;	/**< Number of last enabled texture unit */

-

-   struct ureg half;

-   struct ureg one;

-   struct ureg zero;

-};

-

-

-

-static struct ureg make_ureg(GLuint file, GLuint idx)

-{

-   struct ureg reg;

-   reg.file = file;

-   reg.idx = idx;

-   reg.negatebase = 0;

-   reg.swz = SWIZZLE_NOOP;

-   reg.pad = 0;

-   return reg;

-}

-

-static struct ureg swizzle( struct ureg reg, int x, int y, int z, int w )

-{

-   reg.swz = MAKE_SWIZZLE4(GET_SWZ(reg.swz, x),

-			   GET_SWZ(reg.swz, y),

-			   GET_SWZ(reg.swz, z),

-			   GET_SWZ(reg.swz, w));

-

-   return reg;

-}

-

-static struct ureg swizzle1( struct ureg reg, int x )

-{

-   return swizzle(reg, x, x, x, x);

-}

-

-static struct ureg negate( struct ureg reg )

-{

-   reg.negatebase ^= 1;

-   return reg;

-}

-

-static GLboolean is_undef( struct ureg reg )

-{

-   return reg.file == PROGRAM_UNDEFINED;

-}

-

-

-static struct ureg get_temp( struct texenv_fragment_program *p )

-{

-   GLint bit;

-   

-   /* First try and reuse temps which have been used already:

-    */

-   bit = _mesa_ffs( ~p->temp_in_use & p->alu_temps );

-

-   /* Then any unused temporary:

-    */

-   if (!bit)

-      bit = _mesa_ffs( ~p->temp_in_use );

-

-   if (!bit) {

-      _mesa_problem(NULL, "%s: out of temporaries\n", __FILE__);

-      exit(1);

-   }

-

-   if ((GLuint) bit > p->program->Base.NumTemporaries)

-      p->program->Base.NumTemporaries = bit;

-

-   p->temp_in_use |= 1<<(bit-1);

-   return make_ureg(PROGRAM_TEMPORARY, (bit-1));

-}

-

-static struct ureg get_tex_temp( struct texenv_fragment_program *p )

-{

-   int bit;

-   

-   /* First try to find available temp not previously used (to avoid

-    * starting a new texture indirection).  According to the spec, the

-    * ~p->temps_output isn't necessary, but will keep it there for

-    * now:

-    */

-   bit = _mesa_ffs( ~p->temp_in_use & ~p->alu_temps & ~p->temps_output );

-

-   /* Then any unused temporary:

-    */

-   if (!bit) 

-      bit = _mesa_ffs( ~p->temp_in_use );

-

-   if (!bit) {

-      _mesa_problem(NULL, "%s: out of temporaries\n", __FILE__);

-      exit(1);

-   }

-

-   if ((GLuint) bit > p->program->Base.NumTemporaries)

-      p->program->Base.NumTemporaries = bit;

-

-   p->temp_in_use |= 1<<(bit-1);

-   return make_ureg(PROGRAM_TEMPORARY, (bit-1));

-}

-

-

-/** Mark a temp reg as being no longer allocatable. */

-static void reserve_temp( struct texenv_fragment_program *p, struct ureg r )

-{

-   if (r.file == PROGRAM_TEMPORARY)

-      p->temps_output |= (1 << r.idx);

-}

-

-

-static void release_temps(struct gl_context *ctx, struct texenv_fragment_program *p )

-{

-   GLuint max_temp = ctx->Const.FragmentProgram.MaxTemps;

-

-   /* KW: To support tex_env_crossbar, don't release the registers in

-    * temps_output.

-    */

-   if (max_temp >= sizeof(int) * 8)

-      p->temp_in_use = p->temps_output;

-   else

-      p->temp_in_use = ~((1<<max_temp)-1) | p->temps_output;

-}

-

-

-static struct ureg register_param5( struct texenv_fragment_program *p, 

-				    GLint s0,

-				    GLint s1,

-				    GLint s2,

-				    GLint s3,

-				    GLint s4)

-{

-   gl_state_index tokens[STATE_LENGTH];

-   GLuint idx;

-   tokens[0] = s0;

-   tokens[1] = s1;

-   tokens[2] = s2;

-   tokens[3] = s3;

-   tokens[4] = s4;

-   idx = _mesa_add_state_reference( p->program->Base.Parameters, tokens );

-   return make_ureg(PROGRAM_STATE_VAR, idx);

-}

-

-

-#define register_param1(p,s0)          register_param5(p,s0,0,0,0,0)

-#define register_param2(p,s0,s1)       register_param5(p,s0,s1,0,0,0)

-#define register_param3(p,s0,s1,s2)    register_param5(p,s0,s1,s2,0,0)

-#define register_param4(p,s0,s1,s2,s3) register_param5(p,s0,s1,s2,s3,0)

-

-static GLuint frag_to_vert_attrib( GLuint attrib )

-{

-   switch (attrib) {

-   case FRAG_ATTRIB_COL0: return VERT_ATTRIB_COLOR0;

-   case FRAG_ATTRIB_COL1: return VERT_ATTRIB_COLOR1;

-   default:

-      assert(attrib >= FRAG_ATTRIB_TEX0);

-      assert(attrib <= FRAG_ATTRIB_TEX7);

-      return attrib - FRAG_ATTRIB_TEX0 + VERT_ATTRIB_TEX0;

-   }

-}

-

-

-static struct ureg register_input( struct texenv_fragment_program *p, GLuint input )

-{

-   if (p->state->inputs_available & (1<<input)) {

-      p->program->Base.InputsRead |= (1 << input);

-      return make_ureg(PROGRAM_INPUT, input);

-   }

-   else {

-      GLuint idx = frag_to_vert_attrib( input );

-      return register_param3( p, STATE_INTERNAL, STATE_CURRENT_ATTRIB, idx );

-   }

-}

-

-

-static void emit_arg( struct prog_src_register *reg,

-		      struct ureg ureg )

-{

-   reg->File = ureg.file;

-   reg->Index = ureg.idx;

-   reg->Swizzle = ureg.swz;

-   reg->Negate = ureg.negatebase ? NEGATE_XYZW : NEGATE_NONE;

-   reg->Abs = GL_FALSE;

-}

-

-static void emit_dst( struct prog_dst_register *dst,

-		      struct ureg ureg, GLuint mask )

-{

-   dst->File = ureg.file;

-   dst->Index = ureg.idx;

-   dst->WriteMask = mask;

-   dst->CondMask = COND_TR;  /* always pass cond test */

-   dst->CondSwizzle = SWIZZLE_NOOP;

-}

-

-static struct prog_instruction *

-emit_op(struct texenv_fragment_program *p,

-	enum prog_opcode op,

-	struct ureg dest,

-	GLuint mask,

-	GLboolean saturate,

-	struct ureg src0,

-	struct ureg src1,

-	struct ureg src2 )

-{

-   const GLuint nr = p->program->Base.NumInstructions++;

-   struct prog_instruction *inst = &p->program->Base.Instructions[nr];

-

-   assert(nr < MAX_INSTRUCTIONS);

-

-   _mesa_init_instructions(inst, 1);

-   inst->Opcode = op;

-   

-   emit_arg( &inst->SrcReg[0], src0 );

-   emit_arg( &inst->SrcReg[1], src1 );

-   emit_arg( &inst->SrcReg[2], src2 );

-   

-   inst->SaturateMode = saturate ? SATURATE_ZERO_ONE : SATURATE_OFF;

-

-   emit_dst( &inst->DstReg, dest, mask );

-

-#if 0

-   /* Accounting for indirection tracking:

-    */

-   if (dest.file == PROGRAM_TEMPORARY)

-      p->temps_output |= 1 << dest.idx;

-#endif

-

-   return inst;

-}

-   

-

-static struct ureg emit_arith( struct texenv_fragment_program *p,

-			       enum prog_opcode op,

-			       struct ureg dest,

-			       GLuint mask,

-			       GLboolean saturate,

-			       struct ureg src0,

-			       struct ureg src1,

-			       struct ureg src2 )

-{

-   emit_op(p, op, dest, mask, saturate, src0, src1, src2);

-   

-   /* Accounting for indirection tracking:

-    */

-   if (src0.file == PROGRAM_TEMPORARY)

-      p->alu_temps |= 1 << src0.idx;

-

-   if (!is_undef(src1) && src1.file == PROGRAM_TEMPORARY)

-      p->alu_temps |= 1 << src1.idx;

-

-   if (!is_undef(src2) && src2.file == PROGRAM_TEMPORARY)

-      p->alu_temps |= 1 << src2.idx;

-

-   if (dest.file == PROGRAM_TEMPORARY)

-      p->alu_temps |= 1 << dest.idx;

-       

-   p->program->Base.NumAluInstructions++;

-   return dest;

-}

-

-static struct ureg emit_texld( struct texenv_fragment_program *p,

-			       enum prog_opcode op,

-			       struct ureg dest,

-			       GLuint destmask,

-			       GLuint tex_unit,

-			       GLuint tex_idx,

-                               GLuint tex_shadow,

-			       struct ureg coord )

-{

-   struct prog_instruction *inst = emit_op( p, op, 

-					  dest, destmask, 

-					  GL_FALSE,	/* don't saturate? */

-					  coord, 	/* arg 0? */

-					  undef,

-					  undef);

-   

-   inst->TexSrcTarget = tex_idx;

-   inst->TexSrcUnit = tex_unit;

-   inst->TexShadow = tex_shadow;

-

-   p->program->Base.NumTexInstructions++;

-

-   /* Accounting for indirection tracking:

-    */

-   reserve_temp(p, dest);

-

-#if 0

-   /* Is this a texture indirection?

-    */

-   if ((coord.file == PROGRAM_TEMPORARY &&

-	(p->temps_output & (1<<coord.idx))) ||

-       (dest.file == PROGRAM_TEMPORARY &&

-	(p->alu_temps & (1<<dest.idx)))) {

-      p->program->Base.NumTexIndirections++;

-      p->temps_output = 1<<coord.idx;

-      p->alu_temps = 0;

-      assert(0);		/* KW: texture env crossbar */

-   }

-#endif

-

-   return dest;

-}

-

-

-static struct ureg register_const4f( struct texenv_fragment_program *p, 

-				     GLfloat s0,

-				     GLfloat s1,

-				     GLfloat s2,

-				     GLfloat s3)

-{

-   GLfloat values[4];

-   GLuint idx, swizzle;

-   struct ureg r;

-   values[0] = s0;

-   values[1] = s1;

-   values[2] = s2;

-   values[3] = s3;

-   idx = _mesa_add_unnamed_constant( p->program->Base.Parameters, values, 4,

-                                     &swizzle );

-   r = make_ureg(PROGRAM_CONSTANT, idx);

-   r.swz = swizzle;

-   return r;

-}

-

-#define register_scalar_const(p, s0)    register_const4f(p, s0, s0, s0, s0)

-#define register_const1f(p, s0)         register_const4f(p, s0, 0, 0, 1)

-#define register_const2f(p, s0, s1)     register_const4f(p, s0, s1, 0, 1)

-#define register_const3f(p, s0, s1, s2) register_const4f(p, s0, s1, s2, 1)

-

-

-static struct ureg get_one( struct texenv_fragment_program *p )

-{

-   if (is_undef(p->one)) 

-      p->one = register_scalar_const(p, 1.0);

-   return p->one;

-}

-

-static struct ureg get_half( struct texenv_fragment_program *p )

-{

-   if (is_undef(p->half)) 

-      p->half = register_scalar_const(p, 0.5);

-   return p->half;

-}

-

-static struct ureg get_zero( struct texenv_fragment_program *p )

-{

-   if (is_undef(p->zero)) 

-      p->zero = register_scalar_const(p, 0.0);

-   return p->zero;

-}

-

-

-static void program_error( struct texenv_fragment_program *p, const char *msg )

-{

-   _mesa_problem(NULL, "%s", msg);

-   p->error = 1;

-}

-

-static struct ureg get_source( struct texenv_fragment_program *p, 

-			       GLuint src, GLuint unit )

-{

-   switch (src) {

-   case SRC_TEXTURE: 

-      assert(!is_undef(p->src_texture[unit]));

-      return p->src_texture[unit];

-

-   case SRC_TEXTURE0:

-   case SRC_TEXTURE1:

-   case SRC_TEXTURE2:

-   case SRC_TEXTURE3:

-   case SRC_TEXTURE4:

-   case SRC_TEXTURE5:

-   case SRC_TEXTURE6:

-   case SRC_TEXTURE7: 

-      assert(!is_undef(p->src_texture[src - SRC_TEXTURE0]));

-      return p->src_texture[src - SRC_TEXTURE0];

-

-   case SRC_CONSTANT:

-      return register_param2(p, STATE_TEXENV_COLOR, unit);

-

-   case SRC_PRIMARY_COLOR:

-      return register_input(p, FRAG_ATTRIB_COL0);

-

-   case SRC_ZERO:

-      return get_zero(p);

-

-   case SRC_PREVIOUS:

-      if (is_undef(p->src_previous))

-	 return register_input(p, FRAG_ATTRIB_COL0);

-      else

-	 return p->src_previous;

-

-   default:

-      assert(0);

-      return undef;

-   }

-}

-

-static struct ureg emit_combine_source( struct texenv_fragment_program *p, 

-					GLuint mask,

-					GLuint unit,

-					GLuint source, 

-					GLuint operand )

-{

-   struct ureg arg, src, one;

-

-   src = get_source(p, source, unit);

-

-   switch (operand) {

-   case OPR_ONE_MINUS_SRC_COLOR: 

-      /* Get unused tmp,

-       * Emit tmp = 1.0 - arg.xyzw

-       */

-      arg = get_temp( p );

-      one = get_one( p );

-      return emit_arith( p, OPCODE_SUB, arg, mask, 0, one, src, undef);

-

-   case OPR_SRC_ALPHA: 

-      if (mask == WRITEMASK_W)

-	 return src;

-      else

-	 return swizzle1( src, SWIZZLE_W );

-   case OPR_ONE_MINUS_SRC_ALPHA: 

-      /* Get unused tmp,

-       * Emit tmp = 1.0 - arg.wwww

-       */

-      arg = get_temp(p);

-      one = get_one(p);

-      return emit_arith(p, OPCODE_SUB, arg, mask, 0,

-			one, swizzle1(src, SWIZZLE_W), undef);

-   case OPR_ZERO:

-      return get_zero(p);

-   case OPR_ONE:

-      return get_one(p);

-   case OPR_SRC_COLOR: 

-      return src;

-   default:

-      assert(0);

-      return src;

-   }

-}

-

-/**

- * Check if the RGB and Alpha sources and operands match for the given

- * texture unit's combinder state.  When the RGB and A sources and

- * operands match, we can emit fewer instructions.

- */

-static GLboolean args_match( const struct state_key *key, GLuint unit )

-{

-   GLuint i, numArgs = key->unit[unit].NumArgsRGB;

-

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

-      if (key->unit[unit].OptA[i].Source != key->unit[unit].OptRGB[i].Source) 

-	 return GL_FALSE;

-

-      switch (key->unit[unit].OptA[i].Operand) {

-      case OPR_SRC_ALPHA: 

-	 switch (key->unit[unit].OptRGB[i].Operand) {

-	 case OPR_SRC_COLOR: 

-	 case OPR_SRC_ALPHA: 

-	    break;

-	 default:

-	    return GL_FALSE;

-	 }

-	 break;

-      case OPR_ONE_MINUS_SRC_ALPHA: 

-	 switch (key->unit[unit].OptRGB[i].Operand) {

-	 case OPR_ONE_MINUS_SRC_COLOR: 

-	 case OPR_ONE_MINUS_SRC_ALPHA: 

-	    break;

-	 default:

-	    return GL_FALSE;

-	 }

-	 break;

-      default: 

-	 return GL_FALSE;	/* impossible */

-      }

-   }

-

-   return GL_TRUE;

-}

-

-static struct ureg emit_combine( struct texenv_fragment_program *p,

-				 struct ureg dest,

-				 GLuint mask,

-				 GLboolean saturate,

-				 GLuint unit,

-				 GLuint nr,

-				 GLuint mode,

-				 const struct mode_opt *opt)

-{

-   struct ureg src[MAX_COMBINER_TERMS];

-   struct ureg tmp, half;

-   GLuint i;

-

-   assert(nr <= MAX_COMBINER_TERMS);

-

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

-      src[i] = emit_combine_source( p, mask, unit, opt[i].Source, opt[i].Operand );

-

-   switch (mode) {

-   case MODE_REPLACE: 

-      if (mask == WRITEMASK_XYZW && !saturate)

-	 return src[0];

-      else

-	 return emit_arith( p, OPCODE_MOV, dest, mask, saturate, src[0], undef, undef );

-   case MODE_MODULATE: 

-      return emit_arith( p, OPCODE_MUL, dest, mask, saturate,

-			 src[0], src[1], undef );

-   case MODE_ADD: 

-      return emit_arith( p, OPCODE_ADD, dest, mask, saturate, 

-			 src[0], src[1], undef );

-   case MODE_ADD_SIGNED:

-      /* tmp = arg0 + arg1

-       * result = tmp - .5

-       */

-      half = get_half(p);

-      tmp = get_temp( p );

-      emit_arith( p, OPCODE_ADD, tmp, mask, 0, src[0], src[1], undef );

-      emit_arith( p, OPCODE_SUB, dest, mask, saturate, tmp, half, undef );

-      return dest;

-   case MODE_INTERPOLATE: 

-      /* Arg0 * (Arg2) + Arg1 * (1-Arg2) -- note arguments are reordered:

-       */

-      return emit_arith( p, OPCODE_LRP, dest, mask, saturate, src[2], src[0], src[1] );

-

-   case MODE_SUBTRACT: 

-      return emit_arith( p, OPCODE_SUB, dest, mask, saturate, src[0], src[1], undef );

-

-   case MODE_DOT3_RGBA:

-   case MODE_DOT3_RGBA_EXT: 

-   case MODE_DOT3_RGB_EXT:

-   case MODE_DOT3_RGB: {

-      struct ureg tmp0 = get_temp( p );

-      struct ureg tmp1 = get_temp( p );

-      struct ureg neg1 = register_scalar_const(p, -1);

-      struct ureg two  = register_scalar_const(p, 2);

-

-      /* tmp0 = 2*src0 - 1

-       * tmp1 = 2*src1 - 1

-       *

-       * dst = tmp0 dot3 tmp1 

-       */

-      emit_arith( p, OPCODE_MAD, tmp0, WRITEMASK_XYZW, 0, 

-		  two, src[0], neg1);

-

-      if (memcmp(&src[0], &src[1], sizeof(struct ureg)) == 0)

-	 tmp1 = tmp0;

-      else

-	 emit_arith( p, OPCODE_MAD, tmp1, WRITEMASK_XYZW, 0, 

-		     two, src[1], neg1);

-      emit_arith( p, OPCODE_DP3, dest, mask, saturate, tmp0, tmp1, undef);

-      return dest;

-   }

-   case MODE_MODULATE_ADD_ATI:

-      /* Arg0 * Arg2 + Arg1 */

-      return emit_arith( p, OPCODE_MAD, dest, mask, saturate,

-			 src[0], src[2], src[1] );

-   case MODE_MODULATE_SIGNED_ADD_ATI: {

-      /* Arg0 * Arg2 + Arg1 - 0.5 */

-      struct ureg tmp0 = get_temp(p);

-      half = get_half(p);

-      emit_arith( p, OPCODE_MAD, tmp0, mask, 0, src[0], src[2], src[1] );

-      emit_arith( p, OPCODE_SUB, dest, mask, saturate, tmp0, half, undef );

-      return dest;

-   }

-   case MODE_MODULATE_SUBTRACT_ATI:

-      /* Arg0 * Arg2 - Arg1 */

-      emit_arith( p, OPCODE_MAD, dest, mask, 0, src[0], src[2], negate(src[1]) );

-      return dest;

-   case MODE_ADD_PRODUCTS:

-      /* Arg0 * Arg1 + Arg2 * Arg3 */

-      {

-         struct ureg tmp0 = get_temp(p);

-         emit_arith( p, OPCODE_MUL, tmp0, mask, 0, src[0], src[1], undef );

-         emit_arith( p, OPCODE_MAD, dest, mask, saturate, src[2], src[3], tmp0 );

-      }

-      return dest;

-   case MODE_ADD_PRODUCTS_SIGNED:

-      /* Arg0 * Arg1 + Arg2 * Arg3 - 0.5 */

-      {

-         struct ureg tmp0 = get_temp(p);

-         half = get_half(p);

-         emit_arith( p, OPCODE_MUL, tmp0, mask, 0, src[0], src[1], undef );

-         emit_arith( p, OPCODE_MAD, tmp0, mask, 0, src[2], src[3], tmp0 );

-         emit_arith( p, OPCODE_SUB, dest, mask, saturate, tmp0, half, undef );

-      }

-      return dest;

-   case MODE_BUMP_ENVMAP_ATI:

-      /* special - not handled here */

-      assert(0);

-      return src[0];

-   default: 

-      assert(0);

-      return src[0];

-   }

-}

-

-

-/**

- * Generate instructions for one texture unit's env/combiner mode.

- */

-static struct ureg

-emit_texenv(struct texenv_fragment_program *p, GLuint unit)

-{

-   const struct state_key *key = p->state;

-   GLboolean rgb_saturate, alpha_saturate;

-   GLuint rgb_shift, alpha_shift;

-   struct ureg out, dest;

-

-   if (!key->unit[unit].enabled) {

-      return get_source(p, SRC_PREVIOUS, 0);

-   }

-   if (key->unit[unit].ModeRGB == MODE_BUMP_ENVMAP_ATI) {

-      /* this isn't really a env stage delivering a color and handled elsewhere */

-      return get_source(p, SRC_PREVIOUS, 0);

-   }

-   

-   switch (key->unit[unit].ModeRGB) {

-   case MODE_DOT3_RGB_EXT:

-      alpha_shift = key->unit[unit].ScaleShiftA;

-      rgb_shift = 0;

-      break;

-   case MODE_DOT3_RGBA_EXT:

-      alpha_shift = 0;

-      rgb_shift = 0;

-      break;

-   default:

-      rgb_shift = key->unit[unit].ScaleShiftRGB;

-      alpha_shift = key->unit[unit].ScaleShiftA;

-      break;

-   }

-   

-   /* If we'll do rgb/alpha shifting don't saturate in emit_combine().

-    * We don't want to clamp twice.

-    */

-   if (rgb_shift)

-      rgb_saturate = GL_FALSE;  /* saturate after rgb shift */

-   else if (need_saturate(key->unit[unit].ModeRGB))

-      rgb_saturate = GL_TRUE;

-   else

-      rgb_saturate = GL_FALSE;

-

-   if (alpha_shift)

-      alpha_saturate = GL_FALSE;  /* saturate after alpha shift */

-   else if (need_saturate(key->unit[unit].ModeA))

-      alpha_saturate = GL_TRUE;

-   else

-      alpha_saturate = GL_FALSE;

-

-   /* If this is the very last calculation (and various other conditions

-    * are met), emit directly to the color output register.  Otherwise,

-    * emit to a temporary register.

-    */

-   if (key->separate_specular ||

-       unit != p->last_tex_stage ||

-       alpha_shift ||

-       key->num_draw_buffers != 1 ||

-       rgb_shift)

-      dest = get_temp( p );

-   else

-      dest = make_ureg(PROGRAM_OUTPUT, FRAG_RESULT_COLOR);

-

-   /* Emit the RGB and A combine ops

-    */

-   if (key->unit[unit].ModeRGB == key->unit[unit].ModeA &&

-       args_match(key, unit)) {

-      out = emit_combine( p, dest, WRITEMASK_XYZW, rgb_saturate,

-			  unit,

-			  key->unit[unit].NumArgsRGB,

-			  key->unit[unit].ModeRGB,

-			  key->unit[unit].OptRGB);

-   }

-   else if (key->unit[unit].ModeRGB == MODE_DOT3_RGBA_EXT ||

-	    key->unit[unit].ModeRGB == MODE_DOT3_RGBA) {

-      out = emit_combine( p, dest, WRITEMASK_XYZW, rgb_saturate,

-			  unit,

-			  key->unit[unit].NumArgsRGB,

-			  key->unit[unit].ModeRGB,

-			  key->unit[unit].OptRGB);

-   }

-   else {

-      /* Need to do something to stop from re-emitting identical

-       * argument calculations here:

-       */

-      out = emit_combine( p, dest, WRITEMASK_XYZ, rgb_saturate,

-			  unit,

-			  key->unit[unit].NumArgsRGB,

-			  key->unit[unit].ModeRGB,

-			  key->unit[unit].OptRGB);

-      out = emit_combine( p, dest, WRITEMASK_W, alpha_saturate,

-			  unit,

-			  key->unit[unit].NumArgsA,

-			  key->unit[unit].ModeA,

-			  key->unit[unit].OptA);

-   }

-

-   /* Deal with the final shift:

-    */

-   if (alpha_shift || rgb_shift) {

-      struct ureg shift;

-      GLboolean saturate = GL_TRUE;  /* always saturate at this point */

-

-      if (rgb_shift == alpha_shift) {

-	 shift = register_scalar_const(p, (GLfloat)(1<<rgb_shift));

-      }

-      else {

-	 shift = register_const4f(p, 

-				  (GLfloat)(1<<rgb_shift),

-				  (GLfloat)(1<<rgb_shift),

-				  (GLfloat)(1<<rgb_shift),

-				  (GLfloat)(1<<alpha_shift));

-      }

-      return emit_arith( p, OPCODE_MUL, dest, WRITEMASK_XYZW, 

-			 saturate, out, shift, undef );

-   }

-   else

-      return out;

-}

-

-

-/**

- * Generate instruction for getting a texture source term.

- */

-static void load_texture( struct texenv_fragment_program *p, GLuint unit )

-{

-   if (is_undef(p->src_texture[unit])) {

-      const GLuint texTarget = p->state->unit[unit].source_index;

-      struct ureg texcoord;

-      struct ureg tmp = get_tex_temp( p );

-

-      if (is_undef(p->texcoord_tex[unit])) {

-         texcoord = register_input(p, FRAG_ATTRIB_TEX0+unit);

-      }

-      else {

-         /* might want to reuse this reg for tex output actually */

-         texcoord = p->texcoord_tex[unit];

-      }

-

-      /* TODO: Use D0_MASK_XY where possible.

-       */

-      if (p->state->unit[unit].enabled) {

-         GLboolean shadow = GL_FALSE;

-

-	 if (p->state->unit[unit].shadow) {

-	    p->program->Base.ShadowSamplers |= 1 << unit;

-            shadow = GL_TRUE;

-         }

-

-	 p->src_texture[unit] = emit_texld( p, OPCODE_TXP,

-					    tmp, WRITEMASK_XYZW, 

-					    unit, texTarget, shadow,

-                                            texcoord );

-

-         p->program->Base.SamplersUsed |= (1 << unit);

-         /* This identity mapping should already be in place

-          * (see _mesa_init_program_struct()) but let's be safe.

-          */

-         p->program->Base.SamplerUnits[unit] = unit;

-      }

-      else

-	 p->src_texture[unit] = get_zero(p);

-

-      if (p->state->unit[unit].texture_cyl_wrap) {

-         /* set flag which is checked by Mesa->Gallium program translation */

-         p->program->Base.InputFlags[0] |= PROG_PARAM_BIT_CYL_WRAP;

-      }

-

-   }

-}

-

-static GLboolean load_texenv_source( struct texenv_fragment_program *p, 

-				     GLuint src, GLuint unit )

-{

-   switch (src) {

-   case SRC_TEXTURE:

-      load_texture(p, unit);

-      break;

-

-   case SRC_TEXTURE0:

-   case SRC_TEXTURE1:

-   case SRC_TEXTURE2:

-   case SRC_TEXTURE3:

-   case SRC_TEXTURE4:

-   case SRC_TEXTURE5:

-   case SRC_TEXTURE6:

-   case SRC_TEXTURE7:       

-      load_texture(p, src - SRC_TEXTURE0);

-      break;

-      

-   default:

-      /* not a texture src - do nothing */

-      break;

-   }

- 

-   return GL_TRUE;

-}

-

-

-/**

- * Generate instructions for loading all texture source terms.

- */

-static GLboolean

-load_texunit_sources( struct texenv_fragment_program *p, GLuint unit )

-{

-   const struct state_key *key = p->state;

-   GLuint i;

-

-   for (i = 0; i < key->unit[unit].NumArgsRGB; i++) {

-      load_texenv_source( p, key->unit[unit].OptRGB[i].Source, unit );

-   }

-

-   for (i = 0; i < key->unit[unit].NumArgsA; i++) {

-      load_texenv_source( p, key->unit[unit].OptA[i].Source, unit );

-   }

-

-   return GL_TRUE;

-}

-

-/**

- * Generate instructions for loading bump map textures.

- */

-static GLboolean

-load_texunit_bumpmap( struct texenv_fragment_program *p, GLuint unit )

-{

-   const struct state_key *key = p->state;

-   GLuint bumpedUnitNr = key->unit[unit].OptRGB[1].Source - SRC_TEXTURE0;

-   struct ureg texcDst, bumpMapRes;

-   struct ureg constdudvcolor = register_const4f(p, 0.0, 0.0, 0.0, 1.0);

-   struct ureg texcSrc = register_input(p, FRAG_ATTRIB_TEX0 + bumpedUnitNr);

-   struct ureg rotMat0 = register_param3( p, STATE_INTERNAL, STATE_ROT_MATRIX_0, unit );

-   struct ureg rotMat1 = register_param3( p, STATE_INTERNAL, STATE_ROT_MATRIX_1, unit );

-

-   load_texenv_source( p, unit + SRC_TEXTURE0, unit );

-

-   bumpMapRes = get_source(p, key->unit[unit].OptRGB[0].Source, unit);

-   texcDst = get_tex_temp( p );

-   p->texcoord_tex[bumpedUnitNr] = texcDst;

-

-   /* Apply rot matrix and add coords to be available in next phase.

-    * dest = (Arg0.xxxx * rotMat0 + Arg1) + (Arg0.yyyy * rotMat1)

-    * note only 2 coords are affected the rest are left unchanged (mul by 0)

-    */

-   emit_arith( p, OPCODE_MAD, texcDst, WRITEMASK_XYZW, 0,

-               swizzle1(bumpMapRes, SWIZZLE_X), rotMat0, texcSrc );

-   emit_arith( p, OPCODE_MAD, texcDst, WRITEMASK_XYZW, 0,

-               swizzle1(bumpMapRes, SWIZZLE_Y), rotMat1, texcDst );

-

-   /* Move 0,0,0,1 into bumpmap src if someone (crossbar) is foolish

-    * enough to access this later, should optimize away.

-    */

-   emit_arith( p, OPCODE_MOV, bumpMapRes, WRITEMASK_XYZW, 0,

-               constdudvcolor, undef, undef );

-

-   return GL_TRUE;

-}

-

-/**

- * Generate a new fragment program which implements the context's

- * current texture env/combine mode.

- */

-static void

-create_new_program(struct gl_context *ctx, struct state_key *key,

-                   struct gl_fragment_program *program)

-{

-   struct prog_instruction instBuffer[MAX_INSTRUCTIONS];

-   struct texenv_fragment_program p;

-   GLuint unit;

-   struct ureg cf, out;

-   int i;

-

-   memset(&p, 0, sizeof(p));

-   p.state = key;

-   p.program = program;

-

-   /* During code generation, use locally-allocated instruction buffer,

-    * then alloc dynamic storage below.

-    */

-   p.program->Base.Instructions = instBuffer;

-   p.program->Base.Target = GL_FRAGMENT_PROGRAM_ARB;

-   p.program->Base.String = NULL;

-   p.program->Base.NumTexIndirections = 1; /* is this right? */

-   p.program->Base.NumTexInstructions = 0;

-   p.program->Base.NumAluInstructions = 0;

-   p.program->Base.NumInstructions = 0;

-   p.program->Base.NumTemporaries = 0;

-   p.program->Base.NumParameters = 0;

-   p.program->Base.NumAttributes = 0;

-   p.program->Base.NumAddressRegs = 0;

-   p.program->Base.Parameters = _mesa_new_parameter_list();

-   p.program->Base.InputsRead = 0x0;

-

-   if (key->num_draw_buffers == 1)

-      p.program->Base.OutputsWritten = 1 << FRAG_RESULT_COLOR;

-   else {

-      for (i = 0; i < key->num_draw_buffers; i++)

-	 p.program->Base.OutputsWritten |= (1 << (FRAG_RESULT_DATA0 + i));

-   }

-

-   for (unit = 0; unit < ctx->Const.MaxTextureUnits; unit++) {

-      p.src_texture[unit] = undef;

-      p.texcoord_tex[unit] = undef;

-   }

-

-   p.src_previous = undef;

-   p.half = undef;

-   p.zero = undef;

-   p.one = undef;

-

-   p.last_tex_stage = 0;

-   release_temps(ctx, &p);

-

-   if (key->enabled_units && key->num_draw_buffers) {

-      GLboolean needbumpstage = GL_FALSE;

-

-      /* Zeroth pass - bump map textures first */

-      for (unit = 0; unit < key->nr_enabled_units; unit++)

-	 if (key->unit[unit].enabled &&

-             key->unit[unit].ModeRGB == MODE_BUMP_ENVMAP_ATI) {

-	    needbumpstage = GL_TRUE;

-	    load_texunit_bumpmap( &p, unit );

-	 }

-      if (needbumpstage)

-	 p.program->Base.NumTexIndirections++;

-

-      /* First pass - to support texture_env_crossbar, first identify

-       * all referenced texture sources and emit texld instructions

-       * for each:

-       */

-      for (unit = 0; unit < key->nr_enabled_units; unit++)

-	 if (key->unit[unit].enabled) {

-	    load_texunit_sources( &p, unit );

-	    p.last_tex_stage = unit;

-	 }

-

-      /* Second pass - emit combine instructions to build final color:

-       */

-      for (unit = 0; unit < key->nr_enabled_units; unit++)

-	 if (key->unit[unit].enabled) {

-	    p.src_previous = emit_texenv( &p, unit );

-            reserve_temp(&p, p.src_previous); /* don't re-use this temp reg */

-	    release_temps(ctx, &p);	/* release all temps */

-	 }

-   }

-

-   cf = get_source( &p, SRC_PREVIOUS, 0 );

-

-   for (i = 0; i < key->num_draw_buffers; i++) {

-      if (key->num_draw_buffers == 1)

-	 out = make_ureg( PROGRAM_OUTPUT, FRAG_RESULT_COLOR );

-      else {

-	 out = make_ureg( PROGRAM_OUTPUT, FRAG_RESULT_DATA0 + i );

-      }

-

-      if (key->separate_specular) {

-	 /* Emit specular add.

-	  */

-	 struct ureg s = register_input(&p, FRAG_ATTRIB_COL1);

-	 emit_arith( &p, OPCODE_ADD, out, WRITEMASK_XYZ, 0, cf, s, undef );

-	 emit_arith( &p, OPCODE_MOV, out, WRITEMASK_W, 0, cf, undef, undef );

-      }

-      else if (memcmp(&cf, &out, sizeof(cf)) != 0) {

-	 /* Will wind up in here if no texture enabled or a couple of

-	  * other scenarios (GL_REPLACE for instance).

-	  */

-	 emit_arith( &p, OPCODE_MOV, out, WRITEMASK_XYZW, 0, cf, undef, undef );

-      }

-   }

-   /* Finish up:

-    */

-   emit_arith( &p, OPCODE_END, undef, WRITEMASK_XYZW, 0, undef, undef, undef);

-

-   if (key->fog_enabled) {

-      /* Pull fog mode from struct gl_context, the value in the state key is

-       * a reduced value and not what is expected in FogOption

-       */

-      p.program->FogOption = ctx->Fog.Mode;

-      p.program->Base.InputsRead |= FRAG_BIT_FOGC;

-   }

-   else {

-      p.program->FogOption = GL_NONE;

-   }

-

-   if (p.program->Base.NumTexIndirections > ctx->Const.FragmentProgram.MaxTexIndirections) 

-      program_error(&p, "Exceeded max nr indirect texture lookups");

-

-   if (p.program->Base.NumTexInstructions > ctx->Const.FragmentProgram.MaxTexInstructions)

-      program_error(&p, "Exceeded max TEX instructions");

-

-   if (p.program->Base.NumAluInstructions > ctx->Const.FragmentProgram.MaxAluInstructions)

-      program_error(&p, "Exceeded max ALU instructions");

-

-   ASSERT(p.program->Base.NumInstructions <= MAX_INSTRUCTIONS);

-

-   /* Allocate final instruction array */

-   p.program->Base.Instructions

-      = _mesa_alloc_instructions(p.program->Base.NumInstructions);

-   if (!p.program->Base.Instructions) {

-      _mesa_error(ctx, GL_OUT_OF_MEMORY,

-                  "generating tex env program");

-      return;

-   }

-   _mesa_copy_instructions(p.program->Base.Instructions, instBuffer,

-                           p.program->Base.NumInstructions);

-

-   if (key->num_draw_buffers && p.program->FogOption) {

-      _mesa_append_fog_code(ctx, p.program);

-      p.program->FogOption = GL_NONE;

-   }

-

-

-   /* Notify driver the fragment program has (actually) changed.

-    */

-   if (ctx->Driver.ProgramStringNotify) {

-      GLboolean ok = ctx->Driver.ProgramStringNotify(ctx,

-                                                     GL_FRAGMENT_PROGRAM_ARB, 

-                                                     &p.program->Base);

-      /* Driver should be able to handle any texenv programs as long as

-       * the driver correctly reported max number of texture units correctly,

-       * etc.

-       */

-      ASSERT(ok);

-      (void) ok; /* silence unused var warning */

-   }

-

-   if (DISASSEM) {

-      _mesa_print_program(&p.program->Base);

-      printf("\n");

-   }

-}

-

-

-/**

- * Return a fragment program which implements the current

- * fixed-function texture, fog and color-sum operations.

- */

-struct gl_fragment_program *

-_mesa_get_fixed_func_fragment_program(struct gl_context *ctx)

-{

-   struct gl_fragment_program *prog;

-   struct state_key key;

-   GLuint keySize;

-	

-   keySize = make_state_key(ctx, &key);

-      

-   prog = (struct gl_fragment_program *)

-      _mesa_search_program_cache(ctx->FragmentProgram.Cache,

-                                 &key, keySize);

-

-   if (!prog) {

-      prog = (struct gl_fragment_program *) 

-         ctx->Driver.NewProgram(ctx, GL_FRAGMENT_PROGRAM_ARB, 0);

-

-      create_new_program(ctx, &key, prog);

-

-      _mesa_program_cache_insert(ctx, ctx->FragmentProgram.Cache,

-                                 &key, keySize, &prog->Base);

-   }

-

-   return prog;

-}

diff --git a/mesalib/src/mesa/main/texenvprogram.h b/mesalib/src/mesa/main/texenvprogram.h
index 0895ebacb..dba775feb 100644
--- a/mesalib/src/mesa/main/texenvprogram.h
+++ b/mesalib/src/mesa/main/texenvprogram.h
@@ -29,7 +29,7 @@
 

 struct gl_context;

 

-extern struct gl_fragment_program *

+extern struct gl_shader_program *

 _mesa_get_fixed_func_fragment_program(struct gl_context *ctx);

 

 #endif

diff --git a/mesalib/src/mesa/main/uniforms.c b/mesalib/src/mesa/main/uniforms.c
index eb289722d..523b8e1a9 100644
--- a/mesalib/src/mesa/main/uniforms.c
+++ b/mesalib/src/mesa/main/uniforms.c
@@ -1,1691 +1,1707 @@
-/*
- * Mesa 3-D graphics library
- *
- * Copyright (C) 2004-2008  Brian Paul   All Rights Reserved.
- * Copyright (C) 2009-2010  VMware, Inc.  All Rights Reserved.
- * Copyright © 2010 Intel Corporation
- *
- * 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 uniforms.c
- * Functions related to GLSL uniform variables.
- * \author Brian Paul
- */
-
-/**
- * XXX things to do:
- * 1. Check that the right error code is generated for all _mesa_error() calls.
- * 2. Insert FLUSH_VERTICES calls in various places
- */
-
-
-#include "main/glheader.h"
-#include "main/context.h"
-#include "main/dispatch.h"
-#include "main/mfeatures.h"
-#include "main/mtypes.h"
-#include "main/shaderapi.h"
-#include "main/shaderobj.h"
-#include "main/uniforms.h"
-#include "program/prog_parameter.h"
-#include "program/prog_statevars.h"
-#include "program/prog_uniform.h"
-#include "program/prog_instruction.h"
-
-
-static GLenum
-base_uniform_type(GLenum type)
-{
-   switch (type) {
-#if 0 /* not needed, for now */
-   case GL_BOOL:
-   case GL_BOOL_VEC2:
-   case GL_BOOL_VEC3:
-   case GL_BOOL_VEC4:
-      return GL_BOOL;
-#endif
-   case GL_FLOAT:
-   case GL_FLOAT_VEC2:
-   case GL_FLOAT_VEC3:
-   case GL_FLOAT_VEC4:
-      return GL_FLOAT;
-   case GL_UNSIGNED_INT:
-   case GL_UNSIGNED_INT_VEC2:
-   case GL_UNSIGNED_INT_VEC3:
-   case GL_UNSIGNED_INT_VEC4:
-      return GL_UNSIGNED_INT;
-   case GL_INT:
-   case GL_INT_VEC2:
-   case GL_INT_VEC3:
-   case GL_INT_VEC4:
-      return GL_INT;
-   default:
-      _mesa_problem(NULL, "Invalid type in base_uniform_type()");
-      return GL_FLOAT;
-   }
-}
-
-static struct gl_builtin_uniform_element gl_DepthRange_elements[] = {
-   {"near", {STATE_DEPTH_RANGE, 0, 0}, SWIZZLE_XXXX},
-   {"far", {STATE_DEPTH_RANGE, 0, 0}, SWIZZLE_YYYY},
-   {"diff", {STATE_DEPTH_RANGE, 0, 0}, SWIZZLE_ZZZZ},
-};
-
-static struct gl_builtin_uniform_element gl_ClipPlane_elements[] = {
-   {NULL, {STATE_CLIPPLANE, 0, 0}, SWIZZLE_XYZW}
-};
-
-static struct gl_builtin_uniform_element gl_Point_elements[] = {
-   {"size", {STATE_POINT_SIZE}, SWIZZLE_XXXX},
-   {"sizeMin", {STATE_POINT_SIZE}, SWIZZLE_YYYY},
-   {"sizeMax", {STATE_POINT_SIZE}, SWIZZLE_ZZZZ},
-   {"fadeThresholdSize", {STATE_POINT_SIZE}, SWIZZLE_WWWW},
-   {"distanceConstantAttenuation", {STATE_POINT_ATTENUATION}, SWIZZLE_XXXX},
-   {"distanceLinearAttenuation", {STATE_POINT_ATTENUATION}, SWIZZLE_YYYY},
-   {"distanceQuadraticAttenuation", {STATE_POINT_ATTENUATION}, SWIZZLE_ZZZZ},
-};
-
-static struct gl_builtin_uniform_element gl_FrontMaterial_elements[] = {
-   {"emission", {STATE_MATERIAL, 0, STATE_EMISSION}, SWIZZLE_XYZW},
-   {"ambient", {STATE_MATERIAL, 0, STATE_AMBIENT}, SWIZZLE_XYZW},
-   {"diffuse", {STATE_MATERIAL, 0, STATE_DIFFUSE}, SWIZZLE_XYZW},
-   {"specular", {STATE_MATERIAL, 0, STATE_SPECULAR}, SWIZZLE_XYZW},
-   {"shininess", {STATE_MATERIAL, 0, STATE_SHININESS}, SWIZZLE_XXXX},
-};
-
-static struct gl_builtin_uniform_element gl_BackMaterial_elements[] = {
-   {"emission", {STATE_MATERIAL, 1, STATE_EMISSION}, SWIZZLE_XYZW},
-   {"ambient", {STATE_MATERIAL, 1, STATE_AMBIENT}, SWIZZLE_XYZW},
-   {"diffuse", {STATE_MATERIAL, 1, STATE_DIFFUSE}, SWIZZLE_XYZW},
-   {"specular", {STATE_MATERIAL, 1, STATE_SPECULAR}, SWIZZLE_XYZW},
-   {"shininess", {STATE_MATERIAL, 1, STATE_SHININESS}, SWIZZLE_XXXX},
-};
-
-static struct gl_builtin_uniform_element gl_LightSource_elements[] = {
-   {"ambient", {STATE_LIGHT, 0, STATE_AMBIENT}, SWIZZLE_XYZW},
-   {"diffuse", {STATE_LIGHT, 0, STATE_DIFFUSE}, SWIZZLE_XYZW},
-   {"specular", {STATE_LIGHT, 0, STATE_SPECULAR}, SWIZZLE_XYZW},
-   {"position", {STATE_LIGHT, 0, STATE_POSITION}, SWIZZLE_XYZW},
-   {"halfVector", {STATE_LIGHT, 0, STATE_HALF_VECTOR}, SWIZZLE_XYZW},
-   {"spotDirection", {STATE_LIGHT, 0, STATE_SPOT_DIRECTION},
-    MAKE_SWIZZLE4(SWIZZLE_X,
-		  SWIZZLE_Y,
-		  SWIZZLE_Z,
-		  SWIZZLE_Z)},
-   {"spotCosCutoff", {STATE_LIGHT, 0, STATE_SPOT_DIRECTION}, SWIZZLE_WWWW},
-   {"spotCutoff", {STATE_LIGHT, 0, STATE_SPOT_CUTOFF}, SWIZZLE_XXXX},
-   {"spotExponent", {STATE_LIGHT, 0, STATE_ATTENUATION}, SWIZZLE_WWWW},
-   {"constantAttenuation", {STATE_LIGHT, 0, STATE_ATTENUATION}, SWIZZLE_XXXX},
-   {"linearAttenuation", {STATE_LIGHT, 0, STATE_ATTENUATION}, SWIZZLE_YYYY},
-   {"quadraticAttenuation", {STATE_LIGHT, 0, STATE_ATTENUATION}, SWIZZLE_ZZZZ},
-};
-
-static struct gl_builtin_uniform_element gl_LightModel_elements[] = {
-   {"ambient", {STATE_LIGHTMODEL_AMBIENT, 0}, SWIZZLE_XYZW},
-};
-
-static struct gl_builtin_uniform_element gl_FrontLightModelProduct_elements[] = {
-   {"sceneColor", {STATE_LIGHTMODEL_SCENECOLOR, 0}, SWIZZLE_XYZW},
-};
-
-static struct gl_builtin_uniform_element gl_BackLightModelProduct_elements[] = {
-   {"sceneColor", {STATE_LIGHTMODEL_SCENECOLOR, 1}, SWIZZLE_XYZW},
-};
-
-static struct gl_builtin_uniform_element gl_FrontLightProduct_elements[] = {
-   {"ambient", {STATE_LIGHTPROD, 0, 0, STATE_AMBIENT}, SWIZZLE_XYZW},
-   {"diffuse", {STATE_LIGHTPROD, 0, 0, STATE_DIFFUSE}, SWIZZLE_XYZW},
-   {"specular", {STATE_LIGHTPROD, 0, 0, STATE_SPECULAR}, SWIZZLE_XYZW},
-};
-
-static struct gl_builtin_uniform_element gl_BackLightProduct_elements[] = {
-   {"ambient", {STATE_LIGHTPROD, 0, 1, STATE_AMBIENT}, SWIZZLE_XYZW},
-   {"diffuse", {STATE_LIGHTPROD, 0, 1, STATE_DIFFUSE}, SWIZZLE_XYZW},
-   {"specular", {STATE_LIGHTPROD, 0, 1, STATE_SPECULAR}, SWIZZLE_XYZW},
-};
-
-static struct gl_builtin_uniform_element gl_TextureEnvColor_elements[] = {
-   {NULL, {STATE_TEXENV_COLOR, 0}, SWIZZLE_XYZW},
-};
-
-static struct gl_builtin_uniform_element gl_EyePlaneS_elements[] = {
-   {NULL, {STATE_TEXGEN, 0, STATE_TEXGEN_EYE_S}, SWIZZLE_XYZW},
-};
-
-static struct gl_builtin_uniform_element gl_EyePlaneT_elements[] = {
-   {NULL, {STATE_TEXGEN, 0, STATE_TEXGEN_EYE_T}, SWIZZLE_XYZW},
-};
-
-static struct gl_builtin_uniform_element gl_EyePlaneR_elements[] = {
-   {NULL, {STATE_TEXGEN, 0, STATE_TEXGEN_EYE_R}, SWIZZLE_XYZW},
-};
-
-static struct gl_builtin_uniform_element gl_EyePlaneQ_elements[] = {
-   {NULL, {STATE_TEXGEN, 0, STATE_TEXGEN_EYE_Q}, SWIZZLE_XYZW},
-};
-
-static struct gl_builtin_uniform_element gl_ObjectPlaneS_elements[] = {
-   {NULL, {STATE_TEXGEN, 0, STATE_TEXGEN_OBJECT_S}, SWIZZLE_XYZW},
-};
-
-static struct gl_builtin_uniform_element gl_ObjectPlaneT_elements[] = {
-   {NULL, {STATE_TEXGEN, 0, STATE_TEXGEN_OBJECT_T}, SWIZZLE_XYZW},
-};
-
-static struct gl_builtin_uniform_element gl_ObjectPlaneR_elements[] = {
-   {NULL, {STATE_TEXGEN, 0, STATE_TEXGEN_OBJECT_R}, SWIZZLE_XYZW},
-};
-
-static struct gl_builtin_uniform_element gl_ObjectPlaneQ_elements[] = {
-   {NULL, {STATE_TEXGEN, 0, STATE_TEXGEN_OBJECT_Q}, SWIZZLE_XYZW},
-};
-
-static struct gl_builtin_uniform_element gl_Fog_elements[] = {
-   {"color", {STATE_FOG_COLOR}, SWIZZLE_XYZW},
-   {"density", {STATE_FOG_PARAMS}, SWIZZLE_XXXX},
-   {"start", {STATE_FOG_PARAMS}, SWIZZLE_YYYY},
-   {"end", {STATE_FOG_PARAMS}, SWIZZLE_ZZZZ},
-   {"scale", {STATE_FOG_PARAMS}, SWIZZLE_WWWW},
-};
-
-static struct gl_builtin_uniform_element gl_NormalScale_elements[] = {
-   {NULL, {STATE_NORMAL_SCALE}, SWIZZLE_XXXX},
-};
-
-#define MATRIX(name, statevar, modifier)				\
-   static struct gl_builtin_uniform_element name ## _elements[] = {	\
-      { NULL, { statevar, 0, 0, 0, modifier}, SWIZZLE_XYZW },		\
-      { NULL, { statevar, 0, 1, 1, modifier}, SWIZZLE_XYZW },		\
-      { NULL, { statevar, 0, 2, 2, modifier}, SWIZZLE_XYZW },		\
-      { NULL, { statevar, 0, 3, 3, modifier}, SWIZZLE_XYZW },		\
-   }
-
-MATRIX(gl_ModelViewMatrix,
-       STATE_MODELVIEW_MATRIX, STATE_MATRIX_TRANSPOSE);
-MATRIX(gl_ModelViewMatrixInverse,
-       STATE_MODELVIEW_MATRIX, STATE_MATRIX_INVTRANS);
-MATRIX(gl_ModelViewMatrixTranspose,
-       STATE_MODELVIEW_MATRIX, 0);
-MATRIX(gl_ModelViewMatrixInverseTranspose,
-       STATE_MODELVIEW_MATRIX, STATE_MATRIX_INVERSE);
-
-MATRIX(gl_ProjectionMatrix,
-       STATE_PROJECTION_MATRIX, STATE_MATRIX_TRANSPOSE);
-MATRIX(gl_ProjectionMatrixInverse,
-       STATE_PROJECTION_MATRIX, STATE_MATRIX_INVTRANS);
-MATRIX(gl_ProjectionMatrixTranspose,
-       STATE_PROJECTION_MATRIX, 0);
-MATRIX(gl_ProjectionMatrixInverseTranspose,
-       STATE_PROJECTION_MATRIX, STATE_MATRIX_INVERSE);
-
-MATRIX(gl_ModelViewProjectionMatrix,
-       STATE_MVP_MATRIX, STATE_MATRIX_TRANSPOSE);
-MATRIX(gl_ModelViewProjectionMatrixInverse,
-       STATE_MVP_MATRIX, STATE_MATRIX_INVTRANS);
-MATRIX(gl_ModelViewProjectionMatrixTranspose,
-       STATE_MVP_MATRIX, 0);
-MATRIX(gl_ModelViewProjectionMatrixInverseTranspose,
-       STATE_MVP_MATRIX, STATE_MATRIX_INVERSE);
-
-MATRIX(gl_TextureMatrix,
-       STATE_TEXTURE_MATRIX, STATE_MATRIX_TRANSPOSE);
-MATRIX(gl_TextureMatrixInverse,
-       STATE_TEXTURE_MATRIX, STATE_MATRIX_INVTRANS);
-MATRIX(gl_TextureMatrixTranspose,
-       STATE_TEXTURE_MATRIX, 0);
-MATRIX(gl_TextureMatrixInverseTranspose,
-       STATE_TEXTURE_MATRIX, STATE_MATRIX_INVERSE);
-
-static struct gl_builtin_uniform_element gl_NormalMatrix_elements[] = {
-   { NULL, { STATE_MODELVIEW_MATRIX, 0, 0, 0, STATE_MATRIX_INVERSE},
-     SWIZZLE_XYZW },
-   { NULL, { STATE_MODELVIEW_MATRIX, 0, 1, 1, STATE_MATRIX_INVERSE},
-     SWIZZLE_XYZW },
-   { NULL, { STATE_MODELVIEW_MATRIX, 0, 2, 2, STATE_MATRIX_INVERSE},
-     SWIZZLE_XYZW },
-};
-
-#undef MATRIX
-
-#define STATEVAR(name) {#name, name ## _elements, Elements(name ## _elements)}
-
-const struct gl_builtin_uniform_desc _mesa_builtin_uniform_desc[] = {
-   STATEVAR(gl_DepthRange),
-   STATEVAR(gl_ClipPlane),
-   STATEVAR(gl_Point),
-   STATEVAR(gl_FrontMaterial),
-   STATEVAR(gl_BackMaterial),
-   STATEVAR(gl_LightSource),
-   STATEVAR(gl_LightModel),
-   STATEVAR(gl_FrontLightModelProduct),
-   STATEVAR(gl_BackLightModelProduct),
-   STATEVAR(gl_FrontLightProduct),
-   STATEVAR(gl_BackLightProduct),
-   STATEVAR(gl_TextureEnvColor),
-   STATEVAR(gl_EyePlaneS),
-   STATEVAR(gl_EyePlaneT),
-   STATEVAR(gl_EyePlaneR),
-   STATEVAR(gl_EyePlaneQ),
-   STATEVAR(gl_ObjectPlaneS),
-   STATEVAR(gl_ObjectPlaneT),
-   STATEVAR(gl_ObjectPlaneR),
-   STATEVAR(gl_ObjectPlaneQ),
-   STATEVAR(gl_Fog),
-
-   STATEVAR(gl_ModelViewMatrix),
-   STATEVAR(gl_ModelViewMatrixInverse),
-   STATEVAR(gl_ModelViewMatrixTranspose),
-   STATEVAR(gl_ModelViewMatrixInverseTranspose),
-
-   STATEVAR(gl_ProjectionMatrix),
-   STATEVAR(gl_ProjectionMatrixInverse),
-   STATEVAR(gl_ProjectionMatrixTranspose),
-   STATEVAR(gl_ProjectionMatrixInverseTranspose),
-
-   STATEVAR(gl_ModelViewProjectionMatrix),
-   STATEVAR(gl_ModelViewProjectionMatrixInverse),
-   STATEVAR(gl_ModelViewProjectionMatrixTranspose),
-   STATEVAR(gl_ModelViewProjectionMatrixInverseTranspose),
-
-   STATEVAR(gl_TextureMatrix),
-   STATEVAR(gl_TextureMatrixInverse),
-   STATEVAR(gl_TextureMatrixTranspose),
-   STATEVAR(gl_TextureMatrixInverseTranspose),
-
-   STATEVAR(gl_NormalMatrix),
-   STATEVAR(gl_NormalScale),
-
-   {NULL, NULL, 0}
-};
-
-static GLboolean
-is_boolean_type(GLenum type)
-{
-   switch (type) {
-   case GL_BOOL:
-   case GL_BOOL_VEC2:
-   case GL_BOOL_VEC3:
-   case GL_BOOL_VEC4:
-      return GL_TRUE;
-   default:
-      return GL_FALSE;
-   }
-}
-
-
-static GLboolean
-is_sampler_type(GLenum type)
-{
-   switch (type) {
-   case GL_SAMPLER_1D:
-   case GL_SAMPLER_2D:
-   case GL_SAMPLER_3D:
-   case GL_SAMPLER_CUBE:
-   case GL_SAMPLER_1D_SHADOW:
-   case GL_SAMPLER_2D_SHADOW:
-   case GL_SAMPLER_2D_RECT_ARB:
-   case GL_SAMPLER_2D_RECT_SHADOW_ARB:
-   case GL_SAMPLER_1D_ARRAY_EXT:
-   case GL_SAMPLER_2D_ARRAY_EXT:
-   case GL_SAMPLER_1D_ARRAY_SHADOW_EXT:
-   case GL_SAMPLER_2D_ARRAY_SHADOW_EXT:
-      return GL_TRUE;
-   default:
-      return GL_FALSE;
-   }
-}
-
-
-static struct gl_program_parameter *
-get_uniform_parameter(const struct gl_shader_program *shProg, GLuint index)
-{
-   const struct gl_program *prog = NULL;
-   GLint progPos;
-
-   progPos = shProg->Uniforms->Uniforms[index].VertPos;
-   if (progPos >= 0) {
-      prog = &shProg->VertexProgram->Base;
-   }
-   else {
-      progPos = shProg->Uniforms->Uniforms[index].FragPos;
-      if (progPos >= 0) {
-         prog = &shProg->FragmentProgram->Base;
-      } else {
-         progPos = shProg->Uniforms->Uniforms[index].GeomPos;
-         if (progPos >= 0) {
-            prog = &shProg->GeometryProgram->Base;
-         }
-      }
-   }
-
-   if (!prog || progPos < 0)
-      return NULL; /* should never happen */
-
-   return &prog->Parameters->Parameters[progPos];
-}
-
-
-/**
- * Called by glGetActiveUniform().
- */
-static void
-_mesa_get_active_uniform(struct gl_context *ctx, GLuint program, GLuint index,
-                         GLsizei maxLength, GLsizei *length, GLint *size,
-                         GLenum *type, GLchar *nameOut)
-{
-   const struct gl_shader_program *shProg;
-   const struct gl_program *prog = NULL;
-   const struct gl_program_parameter *param;
-   GLint progPos;
-
-   shProg = _mesa_lookup_shader_program_err(ctx, program, "glGetActiveUniform");
-   if (!shProg)
-      return;
-
-   if (!shProg->Uniforms || index >= shProg->Uniforms->NumUniforms) {
-      _mesa_error(ctx, GL_INVALID_VALUE, "glGetActiveUniform(index)");
-      return;
-   }
-
-   progPos = shProg->Uniforms->Uniforms[index].VertPos;
-   if (progPos >= 0) {
-      prog = &shProg->VertexProgram->Base;
-   }
-   else {
-      progPos = shProg->Uniforms->Uniforms[index].FragPos;
-      if (progPos >= 0) {
-         prog = &shProg->FragmentProgram->Base;
-      } else {
-         progPos = shProg->Uniforms->Uniforms[index].GeomPos;
-         if (progPos >= 0) {
-            prog = &shProg->GeometryProgram->Base;
-         }
-      }
-   }
-
-   if (!prog || progPos < 0)
-      return; /* should never happen */
-
-   ASSERT(progPos < prog->Parameters->NumParameters);
-   param = &prog->Parameters->Parameters[progPos];
-
-   if (nameOut) {
-      _mesa_copy_string(nameOut, maxLength, length, param->Name);
-   }
-
-   if (size) {
-      GLint typeSize = _mesa_sizeof_glsl_type(param->DataType);
-      if ((GLint) param->Size > typeSize) {
-         /* This is an array.
-          * Array elements are placed on vector[4] boundaries so they're
-          * a multiple of four floats.  We round typeSize up to next multiple
-          * of four to get the right size below.
-          */
-         typeSize = (typeSize + 3) & ~3;
-      }
-      /* Note that the returned size is in units of the <type>, not bytes */
-      *size = param->Size / typeSize;
-   }
-
-   if (type) {
-      *type = param->DataType;
-   }
-}
-
-
-static unsigned
-get_vector_elements(GLenum type)
-{
-   switch (type) {
-   case GL_FLOAT:
-   case GL_INT:
-   case GL_BOOL:
-   case GL_UNSIGNED_INT:
-   default: /* Catch all the various sampler types. */
-      return 1;
-
-   case GL_FLOAT_VEC2:
-   case GL_INT_VEC2:
-   case GL_BOOL_VEC2:
-   case GL_UNSIGNED_INT_VEC2:
-      return 2;
-
-   case GL_FLOAT_VEC3:
-   case GL_INT_VEC3:
-   case GL_BOOL_VEC3:
-   case GL_UNSIGNED_INT_VEC3:
-      return 3;
-
-   case GL_FLOAT_VEC4:
-   case GL_INT_VEC4:
-   case GL_BOOL_VEC4:
-   case GL_UNSIGNED_INT_VEC4:
-      return 4;
-   }
-}
-
-static void
-get_matrix_dims(GLenum type, GLint *rows, GLint *cols)
-{
-   switch (type) {
-   case GL_FLOAT_MAT2:
-      *rows = *cols = 2;
-      break;
-   case GL_FLOAT_MAT2x3:
-      *rows = 3;
-      *cols = 2;
-      break;
-   case GL_FLOAT_MAT2x4:
-      *rows = 4;
-      *cols = 2;
-      break;
-   case GL_FLOAT_MAT3:
-      *rows = 3;
-      *cols = 3;
-      break;
-   case GL_FLOAT_MAT3x2:
-      *rows = 2;
-      *cols = 3;
-      break;
-   case GL_FLOAT_MAT3x4:
-      *rows = 4;
-      *cols = 3;
-      break;
-   case GL_FLOAT_MAT4:
-      *rows = 4;
-      *cols = 4;
-      break;
-   case GL_FLOAT_MAT4x2:
-      *rows = 2;
-      *cols = 4;
-      break;
-   case GL_FLOAT_MAT4x3:
-      *rows = 3;
-      *cols = 4;
-      break;
-   default:
-      *rows = *cols = 0;
-   }
-}
-
-
-/**
- * Determine the number of rows and columns occupied by a uniform
- * according to its datatype.  For non-matrix types (such as GL_FLOAT_VEC4),
- * the number of rows = 1 and cols = number of elements in the vector.
- */
-static void
-get_uniform_rows_cols(const struct gl_program_parameter *p,
-                      GLint *rows, GLint *cols)
-{
-   get_matrix_dims(p->DataType, rows, cols);
-   if (*rows == 0 && *cols == 0) {
-      /* not a matrix type, probably a float or vector */
-      *rows = 1;
-      *cols = get_vector_elements(p->DataType);
-   }
-}
-
-
-/**
- * Helper for get_uniform[fi]v() functions.
- * Given a shader program name and uniform location, return a pointer
- * to the shader program and return the program parameter position.
- */
-static void
-lookup_uniform_parameter(struct gl_context *ctx, GLuint program, GLint location,
-                         struct gl_program **progOut, GLint *paramPosOut)
-{
-   struct gl_shader_program *shProg
-      = _mesa_lookup_shader_program_err(ctx, program, "glGetUniform[if]v");
-   struct gl_program *prog = NULL;
-   GLint progPos = -1;
-
-   /* if shProg is NULL, we'll have already recorded an error */
-
-   if (shProg) {
-      if (!shProg->Uniforms ||
-          location < 0 ||
-          location >= (GLint) shProg->Uniforms->NumUniforms) {
-         _mesa_error(ctx, GL_INVALID_OPERATION,  "glGetUniformfv(location)");
-      }
-      else {
-         /* OK, find the gl_program and program parameter location */
-         progPos = shProg->Uniforms->Uniforms[location].VertPos;
-         if (progPos >= 0) {
-            prog = &shProg->VertexProgram->Base;
-         }
-         else {
-            progPos = shProg->Uniforms->Uniforms[location].FragPos;
-            if (progPos >= 0) {
-               prog = &shProg->FragmentProgram->Base;
-            } else {
-               progPos = shProg->Uniforms->Uniforms[location].GeomPos;
-               if (progPos >= 0) {
-                  prog = &shProg->GeometryProgram->Base;
-               }
-            }
-         }
-      }
-   }
-
-   *progOut = prog;
-   *paramPosOut = progPos;
-}
-
-
-/**
- * GLGL uniform arrays and structs require special handling.
- *
- * The GL_ARB_shader_objects spec says that if you use
- * glGetUniformLocation to get the location of an array, you CANNOT
- * access other elements of the array by adding an offset to the
- * returned location.  For example, you must call
- * glGetUniformLocation("foo[16]") if you want to set the 16th element
- * of the array with glUniform().
- *
- * HOWEVER, some other OpenGL drivers allow accessing array elements
- * by adding an offset to the returned array location.  And some apps
- * seem to depend on that behaviour.
- *
- * Mesa's gl_uniform_list doesn't directly support this since each
- * entry in the list describes one uniform variable, not one uniform
- * element.  We could insert dummy entries in the list for each array
- * element after [0] but that causes complications elsewhere.
- *
- * We solve this problem by encoding two values in the location that's
- * returned by glGetUniformLocation():
- *  a) index into gl_uniform_list::Uniforms[] for the uniform
- *  b) an array/field offset (0 for simple types)
- *
- * These two values are encoded in the high and low halves of a GLint.
- * By putting the uniform number in the high part and the offset in the
- * low part, we can support the unofficial ability to index into arrays
- * by adding offsets to the location value.
- */
-static void
-merge_location_offset(GLint *location, GLint offset)
-{
-   *location = (*location << 16) | offset;
-}
-
-
-/**
- * Separate the uniform location and parameter offset.  See above.
- */
-static void
-split_location_offset(GLint *location, GLint *offset)
-{
-   *offset = *location & 0xffff;
-   *location = *location >> 16;
-}
-
-
-
-/**
- * Called via glGetUniformfv().
- */
-static void
-_mesa_get_uniformfv(struct gl_context *ctx, GLuint program, GLint location,
-                    GLfloat *params)
-{
-   struct gl_program *prog;
-   GLint paramPos;
-   GLint offset;
-
-   split_location_offset(&location, &offset);
-
-   lookup_uniform_parameter(ctx, program, location, &prog, &paramPos);
-
-   if (prog) {
-      const struct gl_program_parameter *p =
-         &prog->Parameters->Parameters[paramPos];
-      GLint rows, cols, i, j, k;
-
-      get_uniform_rows_cols(p, &rows, &cols);
-
-      k = 0;
-      for (i = 0; i < rows; i++) {
-	 const int base = paramPos + offset + i;
-
-         for (j = 0; j < cols; j++ ) {
-            params[k++] = prog->Parameters->ParameterValues[base][j];
-         }
-      }
-   }
-}
-
-
-/**
- * Called via glGetUniformiv().
- * \sa _mesa_get_uniformfv, only difference is a cast.
- */
-static void
-_mesa_get_uniformiv(struct gl_context *ctx, GLuint program, GLint location,
-                    GLint *params)
-{
-   struct gl_program *prog;
-   GLint paramPos;
-   GLint offset;
-
-   split_location_offset(&location, &offset);
-
-   lookup_uniform_parameter(ctx, program, location, &prog, &paramPos);
-
-   if (prog) {
-      const struct gl_program_parameter *p =
-         &prog->Parameters->Parameters[paramPos];
-      GLint rows, cols, i, j, k;
-
-      get_uniform_rows_cols(p, &rows, &cols);
-
-      k = 0;
-      for (i = 0; i < rows; i++) {
-	 const int base = paramPos + offset + i;
-
-         for (j = 0; j < cols; j++ ) {
-            params[k++] = (GLint) prog->Parameters->ParameterValues[base][j];
-         }
-      }
-   }
-}
-
-
-/**
- * Called via glGetUniformuiv().
- * New in GL_EXT_gpu_shader4, OpenGL 3.0
- * \sa _mesa_get_uniformfv, only difference is a cast.
- */
-static void
-_mesa_get_uniformuiv(struct gl_context *ctx, GLuint program, GLint location,
-                     GLuint *params)
-{
-   struct gl_program *prog;
-   GLint paramPos;
-   GLint offset;
-
-   split_location_offset(&location, &offset);
-
-   lookup_uniform_parameter(ctx, program, location, &prog, &paramPos);
-
-   if (prog) {
-      const struct gl_program_parameter *p =
-         &prog->Parameters->Parameters[paramPos];
-      GLint rows, cols, i, j, k;
-
-      get_uniform_rows_cols(p, &rows, &cols);
-
-      k = 0;
-      for (i = 0; i < rows; i++) {
-	 const int base = paramPos + offset + i;
-
-         for (j = 0; j < cols; j++ ) {
-            params[k++] = (GLuint) prog->Parameters->ParameterValues[base][j];
-         }
-      }
-   }
-}
-
-
-/**
- * Called via glGetUniformLocation().
- *
- * The return value will encode two values, the uniform location and an
- * offset (used for arrays, structs).
- */
-GLint
-_mesa_get_uniform_location(struct gl_context *ctx, struct gl_shader_program *shProg,
-			   const GLchar *name)
-{
-   GLint offset = 0, location = -1;
-
-   if (shProg->LinkStatus == GL_FALSE) {
-      _mesa_error(ctx, GL_INVALID_OPERATION, "glGetUniformfv(program)");
-      return -1;
-   }
-
-   /* XXX we should return -1 if the uniform was declared, but not
-    * actually used.
-    */
-
-   /* XXX we need to be able to parse uniform names for structs and arrays
-    * such as:
-    *   mymatrix[1]
-    *   mystruct.field1
-    */
-
-   {
-      /* handle 1-dimension arrays here... */
-      char *c = strchr(name, '[');
-      if (c) {
-         /* truncate name at [ */
-         const GLint len = c - name;
-         GLchar *newName = malloc(len + 1);
-         if (!newName)
-            return -1; /* out of mem */
-         memcpy(newName, name, len);
-         newName[len] = 0;
-
-         location = _mesa_lookup_uniform(shProg->Uniforms, newName);
-         if (location >= 0) {
-            const GLint element = atoi(c + 1);
-            if (element > 0) {
-               /* get type of the uniform array element */
-               struct gl_program_parameter *p;
-               p = get_uniform_parameter(shProg, location);
-               if (p) {
-                  GLint rows, cols;
-                  get_matrix_dims(p->DataType, &rows, &cols);
-                  if (rows < 1)
-                     rows = 1;
-                  offset = element * rows;
-               }
-            }
-         }
-
-         free(newName);
-      }
-   }
-
-   if (location < 0) {
-      location = _mesa_lookup_uniform(shProg->Uniforms, name);
-   }
-
-   if (location >= 0) {
-      merge_location_offset(&location, offset);
-   }
-
-   return location;
-}
-
-
-
-/**
- * Update the vertex/fragment program's TexturesUsed array.
- *
- * This needs to be called after glUniform(set sampler var) is called.
- * A call to glUniform(samplerVar, value) causes a sampler to point to a
- * particular texture unit.  We know the sampler's texture target
- * (1D/2D/3D/etc) from compile time but the sampler's texture unit is
- * set by glUniform() calls.
- *
- * So, scan the program->SamplerUnits[] and program->SamplerTargets[]
- * information to update the prog->TexturesUsed[] values.
- * Each value of TexturesUsed[unit] is one of zero, TEXTURE_1D_INDEX,
- * TEXTURE_2D_INDEX, TEXTURE_3D_INDEX, etc.
- * We'll use that info for state validation before rendering.
- */
-void
-_mesa_update_shader_textures_used(struct gl_program *prog)
-{
-   GLuint s;
-
-   memset(prog->TexturesUsed, 0, sizeof(prog->TexturesUsed));
-
-   for (s = 0; s < MAX_SAMPLERS; s++) {
-      if (prog->SamplersUsed & (1 << s)) {
-         GLuint unit = prog->SamplerUnits[s];
-         GLuint tgt = prog->SamplerTargets[s];
-         assert(unit < MAX_TEXTURE_IMAGE_UNITS);
-         assert(tgt < NUM_TEXTURE_TARGETS);
-         prog->TexturesUsed[unit] |= (1 << tgt);
-      }
-   }
-}
-
-
-/**
- * Check if the type given by userType is allowed to set a uniform of the
- * target type.  Generally, equivalence is required, but setting Boolean
- * uniforms can be done with glUniformiv or glUniformfv.
- */
-static GLboolean
-compatible_types(GLenum userType, GLenum targetType)
-{
-   if (userType == targetType)
-      return GL_TRUE;
-
-   if (targetType == GL_BOOL && (userType == GL_FLOAT ||
-                                 userType == GL_UNSIGNED_INT ||
-                                 userType == GL_INT))
-      return GL_TRUE;
-
-   if (targetType == GL_BOOL_VEC2 && (userType == GL_FLOAT_VEC2 ||
-                                      userType == GL_UNSIGNED_INT_VEC2 ||
-                                      userType == GL_INT_VEC2))
-      return GL_TRUE;
-
-   if (targetType == GL_BOOL_VEC3 && (userType == GL_FLOAT_VEC3 ||
-                                      userType == GL_UNSIGNED_INT_VEC3 ||
-                                      userType == GL_INT_VEC3))
-      return GL_TRUE;
-
-   if (targetType == GL_BOOL_VEC4 && (userType == GL_FLOAT_VEC4 ||
-                                      userType == GL_UNSIGNED_INT_VEC4 ||
-                                      userType == GL_INT_VEC4))
-      return GL_TRUE;
-
-   if (is_sampler_type(targetType) && userType == GL_INT)
-      return GL_TRUE;
-
-   return GL_FALSE;
-}
-
-
-/**
- * Set the value of a program's uniform variable.
- * \param program  the program whose uniform to update
- * \param index  the index of the program parameter for the uniform
- * \param offset  additional parameter slot offset (for arrays)
- * \param type  the incoming datatype of 'values'
- * \param count  the number of uniforms to set
- * \param elems  number of elements per uniform (1, 2, 3 or 4)
- * \param values  the new values, of datatype 'type'
- */
-static void
-set_program_uniform(struct gl_context *ctx, struct gl_program *program,
-                    GLint index, GLint offset,
-                    GLenum type, GLsizei count, GLint elems,
-                    const void *values)
-{
-   const struct gl_program_parameter *param =
-      &program->Parameters->Parameters[index];
-
-   assert(offset >= 0);
-   assert(elems >= 1);
-   assert(elems <= 4);
-
-   if (!compatible_types(type, param->DataType)) {
-      _mesa_error(ctx, GL_INVALID_OPERATION, "glUniform(type mismatch)");
-      return;
-   }
-
-   if (index + offset > (GLint) program->Parameters->Size) {
-      /* out of bounds! */
-      return;
-   }
-
-   if (param->Type == PROGRAM_SAMPLER) {
-      /* This controls which texture unit which is used by a sampler */
-      GLboolean changed = GL_FALSE;
-      GLint i;
-
-      /* this should have been caught by the compatible_types() check */
-      ASSERT(type == GL_INT);
-
-      /* loop over number of samplers to change */
-      for (i = 0; i < count; i++) {
-         GLuint sampler =
-            (GLuint) program->Parameters->ParameterValues[index + offset + i][0];
-         GLuint texUnit = ((GLuint *) values)[i];
-
-         /* check that the sampler (tex unit index) is legal */
-         if (texUnit >= ctx->Const.MaxTextureImageUnits) {
-            _mesa_error(ctx, GL_INVALID_VALUE,
-                        "glUniform1(invalid sampler/tex unit index for '%s')",
-                        param->Name);
-            return;
-         }
-
-         /* This maps a sampler to a texture unit: */
-         if (sampler < MAX_SAMPLERS) {
-#if 0
-            printf("Set program %p sampler %d '%s' to unit %u\n",
-		   program, sampler, param->Name, texUnit);
-#endif
-            if (program->SamplerUnits[sampler] != texUnit) {
-               program->SamplerUnits[sampler] = texUnit;
-               changed = GL_TRUE;
-            }
-         }
-      }
-
-      if (changed) {
-         /* When a sampler's value changes it usually requires rewriting
-          * a GPU program's TEX instructions since there may not be a
-          * sampler->texture lookup table.  We signal this with the
-          * ProgramStringNotify() callback.
-          */
-         FLUSH_VERTICES(ctx, _NEW_TEXTURE | _NEW_PROGRAM);
-         _mesa_update_shader_textures_used(program);
-         /* Do we need to care about the return value here?
-          * This should not be the first time the driver was notified of
-          * this program.
-          */
-         (void) ctx->Driver.ProgramStringNotify(ctx, program->Target, program);
-      }
-   }
-   else {
-      /* ordinary uniform variable */
-      const GLboolean isUniformBool = is_boolean_type(param->DataType);
-      const GLenum basicType = base_uniform_type(type);
-      const GLint slots = (param->Size + 3) / 4;
-      const GLint typeSize = _mesa_sizeof_glsl_type(param->DataType);
-      GLsizei k, i;
-
-      if ((GLint) param->Size > typeSize) {
-         /* an array */
-         /* we'll ignore extra data below */
-      }
-      else {
-         /* non-array: count must be at most one; count == 0 is handled by the loop below */
-         if (count > 1) {
-            _mesa_error(ctx, GL_INVALID_OPERATION,
-                        "glUniform(uniform '%s' is not an array)",
-                        param->Name);
-            return;
-         }
-      }
-
-      /* loop over number of array elements */
-      for (k = 0; k < count; k++) {
-         GLfloat *uniformVal;
-
-         if (offset + k >= slots) {
-            /* Extra array data is ignored */
-            break;
-         }
-
-         /* uniformVal (the destination) is always float[4] */
-         uniformVal = program->Parameters->ParameterValues[index + offset + k];
-
-         if (basicType == GL_INT) {
-            /* convert user's ints to floats */
-            const GLint *iValues = ((const GLint *) values) + k * elems;
-            for (i = 0; i < elems; i++) {
-               uniformVal[i] = (GLfloat) iValues[i];
-            }
-         }
-         else if (basicType == GL_UNSIGNED_INT) {
-            /* convert user's uints to floats */
-            const GLuint *iValues = ((const GLuint *) values) + k * elems;
-            for (i = 0; i < elems; i++) {
-               uniformVal[i] = (GLfloat) iValues[i];
-            }
-         }
-         else {
-            const GLfloat *fValues = ((const GLfloat *) values) + k * elems;
-            assert(basicType == GL_FLOAT);
-            for (i = 0; i < elems; i++) {
-               uniformVal[i] = fValues[i];
-            }
-         }
-
-         /* if the uniform is bool-valued, convert to 1.0 or 0.0 */
-         if (isUniformBool) {
-            for (i = 0; i < elems; i++) {
-               uniformVal[i] = uniformVal[i] ? 1.0f : 0.0f;
-            }
-         }
-      }
-   }
-}
-
-
-/**
- * Called via glUniform*() functions.
- */
-void
-_mesa_uniform(struct gl_context *ctx, struct gl_shader_program *shProg,
-	      GLint location, GLsizei count,
-              const GLvoid *values, GLenum type)
-{
-   struct gl_uniform *uniform;
-   GLint elems, offset;
-
-   if (!shProg || !shProg->LinkStatus) {
-      _mesa_error(ctx, GL_INVALID_OPERATION, "glUniform(program not linked)");
-      return;
-   }
-
-   if (location == -1)
-      return;   /* The standard specifies this as a no-op */
-
-   if (location < -1) {
-      _mesa_error(ctx, GL_INVALID_OPERATION, "glUniform(location=%d)",
-                  location);
-      return;
-   }
-
-   split_location_offset(&location, &offset);
-
-   if (location < 0 || location >= (GLint) shProg->Uniforms->NumUniforms) {
-      _mesa_error(ctx, GL_INVALID_VALUE, "glUniform(location=%d)", location);
-      return;
-   }
-
-   if (count < 0) {
-      _mesa_error(ctx, GL_INVALID_VALUE, "glUniform(count < 0)");
-      return;
-   }
-
-   elems = _mesa_sizeof_glsl_type(type);
-
-   FLUSH_VERTICES(ctx, _NEW_PROGRAM_CONSTANTS);
-
-   uniform = &shProg->Uniforms->Uniforms[location];
-
-   if (ctx->Shader.Flags & GLSL_UNIFORMS) {
-      const GLenum basicType = base_uniform_type(type);
-      GLint i;
-      printf("Mesa: set program %u uniform %s (loc %d) to: ",
-	     shProg->Name, uniform->Name, location);
-      if (basicType == GL_INT) {
-         const GLint *v = (const GLint *) values;
-         for (i = 0; i < count * elems; i++) {
-            printf("%d ", v[i]);
-         }
-      }
-      else if (basicType == GL_UNSIGNED_INT) {
-         const GLuint *v = (const GLuint *) values;
-         for (i = 0; i < count * elems; i++) {
-            printf("%u ", v[i]);
-         }
-      }
-      else {
-         const GLfloat *v = (const GLfloat *) values;
-         assert(basicType == GL_FLOAT);
-         for (i = 0; i < count * elems; i++) {
-            printf("%g ", v[i]);
-         }
-      }
-      printf("\n");
-   }
-
-   /* A uniform var may be used by both a vertex shader and a fragment
-    * shader.  We may need to update one or both shader's uniform here:
-    */
-   if (shProg->VertexProgram) {
-      /* convert uniform location to program parameter index */
-      GLint index = uniform->VertPos;
-      if (index >= 0) {
-         set_program_uniform(ctx, &shProg->VertexProgram->Base,
-                             index, offset, type, count, elems, values);
-      }
-   }
-
-   if (shProg->FragmentProgram) {
-      /* convert uniform location to program parameter index */
-      GLint index = uniform->FragPos;
-      if (index >= 0) {
-         set_program_uniform(ctx, &shProg->FragmentProgram->Base,
-                             index, offset, type, count, elems, values);
-      }
-   }
-
-   if (shProg->GeometryProgram) {
-      /* convert uniform location to program parameter index */
-      GLint index = uniform->GeomPos;
-      if (index >= 0) {
-         set_program_uniform(ctx, &shProg->GeometryProgram->Base,
-                             index, offset, type, count, elems, values);
-      }
-   }
-
-   uniform->Initialized = GL_TRUE;
-}
-
-
-/**
- * Set a matrix-valued program parameter.
- */
-static void
-set_program_uniform_matrix(struct gl_context *ctx, struct gl_program *program,
-                           GLuint index, GLuint offset,
-                           GLuint count, GLuint rows, GLuint cols,
-                           GLboolean transpose, const GLfloat *values)
-{
-   GLuint mat, row, col;
-   GLuint src = 0;
-   const struct gl_program_parameter * param = &program->Parameters->Parameters[index];
-   const GLuint slots = (param->Size + 3) / 4;
-   const GLint typeSize = _mesa_sizeof_glsl_type(param->DataType);
-   GLint nr, nc;
-
-   /* check that the number of rows, columns is correct */
-   get_matrix_dims(param->DataType, &nr, &nc);
-   if (rows != nr || cols != nc) {
-      _mesa_error(ctx, GL_INVALID_OPERATION,
-                  "glUniformMatrix(matrix size mismatch)");
-      return;
-   }
-
-   if ((GLint) param->Size <= typeSize) {
-      /* non-array: count must be at most one; count == 0 is handled by the loop below */
-      if (count > 1) {
-         _mesa_error(ctx, GL_INVALID_OPERATION,
-                     "glUniformMatrix(uniform is not an array)");
-         return;
-      }
-   }
-
-   /*
-    * Note: the _columns_ of a matrix are stored in program registers, not
-    * the rows.  So, the loops below look a little funny.
-    * XXX could optimize this a bit...
-    */
-
-   /* loop over matrices */
-   for (mat = 0; mat < count; mat++) {
-
-      /* each matrix: */
-      for (col = 0; col < cols; col++) {
-         GLfloat *v;
-         if (offset >= slots) {
-            /* Ignore writes beyond the end of (the used part of) an array */
-            return;
-         }
-         v = program->Parameters->ParameterValues[index + offset];
-         for (row = 0; row < rows; row++) {
-            if (transpose) {
-               v[row] = values[src + row * cols + col];
-            }
-            else {
-               v[row] = values[src + col * rows + row];
-            }
-         }
-
-         offset++;
-      }
-
-      src += rows * cols;  /* next matrix */
-   }
-}
-
-
-/**
- * Called by glUniformMatrix*() functions.
- * Note: cols=2, rows=4  ==>  array[2] of vec4
- */
-void
-_mesa_uniform_matrix(struct gl_context *ctx, struct gl_shader_program *shProg,
-		     GLint cols, GLint rows,
-                     GLint location, GLsizei count,
-                     GLboolean transpose, const GLfloat *values)
-{
-   struct gl_uniform *uniform;
-   GLint offset;
-
-   if (!shProg || !shProg->LinkStatus) {
-      _mesa_error(ctx, GL_INVALID_OPERATION,
-         "glUniformMatrix(program not linked)");
-      return;
-   }
-
-   if (location == -1)
-      return;   /* The standard specifies this as a no-op */
-
-   if (location < -1) {
-      _mesa_error(ctx, GL_INVALID_OPERATION, "glUniformMatrix(location)");
-      return;
-   }
-
-   split_location_offset(&location, &offset);
-
-   if (location < 0 || location >= (GLint) shProg->Uniforms->NumUniforms) {
-      _mesa_error(ctx, GL_INVALID_VALUE, "glUniformMatrix(location)");
-      return;
-   }
-   if (values == NULL) {
-      _mesa_error(ctx, GL_INVALID_VALUE, "glUniformMatrix");
-      return;
-   }
-
-   FLUSH_VERTICES(ctx, _NEW_PROGRAM_CONSTANTS);
-
-   uniform = &shProg->Uniforms->Uniforms[location];
-
-   if (shProg->VertexProgram) {
-      /* convert uniform location to program parameter index */
-      GLint index = uniform->VertPos;
-      if (index >= 0) {
-         set_program_uniform_matrix(ctx, &shProg->VertexProgram->Base,
-                                    index, offset,
-                                    count, rows, cols, transpose, values);
-      }
-   }
-
-   if (shProg->FragmentProgram) {
-      /* convert uniform location to program parameter index */
-      GLint index = uniform->FragPos;
-      if (index >= 0) {
-         set_program_uniform_matrix(ctx, &shProg->FragmentProgram->Base,
-                                    index, offset,
-                                    count, rows, cols, transpose, values);
-      }
-   }
-
-   if (shProg->GeometryProgram) {
-      /* convert uniform location to program parameter index */
-      GLint index = uniform->GeomPos;
-      if (index >= 0) {
-         set_program_uniform_matrix(ctx, &shProg->GeometryProgram->Base,
-                                    index, offset,
-                                    count, rows, cols, transpose, values);
-      }
-   }
-
-   uniform->Initialized = GL_TRUE;
-}
-
-
-void GLAPIENTRY
-_mesa_Uniform1fARB(GLint location, GLfloat v0)
-{
-   GET_CURRENT_CONTEXT(ctx);
-   _mesa_uniform(ctx, ctx->Shader.ActiveProgram, location, 1, &v0, GL_FLOAT);
-}
-
-void GLAPIENTRY
-_mesa_Uniform2fARB(GLint location, GLfloat v0, GLfloat v1)
-{
-   GET_CURRENT_CONTEXT(ctx);
-   GLfloat v[2];
-   v[0] = v0;
-   v[1] = v1;
-   _mesa_uniform(ctx, ctx->Shader.ActiveProgram, location, 1, v, GL_FLOAT_VEC2);
-}
-
-void GLAPIENTRY
-_mesa_Uniform3fARB(GLint location, GLfloat v0, GLfloat v1, GLfloat v2)
-{
-   GET_CURRENT_CONTEXT(ctx);
-   GLfloat v[3];
-   v[0] = v0;
-   v[1] = v1;
-   v[2] = v2;
-   _mesa_uniform(ctx, ctx->Shader.ActiveProgram, location, 1, v, GL_FLOAT_VEC3);
-}
-
-void GLAPIENTRY
-_mesa_Uniform4fARB(GLint location, GLfloat v0, GLfloat v1, GLfloat v2,
-                   GLfloat v3)
-{
-   GET_CURRENT_CONTEXT(ctx);
-   GLfloat v[4];
-   v[0] = v0;
-   v[1] = v1;
-   v[2] = v2;
-   v[3] = v3;
-   _mesa_uniform(ctx, ctx->Shader.ActiveProgram, location, 1, v, GL_FLOAT_VEC4);
-}
-
-void GLAPIENTRY
-_mesa_Uniform1iARB(GLint location, GLint v0)
-{
-   GET_CURRENT_CONTEXT(ctx);
-   _mesa_uniform(ctx, ctx->Shader.ActiveProgram, location, 1, &v0, GL_INT);
-}
-
-void GLAPIENTRY
-_mesa_Uniform2iARB(GLint location, GLint v0, GLint v1)
-{
-   GET_CURRENT_CONTEXT(ctx);
-   GLint v[2];
-   v[0] = v0;
-   v[1] = v1;
-   _mesa_uniform(ctx, ctx->Shader.ActiveProgram, location, 1, v, GL_INT_VEC2);
-}
-
-void GLAPIENTRY
-_mesa_Uniform3iARB(GLint location, GLint v0, GLint v1, GLint v2)
-{
-   GET_CURRENT_CONTEXT(ctx);
-   GLint v[3];
-   v[0] = v0;
-   v[1] = v1;
-   v[2] = v2;
-   _mesa_uniform(ctx, ctx->Shader.ActiveProgram, location, 1, v, GL_INT_VEC3);
-}
-
-void GLAPIENTRY
-_mesa_Uniform4iARB(GLint location, GLint v0, GLint v1, GLint v2, GLint v3)
-{
-   GET_CURRENT_CONTEXT(ctx);
-   GLint v[4];
-   v[0] = v0;
-   v[1] = v1;
-   v[2] = v2;
-   v[3] = v3;
-   _mesa_uniform(ctx, ctx->Shader.ActiveProgram, location, 1, v, GL_INT_VEC4);
-}
-
-void GLAPIENTRY
-_mesa_Uniform1fvARB(GLint location, GLsizei count, const GLfloat * value)
-{
-   GET_CURRENT_CONTEXT(ctx);
-   _mesa_uniform(ctx, ctx->Shader.ActiveProgram, location, count, value, GL_FLOAT);
-}
-
-void GLAPIENTRY
-_mesa_Uniform2fvARB(GLint location, GLsizei count, const GLfloat * value)
-{
-   GET_CURRENT_CONTEXT(ctx);
-   _mesa_uniform(ctx, ctx->Shader.ActiveProgram, location, count, value, GL_FLOAT_VEC2);
-}
-
-void GLAPIENTRY
-_mesa_Uniform3fvARB(GLint location, GLsizei count, const GLfloat * value)
-{
-   GET_CURRENT_CONTEXT(ctx);
-   _mesa_uniform(ctx, ctx->Shader.ActiveProgram, location, count, value, GL_FLOAT_VEC3);
-}
-
-void GLAPIENTRY
-_mesa_Uniform4fvARB(GLint location, GLsizei count, const GLfloat * value)
-{
-   GET_CURRENT_CONTEXT(ctx);
-   _mesa_uniform(ctx, ctx->Shader.ActiveProgram, location, count, value, GL_FLOAT_VEC4);
-}
-
-void GLAPIENTRY
-_mesa_Uniform1ivARB(GLint location, GLsizei count, const GLint * value)
-{
-   GET_CURRENT_CONTEXT(ctx);
-   _mesa_uniform(ctx, ctx->Shader.ActiveProgram, location, count, value, GL_INT);
-}
-
-void GLAPIENTRY
-_mesa_Uniform2ivARB(GLint location, GLsizei count, const GLint * value)
-{
-   GET_CURRENT_CONTEXT(ctx);
-   _mesa_uniform(ctx, ctx->Shader.ActiveProgram, location, count, value, GL_INT_VEC2);
-}
-
-void GLAPIENTRY
-_mesa_Uniform3ivARB(GLint location, GLsizei count, const GLint * value)
-{
-   GET_CURRENT_CONTEXT(ctx);
-   _mesa_uniform(ctx, ctx->Shader.ActiveProgram, location, count, value, GL_INT_VEC3);
-}
-
-void GLAPIENTRY
-_mesa_Uniform4ivARB(GLint location, GLsizei count, const GLint * value)
-{
-   GET_CURRENT_CONTEXT(ctx);
-   _mesa_uniform(ctx, ctx->Shader.ActiveProgram, location, count, value, GL_INT_VEC4);
-}
-
-
-/** OpenGL 3.0 GLuint-valued functions **/
-void GLAPIENTRY
-_mesa_Uniform1ui(GLint location, GLuint v0)
-{
-   GET_CURRENT_CONTEXT(ctx);
-   _mesa_uniform(ctx, ctx->Shader.ActiveProgram, location, 1, &v0, GL_UNSIGNED_INT);
-}
-
-void GLAPIENTRY
-_mesa_Uniform2ui(GLint location, GLuint v0, GLuint v1)
-{
-   GET_CURRENT_CONTEXT(ctx);
-   GLuint v[2];
-   v[0] = v0;
-   v[1] = v1;
-   _mesa_uniform(ctx, ctx->Shader.ActiveProgram, location, 1, v, GL_UNSIGNED_INT_VEC2);
-}
-
-void GLAPIENTRY
-_mesa_Uniform3ui(GLint location, GLuint v0, GLuint v1, GLuint v2)
-{
-   GET_CURRENT_CONTEXT(ctx);
-   GLuint v[3];
-   v[0] = v0;
-   v[1] = v1;
-   v[2] = v2;
-   _mesa_uniform(ctx, ctx->Shader.ActiveProgram, location, 1, v, GL_UNSIGNED_INT_VEC3);
-}
-
-void GLAPIENTRY
-_mesa_Uniform4ui(GLint location, GLuint v0, GLuint v1, GLuint v2, GLuint v3)
-{
-   GET_CURRENT_CONTEXT(ctx);
-   GLuint v[4];
-   v[0] = v0;
-   v[1] = v1;
-   v[2] = v2;
-   v[3] = v3;
-   _mesa_uniform(ctx, ctx->Shader.ActiveProgram, location, 1, v, GL_UNSIGNED_INT_VEC4);
-}
-
-void GLAPIENTRY
-_mesa_Uniform1uiv(GLint location, GLsizei count, const GLuint *value)
-{
-   GET_CURRENT_CONTEXT(ctx);
-   _mesa_uniform(ctx, ctx->Shader.ActiveProgram, location, count, value, GL_UNSIGNED_INT);
-}
-
-void GLAPIENTRY
-_mesa_Uniform2uiv(GLint location, GLsizei count, const GLuint *value)
-{
-   GET_CURRENT_CONTEXT(ctx);
-   _mesa_uniform(ctx, ctx->Shader.ActiveProgram, location, count, value, GL_UNSIGNED_INT_VEC2);
-}
-
-void GLAPIENTRY
-_mesa_Uniform3uiv(GLint location, GLsizei count, const GLuint *value)
-{
-   GET_CURRENT_CONTEXT(ctx);
-   _mesa_uniform(ctx, ctx->Shader.ActiveProgram, location, count, value, GL_UNSIGNED_INT_VEC3);
-}
-
-void GLAPIENTRY
-_mesa_Uniform4uiv(GLint location, GLsizei count, const GLuint *value)
-{
-   GET_CURRENT_CONTEXT(ctx);
-   _mesa_uniform(ctx, ctx->Shader.ActiveProgram, location, count, value, GL_UNSIGNED_INT_VEC4);
-}
-
-
-
-void GLAPIENTRY
-_mesa_UniformMatrix2fvARB(GLint location, GLsizei count, GLboolean transpose,
-                          const GLfloat * value)
-{
-   GET_CURRENT_CONTEXT(ctx);
-   _mesa_uniform_matrix(ctx, ctx->Shader.ActiveProgram,
-			2, 2, location, count, transpose, value);
-}
-
-void GLAPIENTRY
-_mesa_UniformMatrix3fvARB(GLint location, GLsizei count, GLboolean transpose,
-                          const GLfloat * value)
-{
-   GET_CURRENT_CONTEXT(ctx);
-   _mesa_uniform_matrix(ctx, ctx->Shader.ActiveProgram,
-			3, 3, location, count, transpose, value);
-}
-
-void GLAPIENTRY
-_mesa_UniformMatrix4fvARB(GLint location, GLsizei count, GLboolean transpose,
-                          const GLfloat * value)
-{
-   GET_CURRENT_CONTEXT(ctx);
-   _mesa_uniform_matrix(ctx, ctx->Shader.ActiveProgram,
-			4, 4, location, count, transpose, value);
-}
-
-
-/**
- * Non-square UniformMatrix are OpenGL 2.1
- */
-void GLAPIENTRY
-_mesa_UniformMatrix2x3fv(GLint location, GLsizei count, GLboolean transpose,
-                         const GLfloat *value)
-{
-   GET_CURRENT_CONTEXT(ctx);
-   _mesa_uniform_matrix(ctx, ctx->Shader.ActiveProgram,
-			2, 3, location, count, transpose, value);
-}
-
-void GLAPIENTRY
-_mesa_UniformMatrix3x2fv(GLint location, GLsizei count, GLboolean transpose,
-                         const GLfloat *value)
-{
-   GET_CURRENT_CONTEXT(ctx);
-   _mesa_uniform_matrix(ctx, ctx->Shader.ActiveProgram,
-			3, 2, location, count, transpose, value);
-}
-
-void GLAPIENTRY
-_mesa_UniformMatrix2x4fv(GLint location, GLsizei count, GLboolean transpose,
-                         const GLfloat *value)
-{
-   GET_CURRENT_CONTEXT(ctx);
-   _mesa_uniform_matrix(ctx, ctx->Shader.ActiveProgram,
-			2, 4, location, count, transpose, value);
-}
-
-void GLAPIENTRY
-_mesa_UniformMatrix4x2fv(GLint location, GLsizei count, GLboolean transpose,
-                         const GLfloat *value)
-{
-   GET_CURRENT_CONTEXT(ctx);
-   _mesa_uniform_matrix(ctx, ctx->Shader.ActiveProgram,
-			4, 2, location, count, transpose, value);
-}
-
-void GLAPIENTRY
-_mesa_UniformMatrix3x4fv(GLint location, GLsizei count, GLboolean transpose,
-                         const GLfloat *value)
-{
-   GET_CURRENT_CONTEXT(ctx);
-   _mesa_uniform_matrix(ctx, ctx->Shader.ActiveProgram,
-			3, 4, location, count, transpose, value);
-}
-
-void GLAPIENTRY
-_mesa_UniformMatrix4x3fv(GLint location, GLsizei count, GLboolean transpose,
-                         const GLfloat *value)
-{
-   GET_CURRENT_CONTEXT(ctx);
-   _mesa_uniform_matrix(ctx, ctx->Shader.ActiveProgram,
-			4, 3, location, count, transpose, value);
-}
-
-
-void GLAPIENTRY
-_mesa_GetUniformfvARB(GLhandleARB program, GLint location, GLfloat *params)
-{
-   GET_CURRENT_CONTEXT(ctx);
-   _mesa_get_uniformfv(ctx, program, location, params);
-}
-
-
-void GLAPIENTRY
-_mesa_GetUniformivARB(GLhandleARB program, GLint location, GLint *params)
-{
-   GET_CURRENT_CONTEXT(ctx);
-   _mesa_get_uniformiv(ctx, program, location, params);
-}
-
-
-/* GL3 */
-void GLAPIENTRY
-_mesa_GetUniformuiv(GLhandleARB program, GLint location, GLuint *params)
-{
-   GET_CURRENT_CONTEXT(ctx);
-   _mesa_get_uniformuiv(ctx, program, location, params);
-}
-
-
-
-GLint GLAPIENTRY
-_mesa_GetUniformLocationARB(GLhandleARB programObj, const GLcharARB *name)
-{
-   struct gl_shader_program *shProg;
-
-   GET_CURRENT_CONTEXT(ctx);
-
-   shProg = _mesa_lookup_shader_program_err(ctx, programObj,
-					    "glGetUniformLocation");
-   if (!shProg)
-      return -1;
-
-   return _mesa_get_uniform_location(ctx, shProg, name);
-}
-
-
-void GLAPIENTRY
-_mesa_GetActiveUniformARB(GLhandleARB program, GLuint index,
-                          GLsizei maxLength, GLsizei * length, GLint * size,
-                          GLenum * type, GLcharARB * name)
-{
-   GET_CURRENT_CONTEXT(ctx);
-   _mesa_get_active_uniform(ctx, program, index, maxLength, length, size,
-                            type, name);
-}
-
-
-/**
- * Plug in shader uniform-related functions into API dispatch table.
- */
-void
-_mesa_init_shader_uniform_dispatch(struct _glapi_table *exec)
-{
-#if FEATURE_GL
-   SET_Uniform1fARB(exec, _mesa_Uniform1fARB);
-   SET_Uniform2fARB(exec, _mesa_Uniform2fARB);
-   SET_Uniform3fARB(exec, _mesa_Uniform3fARB);
-   SET_Uniform4fARB(exec, _mesa_Uniform4fARB);
-   SET_Uniform1iARB(exec, _mesa_Uniform1iARB);
-   SET_Uniform2iARB(exec, _mesa_Uniform2iARB);
-   SET_Uniform3iARB(exec, _mesa_Uniform3iARB);
-   SET_Uniform4iARB(exec, _mesa_Uniform4iARB);
-   SET_Uniform1fvARB(exec, _mesa_Uniform1fvARB);
-   SET_Uniform2fvARB(exec, _mesa_Uniform2fvARB);
-   SET_Uniform3fvARB(exec, _mesa_Uniform3fvARB);
-   SET_Uniform4fvARB(exec, _mesa_Uniform4fvARB);
-   SET_Uniform1ivARB(exec, _mesa_Uniform1ivARB);
-   SET_Uniform2ivARB(exec, _mesa_Uniform2ivARB);
-   SET_Uniform3ivARB(exec, _mesa_Uniform3ivARB);
-   SET_Uniform4ivARB(exec, _mesa_Uniform4ivARB);
-   SET_UniformMatrix2fvARB(exec, _mesa_UniformMatrix2fvARB);
-   SET_UniformMatrix3fvARB(exec, _mesa_UniformMatrix3fvARB);
-   SET_UniformMatrix4fvARB(exec, _mesa_UniformMatrix4fvARB);
-
-   SET_GetActiveUniformARB(exec, _mesa_GetActiveUniformARB);
-   SET_GetUniformLocationARB(exec, _mesa_GetUniformLocationARB);
-   SET_GetUniformfvARB(exec, _mesa_GetUniformfvARB);
-   SET_GetUniformivARB(exec, _mesa_GetUniformivARB);
-
-   /* OpenGL 2.1 */
-   SET_UniformMatrix2x3fv(exec, _mesa_UniformMatrix2x3fv);
-   SET_UniformMatrix3x2fv(exec, _mesa_UniformMatrix3x2fv);
-   SET_UniformMatrix2x4fv(exec, _mesa_UniformMatrix2x4fv);
-   SET_UniformMatrix4x2fv(exec, _mesa_UniformMatrix4x2fv);
-   SET_UniformMatrix3x4fv(exec, _mesa_UniformMatrix3x4fv);
-   SET_UniformMatrix4x3fv(exec, _mesa_UniformMatrix4x3fv);
-
-   /* OpenGL 3.0 */
-   /* XXX finish dispatch */
-   SET_Uniform1uiEXT(exec, _mesa_Uniform1ui);
-   SET_Uniform2uiEXT(exec, _mesa_Uniform2ui);
-   SET_Uniform3uiEXT(exec, _mesa_Uniform3ui);
-   SET_Uniform4uiEXT(exec, _mesa_Uniform4ui);
-   SET_Uniform1uivEXT(exec, _mesa_Uniform1uiv);
-   SET_Uniform2uivEXT(exec, _mesa_Uniform2uiv);
-   SET_Uniform3uivEXT(exec, _mesa_Uniform3uiv);
-   SET_Uniform4uivEXT(exec, _mesa_Uniform4uiv);
-   SET_GetUniformuivEXT(exec, _mesa_GetUniformuiv);
-
-
-#endif /* FEATURE_GL */
-}
+/*

+ * Mesa 3-D graphics library

+ *

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

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

+ * Copyright © 2010 Intel Corporation

+ *

+ * 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 uniforms.c

+ * Functions related to GLSL uniform variables.

+ * \author Brian Paul

+ */

+

+/**

+ * XXX things to do:

+ * 1. Check that the right error code is generated for all _mesa_error() calls.

+ * 2. Insert FLUSH_VERTICES calls in various places

+ */

+

+

+#include "main/glheader.h"

+#include "main/context.h"

+#include "main/dispatch.h"

+#include "main/mfeatures.h"

+#include "main/mtypes.h"

+#include "main/shaderapi.h"

+#include "main/shaderobj.h"

+#include "main/uniforms.h"

+#include "program/prog_parameter.h"

+#include "program/prog_statevars.h"

+#include "program/prog_uniform.h"

+#include "program/prog_instruction.h"

+

+

+static GLenum

+base_uniform_type(GLenum type)

+{

+   switch (type) {

+#if 0 /* not needed, for now */

+   case GL_BOOL:

+   case GL_BOOL_VEC2:

+   case GL_BOOL_VEC3:

+   case GL_BOOL_VEC4:

+      return GL_BOOL;

+#endif

+   case GL_FLOAT:

+   case GL_FLOAT_VEC2:

+   case GL_FLOAT_VEC3:

+   case GL_FLOAT_VEC4:

+      return GL_FLOAT;

+   case GL_UNSIGNED_INT:

+   case GL_UNSIGNED_INT_VEC2:

+   case GL_UNSIGNED_INT_VEC3:

+   case GL_UNSIGNED_INT_VEC4:

+      return GL_UNSIGNED_INT;

+   case GL_INT:

+   case GL_INT_VEC2:

+   case GL_INT_VEC3:

+   case GL_INT_VEC4:

+      return GL_INT;

+   default:

+      _mesa_problem(NULL, "Invalid type in base_uniform_type()");

+      return GL_FLOAT;

+   }

+}

+

+static struct gl_builtin_uniform_element gl_DepthRange_elements[] = {

+   {"near", {STATE_DEPTH_RANGE, 0, 0}, SWIZZLE_XXXX},

+   {"far", {STATE_DEPTH_RANGE, 0, 0}, SWIZZLE_YYYY},

+   {"diff", {STATE_DEPTH_RANGE, 0, 0}, SWIZZLE_ZZZZ},

+};

+

+static struct gl_builtin_uniform_element gl_ClipPlane_elements[] = {

+   {NULL, {STATE_CLIPPLANE, 0, 0}, SWIZZLE_XYZW}

+};

+

+static struct gl_builtin_uniform_element gl_Point_elements[] = {

+   {"size", {STATE_POINT_SIZE}, SWIZZLE_XXXX},

+   {"sizeMin", {STATE_POINT_SIZE}, SWIZZLE_YYYY},

+   {"sizeMax", {STATE_POINT_SIZE}, SWIZZLE_ZZZZ},

+   {"fadeThresholdSize", {STATE_POINT_SIZE}, SWIZZLE_WWWW},

+   {"distanceConstantAttenuation", {STATE_POINT_ATTENUATION}, SWIZZLE_XXXX},

+   {"distanceLinearAttenuation", {STATE_POINT_ATTENUATION}, SWIZZLE_YYYY},

+   {"distanceQuadraticAttenuation", {STATE_POINT_ATTENUATION}, SWIZZLE_ZZZZ},

+};

+

+static struct gl_builtin_uniform_element gl_FrontMaterial_elements[] = {

+   {"emission", {STATE_MATERIAL, 0, STATE_EMISSION}, SWIZZLE_XYZW},

+   {"ambient", {STATE_MATERIAL, 0, STATE_AMBIENT}, SWIZZLE_XYZW},

+   {"diffuse", {STATE_MATERIAL, 0, STATE_DIFFUSE}, SWIZZLE_XYZW},

+   {"specular", {STATE_MATERIAL, 0, STATE_SPECULAR}, SWIZZLE_XYZW},

+   {"shininess", {STATE_MATERIAL, 0, STATE_SHININESS}, SWIZZLE_XXXX},

+};

+

+static struct gl_builtin_uniform_element gl_BackMaterial_elements[] = {

+   {"emission", {STATE_MATERIAL, 1, STATE_EMISSION}, SWIZZLE_XYZW},

+   {"ambient", {STATE_MATERIAL, 1, STATE_AMBIENT}, SWIZZLE_XYZW},

+   {"diffuse", {STATE_MATERIAL, 1, STATE_DIFFUSE}, SWIZZLE_XYZW},

+   {"specular", {STATE_MATERIAL, 1, STATE_SPECULAR}, SWIZZLE_XYZW},

+   {"shininess", {STATE_MATERIAL, 1, STATE_SHININESS}, SWIZZLE_XXXX},

+};

+

+static struct gl_builtin_uniform_element gl_LightSource_elements[] = {

+   {"ambient", {STATE_LIGHT, 0, STATE_AMBIENT}, SWIZZLE_XYZW},

+   {"diffuse", {STATE_LIGHT, 0, STATE_DIFFUSE}, SWIZZLE_XYZW},

+   {"specular", {STATE_LIGHT, 0, STATE_SPECULAR}, SWIZZLE_XYZW},

+   {"position", {STATE_LIGHT, 0, STATE_POSITION}, SWIZZLE_XYZW},

+   {"halfVector", {STATE_LIGHT, 0, STATE_HALF_VECTOR}, SWIZZLE_XYZW},

+   {"spotDirection", {STATE_LIGHT, 0, STATE_SPOT_DIRECTION},

+    MAKE_SWIZZLE4(SWIZZLE_X,

+		  SWIZZLE_Y,

+		  SWIZZLE_Z,

+		  SWIZZLE_Z)},

+   {"spotCosCutoff", {STATE_LIGHT, 0, STATE_SPOT_DIRECTION}, SWIZZLE_WWWW},

+   {"spotCutoff", {STATE_LIGHT, 0, STATE_SPOT_CUTOFF}, SWIZZLE_XXXX},

+   {"spotExponent", {STATE_LIGHT, 0, STATE_ATTENUATION}, SWIZZLE_WWWW},

+   {"constantAttenuation", {STATE_LIGHT, 0, STATE_ATTENUATION}, SWIZZLE_XXXX},

+   {"linearAttenuation", {STATE_LIGHT, 0, STATE_ATTENUATION}, SWIZZLE_YYYY},

+   {"quadraticAttenuation", {STATE_LIGHT, 0, STATE_ATTENUATION}, SWIZZLE_ZZZZ},

+};

+

+static struct gl_builtin_uniform_element gl_LightModel_elements[] = {

+   {"ambient", {STATE_LIGHTMODEL_AMBIENT, 0}, SWIZZLE_XYZW},

+};

+

+static struct gl_builtin_uniform_element gl_FrontLightModelProduct_elements[] = {

+   {"sceneColor", {STATE_LIGHTMODEL_SCENECOLOR, 0}, SWIZZLE_XYZW},

+};

+

+static struct gl_builtin_uniform_element gl_BackLightModelProduct_elements[] = {

+   {"sceneColor", {STATE_LIGHTMODEL_SCENECOLOR, 1}, SWIZZLE_XYZW},

+};

+

+static struct gl_builtin_uniform_element gl_FrontLightProduct_elements[] = {

+   {"ambient", {STATE_LIGHTPROD, 0, 0, STATE_AMBIENT}, SWIZZLE_XYZW},

+   {"diffuse", {STATE_LIGHTPROD, 0, 0, STATE_DIFFUSE}, SWIZZLE_XYZW},

+   {"specular", {STATE_LIGHTPROD, 0, 0, STATE_SPECULAR}, SWIZZLE_XYZW},

+};

+

+static struct gl_builtin_uniform_element gl_BackLightProduct_elements[] = {

+   {"ambient", {STATE_LIGHTPROD, 0, 1, STATE_AMBIENT}, SWIZZLE_XYZW},

+   {"diffuse", {STATE_LIGHTPROD, 0, 1, STATE_DIFFUSE}, SWIZZLE_XYZW},

+   {"specular", {STATE_LIGHTPROD, 0, 1, STATE_SPECULAR}, SWIZZLE_XYZW},

+};

+

+static struct gl_builtin_uniform_element gl_TextureEnvColor_elements[] = {

+   {NULL, {STATE_TEXENV_COLOR, 0}, SWIZZLE_XYZW},

+};

+

+static struct gl_builtin_uniform_element gl_EyePlaneS_elements[] = {

+   {NULL, {STATE_TEXGEN, 0, STATE_TEXGEN_EYE_S}, SWIZZLE_XYZW},

+};

+

+static struct gl_builtin_uniform_element gl_EyePlaneT_elements[] = {

+   {NULL, {STATE_TEXGEN, 0, STATE_TEXGEN_EYE_T}, SWIZZLE_XYZW},

+};

+

+static struct gl_builtin_uniform_element gl_EyePlaneR_elements[] = {

+   {NULL, {STATE_TEXGEN, 0, STATE_TEXGEN_EYE_R}, SWIZZLE_XYZW},

+};

+

+static struct gl_builtin_uniform_element gl_EyePlaneQ_elements[] = {

+   {NULL, {STATE_TEXGEN, 0, STATE_TEXGEN_EYE_Q}, SWIZZLE_XYZW},

+};

+

+static struct gl_builtin_uniform_element gl_ObjectPlaneS_elements[] = {

+   {NULL, {STATE_TEXGEN, 0, STATE_TEXGEN_OBJECT_S}, SWIZZLE_XYZW},

+};

+

+static struct gl_builtin_uniform_element gl_ObjectPlaneT_elements[] = {

+   {NULL, {STATE_TEXGEN, 0, STATE_TEXGEN_OBJECT_T}, SWIZZLE_XYZW},

+};

+

+static struct gl_builtin_uniform_element gl_ObjectPlaneR_elements[] = {

+   {NULL, {STATE_TEXGEN, 0, STATE_TEXGEN_OBJECT_R}, SWIZZLE_XYZW},

+};

+

+static struct gl_builtin_uniform_element gl_ObjectPlaneQ_elements[] = {

+   {NULL, {STATE_TEXGEN, 0, STATE_TEXGEN_OBJECT_Q}, SWIZZLE_XYZW},

+};

+

+static struct gl_builtin_uniform_element gl_Fog_elements[] = {

+   {"color", {STATE_FOG_COLOR}, SWIZZLE_XYZW},

+   {"density", {STATE_FOG_PARAMS}, SWIZZLE_XXXX},

+   {"start", {STATE_FOG_PARAMS}, SWIZZLE_YYYY},

+   {"end", {STATE_FOG_PARAMS}, SWIZZLE_ZZZZ},

+   {"scale", {STATE_FOG_PARAMS}, SWIZZLE_WWWW},

+};

+

+static struct gl_builtin_uniform_element gl_NormalScale_elements[] = {

+   {NULL, {STATE_NORMAL_SCALE}, SWIZZLE_XXXX},

+};

+

+static struct gl_builtin_uniform_element gl_MESABumpRotMatrix0_elements[] = {

+   {NULL, {STATE_INTERNAL, STATE_ROT_MATRIX_0}, SWIZZLE_XYZW},

+};

+

+static struct gl_builtin_uniform_element gl_MESABumpRotMatrix1_elements[] = {

+   {NULL, {STATE_INTERNAL, STATE_ROT_MATRIX_1}, SWIZZLE_XYZW},

+};

+

+static struct gl_builtin_uniform_element gl_MESAFogParamsOptimized_elements[] = {

+   {NULL, {STATE_INTERNAL, STATE_FOG_PARAMS_OPTIMIZED}, SWIZZLE_XYZW},

+};

+

+#define MATRIX(name, statevar, modifier)				\

+   static struct gl_builtin_uniform_element name ## _elements[] = {	\

+      { NULL, { statevar, 0, 0, 0, modifier}, SWIZZLE_XYZW },		\

+      { NULL, { statevar, 0, 1, 1, modifier}, SWIZZLE_XYZW },		\

+      { NULL, { statevar, 0, 2, 2, modifier}, SWIZZLE_XYZW },		\

+      { NULL, { statevar, 0, 3, 3, modifier}, SWIZZLE_XYZW },		\

+   }

+

+MATRIX(gl_ModelViewMatrix,

+       STATE_MODELVIEW_MATRIX, STATE_MATRIX_TRANSPOSE);

+MATRIX(gl_ModelViewMatrixInverse,

+       STATE_MODELVIEW_MATRIX, STATE_MATRIX_INVTRANS);

+MATRIX(gl_ModelViewMatrixTranspose,

+       STATE_MODELVIEW_MATRIX, 0);

+MATRIX(gl_ModelViewMatrixInverseTranspose,

+       STATE_MODELVIEW_MATRIX, STATE_MATRIX_INVERSE);

+

+MATRIX(gl_ProjectionMatrix,

+       STATE_PROJECTION_MATRIX, STATE_MATRIX_TRANSPOSE);

+MATRIX(gl_ProjectionMatrixInverse,

+       STATE_PROJECTION_MATRIX, STATE_MATRIX_INVTRANS);

+MATRIX(gl_ProjectionMatrixTranspose,

+       STATE_PROJECTION_MATRIX, 0);

+MATRIX(gl_ProjectionMatrixInverseTranspose,

+       STATE_PROJECTION_MATRIX, STATE_MATRIX_INVERSE);

+

+MATRIX(gl_ModelViewProjectionMatrix,

+       STATE_MVP_MATRIX, STATE_MATRIX_TRANSPOSE);

+MATRIX(gl_ModelViewProjectionMatrixInverse,

+       STATE_MVP_MATRIX, STATE_MATRIX_INVTRANS);

+MATRIX(gl_ModelViewProjectionMatrixTranspose,

+       STATE_MVP_MATRIX, 0);

+MATRIX(gl_ModelViewProjectionMatrixInverseTranspose,

+       STATE_MVP_MATRIX, STATE_MATRIX_INVERSE);

+

+MATRIX(gl_TextureMatrix,

+       STATE_TEXTURE_MATRIX, STATE_MATRIX_TRANSPOSE);

+MATRIX(gl_TextureMatrixInverse,

+       STATE_TEXTURE_MATRIX, STATE_MATRIX_INVTRANS);

+MATRIX(gl_TextureMatrixTranspose,

+       STATE_TEXTURE_MATRIX, 0);

+MATRIX(gl_TextureMatrixInverseTranspose,

+       STATE_TEXTURE_MATRIX, STATE_MATRIX_INVERSE);

+

+static struct gl_builtin_uniform_element gl_NormalMatrix_elements[] = {

+   { NULL, { STATE_MODELVIEW_MATRIX, 0, 0, 0, STATE_MATRIX_INVERSE},

+     SWIZZLE_XYZW },

+   { NULL, { STATE_MODELVIEW_MATRIX, 0, 1, 1, STATE_MATRIX_INVERSE},

+     SWIZZLE_XYZW },

+   { NULL, { STATE_MODELVIEW_MATRIX, 0, 2, 2, STATE_MATRIX_INVERSE},

+     SWIZZLE_XYZW },

+};

+

+#undef MATRIX

+

+#define STATEVAR(name) {#name, name ## _elements, Elements(name ## _elements)}

+

+const struct gl_builtin_uniform_desc _mesa_builtin_uniform_desc[] = {

+   STATEVAR(gl_DepthRange),

+   STATEVAR(gl_ClipPlane),

+   STATEVAR(gl_Point),

+   STATEVAR(gl_FrontMaterial),

+   STATEVAR(gl_BackMaterial),

+   STATEVAR(gl_LightSource),

+   STATEVAR(gl_LightModel),

+   STATEVAR(gl_FrontLightModelProduct),

+   STATEVAR(gl_BackLightModelProduct),

+   STATEVAR(gl_FrontLightProduct),

+   STATEVAR(gl_BackLightProduct),

+   STATEVAR(gl_TextureEnvColor),

+   STATEVAR(gl_EyePlaneS),

+   STATEVAR(gl_EyePlaneT),

+   STATEVAR(gl_EyePlaneR),

+   STATEVAR(gl_EyePlaneQ),

+   STATEVAR(gl_ObjectPlaneS),

+   STATEVAR(gl_ObjectPlaneT),

+   STATEVAR(gl_ObjectPlaneR),

+   STATEVAR(gl_ObjectPlaneQ),

+   STATEVAR(gl_Fog),

+

+   STATEVAR(gl_ModelViewMatrix),

+   STATEVAR(gl_ModelViewMatrixInverse),

+   STATEVAR(gl_ModelViewMatrixTranspose),

+   STATEVAR(gl_ModelViewMatrixInverseTranspose),

+

+   STATEVAR(gl_ProjectionMatrix),

+   STATEVAR(gl_ProjectionMatrixInverse),

+   STATEVAR(gl_ProjectionMatrixTranspose),

+   STATEVAR(gl_ProjectionMatrixInverseTranspose),

+

+   STATEVAR(gl_ModelViewProjectionMatrix),

+   STATEVAR(gl_ModelViewProjectionMatrixInverse),

+   STATEVAR(gl_ModelViewProjectionMatrixTranspose),

+   STATEVAR(gl_ModelViewProjectionMatrixInverseTranspose),

+

+   STATEVAR(gl_TextureMatrix),

+   STATEVAR(gl_TextureMatrixInverse),

+   STATEVAR(gl_TextureMatrixTranspose),

+   STATEVAR(gl_TextureMatrixInverseTranspose),

+

+   STATEVAR(gl_NormalMatrix),

+   STATEVAR(gl_NormalScale),

+

+   STATEVAR(gl_MESABumpRotMatrix0),

+   STATEVAR(gl_MESABumpRotMatrix1),

+   STATEVAR(gl_MESAFogParamsOptimized),

+

+   {NULL, NULL, 0}

+};

+

+static GLboolean

+is_boolean_type(GLenum type)

+{

+   switch (type) {

+   case GL_BOOL:

+   case GL_BOOL_VEC2:

+   case GL_BOOL_VEC3:

+   case GL_BOOL_VEC4:

+      return GL_TRUE;

+   default:

+      return GL_FALSE;

+   }

+}

+

+

+static GLboolean

+is_sampler_type(GLenum type)

+{

+   switch (type) {

+   case GL_SAMPLER_1D:

+   case GL_SAMPLER_2D:

+   case GL_SAMPLER_3D:

+   case GL_SAMPLER_CUBE:

+   case GL_SAMPLER_1D_SHADOW:

+   case GL_SAMPLER_2D_SHADOW:

+   case GL_SAMPLER_2D_RECT_ARB:

+   case GL_SAMPLER_2D_RECT_SHADOW_ARB:

+   case GL_SAMPLER_1D_ARRAY_EXT:

+   case GL_SAMPLER_2D_ARRAY_EXT:

+   case GL_SAMPLER_1D_ARRAY_SHADOW_EXT:

+   case GL_SAMPLER_2D_ARRAY_SHADOW_EXT:

+      return GL_TRUE;

+   default:

+      return GL_FALSE;

+   }

+}

+

+

+static struct gl_program_parameter *

+get_uniform_parameter(const struct gl_shader_program *shProg, GLuint index)

+{

+   const struct gl_program *prog = NULL;

+   GLint progPos;

+

+   progPos = shProg->Uniforms->Uniforms[index].VertPos;

+   if (progPos >= 0) {

+      prog = &shProg->VertexProgram->Base;

+   }

+   else {

+      progPos = shProg->Uniforms->Uniforms[index].FragPos;

+      if (progPos >= 0) {

+         prog = &shProg->FragmentProgram->Base;

+      } else {

+         progPos = shProg->Uniforms->Uniforms[index].GeomPos;

+         if (progPos >= 0) {

+            prog = &shProg->GeometryProgram->Base;

+         }

+      }

+   }

+

+   if (!prog || progPos < 0)

+      return NULL; /* should never happen */

+

+   return &prog->Parameters->Parameters[progPos];

+}

+

+

+/**

+ * Called by glGetActiveUniform().

+ */

+static void

+_mesa_get_active_uniform(struct gl_context *ctx, GLuint program, GLuint index,

+                         GLsizei maxLength, GLsizei *length, GLint *size,

+                         GLenum *type, GLchar *nameOut)

+{

+   const struct gl_shader_program *shProg;

+   const struct gl_program *prog = NULL;

+   const struct gl_program_parameter *param;

+   GLint progPos;

+

+   shProg = _mesa_lookup_shader_program_err(ctx, program, "glGetActiveUniform");

+   if (!shProg)

+      return;

+

+   if (!shProg->Uniforms || index >= shProg->Uniforms->NumUniforms) {

+      _mesa_error(ctx, GL_INVALID_VALUE, "glGetActiveUniform(index)");

+      return;

+   }

+

+   progPos = shProg->Uniforms->Uniforms[index].VertPos;

+   if (progPos >= 0) {

+      prog = &shProg->VertexProgram->Base;

+   }

+   else {

+      progPos = shProg->Uniforms->Uniforms[index].FragPos;

+      if (progPos >= 0) {

+         prog = &shProg->FragmentProgram->Base;

+      } else {

+         progPos = shProg->Uniforms->Uniforms[index].GeomPos;

+         if (progPos >= 0) {

+            prog = &shProg->GeometryProgram->Base;

+         }

+      }

+   }

+

+   if (!prog || progPos < 0)

+      return; /* should never happen */

+

+   ASSERT(progPos < prog->Parameters->NumParameters);

+   param = &prog->Parameters->Parameters[progPos];

+

+   if (nameOut) {

+      _mesa_copy_string(nameOut, maxLength, length, param->Name);

+   }

+

+   if (size) {

+      GLint typeSize = _mesa_sizeof_glsl_type(param->DataType);

+      if ((GLint) param->Size > typeSize) {

+         /* This is an array.

+          * Array elements are placed on vector[4] boundaries so they're

+          * a multiple of four floats.  We round typeSize up to next multiple

+          * of four to get the right size below.

+          */

+         typeSize = (typeSize + 3) & ~3;

+      }

+      /* Note that the returned size is in units of the <type>, not bytes */

+      *size = param->Size / typeSize;

+   }

+

+   if (type) {

+      *type = param->DataType;

+   }

+}

+

+

+static unsigned

+get_vector_elements(GLenum type)

+{

+   switch (type) {

+   case GL_FLOAT:

+   case GL_INT:

+   case GL_BOOL:

+   case GL_UNSIGNED_INT:

+   default: /* Catch all the various sampler types. */

+      return 1;

+

+   case GL_FLOAT_VEC2:

+   case GL_INT_VEC2:

+   case GL_BOOL_VEC2:

+   case GL_UNSIGNED_INT_VEC2:

+      return 2;

+

+   case GL_FLOAT_VEC3:

+   case GL_INT_VEC3:

+   case GL_BOOL_VEC3:

+   case GL_UNSIGNED_INT_VEC3:

+      return 3;

+

+   case GL_FLOAT_VEC4:

+   case GL_INT_VEC4:

+   case GL_BOOL_VEC4:

+   case GL_UNSIGNED_INT_VEC4:

+      return 4;

+   }

+}

+

+static void

+get_matrix_dims(GLenum type, GLint *rows, GLint *cols)

+{

+   switch (type) {

+   case GL_FLOAT_MAT2:

+      *rows = *cols = 2;

+      break;

+   case GL_FLOAT_MAT2x3:

+      *rows = 3;

+      *cols = 2;

+      break;

+   case GL_FLOAT_MAT2x4:

+      *rows = 4;

+      *cols = 2;

+      break;

+   case GL_FLOAT_MAT3:

+      *rows = 3;

+      *cols = 3;

+      break;

+   case GL_FLOAT_MAT3x2:

+      *rows = 2;

+      *cols = 3;

+      break;

+   case GL_FLOAT_MAT3x4:

+      *rows = 4;

+      *cols = 3;

+      break;

+   case GL_FLOAT_MAT4:

+      *rows = 4;

+      *cols = 4;

+      break;

+   case GL_FLOAT_MAT4x2:

+      *rows = 2;

+      *cols = 4;

+      break;

+   case GL_FLOAT_MAT4x3:

+      *rows = 3;

+      *cols = 4;

+      break;

+   default:

+      *rows = *cols = 0;

+   }

+}

+

+

+/**

+ * Determine the number of rows and columns occupied by a uniform

+ * according to its datatype.  For non-matrix types (such as GL_FLOAT_VEC4),

+ * the number of rows = 1 and cols = number of elements in the vector.

+ */

+static void

+get_uniform_rows_cols(const struct gl_program_parameter *p,

+                      GLint *rows, GLint *cols)

+{

+   get_matrix_dims(p->DataType, rows, cols);

+   if (*rows == 0 && *cols == 0) {

+      /* not a matrix type, probably a float or vector */

+      *rows = 1;

+      *cols = get_vector_elements(p->DataType);

+   }

+}

+

+

+/**

+ * Helper for get_uniform[fi]v() functions.

+ * Given a shader program name and uniform location, return a pointer

+ * to the shader program and return the program parameter position.

+ */

+static void

+lookup_uniform_parameter(struct gl_context *ctx, GLuint program, GLint location,

+                         struct gl_program **progOut, GLint *paramPosOut)

+{

+   struct gl_shader_program *shProg

+      = _mesa_lookup_shader_program_err(ctx, program, "glGetUniform[if]v");

+   struct gl_program *prog = NULL;

+   GLint progPos = -1;

+

+   /* if shProg is NULL, we'll have already recorded an error */

+

+   if (shProg) {

+      if (!shProg->Uniforms ||

+          location < 0 ||

+          location >= (GLint) shProg->Uniforms->NumUniforms) {

+         _mesa_error(ctx, GL_INVALID_OPERATION,  "glGetUniformfv(location)");

+      }

+      else {

+         /* OK, find the gl_program and program parameter location */

+         progPos = shProg->Uniforms->Uniforms[location].VertPos;

+         if (progPos >= 0) {

+            prog = &shProg->VertexProgram->Base;

+         }

+         else {

+            progPos = shProg->Uniforms->Uniforms[location].FragPos;

+            if (progPos >= 0) {

+               prog = &shProg->FragmentProgram->Base;

+            } else {

+               progPos = shProg->Uniforms->Uniforms[location].GeomPos;

+               if (progPos >= 0) {

+                  prog = &shProg->GeometryProgram->Base;

+               }

+            }

+         }

+      }

+   }

+

+   *progOut = prog;

+   *paramPosOut = progPos;

+}

+

+

+/**

+ * GLGL uniform arrays and structs require special handling.

+ *

+ * The GL_ARB_shader_objects spec says that if you use

+ * glGetUniformLocation to get the location of an array, you CANNOT

+ * access other elements of the array by adding an offset to the

+ * returned location.  For example, you must call

+ * glGetUniformLocation("foo[16]") if you want to set the 16th element

+ * of the array with glUniform().

+ *

+ * HOWEVER, some other OpenGL drivers allow accessing array elements

+ * by adding an offset to the returned array location.  And some apps

+ * seem to depend on that behaviour.

+ *

+ * Mesa's gl_uniform_list doesn't directly support this since each

+ * entry in the list describes one uniform variable, not one uniform

+ * element.  We could insert dummy entries in the list for each array

+ * element after [0] but that causes complications elsewhere.

+ *

+ * We solve this problem by encoding two values in the location that's

+ * returned by glGetUniformLocation():

+ *  a) index into gl_uniform_list::Uniforms[] for the uniform

+ *  b) an array/field offset (0 for simple types)

+ *

+ * These two values are encoded in the high and low halves of a GLint.

+ * By putting the uniform number in the high part and the offset in the

+ * low part, we can support the unofficial ability to index into arrays

+ * by adding offsets to the location value.

+ */

+static void

+merge_location_offset(GLint *location, GLint offset)

+{

+   *location = (*location << 16) | offset;

+}

+

+

+/**

+ * Separate the uniform location and parameter offset.  See above.

+ */

+static void

+split_location_offset(GLint *location, GLint *offset)

+{

+   *offset = *location & 0xffff;

+   *location = *location >> 16;

+}

+

+

+

+/**

+ * Called via glGetUniformfv().

+ */

+static void

+_mesa_get_uniformfv(struct gl_context *ctx, GLuint program, GLint location,

+                    GLfloat *params)

+{

+   struct gl_program *prog;

+   GLint paramPos;

+   GLint offset;

+

+   split_location_offset(&location, &offset);

+

+   lookup_uniform_parameter(ctx, program, location, &prog, &paramPos);

+

+   if (prog) {

+      const struct gl_program_parameter *p =

+         &prog->Parameters->Parameters[paramPos];

+      GLint rows, cols, i, j, k;

+

+      get_uniform_rows_cols(p, &rows, &cols);

+

+      k = 0;

+      for (i = 0; i < rows; i++) {

+	 const int base = paramPos + offset + i;

+

+         for (j = 0; j < cols; j++ ) {

+            params[k++] = prog->Parameters->ParameterValues[base][j];

+         }

+      }

+   }

+}

+

+

+/**

+ * Called via glGetUniformiv().

+ * \sa _mesa_get_uniformfv, only difference is a cast.

+ */

+static void

+_mesa_get_uniformiv(struct gl_context *ctx, GLuint program, GLint location,

+                    GLint *params)

+{

+   struct gl_program *prog;

+   GLint paramPos;

+   GLint offset;

+

+   split_location_offset(&location, &offset);

+

+   lookup_uniform_parameter(ctx, program, location, &prog, &paramPos);

+

+   if (prog) {

+      const struct gl_program_parameter *p =

+         &prog->Parameters->Parameters[paramPos];

+      GLint rows, cols, i, j, k;

+

+      get_uniform_rows_cols(p, &rows, &cols);

+

+      k = 0;

+      for (i = 0; i < rows; i++) {

+	 const int base = paramPos + offset + i;

+

+         for (j = 0; j < cols; j++ ) {

+            params[k++] = (GLint) prog->Parameters->ParameterValues[base][j];

+         }

+      }

+   }

+}

+

+

+/**

+ * Called via glGetUniformuiv().

+ * New in GL_EXT_gpu_shader4, OpenGL 3.0

+ * \sa _mesa_get_uniformfv, only difference is a cast.

+ */

+static void

+_mesa_get_uniformuiv(struct gl_context *ctx, GLuint program, GLint location,

+                     GLuint *params)

+{

+   struct gl_program *prog;

+   GLint paramPos;

+   GLint offset;

+

+   split_location_offset(&location, &offset);

+

+   lookup_uniform_parameter(ctx, program, location, &prog, &paramPos);

+

+   if (prog) {

+      const struct gl_program_parameter *p =

+         &prog->Parameters->Parameters[paramPos];

+      GLint rows, cols, i, j, k;

+

+      get_uniform_rows_cols(p, &rows, &cols);

+

+      k = 0;

+      for (i = 0; i < rows; i++) {

+	 const int base = paramPos + offset + i;

+

+         for (j = 0; j < cols; j++ ) {

+            params[k++] = (GLuint) prog->Parameters->ParameterValues[base][j];

+         }

+      }

+   }

+}

+

+

+/**

+ * Called via glGetUniformLocation().

+ *

+ * The return value will encode two values, the uniform location and an

+ * offset (used for arrays, structs).

+ */

+GLint

+_mesa_get_uniform_location(struct gl_context *ctx, struct gl_shader_program *shProg,

+			   const GLchar *name)

+{

+   GLint offset = 0, location = -1;

+

+   if (shProg->LinkStatus == GL_FALSE) {

+      _mesa_error(ctx, GL_INVALID_OPERATION, "glGetUniformfv(program)");

+      return -1;

+   }

+

+   /* XXX we should return -1 if the uniform was declared, but not

+    * actually used.

+    */

+

+   /* XXX we need to be able to parse uniform names for structs and arrays

+    * such as:

+    *   mymatrix[1]

+    *   mystruct.field1

+    */

+

+   {

+      /* handle 1-dimension arrays here... */

+      char *c = strchr(name, '[');

+      if (c) {

+         /* truncate name at [ */

+         const GLint len = c - name;

+         GLchar *newName = malloc(len + 1);

+         if (!newName)

+            return -1; /* out of mem */

+         memcpy(newName, name, len);

+         newName[len] = 0;

+

+         location = _mesa_lookup_uniform(shProg->Uniforms, newName);

+         if (location >= 0) {

+            const GLint element = atoi(c + 1);

+            if (element > 0) {

+               /* get type of the uniform array element */

+               struct gl_program_parameter *p;

+               p = get_uniform_parameter(shProg, location);

+               if (p) {

+                  GLint rows, cols;

+                  get_matrix_dims(p->DataType, &rows, &cols);

+                  if (rows < 1)

+                     rows = 1;

+                  offset = element * rows;

+               }

+            }

+         }

+

+         free(newName);

+      }

+   }

+

+   if (location < 0) {

+      location = _mesa_lookup_uniform(shProg->Uniforms, name);

+   }

+

+   if (location >= 0) {

+      merge_location_offset(&location, offset);

+   }

+

+   return location;

+}

+

+

+

+/**

+ * Update the vertex/fragment program's TexturesUsed array.

+ *

+ * This needs to be called after glUniform(set sampler var) is called.

+ * A call to glUniform(samplerVar, value) causes a sampler to point to a

+ * particular texture unit.  We know the sampler's texture target

+ * (1D/2D/3D/etc) from compile time but the sampler's texture unit is

+ * set by glUniform() calls.

+ *

+ * So, scan the program->SamplerUnits[] and program->SamplerTargets[]

+ * information to update the prog->TexturesUsed[] values.

+ * Each value of TexturesUsed[unit] is one of zero, TEXTURE_1D_INDEX,

+ * TEXTURE_2D_INDEX, TEXTURE_3D_INDEX, etc.

+ * We'll use that info for state validation before rendering.

+ */

+void

+_mesa_update_shader_textures_used(struct gl_program *prog)

+{

+   GLuint s;

+

+   memset(prog->TexturesUsed, 0, sizeof(prog->TexturesUsed));

+

+   for (s = 0; s < MAX_SAMPLERS; s++) {

+      if (prog->SamplersUsed & (1 << s)) {

+         GLuint unit = prog->SamplerUnits[s];

+         GLuint tgt = prog->SamplerTargets[s];

+         assert(unit < MAX_TEXTURE_IMAGE_UNITS);

+         assert(tgt < NUM_TEXTURE_TARGETS);

+         prog->TexturesUsed[unit] |= (1 << tgt);

+      }

+   }

+}

+

+

+/**

+ * Check if the type given by userType is allowed to set a uniform of the

+ * target type.  Generally, equivalence is required, but setting Boolean

+ * uniforms can be done with glUniformiv or glUniformfv.

+ */

+static GLboolean

+compatible_types(GLenum userType, GLenum targetType)

+{

+   if (userType == targetType)

+      return GL_TRUE;

+

+   if (targetType == GL_BOOL && (userType == GL_FLOAT ||

+                                 userType == GL_UNSIGNED_INT ||

+                                 userType == GL_INT))

+      return GL_TRUE;

+

+   if (targetType == GL_BOOL_VEC2 && (userType == GL_FLOAT_VEC2 ||

+                                      userType == GL_UNSIGNED_INT_VEC2 ||

+                                      userType == GL_INT_VEC2))

+      return GL_TRUE;

+

+   if (targetType == GL_BOOL_VEC3 && (userType == GL_FLOAT_VEC3 ||

+                                      userType == GL_UNSIGNED_INT_VEC3 ||

+                                      userType == GL_INT_VEC3))

+      return GL_TRUE;

+

+   if (targetType == GL_BOOL_VEC4 && (userType == GL_FLOAT_VEC4 ||

+                                      userType == GL_UNSIGNED_INT_VEC4 ||

+                                      userType == GL_INT_VEC4))

+      return GL_TRUE;

+

+   if (is_sampler_type(targetType) && userType == GL_INT)

+      return GL_TRUE;

+

+   return GL_FALSE;

+}

+

+

+/**

+ * Set the value of a program's uniform variable.

+ * \param program  the program whose uniform to update

+ * \param index  the index of the program parameter for the uniform

+ * \param offset  additional parameter slot offset (for arrays)

+ * \param type  the incoming datatype of 'values'

+ * \param count  the number of uniforms to set

+ * \param elems  number of elements per uniform (1, 2, 3 or 4)

+ * \param values  the new values, of datatype 'type'

+ */

+static void

+set_program_uniform(struct gl_context *ctx, struct gl_program *program,

+                    GLint index, GLint offset,

+                    GLenum type, GLsizei count, GLint elems,

+                    const void *values)

+{

+   const struct gl_program_parameter *param =

+      &program->Parameters->Parameters[index];

+

+   assert(offset >= 0);

+   assert(elems >= 1);

+   assert(elems <= 4);

+

+   if (!compatible_types(type, param->DataType)) {

+      _mesa_error(ctx, GL_INVALID_OPERATION, "glUniform(type mismatch)");

+      return;

+   }

+

+   if (index + offset > (GLint) program->Parameters->Size) {

+      /* out of bounds! */

+      return;

+   }

+

+   if (param->Type == PROGRAM_SAMPLER) {

+      /* This controls which texture unit which is used by a sampler */

+      GLboolean changed = GL_FALSE;

+      GLint i;

+

+      /* this should have been caught by the compatible_types() check */

+      ASSERT(type == GL_INT);

+

+      /* loop over number of samplers to change */

+      for (i = 0; i < count; i++) {

+         GLuint sampler =

+            (GLuint) program->Parameters->ParameterValues[index + offset + i][0];

+         GLuint texUnit = ((GLuint *) values)[i];

+

+         /* check that the sampler (tex unit index) is legal */

+         if (texUnit >= ctx->Const.MaxTextureImageUnits) {

+            _mesa_error(ctx, GL_INVALID_VALUE,

+                        "glUniform1(invalid sampler/tex unit index for '%s')",

+                        param->Name);

+            return;

+         }

+

+         /* This maps a sampler to a texture unit: */

+         if (sampler < MAX_SAMPLERS) {

+#if 0

+            printf("Set program %p sampler %d '%s' to unit %u\n",

+		   program, sampler, param->Name, texUnit);

+#endif

+            if (program->SamplerUnits[sampler] != texUnit) {

+               program->SamplerUnits[sampler] = texUnit;

+               changed = GL_TRUE;

+            }

+         }

+      }

+

+      if (changed) {

+         /* When a sampler's value changes it usually requires rewriting

+          * a GPU program's TEX instructions since there may not be a

+          * sampler->texture lookup table.  We signal this with the

+          * ProgramStringNotify() callback.

+          */

+         FLUSH_VERTICES(ctx, _NEW_TEXTURE | _NEW_PROGRAM);

+         _mesa_update_shader_textures_used(program);

+         /* Do we need to care about the return value here?

+          * This should not be the first time the driver was notified of

+          * this program.

+          */

+         (void) ctx->Driver.ProgramStringNotify(ctx, program->Target, program);

+      }

+   }

+   else {

+      /* ordinary uniform variable */

+      const GLboolean isUniformBool = is_boolean_type(param->DataType);

+      const GLenum basicType = base_uniform_type(type);

+      const GLint slots = (param->Size + 3) / 4;

+      const GLint typeSize = _mesa_sizeof_glsl_type(param->DataType);

+      GLsizei k, i;

+

+      if ((GLint) param->Size > typeSize) {

+         /* an array */

+         /* we'll ignore extra data below */

+      }

+      else {

+         /* non-array: count must be at most one; count == 0 is handled by the loop below */

+         if (count > 1) {

+            _mesa_error(ctx, GL_INVALID_OPERATION,

+                        "glUniform(uniform '%s' is not an array)",

+                        param->Name);

+            return;

+         }

+      }

+

+      /* loop over number of array elements */

+      for (k = 0; k < count; k++) {

+         GLfloat *uniformVal;

+

+         if (offset + k >= slots) {

+            /* Extra array data is ignored */

+            break;

+         }

+

+         /* uniformVal (the destination) is always float[4] */

+         uniformVal = program->Parameters->ParameterValues[index + offset + k];

+

+         if (basicType == GL_INT) {

+            /* convert user's ints to floats */

+            const GLint *iValues = ((const GLint *) values) + k * elems;

+            for (i = 0; i < elems; i++) {

+               uniformVal[i] = (GLfloat) iValues[i];

+            }

+         }

+         else if (basicType == GL_UNSIGNED_INT) {

+            /* convert user's uints to floats */

+            const GLuint *iValues = ((const GLuint *) values) + k * elems;

+            for (i = 0; i < elems; i++) {

+               uniformVal[i] = (GLfloat) iValues[i];

+            }

+         }

+         else {

+            const GLfloat *fValues = ((const GLfloat *) values) + k * elems;

+            assert(basicType == GL_FLOAT);

+            for (i = 0; i < elems; i++) {

+               uniformVal[i] = fValues[i];

+            }

+         }

+

+         /* if the uniform is bool-valued, convert to 1.0 or 0.0 */

+         if (isUniformBool) {

+            for (i = 0; i < elems; i++) {

+               uniformVal[i] = uniformVal[i] ? 1.0f : 0.0f;

+            }

+         }

+      }

+   }

+}

+

+

+/**

+ * Called via glUniform*() functions.

+ */

+void

+_mesa_uniform(struct gl_context *ctx, struct gl_shader_program *shProg,

+	      GLint location, GLsizei count,

+              const GLvoid *values, GLenum type)

+{

+   struct gl_uniform *uniform;

+   GLint elems, offset;

+

+   if (!shProg || !shProg->LinkStatus) {

+      _mesa_error(ctx, GL_INVALID_OPERATION, "glUniform(program not linked)");

+      return;

+   }

+

+   if (location == -1)

+      return;   /* The standard specifies this as a no-op */

+

+   if (location < -1) {

+      _mesa_error(ctx, GL_INVALID_OPERATION, "glUniform(location=%d)",

+                  location);

+      return;

+   }

+

+   split_location_offset(&location, &offset);

+

+   if (location < 0 || location >= (GLint) shProg->Uniforms->NumUniforms) {

+      _mesa_error(ctx, GL_INVALID_VALUE, "glUniform(location=%d)", location);

+      return;

+   }

+

+   if (count < 0) {

+      _mesa_error(ctx, GL_INVALID_VALUE, "glUniform(count < 0)");

+      return;

+   }

+

+   elems = _mesa_sizeof_glsl_type(type);

+

+   FLUSH_VERTICES(ctx, _NEW_PROGRAM_CONSTANTS);

+

+   uniform = &shProg->Uniforms->Uniforms[location];

+

+   if (ctx->Shader.Flags & GLSL_UNIFORMS) {

+      const GLenum basicType = base_uniform_type(type);

+      GLint i;

+      printf("Mesa: set program %u uniform %s (loc %d) to: ",

+	     shProg->Name, uniform->Name, location);

+      if (basicType == GL_INT) {

+         const GLint *v = (const GLint *) values;

+         for (i = 0; i < count * elems; i++) {

+            printf("%d ", v[i]);

+         }

+      }

+      else if (basicType == GL_UNSIGNED_INT) {

+         const GLuint *v = (const GLuint *) values;

+         for (i = 0; i < count * elems; i++) {

+            printf("%u ", v[i]);

+         }

+      }

+      else {

+         const GLfloat *v = (const GLfloat *) values;

+         assert(basicType == GL_FLOAT);

+         for (i = 0; i < count * elems; i++) {

+            printf("%g ", v[i]);

+         }

+      }

+      printf("\n");

+   }

+

+   /* A uniform var may be used by both a vertex shader and a fragment

+    * shader.  We may need to update one or both shader's uniform here:

+    */

+   if (shProg->VertexProgram) {

+      /* convert uniform location to program parameter index */

+      GLint index = uniform->VertPos;

+      if (index >= 0) {

+         set_program_uniform(ctx, &shProg->VertexProgram->Base,

+                             index, offset, type, count, elems, values);

+      }

+   }

+

+   if (shProg->FragmentProgram) {

+      /* convert uniform location to program parameter index */

+      GLint index = uniform->FragPos;

+      if (index >= 0) {

+         set_program_uniform(ctx, &shProg->FragmentProgram->Base,

+                             index, offset, type, count, elems, values);

+      }

+   }

+

+   if (shProg->GeometryProgram) {

+      /* convert uniform location to program parameter index */

+      GLint index = uniform->GeomPos;

+      if (index >= 0) {

+         set_program_uniform(ctx, &shProg->GeometryProgram->Base,

+                             index, offset, type, count, elems, values);

+      }

+   }

+

+   uniform->Initialized = GL_TRUE;

+}

+

+

+/**

+ * Set a matrix-valued program parameter.

+ */

+static void

+set_program_uniform_matrix(struct gl_context *ctx, struct gl_program *program,

+                           GLuint index, GLuint offset,

+                           GLuint count, GLuint rows, GLuint cols,

+                           GLboolean transpose, const GLfloat *values)

+{

+   GLuint mat, row, col;

+   GLuint src = 0;

+   const struct gl_program_parameter * param = &program->Parameters->Parameters[index];

+   const GLuint slots = (param->Size + 3) / 4;

+   const GLint typeSize = _mesa_sizeof_glsl_type(param->DataType);

+   GLint nr, nc;

+

+   /* check that the number of rows, columns is correct */

+   get_matrix_dims(param->DataType, &nr, &nc);

+   if (rows != nr || cols != nc) {

+      _mesa_error(ctx, GL_INVALID_OPERATION,

+                  "glUniformMatrix(matrix size mismatch)");

+      return;

+   }

+

+   if ((GLint) param->Size <= typeSize) {

+      /* non-array: count must be at most one; count == 0 is handled by the loop below */

+      if (count > 1) {

+         _mesa_error(ctx, GL_INVALID_OPERATION,

+                     "glUniformMatrix(uniform is not an array)");

+         return;

+      }

+   }

+

+   /*

+    * Note: the _columns_ of a matrix are stored in program registers, not

+    * the rows.  So, the loops below look a little funny.

+    * XXX could optimize this a bit...

+    */

+

+   /* loop over matrices */

+   for (mat = 0; mat < count; mat++) {

+

+      /* each matrix: */

+      for (col = 0; col < cols; col++) {

+         GLfloat *v;

+         if (offset >= slots) {

+            /* Ignore writes beyond the end of (the used part of) an array */

+            return;

+         }

+         v = program->Parameters->ParameterValues[index + offset];

+         for (row = 0; row < rows; row++) {

+            if (transpose) {

+               v[row] = values[src + row * cols + col];

+            }

+            else {

+               v[row] = values[src + col * rows + row];

+            }

+         }

+

+         offset++;

+      }

+

+      src += rows * cols;  /* next matrix */

+   }

+}

+

+

+/**

+ * Called by glUniformMatrix*() functions.

+ * Note: cols=2, rows=4  ==>  array[2] of vec4

+ */

+void

+_mesa_uniform_matrix(struct gl_context *ctx, struct gl_shader_program *shProg,

+		     GLint cols, GLint rows,

+                     GLint location, GLsizei count,

+                     GLboolean transpose, const GLfloat *values)

+{

+   struct gl_uniform *uniform;

+   GLint offset;

+

+   if (!shProg || !shProg->LinkStatus) {

+      _mesa_error(ctx, GL_INVALID_OPERATION,

+         "glUniformMatrix(program not linked)");

+      return;

+   }

+

+   if (location == -1)

+      return;   /* The standard specifies this as a no-op */

+

+   if (location < -1) {

+      _mesa_error(ctx, GL_INVALID_OPERATION, "glUniformMatrix(location)");

+      return;

+   }

+

+   split_location_offset(&location, &offset);

+

+   if (location < 0 || location >= (GLint) shProg->Uniforms->NumUniforms) {

+      _mesa_error(ctx, GL_INVALID_VALUE, "glUniformMatrix(location)");

+      return;

+   }

+   if (values == NULL) {

+      _mesa_error(ctx, GL_INVALID_VALUE, "glUniformMatrix");

+      return;

+   }

+

+   FLUSH_VERTICES(ctx, _NEW_PROGRAM_CONSTANTS);

+

+   uniform = &shProg->Uniforms->Uniforms[location];

+

+   if (shProg->VertexProgram) {

+      /* convert uniform location to program parameter index */

+      GLint index = uniform->VertPos;

+      if (index >= 0) {

+         set_program_uniform_matrix(ctx, &shProg->VertexProgram->Base,

+                                    index, offset,

+                                    count, rows, cols, transpose, values);

+      }

+   }

+

+   if (shProg->FragmentProgram) {

+      /* convert uniform location to program parameter index */

+      GLint index = uniform->FragPos;

+      if (index >= 0) {

+         set_program_uniform_matrix(ctx, &shProg->FragmentProgram->Base,

+                                    index, offset,

+                                    count, rows, cols, transpose, values);

+      }

+   }

+

+   if (shProg->GeometryProgram) {

+      /* convert uniform location to program parameter index */

+      GLint index = uniform->GeomPos;

+      if (index >= 0) {

+         set_program_uniform_matrix(ctx, &shProg->GeometryProgram->Base,

+                                    index, offset,

+                                    count, rows, cols, transpose, values);

+      }

+   }

+

+   uniform->Initialized = GL_TRUE;

+}

+

+

+void GLAPIENTRY

+_mesa_Uniform1fARB(GLint location, GLfloat v0)

+{

+   GET_CURRENT_CONTEXT(ctx);

+   _mesa_uniform(ctx, ctx->Shader.ActiveProgram, location, 1, &v0, GL_FLOAT);

+}

+

+void GLAPIENTRY

+_mesa_Uniform2fARB(GLint location, GLfloat v0, GLfloat v1)

+{

+   GET_CURRENT_CONTEXT(ctx);

+   GLfloat v[2];

+   v[0] = v0;

+   v[1] = v1;

+   _mesa_uniform(ctx, ctx->Shader.ActiveProgram, location, 1, v, GL_FLOAT_VEC2);

+}

+

+void GLAPIENTRY

+_mesa_Uniform3fARB(GLint location, GLfloat v0, GLfloat v1, GLfloat v2)

+{

+   GET_CURRENT_CONTEXT(ctx);

+   GLfloat v[3];

+   v[0] = v0;

+   v[1] = v1;

+   v[2] = v2;

+   _mesa_uniform(ctx, ctx->Shader.ActiveProgram, location, 1, v, GL_FLOAT_VEC3);

+}

+

+void GLAPIENTRY

+_mesa_Uniform4fARB(GLint location, GLfloat v0, GLfloat v1, GLfloat v2,

+                   GLfloat v3)

+{

+   GET_CURRENT_CONTEXT(ctx);

+   GLfloat v[4];

+   v[0] = v0;

+   v[1] = v1;

+   v[2] = v2;

+   v[3] = v3;

+   _mesa_uniform(ctx, ctx->Shader.ActiveProgram, location, 1, v, GL_FLOAT_VEC4);

+}

+

+void GLAPIENTRY

+_mesa_Uniform1iARB(GLint location, GLint v0)

+{

+   GET_CURRENT_CONTEXT(ctx);

+   _mesa_uniform(ctx, ctx->Shader.ActiveProgram, location, 1, &v0, GL_INT);

+}

+

+void GLAPIENTRY

+_mesa_Uniform2iARB(GLint location, GLint v0, GLint v1)

+{

+   GET_CURRENT_CONTEXT(ctx);

+   GLint v[2];

+   v[0] = v0;

+   v[1] = v1;

+   _mesa_uniform(ctx, ctx->Shader.ActiveProgram, location, 1, v, GL_INT_VEC2);

+}

+

+void GLAPIENTRY

+_mesa_Uniform3iARB(GLint location, GLint v0, GLint v1, GLint v2)

+{

+   GET_CURRENT_CONTEXT(ctx);

+   GLint v[3];

+   v[0] = v0;

+   v[1] = v1;

+   v[2] = v2;

+   _mesa_uniform(ctx, ctx->Shader.ActiveProgram, location, 1, v, GL_INT_VEC3);

+}

+

+void GLAPIENTRY

+_mesa_Uniform4iARB(GLint location, GLint v0, GLint v1, GLint v2, GLint v3)

+{

+   GET_CURRENT_CONTEXT(ctx);

+   GLint v[4];

+   v[0] = v0;

+   v[1] = v1;

+   v[2] = v2;

+   v[3] = v3;

+   _mesa_uniform(ctx, ctx->Shader.ActiveProgram, location, 1, v, GL_INT_VEC4);

+}

+

+void GLAPIENTRY

+_mesa_Uniform1fvARB(GLint location, GLsizei count, const GLfloat * value)

+{

+   GET_CURRENT_CONTEXT(ctx);

+   _mesa_uniform(ctx, ctx->Shader.ActiveProgram, location, count, value, GL_FLOAT);

+}

+

+void GLAPIENTRY

+_mesa_Uniform2fvARB(GLint location, GLsizei count, const GLfloat * value)

+{

+   GET_CURRENT_CONTEXT(ctx);

+   _mesa_uniform(ctx, ctx->Shader.ActiveProgram, location, count, value, GL_FLOAT_VEC2);

+}

+

+void GLAPIENTRY

+_mesa_Uniform3fvARB(GLint location, GLsizei count, const GLfloat * value)

+{

+   GET_CURRENT_CONTEXT(ctx);

+   _mesa_uniform(ctx, ctx->Shader.ActiveProgram, location, count, value, GL_FLOAT_VEC3);

+}

+

+void GLAPIENTRY

+_mesa_Uniform4fvARB(GLint location, GLsizei count, const GLfloat * value)

+{

+   GET_CURRENT_CONTEXT(ctx);

+   _mesa_uniform(ctx, ctx->Shader.ActiveProgram, location, count, value, GL_FLOAT_VEC4);

+}

+

+void GLAPIENTRY

+_mesa_Uniform1ivARB(GLint location, GLsizei count, const GLint * value)

+{

+   GET_CURRENT_CONTEXT(ctx);

+   _mesa_uniform(ctx, ctx->Shader.ActiveProgram, location, count, value, GL_INT);

+}

+

+void GLAPIENTRY

+_mesa_Uniform2ivARB(GLint location, GLsizei count, const GLint * value)

+{

+   GET_CURRENT_CONTEXT(ctx);

+   _mesa_uniform(ctx, ctx->Shader.ActiveProgram, location, count, value, GL_INT_VEC2);

+}

+

+void GLAPIENTRY

+_mesa_Uniform3ivARB(GLint location, GLsizei count, const GLint * value)

+{

+   GET_CURRENT_CONTEXT(ctx);

+   _mesa_uniform(ctx, ctx->Shader.ActiveProgram, location, count, value, GL_INT_VEC3);

+}

+

+void GLAPIENTRY

+_mesa_Uniform4ivARB(GLint location, GLsizei count, const GLint * value)

+{

+   GET_CURRENT_CONTEXT(ctx);

+   _mesa_uniform(ctx, ctx->Shader.ActiveProgram, location, count, value, GL_INT_VEC4);

+}

+

+

+/** OpenGL 3.0 GLuint-valued functions **/

+void GLAPIENTRY

+_mesa_Uniform1ui(GLint location, GLuint v0)

+{

+   GET_CURRENT_CONTEXT(ctx);

+   _mesa_uniform(ctx, ctx->Shader.ActiveProgram, location, 1, &v0, GL_UNSIGNED_INT);

+}

+

+void GLAPIENTRY

+_mesa_Uniform2ui(GLint location, GLuint v0, GLuint v1)

+{

+   GET_CURRENT_CONTEXT(ctx);

+   GLuint v[2];

+   v[0] = v0;

+   v[1] = v1;

+   _mesa_uniform(ctx, ctx->Shader.ActiveProgram, location, 1, v, GL_UNSIGNED_INT_VEC2);

+}

+

+void GLAPIENTRY

+_mesa_Uniform3ui(GLint location, GLuint v0, GLuint v1, GLuint v2)

+{

+   GET_CURRENT_CONTEXT(ctx);

+   GLuint v[3];

+   v[0] = v0;

+   v[1] = v1;

+   v[2] = v2;

+   _mesa_uniform(ctx, ctx->Shader.ActiveProgram, location, 1, v, GL_UNSIGNED_INT_VEC3);

+}

+

+void GLAPIENTRY

+_mesa_Uniform4ui(GLint location, GLuint v0, GLuint v1, GLuint v2, GLuint v3)

+{

+   GET_CURRENT_CONTEXT(ctx);

+   GLuint v[4];

+   v[0] = v0;

+   v[1] = v1;

+   v[2] = v2;

+   v[3] = v3;

+   _mesa_uniform(ctx, ctx->Shader.ActiveProgram, location, 1, v, GL_UNSIGNED_INT_VEC4);

+}

+

+void GLAPIENTRY

+_mesa_Uniform1uiv(GLint location, GLsizei count, const GLuint *value)

+{

+   GET_CURRENT_CONTEXT(ctx);

+   _mesa_uniform(ctx, ctx->Shader.ActiveProgram, location, count, value, GL_UNSIGNED_INT);

+}

+

+void GLAPIENTRY

+_mesa_Uniform2uiv(GLint location, GLsizei count, const GLuint *value)

+{

+   GET_CURRENT_CONTEXT(ctx);

+   _mesa_uniform(ctx, ctx->Shader.ActiveProgram, location, count, value, GL_UNSIGNED_INT_VEC2);

+}

+

+void GLAPIENTRY

+_mesa_Uniform3uiv(GLint location, GLsizei count, const GLuint *value)

+{

+   GET_CURRENT_CONTEXT(ctx);

+   _mesa_uniform(ctx, ctx->Shader.ActiveProgram, location, count, value, GL_UNSIGNED_INT_VEC3);

+}

+

+void GLAPIENTRY

+_mesa_Uniform4uiv(GLint location, GLsizei count, const GLuint *value)

+{

+   GET_CURRENT_CONTEXT(ctx);

+   _mesa_uniform(ctx, ctx->Shader.ActiveProgram, location, count, value, GL_UNSIGNED_INT_VEC4);

+}

+

+

+

+void GLAPIENTRY

+_mesa_UniformMatrix2fvARB(GLint location, GLsizei count, GLboolean transpose,

+                          const GLfloat * value)

+{

+   GET_CURRENT_CONTEXT(ctx);

+   _mesa_uniform_matrix(ctx, ctx->Shader.ActiveProgram,

+			2, 2, location, count, transpose, value);

+}

+

+void GLAPIENTRY

+_mesa_UniformMatrix3fvARB(GLint location, GLsizei count, GLboolean transpose,

+                          const GLfloat * value)

+{

+   GET_CURRENT_CONTEXT(ctx);

+   _mesa_uniform_matrix(ctx, ctx->Shader.ActiveProgram,

+			3, 3, location, count, transpose, value);

+}

+

+void GLAPIENTRY

+_mesa_UniformMatrix4fvARB(GLint location, GLsizei count, GLboolean transpose,

+                          const GLfloat * value)

+{

+   GET_CURRENT_CONTEXT(ctx);

+   _mesa_uniform_matrix(ctx, ctx->Shader.ActiveProgram,

+			4, 4, location, count, transpose, value);

+}

+

+

+/**

+ * Non-square UniformMatrix are OpenGL 2.1

+ */

+void GLAPIENTRY

+_mesa_UniformMatrix2x3fv(GLint location, GLsizei count, GLboolean transpose,

+                         const GLfloat *value)

+{

+   GET_CURRENT_CONTEXT(ctx);

+   _mesa_uniform_matrix(ctx, ctx->Shader.ActiveProgram,

+			2, 3, location, count, transpose, value);

+}

+

+void GLAPIENTRY

+_mesa_UniformMatrix3x2fv(GLint location, GLsizei count, GLboolean transpose,

+                         const GLfloat *value)

+{

+   GET_CURRENT_CONTEXT(ctx);

+   _mesa_uniform_matrix(ctx, ctx->Shader.ActiveProgram,

+			3, 2, location, count, transpose, value);

+}

+

+void GLAPIENTRY

+_mesa_UniformMatrix2x4fv(GLint location, GLsizei count, GLboolean transpose,

+                         const GLfloat *value)

+{

+   GET_CURRENT_CONTEXT(ctx);

+   _mesa_uniform_matrix(ctx, ctx->Shader.ActiveProgram,

+			2, 4, location, count, transpose, value);

+}

+

+void GLAPIENTRY

+_mesa_UniformMatrix4x2fv(GLint location, GLsizei count, GLboolean transpose,

+                         const GLfloat *value)

+{

+   GET_CURRENT_CONTEXT(ctx);

+   _mesa_uniform_matrix(ctx, ctx->Shader.ActiveProgram,

+			4, 2, location, count, transpose, value);

+}

+

+void GLAPIENTRY

+_mesa_UniformMatrix3x4fv(GLint location, GLsizei count, GLboolean transpose,

+                         const GLfloat *value)

+{

+   GET_CURRENT_CONTEXT(ctx);

+   _mesa_uniform_matrix(ctx, ctx->Shader.ActiveProgram,

+			3, 4, location, count, transpose, value);

+}

+

+void GLAPIENTRY

+_mesa_UniformMatrix4x3fv(GLint location, GLsizei count, GLboolean transpose,

+                         const GLfloat *value)

+{

+   GET_CURRENT_CONTEXT(ctx);

+   _mesa_uniform_matrix(ctx, ctx->Shader.ActiveProgram,

+			4, 3, location, count, transpose, value);

+}

+

+

+void GLAPIENTRY

+_mesa_GetUniformfvARB(GLhandleARB program, GLint location, GLfloat *params)

+{

+   GET_CURRENT_CONTEXT(ctx);

+   _mesa_get_uniformfv(ctx, program, location, params);

+}

+

+

+void GLAPIENTRY

+_mesa_GetUniformivARB(GLhandleARB program, GLint location, GLint *params)

+{

+   GET_CURRENT_CONTEXT(ctx);

+   _mesa_get_uniformiv(ctx, program, location, params);

+}

+

+

+/* GL3 */

+void GLAPIENTRY

+_mesa_GetUniformuiv(GLhandleARB program, GLint location, GLuint *params)

+{

+   GET_CURRENT_CONTEXT(ctx);

+   _mesa_get_uniformuiv(ctx, program, location, params);

+}

+

+

+

+GLint GLAPIENTRY

+_mesa_GetUniformLocationARB(GLhandleARB programObj, const GLcharARB *name)

+{

+   struct gl_shader_program *shProg;

+

+   GET_CURRENT_CONTEXT(ctx);

+

+   shProg = _mesa_lookup_shader_program_err(ctx, programObj,

+					    "glGetUniformLocation");

+   if (!shProg)

+      return -1;

+

+   return _mesa_get_uniform_location(ctx, shProg, name);

+}

+

+

+void GLAPIENTRY

+_mesa_GetActiveUniformARB(GLhandleARB program, GLuint index,

+                          GLsizei maxLength, GLsizei * length, GLint * size,

+                          GLenum * type, GLcharARB * name)

+{

+   GET_CURRENT_CONTEXT(ctx);

+   _mesa_get_active_uniform(ctx, program, index, maxLength, length, size,

+                            type, name);

+}

+

+

+/**

+ * Plug in shader uniform-related functions into API dispatch table.

+ */

+void

+_mesa_init_shader_uniform_dispatch(struct _glapi_table *exec)

+{

+#if FEATURE_GL

+   SET_Uniform1fARB(exec, _mesa_Uniform1fARB);

+   SET_Uniform2fARB(exec, _mesa_Uniform2fARB);

+   SET_Uniform3fARB(exec, _mesa_Uniform3fARB);

+   SET_Uniform4fARB(exec, _mesa_Uniform4fARB);

+   SET_Uniform1iARB(exec, _mesa_Uniform1iARB);

+   SET_Uniform2iARB(exec, _mesa_Uniform2iARB);

+   SET_Uniform3iARB(exec, _mesa_Uniform3iARB);

+   SET_Uniform4iARB(exec, _mesa_Uniform4iARB);

+   SET_Uniform1fvARB(exec, _mesa_Uniform1fvARB);

+   SET_Uniform2fvARB(exec, _mesa_Uniform2fvARB);

+   SET_Uniform3fvARB(exec, _mesa_Uniform3fvARB);

+   SET_Uniform4fvARB(exec, _mesa_Uniform4fvARB);

+   SET_Uniform1ivARB(exec, _mesa_Uniform1ivARB);

+   SET_Uniform2ivARB(exec, _mesa_Uniform2ivARB);

+   SET_Uniform3ivARB(exec, _mesa_Uniform3ivARB);

+   SET_Uniform4ivARB(exec, _mesa_Uniform4ivARB);

+   SET_UniformMatrix2fvARB(exec, _mesa_UniformMatrix2fvARB);

+   SET_UniformMatrix3fvARB(exec, _mesa_UniformMatrix3fvARB);

+   SET_UniformMatrix4fvARB(exec, _mesa_UniformMatrix4fvARB);

+

+   SET_GetActiveUniformARB(exec, _mesa_GetActiveUniformARB);

+   SET_GetUniformLocationARB(exec, _mesa_GetUniformLocationARB);

+   SET_GetUniformfvARB(exec, _mesa_GetUniformfvARB);

+   SET_GetUniformivARB(exec, _mesa_GetUniformivARB);

+

+   /* OpenGL 2.1 */

+   SET_UniformMatrix2x3fv(exec, _mesa_UniformMatrix2x3fv);

+   SET_UniformMatrix3x2fv(exec, _mesa_UniformMatrix3x2fv);

+   SET_UniformMatrix2x4fv(exec, _mesa_UniformMatrix2x4fv);

+   SET_UniformMatrix4x2fv(exec, _mesa_UniformMatrix4x2fv);

+   SET_UniformMatrix3x4fv(exec, _mesa_UniformMatrix3x4fv);

+   SET_UniformMatrix4x3fv(exec, _mesa_UniformMatrix4x3fv);

+

+   /* OpenGL 3.0 */

+   /* XXX finish dispatch */

+   SET_Uniform1uiEXT(exec, _mesa_Uniform1ui);

+   SET_Uniform2uiEXT(exec, _mesa_Uniform2ui);

+   SET_Uniform3uiEXT(exec, _mesa_Uniform3ui);

+   SET_Uniform4uiEXT(exec, _mesa_Uniform4ui);

+   SET_Uniform1uivEXT(exec, _mesa_Uniform1uiv);

+   SET_Uniform2uivEXT(exec, _mesa_Uniform2uiv);

+   SET_Uniform3uivEXT(exec, _mesa_Uniform3uiv);

+   SET_Uniform4uivEXT(exec, _mesa_Uniform4uiv);

+   SET_GetUniformuivEXT(exec, _mesa_GetUniformuiv);

+

+

+#endif /* FEATURE_GL */

+}

diff --git a/mesalib/src/mesa/program/ir_to_mesa.cpp b/mesalib/src/mesa/program/ir_to_mesa.cpp
index 0255b576c..a7bafb50b 100644
--- a/mesalib/src/mesa/program/ir_to_mesa.cpp
+++ b/mesalib/src/mesa/program/ir_to_mesa.cpp
@@ -2406,6 +2406,11 @@ print_program(struct prog_instruction *mesa_instructions,
    }

 }

 

+

+/**

+ * Count resources used by the given gpu program (number of texture

+ * samplers, etc).

+ */

 static void

 count_resources(struct gl_program *prog)

 {

@@ -2429,6 +2434,57 @@ count_resources(struct gl_program *prog)
    _mesa_update_shader_textures_used(prog);

 }

 

+

+/**

+ * Check if the given vertex/fragment/shader program is within the

+ * resource limits of the context (number of texture units, etc).

+ * If any of those checks fail, record a linker error.

+ *

+ * XXX more checks are needed...

+ */

+static void

+check_resources(const struct gl_context *ctx,

+                struct gl_shader_program *shader_program,

+                struct gl_program *prog)

+{

+   switch (prog->Target) {

+   case GL_VERTEX_PROGRAM_ARB:

+      if (_mesa_bitcount(prog->SamplersUsed) >

+          ctx->Const.MaxVertexTextureImageUnits) {

+         fail_link(shader_program, "Too many vertex shader texture samplers");

+      }

+      if (prog->Parameters->NumParameters >

+          ctx->Const.VertexProgram.MaxUniformComponents / 4) {

+         fail_link(shader_program, "Too many vertex shader constants");

+      }

+      break;

+   case MESA_GEOMETRY_PROGRAM:

+      if (_mesa_bitcount(prog->SamplersUsed) >

+          ctx->Const.MaxGeometryTextureImageUnits) {

+         fail_link(shader_program, "Too many geometry shader texture samplers");

+      }

+      if (prog->Parameters->NumParameters >

+          ctx->Const.GeometryProgram.MaxUniformComponents / 4) {

+         fail_link(shader_program, "Too many geometry shader constants");

+      }

+      break;

+   case GL_FRAGMENT_PROGRAM_ARB:

+      if (_mesa_bitcount(prog->SamplersUsed) >

+          ctx->Const.MaxTextureImageUnits) {

+         fail_link(shader_program, "Too many fragment shader texture samplers");

+      }

+      if (prog->Parameters->NumParameters >

+          ctx->Const.FragmentProgram.MaxUniformComponents / 4) {

+         fail_link(shader_program, "Too many fragment shader constants");

+      }

+      break;

+   default:

+      _mesa_problem(ctx, "unexpected program type in check_resources()");

+   }

+}

+

+

+

 struct uniform_sort {

    struct gl_uniform *u;

    int pos;

@@ -3026,6 +3082,8 @@ get_mesa_program(struct gl_context *ctx,
    do_set_program_inouts(shader->ir, prog);

    count_resources(prog);

 

+   check_resources(ctx, shader_program, prog);

+

    _mesa_reference_program(ctx, &shader->Program, prog);

 

    if ((ctx->Shader.Flags & GLSL_NO_OPT) == 0) {

diff --git a/mesalib/src/mesa/program/prog_cache.c b/mesalib/src/mesa/program/prog_cache.c
index 93612b4a0..398cd5e6d 100644
--- a/mesalib/src/mesa/program/prog_cache.c
+++ b/mesalib/src/mesa/program/prog_cache.c
@@ -29,6 +29,7 @@
 #include "main/glheader.h"

 #include "main/mtypes.h"

 #include "main/imports.h"

+#include "main/shaderobj.h"

 #include "program/prog_cache.h"

 #include "program/program.h"

 

@@ -104,7 +105,8 @@ rehash(struct gl_program_cache *cache)
 

 

 static void

-clear_cache(struct gl_context *ctx, struct gl_program_cache *cache)

+clear_cache(struct gl_context *ctx, struct gl_program_cache *cache,

+	    GLboolean shader)

 {

    struct cache_item *c, *next;

    GLuint i;

@@ -115,7 +117,13 @@ clear_cache(struct gl_context *ctx, struct gl_program_cache *cache)
       for (c = cache->items[i]; c; c = next) {

 	 next = c->next;

 	 free(c->key);

-         _mesa_reference_program(ctx, &c->program, NULL);

+	 if (shader) {

+	    _mesa_reference_shader_program(ctx,

+					   (struct gl_shader_program **)&c->program,

+					   NULL);

+	 } else {

+	    _mesa_reference_program(ctx, &c->program, NULL);

+	 }

 	 free(c);

       }

       cache->items[i] = NULL;

@@ -147,7 +155,16 @@ _mesa_new_program_cache(void)
 void

 _mesa_delete_program_cache(struct gl_context *ctx, struct gl_program_cache *cache)

 {

-   clear_cache(ctx, cache);

+   clear_cache(ctx, cache, GL_FALSE);

+   free(cache->items);

+   free(cache);

+}

+

+void

+_mesa_delete_shader_cache(struct gl_context *ctx,

+			  struct gl_program_cache *cache)

+{

+   clear_cache(ctx, cache, GL_TRUE);

    free(cache->items);

    free(cache);

 }

@@ -197,7 +214,35 @@ _mesa_program_cache_insert(struct gl_context *ctx,
       if (cache->size < 1000)

 	 rehash(cache);

       else 

-	 clear_cache(ctx, cache);

+	 clear_cache(ctx, cache, GL_FALSE);

+   }

+

+   cache->n_items++;

+   c->next = cache->items[hash % cache->size];

+   cache->items[hash % cache->size] = c;

+}

+

+void

+_mesa_shader_cache_insert(struct gl_context *ctx,

+			  struct gl_program_cache *cache,

+			  const void *key, GLuint keysize,

+			  struct gl_shader_program *program)

+{

+   const GLuint hash = hash_key(key, keysize);

+   struct cache_item *c = CALLOC_STRUCT(cache_item);

+

+   c->hash = hash;

+

+   c->key = malloc(keysize);

+   memcpy(c->key, key, keysize);

+

+   c->program = (struct gl_program *)program;  /* no refcount change */

+

+   if (cache->n_items > cache->size * 1.5) {

+      if (cache->size < 1000)

+	 rehash(cache);

+      else

+	 clear_cache(ctx, cache, GL_TRUE);

    }

 

    cache->n_items++;

diff --git a/mesalib/src/mesa/program/prog_cache.h b/mesalib/src/mesa/program/prog_cache.h
index aae2b7df2..e7ec8d39a 100644
--- a/mesalib/src/mesa/program/prog_cache.h
+++ b/mesalib/src/mesa/program/prog_cache.h
@@ -44,6 +44,9 @@ _mesa_new_program_cache(void);
 extern void

 _mesa_delete_program_cache(struct gl_context *ctx, struct gl_program_cache *pc);

 

+extern void

+_mesa_delete_shader_cache(struct gl_context *ctx,

+			  struct gl_program_cache *cache);

 

 extern struct gl_program *

 _mesa_search_program_cache(struct gl_program_cache *cache,

@@ -55,5 +58,11 @@ _mesa_program_cache_insert(struct gl_context *ctx,
                            const void *key, GLuint keysize,

                            struct gl_program *program);

 

+void

+_mesa_shader_cache_insert(struct gl_context *ctx,

+			  struct gl_program_cache *cache,

+			  const void *key, GLuint keysize,

+			  struct gl_shader_program *program);

+

 

 #endif /* PROG_CACHE_H */

diff --git a/mesalib/src/mesa/program/program.c b/mesalib/src/mesa/program/program.c
index cfdd0da86..43f894a9b 100644
--- a/mesalib/src/mesa/program/program.c
+++ b/mesalib/src/mesa/program/program.c
@@ -1,1077 +1,1077 @@
-/*
- * Mesa 3-D graphics library
- * Version:  6.5.3
- *
- * Copyright (C) 1999-2007  Brian Paul   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 program.c
- * Vertex and fragment program support functions.
- * \author Brian Paul
- */
-
-
-#include "main/glheader.h"
-#include "main/context.h"
-#include "main/hash.h"
-#include "main/mfeatures.h"
-#include "program.h"
-#include "prog_cache.h"
-#include "prog_parameter.h"
-#include "prog_instruction.h"
-
-
-/**
- * A pointer to this dummy program is put into the hash table when
- * glGenPrograms is called.
- */
-struct gl_program _mesa_DummyProgram;
-
-
-/**
- * Init context's vertex/fragment program state
- */
-void
-_mesa_init_program(struct gl_context *ctx)
-{
-   GLuint i;
-
-   /*
-    * If this assertion fails, we need to increase the field
-    * size for register indexes (see INST_INDEX_BITS).
-    */
-   ASSERT(ctx->Const.VertexProgram.MaxUniformComponents / 4
-          <= (1 << INST_INDEX_BITS));
-   ASSERT(ctx->Const.FragmentProgram.MaxUniformComponents / 4
-          <= (1 << INST_INDEX_BITS));
-
-   ASSERT(ctx->Const.VertexProgram.MaxTemps <= (1 << INST_INDEX_BITS));
-   ASSERT(ctx->Const.VertexProgram.MaxLocalParams <= (1 << INST_INDEX_BITS));
-   ASSERT(ctx->Const.FragmentProgram.MaxTemps <= (1 << INST_INDEX_BITS));
-   ASSERT(ctx->Const.FragmentProgram.MaxLocalParams <= (1 << INST_INDEX_BITS));
-
-   ASSERT(ctx->Const.VertexProgram.MaxUniformComponents <= 4 * MAX_UNIFORMS);
-   ASSERT(ctx->Const.FragmentProgram.MaxUniformComponents <= 4 * MAX_UNIFORMS);
-
-   ASSERT(ctx->Const.VertexProgram.MaxAddressOffset <= (1 << INST_INDEX_BITS));
-   ASSERT(ctx->Const.FragmentProgram.MaxAddressOffset <= (1 << INST_INDEX_BITS));
-
-   /* If this fails, increase prog_instruction::TexSrcUnit size */
-   ASSERT(MAX_TEXTURE_UNITS < (1 << 5));
-
-   /* If this fails, increase prog_instruction::TexSrcTarget size */
-   ASSERT(NUM_TEXTURE_TARGETS < (1 << 3));
-
-   ctx->Program.ErrorPos = -1;
-   ctx->Program.ErrorString = _mesa_strdup("");
-
-#if FEATURE_NV_vertex_program || FEATURE_ARB_vertex_program
-   ctx->VertexProgram.Enabled = GL_FALSE;
-#if FEATURE_es2_glsl
-   ctx->VertexProgram.PointSizeEnabled =
-      (ctx->API == API_OPENGLES2) ? GL_TRUE : GL_FALSE;
-#else
-   ctx->VertexProgram.PointSizeEnabled = GL_FALSE;
-#endif
-   ctx->VertexProgram.TwoSideEnabled = GL_FALSE;
-   _mesa_reference_vertprog(ctx, &ctx->VertexProgram.Current,
-                            ctx->Shared->DefaultVertexProgram);
-   assert(ctx->VertexProgram.Current);
-   for (i = 0; i < MAX_NV_VERTEX_PROGRAM_PARAMS / 4; i++) {
-      ctx->VertexProgram.TrackMatrix[i] = GL_NONE;
-      ctx->VertexProgram.TrackMatrixTransform[i] = GL_IDENTITY_NV;
-   }
-   ctx->VertexProgram.Cache = _mesa_new_program_cache();
-#endif
-
-#if FEATURE_NV_fragment_program || FEATURE_ARB_fragment_program
-   ctx->FragmentProgram.Enabled = GL_FALSE;
-   _mesa_reference_fragprog(ctx, &ctx->FragmentProgram.Current,
-                            ctx->Shared->DefaultFragmentProgram);
-   assert(ctx->FragmentProgram.Current);
-   ctx->FragmentProgram.Cache = _mesa_new_program_cache();
-#endif
-
-#if FEATURE_ARB_geometry_shader4
-   ctx->GeometryProgram.Enabled = GL_FALSE;
-   /* right now by default we don't have a geometry program */
-   _mesa_reference_geomprog(ctx, &ctx->GeometryProgram.Current,
-                            NULL);
-   ctx->GeometryProgram.Cache = _mesa_new_program_cache();
-#endif
-
-   /* XXX probably move this stuff */
-#if FEATURE_ATI_fragment_shader
-   ctx->ATIFragmentShader.Enabled = GL_FALSE;
-   ctx->ATIFragmentShader.Current = ctx->Shared->DefaultFragmentShader;
-   assert(ctx->ATIFragmentShader.Current);
-   ctx->ATIFragmentShader.Current->RefCount++;
-#endif
-}
-
-
-/**
- * Free a context's vertex/fragment program state
- */
-void
-_mesa_free_program_data(struct gl_context *ctx)
-{
-#if FEATURE_NV_vertex_program || FEATURE_ARB_vertex_program
-   _mesa_reference_vertprog(ctx, &ctx->VertexProgram.Current, NULL);
-   _mesa_delete_program_cache(ctx, ctx->VertexProgram.Cache);
-#endif
-#if FEATURE_NV_fragment_program || FEATURE_ARB_fragment_program
-   _mesa_reference_fragprog(ctx, &ctx->FragmentProgram.Current, NULL);
-   _mesa_delete_program_cache(ctx, ctx->FragmentProgram.Cache);
-#endif
-#if FEATURE_ARB_geometry_shader4
-   _mesa_reference_geomprog(ctx, &ctx->GeometryProgram.Current, NULL);
-   _mesa_delete_program_cache(ctx, ctx->GeometryProgram.Cache);
-#endif
-   /* XXX probably move this stuff */
-#if FEATURE_ATI_fragment_shader
-   if (ctx->ATIFragmentShader.Current) {
-      ctx->ATIFragmentShader.Current->RefCount--;
-      if (ctx->ATIFragmentShader.Current->RefCount <= 0) {
-         free(ctx->ATIFragmentShader.Current);
-      }
-   }
-#endif
-   free((void *) ctx->Program.ErrorString);
-}
-
-
-/**
- * Update the default program objects in the given context to reference those
- * specified in the shared state and release those referencing the old
- * shared state.
- */
-void
-_mesa_update_default_objects_program(struct gl_context *ctx)
-{
-#if FEATURE_NV_vertex_program || FEATURE_ARB_vertex_program
-   _mesa_reference_vertprog(ctx, &ctx->VertexProgram.Current,
-                            (struct gl_vertex_program *)
-                            ctx->Shared->DefaultVertexProgram);
-   assert(ctx->VertexProgram.Current);
-#endif
-
-#if FEATURE_NV_fragment_program || FEATURE_ARB_fragment_program
-   _mesa_reference_fragprog(ctx, &ctx->FragmentProgram.Current,
-                            (struct gl_fragment_program *)
-                            ctx->Shared->DefaultFragmentProgram);
-   assert(ctx->FragmentProgram.Current);
-#endif
-
-#if FEATURE_ARB_geometry_shader4
-   _mesa_reference_geomprog(ctx, &ctx->GeometryProgram.Current,
-                            (struct gl_geometry_program *)
-                            ctx->Shared->DefaultGeometryProgram);
-#endif
-
-   /* XXX probably move this stuff */
-#if FEATURE_ATI_fragment_shader
-   if (ctx->ATIFragmentShader.Current) {
-      ctx->ATIFragmentShader.Current->RefCount--;
-      if (ctx->ATIFragmentShader.Current->RefCount <= 0) {
-         free(ctx->ATIFragmentShader.Current);
-      }
-   }
-   ctx->ATIFragmentShader.Current = (struct ati_fragment_shader *) ctx->Shared->DefaultFragmentShader;
-   assert(ctx->ATIFragmentShader.Current);
-   ctx->ATIFragmentShader.Current->RefCount++;
-#endif
-}
-
-
-/**
- * Set the vertex/fragment program error state (position and error string).
- * This is generally called from within the parsers.
- */
-void
-_mesa_set_program_error(struct gl_context *ctx, GLint pos, const char *string)
-{
-   ctx->Program.ErrorPos = pos;
-   free((void *) ctx->Program.ErrorString);
-   if (!string)
-      string = "";
-   ctx->Program.ErrorString = _mesa_strdup(string);
-}
-
-
-/**
- * Find the line number and column for 'pos' within 'string'.
- * Return a copy of the line which contains 'pos'.  Free the line with
- * free().
- * \param string  the program string
- * \param pos     the position within the string
- * \param line    returns the line number corresponding to 'pos'.
- * \param col     returns the column number corresponding to 'pos'.
- * \return copy of the line containing 'pos'.
- */
-const GLubyte *
-_mesa_find_line_column(const GLubyte *string, const GLubyte *pos,
-                       GLint *line, GLint *col)
-{
-   const GLubyte *lineStart = string;
-   const GLubyte *p = string;
-   GLubyte *s;
-   int len;
-
-   *line = 1;
-
-   while (p != pos) {
-      if (*p == (GLubyte) '\n') {
-         (*line)++;
-         lineStart = p + 1;
-      }
-      p++;
-   }
-
-   *col = (pos - lineStart) + 1;
-
-   /* return copy of this line */
-   while (*p != 0 && *p != '\n')
-      p++;
-   len = p - lineStart;
-   s = (GLubyte *) malloc(len + 1);
-   memcpy(s, lineStart, len);
-   s[len] = 0;
-
-   return s;
-}
-
-
-/**
- * Initialize a new vertex/fragment program object.
- */
-static struct gl_program *
-_mesa_init_program_struct( struct gl_context *ctx, struct gl_program *prog,
-                           GLenum target, GLuint id)
-{
-   (void) ctx;
-   if (prog) {
-      GLuint i;
-      memset(prog, 0, sizeof(*prog));
-      prog->Id = id;
-      prog->Target = target;
-      prog->Resident = GL_TRUE;
-      prog->RefCount = 1;
-      prog->Format = GL_PROGRAM_FORMAT_ASCII_ARB;
-
-      /* default mapping from samplers to texture units */
-      for (i = 0; i < MAX_SAMPLERS; i++)
-         prog->SamplerUnits[i] = i;
-   }
-
-   return prog;
-}
-
-
-/**
- * Initialize a new fragment program object.
- */
-struct gl_program *
-_mesa_init_fragment_program( struct gl_context *ctx, struct gl_fragment_program *prog,
-                             GLenum target, GLuint id)
-{
-   if (prog)
-      return _mesa_init_program_struct( ctx, &prog->Base, target, id );
-   else
-      return NULL;
-}
-
-
-/**
- * Initialize a new vertex program object.
- */
-struct gl_program *
-_mesa_init_vertex_program( struct gl_context *ctx, struct gl_vertex_program *prog,
-                           GLenum target, GLuint id)
-{
-   if (prog)
-      return _mesa_init_program_struct( ctx, &prog->Base, target, id );
-   else
-      return NULL;
-}
-
-
-/**
- * Initialize a new geometry program object.
- */
-struct gl_program *
-_mesa_init_geometry_program( struct gl_context *ctx, struct gl_geometry_program *prog,
-                             GLenum target, GLuint id)
-{
-   if (prog)
-      return _mesa_init_program_struct( ctx, &prog->Base, target, id );
-   else
-      return NULL;
-}
-
-
-/**
- * Allocate and initialize a new fragment/vertex program object but
- * don't put it into the program hash table.  Called via
- * ctx->Driver.NewProgram.  May be overridden (ie. replaced) by a
- * device driver function to implement OO deriviation with additional
- * types not understood by this function.
- *
- * \param ctx  context
- * \param id   program id/number
- * \param target  program target/type
- * \return  pointer to new program object
- */
-struct gl_program *
-_mesa_new_program(struct gl_context *ctx, GLenum target, GLuint id)
-{
-   struct gl_program *prog;
-   switch (target) {
-   case GL_VERTEX_PROGRAM_ARB: /* == GL_VERTEX_PROGRAM_NV */
-   case GL_VERTEX_STATE_PROGRAM_NV:
-      prog = _mesa_init_vertex_program(ctx, CALLOC_STRUCT(gl_vertex_program),
-                                       target, id );
-      break;
-   case GL_FRAGMENT_PROGRAM_NV:
-   case GL_FRAGMENT_PROGRAM_ARB:
-      prog =_mesa_init_fragment_program(ctx,
-                                         CALLOC_STRUCT(gl_fragment_program),
-                                         target, id );
-      break;
-   case MESA_GEOMETRY_PROGRAM:
-      prog = _mesa_init_geometry_program(ctx,
-                                         CALLOC_STRUCT(gl_geometry_program),
-                                         target, id);
-      break;
-   default:
-      _mesa_problem(ctx, "bad target in _mesa_new_program");
-      prog = NULL;
-   }
-   return prog;
-}
-
-
-/**
- * Delete a program and remove it from the hash table, ignoring the
- * reference count.
- * Called via ctx->Driver.DeleteProgram.  May be wrapped (OO deriviation)
- * by a device driver function.
- */
-void
-_mesa_delete_program(struct gl_context *ctx, struct gl_program *prog)
-{
-   (void) ctx;
-   ASSERT(prog);
-   ASSERT(prog->RefCount==0);
-
-   if (prog == &_mesa_DummyProgram)
-      return;
-
-   if (prog->String)
-      free(prog->String);
-
-   _mesa_free_instructions(prog->Instructions, prog->NumInstructions);
-
-   if (prog->Parameters) {
-      _mesa_free_parameter_list(prog->Parameters);
-   }
-   if (prog->Varying) {
-      _mesa_free_parameter_list(prog->Varying);
-   }
-   if (prog->Attributes) {
-      _mesa_free_parameter_list(prog->Attributes);
-   }
-
-   free(prog);
-}
-
-
-/**
- * Return the gl_program object for a given ID.
- * Basically just a wrapper for _mesa_HashLookup() to avoid a lot of
- * casts elsewhere.
- */
-struct gl_program *
-_mesa_lookup_program(struct gl_context *ctx, GLuint id)
-{
-   if (id)
-      return (struct gl_program *) _mesa_HashLookup(ctx->Shared->Programs, id);
-   else
-      return NULL;
-}
-
-
-/**
- * Reference counting for vertex/fragment programs
- */
-void
-_mesa_reference_program(struct gl_context *ctx,
-                        struct gl_program **ptr,
-                        struct gl_program *prog)
-{
-   assert(ptr);
-   if (*ptr && prog) {
-      /* sanity check */
-      if ((*ptr)->Target == GL_VERTEX_PROGRAM_ARB)
-         ASSERT(prog->Target == GL_VERTEX_PROGRAM_ARB);
-      else if ((*ptr)->Target == GL_FRAGMENT_PROGRAM_ARB)
-         ASSERT(prog->Target == GL_FRAGMENT_PROGRAM_ARB ||
-                prog->Target == GL_FRAGMENT_PROGRAM_NV);
-      else if ((*ptr)->Target == MESA_GEOMETRY_PROGRAM)
-         ASSERT(prog->Target == MESA_GEOMETRY_PROGRAM);
-   }
-   if (*ptr == prog) {
-      return;  /* no change */
-   }
-   if (*ptr) {
-      GLboolean deleteFlag;
-
-      /*_glthread_LOCK_MUTEX((*ptr)->Mutex);*/
-#if 0
-      printf("Program %p ID=%u Target=%s  Refcount-- to %d\n",
-             *ptr, (*ptr)->Id,
-             ((*ptr)->Target == GL_VERTEX_PROGRAM_ARB ? "VP" :
-              ((*ptr)->Target == MESA_GEOMETRY_PROGRAM ? "GP" : "FP")),
-             (*ptr)->RefCount - 1);
-#endif
-      ASSERT((*ptr)->RefCount > 0);
-      (*ptr)->RefCount--;
-
-      deleteFlag = ((*ptr)->RefCount == 0);
-      /*_glthread_UNLOCK_MUTEX((*ptr)->Mutex);*/
-
-      if (deleteFlag) {
-         ASSERT(ctx);
-         ctx->Driver.DeleteProgram(ctx, *ptr);
-      }
-
-      *ptr = NULL;
-   }
-
-   assert(!*ptr);
-   if (prog) {
-      /*_glthread_LOCK_MUTEX(prog->Mutex);*/
-      prog->RefCount++;
-#if 0
-      printf("Program %p ID=%u Target=%s  Refcount++ to %d\n",
-             prog, prog->Id,
-             (prog->Target == GL_VERTEX_PROGRAM_ARB ? "VP" :
-              (prog->Target == MESA_GEOMETRY_PROGRAM ? "GP" : "FP")),
-             prog->RefCount);
-#endif
-      /*_glthread_UNLOCK_MUTEX(prog->Mutex);*/
-   }
-
-   *ptr = prog;
-}
-
-
-/**
- * Return a copy of a program.
- * XXX Problem here if the program object is actually OO-derivation
- * made by a device driver.
- */
-struct gl_program *
-_mesa_clone_program(struct gl_context *ctx, const struct gl_program *prog)
-{
-   struct gl_program *clone;
-
-   clone = ctx->Driver.NewProgram(ctx, prog->Target, prog->Id);
-   if (!clone)
-      return NULL;
-
-   assert(clone->Target == prog->Target);
-   assert(clone->RefCount == 1);
-
-   clone->String = (GLubyte *) _mesa_strdup((char *) prog->String);
-   clone->Format = prog->Format;
-   clone->Instructions = _mesa_alloc_instructions(prog->NumInstructions);
-   if (!clone->Instructions) {
-      _mesa_reference_program(ctx, &clone, NULL);
-      return NULL;
-   }
-   _mesa_copy_instructions(clone->Instructions, prog->Instructions,
-                           prog->NumInstructions);
-   clone->InputsRead = prog->InputsRead;
-   clone->OutputsWritten = prog->OutputsWritten;
-   clone->SamplersUsed = prog->SamplersUsed;
-   clone->ShadowSamplers = prog->ShadowSamplers;
-   memcpy(clone->TexturesUsed, prog->TexturesUsed, sizeof(prog->TexturesUsed));
-
-   if (prog->Parameters)
-      clone->Parameters = _mesa_clone_parameter_list(prog->Parameters);
-   memcpy(clone->LocalParams, prog->LocalParams, sizeof(clone->LocalParams));
-   if (prog->Varying)
-      clone->Varying = _mesa_clone_parameter_list(prog->Varying);
-   if (prog->Attributes)
-      clone->Attributes = _mesa_clone_parameter_list(prog->Attributes);
-   memcpy(clone->LocalParams, prog->LocalParams, sizeof(clone->LocalParams));
-   clone->IndirectRegisterFiles = prog->IndirectRegisterFiles;
-   clone->NumInstructions = prog->NumInstructions;
-   clone->NumTemporaries = prog->NumTemporaries;
-   clone->NumParameters = prog->NumParameters;
-   clone->NumAttributes = prog->NumAttributes;
-   clone->NumAddressRegs = prog->NumAddressRegs;
-   clone->NumNativeInstructions = prog->NumNativeInstructions;
-   clone->NumNativeTemporaries = prog->NumNativeTemporaries;
-   clone->NumNativeParameters = prog->NumNativeParameters;
-   clone->NumNativeAttributes = prog->NumNativeAttributes;
-   clone->NumNativeAddressRegs = prog->NumNativeAddressRegs;
-   clone->NumAluInstructions = prog->NumAluInstructions;
-   clone->NumTexInstructions = prog->NumTexInstructions;
-   clone->NumTexIndirections = prog->NumTexIndirections;
-   clone->NumNativeAluInstructions = prog->NumNativeAluInstructions;
-   clone->NumNativeTexInstructions = prog->NumNativeTexInstructions;
-   clone->NumNativeTexIndirections = prog->NumNativeTexIndirections;
-
-   switch (prog->Target) {
-   case GL_VERTEX_PROGRAM_ARB:
-      {
-         const struct gl_vertex_program *vp
-            = (const struct gl_vertex_program *) prog;
-         struct gl_vertex_program *vpc = (struct gl_vertex_program *) clone;
-         vpc->IsPositionInvariant = vp->IsPositionInvariant;
-         vpc->IsNVProgram = vp->IsNVProgram;
-      }
-      break;
-   case GL_FRAGMENT_PROGRAM_ARB:
-      {
-         const struct gl_fragment_program *fp
-            = (const struct gl_fragment_program *) prog;
-         struct gl_fragment_program *fpc = (struct gl_fragment_program *) clone;
-         fpc->FogOption = fp->FogOption;
-         fpc->UsesKill = fp->UsesKill;
-         fpc->OriginUpperLeft = fp->OriginUpperLeft;
-         fpc->PixelCenterInteger = fp->PixelCenterInteger;
-      }
-      break;
-   case MESA_GEOMETRY_PROGRAM:
-      {
-         const struct gl_geometry_program *gp
-            = (const struct gl_geometry_program *) prog;
-         struct gl_geometry_program *gpc = (struct gl_geometry_program *) clone;
-         gpc->VerticesOut = gp->VerticesOut;
-         gpc->InputType = gp->InputType;
-         gpc->OutputType = gp->OutputType;
-      }
-      break;
-   default:
-      _mesa_problem(NULL, "Unexpected target in _mesa_clone_program");
-   }
-
-   return clone;
-}
-
-
-/**
- * Insert 'count' NOP instructions at 'start' in the given program.
- * Adjust branch targets accordingly.
- */
-GLboolean
-_mesa_insert_instructions(struct gl_program *prog, GLuint start, GLuint count)
-{
-   const GLuint origLen = prog->NumInstructions;
-   const GLuint newLen = origLen + count;
-   struct prog_instruction *newInst;
-   GLuint i;
-
-   /* adjust branches */
-   for (i = 0; i < prog->NumInstructions; i++) {
-      struct prog_instruction *inst = prog->Instructions + i;
-      if (inst->BranchTarget > 0) {
-         if ((GLuint)inst->BranchTarget >= start) {
-            inst->BranchTarget += count;
-         }
-      }
-   }
-
-   /* Alloc storage for new instructions */
-   newInst = _mesa_alloc_instructions(newLen);
-   if (!newInst) {
-      return GL_FALSE;
-   }
-
-   /* Copy 'start' instructions into new instruction buffer */
-   _mesa_copy_instructions(newInst, prog->Instructions, start);
-
-   /* init the new instructions */
-   _mesa_init_instructions(newInst + start, count);
-
-   /* Copy the remaining/tail instructions to new inst buffer */
-   _mesa_copy_instructions(newInst + start + count,
-                           prog->Instructions + start,
-                           origLen - start);
-
-   /* free old instructions */
-   _mesa_free_instructions(prog->Instructions, origLen);
-
-   /* install new instructions */
-   prog->Instructions = newInst;
-   prog->NumInstructions = newLen;
-
-   return GL_TRUE;
-}
-
-/**
- * Delete 'count' instructions at 'start' in the given program.
- * Adjust branch targets accordingly.
- */
-GLboolean
-_mesa_delete_instructions(struct gl_program *prog, GLuint start, GLuint count)
-{
-   const GLuint origLen = prog->NumInstructions;
-   const GLuint newLen = origLen - count;
-   struct prog_instruction *newInst;
-   GLuint i;
-
-   /* adjust branches */
-   for (i = 0; i < prog->NumInstructions; i++) {
-      struct prog_instruction *inst = prog->Instructions + i;
-      if (inst->BranchTarget > 0) {
-         if (inst->BranchTarget > (GLint) start) {
-            inst->BranchTarget -= count;
-         }
-      }
-   }
-
-   /* Alloc storage for new instructions */
-   newInst = _mesa_alloc_instructions(newLen);
-   if (!newInst) {
-      return GL_FALSE;
-   }
-
-   /* Copy 'start' instructions into new instruction buffer */
-   _mesa_copy_instructions(newInst, prog->Instructions, start);
-
-   /* Copy the remaining/tail instructions to new inst buffer */
-   _mesa_copy_instructions(newInst + start,
-                           prog->Instructions + start + count,
-                           newLen - start);
-
-   /* free old instructions */
-   _mesa_free_instructions(prog->Instructions, origLen);
-
-   /* install new instructions */
-   prog->Instructions = newInst;
-   prog->NumInstructions = newLen;
-
-   return GL_TRUE;
-}
-
-
-/**
- * Search instructions for registers that match (oldFile, oldIndex),
- * replacing them with (newFile, newIndex).
- */
-static void
-replace_registers(struct prog_instruction *inst, GLuint numInst,
-                  GLuint oldFile, GLuint oldIndex,
-                  GLuint newFile, GLuint newIndex)
-{
-   GLuint i, j;
-   for (i = 0; i < numInst; i++) {
-      /* src regs */
-      for (j = 0; j < _mesa_num_inst_src_regs(inst[i].Opcode); j++) {
-         if (inst[i].SrcReg[j].File == oldFile &&
-             inst[i].SrcReg[j].Index == oldIndex) {
-            inst[i].SrcReg[j].File = newFile;
-            inst[i].SrcReg[j].Index = newIndex;
-         }
-      }
-      /* dst reg */
-      if (inst[i].DstReg.File == oldFile && inst[i].DstReg.Index == oldIndex) {
-         inst[i].DstReg.File = newFile;
-         inst[i].DstReg.Index = newIndex;
-      }
-   }
-}
-
-
-/**
- * Search instructions for references to program parameters.  When found,
- * increment the parameter index by 'offset'.
- * Used when combining programs.
- */
-static void
-adjust_param_indexes(struct prog_instruction *inst, GLuint numInst,
-                     GLuint offset)
-{
-   GLuint i, j;
-   for (i = 0; i < numInst; i++) {
-      for (j = 0; j < _mesa_num_inst_src_regs(inst[i].Opcode); j++) {
-         GLuint f = inst[i].SrcReg[j].File;
-         if (f == PROGRAM_CONSTANT ||
-             f == PROGRAM_UNIFORM ||
-             f == PROGRAM_STATE_VAR) {
-            inst[i].SrcReg[j].Index += offset;
-         }
-      }
-   }
-}
-
-
-/**
- * Combine two programs into one.  Fix instructions so the outputs of
- * the first program go to the inputs of the second program.
- */
-struct gl_program *
-_mesa_combine_programs(struct gl_context *ctx,
-                       const struct gl_program *progA,
-                       const struct gl_program *progB)
-{
-   struct prog_instruction *newInst;
-   struct gl_program *newProg;
-   const GLuint lenA = progA->NumInstructions - 1; /* omit END instr */
-   const GLuint lenB = progB->NumInstructions;
-   const GLuint numParamsA = _mesa_num_parameters(progA->Parameters);
-   const GLuint newLength = lenA + lenB;
-   GLboolean usedTemps[MAX_PROGRAM_TEMPS];
-   GLuint firstTemp = 0;
-   GLbitfield inputsB;
-   GLuint i;
-
-   ASSERT(progA->Target == progB->Target);
-
-   newInst = _mesa_alloc_instructions(newLength);
-   if (!newInst)
-      return GL_FALSE;
-
-   _mesa_copy_instructions(newInst, progA->Instructions, lenA);
-   _mesa_copy_instructions(newInst + lenA, progB->Instructions, lenB);
-
-   /* adjust branch / instruction addresses for B's instructions */
-   for (i = 0; i < lenB; i++) {
-      newInst[lenA + i].BranchTarget += lenA;
-   }
-
-   newProg = ctx->Driver.NewProgram(ctx, progA->Target, 0);
-   newProg->Instructions = newInst;
-   newProg->NumInstructions = newLength;
-
-   /* find used temp regs (we may need new temps below) */
-   _mesa_find_used_registers(newProg, PROGRAM_TEMPORARY,
-                             usedTemps, MAX_PROGRAM_TEMPS);
-
-   if (newProg->Target == GL_FRAGMENT_PROGRAM_ARB) {
-      struct gl_fragment_program *fprogA, *fprogB, *newFprog;
-      GLbitfield progB_inputsRead = progB->InputsRead;
-      GLint progB_colorFile, progB_colorIndex;
-
-      fprogA = (struct gl_fragment_program *) progA;
-      fprogB = (struct gl_fragment_program *) progB;
-      newFprog = (struct gl_fragment_program *) newProg;
-
-      newFprog->UsesKill = fprogA->UsesKill || fprogB->UsesKill;
-
-      /* We'll do a search and replace for instances
-       * of progB_colorFile/progB_colorIndex below...
-       */
-      progB_colorFile = PROGRAM_INPUT;
-      progB_colorIndex = FRAG_ATTRIB_COL0;
-
-      /*
-       * The fragment program may get color from a state var rather than
-       * a fragment input (vertex output) if it's constant.
-       * See the texenvprogram.c code.
-       * So, search the program's parameter list now to see if the program
-       * gets color from a state var instead of a conventional fragment
-       * input register.
-       */
-      for (i = 0; i < progB->Parameters->NumParameters; i++) {
-         struct gl_program_parameter *p = &progB->Parameters->Parameters[i];
-         if (p->Type == PROGRAM_STATE_VAR &&
-             p->StateIndexes[0] == STATE_INTERNAL &&
-             p->StateIndexes[1] == STATE_CURRENT_ATTRIB &&
-             (int) p->StateIndexes[2] == (int) VERT_ATTRIB_COLOR0) {
-            progB_inputsRead |= FRAG_BIT_COL0;
-            progB_colorFile = PROGRAM_STATE_VAR;
-            progB_colorIndex = i;
-            break;
-         }
-      }
-
-      /* Connect color outputs of fprogA to color inputs of fprogB, via a
-       * new temporary register.
-       */
-      if ((progA->OutputsWritten & (1 << FRAG_RESULT_COLOR)) &&
-          (progB_inputsRead & FRAG_BIT_COL0)) {
-         GLint tempReg = _mesa_find_free_register(usedTemps, MAX_PROGRAM_TEMPS,
-                                                  firstTemp);
-         if (tempReg < 0) {
-            _mesa_problem(ctx, "No free temp regs found in "
-                          "_mesa_combine_programs(), using 31");
-            tempReg = 31;
-         }
-         firstTemp = tempReg + 1;
-
-         /* replace writes to result.color[0] with tempReg */
-         replace_registers(newInst, lenA,
-                           PROGRAM_OUTPUT, FRAG_RESULT_COLOR,
-                           PROGRAM_TEMPORARY, tempReg);
-         /* replace reads from the input color with tempReg */
-         replace_registers(newInst + lenA, lenB,
-                           progB_colorFile, progB_colorIndex, /* search for */
-                           PROGRAM_TEMPORARY, tempReg  /* replace with */ );
-      }
-
-      /* compute combined program's InputsRead */
-      inputsB = progB_inputsRead;
-      if (progA->OutputsWritten & (1 << FRAG_RESULT_COLOR)) {
-         inputsB &= ~(1 << FRAG_ATTRIB_COL0);
-      }
-      newProg->InputsRead = progA->InputsRead | inputsB;
-      newProg->OutputsWritten = progB->OutputsWritten;
-      newProg->SamplersUsed = progA->SamplersUsed | progB->SamplersUsed;
-   }
-   else {
-      /* vertex program */
-      assert(0);      /* XXX todo */
-   }
-
-   /*
-    * Merge parameters (uniforms, constants, etc)
-    */
-   newProg->Parameters = _mesa_combine_parameter_lists(progA->Parameters,
-                                                       progB->Parameters);
-
-   adjust_param_indexes(newInst + lenA, lenB, numParamsA);
-
-
-   return newProg;
-}
-
-
-/**
- * Populate the 'used' array with flags indicating which registers (TEMPs,
- * INPUTs, OUTPUTs, etc, are used by the given program.
- * \param file  type of register to scan for
- * \param used  returns true/false flags for in use / free
- * \param usedSize  size of the 'used' array
- */
-void
-_mesa_find_used_registers(const struct gl_program *prog,
-                          gl_register_file file,
-                          GLboolean used[], GLuint usedSize)
-{
-   GLuint i, j;
-
-   memset(used, 0, usedSize);
-
-   for (i = 0; i < prog->NumInstructions; i++) {
-      const struct prog_instruction *inst = prog->Instructions + i;
-      const GLuint n = _mesa_num_inst_src_regs(inst->Opcode);
-
-      if (inst->DstReg.File == file) {
-         ASSERT(inst->DstReg.Index < usedSize);
-         if(inst->DstReg.Index < usedSize)
-            used[inst->DstReg.Index] = GL_TRUE;
-      }
-
-      for (j = 0; j < n; j++) {
-         if (inst->SrcReg[j].File == file) {
-            ASSERT(inst->SrcReg[j].Index < usedSize);
-            if(inst->SrcReg[j].Index < usedSize)
-               used[inst->SrcReg[j].Index] = GL_TRUE;
-         }
-      }
-   }
-}
-
-
-/**
- * Scan the given 'used' register flag array for the first entry
- * that's >= firstReg.
- * \param used  vector of flags indicating registers in use (as returned
- *              by _mesa_find_used_registers())
- * \param usedSize  size of the 'used' array
- * \param firstReg  first register to start searching at
- * \return index of unused register, or -1 if none.
- */
-GLint
-_mesa_find_free_register(const GLboolean used[],
-                         GLuint usedSize, GLuint firstReg)
-{
-   GLuint i;
-
-   assert(firstReg < usedSize);
-
-   for (i = firstReg; i < usedSize; i++)
-      if (!used[i])
-         return i;
-
-   return -1;
-}
-
-
-
-/**
- * Check if the given register index is valid (doesn't exceed implementation-
- * dependent limits).
- * \return GL_TRUE if OK, GL_FALSE if bad index
- */
-GLboolean
-_mesa_valid_register_index(const struct gl_context *ctx,
-                           gl_shader_type shaderType,
-                           gl_register_file file, GLint index)
-{
-   const struct gl_program_constants *c;
-
-   switch (shaderType) {
-   case MESA_SHADER_VERTEX:
-      c = &ctx->Const.VertexProgram;
-      break;
-   case MESA_SHADER_FRAGMENT:
-      c = &ctx->Const.FragmentProgram;
-      break;
-   case MESA_SHADER_GEOMETRY:
-      c = &ctx->Const.GeometryProgram;
-      break;
-   default:
-      _mesa_problem(ctx,
-                    "unexpected shader type in _mesa_valid_register_index()");
-      return GL_FALSE;
-   }
-
-   switch (file) {
-   case PROGRAM_UNDEFINED:
-      return GL_TRUE;  /* XXX or maybe false? */
-
-   case PROGRAM_TEMPORARY:
-      return index >= 0 && index < c->MaxTemps;
-
-   case PROGRAM_ENV_PARAM:
-      return index >= 0 && index < c->MaxEnvParams;
-
-   case PROGRAM_LOCAL_PARAM:
-      return index >= 0 && index < c->MaxLocalParams;
-
-   case PROGRAM_NAMED_PARAM:
-      return index >= 0 && index < c->MaxParameters;
-
-   case PROGRAM_UNIFORM:
-   case PROGRAM_STATE_VAR:
-      /* aka constant buffer */
-      return index >= 0 && index < c->MaxUniformComponents / 4;
-
-   case PROGRAM_CONSTANT:
-      /* constant buffer w/ possible relative negative addressing */
-      return (index > (int) c->MaxUniformComponents / -4 &&
-              index < c->MaxUniformComponents / 4);
-
-   case PROGRAM_INPUT:
-      if (index < 0)
-         return GL_FALSE;
-
-      switch (shaderType) {
-      case MESA_SHADER_VERTEX:
-         return index < VERT_ATTRIB_GENERIC0 + c->MaxAttribs;
-      case MESA_SHADER_FRAGMENT:
-         return index < FRAG_ATTRIB_VAR0 + ctx->Const.MaxVarying;
-      case MESA_SHADER_GEOMETRY:
-         return index < GEOM_ATTRIB_VAR0 + ctx->Const.MaxVarying;
-      default:
-         return GL_FALSE;
-      }
-
-   case PROGRAM_OUTPUT:
-      if (index < 0)
-         return GL_FALSE;
-
-      switch (shaderType) {
-      case MESA_SHADER_VERTEX:
-         return index < VERT_RESULT_VAR0 + ctx->Const.MaxVarying;
-      case MESA_SHADER_FRAGMENT:
-         return index < FRAG_RESULT_DATA0 + ctx->Const.MaxDrawBuffers;
-      case MESA_SHADER_GEOMETRY:
-         return index < GEOM_RESULT_VAR0 + ctx->Const.MaxVarying;
-      default:
-         return GL_FALSE;
-      }
-
-   case PROGRAM_ADDRESS:
-      return index >= 0 && index < c->MaxAddressRegs;
-
-   default:
-      _mesa_problem(ctx,
-                    "unexpected register file in _mesa_valid_register_index()");
-      return GL_FALSE;
-   }
-}
-
-
-
-/**
- * "Post-process" a GPU program.  This is intended to be used for debugging.
- * Example actions include no-op'ing instructions or changing instruction
- * behaviour.
- */
-void
-_mesa_postprocess_program(struct gl_context *ctx, struct gl_program *prog)
-{
-   static const GLfloat white[4] = { 0.5, 0.5, 0.5, 0.5 };
-   GLuint i;
-   GLuint whiteSwizzle;
-   GLint whiteIndex = _mesa_add_unnamed_constant(prog->Parameters,
-                                                 white, 4, &whiteSwizzle);
-
-   (void) whiteIndex;
-
-   for (i = 0; i < prog->NumInstructions; i++) {
-      struct prog_instruction *inst = prog->Instructions + i;
-      const GLuint n = _mesa_num_inst_src_regs(inst->Opcode);
-
-      (void) n;
-
-      if (_mesa_is_tex_instruction(inst->Opcode)) {
-#if 0
-         /* replace TEX/TXP/TXB with MOV */
-         inst->Opcode = OPCODE_MOV;
-         inst->DstReg.WriteMask = WRITEMASK_XYZW;
-         inst->SrcReg[0].Swizzle = SWIZZLE_XYZW;
-         inst->SrcReg[0].Negate = NEGATE_NONE;
-#endif
-
-#if 0
-         /* disable shadow texture mode */
-         inst->TexShadow = 0;
-#endif
-      }
-
-      if (inst->Opcode == OPCODE_TXP) {
-#if 0
-         inst->Opcode = OPCODE_MOV;
-         inst->DstReg.WriteMask = WRITEMASK_XYZW;
-         inst->SrcReg[0].File = PROGRAM_CONSTANT;
-         inst->SrcReg[0].Index = whiteIndex;
-         inst->SrcReg[0].Swizzle = SWIZZLE_XYZW;
-         inst->SrcReg[0].Negate = NEGATE_NONE;
-#endif
-#if 0
-         inst->TexShadow = 0;
-#endif
-#if 0
-         inst->Opcode = OPCODE_TEX;
-         inst->TexShadow = 0;
-#endif
-      }
-
-   }
-}
+/*

+ * Mesa 3-D graphics library

+ * Version:  6.5.3

+ *

+ * Copyright (C) 1999-2007  Brian Paul   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 program.c

+ * Vertex and fragment program support functions.

+ * \author Brian Paul

+ */

+

+

+#include "main/glheader.h"

+#include "main/context.h"

+#include "main/hash.h"

+#include "main/mfeatures.h"

+#include "program.h"

+#include "prog_cache.h"

+#include "prog_parameter.h"

+#include "prog_instruction.h"

+

+

+/**

+ * A pointer to this dummy program is put into the hash table when

+ * glGenPrograms is called.

+ */

+struct gl_program _mesa_DummyProgram;

+

+

+/**

+ * Init context's vertex/fragment program state

+ */

+void

+_mesa_init_program(struct gl_context *ctx)

+{

+   GLuint i;

+

+   /*

+    * If this assertion fails, we need to increase the field

+    * size for register indexes (see INST_INDEX_BITS).

+    */

+   ASSERT(ctx->Const.VertexProgram.MaxUniformComponents / 4

+          <= (1 << INST_INDEX_BITS));

+   ASSERT(ctx->Const.FragmentProgram.MaxUniformComponents / 4

+          <= (1 << INST_INDEX_BITS));

+

+   ASSERT(ctx->Const.VertexProgram.MaxTemps <= (1 << INST_INDEX_BITS));

+   ASSERT(ctx->Const.VertexProgram.MaxLocalParams <= (1 << INST_INDEX_BITS));

+   ASSERT(ctx->Const.FragmentProgram.MaxTemps <= (1 << INST_INDEX_BITS));

+   ASSERT(ctx->Const.FragmentProgram.MaxLocalParams <= (1 << INST_INDEX_BITS));

+

+   ASSERT(ctx->Const.VertexProgram.MaxUniformComponents <= 4 * MAX_UNIFORMS);

+   ASSERT(ctx->Const.FragmentProgram.MaxUniformComponents <= 4 * MAX_UNIFORMS);

+

+   ASSERT(ctx->Const.VertexProgram.MaxAddressOffset <= (1 << INST_INDEX_BITS));

+   ASSERT(ctx->Const.FragmentProgram.MaxAddressOffset <= (1 << INST_INDEX_BITS));

+

+   /* If this fails, increase prog_instruction::TexSrcUnit size */

+   ASSERT(MAX_TEXTURE_UNITS < (1 << 5));

+

+   /* If this fails, increase prog_instruction::TexSrcTarget size */

+   ASSERT(NUM_TEXTURE_TARGETS < (1 << 3));

+

+   ctx->Program.ErrorPos = -1;

+   ctx->Program.ErrorString = _mesa_strdup("");

+

+#if FEATURE_NV_vertex_program || FEATURE_ARB_vertex_program

+   ctx->VertexProgram.Enabled = GL_FALSE;

+#if FEATURE_es2_glsl

+   ctx->VertexProgram.PointSizeEnabled =

+      (ctx->API == API_OPENGLES2) ? GL_TRUE : GL_FALSE;

+#else

+   ctx->VertexProgram.PointSizeEnabled = GL_FALSE;

+#endif

+   ctx->VertexProgram.TwoSideEnabled = GL_FALSE;

+   _mesa_reference_vertprog(ctx, &ctx->VertexProgram.Current,

+                            ctx->Shared->DefaultVertexProgram);

+   assert(ctx->VertexProgram.Current);

+   for (i = 0; i < MAX_NV_VERTEX_PROGRAM_PARAMS / 4; i++) {

+      ctx->VertexProgram.TrackMatrix[i] = GL_NONE;

+      ctx->VertexProgram.TrackMatrixTransform[i] = GL_IDENTITY_NV;

+   }

+   ctx->VertexProgram.Cache = _mesa_new_program_cache();

+#endif

+

+#if FEATURE_NV_fragment_program || FEATURE_ARB_fragment_program

+   ctx->FragmentProgram.Enabled = GL_FALSE;

+   _mesa_reference_fragprog(ctx, &ctx->FragmentProgram.Current,

+                            ctx->Shared->DefaultFragmentProgram);

+   assert(ctx->FragmentProgram.Current);

+   ctx->FragmentProgram.Cache = _mesa_new_program_cache();

+#endif

+

+#if FEATURE_ARB_geometry_shader4

+   ctx->GeometryProgram.Enabled = GL_FALSE;

+   /* right now by default we don't have a geometry program */

+   _mesa_reference_geomprog(ctx, &ctx->GeometryProgram.Current,

+                            NULL);

+   ctx->GeometryProgram.Cache = _mesa_new_program_cache();

+#endif

+

+   /* XXX probably move this stuff */

+#if FEATURE_ATI_fragment_shader

+   ctx->ATIFragmentShader.Enabled = GL_FALSE;

+   ctx->ATIFragmentShader.Current = ctx->Shared->DefaultFragmentShader;

+   assert(ctx->ATIFragmentShader.Current);

+   ctx->ATIFragmentShader.Current->RefCount++;

+#endif

+}

+

+

+/**

+ * Free a context's vertex/fragment program state

+ */

+void

+_mesa_free_program_data(struct gl_context *ctx)

+{

+#if FEATURE_NV_vertex_program || FEATURE_ARB_vertex_program

+   _mesa_reference_vertprog(ctx, &ctx->VertexProgram.Current, NULL);

+   _mesa_delete_program_cache(ctx, ctx->VertexProgram.Cache);

+#endif

+#if FEATURE_NV_fragment_program || FEATURE_ARB_fragment_program

+   _mesa_reference_fragprog(ctx, &ctx->FragmentProgram.Current, NULL);

+   _mesa_delete_shader_cache(ctx, ctx->FragmentProgram.Cache);

+#endif

+#if FEATURE_ARB_geometry_shader4

+   _mesa_reference_geomprog(ctx, &ctx->GeometryProgram.Current, NULL);

+   _mesa_delete_program_cache(ctx, ctx->GeometryProgram.Cache);

+#endif

+   /* XXX probably move this stuff */

+#if FEATURE_ATI_fragment_shader

+   if (ctx->ATIFragmentShader.Current) {

+      ctx->ATIFragmentShader.Current->RefCount--;

+      if (ctx->ATIFragmentShader.Current->RefCount <= 0) {

+         free(ctx->ATIFragmentShader.Current);

+      }

+   }

+#endif

+   free((void *) ctx->Program.ErrorString);

+}

+

+

+/**

+ * Update the default program objects in the given context to reference those

+ * specified in the shared state and release those referencing the old

+ * shared state.

+ */

+void

+_mesa_update_default_objects_program(struct gl_context *ctx)

+{

+#if FEATURE_NV_vertex_program || FEATURE_ARB_vertex_program

+   _mesa_reference_vertprog(ctx, &ctx->VertexProgram.Current,

+                            (struct gl_vertex_program *)

+                            ctx->Shared->DefaultVertexProgram);

+   assert(ctx->VertexProgram.Current);

+#endif

+

+#if FEATURE_NV_fragment_program || FEATURE_ARB_fragment_program

+   _mesa_reference_fragprog(ctx, &ctx->FragmentProgram.Current,

+                            (struct gl_fragment_program *)

+                            ctx->Shared->DefaultFragmentProgram);

+   assert(ctx->FragmentProgram.Current);

+#endif

+

+#if FEATURE_ARB_geometry_shader4

+   _mesa_reference_geomprog(ctx, &ctx->GeometryProgram.Current,

+                            (struct gl_geometry_program *)

+                            ctx->Shared->DefaultGeometryProgram);

+#endif

+

+   /* XXX probably move this stuff */

+#if FEATURE_ATI_fragment_shader

+   if (ctx->ATIFragmentShader.Current) {

+      ctx->ATIFragmentShader.Current->RefCount--;

+      if (ctx->ATIFragmentShader.Current->RefCount <= 0) {

+         free(ctx->ATIFragmentShader.Current);

+      }

+   }

+   ctx->ATIFragmentShader.Current = (struct ati_fragment_shader *) ctx->Shared->DefaultFragmentShader;

+   assert(ctx->ATIFragmentShader.Current);

+   ctx->ATIFragmentShader.Current->RefCount++;

+#endif

+}

+

+

+/**

+ * Set the vertex/fragment program error state (position and error string).

+ * This is generally called from within the parsers.

+ */

+void

+_mesa_set_program_error(struct gl_context *ctx, GLint pos, const char *string)

+{

+   ctx->Program.ErrorPos = pos;

+   free((void *) ctx->Program.ErrorString);

+   if (!string)

+      string = "";

+   ctx->Program.ErrorString = _mesa_strdup(string);

+}

+

+

+/**

+ * Find the line number and column for 'pos' within 'string'.

+ * Return a copy of the line which contains 'pos'.  Free the line with

+ * free().

+ * \param string  the program string

+ * \param pos     the position within the string

+ * \param line    returns the line number corresponding to 'pos'.

+ * \param col     returns the column number corresponding to 'pos'.

+ * \return copy of the line containing 'pos'.

+ */

+const GLubyte *

+_mesa_find_line_column(const GLubyte *string, const GLubyte *pos,

+                       GLint *line, GLint *col)

+{

+   const GLubyte *lineStart = string;

+   const GLubyte *p = string;

+   GLubyte *s;

+   int len;

+

+   *line = 1;

+

+   while (p != pos) {

+      if (*p == (GLubyte) '\n') {

+         (*line)++;

+         lineStart = p + 1;

+      }

+      p++;

+   }

+

+   *col = (pos - lineStart) + 1;

+

+   /* return copy of this line */

+   while (*p != 0 && *p != '\n')

+      p++;

+   len = p - lineStart;

+   s = (GLubyte *) malloc(len + 1);

+   memcpy(s, lineStart, len);

+   s[len] = 0;

+

+   return s;

+}

+

+

+/**

+ * Initialize a new vertex/fragment program object.

+ */

+static struct gl_program *

+_mesa_init_program_struct( struct gl_context *ctx, struct gl_program *prog,

+                           GLenum target, GLuint id)

+{

+   (void) ctx;

+   if (prog) {

+      GLuint i;

+      memset(prog, 0, sizeof(*prog));

+      prog->Id = id;

+      prog->Target = target;

+      prog->Resident = GL_TRUE;

+      prog->RefCount = 1;

+      prog->Format = GL_PROGRAM_FORMAT_ASCII_ARB;

+

+      /* default mapping from samplers to texture units */

+      for (i = 0; i < MAX_SAMPLERS; i++)

+         prog->SamplerUnits[i] = i;

+   }

+

+   return prog;

+}

+

+

+/**

+ * Initialize a new fragment program object.

+ */

+struct gl_program *

+_mesa_init_fragment_program( struct gl_context *ctx, struct gl_fragment_program *prog,

+                             GLenum target, GLuint id)

+{

+   if (prog)

+      return _mesa_init_program_struct( ctx, &prog->Base, target, id );

+   else

+      return NULL;

+}

+

+

+/**

+ * Initialize a new vertex program object.

+ */

+struct gl_program *

+_mesa_init_vertex_program( struct gl_context *ctx, struct gl_vertex_program *prog,

+                           GLenum target, GLuint id)

+{

+   if (prog)

+      return _mesa_init_program_struct( ctx, &prog->Base, target, id );

+   else

+      return NULL;

+}

+

+

+/**

+ * Initialize a new geometry program object.

+ */

+struct gl_program *

+_mesa_init_geometry_program( struct gl_context *ctx, struct gl_geometry_program *prog,

+                             GLenum target, GLuint id)

+{

+   if (prog)

+      return _mesa_init_program_struct( ctx, &prog->Base, target, id );

+   else

+      return NULL;

+}

+

+

+/**

+ * Allocate and initialize a new fragment/vertex program object but

+ * don't put it into the program hash table.  Called via

+ * ctx->Driver.NewProgram.  May be overridden (ie. replaced) by a

+ * device driver function to implement OO deriviation with additional

+ * types not understood by this function.

+ *

+ * \param ctx  context

+ * \param id   program id/number

+ * \param target  program target/type

+ * \return  pointer to new program object

+ */

+struct gl_program *

+_mesa_new_program(struct gl_context *ctx, GLenum target, GLuint id)

+{

+   struct gl_program *prog;

+   switch (target) {

+   case GL_VERTEX_PROGRAM_ARB: /* == GL_VERTEX_PROGRAM_NV */

+   case GL_VERTEX_STATE_PROGRAM_NV:

+      prog = _mesa_init_vertex_program(ctx, CALLOC_STRUCT(gl_vertex_program),

+                                       target, id );

+      break;

+   case GL_FRAGMENT_PROGRAM_NV:

+   case GL_FRAGMENT_PROGRAM_ARB:

+      prog =_mesa_init_fragment_program(ctx,

+                                         CALLOC_STRUCT(gl_fragment_program),

+                                         target, id );

+      break;

+   case MESA_GEOMETRY_PROGRAM:

+      prog = _mesa_init_geometry_program(ctx,

+                                         CALLOC_STRUCT(gl_geometry_program),

+                                         target, id);

+      break;

+   default:

+      _mesa_problem(ctx, "bad target in _mesa_new_program");

+      prog = NULL;

+   }

+   return prog;

+}

+

+

+/**

+ * Delete a program and remove it from the hash table, ignoring the

+ * reference count.

+ * Called via ctx->Driver.DeleteProgram.  May be wrapped (OO deriviation)

+ * by a device driver function.

+ */

+void

+_mesa_delete_program(struct gl_context *ctx, struct gl_program *prog)

+{

+   (void) ctx;

+   ASSERT(prog);

+   ASSERT(prog->RefCount==0);

+

+   if (prog == &_mesa_DummyProgram)

+      return;

+

+   if (prog->String)

+      free(prog->String);

+

+   _mesa_free_instructions(prog->Instructions, prog->NumInstructions);

+

+   if (prog->Parameters) {

+      _mesa_free_parameter_list(prog->Parameters);

+   }

+   if (prog->Varying) {

+      _mesa_free_parameter_list(prog->Varying);

+   }

+   if (prog->Attributes) {

+      _mesa_free_parameter_list(prog->Attributes);

+   }

+

+   free(prog);

+}

+

+

+/**

+ * Return the gl_program object for a given ID.

+ * Basically just a wrapper for _mesa_HashLookup() to avoid a lot of

+ * casts elsewhere.

+ */

+struct gl_program *

+_mesa_lookup_program(struct gl_context *ctx, GLuint id)

+{

+   if (id)

+      return (struct gl_program *) _mesa_HashLookup(ctx->Shared->Programs, id);

+   else

+      return NULL;

+}

+

+

+/**

+ * Reference counting for vertex/fragment programs

+ */

+void

+_mesa_reference_program(struct gl_context *ctx,

+                        struct gl_program **ptr,

+                        struct gl_program *prog)

+{

+   assert(ptr);

+   if (*ptr && prog) {

+      /* sanity check */

+      if ((*ptr)->Target == GL_VERTEX_PROGRAM_ARB)

+         ASSERT(prog->Target == GL_VERTEX_PROGRAM_ARB);

+      else if ((*ptr)->Target == GL_FRAGMENT_PROGRAM_ARB)

+         ASSERT(prog->Target == GL_FRAGMENT_PROGRAM_ARB ||

+                prog->Target == GL_FRAGMENT_PROGRAM_NV);

+      else if ((*ptr)->Target == MESA_GEOMETRY_PROGRAM)

+         ASSERT(prog->Target == MESA_GEOMETRY_PROGRAM);

+   }

+   if (*ptr == prog) {

+      return;  /* no change */

+   }

+   if (*ptr) {

+      GLboolean deleteFlag;

+

+      /*_glthread_LOCK_MUTEX((*ptr)->Mutex);*/

+#if 0

+      printf("Program %p ID=%u Target=%s  Refcount-- to %d\n",

+             *ptr, (*ptr)->Id,

+             ((*ptr)->Target == GL_VERTEX_PROGRAM_ARB ? "VP" :

+              ((*ptr)->Target == MESA_GEOMETRY_PROGRAM ? "GP" : "FP")),

+             (*ptr)->RefCount - 1);

+#endif

+      ASSERT((*ptr)->RefCount > 0);

+      (*ptr)->RefCount--;

+

+      deleteFlag = ((*ptr)->RefCount == 0);

+      /*_glthread_UNLOCK_MUTEX((*ptr)->Mutex);*/

+

+      if (deleteFlag) {

+         ASSERT(ctx);

+         ctx->Driver.DeleteProgram(ctx, *ptr);

+      }

+

+      *ptr = NULL;

+   }

+

+   assert(!*ptr);

+   if (prog) {

+      /*_glthread_LOCK_MUTEX(prog->Mutex);*/

+      prog->RefCount++;

+#if 0

+      printf("Program %p ID=%u Target=%s  Refcount++ to %d\n",

+             prog, prog->Id,

+             (prog->Target == GL_VERTEX_PROGRAM_ARB ? "VP" :

+              (prog->Target == MESA_GEOMETRY_PROGRAM ? "GP" : "FP")),

+             prog->RefCount);

+#endif

+      /*_glthread_UNLOCK_MUTEX(prog->Mutex);*/

+   }

+

+   *ptr = prog;

+}

+

+

+/**

+ * Return a copy of a program.

+ * XXX Problem here if the program object is actually OO-derivation

+ * made by a device driver.

+ */

+struct gl_program *

+_mesa_clone_program(struct gl_context *ctx, const struct gl_program *prog)

+{

+   struct gl_program *clone;

+

+   clone = ctx->Driver.NewProgram(ctx, prog->Target, prog->Id);

+   if (!clone)

+      return NULL;

+

+   assert(clone->Target == prog->Target);

+   assert(clone->RefCount == 1);

+

+   clone->String = (GLubyte *) _mesa_strdup((char *) prog->String);

+   clone->Format = prog->Format;

+   clone->Instructions = _mesa_alloc_instructions(prog->NumInstructions);

+   if (!clone->Instructions) {

+      _mesa_reference_program(ctx, &clone, NULL);

+      return NULL;

+   }

+   _mesa_copy_instructions(clone->Instructions, prog->Instructions,

+                           prog->NumInstructions);

+   clone->InputsRead = prog->InputsRead;

+   clone->OutputsWritten = prog->OutputsWritten;

+   clone->SamplersUsed = prog->SamplersUsed;

+   clone->ShadowSamplers = prog->ShadowSamplers;

+   memcpy(clone->TexturesUsed, prog->TexturesUsed, sizeof(prog->TexturesUsed));

+

+   if (prog->Parameters)

+      clone->Parameters = _mesa_clone_parameter_list(prog->Parameters);

+   memcpy(clone->LocalParams, prog->LocalParams, sizeof(clone->LocalParams));

+   if (prog->Varying)

+      clone->Varying = _mesa_clone_parameter_list(prog->Varying);

+   if (prog->Attributes)

+      clone->Attributes = _mesa_clone_parameter_list(prog->Attributes);

+   memcpy(clone->LocalParams, prog->LocalParams, sizeof(clone->LocalParams));

+   clone->IndirectRegisterFiles = prog->IndirectRegisterFiles;

+   clone->NumInstructions = prog->NumInstructions;

+   clone->NumTemporaries = prog->NumTemporaries;

+   clone->NumParameters = prog->NumParameters;

+   clone->NumAttributes = prog->NumAttributes;

+   clone->NumAddressRegs = prog->NumAddressRegs;

+   clone->NumNativeInstructions = prog->NumNativeInstructions;

+   clone->NumNativeTemporaries = prog->NumNativeTemporaries;

+   clone->NumNativeParameters = prog->NumNativeParameters;

+   clone->NumNativeAttributes = prog->NumNativeAttributes;

+   clone->NumNativeAddressRegs = prog->NumNativeAddressRegs;

+   clone->NumAluInstructions = prog->NumAluInstructions;

+   clone->NumTexInstructions = prog->NumTexInstructions;

+   clone->NumTexIndirections = prog->NumTexIndirections;

+   clone->NumNativeAluInstructions = prog->NumNativeAluInstructions;

+   clone->NumNativeTexInstructions = prog->NumNativeTexInstructions;

+   clone->NumNativeTexIndirections = prog->NumNativeTexIndirections;

+

+   switch (prog->Target) {

+   case GL_VERTEX_PROGRAM_ARB:

+      {

+         const struct gl_vertex_program *vp

+            = (const struct gl_vertex_program *) prog;

+         struct gl_vertex_program *vpc = (struct gl_vertex_program *) clone;

+         vpc->IsPositionInvariant = vp->IsPositionInvariant;

+         vpc->IsNVProgram = vp->IsNVProgram;

+      }

+      break;

+   case GL_FRAGMENT_PROGRAM_ARB:

+      {

+         const struct gl_fragment_program *fp

+            = (const struct gl_fragment_program *) prog;

+         struct gl_fragment_program *fpc = (struct gl_fragment_program *) clone;

+         fpc->FogOption = fp->FogOption;

+         fpc->UsesKill = fp->UsesKill;

+         fpc->OriginUpperLeft = fp->OriginUpperLeft;

+         fpc->PixelCenterInteger = fp->PixelCenterInteger;

+      }

+      break;

+   case MESA_GEOMETRY_PROGRAM:

+      {

+         const struct gl_geometry_program *gp

+            = (const struct gl_geometry_program *) prog;

+         struct gl_geometry_program *gpc = (struct gl_geometry_program *) clone;

+         gpc->VerticesOut = gp->VerticesOut;

+         gpc->InputType = gp->InputType;

+         gpc->OutputType = gp->OutputType;

+      }

+      break;

+   default:

+      _mesa_problem(NULL, "Unexpected target in _mesa_clone_program");

+   }

+

+   return clone;

+}

+

+

+/**

+ * Insert 'count' NOP instructions at 'start' in the given program.

+ * Adjust branch targets accordingly.

+ */

+GLboolean

+_mesa_insert_instructions(struct gl_program *prog, GLuint start, GLuint count)

+{

+   const GLuint origLen = prog->NumInstructions;

+   const GLuint newLen = origLen + count;

+   struct prog_instruction *newInst;

+   GLuint i;

+

+   /* adjust branches */

+   for (i = 0; i < prog->NumInstructions; i++) {

+      struct prog_instruction *inst = prog->Instructions + i;

+      if (inst->BranchTarget > 0) {

+         if ((GLuint)inst->BranchTarget >= start) {

+            inst->BranchTarget += count;

+         }

+      }

+   }

+

+   /* Alloc storage for new instructions */

+   newInst = _mesa_alloc_instructions(newLen);

+   if (!newInst) {

+      return GL_FALSE;

+   }

+

+   /* Copy 'start' instructions into new instruction buffer */

+   _mesa_copy_instructions(newInst, prog->Instructions, start);

+

+   /* init the new instructions */

+   _mesa_init_instructions(newInst + start, count);

+

+   /* Copy the remaining/tail instructions to new inst buffer */

+   _mesa_copy_instructions(newInst + start + count,

+                           prog->Instructions + start,

+                           origLen - start);

+

+   /* free old instructions */

+   _mesa_free_instructions(prog->Instructions, origLen);

+

+   /* install new instructions */

+   prog->Instructions = newInst;

+   prog->NumInstructions = newLen;

+

+   return GL_TRUE;

+}

+

+/**

+ * Delete 'count' instructions at 'start' in the given program.

+ * Adjust branch targets accordingly.

+ */

+GLboolean

+_mesa_delete_instructions(struct gl_program *prog, GLuint start, GLuint count)

+{

+   const GLuint origLen = prog->NumInstructions;

+   const GLuint newLen = origLen - count;

+   struct prog_instruction *newInst;

+   GLuint i;

+

+   /* adjust branches */

+   for (i = 0; i < prog->NumInstructions; i++) {

+      struct prog_instruction *inst = prog->Instructions + i;

+      if (inst->BranchTarget > 0) {

+         if (inst->BranchTarget > (GLint) start) {

+            inst->BranchTarget -= count;

+         }

+      }

+   }

+

+   /* Alloc storage for new instructions */

+   newInst = _mesa_alloc_instructions(newLen);

+   if (!newInst) {

+      return GL_FALSE;

+   }

+

+   /* Copy 'start' instructions into new instruction buffer */

+   _mesa_copy_instructions(newInst, prog->Instructions, start);

+

+   /* Copy the remaining/tail instructions to new inst buffer */

+   _mesa_copy_instructions(newInst + start,

+                           prog->Instructions + start + count,

+                           newLen - start);

+

+   /* free old instructions */

+   _mesa_free_instructions(prog->Instructions, origLen);

+

+   /* install new instructions */

+   prog->Instructions = newInst;

+   prog->NumInstructions = newLen;

+

+   return GL_TRUE;

+}

+

+

+/**

+ * Search instructions for registers that match (oldFile, oldIndex),

+ * replacing them with (newFile, newIndex).

+ */

+static void

+replace_registers(struct prog_instruction *inst, GLuint numInst,

+                  GLuint oldFile, GLuint oldIndex,

+                  GLuint newFile, GLuint newIndex)

+{

+   GLuint i, j;

+   for (i = 0; i < numInst; i++) {

+      /* src regs */

+      for (j = 0; j < _mesa_num_inst_src_regs(inst[i].Opcode); j++) {

+         if (inst[i].SrcReg[j].File == oldFile &&

+             inst[i].SrcReg[j].Index == oldIndex) {

+            inst[i].SrcReg[j].File = newFile;

+            inst[i].SrcReg[j].Index = newIndex;

+         }

+      }

+      /* dst reg */

+      if (inst[i].DstReg.File == oldFile && inst[i].DstReg.Index == oldIndex) {

+         inst[i].DstReg.File = newFile;

+         inst[i].DstReg.Index = newIndex;

+      }

+   }

+}

+

+

+/**

+ * Search instructions for references to program parameters.  When found,

+ * increment the parameter index by 'offset'.

+ * Used when combining programs.

+ */

+static void

+adjust_param_indexes(struct prog_instruction *inst, GLuint numInst,

+                     GLuint offset)

+{

+   GLuint i, j;

+   for (i = 0; i < numInst; i++) {

+      for (j = 0; j < _mesa_num_inst_src_regs(inst[i].Opcode); j++) {

+         GLuint f = inst[i].SrcReg[j].File;

+         if (f == PROGRAM_CONSTANT ||

+             f == PROGRAM_UNIFORM ||

+             f == PROGRAM_STATE_VAR) {

+            inst[i].SrcReg[j].Index += offset;

+         }

+      }

+   }

+}

+

+

+/**

+ * Combine two programs into one.  Fix instructions so the outputs of

+ * the first program go to the inputs of the second program.

+ */

+struct gl_program *

+_mesa_combine_programs(struct gl_context *ctx,

+                       const struct gl_program *progA,

+                       const struct gl_program *progB)

+{

+   struct prog_instruction *newInst;

+   struct gl_program *newProg;

+   const GLuint lenA = progA->NumInstructions - 1; /* omit END instr */

+   const GLuint lenB = progB->NumInstructions;

+   const GLuint numParamsA = _mesa_num_parameters(progA->Parameters);

+   const GLuint newLength = lenA + lenB;

+   GLboolean usedTemps[MAX_PROGRAM_TEMPS];

+   GLuint firstTemp = 0;

+   GLbitfield inputsB;

+   GLuint i;

+

+   ASSERT(progA->Target == progB->Target);

+

+   newInst = _mesa_alloc_instructions(newLength);

+   if (!newInst)

+      return GL_FALSE;

+

+   _mesa_copy_instructions(newInst, progA->Instructions, lenA);

+   _mesa_copy_instructions(newInst + lenA, progB->Instructions, lenB);

+

+   /* adjust branch / instruction addresses for B's instructions */

+   for (i = 0; i < lenB; i++) {

+      newInst[lenA + i].BranchTarget += lenA;

+   }

+

+   newProg = ctx->Driver.NewProgram(ctx, progA->Target, 0);

+   newProg->Instructions = newInst;

+   newProg->NumInstructions = newLength;

+

+   /* find used temp regs (we may need new temps below) */

+   _mesa_find_used_registers(newProg, PROGRAM_TEMPORARY,

+                             usedTemps, MAX_PROGRAM_TEMPS);

+

+   if (newProg->Target == GL_FRAGMENT_PROGRAM_ARB) {

+      struct gl_fragment_program *fprogA, *fprogB, *newFprog;

+      GLbitfield progB_inputsRead = progB->InputsRead;

+      GLint progB_colorFile, progB_colorIndex;

+

+      fprogA = (struct gl_fragment_program *) progA;

+      fprogB = (struct gl_fragment_program *) progB;

+      newFprog = (struct gl_fragment_program *) newProg;

+

+      newFprog->UsesKill = fprogA->UsesKill || fprogB->UsesKill;

+

+      /* We'll do a search and replace for instances

+       * of progB_colorFile/progB_colorIndex below...

+       */

+      progB_colorFile = PROGRAM_INPUT;

+      progB_colorIndex = FRAG_ATTRIB_COL0;

+

+      /*

+       * The fragment program may get color from a state var rather than

+       * a fragment input (vertex output) if it's constant.

+       * See the texenvprogram.c code.

+       * So, search the program's parameter list now to see if the program

+       * gets color from a state var instead of a conventional fragment

+       * input register.

+       */

+      for (i = 0; i < progB->Parameters->NumParameters; i++) {

+         struct gl_program_parameter *p = &progB->Parameters->Parameters[i];

+         if (p->Type == PROGRAM_STATE_VAR &&

+             p->StateIndexes[0] == STATE_INTERNAL &&

+             p->StateIndexes[1] == STATE_CURRENT_ATTRIB &&

+             (int) p->StateIndexes[2] == (int) VERT_ATTRIB_COLOR0) {

+            progB_inputsRead |= FRAG_BIT_COL0;

+            progB_colorFile = PROGRAM_STATE_VAR;

+            progB_colorIndex = i;

+            break;

+         }

+      }

+

+      /* Connect color outputs of fprogA to color inputs of fprogB, via a

+       * new temporary register.

+       */

+      if ((progA->OutputsWritten & (1 << FRAG_RESULT_COLOR)) &&

+          (progB_inputsRead & FRAG_BIT_COL0)) {

+         GLint tempReg = _mesa_find_free_register(usedTemps, MAX_PROGRAM_TEMPS,

+                                                  firstTemp);

+         if (tempReg < 0) {

+            _mesa_problem(ctx, "No free temp regs found in "

+                          "_mesa_combine_programs(), using 31");

+            tempReg = 31;

+         }

+         firstTemp = tempReg + 1;

+

+         /* replace writes to result.color[0] with tempReg */

+         replace_registers(newInst, lenA,

+                           PROGRAM_OUTPUT, FRAG_RESULT_COLOR,

+                           PROGRAM_TEMPORARY, tempReg);

+         /* replace reads from the input color with tempReg */

+         replace_registers(newInst + lenA, lenB,

+                           progB_colorFile, progB_colorIndex, /* search for */

+                           PROGRAM_TEMPORARY, tempReg  /* replace with */ );

+      }

+

+      /* compute combined program's InputsRead */

+      inputsB = progB_inputsRead;

+      if (progA->OutputsWritten & (1 << FRAG_RESULT_COLOR)) {

+         inputsB &= ~(1 << FRAG_ATTRIB_COL0);

+      }

+      newProg->InputsRead = progA->InputsRead | inputsB;

+      newProg->OutputsWritten = progB->OutputsWritten;

+      newProg->SamplersUsed = progA->SamplersUsed | progB->SamplersUsed;

+   }

+   else {

+      /* vertex program */

+      assert(0);      /* XXX todo */

+   }

+

+   /*

+    * Merge parameters (uniforms, constants, etc)

+    */

+   newProg->Parameters = _mesa_combine_parameter_lists(progA->Parameters,

+                                                       progB->Parameters);

+

+   adjust_param_indexes(newInst + lenA, lenB, numParamsA);

+

+

+   return newProg;

+}

+

+

+/**

+ * Populate the 'used' array with flags indicating which registers (TEMPs,

+ * INPUTs, OUTPUTs, etc, are used by the given program.

+ * \param file  type of register to scan for

+ * \param used  returns true/false flags for in use / free

+ * \param usedSize  size of the 'used' array

+ */

+void

+_mesa_find_used_registers(const struct gl_program *prog,

+                          gl_register_file file,

+                          GLboolean used[], GLuint usedSize)

+{

+   GLuint i, j;

+

+   memset(used, 0, usedSize);

+

+   for (i = 0; i < prog->NumInstructions; i++) {

+      const struct prog_instruction *inst = prog->Instructions + i;

+      const GLuint n = _mesa_num_inst_src_regs(inst->Opcode);

+

+      if (inst->DstReg.File == file) {

+         ASSERT(inst->DstReg.Index < usedSize);

+         if(inst->DstReg.Index < usedSize)

+            used[inst->DstReg.Index] = GL_TRUE;

+      }

+

+      for (j = 0; j < n; j++) {

+         if (inst->SrcReg[j].File == file) {

+            ASSERT(inst->SrcReg[j].Index < usedSize);

+            if(inst->SrcReg[j].Index < usedSize)

+               used[inst->SrcReg[j].Index] = GL_TRUE;

+         }

+      }

+   }

+}

+

+

+/**

+ * Scan the given 'used' register flag array for the first entry

+ * that's >= firstReg.

+ * \param used  vector of flags indicating registers in use (as returned

+ *              by _mesa_find_used_registers())

+ * \param usedSize  size of the 'used' array

+ * \param firstReg  first register to start searching at

+ * \return index of unused register, or -1 if none.

+ */

+GLint

+_mesa_find_free_register(const GLboolean used[],

+                         GLuint usedSize, GLuint firstReg)

+{

+   GLuint i;

+

+   assert(firstReg < usedSize);

+

+   for (i = firstReg; i < usedSize; i++)

+      if (!used[i])

+         return i;

+

+   return -1;

+}

+

+

+

+/**

+ * Check if the given register index is valid (doesn't exceed implementation-

+ * dependent limits).

+ * \return GL_TRUE if OK, GL_FALSE if bad index

+ */

+GLboolean

+_mesa_valid_register_index(const struct gl_context *ctx,

+                           gl_shader_type shaderType,

+                           gl_register_file file, GLint index)

+{

+   const struct gl_program_constants *c;

+

+   switch (shaderType) {

+   case MESA_SHADER_VERTEX:

+      c = &ctx->Const.VertexProgram;

+      break;

+   case MESA_SHADER_FRAGMENT:

+      c = &ctx->Const.FragmentProgram;

+      break;

+   case MESA_SHADER_GEOMETRY:

+      c = &ctx->Const.GeometryProgram;

+      break;

+   default:

+      _mesa_problem(ctx,

+                    "unexpected shader type in _mesa_valid_register_index()");

+      return GL_FALSE;

+   }

+

+   switch (file) {

+   case PROGRAM_UNDEFINED:

+      return GL_TRUE;  /* XXX or maybe false? */

+

+   case PROGRAM_TEMPORARY:

+      return index >= 0 && index < c->MaxTemps;

+

+   case PROGRAM_ENV_PARAM:

+      return index >= 0 && index < c->MaxEnvParams;

+

+   case PROGRAM_LOCAL_PARAM:

+      return index >= 0 && index < c->MaxLocalParams;

+

+   case PROGRAM_NAMED_PARAM:

+      return index >= 0 && index < c->MaxParameters;

+

+   case PROGRAM_UNIFORM:

+   case PROGRAM_STATE_VAR:

+      /* aka constant buffer */

+      return index >= 0 && index < c->MaxUniformComponents / 4;

+

+   case PROGRAM_CONSTANT:

+      /* constant buffer w/ possible relative negative addressing */

+      return (index > (int) c->MaxUniformComponents / -4 &&

+              index < c->MaxUniformComponents / 4);

+

+   case PROGRAM_INPUT:

+      if (index < 0)

+         return GL_FALSE;

+

+      switch (shaderType) {

+      case MESA_SHADER_VERTEX:

+         return index < VERT_ATTRIB_GENERIC0 + c->MaxAttribs;

+      case MESA_SHADER_FRAGMENT:

+         return index < FRAG_ATTRIB_VAR0 + ctx->Const.MaxVarying;

+      case MESA_SHADER_GEOMETRY:

+         return index < GEOM_ATTRIB_VAR0 + ctx->Const.MaxVarying;

+      default:

+         return GL_FALSE;

+      }

+

+   case PROGRAM_OUTPUT:

+      if (index < 0)

+         return GL_FALSE;

+

+      switch (shaderType) {

+      case MESA_SHADER_VERTEX:

+         return index < VERT_RESULT_VAR0 + ctx->Const.MaxVarying;

+      case MESA_SHADER_FRAGMENT:

+         return index < FRAG_RESULT_DATA0 + ctx->Const.MaxDrawBuffers;

+      case MESA_SHADER_GEOMETRY:

+         return index < GEOM_RESULT_VAR0 + ctx->Const.MaxVarying;

+      default:

+         return GL_FALSE;

+      }

+

+   case PROGRAM_ADDRESS:

+      return index >= 0 && index < c->MaxAddressRegs;

+

+   default:

+      _mesa_problem(ctx,

+                    "unexpected register file in _mesa_valid_register_index()");

+      return GL_FALSE;

+   }

+}

+

+

+

+/**

+ * "Post-process" a GPU program.  This is intended to be used for debugging.

+ * Example actions include no-op'ing instructions or changing instruction

+ * behaviour.

+ */

+void

+_mesa_postprocess_program(struct gl_context *ctx, struct gl_program *prog)

+{

+   static const GLfloat white[4] = { 0.5, 0.5, 0.5, 0.5 };

+   GLuint i;

+   GLuint whiteSwizzle;

+   GLint whiteIndex = _mesa_add_unnamed_constant(prog->Parameters,

+                                                 white, 4, &whiteSwizzle);

+

+   (void) whiteIndex;

+

+   for (i = 0; i < prog->NumInstructions; i++) {

+      struct prog_instruction *inst = prog->Instructions + i;

+      const GLuint n = _mesa_num_inst_src_regs(inst->Opcode);

+

+      (void) n;

+

+      if (_mesa_is_tex_instruction(inst->Opcode)) {

+#if 0

+         /* replace TEX/TXP/TXB with MOV */

+         inst->Opcode = OPCODE_MOV;

+         inst->DstReg.WriteMask = WRITEMASK_XYZW;

+         inst->SrcReg[0].Swizzle = SWIZZLE_XYZW;

+         inst->SrcReg[0].Negate = NEGATE_NONE;

+#endif

+

+#if 0

+         /* disable shadow texture mode */

+         inst->TexShadow = 0;

+#endif

+      }

+

+      if (inst->Opcode == OPCODE_TXP) {

+#if 0

+         inst->Opcode = OPCODE_MOV;

+         inst->DstReg.WriteMask = WRITEMASK_XYZW;

+         inst->SrcReg[0].File = PROGRAM_CONSTANT;

+         inst->SrcReg[0].Index = whiteIndex;

+         inst->SrcReg[0].Swizzle = SWIZZLE_XYZW;

+         inst->SrcReg[0].Negate = NEGATE_NONE;

+#endif

+#if 0

+         inst->TexShadow = 0;

+#endif

+#if 0

+         inst->Opcode = OPCODE_TEX;

+         inst->TexShadow = 0;

+#endif

+      }

+

+   }

+}

diff --git a/mesalib/src/mesa/sources.mak b/mesalib/src/mesa/sources.mak
index 95330947a..70171ea0b 100644
--- a/mesalib/src/mesa/sources.mak
+++ b/mesalib/src/mesa/sources.mak
@@ -1,372 +1,376 @@
-### Lists of source files, included by Makefiles
-
-# this is part of MAIN_SOURCES
-MAIN_ES_SOURCES = \
-	main/api_exec_es1.c \
-	main/api_exec_es2.c
-
-MAIN_SOURCES = \
-	main/api_arrayelt.c \
-	main/api_exec.c \
-	main/api_loopback.c \
-	main/api_noop.c \
-	main/api_validate.c \
-	main/accum.c \
-	main/arbprogram.c \
-	main/atifragshader.c \
-	main/attrib.c \
-	main/arrayobj.c \
-	main/blend.c \
-	main/bufferobj.c \
-	main/buffers.c \
-	main/clear.c \
-	main/clip.c \
-	main/colortab.c \
-	main/condrender.c \
-	main/context.c \
-	main/convolve.c \
-	main/cpuinfo.c \
-	main/debug.c \
-	main/depth.c \
-	main/depthstencil.c \
-	main/dlist.c \
-	main/dlopen.c \
-	main/drawpix.c \
-	main/drawtex.c \
-	main/enable.c \
-	main/enums.c \
-	main/eval.c \
-	main/execmem.c \
-	main/extensions.c \
-	main/fbobject.c \
-	main/feedback.c \
-	main/ffvertex_prog.c \
-	main/fog.c \
-	main/formats.c \
-	main/framebuffer.c \
-	main/get.c \
-	main/getstring.c \
-	main/hash.c \
-	main/hint.c \
-	main/histogram.c \
-	main/image.c \
-	main/imports.c \
-	main/light.c \
-	main/lines.c \
-	main/matrix.c \
-	main/mipmap.c \
-	main/mm.c \
-	main/multisample.c \
-	main/nvprogram.c \
-	main/pack.c \
-	main/pbo.c \
-	main/pixel.c \
-	main/pixelstore.c \
-	main/pixeltransfer.c \
-	main/points.c \
-	main/polygon.c \
-	main/queryobj.c \
-	main/querymatrix.c \
-	main/rastpos.c \
-	main/readpix.c \
-	main/remap.c \
-	main/renderbuffer.c \
-	main/scissor.c \
-	main/shaderapi.c \
-	main/shaderobj.c \
-	main/shared.c \
-	main/state.c \
-	main/stencil.c \
-	main/syncobj.c \
-	main/texcompress.c \
-	main/texcompress_rgtc.c \
-	main/texcompress_s3tc.c \
-	main/texcompress_fxt1.c \
-	main/texenv.c \
-	main/texenvprogram.c \
-	main/texfetch.c \
-	main/texformat.c \
-	main/texgen.c \
-	main/texgetimage.c \
-	main/teximage.c \
-	main/texobj.c \
-	main/texpal.c \
-	main/texparam.c \
-	main/texrender.c \
-	main/texstate.c \
-	main/texstore.c \
-	main/transformfeedback.c \
-	main/uniforms.c \
-	main/varray.c \
-	main/version.c \
-	main/viewport.c \
-	main/vtxfmt.c \
-	$(MAIN_ES_SOURCES)
-
-MATH_SOURCES = \
-	math/m_debug_clip.c \
-	math/m_debug_norm.c \
-	math/m_debug_xform.c \
-	math/m_eval.c \
-	math/m_matrix.c \
-	math/m_translate.c \
-	math/m_vector.c
-
-MATH_XFORM_SOURCES = \
-	math/m_xform.c
-
-SWRAST_SOURCES = \
-	swrast/s_aaline.c \
-	swrast/s_aatriangle.c \
-	swrast/s_accum.c \
-	swrast/s_alpha.c \
-	swrast/s_atifragshader.c \
-	swrast/s_bitmap.c \
-	swrast/s_blend.c \
-	swrast/s_blit.c \
-	swrast/s_clear.c \
-	swrast/s_copypix.c \
-	swrast/s_context.c \
-	swrast/s_depth.c \
-	swrast/s_drawpix.c \
-	swrast/s_feedback.c \
-	swrast/s_fog.c \
-	swrast/s_fragprog.c \
-	swrast/s_lines.c \
-	swrast/s_logic.c \
-	swrast/s_masking.c \
-	swrast/s_points.c \
-	swrast/s_readpix.c \
-	swrast/s_span.c \
-	swrast/s_stencil.c \
-	swrast/s_texcombine.c \
-	swrast/s_texfilter.c \
-	swrast/s_triangle.c \
-	swrast/s_zoom.c
-
-SWRAST_SETUP_SOURCES = \
-	swrast_setup/ss_context.c \
-	swrast_setup/ss_triangle.c 
-
-TNL_SOURCES = \
-	tnl/t_context.c \
-	tnl/t_pipeline.c \
-	tnl/t_draw.c \
-	tnl/t_rasterpos.c \
-	tnl/t_vb_program.c \
-	tnl/t_vb_render.c \
-	tnl/t_vb_texgen.c \
-	tnl/t_vb_texmat.c \
-	tnl/t_vb_vertex.c \
-	tnl/t_vb_fog.c \
-	tnl/t_vb_light.c \
-	tnl/t_vb_normals.c \
-	tnl/t_vb_points.c \
-	tnl/t_vp_build.c \
-	tnl/t_vertex.c \
-	tnl/t_vertex_sse.c \
-	tnl/t_vertex_generic.c 
-
-VBO_SOURCES = \
-	vbo/vbo_context.c \
-	vbo/vbo_exec.c \
-	vbo/vbo_exec_api.c \
-	vbo/vbo_exec_array.c \
-	vbo/vbo_exec_draw.c \
-	vbo/vbo_exec_eval.c \
-	vbo/vbo_rebase.c \
-	vbo/vbo_split.c \
-	vbo/vbo_split_copy.c \
-	vbo/vbo_split_inplace.c \
-	vbo/vbo_save.c \
-	vbo/vbo_save_api.c \
-	vbo/vbo_save_draw.c \
-	vbo/vbo_save_loopback.c 
-
-STATETRACKER_SOURCES = \
-	state_tracker/st_atom.c \
-	state_tracker/st_atom_blend.c \
-	state_tracker/st_atom_clip.c \
-	state_tracker/st_atom_constbuf.c \
-	state_tracker/st_atom_depth.c \
-	state_tracker/st_atom_framebuffer.c \
-	state_tracker/st_atom_msaa.c \
-	state_tracker/st_atom_pixeltransfer.c \
-	state_tracker/st_atom_sampler.c \
-	state_tracker/st_atom_scissor.c \
-	state_tracker/st_atom_shader.c \
-	state_tracker/st_atom_rasterizer.c \
-	state_tracker/st_atom_stipple.c \
-	state_tracker/st_atom_texture.c \
-	state_tracker/st_atom_viewport.c \
-	state_tracker/st_cb_accum.c \
-	state_tracker/st_cb_bitmap.c \
-	state_tracker/st_cb_blit.c \
-	state_tracker/st_cb_bufferobjects.c \
-	state_tracker/st_cb_clear.c \
-	state_tracker/st_cb_condrender.c \
-	state_tracker/st_cb_flush.c \
-	state_tracker/st_cb_drawpixels.c \
-	state_tracker/st_cb_drawtex.c \
-	state_tracker/st_cb_eglimage.c \
-	state_tracker/st_cb_fbo.c \
-	state_tracker/st_cb_feedback.c \
-	state_tracker/st_cb_program.c \
-	state_tracker/st_cb_queryobj.c \
-	state_tracker/st_cb_rasterpos.c \
-	state_tracker/st_cb_readpixels.c \
-	state_tracker/st_cb_syncobj.c \
-	state_tracker/st_cb_strings.c \
-	state_tracker/st_cb_texture.c \
-	state_tracker/st_cb_viewport.c \
-	state_tracker/st_cb_xformfb.c \
-	state_tracker/st_context.c \
-	state_tracker/st_debug.c \
-	state_tracker/st_draw.c \
-	state_tracker/st_draw_feedback.c \
-	state_tracker/st_extensions.c \
-	state_tracker/st_format.c \
-	state_tracker/st_gen_mipmap.c \
-	state_tracker/st_manager.c \
-	state_tracker/st_mesa_to_tgsi.c \
-	state_tracker/st_program.c \
-	state_tracker/st_texture.c
-
-PROGRAM_SOURCES = \
-	program/arbprogparse.c \
-	program/hash_table.c \
-	program/lex.yy.c \
-	program/nvfragparse.c \
-	program/nvvertparse.c \
-	program/program.c \
-	program/program_parse.tab.c \
-	program/program_parse_extra.c \
-	program/prog_cache.c \
-	program/prog_execute.c \
-	program/prog_instruction.c \
-	program/prog_noise.c \
-	program/prog_optimize.c \
-	program/prog_parameter.c \
-	program/prog_parameter_layout.c \
-	program/prog_print.c \
-	program/prog_statevars.c \
-	program/prog_uniform.c \
-	program/programopt.c \
-	program/register_allocate.c \
-	program/symbol_table.c
-
-
-SHADER_CXX_SOURCES = \
-	program/ir_to_mesa.cpp \
-	program/sampler.cpp
-
-ASM_C_SOURCES =	\
-	x86/common_x86.c \
-	x86/x86_xform.c \
-	x86/3dnow.c \
-	x86/sse.c \
-	x86/rtasm/x86sse.c \
-	sparc/sparc.c \
-	ppc/common_ppc.c \
-	x86-64/x86-64.c
-
-X86_SOURCES =			\
-	x86/common_x86_asm.S	\
-	x86/x86_xform2.S	\
-	x86/x86_xform3.S	\
-	x86/x86_xform4.S	\
-	x86/x86_cliptest.S	\
-	x86/mmx_blend.S		\
-	x86/3dnow_xform1.S	\
-	x86/3dnow_xform2.S	\
-	x86/3dnow_xform3.S	\
-	x86/3dnow_xform4.S	\
-	x86/3dnow_normal.S	\
-	x86/sse_xform1.S	\
-	x86/sse_xform2.S	\
-	x86/sse_xform3.S	\
-	x86/sse_xform4.S	\
-	x86/sse_normal.S	\
-	x86/read_rgba_span_x86.S
-
-X86-64_SOURCES =		\
-	x86-64/xform4.S
-
-SPARC_SOURCES =			\
-	sparc/clip.S		\
-	sparc/norm.S		\
-	sparc/xform.S
-
-COMMON_DRIVER_SOURCES =			\
-	drivers/common/driverfuncs.c	\
-	drivers/common/meta.c
-
-
-# Sources for building non-Gallium drivers
-MESA_SOURCES = \
-	$(MAIN_SOURCES)		\
-	$(MATH_SOURCES)		\
-	$(MATH_XFORM_SOURCES)	\
-	$(VBO_SOURCES)		\
-	$(TNL_SOURCES)		\
-	$(PROGRAM_SOURCES)	\
-	$(SWRAST_SOURCES)	\
-	$(SWRAST_SETUP_SOURCES)	\
-	$(COMMON_DRIVER_SOURCES)\
-	$(ASM_C_SOURCES)
-
-MESA_CXX_SOURCES = \
-	 $(SHADER_CXX_SOURCES)
-
-# Sources for building Gallium drivers
-MESA_GALLIUM_SOURCES = \
-	$(MAIN_SOURCES)		\
-	$(MATH_SOURCES)		\
-	$(VBO_SOURCES)		\
-	$(STATETRACKER_SOURCES)	\
-	$(PROGRAM_SOURCES)	\
-	ppc/common_ppc.c	\
-	x86/common_x86.c
-
-MESA_GALLIUM_CXX_SOURCES = \
-	 $(SHADER_CXX_SOURCES)
-
-# All the core C sources, for dependency checking
-ALL_SOURCES = \
-	$(MESA_SOURCES)		\
-	$(MESA_CXX_SOURCES)	\
-	$(MESA_ASM_SOURCES)	\
-	$(STATETRACKER_SOURCES)
-
-
-### Object files
-
-MESA_OBJECTS = \
-	$(MESA_SOURCES:.c=.o) \
-	$(MESA_CXX_SOURCES:.cpp=.o) \
-	$(MESA_ASM_SOURCES:.S=.o)
-
-MESA_GALLIUM_OBJECTS = \
-	$(MESA_GALLIUM_SOURCES:.c=.o) \
-	$(MESA_GALLIUM_CXX_SOURCES:.cpp=.o) \
-	$(MESA_ASM_SOURCES:.S=.o)
-
-
-COMMON_DRIVER_OBJECTS = $(COMMON_DRIVER_SOURCES:.c=.o)
-
-
-### Other archives/libraries
-
-GLSL_LIBS = \
-	$(TOP)/src/glsl/libglsl.a
-
-
-### Include directories
-
-INCLUDE_DIRS = \
-	-I$(TOP)/include \
-	-I$(TOP)/src/glsl \
-	-I$(TOP)/src/mesa \
-	-I$(TOP)/src/mapi \
-	-I$(TOP)/src/gallium/include \
-	-I$(TOP)/src/gallium/auxiliary
+### Lists of source files, included by Makefiles

+

+# this is part of MAIN_SOURCES

+MAIN_ES_SOURCES = \

+	main/api_exec_es1.c \

+	main/api_exec_es2.c

+

+MAIN_SOURCES = \

+	main/api_arrayelt.c \

+	main/api_exec.c \

+	main/api_loopback.c \

+	main/api_noop.c \

+	main/api_validate.c \

+	main/accum.c \

+	main/arbprogram.c \

+	main/atifragshader.c \

+	main/attrib.c \

+	main/arrayobj.c \

+	main/blend.c \

+	main/bufferobj.c \

+	main/buffers.c \

+	main/clear.c \

+	main/clip.c \

+	main/colortab.c \

+	main/condrender.c \

+	main/context.c \

+	main/convolve.c \

+	main/cpuinfo.c \

+	main/debug.c \

+	main/depth.c \

+	main/depthstencil.c \

+	main/dlist.c \

+	main/dlopen.c \

+	main/drawpix.c \

+	main/drawtex.c \

+	main/enable.c \

+	main/enums.c \

+	main/eval.c \

+	main/execmem.c \

+	main/extensions.c \

+	main/fbobject.c \

+	main/feedback.c \

+	main/ffvertex_prog.c \

+	main/fog.c \

+	main/formats.c \

+	main/framebuffer.c \

+	main/get.c \

+	main/getstring.c \

+	main/hash.c \

+	main/hint.c \

+	main/histogram.c \

+	main/image.c \

+	main/imports.c \

+	main/light.c \

+	main/lines.c \

+	main/matrix.c \

+	main/mipmap.c \

+	main/mm.c \

+	main/multisample.c \

+	main/nvprogram.c \

+	main/pack.c \

+	main/pbo.c \

+	main/pixel.c \

+	main/pixelstore.c \

+	main/pixeltransfer.c \

+	main/points.c \

+	main/polygon.c \

+	main/queryobj.c \

+	main/querymatrix.c \

+	main/rastpos.c \

+	main/readpix.c \

+	main/remap.c \

+	main/renderbuffer.c \

+	main/scissor.c \

+	main/shaderapi.c \

+	main/shaderobj.c \

+	main/shared.c \

+	main/state.c \

+	main/stencil.c \

+	main/syncobj.c \

+	main/texcompress.c \

+	main/texcompress_rgtc.c \

+	main/texcompress_s3tc.c \

+	main/texcompress_fxt1.c \

+	main/texenv.c \

+	main/texfetch.c \

+	main/texformat.c \

+	main/texgen.c \

+	main/texgetimage.c \

+	main/teximage.c \

+	main/texobj.c \

+	main/texpal.c \

+	main/texparam.c \

+	main/texrender.c \

+	main/texstate.c \

+	main/texstore.c \

+	main/transformfeedback.c \

+	main/uniforms.c \

+	main/varray.c \

+	main/version.c \

+	main/viewport.c \

+	main/vtxfmt.c \

+	$(MAIN_ES_SOURCES)

+

+MAIN_CXX_SOURCES = \

+	main/ff_fragment_shader.cpp

+

+MATH_SOURCES = \

+	math/m_debug_clip.c \

+	math/m_debug_norm.c \

+	math/m_debug_xform.c \

+	math/m_eval.c \

+	math/m_matrix.c \

+	math/m_translate.c \

+	math/m_vector.c

+

+MATH_XFORM_SOURCES = \

+	math/m_xform.c

+

+SWRAST_SOURCES = \

+	swrast/s_aaline.c \

+	swrast/s_aatriangle.c \

+	swrast/s_accum.c \

+	swrast/s_alpha.c \

+	swrast/s_atifragshader.c \

+	swrast/s_bitmap.c \

+	swrast/s_blend.c \

+	swrast/s_blit.c \

+	swrast/s_clear.c \

+	swrast/s_copypix.c \

+	swrast/s_context.c \

+	swrast/s_depth.c \

+	swrast/s_drawpix.c \

+	swrast/s_feedback.c \

+	swrast/s_fog.c \

+	swrast/s_fragprog.c \

+	swrast/s_lines.c \

+	swrast/s_logic.c \

+	swrast/s_masking.c \

+	swrast/s_points.c \

+	swrast/s_readpix.c \

+	swrast/s_span.c \

+	swrast/s_stencil.c \

+	swrast/s_texcombine.c \

+	swrast/s_texfilter.c \

+	swrast/s_triangle.c \

+	swrast/s_zoom.c

+

+SWRAST_SETUP_SOURCES = \

+	swrast_setup/ss_context.c \

+	swrast_setup/ss_triangle.c 

+

+TNL_SOURCES = \

+	tnl/t_context.c \

+	tnl/t_pipeline.c \

+	tnl/t_draw.c \

+	tnl/t_rasterpos.c \

+	tnl/t_vb_program.c \

+	tnl/t_vb_render.c \

+	tnl/t_vb_texgen.c \

+	tnl/t_vb_texmat.c \

+	tnl/t_vb_vertex.c \

+	tnl/t_vb_fog.c \

+	tnl/t_vb_light.c \

+	tnl/t_vb_normals.c \

+	tnl/t_vb_points.c \

+	tnl/t_vp_build.c \

+	tnl/t_vertex.c \

+	tnl/t_vertex_sse.c \

+	tnl/t_vertex_generic.c 

+

+VBO_SOURCES = \

+	vbo/vbo_context.c \

+	vbo/vbo_exec.c \

+	vbo/vbo_exec_api.c \

+	vbo/vbo_exec_array.c \

+	vbo/vbo_exec_draw.c \

+	vbo/vbo_exec_eval.c \

+	vbo/vbo_rebase.c \

+	vbo/vbo_split.c \

+	vbo/vbo_split_copy.c \

+	vbo/vbo_split_inplace.c \

+	vbo/vbo_save.c \

+	vbo/vbo_save_api.c \

+	vbo/vbo_save_draw.c \

+	vbo/vbo_save_loopback.c 

+

+STATETRACKER_SOURCES = \

+	state_tracker/st_atom.c \

+	state_tracker/st_atom_blend.c \

+	state_tracker/st_atom_clip.c \

+	state_tracker/st_atom_constbuf.c \

+	state_tracker/st_atom_depth.c \

+	state_tracker/st_atom_framebuffer.c \

+	state_tracker/st_atom_msaa.c \

+	state_tracker/st_atom_pixeltransfer.c \

+	state_tracker/st_atom_sampler.c \

+	state_tracker/st_atom_scissor.c \

+	state_tracker/st_atom_shader.c \

+	state_tracker/st_atom_rasterizer.c \

+	state_tracker/st_atom_stipple.c \

+	state_tracker/st_atom_texture.c \

+	state_tracker/st_atom_viewport.c \

+	state_tracker/st_cb_accum.c \

+	state_tracker/st_cb_bitmap.c \

+	state_tracker/st_cb_blit.c \

+	state_tracker/st_cb_bufferobjects.c \

+	state_tracker/st_cb_clear.c \

+	state_tracker/st_cb_condrender.c \

+	state_tracker/st_cb_flush.c \

+	state_tracker/st_cb_drawpixels.c \

+	state_tracker/st_cb_drawtex.c \

+	state_tracker/st_cb_eglimage.c \

+	state_tracker/st_cb_fbo.c \

+	state_tracker/st_cb_feedback.c \

+	state_tracker/st_cb_program.c \

+	state_tracker/st_cb_queryobj.c \

+	state_tracker/st_cb_rasterpos.c \

+	state_tracker/st_cb_readpixels.c \

+	state_tracker/st_cb_syncobj.c \

+	state_tracker/st_cb_strings.c \

+	state_tracker/st_cb_texture.c \

+	state_tracker/st_cb_viewport.c \

+	state_tracker/st_cb_xformfb.c \

+	state_tracker/st_context.c \

+	state_tracker/st_debug.c \

+	state_tracker/st_draw.c \

+	state_tracker/st_draw_feedback.c \

+	state_tracker/st_extensions.c \

+	state_tracker/st_format.c \

+	state_tracker/st_gen_mipmap.c \

+	state_tracker/st_manager.c \

+	state_tracker/st_mesa_to_tgsi.c \

+	state_tracker/st_program.c \

+	state_tracker/st_texture.c

+

+PROGRAM_SOURCES = \

+	program/arbprogparse.c \

+	program/hash_table.c \

+	program/lex.yy.c \

+	program/nvfragparse.c \

+	program/nvvertparse.c \

+	program/program.c \

+	program/program_parse.tab.c \

+	program/program_parse_extra.c \

+	program/prog_cache.c \

+	program/prog_execute.c \

+	program/prog_instruction.c \

+	program/prog_noise.c \

+	program/prog_optimize.c \

+	program/prog_parameter.c \

+	program/prog_parameter_layout.c \

+	program/prog_print.c \

+	program/prog_statevars.c \

+	program/prog_uniform.c \

+	program/programopt.c \

+	program/register_allocate.c \

+	program/symbol_table.c

+

+

+SHADER_CXX_SOURCES = \

+	program/ir_to_mesa.cpp \

+	program/sampler.cpp

+

+ASM_C_SOURCES =	\

+	x86/common_x86.c \

+	x86/x86_xform.c \

+	x86/3dnow.c \

+	x86/sse.c \

+	x86/rtasm/x86sse.c \

+	sparc/sparc.c \

+	ppc/common_ppc.c \

+	x86-64/x86-64.c

+

+X86_SOURCES =			\

+	x86/common_x86_asm.S	\

+	x86/x86_xform2.S	\

+	x86/x86_xform3.S	\

+	x86/x86_xform4.S	\

+	x86/x86_cliptest.S	\

+	x86/mmx_blend.S		\

+	x86/3dnow_xform1.S	\

+	x86/3dnow_xform2.S	\

+	x86/3dnow_xform3.S	\

+	x86/3dnow_xform4.S	\

+	x86/3dnow_normal.S	\

+	x86/sse_xform1.S	\

+	x86/sse_xform2.S	\

+	x86/sse_xform3.S	\

+	x86/sse_xform4.S	\

+	x86/sse_normal.S	\

+	x86/read_rgba_span_x86.S

+

+X86-64_SOURCES =		\

+	x86-64/xform4.S

+

+SPARC_SOURCES =			\

+	sparc/clip.S		\

+	sparc/norm.S		\

+	sparc/xform.S

+

+COMMON_DRIVER_SOURCES =			\

+	drivers/common/driverfuncs.c	\

+	drivers/common/meta.c

+

+

+# Sources for building non-Gallium drivers

+MESA_SOURCES = \

+	$(MAIN_SOURCES)		\

+	$(MATH_SOURCES)		\

+	$(MATH_XFORM_SOURCES)	\

+	$(VBO_SOURCES)		\

+	$(TNL_SOURCES)		\

+	$(PROGRAM_SOURCES)	\

+	$(SWRAST_SOURCES)	\

+	$(SWRAST_SETUP_SOURCES)	\

+	$(COMMON_DRIVER_SOURCES)\

+	$(ASM_C_SOURCES)

+

+MESA_CXX_SOURCES = \

+	$(MAIN_CXX_SOURCES) \

+	$(SHADER_CXX_SOURCES)

+

+# Sources for building Gallium drivers

+MESA_GALLIUM_SOURCES = \

+	$(MAIN_SOURCES)		\

+	$(MATH_SOURCES)		\

+	$(VBO_SOURCES)		\

+	$(STATETRACKER_SOURCES)	\

+	$(PROGRAM_SOURCES)	\

+	ppc/common_ppc.c	\

+	x86/common_x86.c

+

+MESA_GALLIUM_CXX_SOURCES = \

+	$(MAIN_CXX_SOURCES) \

+	$(SHADER_CXX_SOURCES)

+

+# All the core C sources, for dependency checking

+ALL_SOURCES = \

+	$(MESA_SOURCES)		\

+	$(MESA_CXX_SOURCES)	\

+	$(MESA_ASM_SOURCES)	\

+	$(STATETRACKER_SOURCES)

+

+

+### Object files

+

+MESA_OBJECTS = \

+	$(MESA_SOURCES:.c=.o) \

+	$(MESA_CXX_SOURCES:.cpp=.o) \

+	$(MESA_ASM_SOURCES:.S=.o)

+

+MESA_GALLIUM_OBJECTS = \

+	$(MESA_GALLIUM_SOURCES:.c=.o) \

+	$(MESA_GALLIUM_CXX_SOURCES:.cpp=.o) \

+	$(MESA_ASM_SOURCES:.S=.o)

+

+

+COMMON_DRIVER_OBJECTS = $(COMMON_DRIVER_SOURCES:.c=.o)

+

+

+### Other archives/libraries

+

+GLSL_LIBS = \

+	$(TOP)/src/glsl/libglsl.a

+

+

+### Include directories

+

+INCLUDE_DIRS = \

+	-I$(TOP)/include \

+	-I$(TOP)/src/glsl \

+	-I$(TOP)/src/mesa \

+	-I$(TOP)/src/mapi \

+	-I$(TOP)/src/gallium/include \

+	-I$(TOP)/src/gallium/auxiliary

diff --git a/mesalib/src/mesa/state_tracker/st_cb_bitmap.c b/mesalib/src/mesa/state_tracker/st_cb_bitmap.c
index 149f1ca44..f49c03b46 100644
--- a/mesalib/src/mesa/state_tracker/st_cb_bitmap.c
+++ b/mesalib/src/mesa/state_tracker/st_cb_bitmap.c
@@ -1,894 +1,894 @@
-/**************************************************************************
- * 
- * Copyright 2007 Tungsten Graphics, Inc., Cedar Park, Texas.
- * 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, sub license, 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 (including the
- * next paragraph) 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 NON-INFRINGEMENT.
- * IN NO EVENT SHALL TUNGSTEN GRAPHICS AND/OR ITS SUPPLIERS 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.
- * 
- **************************************************************************/
-
- /*
-  * Authors:
-  *   Brian Paul
-  */
-
-#include "main/imports.h"
-#include "main/image.h"
-#include "main/bufferobj.h"
-#include "main/macros.h"
-#include "main/mfeatures.h"
-#include "main/pbo.h"
-#include "program/program.h"
-#include "program/prog_print.h"
-
-#include "st_context.h"
-#include "st_atom.h"
-#include "st_atom_constbuf.h"
-#include "st_program.h"
-#include "st_cb_bitmap.h"
-#include "st_texture.h"
-
-#include "pipe/p_context.h"
-#include "pipe/p_defines.h"
-#include "pipe/p_shader_tokens.h"
-#include "util/u_inlines.h"
-#include "util/u_draw_quad.h"
-#include "util/u_simple_shaders.h"
-#include "program/prog_instruction.h"
-#include "cso_cache/cso_context.h"
-
-
-#if FEATURE_drawpix
-
-/**
- * glBitmaps are drawn as textured quads.  The user's bitmap pattern
- * is stored in a texture image.  An alpha8 texture format is used.
- * The fragment shader samples a bit (texel) from the texture, then
- * discards the fragment if the bit is off.
- *
- * Note that we actually store the inverse image of the bitmap to
- * simplify the fragment program.  An "on" bit gets stored as texel=0x0
- * and an "off" bit is stored as texel=0xff.  Then we kill the
- * fragment if the negated texel value is less than zero.
- */
-
-
-/**
- * The bitmap cache attempts to accumulate multiple glBitmap calls in a
- * buffer which is then rendered en mass upon a flush, state change, etc.
- * A wide, short buffer is used to target the common case of a series
- * of glBitmap calls being used to draw text.
- */
-static GLboolean UseBitmapCache = GL_TRUE;
-
-
-#define BITMAP_CACHE_WIDTH  512
-#define BITMAP_CACHE_HEIGHT 32
-
-struct bitmap_cache
-{
-   /** Window pos to render the cached image */
-   GLint xpos, ypos;
-   /** Bounds of region used in window coords */
-   GLint xmin, ymin, xmax, ymax;
-
-   GLfloat color[4];
-
-   /** Bitmap's Z position */
-   GLfloat zpos;
-
-   struct pipe_resource *texture;
-   struct pipe_transfer *trans;
-
-   GLboolean empty;
-
-   /** An I8 texture image: */
-   ubyte *buffer;
-};
-
-
-/** Epsilon for Z comparisons */
-#define Z_EPSILON 1e-06
-
-
-/**
- * Make fragment program for glBitmap:
- *   Sample the texture and kill the fragment if the bit is 0.
- * This program will be combined with the user's fragment program.
- */
-static struct st_fragment_program *
-make_bitmap_fragment_program(struct gl_context *ctx, GLuint samplerIndex)
-{
-   struct st_context *st = st_context(ctx);
-   struct st_fragment_program *stfp;
-   struct gl_program *p;
-   GLuint ic = 0;
-
-   p = ctx->Driver.NewProgram(ctx, GL_FRAGMENT_PROGRAM_ARB, 0);
-   if (!p)
-      return NULL;
-
-   p->NumInstructions = 3;
-
-   p->Instructions = _mesa_alloc_instructions(p->NumInstructions);
-   if (!p->Instructions) {
-      ctx->Driver.DeleteProgram(ctx, p);
-      return NULL;
-   }
-   _mesa_init_instructions(p->Instructions, p->NumInstructions);
-
-   /* TEX tmp0, fragment.texcoord[0], texture[0], 2D; */
-   p->Instructions[ic].Opcode = OPCODE_TEX;
-   p->Instructions[ic].DstReg.File = PROGRAM_TEMPORARY;
-   p->Instructions[ic].DstReg.Index = 0;
-   p->Instructions[ic].SrcReg[0].File = PROGRAM_INPUT;
-   p->Instructions[ic].SrcReg[0].Index = FRAG_ATTRIB_TEX0;
-   p->Instructions[ic].TexSrcUnit = samplerIndex;
-   p->Instructions[ic].TexSrcTarget = TEXTURE_2D_INDEX;
-   ic++;
-
-   /* KIL if -tmp0 < 0 # texel=0 -> keep / texel=0 -> discard */
-   p->Instructions[ic].Opcode = OPCODE_KIL;
-   p->Instructions[ic].SrcReg[0].File = PROGRAM_TEMPORARY;
-
-   if (st->bitmap.tex_format == PIPE_FORMAT_L8_UNORM)
-      p->Instructions[ic].SrcReg[0].Swizzle = SWIZZLE_XXXX;
-
-   p->Instructions[ic].SrcReg[0].Index = 0;
-   p->Instructions[ic].SrcReg[0].Negate = NEGATE_XYZW;
-   ic++;
-
-   /* END; */
-   p->Instructions[ic++].Opcode = OPCODE_END;
-
-   assert(ic == p->NumInstructions);
-
-   p->InputsRead = FRAG_BIT_TEX0;
-   p->OutputsWritten = 0x0;
-   p->SamplersUsed = (1 << samplerIndex);
-
-   stfp = (struct st_fragment_program *) p;
-   stfp->Base.UsesKill = GL_TRUE;
-
-   return stfp;
-}
-
-
-static int
-find_free_bit(uint bitfield)
-{
-   int i;
-   for (i = 0; i < 32; i++) {
-      if ((bitfield & (1 << i)) == 0) {
-         return i;
-      }
-   }
-   return -1;
-}
-
-
-/**
- * Combine basic bitmap fragment program with the user-defined program.
- * \param st  current context
- * \param fpIn  the incoming fragment program
- * \param fpOut  the new fragment program which does fragment culling
- * \param bitmap_sampler  sampler number for the bitmap texture
- */
-void
-st_make_bitmap_fragment_program(struct st_context *st,
-                                struct gl_fragment_program *fpIn,
-                                struct gl_fragment_program **fpOut,
-                                GLuint *bitmap_sampler)
-{
-   struct st_fragment_program *bitmap_prog;
-   struct gl_program *newProg;
-   uint sampler;
-
-   /*
-    * Generate new program which is the user-defined program prefixed
-    * with the bitmap sampler/kill instructions.
-    */
-   sampler = find_free_bit(fpIn->Base.SamplersUsed);
-   bitmap_prog = make_bitmap_fragment_program(st->ctx, sampler);
-
-   newProg = _mesa_combine_programs(st->ctx,
-                                    &bitmap_prog->Base.Base,
-                                    &fpIn->Base);
-   /* done with this after combining */
-   st_reference_fragprog(st, &bitmap_prog, NULL);
-
-#if 0
-   {
-      printf("Combined bitmap program:\n");
-      _mesa_print_program(newProg);
-      printf("InputsRead: 0x%x\n", newProg->InputsRead);
-      printf("OutputsWritten: 0x%x\n", newProg->OutputsWritten);
-      _mesa_print_parameter_list(newProg->Parameters);
-   }
-#endif
-
-   /* return results */
-   *fpOut = (struct gl_fragment_program *) newProg;
-   *bitmap_sampler = sampler;
-}
-
-
-/**
- * Copy user-provide bitmap bits into texture buffer, expanding
- * bits into texels.
- * "On" bits will set texels to 0x0.
- * "Off" bits will not modify texels.
- * Note that the image is actually going to be upside down in
- * the texture.  We deal with that with texcoords.
- */
-static void
-unpack_bitmap(struct st_context *st,
-              GLint px, GLint py, GLsizei width, GLsizei height,
-              const struct gl_pixelstore_attrib *unpack,
-              const GLubyte *bitmap,
-              ubyte *destBuffer, uint destStride)
-{
-   destBuffer += py * destStride + px;
-
-   _mesa_expand_bitmap(width, height, unpack, bitmap,
-                       destBuffer, destStride, 0x0);
-}
-
-
-/**
- * Create a texture which represents a bitmap image.
- */
-static struct pipe_resource *
-make_bitmap_texture(struct gl_context *ctx, GLsizei width, GLsizei height,
-                    const struct gl_pixelstore_attrib *unpack,
-                    const GLubyte *bitmap)
-{
-   struct st_context *st = st_context(ctx);
-   struct pipe_context *pipe = st->pipe;
-   struct pipe_transfer *transfer;
-   ubyte *dest;
-   struct pipe_resource *pt;
-
-   /* PBO source... */
-   bitmap = _mesa_map_pbo_source(ctx, unpack, bitmap);
-   if (!bitmap) {
-      return NULL;
-   }
-
-   /**
-    * Create texture to hold bitmap pattern.
-    */
-   pt = st_texture_create(st, st->internal_target, st->bitmap.tex_format,
-                          0, width, height, 1, 1,
-                          PIPE_BIND_SAMPLER_VIEW);
-   if (!pt) {
-      _mesa_unmap_pbo_source(ctx, unpack);
-      return NULL;
-   }
-
-   transfer = pipe_get_transfer(st->pipe, pt, 0, 0,
-                                PIPE_TRANSFER_WRITE,
-                                0, 0, width, height);
-
-   dest = pipe_transfer_map(pipe, transfer);
-
-   /* Put image into texture transfer */
-   memset(dest, 0xff, height * transfer->stride);
-   unpack_bitmap(st, 0, 0, width, height, unpack, bitmap,
-                 dest, transfer->stride);
-
-   _mesa_unmap_pbo_source(ctx, unpack);
-
-   /* Release transfer */
-   pipe_transfer_unmap(pipe, transfer);
-   pipe->transfer_destroy(pipe, transfer);
-
-   return pt;
-}
-
-static GLuint
-setup_bitmap_vertex_data(struct st_context *st, bool normalized,
-                         int x, int y, int width, int height,
-                         float z, const float color[4])
-{
-   struct pipe_context *pipe = st->pipe;
-   const struct gl_framebuffer *fb = st->ctx->DrawBuffer;
-   const GLfloat fb_width = (GLfloat)fb->Width;
-   const GLfloat fb_height = (GLfloat)fb->Height;
-   const GLfloat x0 = (GLfloat)x;
-   const GLfloat x1 = (GLfloat)(x + width);
-   const GLfloat y0 = (GLfloat)y;
-   const GLfloat y1 = (GLfloat)(y + height);
-   GLfloat sLeft = (GLfloat)0.0, sRight = (GLfloat)1.0;
-   GLfloat tTop = (GLfloat)0.0, tBot = (GLfloat)1.0 - tTop;
-   const GLfloat clip_x0 = (GLfloat)(x0 / fb_width * 2.0 - 1.0);
-   const GLfloat clip_y0 = (GLfloat)(y0 / fb_height * 2.0 - 1.0);
-   const GLfloat clip_x1 = (GLfloat)(x1 / fb_width * 2.0 - 1.0);
-   const GLfloat clip_y1 = (GLfloat)(y1 / fb_height * 2.0 - 1.0);
-   const GLuint max_slots = 1; /* 4096 / sizeof(st->bitmap.vertices); */
-   GLuint i;
-
-   if(!normalized)
-   {
-      sRight = width;
-      tBot = height;
-   }
-
-   /* XXX: Need to improve buffer_write to allow NO_WAIT (as well as
-    * no_flush) updates to buffers where we know there is no conflict
-    * with previous data.  Currently using max_slots > 1 will cause
-    * synchronous rendering if the driver flushes its command buffers
-    * between one bitmap and the next.  Our flush hook below isn't
-    * sufficient to catch this as the driver doesn't tell us when it
-    * flushes its own command buffers.  Until this gets fixed, pay the
-    * price of allocating a new buffer for each bitmap cache-flush to
-    * avoid synchronous rendering.
-    */
-   if (st->bitmap.vbuf_slot >= max_slots) {
-      pipe_resource_reference(&st->bitmap.vbuf, NULL);
-      st->bitmap.vbuf_slot = 0;
-   }
-
-   if (!st->bitmap.vbuf) {
-      st->bitmap.vbuf = pipe_buffer_create(pipe->screen, 
-                                           PIPE_BIND_VERTEX_BUFFER,
-                                           PIPE_USAGE_STREAM,
-                                           max_slots *
-                                           sizeof(st->bitmap.vertices));
-   }
-
-   /* Positions are in clip coords since we need to do clipping in case
-    * the bitmap quad goes beyond the window bounds.
-    */
-   st->bitmap.vertices[0][0][0] = clip_x0;
-   st->bitmap.vertices[0][0][1] = clip_y0;
-   st->bitmap.vertices[0][2][0] = sLeft;
-   st->bitmap.vertices[0][2][1] = tTop;
-
-   st->bitmap.vertices[1][0][0] = clip_x1;
-   st->bitmap.vertices[1][0][1] = clip_y0;
-   st->bitmap.vertices[1][2][0] = sRight;
-   st->bitmap.vertices[1][2][1] = tTop;
-   
-   st->bitmap.vertices[2][0][0] = clip_x1;
-   st->bitmap.vertices[2][0][1] = clip_y1;
-   st->bitmap.vertices[2][2][0] = sRight;
-   st->bitmap.vertices[2][2][1] = tBot;
-   
-   st->bitmap.vertices[3][0][0] = clip_x0;
-   st->bitmap.vertices[3][0][1] = clip_y1;
-   st->bitmap.vertices[3][2][0] = sLeft;
-   st->bitmap.vertices[3][2][1] = tBot;
-   
-   /* same for all verts: */
-   for (i = 0; i < 4; i++) {
-      st->bitmap.vertices[i][0][2] = z;
-      st->bitmap.vertices[i][0][3] = 1.0;
-      st->bitmap.vertices[i][1][0] = color[0];
-      st->bitmap.vertices[i][1][1] = color[1];
-      st->bitmap.vertices[i][1][2] = color[2];
-      st->bitmap.vertices[i][1][3] = color[3];
-      st->bitmap.vertices[i][2][2] = 0.0; /*R*/
-      st->bitmap.vertices[i][2][3] = 1.0; /*Q*/
-   }
-
-   /* put vertex data into vbuf */
-   pipe_buffer_write_nooverlap(st->pipe,
-                               st->bitmap.vbuf,
-                               st->bitmap.vbuf_slot
-                               * sizeof(st->bitmap.vertices),
-                               sizeof st->bitmap.vertices,
-                               st->bitmap.vertices);
-
-   return st->bitmap.vbuf_slot++ * sizeof st->bitmap.vertices;
-}
-
-
-
-/**
- * Render a glBitmap by drawing a textured quad
- */
-static void
-draw_bitmap_quad(struct gl_context *ctx, GLint x, GLint y, GLfloat z,
-                 GLsizei width, GLsizei height,
-                 struct pipe_sampler_view *sv,
-                 const GLfloat *color)
-{
-   struct st_context *st = st_context(ctx);
-   struct pipe_context *pipe = st->pipe;
-   struct cso_context *cso = st->cso_context;
-   struct st_fp_variant *fpv;
-   struct st_fp_variant_key key;
-   GLuint maxSize;
-   GLuint offset;
-
-   memset(&key, 0, sizeof(key));
-   key.st = st;
-   key.bitmap = GL_TRUE;
-
-   fpv = st_get_fp_variant(st, st->fp, &key);
-
-   /* As an optimization, Mesa's fragment programs will sometimes get the
-    * primary color from a statevar/constant rather than a varying variable.
-    * when that's the case, we need to ensure that we use the 'color'
-    * parameter and not the current attribute color (which may have changed
-    * through glRasterPos and state validation.
-    * So, we force the proper color here.  Not elegant, but it works.
-    */
-   {
-      GLfloat colorSave[4];
-      COPY_4V(colorSave, ctx->Current.Attrib[VERT_ATTRIB_COLOR0]);
-      COPY_4V(ctx->Current.Attrib[VERT_ATTRIB_COLOR0], color);
-      st_upload_constants(st, fpv->parameters, PIPE_SHADER_FRAGMENT);
-      COPY_4V(ctx->Current.Attrib[VERT_ATTRIB_COLOR0], colorSave);
-   }
-
-
-   /* limit checks */
-   /* XXX if the bitmap is larger than the max texture size, break
-    * it up into chunks.
-    */
-   maxSize = 1 << (pipe->screen->get_param(pipe->screen,
-                                    PIPE_CAP_MAX_TEXTURE_2D_LEVELS) - 1);
-   assert(width <= (GLsizei)maxSize);
-   assert(height <= (GLsizei)maxSize);
-
-   cso_save_rasterizer(cso);
-   cso_save_samplers(cso);
-   cso_save_fragment_sampler_views(cso);
-   cso_save_viewport(cso);
-   cso_save_fragment_shader(cso);
-   cso_save_vertex_shader(cso);
-   cso_save_vertex_elements(cso);
-   cso_save_vertex_buffers(cso);
-
-   /* rasterizer state: just scissor */
-   st->bitmap.rasterizer.scissor = ctx->Scissor.Enabled;
-   cso_set_rasterizer(cso, &st->bitmap.rasterizer);
-
-   /* fragment shader state: TEX lookup program */
-   cso_set_fragment_shader_handle(cso, fpv->driver_shader);
-
-   /* vertex shader state: position + texcoord pass-through */
-   cso_set_vertex_shader_handle(cso, st->bitmap.vs);
-
-   /* user samplers, plus our bitmap sampler */
-   {
-      struct pipe_sampler_state *samplers[PIPE_MAX_SAMPLERS];
-      uint num = MAX2(fpv->bitmap_sampler + 1, st->state.num_samplers);
-      uint i;
-      for (i = 0; i < st->state.num_samplers; i++) {
-         samplers[i] = &st->state.samplers[i];
-      }
-      samplers[fpv->bitmap_sampler] =
-         &st->bitmap.samplers[sv->texture->target != PIPE_TEXTURE_RECT];
-      cso_set_samplers(cso, num, (const struct pipe_sampler_state **) samplers);
-   }
-
-   /* user textures, plus the bitmap texture */
-   {
-      struct pipe_sampler_view *sampler_views[PIPE_MAX_SAMPLERS];
-      uint num = MAX2(fpv->bitmap_sampler + 1, st->state.num_textures);
-      memcpy(sampler_views, st->state.sampler_views, sizeof(sampler_views));
-      sampler_views[fpv->bitmap_sampler] = sv;
-      cso_set_fragment_sampler_views(cso, num, sampler_views);
-   }
-
-   /* viewport state: viewport matching window dims */
-   {
-      const struct gl_framebuffer *fb = st->ctx->DrawBuffer;
-      const GLboolean invert = (st_fb_orientation(fb) == Y_0_TOP);
-      const GLfloat width = (GLfloat)fb->Width;
-      const GLfloat height = (GLfloat)fb->Height;
-      struct pipe_viewport_state vp;
-      vp.scale[0] =  0.5f * width;
-      vp.scale[1] = height * (invert ? -0.5f : 0.5f);
-      vp.scale[2] = 0.5f;
-      vp.scale[3] = 1.0f;
-      vp.translate[0] = 0.5f * width;
-      vp.translate[1] = 0.5f * height;
-      vp.translate[2] = 0.5f;
-      vp.translate[3] = 0.0f;
-      cso_set_viewport(cso, &vp);
-   }
-
-   cso_set_vertex_elements(cso, 3, st->velems_util_draw);
-
-   /* convert Z from [0,1] to [-1,-1] to match viewport Z scale/bias */
-   z = z * 2.0 - 1.0;
-
-   /* draw textured quad */
-   offset = setup_bitmap_vertex_data(st,
-                                     sv->texture->target != PIPE_TEXTURE_RECT,
-                                     x, y, width, height, z, color);
-
-   util_draw_vertex_buffer(pipe, st->cso_context, st->bitmap.vbuf, offset,
-                           PIPE_PRIM_TRIANGLE_FAN,
-                           4,  /* verts */
-                           3); /* attribs/vert */
-
-
-   /* restore state */
-   cso_restore_rasterizer(cso);
-   cso_restore_samplers(cso);
-   cso_restore_fragment_sampler_views(cso);
-   cso_restore_viewport(cso);
-   cso_restore_fragment_shader(cso);
-   cso_restore_vertex_shader(cso);
-   cso_restore_vertex_elements(cso);
-   cso_restore_vertex_buffers(cso);
-}
-
-
-static void
-reset_cache(struct st_context *st)
-{
-   struct pipe_context *pipe = st->pipe;
-   struct bitmap_cache *cache = st->bitmap.cache;
-
-   /*memset(cache->buffer, 0xff, sizeof(cache->buffer));*/
-   cache->empty = GL_TRUE;
-
-   cache->xmin = 1000000;
-   cache->xmax = -1000000;
-   cache->ymin = 1000000;
-   cache->ymax = -1000000;
-
-   if (cache->trans) {
-      pipe->transfer_destroy(pipe, cache->trans);
-      cache->trans = NULL;
-   }
-
-   assert(!cache->texture);
-
-   /* allocate a new texture */
-   cache->texture = st_texture_create(st, PIPE_TEXTURE_2D,
-                                      st->bitmap.tex_format, 0,
-                                      BITMAP_CACHE_WIDTH, BITMAP_CACHE_HEIGHT,
-                                      1, 1,
-				      PIPE_BIND_SAMPLER_VIEW);
-}
-
-
-/** Print bitmap image to stdout (debug) */
-static void
-print_cache(const struct bitmap_cache *cache)
-{
-   int i, j, k;
-
-   for (i = 0; i < BITMAP_CACHE_HEIGHT; i++) {
-      k = BITMAP_CACHE_WIDTH * (BITMAP_CACHE_HEIGHT - i - 1);
-      for (j = 0; j < BITMAP_CACHE_WIDTH; j++) {
-         if (cache->buffer[k])
-            printf("X");
-         else
-            printf(" ");
-         k++;
-      }
-      printf("\n");
-   }
-}
-
-
-/**
- * Create gallium pipe_transfer object for the bitmap cache.
- */
-static void
-create_cache_trans(struct st_context *st)
-{
-   struct pipe_context *pipe = st->pipe;
-   struct bitmap_cache *cache = st->bitmap.cache;
-
-   if (cache->trans)
-      return;
-
-   /* Map the texture transfer.
-    * Subsequent glBitmap calls will write into the texture image.
-    */
-   cache->trans = pipe_get_transfer(st->pipe, cache->texture, 0, 0,
-                                    PIPE_TRANSFER_WRITE, 0, 0,
-                                    BITMAP_CACHE_WIDTH,
-                                    BITMAP_CACHE_HEIGHT);
-   cache->buffer = pipe_transfer_map(pipe, cache->trans);
-
-   /* init image to all 0xff */
-   memset(cache->buffer, 0xff, cache->trans->stride * BITMAP_CACHE_HEIGHT);
-}
-
-
-/**
- * If there's anything in the bitmap cache, draw/flush it now.
- */
-void
-st_flush_bitmap_cache(struct st_context *st)
-{
-   if (!st->bitmap.cache->empty) {
-      struct bitmap_cache *cache = st->bitmap.cache;
-
-      if (st->ctx->DrawBuffer) {
-         struct pipe_context *pipe = st->pipe;
-         struct pipe_sampler_view *sv;
-
-         assert(cache->xmin <= cache->xmax);
- 
-/*         printf("flush size %d x %d  at %d, %d\n",
-                cache->xmax - cache->xmin,
-                cache->ymax - cache->ymin,
-                cache->xpos, cache->ypos);
-*/
-
-         /* The texture transfer has been mapped until now.
-          * So unmap and release the texture transfer before drawing.
-          */
-         if (cache->trans) {
-            if (0)
-               print_cache(cache);
-            pipe_transfer_unmap(pipe, cache->trans);
-            cache->buffer = NULL;
-
-            pipe->transfer_destroy(pipe, cache->trans);
-            cache->trans = NULL;
-         }
-
-         sv = st_create_texture_sampler_view(st->pipe, cache->texture);
-         if (sv) {
-            draw_bitmap_quad(st->ctx,
-                             cache->xpos,
-                             cache->ypos,
-                             cache->zpos,
-                             BITMAP_CACHE_WIDTH, BITMAP_CACHE_HEIGHT,
-                             sv,
-                             cache->color);
-
-            pipe_sampler_view_reference(&sv, NULL);
-         }
-      }
-
-      /* release/free the texture */
-      pipe_resource_reference(&cache->texture, NULL);
-
-      reset_cache(st);
-   }
-}
-
-
-/**
- * Flush bitmap cache and release vertex buffer.
- */
-void
-st_flush_bitmap( struct st_context *st )
-{
-   st_flush_bitmap_cache(st);
-
-   /* Release vertex buffer to avoid synchronous rendering if we were
-    * to map it in the next frame.
-    */
-   pipe_resource_reference(&st->bitmap.vbuf, NULL);
-   st->bitmap.vbuf_slot = 0;
-}
-
-
-/**
- * Try to accumulate this glBitmap call in the bitmap cache.
- * \return  GL_TRUE for success, GL_FALSE if bitmap is too large, etc.
- */
-static GLboolean
-accum_bitmap(struct st_context *st,
-             GLint x, GLint y, GLsizei width, GLsizei height,
-             const struct gl_pixelstore_attrib *unpack,
-             const GLubyte *bitmap )
-{
-   struct bitmap_cache *cache = st->bitmap.cache;
-   int px = -999, py = -999;
-   const GLfloat z = st->ctx->Current.RasterPos[2];
-
-   if (width > BITMAP_CACHE_WIDTH ||
-       height > BITMAP_CACHE_HEIGHT)
-      return GL_FALSE; /* too big to cache */
-
-   if (!cache->empty) {
-      px = x - cache->xpos;  /* pos in buffer */
-      py = y - cache->ypos;
-      if (px < 0 || px + width > BITMAP_CACHE_WIDTH ||
-          py < 0 || py + height > BITMAP_CACHE_HEIGHT ||
-          !TEST_EQ_4V(st->ctx->Current.RasterColor, cache->color) ||
-          ((fabs(z - cache->zpos) > Z_EPSILON))) {
-         /* This bitmap would extend beyond cache bounds, or the bitmap
-          * color is changing
-          * so flush and continue.
-          */
-         st_flush_bitmap_cache(st);
-      }
-   }
-
-   if (cache->empty) {
-      /* Initialize.  Center bitmap vertically in the buffer. */
-      px = 0;
-      py = (BITMAP_CACHE_HEIGHT - height) / 2;
-      cache->xpos = x;
-      cache->ypos = y - py;
-      cache->zpos = z;
-      cache->empty = GL_FALSE;
-      COPY_4FV(cache->color, st->ctx->Current.RasterColor);
-   }
-
-   assert(px != -999);
-   assert(py != -999);
-
-   if (x < cache->xmin)
-      cache->xmin = x;
-   if (y < cache->ymin)
-      cache->ymin = y;
-   if (x + width > cache->xmax)
-      cache->xmax = x + width;
-   if (y + height > cache->ymax)
-      cache->ymax = y + height;
-
-   /* create the transfer if needed */
-   create_cache_trans(st);
-
-   unpack_bitmap(st, px, py, width, height, unpack, bitmap,
-                 cache->buffer, BITMAP_CACHE_WIDTH);
-
-   return GL_TRUE; /* accumulated */
-}
-
-
-
-/**
- * Called via ctx->Driver.Bitmap()
- */
-static void
-st_Bitmap(struct gl_context *ctx, GLint x, GLint y,
-          GLsizei width, GLsizei height,
-          const struct gl_pixelstore_attrib *unpack, const GLubyte *bitmap )
-{
-   struct st_context *st = st_context(ctx);
-   struct pipe_resource *pt;
-
-   if (width == 0 || height == 0)
-      return;
-
-   st_validate_state(st);
-
-   if (!st->bitmap.vs) {
-      /* create pass-through vertex shader now */
-      const uint semantic_names[] = { TGSI_SEMANTIC_POSITION,
-                                      TGSI_SEMANTIC_COLOR,
-                                      TGSI_SEMANTIC_GENERIC };
-      const uint semantic_indexes[] = { 0, 0, 0 };
-      st->bitmap.vs = util_make_vertex_passthrough_shader(st->pipe, 3,
-                                                          semantic_names,
-                                                          semantic_indexes);
-   }
-
-   if (UseBitmapCache && accum_bitmap(st, x, y, width, height, unpack, bitmap))
-      return;
-
-   pt = make_bitmap_texture(ctx, width, height, unpack, bitmap);
-   if (pt) {
-      struct pipe_sampler_view *sv =
-         st_create_texture_sampler_view(st->pipe, pt);
-
-      assert(pt->target == PIPE_TEXTURE_2D || pt->target == PIPE_TEXTURE_RECT);
-
-      if (sv) {
-         draw_bitmap_quad(ctx, x, y, ctx->Current.RasterPos[2],
-                          width, height, sv,
-                          st->ctx->Current.RasterColor);
-
-         pipe_sampler_view_reference(&sv, NULL);
-      }
-
-      /* release/free the texture */
-      pipe_resource_reference(&pt, NULL);
-   }
-}
-
-
-/** Per-context init */
-void
-st_init_bitmap_functions(struct dd_function_table *functions)
-{
-   functions->Bitmap = st_Bitmap;
-}
-
-
-/** Per-context init */
-void
-st_init_bitmap(struct st_context *st)
-{
-   struct pipe_sampler_state *sampler = &st->bitmap.samplers[0];
-   struct pipe_context *pipe = st->pipe;
-   struct pipe_screen *screen = pipe->screen;
-
-   /* init sampler state once */
-   memset(sampler, 0, sizeof(*sampler));
-   sampler->wrap_s = PIPE_TEX_WRAP_CLAMP;
-   sampler->wrap_t = PIPE_TEX_WRAP_CLAMP;
-   sampler->wrap_r = PIPE_TEX_WRAP_CLAMP;
-   sampler->min_img_filter = PIPE_TEX_FILTER_NEAREST;
-   sampler->min_mip_filter = PIPE_TEX_MIPFILTER_NONE;
-   sampler->mag_img_filter = PIPE_TEX_FILTER_NEAREST;
-   st->bitmap.samplers[1] = *sampler;
-   st->bitmap.samplers[1].normalized_coords = 1;
-
-   /* init baseline rasterizer state once */
-   memset(&st->bitmap.rasterizer, 0, sizeof(st->bitmap.rasterizer));
-   st->bitmap.rasterizer.gl_rasterization_rules = 1;
-
-   /* find a usable texture format */
-   if (screen->is_format_supported(screen, PIPE_FORMAT_I8_UNORM,
-                                   PIPE_TEXTURE_2D, 0,
-                                   PIPE_BIND_SAMPLER_VIEW, 0)) {
-      st->bitmap.tex_format = PIPE_FORMAT_I8_UNORM;
-   }
-   else if (screen->is_format_supported(screen, PIPE_FORMAT_A8_UNORM,
-                                        PIPE_TEXTURE_2D, 0,
-                                        PIPE_BIND_SAMPLER_VIEW, 0)) {
-      st->bitmap.tex_format = PIPE_FORMAT_A8_UNORM;
-   }
-   else if (screen->is_format_supported(screen, PIPE_FORMAT_L8_UNORM,
-                                        PIPE_TEXTURE_2D, 0,
-                                        PIPE_BIND_SAMPLER_VIEW, 0)) {
-      st->bitmap.tex_format = PIPE_FORMAT_L8_UNORM;
-   }
-   else {
-      /* XXX support more formats */
-      assert(0);
-   }
-
-   /* alloc bitmap cache object */
-   st->bitmap.cache = ST_CALLOC_STRUCT(bitmap_cache);
-
-   reset_cache(st);
-}
-
-
-/** Per-context tear-down */
-void
-st_destroy_bitmap(struct st_context *st)
-{
-   struct pipe_context *pipe = st->pipe;
-   struct bitmap_cache *cache = st->bitmap.cache;
-
-   if (st->bitmap.vs) {
-      cso_delete_vertex_shader(st->cso_context, st->bitmap.vs);
-      st->bitmap.vs = NULL;
-   }
-
-   if (st->bitmap.vbuf) {
-      pipe_resource_reference(&st->bitmap.vbuf, NULL);
-      st->bitmap.vbuf = NULL;
-   }
-
-   if (cache) {
-      if (cache->trans) {
-         pipe_transfer_unmap(pipe, cache->trans);
-         pipe->transfer_destroy(pipe, cache->trans);
-      }
-      pipe_resource_reference(&st->bitmap.cache->texture, NULL);
-      free(st->bitmap.cache);
-      st->bitmap.cache = NULL;
-   }
-}
-
-#endif /* FEATURE_drawpix */
+/**************************************************************************

+ * 

+ * Copyright 2007 Tungsten Graphics, Inc., Cedar Park, Texas.

+ * 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, sub license, 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 (including the

+ * next paragraph) 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 NON-INFRINGEMENT.

+ * IN NO EVENT SHALL TUNGSTEN GRAPHICS AND/OR ITS SUPPLIERS 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.

+ * 

+ **************************************************************************/

+

+ /*

+  * Authors:

+  *   Brian Paul

+  */

+

+#include "main/imports.h"

+#include "main/image.h"

+#include "main/bufferobj.h"

+#include "main/macros.h"

+#include "main/mfeatures.h"

+#include "main/pbo.h"

+#include "program/program.h"

+#include "program/prog_print.h"

+

+#include "st_context.h"

+#include "st_atom.h"

+#include "st_atom_constbuf.h"

+#include "st_program.h"

+#include "st_cb_bitmap.h"

+#include "st_texture.h"

+

+#include "pipe/p_context.h"

+#include "pipe/p_defines.h"

+#include "pipe/p_shader_tokens.h"

+#include "util/u_inlines.h"

+#include "util/u_draw_quad.h"

+#include "util/u_simple_shaders.h"

+#include "program/prog_instruction.h"

+#include "cso_cache/cso_context.h"

+

+

+#if FEATURE_drawpix

+

+/**

+ * glBitmaps are drawn as textured quads.  The user's bitmap pattern

+ * is stored in a texture image.  An alpha8 texture format is used.

+ * The fragment shader samples a bit (texel) from the texture, then

+ * discards the fragment if the bit is off.

+ *

+ * Note that we actually store the inverse image of the bitmap to

+ * simplify the fragment program.  An "on" bit gets stored as texel=0x0

+ * and an "off" bit is stored as texel=0xff.  Then we kill the

+ * fragment if the negated texel value is less than zero.

+ */

+

+

+/**

+ * The bitmap cache attempts to accumulate multiple glBitmap calls in a

+ * buffer which is then rendered en mass upon a flush, state change, etc.

+ * A wide, short buffer is used to target the common case of a series

+ * of glBitmap calls being used to draw text.

+ */

+static GLboolean UseBitmapCache = GL_TRUE;

+

+

+#define BITMAP_CACHE_WIDTH  512

+#define BITMAP_CACHE_HEIGHT 32

+

+struct bitmap_cache

+{

+   /** Window pos to render the cached image */

+   GLint xpos, ypos;

+   /** Bounds of region used in window coords */

+   GLint xmin, ymin, xmax, ymax;

+

+   GLfloat color[4];

+

+   /** Bitmap's Z position */

+   GLfloat zpos;

+

+   struct pipe_resource *texture;

+   struct pipe_transfer *trans;

+

+   GLboolean empty;

+

+   /** An I8 texture image: */

+   ubyte *buffer;

+};

+

+

+/** Epsilon for Z comparisons */

+#define Z_EPSILON 1e-06

+

+

+/**

+ * Make fragment program for glBitmap:

+ *   Sample the texture and kill the fragment if the bit is 0.

+ * This program will be combined with the user's fragment program.

+ */

+static struct st_fragment_program *

+make_bitmap_fragment_program(struct gl_context *ctx, GLuint samplerIndex)

+{

+   struct st_context *st = st_context(ctx);

+   struct st_fragment_program *stfp;

+   struct gl_program *p;

+   GLuint ic = 0;

+

+   p = ctx->Driver.NewProgram(ctx, GL_FRAGMENT_PROGRAM_ARB, 0);

+   if (!p)

+      return NULL;

+

+   p->NumInstructions = 3;

+

+   p->Instructions = _mesa_alloc_instructions(p->NumInstructions);

+   if (!p->Instructions) {

+      ctx->Driver.DeleteProgram(ctx, p);

+      return NULL;

+   }

+   _mesa_init_instructions(p->Instructions, p->NumInstructions);

+

+   /* TEX tmp0, fragment.texcoord[0], texture[0], 2D; */

+   p->Instructions[ic].Opcode = OPCODE_TEX;

+   p->Instructions[ic].DstReg.File = PROGRAM_TEMPORARY;

+   p->Instructions[ic].DstReg.Index = 0;

+   p->Instructions[ic].SrcReg[0].File = PROGRAM_INPUT;

+   p->Instructions[ic].SrcReg[0].Index = FRAG_ATTRIB_TEX0;

+   p->Instructions[ic].TexSrcUnit = samplerIndex;

+   p->Instructions[ic].TexSrcTarget = TEXTURE_2D_INDEX;

+   ic++;

+

+   /* KIL if -tmp0 < 0 # texel=0 -> keep / texel=0 -> discard */

+   p->Instructions[ic].Opcode = OPCODE_KIL;

+   p->Instructions[ic].SrcReg[0].File = PROGRAM_TEMPORARY;

+

+   if (st->bitmap.tex_format == PIPE_FORMAT_L8_UNORM)

+      p->Instructions[ic].SrcReg[0].Swizzle = SWIZZLE_XXXX;

+

+   p->Instructions[ic].SrcReg[0].Index = 0;

+   p->Instructions[ic].SrcReg[0].Negate = NEGATE_XYZW;

+   ic++;

+

+   /* END; */

+   p->Instructions[ic++].Opcode = OPCODE_END;

+

+   assert(ic == p->NumInstructions);

+

+   p->InputsRead = FRAG_BIT_TEX0;

+   p->OutputsWritten = 0x0;

+   p->SamplersUsed = (1 << samplerIndex);

+

+   stfp = (struct st_fragment_program *) p;

+   stfp->Base.UsesKill = GL_TRUE;

+

+   return stfp;

+}

+

+

+static int

+find_free_bit(uint bitfield)

+{

+   int i;

+   for (i = 0; i < 32; i++) {

+      if ((bitfield & (1 << i)) == 0) {

+         return i;

+      }

+   }

+   return -1;

+}

+

+

+/**

+ * Combine basic bitmap fragment program with the user-defined program.

+ * \param st  current context

+ * \param fpIn  the incoming fragment program

+ * \param fpOut  the new fragment program which does fragment culling

+ * \param bitmap_sampler  sampler number for the bitmap texture

+ */

+void

+st_make_bitmap_fragment_program(struct st_context *st,

+                                struct gl_fragment_program *fpIn,

+                                struct gl_fragment_program **fpOut,

+                                GLuint *bitmap_sampler)

+{

+   struct st_fragment_program *bitmap_prog;

+   struct gl_program *newProg;

+   uint sampler;

+

+   /*

+    * Generate new program which is the user-defined program prefixed

+    * with the bitmap sampler/kill instructions.

+    */

+   sampler = find_free_bit(fpIn->Base.SamplersUsed);

+   bitmap_prog = make_bitmap_fragment_program(st->ctx, sampler);

+

+   newProg = _mesa_combine_programs(st->ctx,

+                                    &bitmap_prog->Base.Base,

+                                    &fpIn->Base);

+   /* done with this after combining */

+   st_reference_fragprog(st, &bitmap_prog, NULL);

+

+#if 0

+   {

+      printf("Combined bitmap program:\n");

+      _mesa_print_program(newProg);

+      printf("InputsRead: 0x%x\n", newProg->InputsRead);

+      printf("OutputsWritten: 0x%x\n", newProg->OutputsWritten);

+      _mesa_print_parameter_list(newProg->Parameters);

+   }

+#endif

+

+   /* return results */

+   *fpOut = (struct gl_fragment_program *) newProg;

+   *bitmap_sampler = sampler;

+}

+

+

+/**

+ * Copy user-provide bitmap bits into texture buffer, expanding

+ * bits into texels.

+ * "On" bits will set texels to 0x0.

+ * "Off" bits will not modify texels.

+ * Note that the image is actually going to be upside down in

+ * the texture.  We deal with that with texcoords.

+ */

+static void

+unpack_bitmap(struct st_context *st,

+              GLint px, GLint py, GLsizei width, GLsizei height,

+              const struct gl_pixelstore_attrib *unpack,

+              const GLubyte *bitmap,

+              ubyte *destBuffer, uint destStride)

+{

+   destBuffer += py * destStride + px;

+

+   _mesa_expand_bitmap(width, height, unpack, bitmap,

+                       destBuffer, destStride, 0x0);

+}

+

+

+/**

+ * Create a texture which represents a bitmap image.

+ */

+static struct pipe_resource *

+make_bitmap_texture(struct gl_context *ctx, GLsizei width, GLsizei height,

+                    const struct gl_pixelstore_attrib *unpack,

+                    const GLubyte *bitmap)

+{

+   struct st_context *st = st_context(ctx);

+   struct pipe_context *pipe = st->pipe;

+   struct pipe_transfer *transfer;

+   ubyte *dest;

+   struct pipe_resource *pt;

+

+   /* PBO source... */

+   bitmap = _mesa_map_pbo_source(ctx, unpack, bitmap);

+   if (!bitmap) {

+      return NULL;

+   }

+

+   /**

+    * Create texture to hold bitmap pattern.

+    */

+   pt = st_texture_create(st, st->internal_target, st->bitmap.tex_format,

+                          0, width, height, 1, 1,

+                          PIPE_BIND_SAMPLER_VIEW);

+   if (!pt) {

+      _mesa_unmap_pbo_source(ctx, unpack);

+      return NULL;

+   }

+

+   transfer = pipe_get_transfer(st->pipe, pt, 0, 0,

+                                PIPE_TRANSFER_WRITE,

+                                0, 0, width, height);

+

+   dest = pipe_transfer_map(pipe, transfer);

+

+   /* Put image into texture transfer */

+   memset(dest, 0xff, height * transfer->stride);

+   unpack_bitmap(st, 0, 0, width, height, unpack, bitmap,

+                 dest, transfer->stride);

+

+   _mesa_unmap_pbo_source(ctx, unpack);

+

+   /* Release transfer */

+   pipe_transfer_unmap(pipe, transfer);

+   pipe->transfer_destroy(pipe, transfer);

+

+   return pt;

+}

+

+static GLuint

+setup_bitmap_vertex_data(struct st_context *st, bool normalized,

+                         int x, int y, int width, int height,

+                         float z, const float color[4])

+{

+   struct pipe_context *pipe = st->pipe;

+   const struct gl_framebuffer *fb = st->ctx->DrawBuffer;

+   const GLfloat fb_width = (GLfloat)fb->Width;

+   const GLfloat fb_height = (GLfloat)fb->Height;

+   const GLfloat x0 = (GLfloat)x;

+   const GLfloat x1 = (GLfloat)(x + width);

+   const GLfloat y0 = (GLfloat)y;

+   const GLfloat y1 = (GLfloat)(y + height);

+   GLfloat sLeft = (GLfloat)0.0, sRight = (GLfloat)1.0;

+   GLfloat tTop = (GLfloat)0.0, tBot = (GLfloat)1.0 - tTop;

+   const GLfloat clip_x0 = (GLfloat)(x0 / fb_width * 2.0 - 1.0);

+   const GLfloat clip_y0 = (GLfloat)(y0 / fb_height * 2.0 - 1.0);

+   const GLfloat clip_x1 = (GLfloat)(x1 / fb_width * 2.0 - 1.0);

+   const GLfloat clip_y1 = (GLfloat)(y1 / fb_height * 2.0 - 1.0);

+   const GLuint max_slots = 1; /* 4096 / sizeof(st->bitmap.vertices); */

+   GLuint i;

+

+   if(!normalized)

+   {

+      sRight = width;

+      tBot = height;

+   }

+

+   /* XXX: Need to improve buffer_write to allow NO_WAIT (as well as

+    * no_flush) updates to buffers where we know there is no conflict

+    * with previous data.  Currently using max_slots > 1 will cause

+    * synchronous rendering if the driver flushes its command buffers

+    * between one bitmap and the next.  Our flush hook below isn't

+    * sufficient to catch this as the driver doesn't tell us when it

+    * flushes its own command buffers.  Until this gets fixed, pay the

+    * price of allocating a new buffer for each bitmap cache-flush to

+    * avoid synchronous rendering.

+    */

+   if (st->bitmap.vbuf_slot >= max_slots) {

+      pipe_resource_reference(&st->bitmap.vbuf, NULL);

+      st->bitmap.vbuf_slot = 0;

+   }

+

+   if (!st->bitmap.vbuf) {

+      st->bitmap.vbuf = pipe_buffer_create(pipe->screen, 

+                                           PIPE_BIND_VERTEX_BUFFER,

+                                           PIPE_USAGE_STREAM,

+                                           max_slots *

+                                           sizeof(st->bitmap.vertices));

+   }

+

+   /* Positions are in clip coords since we need to do clipping in case

+    * the bitmap quad goes beyond the window bounds.

+    */

+   st->bitmap.vertices[0][0][0] = clip_x0;

+   st->bitmap.vertices[0][0][1] = clip_y0;

+   st->bitmap.vertices[0][2][0] = sLeft;

+   st->bitmap.vertices[0][2][1] = tTop;

+

+   st->bitmap.vertices[1][0][0] = clip_x1;

+   st->bitmap.vertices[1][0][1] = clip_y0;

+   st->bitmap.vertices[1][2][0] = sRight;

+   st->bitmap.vertices[1][2][1] = tTop;

+   

+   st->bitmap.vertices[2][0][0] = clip_x1;

+   st->bitmap.vertices[2][0][1] = clip_y1;

+   st->bitmap.vertices[2][2][0] = sRight;

+   st->bitmap.vertices[2][2][1] = tBot;

+   

+   st->bitmap.vertices[3][0][0] = clip_x0;

+   st->bitmap.vertices[3][0][1] = clip_y1;

+   st->bitmap.vertices[3][2][0] = sLeft;

+   st->bitmap.vertices[3][2][1] = tBot;

+   

+   /* same for all verts: */

+   for (i = 0; i < 4; i++) {

+      st->bitmap.vertices[i][0][2] = z;

+      st->bitmap.vertices[i][0][3] = 1.0;

+      st->bitmap.vertices[i][1][0] = color[0];

+      st->bitmap.vertices[i][1][1] = color[1];

+      st->bitmap.vertices[i][1][2] = color[2];

+      st->bitmap.vertices[i][1][3] = color[3];

+      st->bitmap.vertices[i][2][2] = 0.0; /*R*/

+      st->bitmap.vertices[i][2][3] = 1.0; /*Q*/

+   }

+

+   /* put vertex data into vbuf */

+   pipe_buffer_write_nooverlap(st->pipe,

+                               st->bitmap.vbuf,

+                               st->bitmap.vbuf_slot

+                               * sizeof(st->bitmap.vertices),

+                               sizeof st->bitmap.vertices,

+                               st->bitmap.vertices);

+

+   return st->bitmap.vbuf_slot++ * sizeof st->bitmap.vertices;

+}

+

+

+

+/**

+ * Render a glBitmap by drawing a textured quad

+ */

+static void

+draw_bitmap_quad(struct gl_context *ctx, GLint x, GLint y, GLfloat z,

+                 GLsizei width, GLsizei height,

+                 struct pipe_sampler_view *sv,

+                 const GLfloat *color)

+{

+   struct st_context *st = st_context(ctx);

+   struct pipe_context *pipe = st->pipe;

+   struct cso_context *cso = st->cso_context;

+   struct st_fp_variant *fpv;

+   struct st_fp_variant_key key;

+   GLuint maxSize;

+   GLuint offset;

+

+   memset(&key, 0, sizeof(key));

+   key.st = st;

+   key.bitmap = GL_TRUE;

+

+   fpv = st_get_fp_variant(st, st->fp, &key);

+

+   /* As an optimization, Mesa's fragment programs will sometimes get the

+    * primary color from a statevar/constant rather than a varying variable.

+    * when that's the case, we need to ensure that we use the 'color'

+    * parameter and not the current attribute color (which may have changed

+    * through glRasterPos and state validation.

+    * So, we force the proper color here.  Not elegant, but it works.

+    */

+   {

+      GLfloat colorSave[4];

+      COPY_4V(colorSave, ctx->Current.Attrib[VERT_ATTRIB_COLOR0]);

+      COPY_4V(ctx->Current.Attrib[VERT_ATTRIB_COLOR0], color);

+      st_upload_constants(st, fpv->parameters, PIPE_SHADER_FRAGMENT);

+      COPY_4V(ctx->Current.Attrib[VERT_ATTRIB_COLOR0], colorSave);

+   }

+

+

+   /* limit checks */

+   /* XXX if the bitmap is larger than the max texture size, break

+    * it up into chunks.

+    */

+   maxSize = 1 << (pipe->screen->get_param(pipe->screen,

+                                    PIPE_CAP_MAX_TEXTURE_2D_LEVELS) - 1);

+   assert(width <= (GLsizei)maxSize);

+   assert(height <= (GLsizei)maxSize);

+

+   cso_save_rasterizer(cso);

+   cso_save_samplers(cso);

+   cso_save_fragment_sampler_views(cso);

+   cso_save_viewport(cso);

+   cso_save_fragment_shader(cso);

+   cso_save_vertex_shader(cso);

+   cso_save_vertex_elements(cso);

+   cso_save_vertex_buffers(cso);

+

+   /* rasterizer state: just scissor */

+   st->bitmap.rasterizer.scissor = ctx->Scissor.Enabled;

+   cso_set_rasterizer(cso, &st->bitmap.rasterizer);

+

+   /* fragment shader state: TEX lookup program */

+   cso_set_fragment_shader_handle(cso, fpv->driver_shader);

+

+   /* vertex shader state: position + texcoord pass-through */

+   cso_set_vertex_shader_handle(cso, st->bitmap.vs);

+

+   /* user samplers, plus our bitmap sampler */

+   {

+      struct pipe_sampler_state *samplers[PIPE_MAX_SAMPLERS];

+      uint num = MAX2(fpv->bitmap_sampler + 1, st->state.num_samplers);

+      uint i;

+      for (i = 0; i < st->state.num_samplers; i++) {

+         samplers[i] = &st->state.samplers[i];

+      }

+      samplers[fpv->bitmap_sampler] =

+         &st->bitmap.samplers[sv->texture->target != PIPE_TEXTURE_RECT];

+      cso_set_samplers(cso, num, (const struct pipe_sampler_state **) samplers);

+   }

+

+   /* user textures, plus the bitmap texture */

+   {

+      struct pipe_sampler_view *sampler_views[PIPE_MAX_SAMPLERS];

+      uint num = MAX2(fpv->bitmap_sampler + 1, st->state.num_textures);

+      memcpy(sampler_views, st->state.sampler_views, sizeof(sampler_views));

+      sampler_views[fpv->bitmap_sampler] = sv;

+      cso_set_fragment_sampler_views(cso, num, sampler_views);

+   }

+

+   /* viewport state: viewport matching window dims */

+   {

+      const struct gl_framebuffer *fb = st->ctx->DrawBuffer;

+      const GLboolean invert = (st_fb_orientation(fb) == Y_0_TOP);

+      const GLfloat width = (GLfloat)fb->Width;

+      const GLfloat height = (GLfloat)fb->Height;

+      struct pipe_viewport_state vp;

+      vp.scale[0] =  0.5f * width;

+      vp.scale[1] = height * (invert ? -0.5f : 0.5f);

+      vp.scale[2] = 0.5f;

+      vp.scale[3] = 1.0f;

+      vp.translate[0] = 0.5f * width;

+      vp.translate[1] = 0.5f * height;

+      vp.translate[2] = 0.5f;

+      vp.translate[3] = 0.0f;

+      cso_set_viewport(cso, &vp);

+   }

+

+   cso_set_vertex_elements(cso, 3, st->velems_util_draw);

+

+   /* convert Z from [0,1] to [-1,-1] to match viewport Z scale/bias */

+   z = z * 2.0 - 1.0;

+

+   /* draw textured quad */

+   offset = setup_bitmap_vertex_data(st,

+                                     sv->texture->target != PIPE_TEXTURE_RECT,

+                                     x, y, width, height, z, color);

+

+   util_draw_vertex_buffer(pipe, st->cso_context, st->bitmap.vbuf, offset,

+                           PIPE_PRIM_TRIANGLE_FAN,

+                           4,  /* verts */

+                           3); /* attribs/vert */

+

+

+   /* restore state */

+   cso_restore_rasterizer(cso);

+   cso_restore_samplers(cso);

+   cso_restore_fragment_sampler_views(cso);

+   cso_restore_viewport(cso);

+   cso_restore_fragment_shader(cso);

+   cso_restore_vertex_shader(cso);

+   cso_restore_vertex_elements(cso);

+   cso_restore_vertex_buffers(cso);

+}

+

+

+static void

+reset_cache(struct st_context *st)

+{

+   struct pipe_context *pipe = st->pipe;

+   struct bitmap_cache *cache = st->bitmap.cache;

+

+   /*memset(cache->buffer, 0xff, sizeof(cache->buffer));*/

+   cache->empty = GL_TRUE;

+

+   cache->xmin = 1000000;

+   cache->xmax = -1000000;

+   cache->ymin = 1000000;

+   cache->ymax = -1000000;

+

+   if (cache->trans) {

+      pipe->transfer_destroy(pipe, cache->trans);

+      cache->trans = NULL;

+   }

+

+   assert(!cache->texture);

+

+   /* allocate a new texture */

+   cache->texture = st_texture_create(st, PIPE_TEXTURE_2D,

+                                      st->bitmap.tex_format, 0,

+                                      BITMAP_CACHE_WIDTH, BITMAP_CACHE_HEIGHT,

+                                      1, 1,

+				      PIPE_BIND_SAMPLER_VIEW);

+}

+

+

+/** Print bitmap image to stdout (debug) */

+static void

+print_cache(const struct bitmap_cache *cache)

+{

+   int i, j, k;

+

+   for (i = 0; i < BITMAP_CACHE_HEIGHT; i++) {

+      k = BITMAP_CACHE_WIDTH * (BITMAP_CACHE_HEIGHT - i - 1);

+      for (j = 0; j < BITMAP_CACHE_WIDTH; j++) {

+         if (cache->buffer[k])

+            printf("X");

+         else

+            printf(" ");

+         k++;

+      }

+      printf("\n");

+   }

+}

+

+

+/**

+ * Create gallium pipe_transfer object for the bitmap cache.

+ */

+static void

+create_cache_trans(struct st_context *st)

+{

+   struct pipe_context *pipe = st->pipe;

+   struct bitmap_cache *cache = st->bitmap.cache;

+

+   if (cache->trans)

+      return;

+

+   /* Map the texture transfer.

+    * Subsequent glBitmap calls will write into the texture image.

+    */

+   cache->trans = pipe_get_transfer(st->pipe, cache->texture, 0, 0,

+                                    PIPE_TRANSFER_WRITE, 0, 0,

+                                    BITMAP_CACHE_WIDTH,

+                                    BITMAP_CACHE_HEIGHT);

+   cache->buffer = pipe_transfer_map(pipe, cache->trans);

+

+   /* init image to all 0xff */

+   memset(cache->buffer, 0xff, cache->trans->stride * BITMAP_CACHE_HEIGHT);

+}

+

+

+/**

+ * If there's anything in the bitmap cache, draw/flush it now.

+ */

+void

+st_flush_bitmap_cache(struct st_context *st)

+{

+   if (!st->bitmap.cache->empty) {

+      struct bitmap_cache *cache = st->bitmap.cache;

+

+      if (st->ctx->DrawBuffer) {

+         struct pipe_context *pipe = st->pipe;

+         struct pipe_sampler_view *sv;

+

+         assert(cache->xmin <= cache->xmax);

+ 

+/*         printf("flush size %d x %d  at %d, %d\n",

+                cache->xmax - cache->xmin,

+                cache->ymax - cache->ymin,

+                cache->xpos, cache->ypos);

+*/

+

+         /* The texture transfer has been mapped until now.

+          * So unmap and release the texture transfer before drawing.

+          */

+         if (cache->trans) {

+            if (0)

+               print_cache(cache);

+            pipe_transfer_unmap(pipe, cache->trans);

+            cache->buffer = NULL;

+

+            pipe->transfer_destroy(pipe, cache->trans);

+            cache->trans = NULL;

+         }

+

+         sv = st_create_texture_sampler_view(st->pipe, cache->texture);

+         if (sv) {

+            draw_bitmap_quad(st->ctx,

+                             cache->xpos,

+                             cache->ypos,

+                             cache->zpos,

+                             BITMAP_CACHE_WIDTH, BITMAP_CACHE_HEIGHT,

+                             sv,

+                             cache->color);

+

+            pipe_sampler_view_reference(&sv, NULL);

+         }

+      }

+

+      /* release/free the texture */

+      pipe_resource_reference(&cache->texture, NULL);

+

+      reset_cache(st);

+   }

+}

+

+

+/**

+ * Flush bitmap cache and release vertex buffer.

+ */

+void

+st_flush_bitmap( struct st_context *st )

+{

+   st_flush_bitmap_cache(st);

+

+   /* Release vertex buffer to avoid synchronous rendering if we were

+    * to map it in the next frame.

+    */

+   pipe_resource_reference(&st->bitmap.vbuf, NULL);

+   st->bitmap.vbuf_slot = 0;

+}

+

+

+/**

+ * Try to accumulate this glBitmap call in the bitmap cache.

+ * \return  GL_TRUE for success, GL_FALSE if bitmap is too large, etc.

+ */

+static GLboolean

+accum_bitmap(struct st_context *st,

+             GLint x, GLint y, GLsizei width, GLsizei height,

+             const struct gl_pixelstore_attrib *unpack,

+             const GLubyte *bitmap )

+{

+   struct bitmap_cache *cache = st->bitmap.cache;

+   int px = -999, py = -999;

+   const GLfloat z = st->ctx->Current.RasterPos[2];

+

+   if (width > BITMAP_CACHE_WIDTH ||

+       height > BITMAP_CACHE_HEIGHT)

+      return GL_FALSE; /* too big to cache */

+

+   if (!cache->empty) {

+      px = x - cache->xpos;  /* pos in buffer */

+      py = y - cache->ypos;

+      if (px < 0 || px + width > BITMAP_CACHE_WIDTH ||

+          py < 0 || py + height > BITMAP_CACHE_HEIGHT ||

+          !TEST_EQ_4V(st->ctx->Current.RasterColor, cache->color) ||

+          ((fabs(z - cache->zpos) > Z_EPSILON))) {

+         /* This bitmap would extend beyond cache bounds, or the bitmap

+          * color is changing

+          * so flush and continue.

+          */

+         st_flush_bitmap_cache(st);

+      }

+   }

+

+   if (cache->empty) {

+      /* Initialize.  Center bitmap vertically in the buffer. */

+      px = 0;

+      py = (BITMAP_CACHE_HEIGHT - height) / 2;

+      cache->xpos = x;

+      cache->ypos = y - py;

+      cache->zpos = z;

+      cache->empty = GL_FALSE;

+      COPY_4FV(cache->color, st->ctx->Current.RasterColor);

+   }

+

+   assert(px != -999);

+   assert(py != -999);

+

+   if (x < cache->xmin)

+      cache->xmin = x;

+   if (y < cache->ymin)

+      cache->ymin = y;

+   if (x + width > cache->xmax)

+      cache->xmax = x + width;

+   if (y + height > cache->ymax)

+      cache->ymax = y + height;

+

+   /* create the transfer if needed */

+   create_cache_trans(st);

+

+   unpack_bitmap(st, px, py, width, height, unpack, bitmap,

+                 cache->buffer, BITMAP_CACHE_WIDTH);

+

+   return GL_TRUE; /* accumulated */

+}

+

+

+

+/**

+ * Called via ctx->Driver.Bitmap()

+ */

+static void

+st_Bitmap(struct gl_context *ctx, GLint x, GLint y,

+          GLsizei width, GLsizei height,

+          const struct gl_pixelstore_attrib *unpack, const GLubyte *bitmap )

+{

+   struct st_context *st = st_context(ctx);

+   struct pipe_resource *pt;

+

+   if (width == 0 || height == 0)

+      return;

+

+   st_validate_state(st);

+

+   if (!st->bitmap.vs) {

+      /* create pass-through vertex shader now */

+      const uint semantic_names[] = { TGSI_SEMANTIC_POSITION,

+                                      TGSI_SEMANTIC_COLOR,

+                                      TGSI_SEMANTIC_GENERIC };

+      const uint semantic_indexes[] = { 0, 0, 0 };

+      st->bitmap.vs = util_make_vertex_passthrough_shader(st->pipe, 3,

+                                                          semantic_names,

+                                                          semantic_indexes);

+   }

+

+   if (UseBitmapCache && accum_bitmap(st, x, y, width, height, unpack, bitmap))

+      return;

+

+   pt = make_bitmap_texture(ctx, width, height, unpack, bitmap);

+   if (pt) {

+      struct pipe_sampler_view *sv =

+         st_create_texture_sampler_view(st->pipe, pt);

+

+      assert(pt->target == PIPE_TEXTURE_2D || pt->target == PIPE_TEXTURE_RECT);

+

+      if (sv) {

+         draw_bitmap_quad(ctx, x, y, ctx->Current.RasterPos[2],

+                          width, height, sv,

+                          st->ctx->Current.RasterColor);

+

+         pipe_sampler_view_reference(&sv, NULL);

+      }

+

+      /* release/free the texture */

+      pipe_resource_reference(&pt, NULL);

+   }

+}

+

+

+/** Per-context init */

+void

+st_init_bitmap_functions(struct dd_function_table *functions)

+{

+   functions->Bitmap = st_Bitmap;

+}

+

+

+/** Per-context init */

+void

+st_init_bitmap(struct st_context *st)

+{

+   struct pipe_sampler_state *sampler = &st->bitmap.samplers[0];

+   struct pipe_context *pipe = st->pipe;

+   struct pipe_screen *screen = pipe->screen;

+

+   /* init sampler state once */

+   memset(sampler, 0, sizeof(*sampler));

+   sampler->wrap_s = PIPE_TEX_WRAP_CLAMP;

+   sampler->wrap_t = PIPE_TEX_WRAP_CLAMP;

+   sampler->wrap_r = PIPE_TEX_WRAP_CLAMP;

+   sampler->min_img_filter = PIPE_TEX_FILTER_NEAREST;

+   sampler->min_mip_filter = PIPE_TEX_MIPFILTER_NONE;

+   sampler->mag_img_filter = PIPE_TEX_FILTER_NEAREST;

+   st->bitmap.samplers[1] = *sampler;

+   st->bitmap.samplers[1].normalized_coords = 1;

+

+   /* init baseline rasterizer state once */

+   memset(&st->bitmap.rasterizer, 0, sizeof(st->bitmap.rasterizer));

+   st->bitmap.rasterizer.gl_rasterization_rules = 1;

+

+   /* find a usable texture format */

+   if (screen->is_format_supported(screen, PIPE_FORMAT_I8_UNORM,

+                                   PIPE_TEXTURE_2D, 0,

+                                   PIPE_BIND_SAMPLER_VIEW)) {

+      st->bitmap.tex_format = PIPE_FORMAT_I8_UNORM;

+   }

+   else if (screen->is_format_supported(screen, PIPE_FORMAT_A8_UNORM,

+                                        PIPE_TEXTURE_2D, 0,

+                                        PIPE_BIND_SAMPLER_VIEW)) {

+      st->bitmap.tex_format = PIPE_FORMAT_A8_UNORM;

+   }

+   else if (screen->is_format_supported(screen, PIPE_FORMAT_L8_UNORM,

+                                        PIPE_TEXTURE_2D, 0,

+                                        PIPE_BIND_SAMPLER_VIEW)) {

+      st->bitmap.tex_format = PIPE_FORMAT_L8_UNORM;

+   }

+   else {

+      /* XXX support more formats */

+      assert(0);

+   }

+

+   /* alloc bitmap cache object */

+   st->bitmap.cache = ST_CALLOC_STRUCT(bitmap_cache);

+

+   reset_cache(st);

+}

+

+

+/** Per-context tear-down */

+void

+st_destroy_bitmap(struct st_context *st)

+{

+   struct pipe_context *pipe = st->pipe;

+   struct bitmap_cache *cache = st->bitmap.cache;

+

+   if (st->bitmap.vs) {

+      cso_delete_vertex_shader(st->cso_context, st->bitmap.vs);

+      st->bitmap.vs = NULL;

+   }

+

+   if (st->bitmap.vbuf) {

+      pipe_resource_reference(&st->bitmap.vbuf, NULL);

+      st->bitmap.vbuf = NULL;

+   }

+

+   if (cache) {

+      if (cache->trans) {

+         pipe_transfer_unmap(pipe, cache->trans);

+         pipe->transfer_destroy(pipe, cache->trans);

+      }

+      pipe_resource_reference(&st->bitmap.cache->texture, NULL);

+      free(st->bitmap.cache);

+      st->bitmap.cache = NULL;

+   }

+}

+

+#endif /* FEATURE_drawpix */

diff --git a/mesalib/src/mesa/state_tracker/st_cb_drawpixels.c b/mesalib/src/mesa/state_tracker/st_cb_drawpixels.c
index c2b4e1808..5c95eddd0 100644
--- a/mesalib/src/mesa/state_tracker/st_cb_drawpixels.c
+++ b/mesalib/src/mesa/state_tracker/st_cb_drawpixels.c
@@ -1,1488 +1,1488 @@
-/**************************************************************************
- * 
- * Copyright 2007 Tungsten Graphics, Inc., Cedar Park, Texas.
- * 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, sub license, 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 (including the
- * next paragraph) 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 NON-INFRINGEMENT.
- * IN NO EVENT SHALL TUNGSTEN GRAPHICS AND/OR ITS SUPPLIERS 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.
- * 
- **************************************************************************/
-
- /*
-  * Authors:
-  *   Brian Paul
-  */
-
-#include "main/imports.h"
-#include "main/image.h"
-#include "main/bufferobj.h"
-#include "main/macros.h"
-#include "main/mfeatures.h"
-#include "main/mtypes.h"
-#include "main/pack.h"
-#include "main/pbo.h"
-#include "main/texformat.h"
-#include "main/texstore.h"
-#include "program/program.h"
-#include "program/prog_print.h"
-#include "program/prog_instruction.h"
-
-#include "st_atom.h"
-#include "st_atom_constbuf.h"
-#include "st_cb_drawpixels.h"
-#include "st_cb_readpixels.h"
-#include "st_cb_fbo.h"
-#include "st_context.h"
-#include "st_debug.h"
-#include "st_format.h"
-#include "st_program.h"
-#include "st_texture.h"
-
-#include "pipe/p_context.h"
-#include "pipe/p_defines.h"
-#include "tgsi/tgsi_ureg.h"
-#include "util/u_draw_quad.h"
-#include "util/u_format.h"
-#include "util/u_inlines.h"
-#include "util/u_math.h"
-#include "util/u_tile.h"
-#include "cso_cache/cso_context.h"
-
-
-#if FEATURE_drawpix
-
-/**
- * Check if the given program is:
- * 0: MOVE result.color, fragment.color;
- * 1: END;
- */
-static GLboolean
-is_passthrough_program(const struct gl_fragment_program *prog)
-{
-   if (prog->Base.NumInstructions == 2) {
-      const struct prog_instruction *inst = prog->Base.Instructions;
-      if (inst[0].Opcode == OPCODE_MOV &&
-          inst[1].Opcode == OPCODE_END &&
-          inst[0].DstReg.File == PROGRAM_OUTPUT &&
-          inst[0].DstReg.Index == FRAG_RESULT_COLOR &&
-          inst[0].DstReg.WriteMask == WRITEMASK_XYZW &&
-          inst[0].SrcReg[0].File == PROGRAM_INPUT &&
-          inst[0].SrcReg[0].Index == FRAG_ATTRIB_COL0 &&
-          inst[0].SrcReg[0].Swizzle == SWIZZLE_XYZW) {
-         return GL_TRUE;
-      }
-   }
-   return GL_FALSE;
-}
-
-
-
-/**
- * Make fragment shader for glDraw/CopyPixels.  This shader is made
- * by combining the pixel transfer shader with the user-defined shader.
- * \param fpIn  the current/incoming fragment program
- * \param fpOut  returns the combined fragment program
- */
-void
-st_make_drawpix_fragment_program(struct st_context *st,
-                                 struct gl_fragment_program *fpIn,
-                                 struct gl_fragment_program **fpOut)
-{
-   struct gl_program *newProg;
-
-   if (is_passthrough_program(fpIn)) {
-      newProg = (struct gl_program *) _mesa_clone_fragment_program(st->ctx,
-                                             &st->pixel_xfer.program->Base);
-   }
-   else {
-#if 0
-      /* debug */
-      printf("Base program:\n");
-      _mesa_print_program(&fpIn->Base);
-      printf("DrawPix program:\n");
-      _mesa_print_program(&st->pixel_xfer.program->Base.Base);
-#endif
-      newProg = _mesa_combine_programs(st->ctx,
-                                       &st->pixel_xfer.program->Base.Base,
-                                       &fpIn->Base);
-   }
-
-#if 0
-   /* debug */
-   printf("Combined DrawPixels program:\n");
-   _mesa_print_program(newProg);
-   printf("InputsRead: 0x%x\n", newProg->InputsRead);
-   printf("OutputsWritten: 0x%x\n", newProg->OutputsWritten);
-   _mesa_print_parameter_list(newProg->Parameters);
-#endif
-
-   *fpOut = (struct gl_fragment_program *) newProg;
-}
-
-
-/**
- * Create fragment program that does a TEX() instruction to get a Z and/or
- * stencil value value, then writes to FRAG_RESULT_DEPTH/FRAG_RESULT_STENCIL.
- * Used for glDrawPixels(GL_DEPTH_COMPONENT / GL_STENCIL_INDEX).
- * Pass fragment color through as-is.
- * \return pointer to the gl_fragment program
- */
-struct gl_fragment_program *
-st_make_drawpix_z_stencil_program(struct st_context *st,
-                                  GLboolean write_depth,
-                                  GLboolean write_stencil)
-{
-   struct gl_context *ctx = st->ctx;
-   struct gl_program *p;
-   struct gl_fragment_program *fp;
-   GLuint ic = 0;
-   const GLuint shaderIndex = write_depth * 2 + write_stencil;
-
-   assert(shaderIndex < Elements(st->drawpix.shaders));
-
-   if (st->drawpix.shaders[shaderIndex]) {
-      /* already have the proper shader */
-      return st->drawpix.shaders[shaderIndex];
-   }
-
-   /*
-    * Create shader now
-    */
-   p = ctx->Driver.NewProgram(ctx, GL_FRAGMENT_PROGRAM_ARB, 0);
-   if (!p)
-      return NULL;
-
-   p->NumInstructions = write_depth ? 2 : 1;
-   p->NumInstructions += write_stencil ? 1 : 0;
-
-   p->Instructions = _mesa_alloc_instructions(p->NumInstructions);
-   if (!p->Instructions) {
-      ctx->Driver.DeleteProgram(ctx, p);
-      return NULL;
-   }
-   _mesa_init_instructions(p->Instructions, p->NumInstructions);
-
-   if (write_depth) {
-      /* TEX result.depth, fragment.texcoord[0], texture[0], 2D; */
-      p->Instructions[ic].Opcode = OPCODE_TEX;
-      p->Instructions[ic].DstReg.File = PROGRAM_OUTPUT;
-      p->Instructions[ic].DstReg.Index = FRAG_RESULT_DEPTH;
-      p->Instructions[ic].DstReg.WriteMask = WRITEMASK_Z;
-      p->Instructions[ic].SrcReg[0].File = PROGRAM_INPUT;
-      p->Instructions[ic].SrcReg[0].Index = FRAG_ATTRIB_TEX0;
-      p->Instructions[ic].TexSrcUnit = 0;
-      p->Instructions[ic].TexSrcTarget = TEXTURE_2D_INDEX;
-      ic++;
-   }
-
-   if (write_stencil) {
-      /* TEX result.stencil, fragment.texcoord[0], texture[0], 2D; */
-      p->Instructions[ic].Opcode = OPCODE_TEX;
-      p->Instructions[ic].DstReg.File = PROGRAM_OUTPUT;
-      p->Instructions[ic].DstReg.Index = FRAG_RESULT_STENCIL;
-      p->Instructions[ic].DstReg.WriteMask = WRITEMASK_Y;
-      p->Instructions[ic].SrcReg[0].File = PROGRAM_INPUT;
-      p->Instructions[ic].SrcReg[0].Index = FRAG_ATTRIB_TEX0;
-      p->Instructions[ic].TexSrcUnit = 1;
-      p->Instructions[ic].TexSrcTarget = TEXTURE_2D_INDEX;
-      ic++;
-   }
-
-   /* END; */
-   p->Instructions[ic++].Opcode = OPCODE_END;
-
-   assert(ic == p->NumInstructions);
-
-   p->InputsRead = FRAG_BIT_TEX0 | FRAG_BIT_COL0;
-   p->OutputsWritten = 0;
-   if (write_depth)
-      p->OutputsWritten |= (1 << FRAG_RESULT_DEPTH);
-   if (write_stencil)
-      p->OutputsWritten |= (1 << FRAG_RESULT_STENCIL);
-
-   p->SamplersUsed =  0x1;  /* sampler 0 (bit 0) is used */
-   if (write_stencil)
-      p->SamplersUsed |= 1 << 1;
-
-   fp = (struct gl_fragment_program *) p;
-
-   /* save the new shader */
-   st->drawpix.shaders[shaderIndex] = fp;
-
-   return fp;
-}
-
-
-/**
- * Create a simple vertex shader that just passes through the
- * vertex position and texcoord (and optionally, color).
- */
-static void *
-make_passthrough_vertex_shader(struct st_context *st, 
-                               GLboolean passColor)
-{
-   if (!st->drawpix.vert_shaders[passColor]) {
-      struct ureg_program *ureg = ureg_create( TGSI_PROCESSOR_VERTEX );
-
-      if (ureg == NULL)
-         return NULL;
-
-      /* MOV result.pos, vertex.pos; */
-      ureg_MOV(ureg, 
-               ureg_DECL_output( ureg, TGSI_SEMANTIC_POSITION, 0 ),
-               ureg_DECL_vs_input( ureg, 0 ));
-      
-      /* MOV result.texcoord0, vertex.attr[1]; */
-      ureg_MOV(ureg, 
-               ureg_DECL_output( ureg, TGSI_SEMANTIC_GENERIC, 0 ),
-               ureg_DECL_vs_input( ureg, 1 ));
-      
-      if (passColor) {
-         /* MOV result.color0, vertex.attr[2]; */
-         ureg_MOV(ureg, 
-                  ureg_DECL_output( ureg, TGSI_SEMANTIC_COLOR, 0 ),
-                  ureg_DECL_vs_input( ureg, 2 ));
-      }
-
-      ureg_END( ureg );
-      
-      st->drawpix.vert_shaders[passColor] = 
-         ureg_create_shader_and_destroy( ureg, st->pipe );
-   }
-
-   return st->drawpix.vert_shaders[passColor];
-}
-
-
-/**
- * Return a texture base format for drawing/copying an image
- * of the given format.
- */
-static GLenum
-base_format(GLenum format)
-{
-   switch (format) {
-   case GL_DEPTH_COMPONENT:
-      return GL_DEPTH_COMPONENT;
-   case GL_DEPTH_STENCIL:
-      return GL_DEPTH_STENCIL;
-   case GL_STENCIL_INDEX:
-      return GL_STENCIL_INDEX;
-   default:
-      return GL_RGBA;
-   }
-}
-
-
-/**
- * Return a texture internalFormat for drawing/copying an image
- * of the given format and type.
- */
-static GLenum
-internal_format(GLenum format, GLenum type)
-{
-   switch (format) {
-   case GL_DEPTH_COMPONENT:
-      return GL_DEPTH_COMPONENT;
-   case GL_DEPTH_STENCIL:
-      return GL_DEPTH_STENCIL;
-   case GL_STENCIL_INDEX:
-      return GL_STENCIL_INDEX;
-   default:
-      if (_mesa_is_integer_format(format)) {
-         switch (type) {
-         case GL_BYTE:
-            return GL_RGBA8I;
-         case GL_UNSIGNED_BYTE:
-            return GL_RGBA8UI;
-         case GL_SHORT:
-            return GL_RGBA16I;
-         case GL_UNSIGNED_SHORT:
-            return GL_RGBA16UI;
-         case GL_INT:
-            return GL_RGBA32I;
-         case GL_UNSIGNED_INT:
-            return GL_RGBA32UI;
-         default:
-            assert(0 && "Unexpected type in internal_format()");
-            return GL_RGBA_INTEGER;
-         }
-      }
-      else {
-         return GL_RGBA;
-      }
-   }
-}
-
-
-/**
- * Create a temporary texture to hold an image of the given size.
- * If width, height are not POT and the driver only handles POT textures,
- * allocate the next larger size of texture that is POT.
- */
-static struct pipe_resource *
-alloc_texture(struct st_context *st, GLsizei width, GLsizei height,
-              enum pipe_format texFormat)
-{
-   struct pipe_resource *pt;
-
-   pt = st_texture_create(st, st->internal_target, texFormat, 0,
-                          width, height, 1, 1, PIPE_BIND_SAMPLER_VIEW);
-
-   return pt;
-}
-
-
-/**
- * Make texture containing an image for glDrawPixels image.
- * If 'pixels' is NULL, leave the texture image data undefined.
- */
-static struct pipe_resource *
-make_texture(struct st_context *st,
-	     GLsizei width, GLsizei height, GLenum format, GLenum type,
-	     const struct gl_pixelstore_attrib *unpack,
-	     const GLvoid *pixels)
-{
-   struct gl_context *ctx = st->ctx;
-   struct pipe_context *pipe = st->pipe;
-   gl_format mformat;
-   struct pipe_resource *pt;
-   enum pipe_format pipeFormat;
-   GLuint cpp;
-   GLenum baseFormat, intFormat;
-
-   baseFormat = base_format(format);
-   intFormat = internal_format(format, type);
-
-   mformat = st_ChooseTextureFormat_renderable(ctx, intFormat,
-                                               format, type, GL_FALSE);
-   assert(mformat);
-
-   pipeFormat = st_mesa_format_to_pipe_format(mformat);
-   assert(pipeFormat);
-   cpp = util_format_get_blocksize(pipeFormat);
-
-   pixels = _mesa_map_pbo_source(ctx, unpack, pixels);
-   if (!pixels)
-      return NULL;
-
-   /* alloc temporary texture */
-   pt = alloc_texture(st, width, height, pipeFormat);
-   if (!pt) {
-      _mesa_unmap_pbo_source(ctx, unpack);
-      return NULL;
-   }
-
-   {
-      struct pipe_transfer *transfer;
-      static const GLuint dstImageOffsets = 0;
-      GLboolean success;
-      GLubyte *dest;
-      const GLbitfield imageTransferStateSave = ctx->_ImageTransferState;
-
-      /* we'll do pixel transfer in a fragment shader */
-      ctx->_ImageTransferState = 0x0;
-
-      transfer = pipe_get_transfer(st->pipe, pt, 0, 0,
-                                   PIPE_TRANSFER_WRITE, 0, 0,
-                                   width, height);
-
-      /* map texture transfer */
-      dest = pipe_transfer_map(pipe, transfer);
-
-
-      /* Put image into texture transfer.
-       * Note that the image is actually going to be upside down in
-       * the texture.  We deal with that with texcoords.
-       */
-      success = _mesa_texstore(ctx, 2,           /* dims */
-                               baseFormat,       /* baseInternalFormat */
-                               mformat,          /* gl_format */
-                               dest,             /* dest */
-                               0, 0, 0,          /* dstX/Y/Zoffset */
-                               transfer->stride, /* dstRowStride, bytes */
-                               &dstImageOffsets, /* dstImageOffsets */
-                               width, height, 1, /* size */
-                               format, type,     /* src format/type */
-                               pixels,           /* data source */
-                               unpack);
-
-      /* unmap */
-      pipe_transfer_unmap(pipe, transfer);
-      pipe->transfer_destroy(pipe, transfer);
-
-      assert(success);
-
-      /* restore */
-      ctx->_ImageTransferState = imageTransferStateSave;
-   }
-
-   _mesa_unmap_pbo_source(ctx, unpack);
-
-   return pt;
-}
-
-
-/**
- * Draw quad with texcoords and optional color.
- * Coords are gallium window coords with y=0=top.
- * \param color  may be null
- * \param invertTex  if true, flip texcoords vertically
- */
-static void
-draw_quad(struct gl_context *ctx, GLfloat x0, GLfloat y0, GLfloat z,
-          GLfloat x1, GLfloat y1, const GLfloat *color,
-          GLboolean invertTex, GLfloat maxXcoord, GLfloat maxYcoord)
-{
-   struct st_context *st = st_context(ctx);
-   struct pipe_context *pipe = st->pipe;
-   GLfloat verts[4][3][4]; /* four verts, three attribs, XYZW */
-
-   /* setup vertex data */
-   {
-      const struct gl_framebuffer *fb = st->ctx->DrawBuffer;
-      const GLfloat fb_width = (GLfloat) fb->Width;
-      const GLfloat fb_height = (GLfloat) fb->Height;
-      const GLfloat clip_x0 = x0 / fb_width * 2.0f - 1.0f;
-      const GLfloat clip_y0 = y0 / fb_height * 2.0f - 1.0f;
-      const GLfloat clip_x1 = x1 / fb_width * 2.0f - 1.0f;
-      const GLfloat clip_y1 = y1 / fb_height * 2.0f - 1.0f;
-      const GLfloat sLeft = 0.0f, sRight = maxXcoord;
-      const GLfloat tTop = invertTex ? maxYcoord : 0.0f;
-      const GLfloat tBot = invertTex ? 0.0f : maxYcoord;
-      GLuint i;
-
-      /* upper-left */
-      verts[0][0][0] = clip_x0;    /* v[0].attr[0].x */
-      verts[0][0][1] = clip_y0;    /* v[0].attr[0].y */
-
-      /* upper-right */
-      verts[1][0][0] = clip_x1;
-      verts[1][0][1] = clip_y0;
-
-      /* lower-right */
-      verts[2][0][0] = clip_x1;
-      verts[2][0][1] = clip_y1;
-
-      /* lower-left */
-      verts[3][0][0] = clip_x0;
-      verts[3][0][1] = clip_y1;
-
-      verts[0][1][0] = sLeft; /* v[0].attr[1].S */
-      verts[0][1][1] = tTop;  /* v[0].attr[1].T */
-      verts[1][1][0] = sRight;
-      verts[1][1][1] = tTop;
-      verts[2][1][0] = sRight;
-      verts[2][1][1] = tBot;
-      verts[3][1][0] = sLeft;
-      verts[3][1][1] = tBot;
-
-      /* same for all verts: */
-      if (color) {
-         for (i = 0; i < 4; i++) {
-            verts[i][0][2] = z;         /* v[i].attr[0].z */
-            verts[i][0][3] = 1.0f;      /* v[i].attr[0].w */
-            verts[i][2][0] = color[0];  /* v[i].attr[2].r */
-            verts[i][2][1] = color[1];  /* v[i].attr[2].g */
-            verts[i][2][2] = color[2];  /* v[i].attr[2].b */
-            verts[i][2][3] = color[3];  /* v[i].attr[2].a */
-            verts[i][1][2] = 0.0f;      /* v[i].attr[1].R */
-            verts[i][1][3] = 1.0f;      /* v[i].attr[1].Q */
-         }
-      }
-      else {
-         for (i = 0; i < 4; i++) {
-            verts[i][0][2] = z;    /*Z*/
-            verts[i][0][3] = 1.0f; /*W*/
-            verts[i][1][2] = 0.0f; /*R*/
-            verts[i][1][3] = 1.0f; /*Q*/
-         }
-      }
-   }
-
-   {
-      struct pipe_resource *buf;
-
-      /* allocate/load buffer object with vertex data */
-      buf = pipe_buffer_create(pipe->screen,
-			       PIPE_BIND_VERTEX_BUFFER,
-			       PIPE_USAGE_STATIC,
-                               sizeof(verts));
-      pipe_buffer_write(st->pipe, buf, 0, sizeof(verts), verts);
-
-      util_draw_vertex_buffer(pipe, st->cso_context, buf, 0,
-                              PIPE_PRIM_QUADS,
-                              4,  /* verts */
-                              3); /* attribs/vert */
-      pipe_resource_reference(&buf, NULL);
-   }
-}
-
-
-
-static void
-draw_textured_quad(struct gl_context *ctx, GLint x, GLint y, GLfloat z,
-                   GLsizei width, GLsizei height,
-                   GLfloat zoomX, GLfloat zoomY,
-                   struct pipe_sampler_view **sv,
-                   int num_sampler_view,
-                   void *driver_vp,
-                   void *driver_fp,
-                   const GLfloat *color,
-                   GLboolean invertTex,
-                   GLboolean write_depth, GLboolean write_stencil)
-{
-   struct st_context *st = st_context(ctx);
-   struct pipe_context *pipe = st->pipe;
-   struct cso_context *cso = st->cso_context;
-   GLfloat x0, y0, x1, y1;
-   GLsizei maxSize;
-   boolean normalized = sv[0]->texture->target != PIPE_TEXTURE_RECT;
-
-   /* limit checks */
-   /* XXX if DrawPixels image is larger than max texture size, break
-    * it up into chunks.
-    */
-   maxSize = 1 << (pipe->screen->get_param(pipe->screen,
-                                        PIPE_CAP_MAX_TEXTURE_2D_LEVELS) - 1);
-   assert(width <= maxSize);
-   assert(height <= maxSize);
-
-   cso_save_rasterizer(cso);
-   cso_save_viewport(cso);
-   cso_save_samplers(cso);
-   cso_save_fragment_sampler_views(cso);
-   cso_save_fragment_shader(cso);
-   cso_save_vertex_shader(cso);
-   cso_save_vertex_elements(cso);
-   cso_save_vertex_buffers(cso);
-   if (write_stencil) {
-      cso_save_depth_stencil_alpha(cso);
-      cso_save_blend(cso);
-   }
-
-   /* rasterizer state: just scissor */
-   {
-      struct pipe_rasterizer_state rasterizer;
-      memset(&rasterizer, 0, sizeof(rasterizer));
-      rasterizer.gl_rasterization_rules = 1;
-      rasterizer.scissor = ctx->Scissor.Enabled;
-      cso_set_rasterizer(cso, &rasterizer);
-   }
-
-   if (write_stencil) {
-      /* Stencil writing bypasses the normal fragment pipeline to
-       * disable color writing and set stencil test to always pass.
-       */
-      struct pipe_depth_stencil_alpha_state dsa;
-      struct pipe_blend_state blend;
-
-      /* depth/stencil */
-      memset(&dsa, 0, sizeof(dsa));
-      dsa.stencil[0].enabled = 1;
-      dsa.stencil[0].func = PIPE_FUNC_ALWAYS;
-      dsa.stencil[0].writemask = ctx->Stencil.WriteMask[0] & 0xff;
-      dsa.stencil[0].zpass_op = PIPE_STENCIL_OP_REPLACE;
-      if (write_depth) {
-         /* writing depth+stencil: depth test always passes */
-         dsa.depth.enabled = 1;
-         dsa.depth.writemask = ctx->Depth.Mask;
-         dsa.depth.func = PIPE_FUNC_ALWAYS;
-      }
-      cso_set_depth_stencil_alpha(cso, &dsa);
-
-      /* blend (colormask) */
-      memset(&blend, 0, sizeof(blend));
-      cso_set_blend(cso, &blend);
-   }
-
-   /* fragment shader state: TEX lookup program */
-   cso_set_fragment_shader_handle(cso, driver_fp);
-
-   /* vertex shader state: position + texcoord pass-through */
-   cso_set_vertex_shader_handle(cso, driver_vp);
-
-
-   /* texture sampling state: */
-   {
-      struct pipe_sampler_state sampler;
-      memset(&sampler, 0, sizeof(sampler));
-      sampler.wrap_s = PIPE_TEX_WRAP_CLAMP;
-      sampler.wrap_t = PIPE_TEX_WRAP_CLAMP;
-      sampler.wrap_r = PIPE_TEX_WRAP_CLAMP;
-      sampler.min_img_filter = PIPE_TEX_FILTER_NEAREST;
-      sampler.min_mip_filter = PIPE_TEX_MIPFILTER_NONE;
-      sampler.mag_img_filter = PIPE_TEX_FILTER_NEAREST;
-      sampler.normalized_coords = normalized;
-
-      cso_single_sampler(cso, 0, &sampler);
-      if (num_sampler_view > 1) {
-         cso_single_sampler(cso, 1, &sampler);
-      }
-      cso_single_sampler_done(cso);
-   }
-
-   /* viewport state: viewport matching window dims */
-   {
-      const float w = (float) ctx->DrawBuffer->Width;
-      const float h = (float) ctx->DrawBuffer->Height;
-      struct pipe_viewport_state vp;
-      vp.scale[0] =  0.5f * w;
-      vp.scale[1] = -0.5f * h;
-      vp.scale[2] = 0.5f;
-      vp.scale[3] = 1.0f;
-      vp.translate[0] = 0.5f * w;
-      vp.translate[1] = 0.5f * h;
-      vp.translate[2] = 0.5f;
-      vp.translate[3] = 0.0f;
-      cso_set_viewport(cso, &vp);
-   }
-
-   cso_set_vertex_elements(cso, 3, st->velems_util_draw);
-
-   /* texture state: */
-   cso_set_fragment_sampler_views(cso, num_sampler_view, sv);
-
-   /* Compute Gallium window coords (y=0=top) with pixel zoom.
-    * Recall that these coords are transformed by the current
-    * vertex shader and viewport transformation.
-    */
-   if (st_fb_orientation(ctx->DrawBuffer) == Y_0_BOTTOM) {
-      y = ctx->DrawBuffer->Height - (int) (y + height * ctx->Pixel.ZoomY);
-      invertTex = !invertTex;
-   }
-
-   x0 = (GLfloat) x;
-   x1 = x + width * ctx->Pixel.ZoomX;
-   y0 = (GLfloat) y;
-   y1 = y + height * ctx->Pixel.ZoomY;
-
-   /* convert Z from [0,1] to [-1,-1] to match viewport Z scale/bias */
-   z = z * 2.0 - 1.0;
-
-   draw_quad(ctx, x0, y0, z, x1, y1, color, invertTex,
-             normalized ? ((GLfloat) width / sv[0]->texture->width0) : (GLfloat)width,
-             normalized ? ((GLfloat) height / sv[0]->texture->height0) : (GLfloat)height);
-
-   /* restore state */
-   cso_restore_rasterizer(cso);
-   cso_restore_viewport(cso);
-   cso_restore_samplers(cso);
-   cso_restore_fragment_sampler_views(cso);
-   cso_restore_fragment_shader(cso);
-   cso_restore_vertex_shader(cso);
-   cso_restore_vertex_elements(cso);
-   cso_restore_vertex_buffers(cso);
-   if (write_stencil) {
-      cso_restore_depth_stencil_alpha(cso);
-      cso_restore_blend(cso);
-   }
-}
-
-
-/**
- * Software fallback to do glDrawPixels(GL_STENCIL_INDEX) when we
- * can't use a fragment shader to write stencil values.
- */
-static void
-draw_stencil_pixels(struct gl_context *ctx, GLint x, GLint y,
-                    GLsizei width, GLsizei height, GLenum format, GLenum type,
-                    const struct gl_pixelstore_attrib *unpack,
-                    const GLvoid *pixels)
-{
-   struct st_context *st = st_context(ctx);
-   struct pipe_context *pipe = st->pipe;
-   struct st_renderbuffer *strb;
-   enum pipe_transfer_usage usage;
-   struct pipe_transfer *pt;
-   const GLboolean zoom = ctx->Pixel.ZoomX != 1.0 || ctx->Pixel.ZoomY != 1.0;
-   GLint skipPixels;
-   ubyte *stmap;
-   struct gl_pixelstore_attrib clippedUnpack = *unpack;
-
-   if (!zoom) {
-      if (!_mesa_clip_drawpixels(ctx, &x, &y, &width, &height,
-                                 &clippedUnpack)) {
-         /* totally clipped */
-         return;
-      }
-   }
-
-   strb = st_renderbuffer(ctx->DrawBuffer->
-                          Attachment[BUFFER_STENCIL].Renderbuffer);
-
-   if (st_fb_orientation(ctx->DrawBuffer) == Y_0_TOP) {
-      y = ctx->DrawBuffer->Height - y - height;
-   }
-
-   if(format != GL_DEPTH_STENCIL && 
-      util_format_get_component_bits(strb->format,
-                                     UTIL_FORMAT_COLORSPACE_ZS, 0) != 0)
-      usage = PIPE_TRANSFER_READ_WRITE;
-   else
-      usage = PIPE_TRANSFER_WRITE;
-
-   pt = pipe_get_transfer(st_context(ctx)->pipe, strb->texture, 0, 0,
-                                     usage, x, y,
-                                     width, height);
-
-   stmap = pipe_transfer_map(pipe, pt);
-
-   pixels = _mesa_map_pbo_source(ctx, &clippedUnpack, pixels);
-   assert(pixels);
-
-   /* if width > MAX_WIDTH, have to process image in chunks */
-   skipPixels = 0;
-   while (skipPixels < width) {
-      const GLint spanX = skipPixels;
-      const GLint spanWidth = MIN2(width - skipPixels, MAX_WIDTH);
-      GLint row;
-      for (row = 0; row < height; row++) {
-         GLubyte sValues[MAX_WIDTH];
-         GLuint zValues[MAX_WIDTH];
-         GLenum destType = GL_UNSIGNED_BYTE;
-         const GLvoid *source = _mesa_image_address2d(&clippedUnpack, pixels,
-                                                      width, height,
-                                                      format, type,
-                                                      row, skipPixels);
-         _mesa_unpack_stencil_span(ctx, spanWidth, destType, sValues,
-                                   type, source, &clippedUnpack,
-                                   ctx->_ImageTransferState);
-
-         if (format == GL_DEPTH_STENCIL) {
-            _mesa_unpack_depth_span(ctx, spanWidth, GL_UNSIGNED_INT, zValues,
-                                    (1 << 24) - 1, type, source,
-                                    &clippedUnpack);
-         }
-
-         if (zoom) {
-            _mesa_problem(ctx, "Gallium glDrawPixels(GL_STENCIL) with "
-                          "zoom not complete");
-         }
-
-         {
-            GLint spanY;
-
-            if (st_fb_orientation(ctx->DrawBuffer) == Y_0_TOP) {
-               spanY = height - row - 1;
-            }
-            else {
-               spanY = row;
-            }
-
-            /* now pack the stencil (and Z) values in the dest format */
-            switch (pt->resource->format) {
-            case PIPE_FORMAT_S8_USCALED:
-               {
-                  ubyte *dest = stmap + spanY * pt->stride + spanX;
-                  assert(usage == PIPE_TRANSFER_WRITE);
-                  memcpy(dest, sValues, spanWidth);
-               }
-               break;
-            case PIPE_FORMAT_Z24_UNORM_S8_USCALED:
-               if (format == GL_DEPTH_STENCIL) {
-                  uint *dest = (uint *) (stmap + spanY * pt->stride + spanX*4);
-                  GLint k;
-                  assert(usage == PIPE_TRANSFER_WRITE);
-                  for (k = 0; k < spanWidth; k++) {
-                     dest[k] = zValues[k] | (sValues[k] << 24);
-                  }
-               }
-               else {
-                  uint *dest = (uint *) (stmap + spanY * pt->stride + spanX*4);
-                  GLint k;
-                  assert(usage == PIPE_TRANSFER_READ_WRITE);
-                  for (k = 0; k < spanWidth; k++) {
-                     dest[k] = (dest[k] & 0xffffff) | (sValues[k] << 24);
-                  }
-               }
-               break;
-            case PIPE_FORMAT_S8_USCALED_Z24_UNORM:
-               if (format == GL_DEPTH_STENCIL) {
-                  uint *dest = (uint *) (stmap + spanY * pt->stride + spanX*4);
-                  GLint k;
-                  assert(usage == PIPE_TRANSFER_WRITE);
-                  for (k = 0; k < spanWidth; k++) {
-                     dest[k] = (zValues[k] << 8) | (sValues[k] & 0xff);
-                  }
-               }
-               else {
-                  uint *dest = (uint *) (stmap + spanY * pt->stride + spanX*4);
-                  GLint k;
-                  assert(usage == PIPE_TRANSFER_READ_WRITE);
-                  for (k = 0; k < spanWidth; k++) {
-                     dest[k] = (dest[k] & 0xffffff00) | (sValues[k] & 0xff);
-                  }
-               }
-               break;
-            default:
-               assert(0);
-            }
-         }
-      }
-      skipPixels += spanWidth;
-   }
-
-   _mesa_unmap_pbo_source(ctx, &clippedUnpack);
-
-   /* unmap the stencil buffer */
-   pipe_transfer_unmap(pipe, pt);
-   pipe->transfer_destroy(pipe, pt);
-}
-
-
-/**
- * Get fragment program variant for a glDrawPixels or glCopyPixels
- * command for RGBA data.
- */
-static struct st_fp_variant *
-get_color_fp_variant(struct st_context *st)
-{
-   struct gl_context *ctx = st->ctx;
-   struct st_fp_variant_key key;
-   struct st_fp_variant *fpv;
-
-   memset(&key, 0, sizeof(key));
-
-   key.st = st;
-   key.drawpixels = 1;
-   key.scaleAndBias = (ctx->Pixel.RedBias != 0.0 ||
-                       ctx->Pixel.RedScale != 1.0 ||
-                       ctx->Pixel.GreenBias != 0.0 ||
-                       ctx->Pixel.GreenScale != 1.0 ||
-                       ctx->Pixel.BlueBias != 0.0 ||
-                       ctx->Pixel.BlueScale != 1.0 ||
-                       ctx->Pixel.AlphaBias != 0.0 ||
-                       ctx->Pixel.AlphaScale != 1.0);
-   key.pixelMaps = ctx->Pixel.MapColorFlag;
-
-   fpv = st_get_fp_variant(st, st->fp, &key);
-
-   return fpv;
-}
-
-
-/**
- * Get fragment program variant for a glDrawPixels or glCopyPixels
- * command for depth/stencil data.
- */
-static struct st_fp_variant *
-get_depth_stencil_fp_variant(struct st_context *st, GLboolean write_depth,
-                             GLboolean write_stencil)
-{
-   struct st_fp_variant_key key;
-   struct st_fp_variant *fpv;
-
-   memset(&key, 0, sizeof(key));
-
-   key.st = st;
-   key.drawpixels = 1;
-   key.drawpixels_z = write_depth;
-   key.drawpixels_stencil = write_stencil;
-
-   fpv = st_get_fp_variant(st, st->fp, &key);
-
-   return fpv;
-}
-
-
-/**
- * Called via ctx->Driver.DrawPixels()
- */
-static void
-st_DrawPixels(struct gl_context *ctx, GLint x, GLint y,
-              GLsizei width, GLsizei height,
-              GLenum format, GLenum type,
-              const struct gl_pixelstore_attrib *unpack, const GLvoid *pixels)
-{
-   void *driver_vp, *driver_fp;
-   struct st_context *st = st_context(ctx);
-   const GLfloat *color;
-   struct pipe_context *pipe = st->pipe;
-   GLboolean write_stencil = GL_FALSE, write_depth = GL_FALSE;
-   struct pipe_sampler_view *sv[2];
-   int num_sampler_view = 1;
-   enum pipe_format stencil_format = PIPE_FORMAT_NONE;
-   struct st_fp_variant *fpv;
-
-   if (format == GL_DEPTH_STENCIL)
-      write_stencil = write_depth = GL_TRUE;
-   else if (format == GL_STENCIL_INDEX)
-      write_stencil = GL_TRUE;
-   else if (format == GL_DEPTH_COMPONENT)
-      write_depth = GL_TRUE;
-
-   if (write_stencil) {
-      enum pipe_format tex_format;
-      /* can we write to stencil if not fallback */
-      if (!pipe->screen->get_param(pipe->screen, PIPE_CAP_SHADER_STENCIL_EXPORT))
-	 goto stencil_fallback;
-      
-      tex_format = st_choose_format(st->pipe->screen, base_format(format),
-                                    PIPE_TEXTURE_2D,
-				    0, PIPE_BIND_SAMPLER_VIEW);
-      if (tex_format == PIPE_FORMAT_Z24_UNORM_S8_USCALED)
-	 stencil_format = PIPE_FORMAT_X24S8_USCALED;
-      else if (tex_format == PIPE_FORMAT_S8_USCALED_Z24_UNORM)
-	 stencil_format = PIPE_FORMAT_S8X24_USCALED;
-      else
-	 stencil_format = PIPE_FORMAT_S8_USCALED;
-      if (stencil_format == PIPE_FORMAT_NONE)
-	 goto stencil_fallback;
-   }
-
-   /* Mesa state should be up to date by now */
-   assert(ctx->NewState == 0x0);
-
-   st_validate_state(st);
-
-   /*
-    * Get vertex/fragment shaders
-    */
-   if (write_depth || write_stencil) {
-      fpv = get_depth_stencil_fp_variant(st, write_depth, write_stencil);
-
-      driver_fp = fpv->driver_shader;
-
-      driver_vp = make_passthrough_vertex_shader(st, GL_TRUE);
-
-      color = ctx->Current.RasterColor;
-   }
-   else {
-      fpv = get_color_fp_variant(st);
-
-      driver_fp = fpv->driver_shader;
-
-      driver_vp = make_passthrough_vertex_shader(st, GL_FALSE);
-
-      color = NULL;
-      if (st->pixel_xfer.pixelmap_enabled) {
-	  sv[1] = st->pixel_xfer.pixelmap_sampler_view;
-	  num_sampler_view++;
-      }
-   }
-
-   /* update fragment program constants */
-   st_upload_constants(st, fpv->parameters, PIPE_SHADER_FRAGMENT);
-
-   /* draw with textured quad */
-   {
-      struct pipe_resource *pt
-         = make_texture(st, width, height, format, type, unpack, pixels);
-      if (pt) {
-         sv[0] = st_create_texture_sampler_view(st->pipe, pt);
-
-         if (sv[0]) {
-	    if (write_stencil) {
-	       sv[1] = st_create_texture_sampler_view_format(st->pipe, pt,
-                                                             stencil_format);
-	       num_sampler_view++;
-	    }
-
-            draw_textured_quad(ctx, x, y, ctx->Current.RasterPos[2],
-                               width, height,
-                               ctx->Pixel.ZoomX, ctx->Pixel.ZoomY,
-                               sv,
-                               num_sampler_view,
-                               driver_vp,
-                               driver_fp,
-                               color, GL_FALSE, write_depth, write_stencil);
-            pipe_sampler_view_reference(&sv[0], NULL);
-            if (num_sampler_view > 1)
-               pipe_sampler_view_reference(&sv[1], NULL);
-         }
-         pipe_resource_reference(&pt, NULL);
-      }
-   }
-   return;
-
-stencil_fallback:
-   draw_stencil_pixels(ctx, x, y, width, height, format, type,
-		       unpack, pixels);
-}
-
-
-
-/**
- * Software fallback for glCopyPixels(GL_STENCIL).
- */
-static void
-copy_stencil_pixels(struct gl_context *ctx, GLint srcx, GLint srcy,
-                    GLsizei width, GLsizei height,
-                    GLint dstx, GLint dsty)
-{
-   struct st_renderbuffer *rbDraw;
-   struct pipe_context *pipe = st_context(ctx)->pipe;
-   enum pipe_transfer_usage usage;
-   struct pipe_transfer *ptDraw;
-   ubyte *drawMap;
-   ubyte *buffer;
-   int i;
-
-   buffer = malloc(width * height * sizeof(ubyte));
-   if (!buffer) {
-      _mesa_error(ctx, GL_OUT_OF_MEMORY, "glCopyPixels(stencil)");
-      return;
-   }
-
-   /* Get the dest renderbuffer.  If there's a wrapper, use the
-    * underlying renderbuffer.
-    */
-   rbDraw = st_renderbuffer(ctx->DrawBuffer->_StencilBuffer);
-   if (rbDraw->Base.Wrapped)
-      rbDraw = st_renderbuffer(rbDraw->Base.Wrapped);
-
-   /* this will do stencil pixel transfer ops */
-   st_read_stencil_pixels(ctx, srcx, srcy, width, height,
-                          GL_STENCIL_INDEX, GL_UNSIGNED_BYTE,
-                          &ctx->DefaultPacking, buffer);
-
-   if (0) {
-      /* debug code: dump stencil values */
-      GLint row, col;
-      for (row = 0; row < height; row++) {
-         printf("%3d: ", row);
-         for (col = 0; col < width; col++) {
-            printf("%02x ", buffer[col + row * width]);
-         }
-         printf("\n");
-      }
-   }
-
-   if (util_format_get_component_bits(rbDraw->format,
-                                     UTIL_FORMAT_COLORSPACE_ZS, 0) != 0)
-      usage = PIPE_TRANSFER_READ_WRITE;
-   else
-      usage = PIPE_TRANSFER_WRITE;
-
-   if (st_fb_orientation(ctx->DrawBuffer) == Y_0_TOP) {
-      dsty = rbDraw->Base.Height - dsty - height;
-   }
-
-   ptDraw = pipe_get_transfer(st_context(ctx)->pipe,
-                              rbDraw->texture, 0, 0,
-                              usage, dstx, dsty,
-                              width, height);
-
-   assert(util_format_get_blockwidth(ptDraw->resource->format) == 1);
-   assert(util_format_get_blockheight(ptDraw->resource->format) == 1);
-
-   /* map the stencil buffer */
-   drawMap = pipe_transfer_map(pipe, ptDraw);
-
-   /* draw */
-   /* XXX PixelZoom not handled yet */
-   for (i = 0; i < height; i++) {
-      ubyte *dst;
-      const ubyte *src;
-      int y;
-
-      y = i;
-
-      if (st_fb_orientation(ctx->DrawBuffer) == Y_0_TOP) {
-         y = height - y - 1;
-      }
-
-      dst = drawMap + y * ptDraw->stride;
-      src = buffer + i * width;
-
-      switch (ptDraw->resource->format) {
-      case PIPE_FORMAT_Z24_UNORM_S8_USCALED:
-         {
-            uint *dst4 = (uint *) dst;
-            int j;
-            assert(usage == PIPE_TRANSFER_READ_WRITE);
-            for (j = 0; j < width; j++) {
-               *dst4 = (*dst4 & 0xffffff) | (src[j] << 24);
-               dst4++;
-            }
-         }
-         break;
-      case PIPE_FORMAT_S8_USCALED_Z24_UNORM:
-         {
-            uint *dst4 = (uint *) dst;
-            int j;
-            assert(usage == PIPE_TRANSFER_READ_WRITE);
-            for (j = 0; j < width; j++) {
-               *dst4 = (*dst4 & 0xffffff00) | (src[j] & 0xff);
-               dst4++;
-            }
-         }
-         break;
-      case PIPE_FORMAT_S8_USCALED:
-         assert(usage == PIPE_TRANSFER_WRITE);
-         memcpy(dst, src, width);
-         break;
-      default:
-         assert(0);
-      }
-   }
-
-   free(buffer);
-
-   /* unmap the stencil buffer */
-   pipe_transfer_unmap(pipe, ptDraw);
-   pipe->transfer_destroy(pipe, ptDraw);
-}
-
-
-/** Do the src/dest regions overlap? */
-static GLboolean
-regions_overlap(GLint srcX, GLint srcY, GLint dstX, GLint dstY,
-                GLsizei width, GLsizei height)
-{
-   if (srcX + width <= dstX ||
-       dstX + width <= srcX ||
-       srcY + height <= dstY ||
-       dstY + height <= srcY)
-      return GL_FALSE;
-   else
-      return GL_TRUE;
-}
-
-
-/**
- * Try to do a glCopyPixels for simple cases with a blit by calling
- * pipe->resource_copy_region().
- *
- * We can do this when we're copying color pixels (depth/stencil
- * eventually) with no pixel zoom, no pixel transfer ops, no
- * per-fragment ops, the src/dest regions don't overlap and the
- * src/dest pixel formats are the same.
- */
-static GLboolean
-blit_copy_pixels(struct gl_context *ctx, GLint srcx, GLint srcy,
-                 GLsizei width, GLsizei height,
-                 GLint dstx, GLint dsty, GLenum type)
-{
-   struct st_context *st = st_context(ctx);
-   struct pipe_context *pipe = st->pipe;
-   struct gl_pixelstore_attrib pack, unpack;
-   GLint readX, readY, readW, readH;
-
-   if (type == GL_COLOR &&
-       ctx->Pixel.ZoomX == 1.0 &&
-       ctx->Pixel.ZoomY == 1.0 &&
-       ctx->_ImageTransferState == 0x0 &&
-       !ctx->Color.BlendEnabled &&
-       !ctx->Color.AlphaEnabled &&
-       !ctx->Depth.Test &&
-       !ctx->Fog.Enabled &&
-       !ctx->Stencil.Enabled &&
-       !ctx->FragmentProgram.Enabled &&
-       !ctx->VertexProgram.Enabled &&
-       !ctx->Shader.CurrentFragmentProgram &&
-       st_fb_orientation(ctx->ReadBuffer) == st_fb_orientation(ctx->DrawBuffer) &&
-       ctx->DrawBuffer->_NumColorDrawBuffers == 1) {
-      struct st_renderbuffer *rbRead, *rbDraw;
-      GLint drawX, drawY;
-
-      /*
-       * Clip the read region against the src buffer bounds.
-       * We'll still allocate a temporary buffer/texture for the original
-       * src region size but we'll only read the region which is on-screen.
-       * This may mean that we draw garbage pixels into the dest region, but
-       * that's expected.
-       */
-      readX = srcx;
-      readY = srcy;
-      readW = width;
-      readH = height;
-      pack = ctx->DefaultPacking;
-      if (!_mesa_clip_readpixels(ctx, &readX, &readY, &readW, &readH, &pack))
-         return GL_TRUE; /* all done */
-
-      /* clip against dest buffer bounds and scissor box */
-      drawX = dstx + pack.SkipPixels;
-      drawY = dsty + pack.SkipRows;
-      unpack = pack;
-      if (!_mesa_clip_drawpixels(ctx, &drawX, &drawY, &readW, &readH, &unpack))
-         return GL_TRUE; /* all done */
-
-      readX = readX - pack.SkipPixels + unpack.SkipPixels;
-      readY = readY - pack.SkipRows + unpack.SkipRows;
-
-      rbRead = st_get_color_read_renderbuffer(ctx);
-      rbDraw = st_renderbuffer(ctx->DrawBuffer->_ColorDrawBuffers[0]);
-
-      if ((rbRead != rbDraw ||
-           !regions_overlap(readX, readY, drawX, drawY, readW, readH)) &&
-          rbRead->Base.Format == rbDraw->Base.Format) {
-         struct pipe_box srcBox;
-
-         /* flip src/dst position if needed */
-         if (st_fb_orientation(ctx->ReadBuffer) == Y_0_TOP) {
-            /* both buffers will have the same orientation */
-            readY = ctx->ReadBuffer->Height - readY - readH;
-            drawY = ctx->DrawBuffer->Height - drawY - readH;
-         }
-
-         u_box_2d(readX, readY, readW, readH, &srcBox);
-
-         pipe->resource_copy_region(pipe,
-                                    rbDraw->texture, 0, drawX, drawY, 0,
-                                    rbRead->texture, 0, &srcBox);
-         return GL_TRUE;
-      }
-   }
-
-   return GL_FALSE;
-}
-
-
-static void
-st_CopyPixels(struct gl_context *ctx, GLint srcx, GLint srcy,
-              GLsizei width, GLsizei height,
-              GLint dstx, GLint dsty, GLenum type)
-{
-   struct st_context *st = st_context(ctx);
-   struct pipe_context *pipe = st->pipe;
-   struct pipe_screen *screen = pipe->screen;
-   struct st_renderbuffer *rbRead;
-   void *driver_vp, *driver_fp;
-   struct pipe_resource *pt;
-   struct pipe_sampler_view *sv[2];
-   int num_sampler_view = 1;
-   GLfloat *color;
-   enum pipe_format srcFormat, texFormat;
-   GLboolean invertTex = GL_FALSE;
-   GLint readX, readY, readW, readH;
-   GLuint sample_count;
-   struct gl_pixelstore_attrib pack = ctx->DefaultPacking;
-   struct st_fp_variant *fpv;
-
-   st_validate_state(st);
-
-   if (type == GL_STENCIL) {
-      /* can't use texturing to do stencil */
-      copy_stencil_pixels(ctx, srcx, srcy, width, height, dstx, dsty);
-      return;
-   }
-
-   if (blit_copy_pixels(ctx, srcx, srcy, width, height, dstx, dsty, type))
-      return;
-
-   /*
-    * The subsequent code implements glCopyPixels by copying the source
-    * pixels into a temporary texture that's then applied to a textured quad.
-    * When we draw the textured quad, all the usual per-fragment operations
-    * are handled.
-    */
-
-
-   /*
-    * Get vertex/fragment shaders
-    */
-   if (type == GL_COLOR) {
-      rbRead = st_get_color_read_renderbuffer(ctx);
-      color = NULL;
-
-      fpv = get_color_fp_variant(st);
-      driver_fp = fpv->driver_shader;
-
-      driver_vp = make_passthrough_vertex_shader(st, GL_FALSE);
-
-      if (st->pixel_xfer.pixelmap_enabled) {
-	  sv[1] = st->pixel_xfer.pixelmap_sampler_view;
-	  num_sampler_view++;
-      }
-   }
-   else {
-      assert(type == GL_DEPTH);
-      rbRead = st_renderbuffer(ctx->ReadBuffer->_DepthBuffer);
-      color = ctx->Current.Attrib[VERT_ATTRIB_COLOR0];
-
-      fpv = get_depth_stencil_fp_variant(st, GL_TRUE, GL_FALSE);
-      driver_fp = fpv->driver_shader;
-
-      driver_vp = make_passthrough_vertex_shader(st, GL_TRUE);
-   }
-
-   /* update fragment program constants */
-   st_upload_constants(st, fpv->parameters, PIPE_SHADER_FRAGMENT);
-
-
-   if (rbRead->Base.Wrapped)
-      rbRead = st_renderbuffer(rbRead->Base.Wrapped);
-
-   sample_count = rbRead->texture->nr_samples;
-   /* I believe this would be legal, presumably would need to do a resolve
-      for color, and for depth/stencil spec says to just use one of the
-      depth/stencil samples per pixel? Need some transfer clarifications. */
-   assert(sample_count < 2);
-
-   srcFormat = rbRead->texture->format;
-
-   if (screen->is_format_supported(screen, srcFormat, st->internal_target,
-                                   sample_count,
-                                   PIPE_BIND_SAMPLER_VIEW, 0)) {
-      texFormat = srcFormat;
-   }
-   else {
-      /* srcFormat can't be used as a texture format */
-      if (type == GL_DEPTH) {
-         texFormat = st_choose_format(screen, GL_DEPTH_COMPONENT,
-                                      st->internal_target, sample_count,
-                                      PIPE_BIND_DEPTH_STENCIL);
-         assert(texFormat != PIPE_FORMAT_NONE);
-      }
-      else {
-         /* default color format */
-         texFormat = st_choose_format(screen, GL_RGBA, st->internal_target,
-                                      sample_count, PIPE_BIND_SAMPLER_VIEW);
-         assert(texFormat != PIPE_FORMAT_NONE);
-      }
-   }
-
-   /* Invert src region if needed */
-   if (st_fb_orientation(ctx->ReadBuffer) == Y_0_TOP) {
-      srcy = ctx->ReadBuffer->Height - srcy - height;
-      invertTex = !invertTex;
-   }
-
-   /* Clip the read region against the src buffer bounds.
-    * We'll still allocate a temporary buffer/texture for the original
-    * src region size but we'll only read the region which is on-screen.
-    * This may mean that we draw garbage pixels into the dest region, but
-    * that's expected.
-    */
-   readX = srcx;
-   readY = srcy;
-   readW = width;
-   readH = height;
-   _mesa_clip_readpixels(ctx, &readX, &readY, &readW, &readH, &pack);
-   readW = MAX2(0, readW);
-   readH = MAX2(0, readH);
-
-   /* alloc temporary texture */
-   pt = alloc_texture(st, width, height, texFormat);
-   if (!pt)
-      return;
-
-   sv[0] = st_create_texture_sampler_view(st->pipe, pt);
-   if (!sv[0]) {
-      pipe_resource_reference(&pt, NULL);
-      return;
-   }
-
-   /* Make temporary texture which is a copy of the src region.
-    */
-   if (srcFormat == texFormat) {
-      struct pipe_box src_box;
-      u_box_2d(readX, readY, readW, readH, &src_box);
-      /* copy source framebuffer surface into mipmap/texture */
-      pipe->resource_copy_region(pipe,
-                                 pt,                                /* dest tex */
-                                 0,
-                                 pack.SkipPixels, pack.SkipRows, 0, /* dest pos */
-                                 rbRead->texture,                   /* src tex */
-                                 0,
-                                 &src_box);
-
-   }
-   else {
-      /* CPU-based fallback/conversion */
-      struct pipe_transfer *ptRead =
-         pipe_get_transfer(st->pipe, rbRead->texture,
-                           0, 0, /* level, layer */
-                           PIPE_TRANSFER_READ,
-                           readX, readY, readW, readH);
-      struct pipe_transfer *ptTex;
-      enum pipe_transfer_usage transfer_usage;
-
-      if (ST_DEBUG & DEBUG_FALLBACK)
-         debug_printf("%s: fallback processing\n", __FUNCTION__);
-
-      if (type == GL_DEPTH && util_format_is_depth_and_stencil(pt->format))
-         transfer_usage = PIPE_TRANSFER_READ_WRITE;
-      else
-         transfer_usage = PIPE_TRANSFER_WRITE;
-
-      ptTex = pipe_get_transfer(st->pipe, pt, 0, 0, transfer_usage,
-                                0, 0, width, height);
-
-      /* copy image from ptRead surface to ptTex surface */
-      if (type == GL_COLOR) {
-         /* alternate path using get/put_tile() */
-         GLfloat *buf = (GLfloat *) malloc(width * height * 4 * sizeof(GLfloat));
-         enum pipe_format readFormat, drawFormat;
-         readFormat = util_format_linear(rbRead->texture->format);
-         drawFormat = util_format_linear(pt->format);
-         pipe_get_tile_rgba_format(pipe, ptRead, 0, 0, readW, readH,
-                                   readFormat, buf);
-         pipe_put_tile_rgba_format(pipe, ptTex, pack.SkipPixels, pack.SkipRows,
-                                   readW, readH, drawFormat, buf);
-         free(buf);
-      }
-      else {
-         /* GL_DEPTH */
-         GLuint *buf = (GLuint *) malloc(width * height * sizeof(GLuint));
-         pipe_get_tile_z(pipe, ptRead, 0, 0, readW, readH, buf);
-         pipe_put_tile_z(pipe, ptTex, pack.SkipPixels, pack.SkipRows,
-                         readW, readH, buf);
-         free(buf);
-      }
-
-      pipe->transfer_destroy(pipe, ptRead);
-      pipe->transfer_destroy(pipe, ptTex);
-   }
-
-   /* OK, the texture 'pt' contains the src image/pixels.  Now draw a
-    * textured quad with that texture.
-    */
-   draw_textured_quad(ctx, dstx, dsty, ctx->Current.RasterPos[2],
-                      width, height, ctx->Pixel.ZoomX, ctx->Pixel.ZoomY,
-                      sv,
-                      num_sampler_view,
-                      driver_vp, 
-                      driver_fp,
-                      color, invertTex, GL_FALSE, GL_FALSE);
-
-   pipe_resource_reference(&pt, NULL);
-   pipe_sampler_view_reference(&sv[0], NULL);
-}
-
-
-
-void st_init_drawpixels_functions(struct dd_function_table *functions)
-{
-   functions->DrawPixels = st_DrawPixels;
-   functions->CopyPixels = st_CopyPixels;
-}
-
-
-void
-st_destroy_drawpix(struct st_context *st)
-{
-   GLuint i;
-
-   for (i = 0; i < Elements(st->drawpix.shaders); i++) {
-      if (st->drawpix.shaders[i])
-         _mesa_reference_fragprog(st->ctx, &st->drawpix.shaders[i], NULL);
-   }
-
-   st_reference_fragprog(st, &st->pixel_xfer.combined_prog, NULL);
-   if (st->drawpix.vert_shaders[0])
-      ureg_free_tokens(st->drawpix.vert_shaders[0]);
-   if (st->drawpix.vert_shaders[1])
-      ureg_free_tokens(st->drawpix.vert_shaders[1]);
-}
-
-#endif /* FEATURE_drawpix */
+/**************************************************************************

+ * 

+ * Copyright 2007 Tungsten Graphics, Inc., Cedar Park, Texas.

+ * 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, sub license, 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 (including the

+ * next paragraph) 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 NON-INFRINGEMENT.

+ * IN NO EVENT SHALL TUNGSTEN GRAPHICS AND/OR ITS SUPPLIERS 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.

+ * 

+ **************************************************************************/

+

+ /*

+  * Authors:

+  *   Brian Paul

+  */

+

+#include "main/imports.h"

+#include "main/image.h"

+#include "main/bufferobj.h"

+#include "main/macros.h"

+#include "main/mfeatures.h"

+#include "main/mtypes.h"

+#include "main/pack.h"

+#include "main/pbo.h"

+#include "main/texformat.h"

+#include "main/texstore.h"

+#include "program/program.h"

+#include "program/prog_print.h"

+#include "program/prog_instruction.h"

+

+#include "st_atom.h"

+#include "st_atom_constbuf.h"

+#include "st_cb_drawpixels.h"

+#include "st_cb_readpixels.h"

+#include "st_cb_fbo.h"

+#include "st_context.h"

+#include "st_debug.h"

+#include "st_format.h"

+#include "st_program.h"

+#include "st_texture.h"

+

+#include "pipe/p_context.h"

+#include "pipe/p_defines.h"

+#include "tgsi/tgsi_ureg.h"

+#include "util/u_draw_quad.h"

+#include "util/u_format.h"

+#include "util/u_inlines.h"

+#include "util/u_math.h"

+#include "util/u_tile.h"

+#include "cso_cache/cso_context.h"

+

+

+#if FEATURE_drawpix

+

+/**

+ * Check if the given program is:

+ * 0: MOVE result.color, fragment.color;

+ * 1: END;

+ */

+static GLboolean

+is_passthrough_program(const struct gl_fragment_program *prog)

+{

+   if (prog->Base.NumInstructions == 2) {

+      const struct prog_instruction *inst = prog->Base.Instructions;

+      if (inst[0].Opcode == OPCODE_MOV &&

+          inst[1].Opcode == OPCODE_END &&

+          inst[0].DstReg.File == PROGRAM_OUTPUT &&

+          inst[0].DstReg.Index == FRAG_RESULT_COLOR &&

+          inst[0].DstReg.WriteMask == WRITEMASK_XYZW &&

+          inst[0].SrcReg[0].File == PROGRAM_INPUT &&

+          inst[0].SrcReg[0].Index == FRAG_ATTRIB_COL0 &&

+          inst[0].SrcReg[0].Swizzle == SWIZZLE_XYZW) {

+         return GL_TRUE;

+      }

+   }

+   return GL_FALSE;

+}

+

+

+

+/**

+ * Make fragment shader for glDraw/CopyPixels.  This shader is made

+ * by combining the pixel transfer shader with the user-defined shader.

+ * \param fpIn  the current/incoming fragment program

+ * \param fpOut  returns the combined fragment program

+ */

+void

+st_make_drawpix_fragment_program(struct st_context *st,

+                                 struct gl_fragment_program *fpIn,

+                                 struct gl_fragment_program **fpOut)

+{

+   struct gl_program *newProg;

+

+   if (is_passthrough_program(fpIn)) {

+      newProg = (struct gl_program *) _mesa_clone_fragment_program(st->ctx,

+                                             &st->pixel_xfer.program->Base);

+   }

+   else {

+#if 0

+      /* debug */

+      printf("Base program:\n");

+      _mesa_print_program(&fpIn->Base);

+      printf("DrawPix program:\n");

+      _mesa_print_program(&st->pixel_xfer.program->Base.Base);

+#endif

+      newProg = _mesa_combine_programs(st->ctx,

+                                       &st->pixel_xfer.program->Base.Base,

+                                       &fpIn->Base);

+   }

+

+#if 0

+   /* debug */

+   printf("Combined DrawPixels program:\n");

+   _mesa_print_program(newProg);

+   printf("InputsRead: 0x%x\n", newProg->InputsRead);

+   printf("OutputsWritten: 0x%x\n", newProg->OutputsWritten);

+   _mesa_print_parameter_list(newProg->Parameters);

+#endif

+

+   *fpOut = (struct gl_fragment_program *) newProg;

+}

+

+

+/**

+ * Create fragment program that does a TEX() instruction to get a Z and/or

+ * stencil value value, then writes to FRAG_RESULT_DEPTH/FRAG_RESULT_STENCIL.

+ * Used for glDrawPixels(GL_DEPTH_COMPONENT / GL_STENCIL_INDEX).

+ * Pass fragment color through as-is.

+ * \return pointer to the gl_fragment program

+ */

+struct gl_fragment_program *

+st_make_drawpix_z_stencil_program(struct st_context *st,

+                                  GLboolean write_depth,

+                                  GLboolean write_stencil)

+{

+   struct gl_context *ctx = st->ctx;

+   struct gl_program *p;

+   struct gl_fragment_program *fp;

+   GLuint ic = 0;

+   const GLuint shaderIndex = write_depth * 2 + write_stencil;

+

+   assert(shaderIndex < Elements(st->drawpix.shaders));

+

+   if (st->drawpix.shaders[shaderIndex]) {

+      /* already have the proper shader */

+      return st->drawpix.shaders[shaderIndex];

+   }

+

+   /*

+    * Create shader now

+    */

+   p = ctx->Driver.NewProgram(ctx, GL_FRAGMENT_PROGRAM_ARB, 0);

+   if (!p)

+      return NULL;

+

+   p->NumInstructions = write_depth ? 2 : 1;

+   p->NumInstructions += write_stencil ? 1 : 0;

+

+   p->Instructions = _mesa_alloc_instructions(p->NumInstructions);

+   if (!p->Instructions) {

+      ctx->Driver.DeleteProgram(ctx, p);

+      return NULL;

+   }

+   _mesa_init_instructions(p->Instructions, p->NumInstructions);

+

+   if (write_depth) {

+      /* TEX result.depth, fragment.texcoord[0], texture[0], 2D; */

+      p->Instructions[ic].Opcode = OPCODE_TEX;

+      p->Instructions[ic].DstReg.File = PROGRAM_OUTPUT;

+      p->Instructions[ic].DstReg.Index = FRAG_RESULT_DEPTH;

+      p->Instructions[ic].DstReg.WriteMask = WRITEMASK_Z;

+      p->Instructions[ic].SrcReg[0].File = PROGRAM_INPUT;

+      p->Instructions[ic].SrcReg[0].Index = FRAG_ATTRIB_TEX0;

+      p->Instructions[ic].TexSrcUnit = 0;

+      p->Instructions[ic].TexSrcTarget = TEXTURE_2D_INDEX;

+      ic++;

+   }

+

+   if (write_stencil) {

+      /* TEX result.stencil, fragment.texcoord[0], texture[0], 2D; */

+      p->Instructions[ic].Opcode = OPCODE_TEX;

+      p->Instructions[ic].DstReg.File = PROGRAM_OUTPUT;

+      p->Instructions[ic].DstReg.Index = FRAG_RESULT_STENCIL;

+      p->Instructions[ic].DstReg.WriteMask = WRITEMASK_Y;

+      p->Instructions[ic].SrcReg[0].File = PROGRAM_INPUT;

+      p->Instructions[ic].SrcReg[0].Index = FRAG_ATTRIB_TEX0;

+      p->Instructions[ic].TexSrcUnit = 1;

+      p->Instructions[ic].TexSrcTarget = TEXTURE_2D_INDEX;

+      ic++;

+   }

+

+   /* END; */

+   p->Instructions[ic++].Opcode = OPCODE_END;

+

+   assert(ic == p->NumInstructions);

+

+   p->InputsRead = FRAG_BIT_TEX0 | FRAG_BIT_COL0;

+   p->OutputsWritten = 0;

+   if (write_depth)

+      p->OutputsWritten |= (1 << FRAG_RESULT_DEPTH);

+   if (write_stencil)

+      p->OutputsWritten |= (1 << FRAG_RESULT_STENCIL);

+

+   p->SamplersUsed =  0x1;  /* sampler 0 (bit 0) is used */

+   if (write_stencil)

+      p->SamplersUsed |= 1 << 1;

+

+   fp = (struct gl_fragment_program *) p;

+

+   /* save the new shader */

+   st->drawpix.shaders[shaderIndex] = fp;

+

+   return fp;

+}

+

+

+/**

+ * Create a simple vertex shader that just passes through the

+ * vertex position and texcoord (and optionally, color).

+ */

+static void *

+make_passthrough_vertex_shader(struct st_context *st, 

+                               GLboolean passColor)

+{

+   if (!st->drawpix.vert_shaders[passColor]) {

+      struct ureg_program *ureg = ureg_create( TGSI_PROCESSOR_VERTEX );

+

+      if (ureg == NULL)

+         return NULL;

+

+      /* MOV result.pos, vertex.pos; */

+      ureg_MOV(ureg, 

+               ureg_DECL_output( ureg, TGSI_SEMANTIC_POSITION, 0 ),

+               ureg_DECL_vs_input( ureg, 0 ));

+      

+      /* MOV result.texcoord0, vertex.attr[1]; */

+      ureg_MOV(ureg, 

+               ureg_DECL_output( ureg, TGSI_SEMANTIC_GENERIC, 0 ),

+               ureg_DECL_vs_input( ureg, 1 ));

+      

+      if (passColor) {

+         /* MOV result.color0, vertex.attr[2]; */

+         ureg_MOV(ureg, 

+                  ureg_DECL_output( ureg, TGSI_SEMANTIC_COLOR, 0 ),

+                  ureg_DECL_vs_input( ureg, 2 ));

+      }

+

+      ureg_END( ureg );

+      

+      st->drawpix.vert_shaders[passColor] = 

+         ureg_create_shader_and_destroy( ureg, st->pipe );

+   }

+

+   return st->drawpix.vert_shaders[passColor];

+}

+

+

+/**

+ * Return a texture base format for drawing/copying an image

+ * of the given format.

+ */

+static GLenum

+base_format(GLenum format)

+{

+   switch (format) {

+   case GL_DEPTH_COMPONENT:

+      return GL_DEPTH_COMPONENT;

+   case GL_DEPTH_STENCIL:

+      return GL_DEPTH_STENCIL;

+   case GL_STENCIL_INDEX:

+      return GL_STENCIL_INDEX;

+   default:

+      return GL_RGBA;

+   }

+}

+

+

+/**

+ * Return a texture internalFormat for drawing/copying an image

+ * of the given format and type.

+ */

+static GLenum

+internal_format(GLenum format, GLenum type)

+{

+   switch (format) {

+   case GL_DEPTH_COMPONENT:

+      return GL_DEPTH_COMPONENT;

+   case GL_DEPTH_STENCIL:

+      return GL_DEPTH_STENCIL;

+   case GL_STENCIL_INDEX:

+      return GL_STENCIL_INDEX;

+   default:

+      if (_mesa_is_integer_format(format)) {

+         switch (type) {

+         case GL_BYTE:

+            return GL_RGBA8I;

+         case GL_UNSIGNED_BYTE:

+            return GL_RGBA8UI;

+         case GL_SHORT:

+            return GL_RGBA16I;

+         case GL_UNSIGNED_SHORT:

+            return GL_RGBA16UI;

+         case GL_INT:

+            return GL_RGBA32I;

+         case GL_UNSIGNED_INT:

+            return GL_RGBA32UI;

+         default:

+            assert(0 && "Unexpected type in internal_format()");

+            return GL_RGBA_INTEGER;

+         }

+      }

+      else {

+         return GL_RGBA;

+      }

+   }

+}

+

+

+/**

+ * Create a temporary texture to hold an image of the given size.

+ * If width, height are not POT and the driver only handles POT textures,

+ * allocate the next larger size of texture that is POT.

+ */

+static struct pipe_resource *

+alloc_texture(struct st_context *st, GLsizei width, GLsizei height,

+              enum pipe_format texFormat)

+{

+   struct pipe_resource *pt;

+

+   pt = st_texture_create(st, st->internal_target, texFormat, 0,

+                          width, height, 1, 1, PIPE_BIND_SAMPLER_VIEW);

+

+   return pt;

+}

+

+

+/**

+ * Make texture containing an image for glDrawPixels image.

+ * If 'pixels' is NULL, leave the texture image data undefined.

+ */

+static struct pipe_resource *

+make_texture(struct st_context *st,

+	     GLsizei width, GLsizei height, GLenum format, GLenum type,

+	     const struct gl_pixelstore_attrib *unpack,

+	     const GLvoid *pixels)

+{

+   struct gl_context *ctx = st->ctx;

+   struct pipe_context *pipe = st->pipe;

+   gl_format mformat;

+   struct pipe_resource *pt;

+   enum pipe_format pipeFormat;

+   GLuint cpp;

+   GLenum baseFormat, intFormat;

+

+   baseFormat = base_format(format);

+   intFormat = internal_format(format, type);

+

+   mformat = st_ChooseTextureFormat_renderable(ctx, intFormat,

+                                               format, type, GL_FALSE);

+   assert(mformat);

+

+   pipeFormat = st_mesa_format_to_pipe_format(mformat);

+   assert(pipeFormat);

+   cpp = util_format_get_blocksize(pipeFormat);

+

+   pixels = _mesa_map_pbo_source(ctx, unpack, pixels);

+   if (!pixels)

+      return NULL;

+

+   /* alloc temporary texture */

+   pt = alloc_texture(st, width, height, pipeFormat);

+   if (!pt) {

+      _mesa_unmap_pbo_source(ctx, unpack);

+      return NULL;

+   }

+

+   {

+      struct pipe_transfer *transfer;

+      static const GLuint dstImageOffsets = 0;

+      GLboolean success;

+      GLubyte *dest;

+      const GLbitfield imageTransferStateSave = ctx->_ImageTransferState;

+

+      /* we'll do pixel transfer in a fragment shader */

+      ctx->_ImageTransferState = 0x0;

+

+      transfer = pipe_get_transfer(st->pipe, pt, 0, 0,

+                                   PIPE_TRANSFER_WRITE, 0, 0,

+                                   width, height);

+

+      /* map texture transfer */

+      dest = pipe_transfer_map(pipe, transfer);

+

+

+      /* Put image into texture transfer.

+       * Note that the image is actually going to be upside down in

+       * the texture.  We deal with that with texcoords.

+       */

+      success = _mesa_texstore(ctx, 2,           /* dims */

+                               baseFormat,       /* baseInternalFormat */

+                               mformat,          /* gl_format */

+                               dest,             /* dest */

+                               0, 0, 0,          /* dstX/Y/Zoffset */

+                               transfer->stride, /* dstRowStride, bytes */

+                               &dstImageOffsets, /* dstImageOffsets */

+                               width, height, 1, /* size */

+                               format, type,     /* src format/type */

+                               pixels,           /* data source */

+                               unpack);

+

+      /* unmap */

+      pipe_transfer_unmap(pipe, transfer);

+      pipe->transfer_destroy(pipe, transfer);

+

+      assert(success);

+

+      /* restore */

+      ctx->_ImageTransferState = imageTransferStateSave;

+   }

+

+   _mesa_unmap_pbo_source(ctx, unpack);

+

+   return pt;

+}

+

+

+/**

+ * Draw quad with texcoords and optional color.

+ * Coords are gallium window coords with y=0=top.

+ * \param color  may be null

+ * \param invertTex  if true, flip texcoords vertically

+ */

+static void

+draw_quad(struct gl_context *ctx, GLfloat x0, GLfloat y0, GLfloat z,

+          GLfloat x1, GLfloat y1, const GLfloat *color,

+          GLboolean invertTex, GLfloat maxXcoord, GLfloat maxYcoord)

+{

+   struct st_context *st = st_context(ctx);

+   struct pipe_context *pipe = st->pipe;

+   GLfloat verts[4][3][4]; /* four verts, three attribs, XYZW */

+

+   /* setup vertex data */

+   {

+      const struct gl_framebuffer *fb = st->ctx->DrawBuffer;

+      const GLfloat fb_width = (GLfloat) fb->Width;

+      const GLfloat fb_height = (GLfloat) fb->Height;

+      const GLfloat clip_x0 = x0 / fb_width * 2.0f - 1.0f;

+      const GLfloat clip_y0 = y0 / fb_height * 2.0f - 1.0f;

+      const GLfloat clip_x1 = x1 / fb_width * 2.0f - 1.0f;

+      const GLfloat clip_y1 = y1 / fb_height * 2.0f - 1.0f;

+      const GLfloat sLeft = 0.0f, sRight = maxXcoord;

+      const GLfloat tTop = invertTex ? maxYcoord : 0.0f;

+      const GLfloat tBot = invertTex ? 0.0f : maxYcoord;

+      GLuint i;

+

+      /* upper-left */

+      verts[0][0][0] = clip_x0;    /* v[0].attr[0].x */

+      verts[0][0][1] = clip_y0;    /* v[0].attr[0].y */

+

+      /* upper-right */

+      verts[1][0][0] = clip_x1;

+      verts[1][0][1] = clip_y0;

+

+      /* lower-right */

+      verts[2][0][0] = clip_x1;

+      verts[2][0][1] = clip_y1;

+

+      /* lower-left */

+      verts[3][0][0] = clip_x0;

+      verts[3][0][1] = clip_y1;

+

+      verts[0][1][0] = sLeft; /* v[0].attr[1].S */

+      verts[0][1][1] = tTop;  /* v[0].attr[1].T */

+      verts[1][1][0] = sRight;

+      verts[1][1][1] = tTop;

+      verts[2][1][0] = sRight;

+      verts[2][1][1] = tBot;

+      verts[3][1][0] = sLeft;

+      verts[3][1][1] = tBot;

+

+      /* same for all verts: */

+      if (color) {

+         for (i = 0; i < 4; i++) {

+            verts[i][0][2] = z;         /* v[i].attr[0].z */

+            verts[i][0][3] = 1.0f;      /* v[i].attr[0].w */

+            verts[i][2][0] = color[0];  /* v[i].attr[2].r */

+            verts[i][2][1] = color[1];  /* v[i].attr[2].g */

+            verts[i][2][2] = color[2];  /* v[i].attr[2].b */

+            verts[i][2][3] = color[3];  /* v[i].attr[2].a */

+            verts[i][1][2] = 0.0f;      /* v[i].attr[1].R */

+            verts[i][1][3] = 1.0f;      /* v[i].attr[1].Q */

+         }

+      }

+      else {

+         for (i = 0; i < 4; i++) {

+            verts[i][0][2] = z;    /*Z*/

+            verts[i][0][3] = 1.0f; /*W*/

+            verts[i][1][2] = 0.0f; /*R*/

+            verts[i][1][3] = 1.0f; /*Q*/

+         }

+      }

+   }

+

+   {

+      struct pipe_resource *buf;

+

+      /* allocate/load buffer object with vertex data */

+      buf = pipe_buffer_create(pipe->screen,

+			       PIPE_BIND_VERTEX_BUFFER,

+			       PIPE_USAGE_STATIC,

+                               sizeof(verts));

+      pipe_buffer_write(st->pipe, buf, 0, sizeof(verts), verts);

+

+      util_draw_vertex_buffer(pipe, st->cso_context, buf, 0,

+                              PIPE_PRIM_QUADS,

+                              4,  /* verts */

+                              3); /* attribs/vert */

+      pipe_resource_reference(&buf, NULL);

+   }

+}

+

+

+

+static void

+draw_textured_quad(struct gl_context *ctx, GLint x, GLint y, GLfloat z,

+                   GLsizei width, GLsizei height,

+                   GLfloat zoomX, GLfloat zoomY,

+                   struct pipe_sampler_view **sv,

+                   int num_sampler_view,

+                   void *driver_vp,

+                   void *driver_fp,

+                   const GLfloat *color,

+                   GLboolean invertTex,

+                   GLboolean write_depth, GLboolean write_stencil)

+{

+   struct st_context *st = st_context(ctx);

+   struct pipe_context *pipe = st->pipe;

+   struct cso_context *cso = st->cso_context;

+   GLfloat x0, y0, x1, y1;

+   GLsizei maxSize;

+   boolean normalized = sv[0]->texture->target != PIPE_TEXTURE_RECT;

+

+   /* limit checks */

+   /* XXX if DrawPixels image is larger than max texture size, break

+    * it up into chunks.

+    */

+   maxSize = 1 << (pipe->screen->get_param(pipe->screen,

+                                        PIPE_CAP_MAX_TEXTURE_2D_LEVELS) - 1);

+   assert(width <= maxSize);

+   assert(height <= maxSize);

+

+   cso_save_rasterizer(cso);

+   cso_save_viewport(cso);

+   cso_save_samplers(cso);

+   cso_save_fragment_sampler_views(cso);

+   cso_save_fragment_shader(cso);

+   cso_save_vertex_shader(cso);

+   cso_save_vertex_elements(cso);

+   cso_save_vertex_buffers(cso);

+   if (write_stencil) {

+      cso_save_depth_stencil_alpha(cso);

+      cso_save_blend(cso);

+   }

+

+   /* rasterizer state: just scissor */

+   {

+      struct pipe_rasterizer_state rasterizer;

+      memset(&rasterizer, 0, sizeof(rasterizer));

+      rasterizer.gl_rasterization_rules = 1;

+      rasterizer.scissor = ctx->Scissor.Enabled;

+      cso_set_rasterizer(cso, &rasterizer);

+   }

+

+   if (write_stencil) {

+      /* Stencil writing bypasses the normal fragment pipeline to

+       * disable color writing and set stencil test to always pass.

+       */

+      struct pipe_depth_stencil_alpha_state dsa;

+      struct pipe_blend_state blend;

+

+      /* depth/stencil */

+      memset(&dsa, 0, sizeof(dsa));

+      dsa.stencil[0].enabled = 1;

+      dsa.stencil[0].func = PIPE_FUNC_ALWAYS;

+      dsa.stencil[0].writemask = ctx->Stencil.WriteMask[0] & 0xff;

+      dsa.stencil[0].zpass_op = PIPE_STENCIL_OP_REPLACE;

+      if (write_depth) {

+         /* writing depth+stencil: depth test always passes */

+         dsa.depth.enabled = 1;

+         dsa.depth.writemask = ctx->Depth.Mask;

+         dsa.depth.func = PIPE_FUNC_ALWAYS;

+      }

+      cso_set_depth_stencil_alpha(cso, &dsa);

+

+      /* blend (colormask) */

+      memset(&blend, 0, sizeof(blend));

+      cso_set_blend(cso, &blend);

+   }

+

+   /* fragment shader state: TEX lookup program */

+   cso_set_fragment_shader_handle(cso, driver_fp);

+

+   /* vertex shader state: position + texcoord pass-through */

+   cso_set_vertex_shader_handle(cso, driver_vp);

+

+

+   /* texture sampling state: */

+   {

+      struct pipe_sampler_state sampler;

+      memset(&sampler, 0, sizeof(sampler));

+      sampler.wrap_s = PIPE_TEX_WRAP_CLAMP;

+      sampler.wrap_t = PIPE_TEX_WRAP_CLAMP;

+      sampler.wrap_r = PIPE_TEX_WRAP_CLAMP;

+      sampler.min_img_filter = PIPE_TEX_FILTER_NEAREST;

+      sampler.min_mip_filter = PIPE_TEX_MIPFILTER_NONE;

+      sampler.mag_img_filter = PIPE_TEX_FILTER_NEAREST;

+      sampler.normalized_coords = normalized;

+

+      cso_single_sampler(cso, 0, &sampler);

+      if (num_sampler_view > 1) {

+         cso_single_sampler(cso, 1, &sampler);

+      }

+      cso_single_sampler_done(cso);

+   }

+

+   /* viewport state: viewport matching window dims */

+   {

+      const float w = (float) ctx->DrawBuffer->Width;

+      const float h = (float) ctx->DrawBuffer->Height;

+      struct pipe_viewport_state vp;

+      vp.scale[0] =  0.5f * w;

+      vp.scale[1] = -0.5f * h;

+      vp.scale[2] = 0.5f;

+      vp.scale[3] = 1.0f;

+      vp.translate[0] = 0.5f * w;

+      vp.translate[1] = 0.5f * h;

+      vp.translate[2] = 0.5f;

+      vp.translate[3] = 0.0f;

+      cso_set_viewport(cso, &vp);

+   }

+

+   cso_set_vertex_elements(cso, 3, st->velems_util_draw);

+

+   /* texture state: */

+   cso_set_fragment_sampler_views(cso, num_sampler_view, sv);

+

+   /* Compute Gallium window coords (y=0=top) with pixel zoom.

+    * Recall that these coords are transformed by the current

+    * vertex shader and viewport transformation.

+    */

+   if (st_fb_orientation(ctx->DrawBuffer) == Y_0_BOTTOM) {

+      y = ctx->DrawBuffer->Height - (int) (y + height * ctx->Pixel.ZoomY);

+      invertTex = !invertTex;

+   }

+

+   x0 = (GLfloat) x;

+   x1 = x + width * ctx->Pixel.ZoomX;

+   y0 = (GLfloat) y;

+   y1 = y + height * ctx->Pixel.ZoomY;

+

+   /* convert Z from [0,1] to [-1,-1] to match viewport Z scale/bias */

+   z = z * 2.0 - 1.0;

+

+   draw_quad(ctx, x0, y0, z, x1, y1, color, invertTex,

+             normalized ? ((GLfloat) width / sv[0]->texture->width0) : (GLfloat)width,

+             normalized ? ((GLfloat) height / sv[0]->texture->height0) : (GLfloat)height);

+

+   /* restore state */

+   cso_restore_rasterizer(cso);

+   cso_restore_viewport(cso);

+   cso_restore_samplers(cso);

+   cso_restore_fragment_sampler_views(cso);

+   cso_restore_fragment_shader(cso);

+   cso_restore_vertex_shader(cso);

+   cso_restore_vertex_elements(cso);

+   cso_restore_vertex_buffers(cso);

+   if (write_stencil) {

+      cso_restore_depth_stencil_alpha(cso);

+      cso_restore_blend(cso);

+   }

+}

+

+

+/**

+ * Software fallback to do glDrawPixels(GL_STENCIL_INDEX) when we

+ * can't use a fragment shader to write stencil values.

+ */

+static void

+draw_stencil_pixels(struct gl_context *ctx, GLint x, GLint y,

+                    GLsizei width, GLsizei height, GLenum format, GLenum type,

+                    const struct gl_pixelstore_attrib *unpack,

+                    const GLvoid *pixels)

+{

+   struct st_context *st = st_context(ctx);

+   struct pipe_context *pipe = st->pipe;

+   struct st_renderbuffer *strb;

+   enum pipe_transfer_usage usage;

+   struct pipe_transfer *pt;

+   const GLboolean zoom = ctx->Pixel.ZoomX != 1.0 || ctx->Pixel.ZoomY != 1.0;

+   GLint skipPixels;

+   ubyte *stmap;

+   struct gl_pixelstore_attrib clippedUnpack = *unpack;

+

+   if (!zoom) {

+      if (!_mesa_clip_drawpixels(ctx, &x, &y, &width, &height,

+                                 &clippedUnpack)) {

+         /* totally clipped */

+         return;

+      }

+   }

+

+   strb = st_renderbuffer(ctx->DrawBuffer->

+                          Attachment[BUFFER_STENCIL].Renderbuffer);

+

+   if (st_fb_orientation(ctx->DrawBuffer) == Y_0_TOP) {

+      y = ctx->DrawBuffer->Height - y - height;

+   }

+

+   if(format != GL_DEPTH_STENCIL && 

+      util_format_get_component_bits(strb->format,

+                                     UTIL_FORMAT_COLORSPACE_ZS, 0) != 0)

+      usage = PIPE_TRANSFER_READ_WRITE;

+   else

+      usage = PIPE_TRANSFER_WRITE;

+

+   pt = pipe_get_transfer(st_context(ctx)->pipe, strb->texture, 0, 0,

+                                     usage, x, y,

+                                     width, height);

+

+   stmap = pipe_transfer_map(pipe, pt);

+

+   pixels = _mesa_map_pbo_source(ctx, &clippedUnpack, pixels);

+   assert(pixels);

+

+   /* if width > MAX_WIDTH, have to process image in chunks */

+   skipPixels = 0;

+   while (skipPixels < width) {

+      const GLint spanX = skipPixels;

+      const GLint spanWidth = MIN2(width - skipPixels, MAX_WIDTH);

+      GLint row;

+      for (row = 0; row < height; row++) {

+         GLubyte sValues[MAX_WIDTH];

+         GLuint zValues[MAX_WIDTH];

+         GLenum destType = GL_UNSIGNED_BYTE;

+         const GLvoid *source = _mesa_image_address2d(&clippedUnpack, pixels,

+                                                      width, height,

+                                                      format, type,

+                                                      row, skipPixels);

+         _mesa_unpack_stencil_span(ctx, spanWidth, destType, sValues,

+                                   type, source, &clippedUnpack,

+                                   ctx->_ImageTransferState);

+

+         if (format == GL_DEPTH_STENCIL) {

+            _mesa_unpack_depth_span(ctx, spanWidth, GL_UNSIGNED_INT, zValues,

+                                    (1 << 24) - 1, type, source,

+                                    &clippedUnpack);

+         }

+

+         if (zoom) {

+            _mesa_problem(ctx, "Gallium glDrawPixels(GL_STENCIL) with "

+                          "zoom not complete");

+         }

+

+         {

+            GLint spanY;

+

+            if (st_fb_orientation(ctx->DrawBuffer) == Y_0_TOP) {

+               spanY = height - row - 1;

+            }

+            else {

+               spanY = row;

+            }

+

+            /* now pack the stencil (and Z) values in the dest format */

+            switch (pt->resource->format) {

+            case PIPE_FORMAT_S8_USCALED:

+               {

+                  ubyte *dest = stmap + spanY * pt->stride + spanX;

+                  assert(usage == PIPE_TRANSFER_WRITE);

+                  memcpy(dest, sValues, spanWidth);

+               }

+               break;

+            case PIPE_FORMAT_Z24_UNORM_S8_USCALED:

+               if (format == GL_DEPTH_STENCIL) {

+                  uint *dest = (uint *) (stmap + spanY * pt->stride + spanX*4);

+                  GLint k;

+                  assert(usage == PIPE_TRANSFER_WRITE);

+                  for (k = 0; k < spanWidth; k++) {

+                     dest[k] = zValues[k] | (sValues[k] << 24);

+                  }

+               }

+               else {

+                  uint *dest = (uint *) (stmap + spanY * pt->stride + spanX*4);

+                  GLint k;

+                  assert(usage == PIPE_TRANSFER_READ_WRITE);

+                  for (k = 0; k < spanWidth; k++) {

+                     dest[k] = (dest[k] & 0xffffff) | (sValues[k] << 24);

+                  }

+               }

+               break;

+            case PIPE_FORMAT_S8_USCALED_Z24_UNORM:

+               if (format == GL_DEPTH_STENCIL) {

+                  uint *dest = (uint *) (stmap + spanY * pt->stride + spanX*4);

+                  GLint k;

+                  assert(usage == PIPE_TRANSFER_WRITE);

+                  for (k = 0; k < spanWidth; k++) {

+                     dest[k] = (zValues[k] << 8) | (sValues[k] & 0xff);

+                  }

+               }

+               else {

+                  uint *dest = (uint *) (stmap + spanY * pt->stride + spanX*4);

+                  GLint k;

+                  assert(usage == PIPE_TRANSFER_READ_WRITE);

+                  for (k = 0; k < spanWidth; k++) {

+                     dest[k] = (dest[k] & 0xffffff00) | (sValues[k] & 0xff);

+                  }

+               }

+               break;

+            default:

+               assert(0);

+            }

+         }

+      }

+      skipPixels += spanWidth;

+   }

+

+   _mesa_unmap_pbo_source(ctx, &clippedUnpack);

+

+   /* unmap the stencil buffer */

+   pipe_transfer_unmap(pipe, pt);

+   pipe->transfer_destroy(pipe, pt);

+}

+

+

+/**

+ * Get fragment program variant for a glDrawPixels or glCopyPixels

+ * command for RGBA data.

+ */

+static struct st_fp_variant *

+get_color_fp_variant(struct st_context *st)

+{

+   struct gl_context *ctx = st->ctx;

+   struct st_fp_variant_key key;

+   struct st_fp_variant *fpv;

+

+   memset(&key, 0, sizeof(key));

+

+   key.st = st;

+   key.drawpixels = 1;

+   key.scaleAndBias = (ctx->Pixel.RedBias != 0.0 ||

+                       ctx->Pixel.RedScale != 1.0 ||

+                       ctx->Pixel.GreenBias != 0.0 ||

+                       ctx->Pixel.GreenScale != 1.0 ||

+                       ctx->Pixel.BlueBias != 0.0 ||

+                       ctx->Pixel.BlueScale != 1.0 ||

+                       ctx->Pixel.AlphaBias != 0.0 ||

+                       ctx->Pixel.AlphaScale != 1.0);

+   key.pixelMaps = ctx->Pixel.MapColorFlag;

+

+   fpv = st_get_fp_variant(st, st->fp, &key);

+

+   return fpv;

+}

+

+

+/**

+ * Get fragment program variant for a glDrawPixels or glCopyPixels

+ * command for depth/stencil data.

+ */

+static struct st_fp_variant *

+get_depth_stencil_fp_variant(struct st_context *st, GLboolean write_depth,

+                             GLboolean write_stencil)

+{

+   struct st_fp_variant_key key;

+   struct st_fp_variant *fpv;

+

+   memset(&key, 0, sizeof(key));

+

+   key.st = st;

+   key.drawpixels = 1;

+   key.drawpixels_z = write_depth;

+   key.drawpixels_stencil = write_stencil;

+

+   fpv = st_get_fp_variant(st, st->fp, &key);

+

+   return fpv;

+}

+

+

+/**

+ * Called via ctx->Driver.DrawPixels()

+ */

+static void

+st_DrawPixels(struct gl_context *ctx, GLint x, GLint y,

+              GLsizei width, GLsizei height,

+              GLenum format, GLenum type,

+              const struct gl_pixelstore_attrib *unpack, const GLvoid *pixels)

+{

+   void *driver_vp, *driver_fp;

+   struct st_context *st = st_context(ctx);

+   const GLfloat *color;

+   struct pipe_context *pipe = st->pipe;

+   GLboolean write_stencil = GL_FALSE, write_depth = GL_FALSE;

+   struct pipe_sampler_view *sv[2];

+   int num_sampler_view = 1;

+   enum pipe_format stencil_format = PIPE_FORMAT_NONE;

+   struct st_fp_variant *fpv;

+

+   if (format == GL_DEPTH_STENCIL)

+      write_stencil = write_depth = GL_TRUE;

+   else if (format == GL_STENCIL_INDEX)

+      write_stencil = GL_TRUE;

+   else if (format == GL_DEPTH_COMPONENT)

+      write_depth = GL_TRUE;

+

+   if (write_stencil) {

+      enum pipe_format tex_format;

+      /* can we write to stencil if not fallback */

+      if (!pipe->screen->get_param(pipe->screen, PIPE_CAP_SHADER_STENCIL_EXPORT))

+	 goto stencil_fallback;

+      

+      tex_format = st_choose_format(st->pipe->screen, base_format(format),

+                                    PIPE_TEXTURE_2D,

+				    0, PIPE_BIND_SAMPLER_VIEW);

+      if (tex_format == PIPE_FORMAT_Z24_UNORM_S8_USCALED)

+	 stencil_format = PIPE_FORMAT_X24S8_USCALED;

+      else if (tex_format == PIPE_FORMAT_S8_USCALED_Z24_UNORM)

+	 stencil_format = PIPE_FORMAT_S8X24_USCALED;

+      else

+	 stencil_format = PIPE_FORMAT_S8_USCALED;

+      if (stencil_format == PIPE_FORMAT_NONE)

+	 goto stencil_fallback;

+   }

+

+   /* Mesa state should be up to date by now */

+   assert(ctx->NewState == 0x0);

+

+   st_validate_state(st);

+

+   /*

+    * Get vertex/fragment shaders

+    */

+   if (write_depth || write_stencil) {

+      fpv = get_depth_stencil_fp_variant(st, write_depth, write_stencil);

+

+      driver_fp = fpv->driver_shader;

+

+      driver_vp = make_passthrough_vertex_shader(st, GL_TRUE);

+

+      color = ctx->Current.RasterColor;

+   }

+   else {

+      fpv = get_color_fp_variant(st);

+

+      driver_fp = fpv->driver_shader;

+

+      driver_vp = make_passthrough_vertex_shader(st, GL_FALSE);

+

+      color = NULL;

+      if (st->pixel_xfer.pixelmap_enabled) {

+	  sv[1] = st->pixel_xfer.pixelmap_sampler_view;

+	  num_sampler_view++;

+      }

+   }

+

+   /* update fragment program constants */

+   st_upload_constants(st, fpv->parameters, PIPE_SHADER_FRAGMENT);

+

+   /* draw with textured quad */

+   {

+      struct pipe_resource *pt

+         = make_texture(st, width, height, format, type, unpack, pixels);

+      if (pt) {

+         sv[0] = st_create_texture_sampler_view(st->pipe, pt);

+

+         if (sv[0]) {

+	    if (write_stencil) {

+	       sv[1] = st_create_texture_sampler_view_format(st->pipe, pt,

+                                                             stencil_format);

+	       num_sampler_view++;

+	    }

+

+            draw_textured_quad(ctx, x, y, ctx->Current.RasterPos[2],

+                               width, height,

+                               ctx->Pixel.ZoomX, ctx->Pixel.ZoomY,

+                               sv,

+                               num_sampler_view,

+                               driver_vp,

+                               driver_fp,

+                               color, GL_FALSE, write_depth, write_stencil);

+            pipe_sampler_view_reference(&sv[0], NULL);

+            if (num_sampler_view > 1)

+               pipe_sampler_view_reference(&sv[1], NULL);

+         }

+         pipe_resource_reference(&pt, NULL);

+      }

+   }

+   return;

+

+stencil_fallback:

+   draw_stencil_pixels(ctx, x, y, width, height, format, type,

+		       unpack, pixels);

+}

+

+

+

+/**

+ * Software fallback for glCopyPixels(GL_STENCIL).

+ */

+static void

+copy_stencil_pixels(struct gl_context *ctx, GLint srcx, GLint srcy,

+                    GLsizei width, GLsizei height,

+                    GLint dstx, GLint dsty)

+{

+   struct st_renderbuffer *rbDraw;

+   struct pipe_context *pipe = st_context(ctx)->pipe;

+   enum pipe_transfer_usage usage;

+   struct pipe_transfer *ptDraw;

+   ubyte *drawMap;

+   ubyte *buffer;

+   int i;

+

+   buffer = malloc(width * height * sizeof(ubyte));

+   if (!buffer) {

+      _mesa_error(ctx, GL_OUT_OF_MEMORY, "glCopyPixels(stencil)");

+      return;

+   }

+

+   /* Get the dest renderbuffer.  If there's a wrapper, use the

+    * underlying renderbuffer.

+    */

+   rbDraw = st_renderbuffer(ctx->DrawBuffer->_StencilBuffer);

+   if (rbDraw->Base.Wrapped)

+      rbDraw = st_renderbuffer(rbDraw->Base.Wrapped);

+

+   /* this will do stencil pixel transfer ops */

+   st_read_stencil_pixels(ctx, srcx, srcy, width, height,

+                          GL_STENCIL_INDEX, GL_UNSIGNED_BYTE,

+                          &ctx->DefaultPacking, buffer);

+

+   if (0) {

+      /* debug code: dump stencil values */

+      GLint row, col;

+      for (row = 0; row < height; row++) {

+         printf("%3d: ", row);

+         for (col = 0; col < width; col++) {

+            printf("%02x ", buffer[col + row * width]);

+         }

+         printf("\n");

+      }

+   }

+

+   if (util_format_get_component_bits(rbDraw->format,

+                                     UTIL_FORMAT_COLORSPACE_ZS, 0) != 0)

+      usage = PIPE_TRANSFER_READ_WRITE;

+   else

+      usage = PIPE_TRANSFER_WRITE;

+

+   if (st_fb_orientation(ctx->DrawBuffer) == Y_0_TOP) {

+      dsty = rbDraw->Base.Height - dsty - height;

+   }

+

+   ptDraw = pipe_get_transfer(st_context(ctx)->pipe,

+                              rbDraw->texture, 0, 0,

+                              usage, dstx, dsty,

+                              width, height);

+

+   assert(util_format_get_blockwidth(ptDraw->resource->format) == 1);

+   assert(util_format_get_blockheight(ptDraw->resource->format) == 1);

+

+   /* map the stencil buffer */

+   drawMap = pipe_transfer_map(pipe, ptDraw);

+

+   /* draw */

+   /* XXX PixelZoom not handled yet */

+   for (i = 0; i < height; i++) {

+      ubyte *dst;

+      const ubyte *src;

+      int y;

+

+      y = i;

+

+      if (st_fb_orientation(ctx->DrawBuffer) == Y_0_TOP) {

+         y = height - y - 1;

+      }

+

+      dst = drawMap + y * ptDraw->stride;

+      src = buffer + i * width;

+

+      switch (ptDraw->resource->format) {

+      case PIPE_FORMAT_Z24_UNORM_S8_USCALED:

+         {

+            uint *dst4 = (uint *) dst;

+            int j;

+            assert(usage == PIPE_TRANSFER_READ_WRITE);

+            for (j = 0; j < width; j++) {

+               *dst4 = (*dst4 & 0xffffff) | (src[j] << 24);

+               dst4++;

+            }

+         }

+         break;

+      case PIPE_FORMAT_S8_USCALED_Z24_UNORM:

+         {

+            uint *dst4 = (uint *) dst;

+            int j;

+            assert(usage == PIPE_TRANSFER_READ_WRITE);

+            for (j = 0; j < width; j++) {

+               *dst4 = (*dst4 & 0xffffff00) | (src[j] & 0xff);

+               dst4++;

+            }

+         }

+         break;

+      case PIPE_FORMAT_S8_USCALED:

+         assert(usage == PIPE_TRANSFER_WRITE);

+         memcpy(dst, src, width);

+         break;

+      default:

+         assert(0);

+      }

+   }

+

+   free(buffer);

+

+   /* unmap the stencil buffer */

+   pipe_transfer_unmap(pipe, ptDraw);

+   pipe->transfer_destroy(pipe, ptDraw);

+}

+

+

+/** Do the src/dest regions overlap? */

+static GLboolean

+regions_overlap(GLint srcX, GLint srcY, GLint dstX, GLint dstY,

+                GLsizei width, GLsizei height)

+{

+   if (srcX + width <= dstX ||

+       dstX + width <= srcX ||

+       srcY + height <= dstY ||

+       dstY + height <= srcY)

+      return GL_FALSE;

+   else

+      return GL_TRUE;

+}

+

+

+/**

+ * Try to do a glCopyPixels for simple cases with a blit by calling

+ * pipe->resource_copy_region().

+ *

+ * We can do this when we're copying color pixels (depth/stencil

+ * eventually) with no pixel zoom, no pixel transfer ops, no

+ * per-fragment ops, the src/dest regions don't overlap and the

+ * src/dest pixel formats are the same.

+ */

+static GLboolean

+blit_copy_pixels(struct gl_context *ctx, GLint srcx, GLint srcy,

+                 GLsizei width, GLsizei height,

+                 GLint dstx, GLint dsty, GLenum type)

+{

+   struct st_context *st = st_context(ctx);

+   struct pipe_context *pipe = st->pipe;

+   struct gl_pixelstore_attrib pack, unpack;

+   GLint readX, readY, readW, readH;

+

+   if (type == GL_COLOR &&

+       ctx->Pixel.ZoomX == 1.0 &&

+       ctx->Pixel.ZoomY == 1.0 &&

+       ctx->_ImageTransferState == 0x0 &&

+       !ctx->Color.BlendEnabled &&

+       !ctx->Color.AlphaEnabled &&

+       !ctx->Depth.Test &&

+       !ctx->Fog.Enabled &&

+       !ctx->Stencil.Enabled &&

+       !ctx->FragmentProgram.Enabled &&

+       !ctx->VertexProgram.Enabled &&

+       !ctx->Shader.CurrentFragmentProgram &&

+       st_fb_orientation(ctx->ReadBuffer) == st_fb_orientation(ctx->DrawBuffer) &&

+       ctx->DrawBuffer->_NumColorDrawBuffers == 1) {

+      struct st_renderbuffer *rbRead, *rbDraw;

+      GLint drawX, drawY;

+

+      /*

+       * Clip the read region against the src buffer bounds.

+       * We'll still allocate a temporary buffer/texture for the original

+       * src region size but we'll only read the region which is on-screen.

+       * This may mean that we draw garbage pixels into the dest region, but

+       * that's expected.

+       */

+      readX = srcx;

+      readY = srcy;

+      readW = width;

+      readH = height;

+      pack = ctx->DefaultPacking;

+      if (!_mesa_clip_readpixels(ctx, &readX, &readY, &readW, &readH, &pack))

+         return GL_TRUE; /* all done */

+

+      /* clip against dest buffer bounds and scissor box */

+      drawX = dstx + pack.SkipPixels;

+      drawY = dsty + pack.SkipRows;

+      unpack = pack;

+      if (!_mesa_clip_drawpixels(ctx, &drawX, &drawY, &readW, &readH, &unpack))

+         return GL_TRUE; /* all done */

+

+      readX = readX - pack.SkipPixels + unpack.SkipPixels;

+      readY = readY - pack.SkipRows + unpack.SkipRows;

+

+      rbRead = st_get_color_read_renderbuffer(ctx);

+      rbDraw = st_renderbuffer(ctx->DrawBuffer->_ColorDrawBuffers[0]);

+

+      if ((rbRead != rbDraw ||

+           !regions_overlap(readX, readY, drawX, drawY, readW, readH)) &&

+          rbRead->Base.Format == rbDraw->Base.Format) {

+         struct pipe_box srcBox;

+

+         /* flip src/dst position if needed */

+         if (st_fb_orientation(ctx->ReadBuffer) == Y_0_TOP) {

+            /* both buffers will have the same orientation */

+            readY = ctx->ReadBuffer->Height - readY - readH;

+            drawY = ctx->DrawBuffer->Height - drawY - readH;

+         }

+

+         u_box_2d(readX, readY, readW, readH, &srcBox);

+

+         pipe->resource_copy_region(pipe,

+                                    rbDraw->texture, 0, drawX, drawY, 0,

+                                    rbRead->texture, 0, &srcBox);

+         return GL_TRUE;

+      }

+   }

+

+   return GL_FALSE;

+}

+

+

+static void

+st_CopyPixels(struct gl_context *ctx, GLint srcx, GLint srcy,

+              GLsizei width, GLsizei height,

+              GLint dstx, GLint dsty, GLenum type)

+{

+   struct st_context *st = st_context(ctx);

+   struct pipe_context *pipe = st->pipe;

+   struct pipe_screen *screen = pipe->screen;

+   struct st_renderbuffer *rbRead;

+   void *driver_vp, *driver_fp;

+   struct pipe_resource *pt;

+   struct pipe_sampler_view *sv[2];

+   int num_sampler_view = 1;

+   GLfloat *color;

+   enum pipe_format srcFormat, texFormat;

+   GLboolean invertTex = GL_FALSE;

+   GLint readX, readY, readW, readH;

+   GLuint sample_count;

+   struct gl_pixelstore_attrib pack = ctx->DefaultPacking;

+   struct st_fp_variant *fpv;

+

+   st_validate_state(st);

+

+   if (type == GL_STENCIL) {

+      /* can't use texturing to do stencil */

+      copy_stencil_pixels(ctx, srcx, srcy, width, height, dstx, dsty);

+      return;

+   }

+

+   if (blit_copy_pixels(ctx, srcx, srcy, width, height, dstx, dsty, type))

+      return;

+

+   /*

+    * The subsequent code implements glCopyPixels by copying the source

+    * pixels into a temporary texture that's then applied to a textured quad.

+    * When we draw the textured quad, all the usual per-fragment operations

+    * are handled.

+    */

+

+

+   /*

+    * Get vertex/fragment shaders

+    */

+   if (type == GL_COLOR) {

+      rbRead = st_get_color_read_renderbuffer(ctx);

+      color = NULL;

+

+      fpv = get_color_fp_variant(st);

+      driver_fp = fpv->driver_shader;

+

+      driver_vp = make_passthrough_vertex_shader(st, GL_FALSE);

+

+      if (st->pixel_xfer.pixelmap_enabled) {

+	  sv[1] = st->pixel_xfer.pixelmap_sampler_view;

+	  num_sampler_view++;

+      }

+   }

+   else {

+      assert(type == GL_DEPTH);

+      rbRead = st_renderbuffer(ctx->ReadBuffer->_DepthBuffer);

+      color = ctx->Current.Attrib[VERT_ATTRIB_COLOR0];

+

+      fpv = get_depth_stencil_fp_variant(st, GL_TRUE, GL_FALSE);

+      driver_fp = fpv->driver_shader;

+

+      driver_vp = make_passthrough_vertex_shader(st, GL_TRUE);

+   }

+

+   /* update fragment program constants */

+   st_upload_constants(st, fpv->parameters, PIPE_SHADER_FRAGMENT);

+

+

+   if (rbRead->Base.Wrapped)

+      rbRead = st_renderbuffer(rbRead->Base.Wrapped);

+

+   sample_count = rbRead->texture->nr_samples;

+   /* I believe this would be legal, presumably would need to do a resolve

+      for color, and for depth/stencil spec says to just use one of the

+      depth/stencil samples per pixel? Need some transfer clarifications. */

+   assert(sample_count < 2);

+

+   srcFormat = rbRead->texture->format;

+

+   if (screen->is_format_supported(screen, srcFormat, st->internal_target,

+                                   sample_count,

+                                   PIPE_BIND_SAMPLER_VIEW)) {

+      texFormat = srcFormat;

+   }

+   else {

+      /* srcFormat can't be used as a texture format */

+      if (type == GL_DEPTH) {

+         texFormat = st_choose_format(screen, GL_DEPTH_COMPONENT,

+                                      st->internal_target, sample_count,

+                                      PIPE_BIND_DEPTH_STENCIL);

+         assert(texFormat != PIPE_FORMAT_NONE);

+      }

+      else {

+         /* default color format */

+         texFormat = st_choose_format(screen, GL_RGBA, st->internal_target,

+                                      sample_count, PIPE_BIND_SAMPLER_VIEW);

+         assert(texFormat != PIPE_FORMAT_NONE);

+      }

+   }

+

+   /* Invert src region if needed */

+   if (st_fb_orientation(ctx->ReadBuffer) == Y_0_TOP) {

+      srcy = ctx->ReadBuffer->Height - srcy - height;

+      invertTex = !invertTex;

+   }

+

+   /* Clip the read region against the src buffer bounds.

+    * We'll still allocate a temporary buffer/texture for the original

+    * src region size but we'll only read the region which is on-screen.

+    * This may mean that we draw garbage pixels into the dest region, but

+    * that's expected.

+    */

+   readX = srcx;

+   readY = srcy;

+   readW = width;

+   readH = height;

+   _mesa_clip_readpixels(ctx, &readX, &readY, &readW, &readH, &pack);

+   readW = MAX2(0, readW);

+   readH = MAX2(0, readH);

+

+   /* alloc temporary texture */

+   pt = alloc_texture(st, width, height, texFormat);

+   if (!pt)

+      return;

+

+   sv[0] = st_create_texture_sampler_view(st->pipe, pt);

+   if (!sv[0]) {

+      pipe_resource_reference(&pt, NULL);

+      return;

+   }

+

+   /* Make temporary texture which is a copy of the src region.

+    */

+   if (srcFormat == texFormat) {

+      struct pipe_box src_box;

+      u_box_2d(readX, readY, readW, readH, &src_box);

+      /* copy source framebuffer surface into mipmap/texture */

+      pipe->resource_copy_region(pipe,

+                                 pt,                                /* dest tex */

+                                 0,

+                                 pack.SkipPixels, pack.SkipRows, 0, /* dest pos */

+                                 rbRead->texture,                   /* src tex */

+                                 0,

+                                 &src_box);

+

+   }

+   else {

+      /* CPU-based fallback/conversion */

+      struct pipe_transfer *ptRead =

+         pipe_get_transfer(st->pipe, rbRead->texture,

+                           0, 0, /* level, layer */

+                           PIPE_TRANSFER_READ,

+                           readX, readY, readW, readH);

+      struct pipe_transfer *ptTex;

+      enum pipe_transfer_usage transfer_usage;

+

+      if (ST_DEBUG & DEBUG_FALLBACK)

+         debug_printf("%s: fallback processing\n", __FUNCTION__);

+

+      if (type == GL_DEPTH && util_format_is_depth_and_stencil(pt->format))

+         transfer_usage = PIPE_TRANSFER_READ_WRITE;

+      else

+         transfer_usage = PIPE_TRANSFER_WRITE;

+

+      ptTex = pipe_get_transfer(st->pipe, pt, 0, 0, transfer_usage,

+                                0, 0, width, height);

+

+      /* copy image from ptRead surface to ptTex surface */

+      if (type == GL_COLOR) {

+         /* alternate path using get/put_tile() */

+         GLfloat *buf = (GLfloat *) malloc(width * height * 4 * sizeof(GLfloat));

+         enum pipe_format readFormat, drawFormat;

+         readFormat = util_format_linear(rbRead->texture->format);

+         drawFormat = util_format_linear(pt->format);

+         pipe_get_tile_rgba_format(pipe, ptRead, 0, 0, readW, readH,

+                                   readFormat, buf);

+         pipe_put_tile_rgba_format(pipe, ptTex, pack.SkipPixels, pack.SkipRows,

+                                   readW, readH, drawFormat, buf);

+         free(buf);

+      }

+      else {

+         /* GL_DEPTH */

+         GLuint *buf = (GLuint *) malloc(width * height * sizeof(GLuint));

+         pipe_get_tile_z(pipe, ptRead, 0, 0, readW, readH, buf);

+         pipe_put_tile_z(pipe, ptTex, pack.SkipPixels, pack.SkipRows,

+                         readW, readH, buf);

+         free(buf);

+      }

+

+      pipe->transfer_destroy(pipe, ptRead);

+      pipe->transfer_destroy(pipe, ptTex);

+   }

+

+   /* OK, the texture 'pt' contains the src image/pixels.  Now draw a

+    * textured quad with that texture.

+    */

+   draw_textured_quad(ctx, dstx, dsty, ctx->Current.RasterPos[2],

+                      width, height, ctx->Pixel.ZoomX, ctx->Pixel.ZoomY,

+                      sv,

+                      num_sampler_view,

+                      driver_vp, 

+                      driver_fp,

+                      color, invertTex, GL_FALSE, GL_FALSE);

+

+   pipe_resource_reference(&pt, NULL);

+   pipe_sampler_view_reference(&sv[0], NULL);

+}

+

+

+

+void st_init_drawpixels_functions(struct dd_function_table *functions)

+{

+   functions->DrawPixels = st_DrawPixels;

+   functions->CopyPixels = st_CopyPixels;

+}

+

+

+void

+st_destroy_drawpix(struct st_context *st)

+{

+   GLuint i;

+

+   for (i = 0; i < Elements(st->drawpix.shaders); i++) {

+      if (st->drawpix.shaders[i])

+         _mesa_reference_fragprog(st->ctx, &st->drawpix.shaders[i], NULL);

+   }

+

+   st_reference_fragprog(st, &st->pixel_xfer.combined_prog, NULL);

+   if (st->drawpix.vert_shaders[0])

+      ureg_free_tokens(st->drawpix.vert_shaders[0]);

+   if (st->drawpix.vert_shaders[1])

+      ureg_free_tokens(st->drawpix.vert_shaders[1]);

+}

+

+#endif /* FEATURE_drawpix */

diff --git a/mesalib/src/mesa/state_tracker/st_cb_fbo.c b/mesalib/src/mesa/state_tracker/st_cb_fbo.c
index ae49434ca..fe67b03b2 100644
--- a/mesalib/src/mesa/state_tracker/st_cb_fbo.c
+++ b/mesalib/src/mesa/state_tracker/st_cb_fbo.c
@@ -1,645 +1,642 @@
-/**************************************************************************
- * 
- * Copyright 2007 Tungsten Graphics, Inc., Cedar Park, Texas.
- * 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, sub license, 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 (including the
- * next paragraph) 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 NON-INFRINGEMENT.
- * IN NO EVENT SHALL TUNGSTEN GRAPHICS AND/OR ITS SUPPLIERS 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.
- * 
- **************************************************************************/
-
-
-/**
- * Framebuffer/renderbuffer functions.
- *
- * \author Brian Paul
- */
-
-
-#include "main/imports.h"
-#include "main/context.h"
-#include "main/fbobject.h"
-#include "main/framebuffer.h"
-#include "main/macros.h"
-#include "main/mfeatures.h"
-#include "main/renderbuffer.h"
-
-#include "pipe/p_context.h"
-#include "pipe/p_defines.h"
-#include "pipe/p_screen.h"
-#include "st_context.h"
-#include "st_cb_fbo.h"
-#include "st_cb_flush.h"
-#include "st_format.h"
-#include "st_texture.h"
-#include "st_manager.h"
-
-#include "util/u_format.h"
-#include "util/u_inlines.h"
-#include "util/u_surface.h"
-
-
-/**
- * gl_renderbuffer::AllocStorage()
- * This is called to allocate the original drawing surface, and
- * during window resize.
- */
-static GLboolean
-st_renderbuffer_alloc_storage(struct gl_context * ctx,
-                              struct gl_renderbuffer *rb,
-                              GLenum internalFormat,
-                              GLuint width, GLuint height)
-{
-   struct st_context *st = st_context(ctx);
-   struct pipe_context *pipe = st->pipe;
-   struct pipe_screen *screen = st->pipe->screen;
-   struct st_renderbuffer *strb = st_renderbuffer(rb);
-   enum pipe_format format;
-   struct pipe_surface surf_tmpl;
-
-   if (strb->format != PIPE_FORMAT_NONE)
-      format = strb->format;
-   else
-      format = st_choose_renderbuffer_format(screen, internalFormat,
-                                             rb->NumSamples);
-
-   if (format == PIPE_FORMAT_NONE) {
-      return FALSE;
-   }
-
-   /* init renderbuffer fields */
-   strb->Base.Width  = width;
-   strb->Base.Height = height;
-   strb->Base.Format = st_pipe_format_to_mesa_format(format);
-   strb->Base._BaseFormat = _mesa_base_fbo_format(ctx, internalFormat);
-   strb->Base.DataType = st_format_datatype(format);
-
-   strb->defined = GL_FALSE;  /* undefined contents now */
-
-   if (strb->software) {
-      size_t size;
-      
-      free(strb->data);
-
-      assert(strb->format != PIPE_FORMAT_NONE);
-      
-      strb->stride = util_format_get_stride(strb->format, width);
-      size = util_format_get_2d_size(strb->format, strb->stride, height);
-      
-      strb->data = malloc(size);
-      
-      return strb->data != NULL;
-   }
-   else {
-      struct pipe_resource template;
-    
-      /* Free the old surface and texture
-       */
-      pipe_surface_reference( &strb->surface, NULL );
-      pipe_resource_reference( &strb->texture, NULL );
-      pipe_sampler_view_reference(&strb->sampler_view, NULL);
-
-      /* Setup new texture template.
-       */
-      memset(&template, 0, sizeof(template));
-      template.target = st->internal_target;
-      template.format = format;
-      template.width0 = width;
-      template.height0 = height;
-      template.depth0 = 1;
-      template.array_size = 1;
-      template.last_level = 0;
-      template.nr_samples = rb->NumSamples;
-      if (util_format_is_depth_or_stencil(format)) {
-         template.bind = PIPE_BIND_DEPTH_STENCIL;
-      }
-      else {
-         template.bind = (PIPE_BIND_DISPLAY_TARGET |
-                          PIPE_BIND_RENDER_TARGET);
-      }
-
-      strb->texture = screen->resource_create(screen, &template);
-
-      if (!strb->texture) 
-         return FALSE;
-
-      memset(&surf_tmpl, 0, sizeof(surf_tmpl));
-      u_surface_default_template(&surf_tmpl, strb->texture, template.bind);
-      strb->surface = pipe->create_surface(pipe,
-                                           strb->texture,
-                                           &surf_tmpl);
-      if (strb->surface) {
-         assert(strb->surface->texture);
-         assert(strb->surface->format);
-         assert(strb->surface->width == width);
-         assert(strb->surface->height == height);
-      }
-
-      return strb->surface != NULL;
-   }
-}
-
-
-/**
- * gl_renderbuffer::Delete()
- */
-static void
-st_renderbuffer_delete(struct gl_renderbuffer *rb)
-{
-   struct st_renderbuffer *strb = st_renderbuffer(rb);
-   ASSERT(strb);
-   pipe_surface_reference(&strb->surface, NULL);
-   pipe_resource_reference(&strb->texture, NULL);
-   pipe_sampler_view_reference(&strb->sampler_view, NULL);
-   free(strb->data);
-   free(strb);
-}
-
-
-/**
- * gl_renderbuffer::GetPointer()
- */
-static void *
-null_get_pointer(struct gl_context * ctx, struct gl_renderbuffer *rb,
-                 GLint x, GLint y)
-{
-   /* By returning NULL we force all software rendering to go through
-    * the span routines.
-    */
-#if 0
-   assert(0);  /* Should never get called with softpipe */
-#endif
-   return NULL;
-}
-
-
-/**
- * Called via ctx->Driver.NewFramebuffer()
- */
-static struct gl_framebuffer *
-st_new_framebuffer(struct gl_context *ctx, GLuint name)
-{
-   /* XXX not sure we need to subclass gl_framebuffer for pipe */
-   return _mesa_new_framebuffer(ctx, name);
-}
-
-
-/**
- * Called via ctx->Driver.NewRenderbuffer()
- */
-static struct gl_renderbuffer *
-st_new_renderbuffer(struct gl_context *ctx, GLuint name)
-{
-   struct st_renderbuffer *strb = ST_CALLOC_STRUCT(st_renderbuffer);
-   if (strb) {
-      _mesa_init_renderbuffer(&strb->Base, name);
-      strb->Base.Delete = st_renderbuffer_delete;
-      strb->Base.AllocStorage = st_renderbuffer_alloc_storage;
-      strb->Base.GetPointer = null_get_pointer;
-      strb->format = PIPE_FORMAT_NONE;
-      return &strb->Base;
-   }
-   return NULL;
-}
-
-
-/**
- * Allocate a renderbuffer for a an on-screen window (not a user-created
- * renderbuffer).  The window system code determines the format.
- */
-struct gl_renderbuffer *
-st_new_renderbuffer_fb(enum pipe_format format, int samples, boolean sw)
-{
-   struct st_renderbuffer *strb;
-
-   strb = ST_CALLOC_STRUCT(st_renderbuffer);
-   if (!strb) {
-      _mesa_error(NULL, GL_OUT_OF_MEMORY, "creating renderbuffer");
-      return NULL;
-   }
-
-   _mesa_init_renderbuffer(&strb->Base, 0);
-   strb->Base.ClassID = 0x4242; /* just a unique value */
-   strb->Base.NumSamples = samples;
-   strb->Base.Format = st_pipe_format_to_mesa_format(format);
-   strb->Base._BaseFormat = _mesa_get_format_base_format(strb->Base.Format);
-   strb->Base.DataType = st_format_datatype(format);
-   strb->format = format;
-   strb->software = sw;
-   
-   switch (format) {
-   case PIPE_FORMAT_R8G8B8A8_UNORM:
-   case PIPE_FORMAT_B8G8R8A8_UNORM:
-   case PIPE_FORMAT_A8R8G8B8_UNORM:
-   case PIPE_FORMAT_R8G8B8X8_UNORM:
-   case PIPE_FORMAT_B8G8R8X8_UNORM:
-   case PIPE_FORMAT_X8R8G8B8_UNORM:
-   case PIPE_FORMAT_B5G5R5A1_UNORM:
-   case PIPE_FORMAT_B4G4R4A4_UNORM:
-   case PIPE_FORMAT_B5G6R5_UNORM:
-      strb->Base.InternalFormat = GL_RGBA;
-      break;
-   case PIPE_FORMAT_Z16_UNORM:
-      strb->Base.InternalFormat = GL_DEPTH_COMPONENT16;
-      break;
-   case PIPE_FORMAT_Z32_UNORM:
-      strb->Base.InternalFormat = GL_DEPTH_COMPONENT32;
-      break;
-   case PIPE_FORMAT_Z24_UNORM_S8_USCALED:
-   case PIPE_FORMAT_S8_USCALED_Z24_UNORM:
-   case PIPE_FORMAT_Z24X8_UNORM:
-   case PIPE_FORMAT_X8Z24_UNORM:
-      strb->Base.InternalFormat = GL_DEPTH24_STENCIL8_EXT;
-      break;
-   case PIPE_FORMAT_S8_USCALED:
-      strb->Base.InternalFormat = GL_STENCIL_INDEX8_EXT;
-      break;
-   case PIPE_FORMAT_R16G16B16A16_SNORM:
-      strb->Base.InternalFormat = GL_RGBA16;
-      break;
-   case PIPE_FORMAT_R8_UNORM:
-      strb->Base.InternalFormat = GL_R8;
-      break;
-   case PIPE_FORMAT_R8G8_UNORM:
-      strb->Base.InternalFormat = GL_RG8;
-      break;
-   case PIPE_FORMAT_R16_UNORM:
-      strb->Base.InternalFormat = GL_R16;
-      break;
-   case PIPE_FORMAT_R16G16_UNORM:
-      strb->Base.InternalFormat = GL_RG16;
-      break;
-   default:
-      _mesa_problem(NULL,
-		    "Unexpected format in st_new_renderbuffer_fb");
-      free(strb);
-      return NULL;
-   }
-
-   /* st-specific methods */
-   strb->Base.Delete = st_renderbuffer_delete;
-   strb->Base.AllocStorage = st_renderbuffer_alloc_storage;
-   strb->Base.GetPointer = null_get_pointer;
-
-   /* surface is allocated in st_renderbuffer_alloc_storage() */
-   strb->surface = NULL;
-
-   return &strb->Base;
-}
-
-
-
-
-/**
- * Called via ctx->Driver.BindFramebufferEXT().
- */
-static void
-st_bind_framebuffer(struct gl_context *ctx, GLenum target,
-                    struct gl_framebuffer *fb, struct gl_framebuffer *fbread)
-{
-
-}
-
-/**
- * Called by ctx->Driver.FramebufferRenderbuffer
- */
-static void
-st_framebuffer_renderbuffer(struct gl_context *ctx, 
-                            struct gl_framebuffer *fb,
-                            GLenum attachment,
-                            struct gl_renderbuffer *rb)
-{
-   /* XXX no need for derivation? */
-   _mesa_framebuffer_renderbuffer(ctx, fb, attachment, rb);
-}
-
-
-/**
- * Called by ctx->Driver.RenderTexture
- */
-static void
-st_render_texture(struct gl_context *ctx,
-                  struct gl_framebuffer *fb,
-                  struct gl_renderbuffer_attachment *att)
-{
-   struct st_context *st = st_context(ctx);
-   struct pipe_context *pipe = st->pipe;
-   struct st_renderbuffer *strb;
-   struct gl_renderbuffer *rb;
-   struct pipe_resource *pt = st_get_texobj_resource(att->Texture);
-   struct st_texture_object *stObj;
-   const struct gl_texture_image *texImage;
-   struct pipe_surface surf_tmpl;
-
-   /* When would this fail?  Perhaps assert? */
-   if (!pt) 
-      return;
-
-   /* get pointer to texture image we're rendeing to */
-   texImage = att->Texture->Image[att->CubeMapFace][att->TextureLevel];
-
-   /* create new renderbuffer which wraps the texture image */
-   rb = st_new_renderbuffer(ctx, 0);
-   if (!rb) {
-      _mesa_error(ctx, GL_OUT_OF_MEMORY, "glFramebufferTexture()");
-      return;
-   }
-
-   _mesa_reference_renderbuffer(&att->Renderbuffer, rb);
-   assert(rb->RefCount == 1);
-   rb->AllocStorage = NULL; /* should not get called */
-   strb = st_renderbuffer(rb);
-
-   assert(strb->Base.RefCount > 0);
-
-   /* get the texture for the texture object */
-   stObj = st_texture_object(att->Texture);
-
-   /* point renderbuffer at texobject */
-   strb->rtt = stObj;
-   strb->rtt_level = att->TextureLevel;
-   strb->rtt_face = att->CubeMapFace;
-   strb->rtt_slice = att->Zoffset;
-
-   rb->Width = texImage->Width2;
-   rb->Height = texImage->Height2;
-   rb->_BaseFormat = texImage->_BaseFormat;
-   /*printf("***** render to texture level %d: %d x %d\n", att->TextureLevel, rb->Width, rb->Height);*/
-
-   /*printf("***** pipe texture %d x %d\n", pt->width0, pt->height0);*/
-
-   pipe_resource_reference( &strb->texture, pt );
-
-   pipe_surface_reference(&strb->surface, NULL);
-
-   pipe_sampler_view_reference(&strb->sampler_view,
-                               st_get_texture_sampler_view(stObj, pipe));
-
-   assert(strb->rtt_level <= strb->texture->last_level);
-
-   /* new surface for rendering into the texture */
-   memset(&surf_tmpl, 0, sizeof(surf_tmpl));
-   surf_tmpl.format = ctx->Color.sRGBEnabled ? strb->texture->format : util_format_linear(strb->texture->format);
-   surf_tmpl.usage = PIPE_BIND_RENDER_TARGET;
-   surf_tmpl.u.tex.level = strb->rtt_level;
-   surf_tmpl.u.tex.first_layer = strb->rtt_face + strb->rtt_slice;
-   surf_tmpl.u.tex.last_layer = strb->rtt_face + strb->rtt_slice;
-   strb->surface = pipe->create_surface(pipe,
-                                        strb->texture,
-                                        &surf_tmpl);
-
-   strb->format = pt->format;
-
-   strb->Base.Format = st_pipe_format_to_mesa_format(pt->format);
-   strb->Base.DataType = st_format_datatype(pt->format);
-
-   /*
-   printf("RENDER TO TEXTURE obj=%p pt=%p surf=%p  %d x %d\n",
-          att->Texture, pt, strb->surface, rb->Width, rb->Height);
-   */
-
-   /* Invalidate buffer state so that the pipe's framebuffer state
-    * gets updated.
-    * That's where the new renderbuffer (which we just created) gets
-    * passed to the pipe as a (color/depth) render target.
-    */
-   st_invalidate_state(ctx, _NEW_BUFFERS);
-}
-
-
-/**
- * Called via ctx->Driver.FinishRenderTexture.
- */
-static void
-st_finish_render_texture(struct gl_context *ctx,
-                         struct gl_renderbuffer_attachment *att)
-{
-   struct st_context *st = st_context(ctx);
-   struct st_renderbuffer *strb = st_renderbuffer(att->Renderbuffer);
-
-   if (!strb)
-      return;
-
-   st_flush(st, PIPE_FLUSH_RENDER_CACHE, NULL);
-
-   strb->rtt = NULL;
-
-   /*
-   printf("FINISH RENDER TO TEXTURE surf=%p\n", strb->surface);
-   */
-
-   /* restore previous framebuffer state */
-   st_invalidate_state(ctx, _NEW_BUFFERS);
-}
-
-
-/**
- * Validate a renderbuffer attachment for a particular set of bindings.
- */
-static GLboolean
-st_validate_attachment(struct gl_context *ctx,
-		       struct pipe_screen *screen,
-		       const struct gl_renderbuffer_attachment *att,
-		       unsigned bindings)
-{
-   const struct st_texture_object *stObj = st_texture_object(att->Texture);
-   enum pipe_format format;
-   gl_format texFormat;
-
-   /* Only validate texture attachments for now, since
-    * st_renderbuffer_alloc_storage makes sure that
-    * the format is supported.
-    */
-   if (att->Type != GL_TEXTURE)
-      return GL_TRUE;
-
-   if (!stObj)
-      return GL_FALSE;
-
-   format = stObj->pt->format;
-   texFormat =
-      stObj->base.Image[att->CubeMapFace][att->TextureLevel]->TexFormat;
-
-   /* If the encoding is sRGB and sRGB rendering cannot be enabled,
-    * check for linear format support instead.
-    * Later when we create a surface, we change the format to a linear one. */
-   if (!ctx->Const.sRGBCapable &&
-       _mesa_get_format_color_encoding(texFormat) == GL_SRGB) {
-      const gl_format linearFormat = _mesa_get_srgb_format_linear(texFormat);
-      format = st_mesa_format_to_pipe_format(linearFormat);
-   }
-
-   return screen->is_format_supported(screen, format,
-                                      PIPE_TEXTURE_2D,
-                                      stObj->pt->nr_samples, bindings, 0);
-}
-
-
-/**
- * Check if two renderbuffer attachments name a combined depth/stencil
- * renderbuffer.
- */
-GLboolean
-st_is_depth_stencil_combined(const struct gl_renderbuffer_attachment *depth,
-                             const struct gl_renderbuffer_attachment *stencil)
-{
-   assert(depth && stencil);
-
-   if (depth->Type == stencil->Type) {
-      if (depth->Type == GL_RENDERBUFFER_EXT &&
-          depth->Renderbuffer == stencil->Renderbuffer)
-         return GL_TRUE;
-
-      if (depth->Type == GL_TEXTURE &&
-          depth->Texture == stencil->Texture)
-         return GL_TRUE;
-   }
-
-   return GL_FALSE;
-}
- 
-
-/**
- * Check that the framebuffer configuration is valid in terms of what
- * the driver can support.
- *
- * For Gallium we only supports combined Z+stencil, not separate buffers.
- */
-static void
-st_validate_framebuffer(struct gl_context *ctx, struct gl_framebuffer *fb)
-{
-   struct st_context *st = st_context(ctx);
-   struct pipe_screen *screen = st->pipe->screen;
-   const struct gl_renderbuffer_attachment *depth =
-         &fb->Attachment[BUFFER_DEPTH];
-   const struct gl_renderbuffer_attachment *stencil =
-         &fb->Attachment[BUFFER_STENCIL];
-   GLuint i;
-
-   if (depth->Type && stencil->Type && depth->Type != stencil->Type) {
-      fb->_Status = GL_FRAMEBUFFER_UNSUPPORTED_EXT;
-      return;
-   }
-   if (depth->Type == GL_RENDERBUFFER_EXT &&
-       stencil->Type == GL_RENDERBUFFER_EXT &&
-       depth->Renderbuffer != stencil->Renderbuffer) {
-      fb->_Status = GL_FRAMEBUFFER_UNSUPPORTED_EXT;
-      return;
-   }
-   if (depth->Type == GL_TEXTURE &&
-       stencil->Type == GL_TEXTURE &&
-       depth->Texture != stencil->Texture) {
-      fb->_Status = GL_FRAMEBUFFER_UNSUPPORTED_EXT;
-      return;
-   }
-
-   if (!st_validate_attachment(ctx,
-                               screen,
-                               depth,
-			       PIPE_BIND_DEPTH_STENCIL)) {
-      fb->_Status = GL_FRAMEBUFFER_UNSUPPORTED_EXT;
-      return;
-   }
-   if (!st_validate_attachment(ctx,
-                               screen,
-                               stencil,
-			       PIPE_BIND_DEPTH_STENCIL)) {
-      fb->_Status = GL_FRAMEBUFFER_UNSUPPORTED_EXT;
-      return;
-   }
-   for (i = 0; i < ctx->Const.MaxColorAttachments; i++) {
-      if (!st_validate_attachment(ctx,
-                                  screen,
-				  &fb->Attachment[BUFFER_COLOR0 + i],
-				  PIPE_BIND_RENDER_TARGET)) {
-	 fb->_Status = GL_FRAMEBUFFER_UNSUPPORTED_EXT;
-	 return;
-      }
-   }
-}
-
-
-/**
- * Called via glDrawBuffer.
- */
-static void
-st_DrawBuffers(struct gl_context *ctx, GLsizei count, const GLenum *buffers)
-{
-   struct st_context *st = st_context(ctx);
-   struct gl_framebuffer *fb = ctx->DrawBuffer;
-   GLuint i;
-
-   (void) count;
-   (void) buffers;
-
-   /* add the renderbuffers on demand */
-   for (i = 0; i < fb->_NumColorDrawBuffers; i++) {
-      gl_buffer_index idx = fb->_ColorDrawBufferIndexes[i];
-      st_manager_add_color_renderbuffer(st, fb, idx);
-   }
-}
-
-
-/**
- * Called via glReadBuffer.
- */
-static void
-st_ReadBuffer(struct gl_context *ctx, GLenum buffer)
-{
-   struct st_context *st = st_context(ctx);
-   struct gl_framebuffer *fb = ctx->ReadBuffer;
-
-   (void) buffer;
-
-   /* add the renderbuffer on demand */
-   st_manager_add_color_renderbuffer(st, fb, fb->_ColorReadBufferIndex);
-}
-
-
-void st_init_fbo_functions(struct dd_function_table *functions)
-{
-#if FEATURE_EXT_framebuffer_object
-   functions->NewFramebuffer = st_new_framebuffer;
-   functions->NewRenderbuffer = st_new_renderbuffer;
-   functions->BindFramebuffer = st_bind_framebuffer;
-   functions->FramebufferRenderbuffer = st_framebuffer_renderbuffer;
-   functions->RenderTexture = st_render_texture;
-   functions->FinishRenderTexture = st_finish_render_texture;
-   functions->ValidateFramebuffer = st_validate_framebuffer;
-#endif
-   /* no longer needed by core Mesa, drivers handle resizes...
-   functions->ResizeBuffers = st_resize_buffers;
-   */
-
-   functions->DrawBuffers = st_DrawBuffers;
-   functions->ReadBuffer = st_ReadBuffer;
-}
-
-/* XXX unused ? */
-struct pipe_sampler_view *
-st_get_renderbuffer_sampler_view(struct st_renderbuffer *rb,
-                                 struct pipe_context *pipe)
-{
-   if (!rb->sampler_view) {
-      rb->sampler_view = st_create_texture_sampler_view(pipe, rb->texture);
-   }
-
-   return rb->sampler_view;
-}
+/**************************************************************************

+ * 

+ * Copyright 2007 Tungsten Graphics, Inc., Cedar Park, Texas.

+ * 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, sub license, 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 (including the

+ * next paragraph) 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 NON-INFRINGEMENT.

+ * IN NO EVENT SHALL TUNGSTEN GRAPHICS AND/OR ITS SUPPLIERS 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.

+ * 

+ **************************************************************************/

+

+

+/**

+ * Framebuffer/renderbuffer functions.

+ *

+ * \author Brian Paul

+ */

+

+

+#include "main/imports.h"

+#include "main/context.h"

+#include "main/fbobject.h"

+#include "main/framebuffer.h"

+#include "main/macros.h"

+#include "main/mfeatures.h"

+#include "main/renderbuffer.h"

+

+#include "pipe/p_context.h"

+#include "pipe/p_defines.h"

+#include "pipe/p_screen.h"

+#include "st_context.h"

+#include "st_cb_fbo.h"

+#include "st_cb_flush.h"

+#include "st_format.h"

+#include "st_texture.h"

+#include "st_manager.h"

+

+#include "util/u_format.h"

+#include "util/u_inlines.h"

+#include "util/u_surface.h"

+

+

+/**

+ * gl_renderbuffer::AllocStorage()

+ * This is called to allocate the original drawing surface, and

+ * during window resize.

+ */

+static GLboolean

+st_renderbuffer_alloc_storage(struct gl_context * ctx,

+                              struct gl_renderbuffer *rb,

+                              GLenum internalFormat,

+                              GLuint width, GLuint height)

+{

+   struct st_context *st = st_context(ctx);

+   struct pipe_context *pipe = st->pipe;

+   struct pipe_screen *screen = st->pipe->screen;

+   struct st_renderbuffer *strb = st_renderbuffer(rb);

+   enum pipe_format format;

+   struct pipe_surface surf_tmpl;

+

+   if (strb->format != PIPE_FORMAT_NONE)

+      format = strb->format;

+   else

+      format = st_choose_renderbuffer_format(screen, internalFormat,

+                                             rb->NumSamples);

+

+   if (format == PIPE_FORMAT_NONE) {

+      return FALSE;

+   }

+

+   /* init renderbuffer fields */

+   strb->Base.Width  = width;

+   strb->Base.Height = height;

+   strb->Base.Format = st_pipe_format_to_mesa_format(format);

+   strb->Base._BaseFormat = _mesa_base_fbo_format(ctx, internalFormat);

+   strb->Base.DataType = st_format_datatype(format);

+

+   strb->defined = GL_FALSE;  /* undefined contents now */

+

+   if (strb->software) {

+      size_t size;

+      

+      free(strb->data);

+

+      assert(strb->format != PIPE_FORMAT_NONE);

+      

+      strb->stride = util_format_get_stride(strb->format, width);

+      size = util_format_get_2d_size(strb->format, strb->stride, height);

+      

+      strb->data = malloc(size);

+      

+      return strb->data != NULL;

+   }

+   else {

+      struct pipe_resource template;

+    

+      /* Free the old surface and texture

+       */

+      pipe_surface_reference( &strb->surface, NULL );

+      pipe_resource_reference( &strb->texture, NULL );

+      pipe_sampler_view_reference(&strb->sampler_view, NULL);

+

+      /* Setup new texture template.

+       */

+      memset(&template, 0, sizeof(template));

+      template.target = st->internal_target;

+      template.format = format;

+      template.width0 = width;

+      template.height0 = height;

+      template.depth0 = 1;

+      template.array_size = 1;

+      template.last_level = 0;

+      template.nr_samples = rb->NumSamples;

+      if (util_format_is_depth_or_stencil(format)) {

+         template.bind = PIPE_BIND_DEPTH_STENCIL;

+      }

+      else {

+         template.bind = (PIPE_BIND_DISPLAY_TARGET |

+                          PIPE_BIND_RENDER_TARGET);

+      }

+

+      strb->texture = screen->resource_create(screen, &template);

+

+      if (!strb->texture) 

+         return FALSE;

+

+      memset(&surf_tmpl, 0, sizeof(surf_tmpl));

+      u_surface_default_template(&surf_tmpl, strb->texture, template.bind);

+      strb->surface = pipe->create_surface(pipe,

+                                           strb->texture,

+                                           &surf_tmpl);

+      if (strb->surface) {

+         assert(strb->surface->texture);

+         assert(strb->surface->format);

+         assert(strb->surface->width == width);

+         assert(strb->surface->height == height);

+      }

+

+      return strb->surface != NULL;

+   }

+}

+

+

+/**

+ * gl_renderbuffer::Delete()

+ */

+static void

+st_renderbuffer_delete(struct gl_renderbuffer *rb)

+{

+   struct st_renderbuffer *strb = st_renderbuffer(rb);

+   ASSERT(strb);

+   pipe_surface_reference(&strb->surface, NULL);

+   pipe_resource_reference(&strb->texture, NULL);

+   pipe_sampler_view_reference(&strb->sampler_view, NULL);

+   free(strb->data);

+   free(strb);

+}

+

+

+/**

+ * gl_renderbuffer::GetPointer()

+ */

+static void *

+null_get_pointer(struct gl_context * ctx, struct gl_renderbuffer *rb,

+                 GLint x, GLint y)

+{

+   /* By returning NULL we force all software rendering to go through

+    * the span routines.

+    */

+#if 0

+   assert(0);  /* Should never get called with softpipe */

+#endif

+   return NULL;

+}

+

+

+/**

+ * Called via ctx->Driver.NewFramebuffer()

+ */

+static struct gl_framebuffer *

+st_new_framebuffer(struct gl_context *ctx, GLuint name)

+{

+   /* XXX not sure we need to subclass gl_framebuffer for pipe */

+   return _mesa_new_framebuffer(ctx, name);

+}

+

+

+/**

+ * Called via ctx->Driver.NewRenderbuffer()

+ */

+static struct gl_renderbuffer *

+st_new_renderbuffer(struct gl_context *ctx, GLuint name)

+{

+   struct st_renderbuffer *strb = ST_CALLOC_STRUCT(st_renderbuffer);

+   if (strb) {

+      _mesa_init_renderbuffer(&strb->Base, name);

+      strb->Base.Delete = st_renderbuffer_delete;

+      strb->Base.AllocStorage = st_renderbuffer_alloc_storage;

+      strb->Base.GetPointer = null_get_pointer;

+      strb->format = PIPE_FORMAT_NONE;

+      return &strb->Base;

+   }

+   return NULL;

+}

+

+

+/**

+ * Allocate a renderbuffer for a an on-screen window (not a user-created

+ * renderbuffer).  The window system code determines the format.

+ */

+struct gl_renderbuffer *

+st_new_renderbuffer_fb(enum pipe_format format, int samples, boolean sw)

+{

+   struct st_renderbuffer *strb;

+

+   strb = ST_CALLOC_STRUCT(st_renderbuffer);

+   if (!strb) {

+      _mesa_error(NULL, GL_OUT_OF_MEMORY, "creating renderbuffer");

+      return NULL;

+   }

+

+   _mesa_init_renderbuffer(&strb->Base, 0);

+   strb->Base.ClassID = 0x4242; /* just a unique value */

+   strb->Base.NumSamples = samples;

+   strb->Base.Format = st_pipe_format_to_mesa_format(format);

+   strb->Base._BaseFormat = _mesa_get_format_base_format(strb->Base.Format);

+   strb->Base.DataType = st_format_datatype(format);

+   strb->format = format;

+   strb->software = sw;

+   

+   switch (format) {

+   case PIPE_FORMAT_R8G8B8A8_UNORM:

+   case PIPE_FORMAT_B8G8R8A8_UNORM:

+   case PIPE_FORMAT_A8R8G8B8_UNORM:

+   case PIPE_FORMAT_R8G8B8X8_UNORM:

+   case PIPE_FORMAT_B8G8R8X8_UNORM:

+   case PIPE_FORMAT_X8R8G8B8_UNORM:

+   case PIPE_FORMAT_B5G5R5A1_UNORM:

+   case PIPE_FORMAT_B4G4R4A4_UNORM:

+   case PIPE_FORMAT_B5G6R5_UNORM:

+      strb->Base.InternalFormat = GL_RGBA;

+      break;

+   case PIPE_FORMAT_Z16_UNORM:

+      strb->Base.InternalFormat = GL_DEPTH_COMPONENT16;

+      break;

+   case PIPE_FORMAT_Z32_UNORM:

+      strb->Base.InternalFormat = GL_DEPTH_COMPONENT32;

+      break;

+   case PIPE_FORMAT_Z24_UNORM_S8_USCALED:

+   case PIPE_FORMAT_S8_USCALED_Z24_UNORM:

+   case PIPE_FORMAT_Z24X8_UNORM:

+   case PIPE_FORMAT_X8Z24_UNORM:

+      strb->Base.InternalFormat = GL_DEPTH24_STENCIL8_EXT;

+      break;

+   case PIPE_FORMAT_S8_USCALED:

+      strb->Base.InternalFormat = GL_STENCIL_INDEX8_EXT;

+      break;

+   case PIPE_FORMAT_R16G16B16A16_SNORM:

+      strb->Base.InternalFormat = GL_RGBA16;

+      break;

+   case PIPE_FORMAT_R8_UNORM:

+      strb->Base.InternalFormat = GL_R8;

+      break;

+   case PIPE_FORMAT_R8G8_UNORM:

+      strb->Base.InternalFormat = GL_RG8;

+      break;

+   case PIPE_FORMAT_R16_UNORM:

+      strb->Base.InternalFormat = GL_R16;

+      break;

+   case PIPE_FORMAT_R16G16_UNORM:

+      strb->Base.InternalFormat = GL_RG16;

+      break;

+   default:

+      _mesa_problem(NULL,

+		    "Unexpected format in st_new_renderbuffer_fb");

+      free(strb);

+      return NULL;

+   }

+

+   /* st-specific methods */

+   strb->Base.Delete = st_renderbuffer_delete;

+   strb->Base.AllocStorage = st_renderbuffer_alloc_storage;

+   strb->Base.GetPointer = null_get_pointer;

+

+   /* surface is allocated in st_renderbuffer_alloc_storage() */

+   strb->surface = NULL;

+

+   return &strb->Base;

+}

+

+

+

+

+/**

+ * Called via ctx->Driver.BindFramebufferEXT().

+ */

+static void

+st_bind_framebuffer(struct gl_context *ctx, GLenum target,

+                    struct gl_framebuffer *fb, struct gl_framebuffer *fbread)

+{

+

+}

+

+/**

+ * Called by ctx->Driver.FramebufferRenderbuffer

+ */

+static void

+st_framebuffer_renderbuffer(struct gl_context *ctx, 

+                            struct gl_framebuffer *fb,

+                            GLenum attachment,

+                            struct gl_renderbuffer *rb)

+{

+   /* XXX no need for derivation? */

+   _mesa_framebuffer_renderbuffer(ctx, fb, attachment, rb);

+}

+

+

+/**

+ * Called by ctx->Driver.RenderTexture

+ */

+static void

+st_render_texture(struct gl_context *ctx,

+                  struct gl_framebuffer *fb,

+                  struct gl_renderbuffer_attachment *att)

+{

+   struct st_context *st = st_context(ctx);

+   struct pipe_context *pipe = st->pipe;

+   struct st_renderbuffer *strb;

+   struct gl_renderbuffer *rb;

+   struct pipe_resource *pt = st_get_texobj_resource(att->Texture);

+   struct st_texture_object *stObj;

+   const struct gl_texture_image *texImage;

+   struct pipe_surface surf_tmpl;

+

+   /* When would this fail?  Perhaps assert? */

+   if (!pt) 

+      return;

+

+   /* get pointer to texture image we're rendeing to */

+   texImage = att->Texture->Image[att->CubeMapFace][att->TextureLevel];

+

+   /* create new renderbuffer which wraps the texture image */

+   rb = st_new_renderbuffer(ctx, 0);

+   if (!rb) {

+      _mesa_error(ctx, GL_OUT_OF_MEMORY, "glFramebufferTexture()");

+      return;

+   }

+

+   _mesa_reference_renderbuffer(&att->Renderbuffer, rb);

+   assert(rb->RefCount == 1);

+   rb->AllocStorage = NULL; /* should not get called */

+   strb = st_renderbuffer(rb);

+

+   assert(strb->Base.RefCount > 0);

+

+   /* get the texture for the texture object */

+   stObj = st_texture_object(att->Texture);

+

+   /* point renderbuffer at texobject */

+   strb->rtt = stObj;

+   strb->rtt_level = att->TextureLevel;

+   strb->rtt_face = att->CubeMapFace;

+   strb->rtt_slice = att->Zoffset;

+

+   rb->Width = texImage->Width2;

+   rb->Height = texImage->Height2;

+   rb->_BaseFormat = texImage->_BaseFormat;

+   /*printf("***** render to texture level %d: %d x %d\n", att->TextureLevel, rb->Width, rb->Height);*/

+

+   /*printf("***** pipe texture %d x %d\n", pt->width0, pt->height0);*/

+

+   pipe_resource_reference( &strb->texture, pt );

+

+   pipe_surface_reference(&strb->surface, NULL);

+

+   pipe_sampler_view_reference(&strb->sampler_view,

+                               st_get_texture_sampler_view(stObj, pipe));

+

+   assert(strb->rtt_level <= strb->texture->last_level);

+

+   /* new surface for rendering into the texture */

+   memset(&surf_tmpl, 0, sizeof(surf_tmpl));

+   surf_tmpl.format = ctx->Color.sRGBEnabled ? strb->texture->format : util_format_linear(strb->texture->format);

+   surf_tmpl.usage = PIPE_BIND_RENDER_TARGET;

+   surf_tmpl.u.tex.level = strb->rtt_level;

+   surf_tmpl.u.tex.first_layer = strb->rtt_face + strb->rtt_slice;

+   surf_tmpl.u.tex.last_layer = strb->rtt_face + strb->rtt_slice;

+   strb->surface = pipe->create_surface(pipe,

+                                        strb->texture,

+                                        &surf_tmpl);

+

+   strb->format = pt->format;

+

+   strb->Base.Format = st_pipe_format_to_mesa_format(pt->format);

+   strb->Base.DataType = st_format_datatype(pt->format);

+

+   /*

+   printf("RENDER TO TEXTURE obj=%p pt=%p surf=%p  %d x %d\n",

+          att->Texture, pt, strb->surface, rb->Width, rb->Height);

+   */

+

+   /* Invalidate buffer state so that the pipe's framebuffer state

+    * gets updated.

+    * That's where the new renderbuffer (which we just created) gets

+    * passed to the pipe as a (color/depth) render target.

+    */

+   st_invalidate_state(ctx, _NEW_BUFFERS);

+}

+

+

+/**

+ * Called via ctx->Driver.FinishRenderTexture.

+ */

+static void

+st_finish_render_texture(struct gl_context *ctx,

+                         struct gl_renderbuffer_attachment *att)

+{

+   struct st_renderbuffer *strb = st_renderbuffer(att->Renderbuffer);

+

+   if (!strb)

+      return;

+

+   strb->rtt = NULL;

+

+   /*

+   printf("FINISH RENDER TO TEXTURE surf=%p\n", strb->surface);

+   */

+

+   /* restore previous framebuffer state */

+   st_invalidate_state(ctx, _NEW_BUFFERS);

+}

+

+

+/**

+ * Validate a renderbuffer attachment for a particular set of bindings.

+ */

+static GLboolean

+st_validate_attachment(struct gl_context *ctx,

+		       struct pipe_screen *screen,

+		       const struct gl_renderbuffer_attachment *att,

+		       unsigned bindings)

+{

+   const struct st_texture_object *stObj = st_texture_object(att->Texture);

+   enum pipe_format format;

+   gl_format texFormat;

+

+   /* Only validate texture attachments for now, since

+    * st_renderbuffer_alloc_storage makes sure that

+    * the format is supported.

+    */

+   if (att->Type != GL_TEXTURE)

+      return GL_TRUE;

+

+   if (!stObj)

+      return GL_FALSE;

+

+   format = stObj->pt->format;

+   texFormat =

+      stObj->base.Image[att->CubeMapFace][att->TextureLevel]->TexFormat;

+

+   /* If the encoding is sRGB and sRGB rendering cannot be enabled,

+    * check for linear format support instead.

+    * Later when we create a surface, we change the format to a linear one. */

+   if (!ctx->Const.sRGBCapable &&

+       _mesa_get_format_color_encoding(texFormat) == GL_SRGB) {

+      const gl_format linearFormat = _mesa_get_srgb_format_linear(texFormat);

+      format = st_mesa_format_to_pipe_format(linearFormat);

+   }

+

+   return screen->is_format_supported(screen, format,

+                                      PIPE_TEXTURE_2D,

+                                      stObj->pt->nr_samples, bindings);

+}

+

+

+/**

+ * Check if two renderbuffer attachments name a combined depth/stencil

+ * renderbuffer.

+ */

+GLboolean

+st_is_depth_stencil_combined(const struct gl_renderbuffer_attachment *depth,

+                             const struct gl_renderbuffer_attachment *stencil)

+{

+   assert(depth && stencil);

+

+   if (depth->Type == stencil->Type) {

+      if (depth->Type == GL_RENDERBUFFER_EXT &&

+          depth->Renderbuffer == stencil->Renderbuffer)

+         return GL_TRUE;

+

+      if (depth->Type == GL_TEXTURE &&

+          depth->Texture == stencil->Texture)

+         return GL_TRUE;

+   }

+

+   return GL_FALSE;

+}

+ 

+

+/**

+ * Check that the framebuffer configuration is valid in terms of what

+ * the driver can support.

+ *

+ * For Gallium we only supports combined Z+stencil, not separate buffers.

+ */

+static void

+st_validate_framebuffer(struct gl_context *ctx, struct gl_framebuffer *fb)

+{

+   struct st_context *st = st_context(ctx);

+   struct pipe_screen *screen = st->pipe->screen;

+   const struct gl_renderbuffer_attachment *depth =

+         &fb->Attachment[BUFFER_DEPTH];

+   const struct gl_renderbuffer_attachment *stencil =

+         &fb->Attachment[BUFFER_STENCIL];

+   GLuint i;

+

+   if (depth->Type && stencil->Type && depth->Type != stencil->Type) {

+      fb->_Status = GL_FRAMEBUFFER_UNSUPPORTED_EXT;

+      return;

+   }

+   if (depth->Type == GL_RENDERBUFFER_EXT &&

+       stencil->Type == GL_RENDERBUFFER_EXT &&

+       depth->Renderbuffer != stencil->Renderbuffer) {

+      fb->_Status = GL_FRAMEBUFFER_UNSUPPORTED_EXT;

+      return;

+   }

+   if (depth->Type == GL_TEXTURE &&

+       stencil->Type == GL_TEXTURE &&

+       depth->Texture != stencil->Texture) {

+      fb->_Status = GL_FRAMEBUFFER_UNSUPPORTED_EXT;

+      return;

+   }

+

+   if (!st_validate_attachment(ctx,

+                               screen,

+                               depth,

+			       PIPE_BIND_DEPTH_STENCIL)) {

+      fb->_Status = GL_FRAMEBUFFER_UNSUPPORTED_EXT;

+      return;

+   }

+   if (!st_validate_attachment(ctx,

+                               screen,

+                               stencil,

+			       PIPE_BIND_DEPTH_STENCIL)) {

+      fb->_Status = GL_FRAMEBUFFER_UNSUPPORTED_EXT;

+      return;

+   }

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

+      if (!st_validate_attachment(ctx,

+                                  screen,

+				  &fb->Attachment[BUFFER_COLOR0 + i],

+				  PIPE_BIND_RENDER_TARGET)) {

+	 fb->_Status = GL_FRAMEBUFFER_UNSUPPORTED_EXT;

+	 return;

+      }

+   }

+}

+

+

+/**

+ * Called via glDrawBuffer.

+ */

+static void

+st_DrawBuffers(struct gl_context *ctx, GLsizei count, const GLenum *buffers)

+{

+   struct st_context *st = st_context(ctx);

+   struct gl_framebuffer *fb = ctx->DrawBuffer;

+   GLuint i;

+

+   (void) count;

+   (void) buffers;

+

+   /* add the renderbuffers on demand */

+   for (i = 0; i < fb->_NumColorDrawBuffers; i++) {

+      gl_buffer_index idx = fb->_ColorDrawBufferIndexes[i];

+      st_manager_add_color_renderbuffer(st, fb, idx);

+   }

+}

+

+

+/**

+ * Called via glReadBuffer.

+ */

+static void

+st_ReadBuffer(struct gl_context *ctx, GLenum buffer)

+{

+   struct st_context *st = st_context(ctx);

+   struct gl_framebuffer *fb = ctx->ReadBuffer;

+

+   (void) buffer;

+

+   /* add the renderbuffer on demand */

+   st_manager_add_color_renderbuffer(st, fb, fb->_ColorReadBufferIndex);

+}

+

+

+void st_init_fbo_functions(struct dd_function_table *functions)

+{

+#if FEATURE_EXT_framebuffer_object

+   functions->NewFramebuffer = st_new_framebuffer;

+   functions->NewRenderbuffer = st_new_renderbuffer;

+   functions->BindFramebuffer = st_bind_framebuffer;

+   functions->FramebufferRenderbuffer = st_framebuffer_renderbuffer;

+   functions->RenderTexture = st_render_texture;

+   functions->FinishRenderTexture = st_finish_render_texture;

+   functions->ValidateFramebuffer = st_validate_framebuffer;

+#endif

+   /* no longer needed by core Mesa, drivers handle resizes...

+   functions->ResizeBuffers = st_resize_buffers;

+   */

+

+   functions->DrawBuffers = st_DrawBuffers;

+   functions->ReadBuffer = st_ReadBuffer;

+}

+

+/* XXX unused ? */

+struct pipe_sampler_view *

+st_get_renderbuffer_sampler_view(struct st_renderbuffer *rb,

+                                 struct pipe_context *pipe)

+{

+   if (!rb->sampler_view) {

+      rb->sampler_view = st_create_texture_sampler_view(pipe, rb->texture);

+   }

+

+   return rb->sampler_view;

+}

diff --git a/mesalib/src/mesa/state_tracker/st_cb_flush.c b/mesalib/src/mesa/state_tracker/st_cb_flush.c
index 35ab00f6d..c029fad48 100644
--- a/mesalib/src/mesa/state_tracker/st_cb_flush.c
+++ b/mesalib/src/mesa/state_tracker/st_cb_flush.c
@@ -1,165 +1,165 @@
-/**************************************************************************
- * 
- * Copyright 2007 Tungsten Graphics, Inc., Cedar Park, Texas.
- * 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, sub license, 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 (including the
- * next paragraph) 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 NON-INFRINGEMENT.
- * IN NO EVENT SHALL TUNGSTEN GRAPHICS AND/OR ITS SUPPLIERS 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.
- * 
- **************************************************************************/
-
- /*
-  * Authors:
-  *   Keith Whitwell <keith@tungstengraphics.com>
-  *   Brian Paul
-  */
-
-#include "main/glheader.h"
-#include "main/macros.h"
-#include "main/context.h"
-#include "st_context.h"
-#include "st_cb_bitmap.h"
-#include "st_cb_flush.h"
-#include "st_cb_clear.h"
-#include "st_cb_fbo.h"
-#include "st_manager.h"
-#include "pipe/p_context.h"
-#include "pipe/p_defines.h"
-#include "pipe/p_screen.h"
-#include "util/u_gen_mipmap.h"
-#include "util/u_blit.h"
-
-
-/** Check if we have a front color buffer and if it's been drawn to. */
-static INLINE GLboolean
-is_front_buffer_dirty(struct st_context *st)
-{
-   struct gl_framebuffer *fb = st->ctx->DrawBuffer;
-   struct st_renderbuffer *strb
-      = st_renderbuffer(fb->Attachment[BUFFER_FRONT_LEFT].Renderbuffer);
-   return strb && strb->defined;
-}
-
-
-/**
- * Tell the screen to display the front color buffer on-screen.
- */
-static void
-display_front_buffer(struct st_context *st)
-{
-   struct gl_framebuffer *fb = st->ctx->DrawBuffer;
-   struct st_renderbuffer *strb
-      = st_renderbuffer(fb->Attachment[BUFFER_FRONT_LEFT].Renderbuffer);
-
-   if (strb) {
-      /* Hook for copying "fake" frontbuffer if necessary:
-       */
-      st_manager_flush_frontbuffer(st);
-   }
-}
-
-
-void st_flush( struct st_context *st, uint pipeFlushFlags,
-               struct pipe_fence_handle **fence )
-{
-   FLUSH_CURRENT(st->ctx, 0);
-
-   /* Release any vertex buffers that might potentially be accessed in
-    * successive frames:
-    */
-   st_flush_bitmap(st);
-   st_flush_clear(st);
-   util_blit_flush(st->blit);
-   util_gen_mipmap_flush(st->gen_mipmap);
-
-   st->pipe->flush( st->pipe, pipeFlushFlags, fence );
-}
-
-
-/**
- * Flush, and wait for completion.
- */
-void st_finish( struct st_context *st )
-{
-   struct pipe_fence_handle *fence = NULL;
-
-   st_flush(st, PIPE_FLUSH_RENDER_CACHE | PIPE_FLUSH_FRAME, &fence);
-
-   if(fence) {
-      st->pipe->screen->fence_finish(st->pipe->screen, fence, 0,
-                                     PIPE_TIMEOUT_INFINITE);
-      st->pipe->screen->fence_reference(st->pipe->screen, &fence, NULL);
-   }
-}
-
-
-
-/**
- * Called via ctx->Driver.Flush()
- */
-static void st_glFlush(struct gl_context *ctx)
-{
-   struct st_context *st = st_context(ctx);
-
-   /* Don't call st_finish() here.  It is not the state tracker's
-    * responsibilty to inject sleeps in the hope of avoiding buffer
-    * synchronization issues.  Calling finish() here will just hide
-    * problems that need to be fixed elsewhere.
-    */
-   st_flush(st, PIPE_FLUSH_RENDER_CACHE | PIPE_FLUSH_FRAME, NULL);
-
-   if (is_front_buffer_dirty(st)) {
-      display_front_buffer(st);
-   }
-}
-
-
-/**
- * Called via ctx->Driver.Finish()
- */
-static void st_glFinish(struct gl_context *ctx)
-{
-   struct st_context *st = st_context(ctx);
-
-   st_finish(st);
-
-   if (is_front_buffer_dirty(st)) {
-      display_front_buffer(st);
-   }
-}
-
-
-void st_init_flush_functions(struct dd_function_table *functions)
-{
-   functions->Flush = st_glFlush;
-   functions->Finish = st_glFinish;
-
-   /* Windows opengl32.dll calls glFinish prior to every swapbuffers.
-    * This is unnecessary and degrades performance.  Luckily we have some
-    * scope to work around this, as the externally-visible behaviour of
-    * Finish() is identical to Flush() in all cases - no differences in
-    * rendering or ReadPixels are visible if we opt not to wait here.
-    *
-    * Only set this up on windows to avoid suprise elsewhere.
-    */
-#ifdef PIPE_OS_WINDOWS
-   functions->Finish = st_glFlush;
-#endif
-}
+/**************************************************************************

+ * 

+ * Copyright 2007 Tungsten Graphics, Inc., Cedar Park, Texas.

+ * 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, sub license, 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 (including the

+ * next paragraph) 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 NON-INFRINGEMENT.

+ * IN NO EVENT SHALL TUNGSTEN GRAPHICS AND/OR ITS SUPPLIERS 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.

+ * 

+ **************************************************************************/

+

+ /*

+  * Authors:

+  *   Keith Whitwell <keith@tungstengraphics.com>

+  *   Brian Paul

+  */

+

+#include "main/glheader.h"

+#include "main/macros.h"

+#include "main/context.h"

+#include "st_context.h"

+#include "st_cb_bitmap.h"

+#include "st_cb_flush.h"

+#include "st_cb_clear.h"

+#include "st_cb_fbo.h"

+#include "st_manager.h"

+#include "pipe/p_context.h"

+#include "pipe/p_defines.h"

+#include "pipe/p_screen.h"

+#include "util/u_gen_mipmap.h"

+#include "util/u_blit.h"

+

+

+/** Check if we have a front color buffer and if it's been drawn to. */

+static INLINE GLboolean

+is_front_buffer_dirty(struct st_context *st)

+{

+   struct gl_framebuffer *fb = st->ctx->DrawBuffer;

+   struct st_renderbuffer *strb

+      = st_renderbuffer(fb->Attachment[BUFFER_FRONT_LEFT].Renderbuffer);

+   return strb && strb->defined;

+}

+

+

+/**

+ * Tell the screen to display the front color buffer on-screen.

+ */

+static void

+display_front_buffer(struct st_context *st)

+{

+   struct gl_framebuffer *fb = st->ctx->DrawBuffer;

+   struct st_renderbuffer *strb

+      = st_renderbuffer(fb->Attachment[BUFFER_FRONT_LEFT].Renderbuffer);

+

+   if (strb) {

+      /* Hook for copying "fake" frontbuffer if necessary:

+       */

+      st_manager_flush_frontbuffer(st);

+   }

+}

+

+

+void st_flush( struct st_context *st,

+               struct pipe_fence_handle **fence )

+{

+   FLUSH_CURRENT(st->ctx, 0);

+

+   /* Release any vertex buffers that might potentially be accessed in

+    * successive frames:

+    */

+   st_flush_bitmap(st);

+   st_flush_clear(st);

+   util_blit_flush(st->blit);

+   util_gen_mipmap_flush(st->gen_mipmap);

+

+   st->pipe->flush( st->pipe, fence );

+}

+

+

+/**

+ * Flush, and wait for completion.

+ */

+void st_finish( struct st_context *st )

+{

+   struct pipe_fence_handle *fence = NULL;

+

+   st_flush(st, &fence);

+

+   if(fence) {

+      st->pipe->screen->fence_finish(st->pipe->screen, fence,

+                                     PIPE_TIMEOUT_INFINITE);

+      st->pipe->screen->fence_reference(st->pipe->screen, &fence, NULL);

+   }

+}

+

+

+

+/**

+ * Called via ctx->Driver.Flush()

+ */

+static void st_glFlush(struct gl_context *ctx)

+{

+   struct st_context *st = st_context(ctx);

+

+   /* Don't call st_finish() here.  It is not the state tracker's

+    * responsibilty to inject sleeps in the hope of avoiding buffer

+    * synchronization issues.  Calling finish() here will just hide

+    * problems that need to be fixed elsewhere.

+    */

+   st_flush(st, NULL);

+

+   if (is_front_buffer_dirty(st)) {

+      display_front_buffer(st);

+   }

+}

+

+

+/**

+ * Called via ctx->Driver.Finish()

+ */

+static void st_glFinish(struct gl_context *ctx)

+{

+   struct st_context *st = st_context(ctx);

+

+   st_finish(st);

+

+   if (is_front_buffer_dirty(st)) {

+      display_front_buffer(st);

+   }

+}

+

+

+void st_init_flush_functions(struct dd_function_table *functions)

+{

+   functions->Flush = st_glFlush;

+   functions->Finish = st_glFinish;

+

+   /* Windows opengl32.dll calls glFinish prior to every swapbuffers.

+    * This is unnecessary and degrades performance.  Luckily we have some

+    * scope to work around this, as the externally-visible behaviour of

+    * Finish() is identical to Flush() in all cases - no differences in

+    * rendering or ReadPixels are visible if we opt not to wait here.

+    *

+    * Only set this up on windows to avoid suprise elsewhere.

+    */

+#ifdef PIPE_OS_WINDOWS

+   functions->Finish = st_glFlush;

+#endif

+}

diff --git a/mesalib/src/mesa/state_tracker/st_cb_flush.h b/mesalib/src/mesa/state_tracker/st_cb_flush.h
index 234713675..1fd0c56d7 100644
--- a/mesalib/src/mesa/state_tracker/st_cb_flush.h
+++ b/mesalib/src/mesa/state_tracker/st_cb_flush.h
@@ -40,7 +40,7 @@ extern void
 st_init_flush_functions(struct dd_function_table *functions);

 

 extern void

-st_flush(struct st_context *st, uint pipeFlushFlags,

+st_flush(struct st_context *st,

          struct pipe_fence_handle **fence);

 

 extern void

diff --git a/mesalib/src/mesa/state_tracker/st_cb_syncobj.c b/mesalib/src/mesa/state_tracker/st_cb_syncobj.c
index 85aad08cc..7e243561a 100644
--- a/mesalib/src/mesa/state_tracker/st_cb_syncobj.c
+++ b/mesalib/src/mesa/state_tracker/st_cb_syncobj.c
@@ -1,122 +1,122 @@
-/**************************************************************************
- *
- * Copyright 2011 Marek Olšák <maraeo@gmail.com>
- * 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, sub license, 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 (including the
- * next paragraph) 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 NON-INFRINGEMENT.
- * IN NO EVENT SHALL AUTHORS AND/OR ITS SUPPLIERS 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.
- *
- **************************************************************************/
-
- /*
-  * Authors:
-  *   Marek Olšák <maraeo@gmail.com>
-  */
-
-#include "main/glheader.h"
-#include "main/macros.h"
-#include "pipe/p_context.h"
-#include "pipe/p_screen.h"
-#include "st_context.h"
-#include "st_cb_syncobj.h"
-
-struct st_sync_object {
-   struct gl_sync_object b;
-
-   struct pipe_fence_handle *fence;
-};
-
-
-static struct gl_sync_object * st_new_sync_object(struct gl_context *ctx,
-                                                  GLenum type)
-{
-   if (type == GL_SYNC_FENCE)
-      return (struct gl_sync_object*)CALLOC_STRUCT(st_sync_object);
-   else
-      return NULL;
-}
-
-static void st_delete_sync_object(struct gl_context *ctx,
-                                  struct gl_sync_object *obj)
-{
-   struct pipe_screen *screen = st_context(ctx)->pipe->screen;
-   struct st_sync_object *so = (struct st_sync_object*)obj;
-
-   screen->fence_reference(screen, &so->fence, NULL);
-   FREE(so);
-}
-
-static void st_fence_sync(struct gl_context *ctx, struct gl_sync_object *obj,
-                          GLenum condition, GLbitfield flags)
-{
-   struct pipe_context *pipe = st_context(ctx)->pipe;
-   struct st_sync_object *so = (struct st_sync_object*)obj;
-
-   assert(condition == GL_SYNC_GPU_COMMANDS_COMPLETE && flags == 0);
-   assert(so->fence == NULL);
-
-   pipe->flush(pipe, 0, &so->fence);
-}
-
-static void st_check_sync(struct gl_context *ctx, struct gl_sync_object *obj)
-{
-   struct pipe_screen *screen = st_context(ctx)->pipe->screen;
-   struct st_sync_object *so = (struct st_sync_object*)obj;
-
-   if (so->fence && screen->fence_signalled(screen, so->fence, 0) == 0) {
-      screen->fence_reference(screen, &so->fence, NULL);
-      so->b.StatusFlag = GL_TRUE;
-   }
-}
-
-static void st_client_wait_sync(struct gl_context *ctx,
-                                struct gl_sync_object *obj,
-                                GLbitfield flags, GLuint64 timeout)
-{
-   struct pipe_screen *screen = st_context(ctx)->pipe->screen;
-   struct st_sync_object *so = (struct st_sync_object*)obj;
-
-   /* We don't care about GL_SYNC_FLUSH_COMMANDS_BIT, because flush is
-    * already called when creating a fence. */
-
-   if (so->fence &&
-       screen->fence_finish(screen, so->fence, 0, timeout) == 0) {
-      screen->fence_reference(screen, &so->fence, NULL);
-      so->b.StatusFlag = GL_TRUE;
-   }
-}
-
-static void st_server_wait_sync(struct gl_context *ctx,
-                                struct gl_sync_object *obj,
-                                GLbitfield flags, GLuint64 timeout)
-{
-   /* NO-OP.
-    * Neither Gallium nor DRM interfaces support blocking on the GPU. */
-}
-
-void st_init_syncobj_functions(struct dd_function_table *functions)
-{
-   functions->NewSyncObject = st_new_sync_object;
-   functions->FenceSync = st_fence_sync;
-   functions->DeleteSyncObject = st_delete_sync_object;
-   functions->CheckSync = st_check_sync;
-   functions->ClientWaitSync = st_client_wait_sync;
-   functions->ServerWaitSync = st_server_wait_sync;
-}
+/**************************************************************************

+ *

+ * Copyright 2011 Marek Olšák <maraeo@gmail.com>

+ * 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, sub license, 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 (including the

+ * next paragraph) 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 NON-INFRINGEMENT.

+ * IN NO EVENT SHALL AUTHORS AND/OR ITS SUPPLIERS 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.

+ *

+ **************************************************************************/

+

+ /*

+  * Authors:

+  *   Marek Olšák <maraeo@gmail.com>

+  */

+

+#include "main/glheader.h"

+#include "main/macros.h"

+#include "pipe/p_context.h"

+#include "pipe/p_screen.h"

+#include "st_context.h"

+#include "st_cb_syncobj.h"

+

+struct st_sync_object {

+   struct gl_sync_object b;

+

+   struct pipe_fence_handle *fence;

+};

+

+

+static struct gl_sync_object * st_new_sync_object(struct gl_context *ctx,

+                                                  GLenum type)

+{

+   if (type == GL_SYNC_FENCE)

+      return (struct gl_sync_object*)CALLOC_STRUCT(st_sync_object);

+   else

+      return NULL;

+}

+

+static void st_delete_sync_object(struct gl_context *ctx,

+                                  struct gl_sync_object *obj)

+{

+   struct pipe_screen *screen = st_context(ctx)->pipe->screen;

+   struct st_sync_object *so = (struct st_sync_object*)obj;

+

+   screen->fence_reference(screen, &so->fence, NULL);

+   FREE(so);

+}

+

+static void st_fence_sync(struct gl_context *ctx, struct gl_sync_object *obj,

+                          GLenum condition, GLbitfield flags)

+{

+   struct pipe_context *pipe = st_context(ctx)->pipe;

+   struct st_sync_object *so = (struct st_sync_object*)obj;

+

+   assert(condition == GL_SYNC_GPU_COMMANDS_COMPLETE && flags == 0);

+   assert(so->fence == NULL);

+

+   pipe->flush(pipe, &so->fence);

+}

+

+static void st_check_sync(struct gl_context *ctx, struct gl_sync_object *obj)

+{

+   struct pipe_screen *screen = st_context(ctx)->pipe->screen;

+   struct st_sync_object *so = (struct st_sync_object*)obj;

+

+   if (so->fence && screen->fence_signalled(screen, so->fence)) {

+      screen->fence_reference(screen, &so->fence, NULL);

+      so->b.StatusFlag = GL_TRUE;

+   }

+}

+

+static void st_client_wait_sync(struct gl_context *ctx,

+                                struct gl_sync_object *obj,

+                                GLbitfield flags, GLuint64 timeout)

+{

+   struct pipe_screen *screen = st_context(ctx)->pipe->screen;

+   struct st_sync_object *so = (struct st_sync_object*)obj;

+

+   /* We don't care about GL_SYNC_FLUSH_COMMANDS_BIT, because flush is

+    * already called when creating a fence. */

+

+   if (so->fence &&

+       screen->fence_finish(screen, so->fence, timeout)) {

+      screen->fence_reference(screen, &so->fence, NULL);

+      so->b.StatusFlag = GL_TRUE;

+   }

+}

+

+static void st_server_wait_sync(struct gl_context *ctx,

+                                struct gl_sync_object *obj,

+                                GLbitfield flags, GLuint64 timeout)

+{

+   /* NO-OP.

+    * Neither Gallium nor DRM interfaces support blocking on the GPU. */

+}

+

+void st_init_syncobj_functions(struct dd_function_table *functions)

+{

+   functions->NewSyncObject = st_new_sync_object;

+   functions->FenceSync = st_fence_sync;

+   functions->DeleteSyncObject = st_delete_sync_object;

+   functions->CheckSync = st_check_sync;

+   functions->ClientWaitSync = st_client_wait_sync;

+   functions->ServerWaitSync = st_server_wait_sync;

+}

diff --git a/mesalib/src/mesa/state_tracker/st_cb_texture.c b/mesalib/src/mesa/state_tracker/st_cb_texture.c
index 17dab2f1a..8bdb3c801 100644
--- a/mesalib/src/mesa/state_tracker/st_cb_texture.c
+++ b/mesalib/src/mesa/state_tracker/st_cb_texture.c
@@ -217,7 +217,6 @@ default_bindings(struct st_context *st, enum pipe_format format)
 {

    struct pipe_screen *screen = st->pipe->screen;

    const unsigned target = PIPE_TEXTURE_2D;

-   const unsigned geom = 0x0;

    unsigned bindings;

 

    if (util_format_is_depth_or_stencil(format))

@@ -225,13 +224,13 @@ default_bindings(struct st_context *st, enum pipe_format format)
    else

       bindings = PIPE_BIND_SAMPLER_VIEW | PIPE_BIND_RENDER_TARGET;

 

-   if (screen->is_format_supported(screen, format, target, 0, bindings, geom))

+   if (screen->is_format_supported(screen, format, target, 0, bindings))

       return bindings;

    else {

       /* Try non-sRGB. */

       format = util_format_linear(format);

 

-      if (screen->is_format_supported(screen, format, target, 0, bindings, geom))

+      if (screen->is_format_supported(screen, format, target, 0, bindings))

          return bindings;

       else

          return PIPE_BIND_SAMPLER_VIEW;

@@ -1523,12 +1522,10 @@ st_copy_texsubimage(struct gl_context *ctx,
                texBaseFormat != GL_DEPTH_STENCIL &&

                screen->is_format_supported(screen, src_format,

                                            PIPE_TEXTURE_2D, sample_count,

-                                           PIPE_BIND_SAMPLER_VIEW,

-                                           0) &&

+                                           PIPE_BIND_SAMPLER_VIEW) &&

                screen->is_format_supported(screen, dest_format,

                                            PIPE_TEXTURE_2D, 0,

-                                           PIPE_BIND_RENDER_TARGET,

-                                           0)) {

+                                           PIPE_BIND_RENDER_TARGET)) {

          /* draw textured quad to do the copy */

          GLint srcY0, srcY1;

          struct pipe_surface surf_tmpl;

diff --git a/mesalib/src/mesa/state_tracker/st_extensions.c b/mesalib/src/mesa/state_tracker/st_extensions.c
index aaa1658f4..5fe516c19 100644
--- a/mesalib/src/mesa/state_tracker/st_extensions.c
+++ b/mesalib/src/mesa/state_tracker/st_extensions.c
@@ -1,525 +1,525 @@
-/**************************************************************************
- * 
- * Copyright 2007 Tungsten Graphics, Inc., Cedar Park, Texas.
- * Copyright (c) 2008 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, sub license, 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 (including the
- * next paragraph) 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 NON-INFRINGEMENT.
- * IN NO EVENT SHALL TUNGSTEN GRAPHICS AND/OR ITS SUPPLIERS 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.
- * 
- **************************************************************************/
-
-#include "main/imports.h"
-#include "main/context.h"
-#include "main/macros.h"
-#include "main/mfeatures.h"
-
-#include "pipe/p_context.h"
-#include "pipe/p_defines.h"
-#include "pipe/p_screen.h"
-
-#include "st_context.h"
-#include "st_extensions.h"
-
-
-static int _min(int a, int b)
-{
-   return (a < b) ? a : b;
-}
-
-static float _maxf(float a, float b)
-{
-   return (a > b) ? a : b;
-}
-
-static int _clamp(int a, int min, int max)
-{
-   if (a < min)
-      return min;
-   else if (a > max)
-      return max;
-   else
-      return a;
-}
-
-
-/**
- * Query driver to get implementation limits.
- * Note that we have to limit/clamp against Mesa's internal limits too.
- */
-void st_init_limits(struct st_context *st)
-{
-   struct pipe_screen *screen = st->pipe->screen;
-   struct gl_constants *c = &st->ctx->Const;
-   gl_shader_type sh;
-
-   c->MaxTextureLevels
-      = _min(screen->get_param(screen, PIPE_CAP_MAX_TEXTURE_2D_LEVELS),
-            MAX_TEXTURE_LEVELS);
-
-   c->Max3DTextureLevels
-      = _min(screen->get_param(screen, PIPE_CAP_MAX_TEXTURE_3D_LEVELS),
-            MAX_3D_TEXTURE_LEVELS);
-
-   c->MaxCubeTextureLevels
-      = _min(screen->get_param(screen, PIPE_CAP_MAX_TEXTURE_CUBE_LEVELS),
-            MAX_CUBE_TEXTURE_LEVELS);
-
-   c->MaxTextureRectSize
-      = _min(1 << (c->MaxTextureLevels - 1), MAX_TEXTURE_RECT_SIZE);
-
-   c->MaxTextureImageUnits
-      = _min(screen->get_param(screen, PIPE_CAP_MAX_TEXTURE_IMAGE_UNITS),
-            MAX_TEXTURE_IMAGE_UNITS);
-
-   c->MaxVertexTextureImageUnits
-      = _min(screen->get_param(screen, PIPE_CAP_MAX_VERTEX_TEXTURE_UNITS),
-             MAX_VERTEX_TEXTURE_IMAGE_UNITS);
-
-   c->MaxCombinedTextureImageUnits
-      = _min(screen->get_param(screen, PIPE_CAP_MAX_COMBINED_SAMPLERS),
-             MAX_COMBINED_TEXTURE_IMAGE_UNITS);
-
-   c->MaxTextureCoordUnits
-      = _min(c->MaxTextureImageUnits, MAX_TEXTURE_COORD_UNITS);
-
-   c->MaxTextureUnits = _min(c->MaxTextureImageUnits, c->MaxTextureCoordUnits);
-
-   c->MaxDrawBuffers
-      = _clamp(screen->get_param(screen, PIPE_CAP_MAX_RENDER_TARGETS),
-              1, MAX_DRAW_BUFFERS);
-
-   c->MaxLineWidth
-      = _maxf(1.0f, screen->get_paramf(screen, PIPE_CAP_MAX_LINE_WIDTH));
-   c->MaxLineWidthAA
-      = _maxf(1.0f, screen->get_paramf(screen, PIPE_CAP_MAX_LINE_WIDTH_AA));
-
-   c->MaxPointSize
-      = _maxf(1.0f, screen->get_paramf(screen, PIPE_CAP_MAX_POINT_WIDTH));
-   c->MaxPointSizeAA
-      = _maxf(1.0f, screen->get_paramf(screen, PIPE_CAP_MAX_POINT_WIDTH_AA));
-   /* called after _mesa_create_context/_mesa_init_point, fix default user
-    * settable max point size up
-    */
-   st->ctx->Point.MaxSize = MAX2(c->MaxPointSize, c->MaxPointSizeAA);
-   /* these are not queryable. Note that GL basically mandates a 1.0 minimum
-    * for non-aa sizes, but we can go down to 0.0 for aa points.
-    */
-   c->MinPointSize = 1.0f;
-   c->MinPointSizeAA = 0.0f;
-
-   c->MaxTextureMaxAnisotropy
-      = _maxf(2.0f, screen->get_paramf(screen, PIPE_CAP_MAX_TEXTURE_ANISOTROPY));
-
-   c->MaxTextureLodBias
-      = screen->get_paramf(screen, PIPE_CAP_MAX_TEXTURE_LOD_BIAS);
-
-   c->MaxDrawBuffers
-      = CLAMP(screen->get_param(screen, PIPE_CAP_MAX_RENDER_TARGETS),
-              1, MAX_DRAW_BUFFERS);
-
-   /* Quads always follow GL provoking rules. */
-   c->QuadsFollowProvokingVertexConvention = GL_FALSE;
-
-   for (sh = 0; sh < MESA_SHADER_TYPES; ++sh) {
-      struct gl_shader_compiler_options *options =
-         &st->ctx->ShaderCompilerOptions[sh];
-      struct gl_program_constants *pc;
-
-      switch (sh) {
-      case PIPE_SHADER_FRAGMENT:
-         pc = &c->FragmentProgram;
-         break;
-      case PIPE_SHADER_VERTEX:
-         pc = &c->VertexProgram;
-         break;
-      case PIPE_SHADER_GEOMETRY:
-         pc = &c->GeometryProgram;
-         break;
-      default:
-         assert(0);
-         continue;
-      }
-
-      pc->MaxNativeInstructions    = screen->get_shader_param(screen, sh, PIPE_SHADER_CAP_MAX_INSTRUCTIONS);
-      pc->MaxNativeAluInstructions = screen->get_shader_param(screen, sh, PIPE_SHADER_CAP_MAX_ALU_INSTRUCTIONS);
-      pc->MaxNativeTexInstructions = screen->get_shader_param(screen, sh, PIPE_SHADER_CAP_MAX_TEX_INSTRUCTIONS);
-      pc->MaxNativeTexIndirections = screen->get_shader_param(screen, sh, PIPE_SHADER_CAP_MAX_TEX_INDIRECTIONS);
-      pc->MaxNativeAttribs         = screen->get_shader_param(screen, sh, PIPE_SHADER_CAP_MAX_INPUTS);
-      pc->MaxNativeTemps           = screen->get_shader_param(screen, sh, PIPE_SHADER_CAP_MAX_TEMPS);
-      pc->MaxNativeAddressRegs     = screen->get_shader_param(screen, sh, PIPE_SHADER_CAP_MAX_ADDRS);
-      pc->MaxNativeParameters      = screen->get_shader_param(screen, sh, PIPE_SHADER_CAP_MAX_CONSTS);
-      pc->MaxUniformComponents     = 4 * MIN2(pc->MaxNativeParameters, MAX_UNIFORMS);
-
-      options->EmitNoNoise = TRUE;
-
-      /* TODO: make these more fine-grained if anyone needs it */
-      options->EmitNoIfs = !screen->get_shader_param(screen, sh, PIPE_SHADER_CAP_MAX_CONTROL_FLOW_DEPTH);
-      options->EmitNoLoops = !screen->get_shader_param(screen, sh, PIPE_SHADER_CAP_MAX_CONTROL_FLOW_DEPTH);
-      options->EmitNoFunctions = !screen->get_shader_param(screen, sh, PIPE_SHADER_CAP_SUBROUTINES);
-      options->EmitNoMainReturn = !screen->get_shader_param(screen, sh, PIPE_SHADER_CAP_SUBROUTINES);
-
-      options->EmitNoCont = !screen->get_shader_param(screen, sh, PIPE_SHADER_CAP_TGSI_CONT_SUPPORTED);
-
-      options->EmitNoIndirectInput = !screen->get_shader_param(screen, sh,
-                                        PIPE_SHADER_CAP_INDIRECT_INPUT_ADDR);
-      options->EmitNoIndirectOutput = !screen->get_shader_param(screen, sh,
-                                        PIPE_SHADER_CAP_INDIRECT_OUTPUT_ADDR);
-      options->EmitNoIndirectTemp = !screen->get_shader_param(screen, sh,
-                                        PIPE_SHADER_CAP_INDIRECT_TEMP_ADDR);
-      options->EmitNoIndirectUniform = !screen->get_shader_param(screen, sh,
-                                        PIPE_SHADER_CAP_INDIRECT_CONST_ADDR);
-
-      if(options->EmitNoLoops)
-         options->MaxUnrollIterations = MIN2(screen->get_shader_param(screen, sh, PIPE_SHADER_CAP_MAX_INSTRUCTIONS), 65536);
-   }
-
-   /* PIPE_CAP_MAX_FS_INPUTS specifies the number of COLORn + GENERICn inputs
-    * and is set in MaxNativeAttribs. It's always 2 colors + N generic
-    * attributes. The GLSL compiler never uses COLORn for varyings, so we
-    * subtract the 2 colors to get the maximum number of varyings (generic
-    * attributes) supported by a driver. */
-   c->MaxVarying = screen->get_shader_param(screen, PIPE_SHADER_FRAGMENT, PIPE_SHADER_CAP_MAX_INPUTS) - 2;
-   c->MaxVarying = MIN2(c->MaxVarying, MAX_VARYING);
-
-   /* XXX we'll need a better query here someday */
-   if (screen->get_param(screen, PIPE_CAP_GLSL)) {
-      c->GLSLVersion = 120;
-   }
-}
-
-
-/**
- * Use pipe_screen::get_param() to query PIPE_CAP_ values to determine
- * which GL extensions are supported.
- * Quite a few extensions are always supported because they are standard
- * features or can be built on top of other gallium features.
- * Some fine tuning may still be needed.
- */
-void st_init_extensions(struct st_context *st)
-{
-   struct pipe_screen *screen = st->pipe->screen;
-   struct gl_context *ctx = st->ctx;
-
-   /*
-    * Extensions that are supported by all Gallium drivers:
-    */
-   ctx->Extensions.ARB_copy_buffer = GL_TRUE;
-   ctx->Extensions.ARB_draw_elements_base_vertex = GL_TRUE;
-   ctx->Extensions.ARB_fragment_coord_conventions = GL_TRUE;
-   ctx->Extensions.ARB_fragment_program = GL_TRUE;
-   ctx->Extensions.ARB_half_float_pixel = GL_TRUE;
-   ctx->Extensions.ARB_map_buffer_range = GL_TRUE;
-   ctx->Extensions.ARB_multisample = GL_TRUE;
-   ctx->Extensions.ARB_texture_border_clamp = GL_TRUE; /* XXX temp */
-   ctx->Extensions.ARB_texture_compression = GL_TRUE;
-   ctx->Extensions.ARB_texture_cube_map = GL_TRUE;
-   ctx->Extensions.ARB_texture_env_combine = GL_TRUE;
-   ctx->Extensions.ARB_texture_env_crossbar = GL_TRUE;
-   ctx->Extensions.ARB_texture_env_dot3 = GL_TRUE;
-   ctx->Extensions.ARB_vertex_array_object = GL_TRUE;
-   ctx->Extensions.ARB_vertex_buffer_object = GL_TRUE;
-   ctx->Extensions.ARB_vertex_program = GL_TRUE;
-   ctx->Extensions.ARB_window_pos = GL_TRUE;
-
-   ctx->Extensions.EXT_blend_color = GL_TRUE;
-   ctx->Extensions.EXT_blend_func_separate = GL_TRUE;
-   ctx->Extensions.EXT_blend_logic_op = GL_TRUE;
-   ctx->Extensions.EXT_blend_minmax = GL_TRUE;
-   ctx->Extensions.EXT_blend_subtract = GL_TRUE;
-   ctx->Extensions.EXT_framebuffer_blit = GL_TRUE;
-   ctx->Extensions.EXT_framebuffer_object = GL_TRUE;
-   ctx->Extensions.EXT_framebuffer_multisample = GL_TRUE;
-   ctx->Extensions.EXT_fog_coord = GL_TRUE;
-   ctx->Extensions.EXT_gpu_program_parameters = GL_TRUE;
-   ctx->Extensions.EXT_multi_draw_arrays = GL_TRUE;
-   ctx->Extensions.EXT_pixel_buffer_object = GL_TRUE;
-   ctx->Extensions.EXT_point_parameters = GL_TRUE;
-   ctx->Extensions.EXT_provoking_vertex = GL_TRUE;
-   ctx->Extensions.EXT_secondary_color = GL_TRUE;
-   ctx->Extensions.EXT_stencil_wrap = GL_TRUE;
-   ctx->Extensions.EXT_texture_env_add = GL_TRUE;
-   ctx->Extensions.EXT_texture_env_combine = GL_TRUE;
-   ctx->Extensions.EXT_texture_env_dot3 = GL_TRUE;
-   ctx->Extensions.EXT_texture_lod_bias = GL_TRUE;
-   ctx->Extensions.EXT_vertex_array_bgra = GL_TRUE;
-   if (ctx->API == API_OPENGLES || ctx->API == API_OPENGLES2)
-	   ctx->Extensions.EXT_texture_format_BGRA8888 = GL_TRUE;
-
-   ctx->Extensions.APPLE_vertex_array_object = GL_TRUE;
-
-   ctx->Extensions.ATI_texture_env_combine3 = GL_TRUE;
-
-   ctx->Extensions.MESA_pack_invert = GL_TRUE;
-
-   ctx->Extensions.NV_blend_square = GL_TRUE;
-   ctx->Extensions.NV_texgen_reflection = GL_TRUE;
-   ctx->Extensions.NV_texture_env_combine4 = GL_TRUE;
-   ctx->Extensions.NV_texture_rectangle = GL_TRUE;
-#if 0
-   /* possibly could support the following two */
-   ctx->Extensions.NV_vertex_program = GL_TRUE;
-   ctx->Extensions.NV_vertex_program1_1 = GL_TRUE;
-#endif
-
-#if FEATURE_OES_EGL_image
-   ctx->Extensions.OES_EGL_image = GL_TRUE;
-#endif
-#if FEATURE_OES_draw_texture
-   ctx->Extensions.OES_draw_texture = GL_TRUE;
-#endif
-
-   ctx->Extensions.SGIS_generate_mipmap = GL_TRUE;
-
-   /*
-    * Extensions that depend on the driver/hardware:
-    */
-   if (screen->get_param(screen, PIPE_CAP_MAX_RENDER_TARGETS) > 0) {
-      ctx->Extensions.ARB_draw_buffers = GL_TRUE;
-   }
-
-   if (screen->get_param(screen, PIPE_CAP_TEXTURE_SWIZZLE) > 0) {
-      ctx->Extensions.EXT_texture_swizzle = GL_TRUE;
-   }
-
-   if (screen->get_param(screen, PIPE_CAP_GLSL)) {
-      ctx->Extensions.ARB_fragment_shader = GL_TRUE;
-      ctx->Extensions.ARB_vertex_shader = GL_TRUE;
-      ctx->Extensions.ARB_shader_objects = GL_TRUE;
-      ctx->Extensions.ARB_shading_language_100 = GL_TRUE;
-      ctx->Extensions.ARB_explicit_attrib_location = GL_TRUE;
-      ctx->Extensions.EXT_separate_shader_objects = GL_TRUE;
-   }
-
-   if (screen->get_param(screen, PIPE_CAP_TEXTURE_MIRROR_REPEAT) > 0) {
-      ctx->Extensions.ARB_texture_mirrored_repeat = GL_TRUE;
-   }
-
-   if (screen->get_param(screen, PIPE_CAP_BLEND_EQUATION_SEPARATE)) {
-      ctx->Extensions.EXT_blend_equation_separate = GL_TRUE;
-   }
-
-   if (screen->get_param(screen, PIPE_CAP_TEXTURE_MIRROR_CLAMP) > 0) {
-      ctx->Extensions.EXT_texture_mirror_clamp = GL_TRUE;
-      ctx->Extensions.ATI_texture_mirror_once = GL_TRUE;
-   }
-
-   if (screen->get_param(screen, PIPE_CAP_NPOT_TEXTURES)) {
-      ctx->Extensions.ARB_texture_non_power_of_two = GL_TRUE;
-   }
-
-   if (screen->get_param(screen, PIPE_CAP_MAX_TEXTURE_IMAGE_UNITS) > 1) {
-      ctx->Extensions.ARB_multitexture = GL_TRUE;
-   }
-
-   if (screen->get_param(screen, PIPE_CAP_TWO_SIDED_STENCIL)) {
-      ctx->Extensions.ATI_separate_stencil = GL_TRUE;
-      ctx->Extensions.EXT_stencil_two_side = GL_TRUE;
-   }
-
-   if (screen->get_param(screen, PIPE_CAP_ANISOTROPIC_FILTER)) {
-      ctx->Extensions.EXT_texture_filter_anisotropic = GL_TRUE;
-   }
-
-   if (screen->get_param(screen, PIPE_CAP_POINT_SPRITE)) {
-      ctx->Extensions.ARB_point_sprite = GL_TRUE;
-      /* GL_NV_point_sprite is not supported by gallium because we don't
-       * support the GL_POINT_SPRITE_R_MODE_NV option.
-       */
-   }
-
-   if (screen->get_param(screen, PIPE_CAP_OCCLUSION_QUERY)) {
-      ctx->Extensions.ARB_occlusion_query = GL_TRUE;
-      ctx->Extensions.ARB_occlusion_query2 = GL_TRUE;
-   }
-   if (screen->get_param(screen, PIPE_CAP_TIMER_QUERY)) {
-     ctx->Extensions.EXT_timer_query = GL_TRUE;
-   }
-
-   if (screen->get_param(screen, PIPE_CAP_TEXTURE_SHADOW_MAP)) {
-      ctx->Extensions.ARB_depth_texture = GL_TRUE;
-      ctx->Extensions.ARB_fragment_program_shadow = GL_TRUE;
-      ctx->Extensions.ARB_shadow = GL_TRUE;
-      ctx->Extensions.EXT_shadow_funcs = GL_TRUE;
-      /*ctx->Extensions.ARB_shadow_ambient = GL_TRUE;*/
-   }
-
-   /* GL_EXT_packed_depth_stencil requires both the ability to render to
-    * a depth/stencil buffer and texture from depth/stencil source.
-    */
-   if (screen->is_format_supported(screen, PIPE_FORMAT_S8_USCALED_Z24_UNORM,
-                                   PIPE_TEXTURE_2D, 0,
-                                   PIPE_BIND_DEPTH_STENCIL, 0) &&
-       screen->is_format_supported(screen, PIPE_FORMAT_S8_USCALED_Z24_UNORM,
-                                   PIPE_TEXTURE_2D, 0,
-                                   PIPE_BIND_SAMPLER_VIEW, 0)) {
-      ctx->Extensions.EXT_packed_depth_stencil = GL_TRUE;
-   }
-   else if (screen->is_format_supported(screen, PIPE_FORMAT_Z24_UNORM_S8_USCALED,
-                                        PIPE_TEXTURE_2D, 0,
-                                        PIPE_BIND_DEPTH_STENCIL, 0) &&
-            screen->is_format_supported(screen, PIPE_FORMAT_Z24_UNORM_S8_USCALED,
-                                        PIPE_TEXTURE_2D, 0,
-                                        PIPE_BIND_SAMPLER_VIEW, 0)) {
-      ctx->Extensions.EXT_packed_depth_stencil = GL_TRUE;
-   }
-
-   /* sRGB support */
-   if (screen->is_format_supported(screen, PIPE_FORMAT_A8B8G8R8_SRGB,
-                                   PIPE_TEXTURE_2D, 0,
-                                   PIPE_BIND_SAMPLER_VIEW, 0) ||
-      screen->is_format_supported(screen, PIPE_FORMAT_B8G8R8A8_SRGB,
-                                   PIPE_TEXTURE_2D, 0,
-                                   PIPE_BIND_SAMPLER_VIEW, 0)) {
-      ctx->Extensions.EXT_texture_sRGB = GL_TRUE;
-      ctx->Extensions.EXT_texture_sRGB_decode = GL_TRUE;
-      if (screen->is_format_supported(screen, PIPE_FORMAT_A8B8G8R8_SRGB,
-                                   PIPE_TEXTURE_2D, 0,
-                                   PIPE_BIND_RENDER_TARGET, 0) ||
-          screen->is_format_supported(screen, PIPE_FORMAT_B8G8R8A8_SRGB,
-                                   PIPE_TEXTURE_2D, 0,
-                                   PIPE_BIND_RENDER_TARGET, 0)) {
-         ctx->Extensions.EXT_framebuffer_sRGB = GL_TRUE;
-         ctx->Const.sRGBCapable = GL_TRUE;
-      }
-   }
-
-   if (screen->is_format_supported(screen, PIPE_FORMAT_R8G8_UNORM,
-                                   PIPE_TEXTURE_2D, 0,
-                                   PIPE_BIND_SAMPLER_VIEW, 0)) {
-      ctx->Extensions.ARB_texture_rg = GL_TRUE;
-   }
-
-   /* s3tc support */
-   if (screen->is_format_supported(screen, PIPE_FORMAT_DXT5_RGBA,
-                                   PIPE_TEXTURE_2D, 0,
-                                   PIPE_BIND_SAMPLER_VIEW, 0) &&
-       ctx->Mesa_DXTn) {
-      ctx->Extensions.EXT_texture_compression_s3tc = GL_TRUE;
-      ctx->Extensions.S3_s3tc = GL_TRUE;
-   }
-
-   if (screen->is_format_supported(screen, PIPE_FORMAT_RGTC1_UNORM,
-                                   PIPE_TEXTURE_2D, 0,
-                                   PIPE_BIND_SAMPLER_VIEW, 0) &&
-       screen->is_format_supported(screen, PIPE_FORMAT_RGTC1_SNORM,
-				   PIPE_TEXTURE_2D, 0,
-                                   PIPE_BIND_SAMPLER_VIEW, 0) &&
-       screen->is_format_supported(screen, PIPE_FORMAT_RGTC2_UNORM,
-                                   PIPE_TEXTURE_2D, 0,
-                                   PIPE_BIND_SAMPLER_VIEW, 0) &&
-       screen->is_format_supported(screen, PIPE_FORMAT_RGTC2_SNORM,
-                                   PIPE_TEXTURE_2D, 0,
-                                   PIPE_BIND_SAMPLER_VIEW, 0)
-       ) {
-     ctx->Extensions.ARB_texture_compression_rgtc = GL_TRUE;
-   }
-
-   if (screen->is_format_supported(screen, PIPE_FORMAT_LATC1_UNORM,
-                                   PIPE_TEXTURE_2D, 0,
-                                   PIPE_BIND_SAMPLER_VIEW, 0) &&
-       screen->is_format_supported(screen, PIPE_FORMAT_LATC1_SNORM,
-                                   PIPE_TEXTURE_2D, 0,
-                                   PIPE_BIND_SAMPLER_VIEW, 0) &&
-       screen->is_format_supported(screen, PIPE_FORMAT_LATC2_UNORM,
-                                   PIPE_TEXTURE_2D, 0,
-                                   PIPE_BIND_SAMPLER_VIEW, 0) &&
-       screen->is_format_supported(screen, PIPE_FORMAT_LATC2_SNORM,
-                                   PIPE_TEXTURE_2D, 0,
-                                   PIPE_BIND_SAMPLER_VIEW, 0)) {
-      ctx->Extensions.EXT_texture_compression_latc = GL_TRUE;
-   }
-
-   if (screen->is_format_supported(screen, PIPE_FORMAT_LATC2_UNORM,
-                                   PIPE_TEXTURE_2D, 0,
-                                   PIPE_BIND_SAMPLER_VIEW, 0)) {
-      ctx->Extensions.ATI_texture_compression_3dc = GL_TRUE;
-   }
-
-   /* ycbcr support */
-   if (screen->is_format_supported(screen, PIPE_FORMAT_UYVY, 
-                                   PIPE_TEXTURE_2D, 0,
-                                   PIPE_BIND_SAMPLER_VIEW, 0) ||
-       screen->is_format_supported(screen, PIPE_FORMAT_YUYV, 
-                                   PIPE_TEXTURE_2D, 0,
-                                   PIPE_BIND_SAMPLER_VIEW, 0)) {
-      ctx->Extensions.MESA_ycbcr_texture = GL_TRUE;
-   }
-
-   /* GL_EXT_texture_array */
-   if (screen->get_param(screen, PIPE_CAP_ARRAY_TEXTURES)) {
-      ctx->Extensions.EXT_texture_array = GL_TRUE;
-      ctx->Extensions.MESA_texture_array = GL_TRUE;
-   }
-
-   /* GL_ARB_framebuffer_object */
-   if (ctx->Extensions.EXT_packed_depth_stencil) {
-      /* we support always support GL_EXT_framebuffer_blit */
-      ctx->Extensions.ARB_framebuffer_object = GL_TRUE;
-   }
-
-   if (st->pipe->render_condition) {
-      ctx->Extensions.NV_conditional_render = GL_TRUE;
-   }
-
-   if (screen->get_param(screen, PIPE_CAP_INDEP_BLEND_ENABLE)) {
-      ctx->Extensions.EXT_draw_buffers2 = GL_TRUE;
-   }
-
-   if (screen->get_param(screen, PIPE_CAP_INDEP_BLEND_FUNC)) {
-      ctx->Extensions.ARB_draw_buffers_blend = GL_TRUE;
-   }
-
-   /* GL_ARB_half_float_vertex */
-   if (screen->is_format_supported(screen, PIPE_FORMAT_R16G16B16A16_FLOAT,
-                                   PIPE_BUFFER, 0,
-                                   PIPE_BIND_VERTEX_BUFFER, 0)) {
-      ctx->Extensions.ARB_half_float_vertex = GL_TRUE;
-   }
-
-   if (screen->get_shader_param(screen, PIPE_SHADER_GEOMETRY, PIPE_SHADER_CAP_MAX_INSTRUCTIONS) > 0) {
-#if 0 /* XXX re-enable when GLSL compiler again supports geometry shaders */
-      ctx->Extensions.ARB_geometry_shader4 = GL_TRUE;
-#endif
-   }
-
-   if (screen->get_param(screen, PIPE_CAP_PRIMITIVE_RESTART)) {
-      ctx->Extensions.NV_primitive_restart = GL_TRUE;
-   }
-
-   if (screen->get_param(screen, PIPE_CAP_DEPTH_CLAMP)) {
-      ctx->Extensions.ARB_depth_clamp = GL_TRUE;
-   }
-
-   if (screen->get_param(screen, PIPE_CAP_SHADER_STENCIL_EXPORT)) {
-      ctx->Extensions.ARB_shader_stencil_export = GL_TRUE;
-   }
-
-   if (screen->get_param(screen, PIPE_CAP_TGSI_INSTANCEID)) {
-      ctx->Extensions.ARB_draw_instanced = GL_TRUE;
-   }
-   if (screen->get_param(screen, PIPE_CAP_VERTEX_ELEMENT_INSTANCE_DIVISOR)) {
-      ctx->Extensions.ARB_instanced_arrays = GL_TRUE;
-   }
-
-   if (screen->fence_finish) {
-      ctx->Extensions.ARB_sync = GL_TRUE;
-   }
-}
+/**************************************************************************

+ * 

+ * Copyright 2007 Tungsten Graphics, Inc., Cedar Park, Texas.

+ * Copyright (c) 2008 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, sub license, 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 (including the

+ * next paragraph) 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 NON-INFRINGEMENT.

+ * IN NO EVENT SHALL TUNGSTEN GRAPHICS AND/OR ITS SUPPLIERS 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.

+ * 

+ **************************************************************************/

+

+#include "main/imports.h"

+#include "main/context.h"

+#include "main/macros.h"

+#include "main/mfeatures.h"

+

+#include "pipe/p_context.h"

+#include "pipe/p_defines.h"

+#include "pipe/p_screen.h"

+

+#include "st_context.h"

+#include "st_extensions.h"

+

+

+static int _min(int a, int b)

+{

+   return (a < b) ? a : b;

+}

+

+static float _maxf(float a, float b)

+{

+   return (a > b) ? a : b;

+}

+

+static int _clamp(int a, int min, int max)

+{

+   if (a < min)

+      return min;

+   else if (a > max)

+      return max;

+   else

+      return a;

+}

+

+

+/**

+ * Query driver to get implementation limits.

+ * Note that we have to limit/clamp against Mesa's internal limits too.

+ */

+void st_init_limits(struct st_context *st)

+{

+   struct pipe_screen *screen = st->pipe->screen;

+   struct gl_constants *c = &st->ctx->Const;

+   gl_shader_type sh;

+

+   c->MaxTextureLevels

+      = _min(screen->get_param(screen, PIPE_CAP_MAX_TEXTURE_2D_LEVELS),

+            MAX_TEXTURE_LEVELS);

+

+   c->Max3DTextureLevels

+      = _min(screen->get_param(screen, PIPE_CAP_MAX_TEXTURE_3D_LEVELS),

+            MAX_3D_TEXTURE_LEVELS);

+

+   c->MaxCubeTextureLevels

+      = _min(screen->get_param(screen, PIPE_CAP_MAX_TEXTURE_CUBE_LEVELS),

+            MAX_CUBE_TEXTURE_LEVELS);

+

+   c->MaxTextureRectSize

+      = _min(1 << (c->MaxTextureLevels - 1), MAX_TEXTURE_RECT_SIZE);

+

+   c->MaxTextureImageUnits

+      = _min(screen->get_param(screen, PIPE_CAP_MAX_TEXTURE_IMAGE_UNITS),

+            MAX_TEXTURE_IMAGE_UNITS);

+

+   c->MaxVertexTextureImageUnits

+      = _min(screen->get_param(screen, PIPE_CAP_MAX_VERTEX_TEXTURE_UNITS),

+             MAX_VERTEX_TEXTURE_IMAGE_UNITS);

+

+   c->MaxCombinedTextureImageUnits

+      = _min(screen->get_param(screen, PIPE_CAP_MAX_COMBINED_SAMPLERS),

+             MAX_COMBINED_TEXTURE_IMAGE_UNITS);

+

+   c->MaxTextureCoordUnits

+      = _min(c->MaxTextureImageUnits, MAX_TEXTURE_COORD_UNITS);

+

+   c->MaxTextureUnits = _min(c->MaxTextureImageUnits, c->MaxTextureCoordUnits);

+

+   c->MaxDrawBuffers

+      = _clamp(screen->get_param(screen, PIPE_CAP_MAX_RENDER_TARGETS),

+              1, MAX_DRAW_BUFFERS);

+

+   c->MaxLineWidth

+      = _maxf(1.0f, screen->get_paramf(screen, PIPE_CAP_MAX_LINE_WIDTH));

+   c->MaxLineWidthAA

+      = _maxf(1.0f, screen->get_paramf(screen, PIPE_CAP_MAX_LINE_WIDTH_AA));

+

+   c->MaxPointSize

+      = _maxf(1.0f, screen->get_paramf(screen, PIPE_CAP_MAX_POINT_WIDTH));

+   c->MaxPointSizeAA

+      = _maxf(1.0f, screen->get_paramf(screen, PIPE_CAP_MAX_POINT_WIDTH_AA));

+   /* called after _mesa_create_context/_mesa_init_point, fix default user

+    * settable max point size up

+    */

+   st->ctx->Point.MaxSize = MAX2(c->MaxPointSize, c->MaxPointSizeAA);

+   /* these are not queryable. Note that GL basically mandates a 1.0 minimum

+    * for non-aa sizes, but we can go down to 0.0 for aa points.

+    */

+   c->MinPointSize = 1.0f;

+   c->MinPointSizeAA = 0.0f;

+

+   c->MaxTextureMaxAnisotropy

+      = _maxf(2.0f, screen->get_paramf(screen, PIPE_CAP_MAX_TEXTURE_ANISOTROPY));

+

+   c->MaxTextureLodBias

+      = screen->get_paramf(screen, PIPE_CAP_MAX_TEXTURE_LOD_BIAS);

+

+   c->MaxDrawBuffers

+      = CLAMP(screen->get_param(screen, PIPE_CAP_MAX_RENDER_TARGETS),

+              1, MAX_DRAW_BUFFERS);

+

+   /* Quads always follow GL provoking rules. */

+   c->QuadsFollowProvokingVertexConvention = GL_FALSE;

+

+   for (sh = 0; sh < MESA_SHADER_TYPES; ++sh) {

+      struct gl_shader_compiler_options *options =

+         &st->ctx->ShaderCompilerOptions[sh];

+      struct gl_program_constants *pc;

+

+      switch (sh) {

+      case PIPE_SHADER_FRAGMENT:

+         pc = &c->FragmentProgram;

+         break;

+      case PIPE_SHADER_VERTEX:

+         pc = &c->VertexProgram;

+         break;

+      case PIPE_SHADER_GEOMETRY:

+         pc = &c->GeometryProgram;

+         break;

+      default:

+         assert(0);

+         continue;

+      }

+

+      pc->MaxNativeInstructions    = screen->get_shader_param(screen, sh, PIPE_SHADER_CAP_MAX_INSTRUCTIONS);

+      pc->MaxNativeAluInstructions = screen->get_shader_param(screen, sh, PIPE_SHADER_CAP_MAX_ALU_INSTRUCTIONS);

+      pc->MaxNativeTexInstructions = screen->get_shader_param(screen, sh, PIPE_SHADER_CAP_MAX_TEX_INSTRUCTIONS);

+      pc->MaxNativeTexIndirections = screen->get_shader_param(screen, sh, PIPE_SHADER_CAP_MAX_TEX_INDIRECTIONS);

+      pc->MaxNativeAttribs         = screen->get_shader_param(screen, sh, PIPE_SHADER_CAP_MAX_INPUTS);

+      pc->MaxNativeTemps           = screen->get_shader_param(screen, sh, PIPE_SHADER_CAP_MAX_TEMPS);

+      pc->MaxNativeAddressRegs     = screen->get_shader_param(screen, sh, PIPE_SHADER_CAP_MAX_ADDRS);

+      pc->MaxNativeParameters      = screen->get_shader_param(screen, sh, PIPE_SHADER_CAP_MAX_CONSTS);

+      pc->MaxUniformComponents     = 4 * MIN2(pc->MaxNativeParameters, MAX_UNIFORMS);

+

+      options->EmitNoNoise = TRUE;

+

+      /* TODO: make these more fine-grained if anyone needs it */

+      options->EmitNoIfs = !screen->get_shader_param(screen, sh, PIPE_SHADER_CAP_MAX_CONTROL_FLOW_DEPTH);

+      options->EmitNoLoops = !screen->get_shader_param(screen, sh, PIPE_SHADER_CAP_MAX_CONTROL_FLOW_DEPTH);

+      options->EmitNoFunctions = !screen->get_shader_param(screen, sh, PIPE_SHADER_CAP_SUBROUTINES);

+      options->EmitNoMainReturn = !screen->get_shader_param(screen, sh, PIPE_SHADER_CAP_SUBROUTINES);

+

+      options->EmitNoCont = !screen->get_shader_param(screen, sh, PIPE_SHADER_CAP_TGSI_CONT_SUPPORTED);

+

+      options->EmitNoIndirectInput = !screen->get_shader_param(screen, sh,

+                                        PIPE_SHADER_CAP_INDIRECT_INPUT_ADDR);

+      options->EmitNoIndirectOutput = !screen->get_shader_param(screen, sh,

+                                        PIPE_SHADER_CAP_INDIRECT_OUTPUT_ADDR);

+      options->EmitNoIndirectTemp = !screen->get_shader_param(screen, sh,

+                                        PIPE_SHADER_CAP_INDIRECT_TEMP_ADDR);

+      options->EmitNoIndirectUniform = !screen->get_shader_param(screen, sh,

+                                        PIPE_SHADER_CAP_INDIRECT_CONST_ADDR);

+

+      if(options->EmitNoLoops)

+         options->MaxUnrollIterations = MIN2(screen->get_shader_param(screen, sh, PIPE_SHADER_CAP_MAX_INSTRUCTIONS), 65536);

+   }

+

+   /* PIPE_CAP_MAX_FS_INPUTS specifies the number of COLORn + GENERICn inputs

+    * and is set in MaxNativeAttribs. It's always 2 colors + N generic

+    * attributes. The GLSL compiler never uses COLORn for varyings, so we

+    * subtract the 2 colors to get the maximum number of varyings (generic

+    * attributes) supported by a driver. */

+   c->MaxVarying = screen->get_shader_param(screen, PIPE_SHADER_FRAGMENT, PIPE_SHADER_CAP_MAX_INPUTS) - 2;

+   c->MaxVarying = MIN2(c->MaxVarying, MAX_VARYING);

+

+   /* XXX we'll need a better query here someday */

+   if (screen->get_param(screen, PIPE_CAP_GLSL)) {

+      c->GLSLVersion = 120;

+   }

+}

+

+

+/**

+ * Use pipe_screen::get_param() to query PIPE_CAP_ values to determine

+ * which GL extensions are supported.

+ * Quite a few extensions are always supported because they are standard

+ * features or can be built on top of other gallium features.

+ * Some fine tuning may still be needed.

+ */

+void st_init_extensions(struct st_context *st)

+{

+   struct pipe_screen *screen = st->pipe->screen;

+   struct gl_context *ctx = st->ctx;

+

+   /*

+    * Extensions that are supported by all Gallium drivers:

+    */

+   ctx->Extensions.ARB_copy_buffer = GL_TRUE;

+   ctx->Extensions.ARB_draw_elements_base_vertex = GL_TRUE;

+   ctx->Extensions.ARB_fragment_coord_conventions = GL_TRUE;

+   ctx->Extensions.ARB_fragment_program = GL_TRUE;

+   ctx->Extensions.ARB_half_float_pixel = GL_TRUE;

+   ctx->Extensions.ARB_map_buffer_range = GL_TRUE;

+   ctx->Extensions.ARB_multisample = GL_TRUE;

+   ctx->Extensions.ARB_texture_border_clamp = GL_TRUE; /* XXX temp */

+   ctx->Extensions.ARB_texture_compression = GL_TRUE;

+   ctx->Extensions.ARB_texture_cube_map = GL_TRUE;

+   ctx->Extensions.ARB_texture_env_combine = GL_TRUE;

+   ctx->Extensions.ARB_texture_env_crossbar = GL_TRUE;

+   ctx->Extensions.ARB_texture_env_dot3 = GL_TRUE;

+   ctx->Extensions.ARB_vertex_array_object = GL_TRUE;

+   ctx->Extensions.ARB_vertex_buffer_object = GL_TRUE;

+   ctx->Extensions.ARB_vertex_program = GL_TRUE;

+   ctx->Extensions.ARB_window_pos = GL_TRUE;

+

+   ctx->Extensions.EXT_blend_color = GL_TRUE;

+   ctx->Extensions.EXT_blend_func_separate = GL_TRUE;

+   ctx->Extensions.EXT_blend_logic_op = GL_TRUE;

+   ctx->Extensions.EXT_blend_minmax = GL_TRUE;

+   ctx->Extensions.EXT_blend_subtract = GL_TRUE;

+   ctx->Extensions.EXT_framebuffer_blit = GL_TRUE;

+   ctx->Extensions.EXT_framebuffer_object = GL_TRUE;

+   ctx->Extensions.EXT_framebuffer_multisample = GL_TRUE;

+   ctx->Extensions.EXT_fog_coord = GL_TRUE;

+   ctx->Extensions.EXT_gpu_program_parameters = GL_TRUE;

+   ctx->Extensions.EXT_multi_draw_arrays = GL_TRUE;

+   ctx->Extensions.EXT_pixel_buffer_object = GL_TRUE;

+   ctx->Extensions.EXT_point_parameters = GL_TRUE;

+   ctx->Extensions.EXT_provoking_vertex = GL_TRUE;

+   ctx->Extensions.EXT_secondary_color = GL_TRUE;

+   ctx->Extensions.EXT_stencil_wrap = GL_TRUE;

+   ctx->Extensions.EXT_texture_env_add = GL_TRUE;

+   ctx->Extensions.EXT_texture_env_combine = GL_TRUE;

+   ctx->Extensions.EXT_texture_env_dot3 = GL_TRUE;

+   ctx->Extensions.EXT_texture_lod_bias = GL_TRUE;

+   ctx->Extensions.EXT_vertex_array_bgra = GL_TRUE;

+   if (ctx->API == API_OPENGLES || ctx->API == API_OPENGLES2)

+	   ctx->Extensions.EXT_texture_format_BGRA8888 = GL_TRUE;

+

+   ctx->Extensions.APPLE_vertex_array_object = GL_TRUE;

+

+   ctx->Extensions.ATI_texture_env_combine3 = GL_TRUE;

+

+   ctx->Extensions.MESA_pack_invert = GL_TRUE;

+

+   ctx->Extensions.NV_blend_square = GL_TRUE;

+   ctx->Extensions.NV_texgen_reflection = GL_TRUE;

+   ctx->Extensions.NV_texture_env_combine4 = GL_TRUE;

+   ctx->Extensions.NV_texture_rectangle = GL_TRUE;

+#if 0

+   /* possibly could support the following two */

+   ctx->Extensions.NV_vertex_program = GL_TRUE;

+   ctx->Extensions.NV_vertex_program1_1 = GL_TRUE;

+#endif

+

+#if FEATURE_OES_EGL_image

+   ctx->Extensions.OES_EGL_image = GL_TRUE;

+#endif

+#if FEATURE_OES_draw_texture

+   ctx->Extensions.OES_draw_texture = GL_TRUE;

+#endif

+

+   ctx->Extensions.SGIS_generate_mipmap = GL_TRUE;

+

+   /*

+    * Extensions that depend on the driver/hardware:

+    */

+   if (screen->get_param(screen, PIPE_CAP_MAX_RENDER_TARGETS) > 0) {

+      ctx->Extensions.ARB_draw_buffers = GL_TRUE;

+   }

+

+   if (screen->get_param(screen, PIPE_CAP_TEXTURE_SWIZZLE) > 0) {

+      ctx->Extensions.EXT_texture_swizzle = GL_TRUE;

+   }

+

+   if (screen->get_param(screen, PIPE_CAP_GLSL)) {

+      ctx->Extensions.ARB_fragment_shader = GL_TRUE;

+      ctx->Extensions.ARB_vertex_shader = GL_TRUE;

+      ctx->Extensions.ARB_shader_objects = GL_TRUE;

+      ctx->Extensions.ARB_shading_language_100 = GL_TRUE;

+      ctx->Extensions.ARB_explicit_attrib_location = GL_TRUE;

+      ctx->Extensions.EXT_separate_shader_objects = GL_TRUE;

+   }

+

+   if (screen->get_param(screen, PIPE_CAP_TEXTURE_MIRROR_REPEAT) > 0) {

+      ctx->Extensions.ARB_texture_mirrored_repeat = GL_TRUE;

+   }

+

+   if (screen->get_param(screen, PIPE_CAP_BLEND_EQUATION_SEPARATE)) {

+      ctx->Extensions.EXT_blend_equation_separate = GL_TRUE;

+   }

+

+   if (screen->get_param(screen, PIPE_CAP_TEXTURE_MIRROR_CLAMP) > 0) {

+      ctx->Extensions.EXT_texture_mirror_clamp = GL_TRUE;

+      ctx->Extensions.ATI_texture_mirror_once = GL_TRUE;

+   }

+

+   if (screen->get_param(screen, PIPE_CAP_NPOT_TEXTURES)) {

+      ctx->Extensions.ARB_texture_non_power_of_two = GL_TRUE;

+   }

+

+   if (screen->get_param(screen, PIPE_CAP_MAX_TEXTURE_IMAGE_UNITS) > 1) {

+      ctx->Extensions.ARB_multitexture = GL_TRUE;

+   }

+

+   if (screen->get_param(screen, PIPE_CAP_TWO_SIDED_STENCIL)) {

+      ctx->Extensions.ATI_separate_stencil = GL_TRUE;

+      ctx->Extensions.EXT_stencil_two_side = GL_TRUE;

+   }

+

+   if (screen->get_param(screen, PIPE_CAP_ANISOTROPIC_FILTER)) {

+      ctx->Extensions.EXT_texture_filter_anisotropic = GL_TRUE;

+   }

+

+   if (screen->get_param(screen, PIPE_CAP_POINT_SPRITE)) {

+      ctx->Extensions.ARB_point_sprite = GL_TRUE;

+      /* GL_NV_point_sprite is not supported by gallium because we don't

+       * support the GL_POINT_SPRITE_R_MODE_NV option.

+       */

+   }

+

+   if (screen->get_param(screen, PIPE_CAP_OCCLUSION_QUERY)) {

+      ctx->Extensions.ARB_occlusion_query = GL_TRUE;

+      ctx->Extensions.ARB_occlusion_query2 = GL_TRUE;

+   }

+   if (screen->get_param(screen, PIPE_CAP_TIMER_QUERY)) {

+     ctx->Extensions.EXT_timer_query = GL_TRUE;

+   }

+

+   if (screen->get_param(screen, PIPE_CAP_TEXTURE_SHADOW_MAP)) {

+      ctx->Extensions.ARB_depth_texture = GL_TRUE;

+      ctx->Extensions.ARB_fragment_program_shadow = GL_TRUE;

+      ctx->Extensions.ARB_shadow = GL_TRUE;

+      ctx->Extensions.EXT_shadow_funcs = GL_TRUE;

+      /*ctx->Extensions.ARB_shadow_ambient = GL_TRUE;*/

+   }

+

+   /* GL_EXT_packed_depth_stencil requires both the ability to render to

+    * a depth/stencil buffer and texture from depth/stencil source.

+    */

+   if (screen->is_format_supported(screen, PIPE_FORMAT_S8_USCALED_Z24_UNORM,

+                                   PIPE_TEXTURE_2D, 0,

+                                   PIPE_BIND_DEPTH_STENCIL) &&

+       screen->is_format_supported(screen, PIPE_FORMAT_S8_USCALED_Z24_UNORM,

+                                   PIPE_TEXTURE_2D, 0,

+                                   PIPE_BIND_SAMPLER_VIEW)) {

+      ctx->Extensions.EXT_packed_depth_stencil = GL_TRUE;

+   }

+   else if (screen->is_format_supported(screen, PIPE_FORMAT_Z24_UNORM_S8_USCALED,

+                                        PIPE_TEXTURE_2D, 0,

+                                        PIPE_BIND_DEPTH_STENCIL) &&

+            screen->is_format_supported(screen, PIPE_FORMAT_Z24_UNORM_S8_USCALED,

+                                        PIPE_TEXTURE_2D, 0,

+                                        PIPE_BIND_SAMPLER_VIEW)) {

+      ctx->Extensions.EXT_packed_depth_stencil = GL_TRUE;

+   }

+

+   /* sRGB support */

+   if (screen->is_format_supported(screen, PIPE_FORMAT_A8B8G8R8_SRGB,

+                                   PIPE_TEXTURE_2D, 0,

+                                   PIPE_BIND_SAMPLER_VIEW) ||

+      screen->is_format_supported(screen, PIPE_FORMAT_B8G8R8A8_SRGB,

+                                   PIPE_TEXTURE_2D, 0,

+                                   PIPE_BIND_SAMPLER_VIEW)) {

+      ctx->Extensions.EXT_texture_sRGB = GL_TRUE;

+      ctx->Extensions.EXT_texture_sRGB_decode = GL_TRUE;

+      if (screen->is_format_supported(screen, PIPE_FORMAT_A8B8G8R8_SRGB,

+                                   PIPE_TEXTURE_2D, 0,

+                                   PIPE_BIND_RENDER_TARGET) ||

+          screen->is_format_supported(screen, PIPE_FORMAT_B8G8R8A8_SRGB,

+                                   PIPE_TEXTURE_2D, 0,

+                                   PIPE_BIND_RENDER_TARGET)) {

+         ctx->Extensions.EXT_framebuffer_sRGB = GL_TRUE;

+         ctx->Const.sRGBCapable = GL_TRUE;

+      }

+   }

+

+   if (screen->is_format_supported(screen, PIPE_FORMAT_R8G8_UNORM,

+                                   PIPE_TEXTURE_2D, 0,

+                                   PIPE_BIND_SAMPLER_VIEW)) {

+      ctx->Extensions.ARB_texture_rg = GL_TRUE;

+   }

+

+   /* s3tc support */

+   if (screen->is_format_supported(screen, PIPE_FORMAT_DXT5_RGBA,

+                                   PIPE_TEXTURE_2D, 0,

+                                   PIPE_BIND_SAMPLER_VIEW) &&

+       ctx->Mesa_DXTn) {

+      ctx->Extensions.EXT_texture_compression_s3tc = GL_TRUE;

+      ctx->Extensions.S3_s3tc = GL_TRUE;

+   }

+

+   if (screen->is_format_supported(screen, PIPE_FORMAT_RGTC1_UNORM,

+                                   PIPE_TEXTURE_2D, 0,

+                                   PIPE_BIND_SAMPLER_VIEW) &&

+       screen->is_format_supported(screen, PIPE_FORMAT_RGTC1_SNORM,

+				   PIPE_TEXTURE_2D, 0,

+                                   PIPE_BIND_SAMPLER_VIEW) &&

+       screen->is_format_supported(screen, PIPE_FORMAT_RGTC2_UNORM,

+                                   PIPE_TEXTURE_2D, 0,

+                                   PIPE_BIND_SAMPLER_VIEW) &&

+       screen->is_format_supported(screen, PIPE_FORMAT_RGTC2_SNORM,

+                                   PIPE_TEXTURE_2D, 0,

+                                   PIPE_BIND_SAMPLER_VIEW)

+       ) {

+     ctx->Extensions.ARB_texture_compression_rgtc = GL_TRUE;

+   }

+

+   if (screen->is_format_supported(screen, PIPE_FORMAT_LATC1_UNORM,

+                                   PIPE_TEXTURE_2D, 0,

+                                   PIPE_BIND_SAMPLER_VIEW) &&

+       screen->is_format_supported(screen, PIPE_FORMAT_LATC1_SNORM,

+                                   PIPE_TEXTURE_2D, 0,

+                                   PIPE_BIND_SAMPLER_VIEW) &&

+       screen->is_format_supported(screen, PIPE_FORMAT_LATC2_UNORM,

+                                   PIPE_TEXTURE_2D, 0,

+                                   PIPE_BIND_SAMPLER_VIEW) &&

+       screen->is_format_supported(screen, PIPE_FORMAT_LATC2_SNORM,

+                                   PIPE_TEXTURE_2D, 0,

+                                   PIPE_BIND_SAMPLER_VIEW)) {

+      ctx->Extensions.EXT_texture_compression_latc = GL_TRUE;

+   }

+

+   if (screen->is_format_supported(screen, PIPE_FORMAT_LATC2_UNORM,

+                                   PIPE_TEXTURE_2D, 0,

+                                   PIPE_BIND_SAMPLER_VIEW)) {

+      ctx->Extensions.ATI_texture_compression_3dc = GL_TRUE;

+   }

+

+   /* ycbcr support */

+   if (screen->is_format_supported(screen, PIPE_FORMAT_UYVY, 

+                                   PIPE_TEXTURE_2D, 0,

+                                   PIPE_BIND_SAMPLER_VIEW) ||

+       screen->is_format_supported(screen, PIPE_FORMAT_YUYV, 

+                                   PIPE_TEXTURE_2D, 0,

+                                   PIPE_BIND_SAMPLER_VIEW)) {

+      ctx->Extensions.MESA_ycbcr_texture = GL_TRUE;

+   }

+

+   /* GL_EXT_texture_array */

+   if (screen->get_param(screen, PIPE_CAP_ARRAY_TEXTURES)) {

+      ctx->Extensions.EXT_texture_array = GL_TRUE;

+      ctx->Extensions.MESA_texture_array = GL_TRUE;

+   }

+

+   /* GL_ARB_framebuffer_object */

+   if (ctx->Extensions.EXT_packed_depth_stencil) {

+      /* we support always support GL_EXT_framebuffer_blit */

+      ctx->Extensions.ARB_framebuffer_object = GL_TRUE;

+   }

+

+   if (st->pipe->render_condition) {

+      ctx->Extensions.NV_conditional_render = GL_TRUE;

+   }

+

+   if (screen->get_param(screen, PIPE_CAP_INDEP_BLEND_ENABLE)) {

+      ctx->Extensions.EXT_draw_buffers2 = GL_TRUE;

+   }

+

+   if (screen->get_param(screen, PIPE_CAP_INDEP_BLEND_FUNC)) {

+      ctx->Extensions.ARB_draw_buffers_blend = GL_TRUE;

+   }

+

+   /* GL_ARB_half_float_vertex */

+   if (screen->is_format_supported(screen, PIPE_FORMAT_R16G16B16A16_FLOAT,

+                                   PIPE_BUFFER, 0,

+                                   PIPE_BIND_VERTEX_BUFFER)) {

+      ctx->Extensions.ARB_half_float_vertex = GL_TRUE;

+   }

+

+   if (screen->get_shader_param(screen, PIPE_SHADER_GEOMETRY, PIPE_SHADER_CAP_MAX_INSTRUCTIONS) > 0) {

+#if 0 /* XXX re-enable when GLSL compiler again supports geometry shaders */

+      ctx->Extensions.ARB_geometry_shader4 = GL_TRUE;

+#endif

+   }

+

+   if (screen->get_param(screen, PIPE_CAP_PRIMITIVE_RESTART)) {

+      ctx->Extensions.NV_primitive_restart = GL_TRUE;

+   }

+

+   if (screen->get_param(screen, PIPE_CAP_DEPTH_CLAMP)) {

+      ctx->Extensions.ARB_depth_clamp = GL_TRUE;

+   }

+

+   if (screen->get_param(screen, PIPE_CAP_SHADER_STENCIL_EXPORT)) {

+      ctx->Extensions.ARB_shader_stencil_export = GL_TRUE;

+   }

+

+   if (screen->get_param(screen, PIPE_CAP_TGSI_INSTANCEID)) {

+      ctx->Extensions.ARB_draw_instanced = GL_TRUE;

+   }

+   if (screen->get_param(screen, PIPE_CAP_VERTEX_ELEMENT_INSTANCE_DIVISOR)) {

+      ctx->Extensions.ARB_instanced_arrays = GL_TRUE;

+   }

+

+   if (screen->fence_finish) {

+      ctx->Extensions.ARB_sync = GL_TRUE;

+   }

+}

diff --git a/mesalib/src/mesa/state_tracker/st_format.c b/mesalib/src/mesa/state_tracker/st_format.c
index 6b89bae7d..0e67a6bc2 100644
--- a/mesalib/src/mesa/state_tracker/st_format.c
+++ b/mesalib/src/mesa/state_tracker/st_format.c
@@ -1,1222 +1,1184 @@
-/**************************************************************************
- * 
- * Copyright 2007 Tungsten Graphics, Inc., Cedar Park, Texas.
- * Copyright (c) 2008-2010 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, sub license, 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 (including the
- * next paragraph) 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 NON-INFRINGEMENT.
- * IN NO EVENT SHALL TUNGSTEN GRAPHICS AND/OR ITS SUPPLIERS 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.
- * 
- **************************************************************************/
-
-
-/**
- * Mesa / Gallium format conversion and format selection code.
- * \author Brian Paul
- */
-
-#include "main/imports.h"
-#include "main/context.h"
-#include "main/texstore.h"
-#include "main/image.h"
-#include "main/macros.h"
-#include "main/mfeatures.h"
-
-#include "pipe/p_context.h"
-#include "pipe/p_defines.h"
-#include "pipe/p_screen.h"
-#include "util/u_format.h"
-#include "st_context.h"
-#include "st_format.h"
-
-
-static GLuint
-format_max_bits(enum pipe_format format)
-{
-   GLuint size = util_format_get_component_bits(format, UTIL_FORMAT_COLORSPACE_RGB, 0);
-
-   size = MAX2(size, util_format_get_component_bits(format, UTIL_FORMAT_COLORSPACE_RGB, 1));
-   size = MAX2(size, util_format_get_component_bits(format, UTIL_FORMAT_COLORSPACE_RGB, 2));
-   size = MAX2(size, util_format_get_component_bits(format, UTIL_FORMAT_COLORSPACE_RGB, 3));
-   size = MAX2(size, util_format_get_component_bits(format, UTIL_FORMAT_COLORSPACE_ZS, 0));
-   size = MAX2(size, util_format_get_component_bits(format, UTIL_FORMAT_COLORSPACE_ZS, 1));
-   return size;
-}
-
-
-/**
- * Return basic GL datatype for the given gallium format.
- */
-GLenum
-st_format_datatype(enum pipe_format format)
-{
-   const struct util_format_description *desc;
-
-   desc = util_format_description(format);
-   assert(desc);
-
-   if (desc->layout == UTIL_FORMAT_LAYOUT_PLAIN) {
-      if (format == PIPE_FORMAT_B5G5R5A1_UNORM ||
-          format == PIPE_FORMAT_B5G6R5_UNORM) {
-         return GL_UNSIGNED_SHORT;
-      }
-      else if (format == PIPE_FORMAT_Z24_UNORM_S8_USCALED ||
-               format == PIPE_FORMAT_S8_USCALED_Z24_UNORM ||
-               format == PIPE_FORMAT_Z24X8_UNORM ||
-               format == PIPE_FORMAT_X8Z24_UNORM) {
-         return GL_UNSIGNED_INT_24_8;
-      }
-      else {
-         const GLuint size = format_max_bits(format);
-         if (size == 8) {
-            if (desc->channel[0].type == UTIL_FORMAT_TYPE_UNSIGNED)
-               return GL_UNSIGNED_BYTE;
-            else
-               return GL_BYTE;
-         }
-         else if (size == 16) {
-            if (desc->channel[0].type == UTIL_FORMAT_TYPE_UNSIGNED)
-               return GL_UNSIGNED_SHORT;
-            else
-               return GL_SHORT;
-         }
-         else {
-            assert( size <= 32 );
-            if (desc->channel[0].type == UTIL_FORMAT_TYPE_UNSIGNED)
-               return GL_UNSIGNED_INT;
-            else
-               return GL_INT;
-         }
-      }
-   }
-   else if (format == PIPE_FORMAT_UYVY) {
-      return GL_UNSIGNED_SHORT;
-   }
-   else if (format == PIPE_FORMAT_YUYV) {
-      return GL_UNSIGNED_SHORT;
-   }
-   else {
-      /* probably a compressed format, unsupported anyway */
-      return GL_NONE;
-   }
-}
-
-
-/**
- * Translate Mesa format to Gallium format.
- */
-enum pipe_format
-st_mesa_format_to_pipe_format(gl_format mesaFormat)
-{
-   switch (mesaFormat) {
-   case MESA_FORMAT_RGBA8888:
-      return PIPE_FORMAT_A8B8G8R8_UNORM;
-   case MESA_FORMAT_RGBA8888_REV:
-      return PIPE_FORMAT_R8G8B8A8_UNORM;
-   case MESA_FORMAT_ARGB8888:
-      return PIPE_FORMAT_B8G8R8A8_UNORM;
-   case MESA_FORMAT_ARGB8888_REV:
-      return PIPE_FORMAT_A8R8G8B8_UNORM;
-   case MESA_FORMAT_XRGB8888:
-      return PIPE_FORMAT_B8G8R8X8_UNORM;
-   case MESA_FORMAT_XRGB8888_REV:
-      return PIPE_FORMAT_X8R8G8B8_UNORM;
-   case MESA_FORMAT_ARGB1555:
-      return PIPE_FORMAT_B5G5R5A1_UNORM;
-   case MESA_FORMAT_ARGB4444:
-      return PIPE_FORMAT_B4G4R4A4_UNORM;
-   case MESA_FORMAT_RGB565:
-      return PIPE_FORMAT_B5G6R5_UNORM;
-   case MESA_FORMAT_RGB332:
-      return PIPE_FORMAT_B2G3R3_UNORM;
-   case MESA_FORMAT_ARGB2101010:
-      return PIPE_FORMAT_B10G10R10A2_UNORM;
-   case MESA_FORMAT_AL44:
-      return PIPE_FORMAT_L4A4_UNORM;
-   case MESA_FORMAT_AL88:
-      return PIPE_FORMAT_L8A8_UNORM;
-   case MESA_FORMAT_AL1616:
-      return PIPE_FORMAT_L16A16_UNORM;
-   case MESA_FORMAT_A8:
-      return PIPE_FORMAT_A8_UNORM;
-   case MESA_FORMAT_A16:
-      return PIPE_FORMAT_A16_UNORM;
-   case MESA_FORMAT_L8:
-      return PIPE_FORMAT_L8_UNORM;
-   case MESA_FORMAT_L16:
-      return PIPE_FORMAT_L16_UNORM;
-   case MESA_FORMAT_I8:
-      return PIPE_FORMAT_I8_UNORM;
-   case MESA_FORMAT_I16:
-      return PIPE_FORMAT_I16_UNORM;
-   case MESA_FORMAT_Z16:
-      return PIPE_FORMAT_Z16_UNORM;
-   case MESA_FORMAT_Z32:
-      return PIPE_FORMAT_Z32_UNORM;
-   case MESA_FORMAT_Z24_S8:
-      return PIPE_FORMAT_S8_USCALED_Z24_UNORM;
-   case MESA_FORMAT_S8_Z24:
-      return PIPE_FORMAT_Z24_UNORM_S8_USCALED;
-   case MESA_FORMAT_Z24_X8:
-      return PIPE_FORMAT_X8Z24_UNORM;
-   case MESA_FORMAT_X8_Z24:
-      return PIPE_FORMAT_Z24X8_UNORM;
-   case MESA_FORMAT_S8:
-      return PIPE_FORMAT_S8_USCALED;
-   case MESA_FORMAT_YCBCR:
-      return PIPE_FORMAT_UYVY;
-#if FEATURE_texture_s3tc
-   case MESA_FORMAT_RGB_DXT1:
-      return PIPE_FORMAT_DXT1_RGB;
-   case MESA_FORMAT_RGBA_DXT1:
-      return PIPE_FORMAT_DXT1_RGBA;
-   case MESA_FORMAT_RGBA_DXT3:
-      return PIPE_FORMAT_DXT3_RGBA;
-   case MESA_FORMAT_RGBA_DXT5:
-      return PIPE_FORMAT_DXT5_RGBA;
-#if FEATURE_EXT_texture_sRGB
-   case MESA_FORMAT_SRGB_DXT1:
-      return PIPE_FORMAT_DXT1_SRGB;
-   case MESA_FORMAT_SRGBA_DXT1:
-      return PIPE_FORMAT_DXT1_SRGBA;
-   case MESA_FORMAT_SRGBA_DXT3:
-      return PIPE_FORMAT_DXT3_SRGBA;
-   case MESA_FORMAT_SRGBA_DXT5:
-      return PIPE_FORMAT_DXT5_SRGBA;
-#endif
-#endif
-#if FEATURE_EXT_texture_sRGB
-   case MESA_FORMAT_SLA8:
-      return PIPE_FORMAT_L8A8_SRGB;
-   case MESA_FORMAT_SL8:
-      return PIPE_FORMAT_L8_SRGB;
-   case MESA_FORMAT_SRGB8:
-      return PIPE_FORMAT_R8G8B8_SRGB;
-   case MESA_FORMAT_SRGBA8:
-      return PIPE_FORMAT_A8B8G8R8_SRGB;
-   case MESA_FORMAT_SARGB8:
-      return PIPE_FORMAT_B8G8R8A8_SRGB;
-#endif
-   case MESA_FORMAT_R8:
-      return PIPE_FORMAT_R8_UNORM;
-   case MESA_FORMAT_R16:
-      return PIPE_FORMAT_R16_UNORM;
-   case MESA_FORMAT_RG88:
-      return PIPE_FORMAT_R8G8_UNORM;
-   case MESA_FORMAT_RG1616:
-      return PIPE_FORMAT_R16G16_UNORM;
-   case MESA_FORMAT_RGBA_16:
-      return PIPE_FORMAT_R16G16B16A16_UNORM;
-
-   /* signed int formats */
-   case MESA_FORMAT_RGBA_INT8:
-      return PIPE_FORMAT_R8G8B8A8_SSCALED;
-   case MESA_FORMAT_RGBA_INT16:
-      return PIPE_FORMAT_R16G16B16A16_SSCALED;
-   case MESA_FORMAT_RGBA_INT32:
-      return PIPE_FORMAT_R32G32B32A32_SSCALED;
-
-   /* unsigned int formats */
-   case MESA_FORMAT_RGBA_UINT8:
-      return PIPE_FORMAT_R8G8B8A8_USCALED;
-   case MESA_FORMAT_RGBA_UINT16:
-      return PIPE_FORMAT_R16G16B16A16_USCALED;
-   case MESA_FORMAT_RGBA_UINT32:
-      return PIPE_FORMAT_R32G32B32A32_USCALED;
-
-   case MESA_FORMAT_RED_RGTC1:
-      return PIPE_FORMAT_RGTC1_UNORM;
-   case MESA_FORMAT_SIGNED_RED_RGTC1:
-      return PIPE_FORMAT_RGTC1_SNORM;
-   case MESA_FORMAT_RG_RGTC2:
-      return PIPE_FORMAT_RGTC2_UNORM;
-   case MESA_FORMAT_SIGNED_RG_RGTC2:
-      return PIPE_FORMAT_RGTC2_SNORM;
-
-   case MESA_FORMAT_L_LATC1:
-      return PIPE_FORMAT_LATC1_UNORM;
-   case MESA_FORMAT_SIGNED_L_LATC1:
-      return PIPE_FORMAT_LATC1_SNORM;
-   case MESA_FORMAT_LA_LATC2:
-      return PIPE_FORMAT_LATC2_UNORM;
-   case MESA_FORMAT_SIGNED_LA_LATC2:
-      return PIPE_FORMAT_LATC2_SNORM;
-
-   default:
-      assert(0);
-      return PIPE_FORMAT_NONE;
-   }
-}
-
-
-/**
- * Translate Gallium format to Mesa format.
- */
-gl_format
-st_pipe_format_to_mesa_format(enum pipe_format format)
-{
-   switch (format) {
-   case PIPE_FORMAT_A8B8G8R8_UNORM:
-      return MESA_FORMAT_RGBA8888;
-   case PIPE_FORMAT_R8G8B8A8_UNORM:
-      return MESA_FORMAT_RGBA8888_REV;
-   case PIPE_FORMAT_B8G8R8A8_UNORM:
-      return MESA_FORMAT_ARGB8888;
-   case PIPE_FORMAT_A8R8G8B8_UNORM:
-      return MESA_FORMAT_ARGB8888_REV;
-   case PIPE_FORMAT_B8G8R8X8_UNORM:
-      return MESA_FORMAT_XRGB8888;
-   case PIPE_FORMAT_X8R8G8B8_UNORM:
-      return MESA_FORMAT_XRGB8888_REV;
-   case PIPE_FORMAT_B5G5R5A1_UNORM:
-      return MESA_FORMAT_ARGB1555;
-   case PIPE_FORMAT_B4G4R4A4_UNORM:
-      return MESA_FORMAT_ARGB4444;
-   case PIPE_FORMAT_B5G6R5_UNORM:
-      return MESA_FORMAT_RGB565;
-   case PIPE_FORMAT_B2G3R3_UNORM:
-      return MESA_FORMAT_RGB332;
-   case PIPE_FORMAT_B10G10R10A2_UNORM:
-      return MESA_FORMAT_ARGB2101010;
-   case PIPE_FORMAT_L4A4_UNORM:
-      return MESA_FORMAT_AL44;
-   case PIPE_FORMAT_L8A8_UNORM:
-      return MESA_FORMAT_AL88;
-   case PIPE_FORMAT_L16A16_UNORM:
-      return MESA_FORMAT_AL1616;
-   case PIPE_FORMAT_A8_UNORM:
-      return MESA_FORMAT_A8;
-   case PIPE_FORMAT_A16_UNORM:
-      return MESA_FORMAT_A16;
-   case PIPE_FORMAT_L8_UNORM:
-      return MESA_FORMAT_L8;
-   case PIPE_FORMAT_L16_UNORM:
-      return MESA_FORMAT_L16;
-   case PIPE_FORMAT_I8_UNORM:
-      return MESA_FORMAT_I8;
-   case PIPE_FORMAT_I16_UNORM:
-      return MESA_FORMAT_I16;
-   case PIPE_FORMAT_S8_USCALED:
-      return MESA_FORMAT_S8;
-
-   case PIPE_FORMAT_R16G16B16A16_UNORM:
-      return MESA_FORMAT_RGBA_16;
-   case PIPE_FORMAT_R16G16B16A16_SNORM:
-      return MESA_FORMAT_SIGNED_RGBA_16;
-
-   case PIPE_FORMAT_Z16_UNORM:
-      return MESA_FORMAT_Z16;
-   case PIPE_FORMAT_Z32_UNORM:
-      return MESA_FORMAT_Z32;
-   case PIPE_FORMAT_S8_USCALED_Z24_UNORM:
-      return MESA_FORMAT_Z24_S8;
-   case PIPE_FORMAT_X8Z24_UNORM:
-      return MESA_FORMAT_Z24_X8;
-   case PIPE_FORMAT_Z24X8_UNORM:
-      return MESA_FORMAT_X8_Z24;
-   case PIPE_FORMAT_Z24_UNORM_S8_USCALED:
-      return MESA_FORMAT_S8_Z24;
-
-   case PIPE_FORMAT_UYVY:
-      return MESA_FORMAT_YCBCR;
-   case PIPE_FORMAT_YUYV:
-      return MESA_FORMAT_YCBCR_REV;
-
-#if FEATURE_texture_s3tc
-   case PIPE_FORMAT_DXT1_RGB:
-      return MESA_FORMAT_RGB_DXT1;
-   case PIPE_FORMAT_DXT1_RGBA:
-      return MESA_FORMAT_RGBA_DXT1;
-   case PIPE_FORMAT_DXT3_RGBA:
-      return MESA_FORMAT_RGBA_DXT3;
-   case PIPE_FORMAT_DXT5_RGBA:
-      return MESA_FORMAT_RGBA_DXT5;
-#if FEATURE_EXT_texture_sRGB
-   case PIPE_FORMAT_DXT1_SRGB:
-      return MESA_FORMAT_SRGB_DXT1;
-   case PIPE_FORMAT_DXT1_SRGBA:
-      return MESA_FORMAT_SRGBA_DXT1;
-   case PIPE_FORMAT_DXT3_SRGBA:
-      return MESA_FORMAT_SRGBA_DXT3;
-   case PIPE_FORMAT_DXT5_SRGBA:
-      return MESA_FORMAT_SRGBA_DXT5;
-#endif
-#endif
-
-#if FEATURE_EXT_texture_sRGB
-   case PIPE_FORMAT_L8A8_SRGB:
-      return MESA_FORMAT_SLA8;
-   case PIPE_FORMAT_L8_SRGB:
-      return MESA_FORMAT_SL8;
-   case PIPE_FORMAT_R8G8B8_SRGB:
-      return MESA_FORMAT_SRGB8;
-   case PIPE_FORMAT_A8B8G8R8_SRGB:
-      return MESA_FORMAT_SRGBA8;
-   case PIPE_FORMAT_B8G8R8A8_SRGB:
-      return MESA_FORMAT_SARGB8;
-#endif
-
-   case PIPE_FORMAT_R8_UNORM:
-      return MESA_FORMAT_R8;
-   case PIPE_FORMAT_R16_UNORM:
-      return MESA_FORMAT_R16;
-   case PIPE_FORMAT_R8G8_UNORM:
-      return MESA_FORMAT_RG88;
-   case PIPE_FORMAT_R16G16_UNORM:
-      return MESA_FORMAT_RG1616;
-
-   /* signed int formats */
-   case PIPE_FORMAT_R8G8B8A8_SSCALED:
-      return MESA_FORMAT_RGBA_INT8;
-   case PIPE_FORMAT_R16G16B16A16_SSCALED:
-      return MESA_FORMAT_RGBA_INT16;
-   case PIPE_FORMAT_R32G32B32A32_SSCALED:
-      return MESA_FORMAT_RGBA_INT32;
-
-   /* unsigned int formats */
-   case PIPE_FORMAT_R8G8B8A8_USCALED:
-      return MESA_FORMAT_RGBA_UINT8;
-   case PIPE_FORMAT_R16G16B16A16_USCALED:
-      return MESA_FORMAT_RGBA_UINT16;
-   case PIPE_FORMAT_R32G32B32A32_USCALED:
-      return MESA_FORMAT_RGBA_UINT32;
-
-   case PIPE_FORMAT_RGTC1_UNORM:
-      return MESA_FORMAT_RED_RGTC1;
-   case PIPE_FORMAT_RGTC1_SNORM:
-      return MESA_FORMAT_SIGNED_RED_RGTC1;
-   case PIPE_FORMAT_RGTC2_UNORM:
-      return MESA_FORMAT_RG_RGTC2;
-   case PIPE_FORMAT_RGTC2_SNORM:
-      return MESA_FORMAT_SIGNED_RG_RGTC2;
-
-   case PIPE_FORMAT_LATC1_UNORM:
-      return MESA_FORMAT_L_LATC1;
-   case PIPE_FORMAT_LATC1_SNORM:
-      return MESA_FORMAT_SIGNED_L_LATC1;
-   case PIPE_FORMAT_LATC2_UNORM:
-      return MESA_FORMAT_LA_LATC2;
-   case PIPE_FORMAT_LATC2_SNORM:
-      return MESA_FORMAT_SIGNED_LA_LATC2;
-
-   default:
-      assert(0);
-      return MESA_FORMAT_NONE;
-   }
-}
-
-
-/**
- * Return first supported format from the given list.
- */
-static enum pipe_format
-find_supported_format(struct pipe_screen *screen, 
-                      const enum pipe_format formats[],
-                      uint num_formats,
-                      enum pipe_texture_target target,
-                      unsigned sample_count,
-                      unsigned tex_usage,
-                      unsigned geom_flags)
-{
-   uint i;
-   for (i = 0; i < num_formats; i++) {
-      if (screen->is_format_supported(screen, formats[i], target,
-                                      sample_count, tex_usage, geom_flags)) {
-         return formats[i];
-      }
-   }
-   return PIPE_FORMAT_NONE;
-}
-
-
-/**
- * Find an RGBA format supported by the context/winsys.
- */
-static enum pipe_format
-default_rgba_format(struct pipe_screen *screen, 
-                    enum pipe_texture_target target,
-                    unsigned sample_count,
-                    unsigned tex_usage,
-                    unsigned geom_flags)
-{
-   static const enum pipe_format colorFormats[] = {
-      PIPE_FORMAT_B8G8R8A8_UNORM,
-      PIPE_FORMAT_A8R8G8B8_UNORM,
-      PIPE_FORMAT_A8B8G8R8_UNORM,
-      PIPE_FORMAT_B5G6R5_UNORM
-   };
-   return find_supported_format(screen, colorFormats, Elements(colorFormats),
-                                target, sample_count, tex_usage, geom_flags);
-}
-
-
-/**
- * Find an RGB format supported by the context/winsys.
- */
-static enum pipe_format
-default_rgb_format(struct pipe_screen *screen, 
-                   enum pipe_texture_target target,
-                   unsigned sample_count,
-                   unsigned tex_usage,
-                   unsigned geom_flags)
-{
-   static const enum pipe_format colorFormats[] = {
-      PIPE_FORMAT_B8G8R8X8_UNORM,
-      PIPE_FORMAT_X8R8G8B8_UNORM,
-      PIPE_FORMAT_X8B8G8R8_UNORM,
-      PIPE_FORMAT_B8G8R8A8_UNORM,
-      PIPE_FORMAT_A8R8G8B8_UNORM,
-      PIPE_FORMAT_A8B8G8R8_UNORM,
-      PIPE_FORMAT_B5G6R5_UNORM
-   };
-   return find_supported_format(screen, colorFormats, Elements(colorFormats),
-                                target, sample_count, tex_usage, geom_flags);
-}
-
-/**
- * Find an sRGBA format supported by the context/winsys.
- */
-static enum pipe_format
-default_srgba_format(struct pipe_screen *screen, 
-                    enum pipe_texture_target target,
-                    unsigned sample_count,
-                    unsigned tex_usage,
-                    unsigned geom_flags)
-{
-   static const enum pipe_format colorFormats[] = {
-      PIPE_FORMAT_B8G8R8A8_SRGB,
-      PIPE_FORMAT_A8R8G8B8_SRGB,
-      PIPE_FORMAT_A8B8G8R8_SRGB,
-   };
-   return find_supported_format(screen, colorFormats, Elements(colorFormats),
-                                target, sample_count, tex_usage, geom_flags);
-}
-
-
-/**
- * Given an OpenGL internalFormat value for a texture or surface, return
- * the best matching PIPE_FORMAT_x, or PIPE_FORMAT_NONE if there's no match.
- * This is called during glTexImage2D, for example.
- *
- * The bindings parameter typically has PIPE_BIND_SAMPLER_VIEW set, plus
- * either PIPE_BINDING_RENDER_TARGET or PIPE_BINDING_DEPTH_STENCIL if
- * we want render-to-texture ability.
- *
- * \param internalFormat  the user value passed to glTexImage2D
- * \param target  one of PIPE_TEXTURE_x
- * \param bindings  bitmask of PIPE_BIND_x flags.
- */
-enum pipe_format
-st_choose_format(struct pipe_screen *screen, GLenum internalFormat,
-                 enum pipe_texture_target target, unsigned sample_count,
-                 unsigned bindings)
-{
-   unsigned geom_flags = 0; /* we don't care about POT vs. NPOT here, yet */
-
-   switch (internalFormat) {
-   case GL_RGB10:
-   case GL_RGB10_A2:
-      if (screen->is_format_supported( screen, PIPE_FORMAT_B10G10R10A2_UNORM,
-                                       target, sample_count, bindings,
-                                       geom_flags ))
-         return PIPE_FORMAT_B10G10R10A2_UNORM;
-      /* Pass through. */
-   case 4:
-   case GL_RGBA:
-   case GL_RGBA8:
-      return default_rgba_format( screen, target, sample_count, bindings,
-                                  geom_flags );
-
-   case GL_BGRA:
-      if (screen->is_format_supported( screen, PIPE_FORMAT_B8G8R8A8_UNORM,
-                                       target, sample_count, bindings,
-                                       geom_flags ))
-         return PIPE_FORMAT_B8G8R8A8_UNORM;
-      return default_rgba_format( screen, target, sample_count, bindings,
-                                  geom_flags );
-
-   case 3:
-   case GL_RGB:
-   case GL_RGB8:
-      return default_rgb_format( screen, target, sample_count, bindings,
-                                 geom_flags );
-
-   case GL_RGB12:
-   case GL_RGB16:
-   case GL_RGBA12:
-   case GL_RGBA16:
-      if (screen->is_format_supported( screen, PIPE_FORMAT_R16G16B16A16_UNORM,
-                                             target, sample_count, bindings,
-                                             geom_flags ))
-         return PIPE_FORMAT_R16G16B16A16_UNORM;
-      return default_rgba_format( screen, target, sample_count, bindings,
-                                  geom_flags );
-
-   case GL_RGBA4:
-   case GL_RGBA2:
-      if (screen->is_format_supported( screen, PIPE_FORMAT_B4G4R4A4_UNORM,
-                                       target, sample_count, bindings,
-                                       geom_flags ))
-         return PIPE_FORMAT_B4G4R4A4_UNORM;
-      return default_rgba_format( screen, target, sample_count, bindings,
-                                  geom_flags );
-
-   case GL_RGB5_A1:
-      if (screen->is_format_supported( screen, PIPE_FORMAT_B5G5R5A1_UNORM,
-                                       target, sample_count, bindings,
-                                       geom_flags ))
-         return PIPE_FORMAT_B5G5R5A1_UNORM;
-      return default_rgba_format( screen, target, sample_count, bindings,
-                                  geom_flags );
-
-   case GL_R3_G3_B2:
-      if (screen->is_format_supported( screen, PIPE_FORMAT_B2G3R3_UNORM,
-                                       target, sample_count, bindings,
-                                       geom_flags ))
-         return PIPE_FORMAT_B2G3R3_UNORM;
-      /* Pass through. */
-   case GL_RGB5:
-   case GL_RGB4:
-      if (screen->is_format_supported( screen, PIPE_FORMAT_B5G6R5_UNORM,
-                                       target, sample_count, bindings,
-                                       geom_flags ))
-         return PIPE_FORMAT_B5G6R5_UNORM;
-      if (screen->is_format_supported( screen, PIPE_FORMAT_B5G5R5A1_UNORM,
-                                       target, sample_count, bindings,
-                                       geom_flags ))
-         return PIPE_FORMAT_B5G5R5A1_UNORM;
-      return default_rgba_format( screen, target, sample_count, bindings,
-                                  geom_flags );
-
-   case GL_ALPHA12:
-   case GL_ALPHA16:
-      if (screen->is_format_supported( screen, PIPE_FORMAT_A16_UNORM, target,
-                                       sample_count, bindings, geom_flags ))
-         return PIPE_FORMAT_A16_UNORM;
-      /* Pass through. */
-   case GL_ALPHA:
-   case GL_ALPHA4:
-   case GL_ALPHA8:
-   case GL_COMPRESSED_ALPHA:
-      if (screen->is_format_supported( screen, PIPE_FORMAT_A8_UNORM, target,
-                                       sample_count, bindings, geom_flags ))
-         return PIPE_FORMAT_A8_UNORM;
-      return default_rgba_format( screen, target, sample_count, bindings,
-                                  geom_flags );
-
-   case GL_LUMINANCE12:
-   case GL_LUMINANCE16:
-      if (screen->is_format_supported( screen, PIPE_FORMAT_L16_UNORM, target,
-                                       sample_count, bindings, geom_flags ))
-         return PIPE_FORMAT_L16_UNORM;
-      /* Pass through. */
-   case 1:
-   case GL_LUMINANCE:
-   case GL_LUMINANCE4:
-   case GL_LUMINANCE8:
-      if (screen->is_format_supported( screen, PIPE_FORMAT_L8_UNORM, target,
-                                       sample_count, bindings, geom_flags ))
-         return PIPE_FORMAT_L8_UNORM;
-      return default_rgba_format( screen, target, sample_count, bindings,
-                                  geom_flags );
-
-   case GL_LUMINANCE12_ALPHA4:
-   case GL_LUMINANCE12_ALPHA12:
-   case GL_LUMINANCE16_ALPHA16:
-      if (screen->is_format_supported( screen, PIPE_FORMAT_L16A16_UNORM, target,
-                                       sample_count, bindings, geom_flags ))
-         return PIPE_FORMAT_L16A16_UNORM;
-      /* Pass through. */
-   case 2:
-   case GL_LUMINANCE_ALPHA:
-   case GL_LUMINANCE6_ALPHA2:
-   case GL_LUMINANCE8_ALPHA8:
-      if (screen->is_format_supported( screen, PIPE_FORMAT_L8A8_UNORM, target,
-                                       sample_count, bindings, geom_flags ))
-         return PIPE_FORMAT_L8A8_UNORM;
-      return default_rgba_format( screen, target, sample_count, bindings,
-                                  geom_flags );
-
-   case GL_LUMINANCE4_ALPHA4:
-      if (screen->is_format_supported( screen, PIPE_FORMAT_L4A4_UNORM, target,
-                                       sample_count, bindings, geom_flags ))
-         return PIPE_FORMAT_L4A4_UNORM;
-      if (screen->is_format_supported( screen, PIPE_FORMAT_L8A8_UNORM, target,
-                                       sample_count, bindings, geom_flags ))
-         return PIPE_FORMAT_L8A8_UNORM;
-      return default_rgba_format( screen, target, sample_count, bindings,
-                                  geom_flags );
-
-   case GL_INTENSITY12:
-   case GL_INTENSITY16:
-      if (screen->is_format_supported( screen, PIPE_FORMAT_I16_UNORM, target,
-                                       sample_count, bindings, geom_flags ))
-         return PIPE_FORMAT_I16_UNORM;
-      /* Pass through. */
-   case GL_INTENSITY:
-   case GL_INTENSITY4:
-   case GL_INTENSITY8:
-   case GL_COMPRESSED_INTENSITY:
-      if (screen->is_format_supported( screen, PIPE_FORMAT_I8_UNORM, target,
-                                       sample_count, bindings, geom_flags ))
-         return PIPE_FORMAT_I8_UNORM;
-      return default_rgba_format( screen, target, sample_count, bindings,
-                                  geom_flags );
-
-   case GL_YCBCR_MESA:
-      if (screen->is_format_supported(screen, PIPE_FORMAT_UYVY, target,
-                                      sample_count, bindings, geom_flags)) {
-         return PIPE_FORMAT_UYVY;
-      }
-      if (screen->is_format_supported(screen, PIPE_FORMAT_YUYV, target,
-                                      sample_count, bindings, geom_flags)) {
-         return PIPE_FORMAT_YUYV;
-      }
-      return PIPE_FORMAT_NONE;
-
-   case GL_COMPRESSED_RGB:
-      /* can only sample from compressed formats */
-      if (bindings & ~PIPE_BIND_SAMPLER_VIEW)
-         return PIPE_FORMAT_NONE;
-      else if (screen->is_format_supported(screen, PIPE_FORMAT_DXT1_RGB,
-                                           target, sample_count, bindings,
-                                           geom_flags))
-         return PIPE_FORMAT_DXT1_RGB;
-      else
-         return default_rgb_format(screen, target, sample_count, bindings,
-                                   geom_flags);
-
-   case GL_COMPRESSED_RGBA:
-      /* can only sample from compressed formats */
-      if (bindings & ~PIPE_BIND_SAMPLER_VIEW)
-         return PIPE_FORMAT_NONE;
-      else if (screen->is_format_supported(screen, PIPE_FORMAT_DXT3_RGBA,
-                                           target, sample_count, bindings,
-                                           geom_flags))
-         return PIPE_FORMAT_DXT3_RGBA;
-      else
-         return default_rgba_format(screen, target, sample_count, bindings,
-                                    geom_flags);
-
-   case GL_RGB_S3TC:
-   case GL_RGB4_S3TC:
-   case GL_COMPRESSED_RGB_S3TC_DXT1_EXT:
-      if (screen->is_format_supported(screen, PIPE_FORMAT_DXT1_RGB,
-                                      target, sample_count, bindings,
-                                      geom_flags))
-         return PIPE_FORMAT_DXT1_RGB;
-      else
-         return PIPE_FORMAT_NONE;
-
-   case GL_COMPRESSED_RGBA_S3TC_DXT1_EXT:
-      if (screen->is_format_supported(screen, PIPE_FORMAT_DXT1_RGBA,
-                                      target, sample_count, bindings,
-                                      geom_flags))
-         return PIPE_FORMAT_DXT1_RGBA;
-      else
-         return PIPE_FORMAT_NONE;
-
-   case GL_RGBA_S3TC:
-   case GL_RGBA4_S3TC:
-   case GL_COMPRESSED_RGBA_S3TC_DXT3_EXT:
-      if (screen->is_format_supported(screen, PIPE_FORMAT_DXT3_RGBA,
-                                      target, sample_count, bindings,
-                                      geom_flags))
-         return PIPE_FORMAT_DXT3_RGBA;
-      else
-         return PIPE_FORMAT_NONE;
-
-   case GL_COMPRESSED_RGBA_S3TC_DXT5_EXT:
-      if (screen->is_format_supported(screen, PIPE_FORMAT_DXT5_RGBA,
-                                      target, sample_count, bindings,
-                                      geom_flags))
-         return PIPE_FORMAT_DXT5_RGBA;
-      else
-         return PIPE_FORMAT_NONE;
-
-#if 0
-   case GL_COMPRESSED_RGB_FXT1_3DFX:
-      return PIPE_FORMAT_RGB_FXT1;
-   case GL_COMPRESSED_RGBA_FXT1_3DFX:
-      return PIPE_FORMAT_RGB_FXT1;
-#endif
-
-   case GL_DEPTH_COMPONENT16:
-      if (screen->is_format_supported(screen, PIPE_FORMAT_Z16_UNORM, target,
-                                      sample_count, bindings, geom_flags))
-         return PIPE_FORMAT_Z16_UNORM;
-      /* fall-through */
-   case GL_DEPTH_COMPONENT24:
-      if (screen->is_format_supported(screen, PIPE_FORMAT_Z24_UNORM_S8_USCALED,
-                                      target, sample_count, bindings, geom_flags))
-         return PIPE_FORMAT_Z24_UNORM_S8_USCALED;
-      if (screen->is_format_supported(screen, PIPE_FORMAT_S8_USCALED_Z24_UNORM,
-                                      target, sample_count, bindings, geom_flags))
-         return PIPE_FORMAT_S8_USCALED_Z24_UNORM;
-      /* fall-through */
-   case GL_DEPTH_COMPONENT32:
-      if (screen->is_format_supported(screen, PIPE_FORMAT_Z32_UNORM, target,
-                                      sample_count, bindings, geom_flags))
-         return PIPE_FORMAT_Z32_UNORM;
-      /* fall-through */
-   case GL_DEPTH_COMPONENT:
-      {
-         static const enum pipe_format formats[] = {
-            PIPE_FORMAT_Z32_UNORM,
-            PIPE_FORMAT_Z24_UNORM_S8_USCALED,
-            PIPE_FORMAT_S8_USCALED_Z24_UNORM,
-            PIPE_FORMAT_Z16_UNORM
-         };
-         return find_supported_format(screen, formats, Elements(formats),
-                                      target, sample_count, bindings, geom_flags);
-      }
-
-   case GL_STENCIL_INDEX:
-   case GL_STENCIL_INDEX1_EXT:
-   case GL_STENCIL_INDEX4_EXT:
-   case GL_STENCIL_INDEX8_EXT:
-   case GL_STENCIL_INDEX16_EXT:
-      {
-         static const enum pipe_format formats[] = {
-            PIPE_FORMAT_S8_USCALED,
-            PIPE_FORMAT_Z24_UNORM_S8_USCALED,
-            PIPE_FORMAT_S8_USCALED_Z24_UNORM
-         };
-         return find_supported_format(screen, formats, Elements(formats),
-                                      target, sample_count, bindings, geom_flags);
-      }
-
-   case GL_DEPTH_STENCIL_EXT:
-   case GL_DEPTH24_STENCIL8_EXT:
-      {
-         static const enum pipe_format formats[] = {
-            PIPE_FORMAT_Z24_UNORM_S8_USCALED,
-            PIPE_FORMAT_S8_USCALED_Z24_UNORM
-         };
-         return find_supported_format(screen, formats, Elements(formats),
-                                      target, sample_count, bindings, geom_flags);
-      }
-
-   case GL_SRGB_EXT:
-   case GL_SRGB8_EXT:
-   case GL_SRGB_ALPHA_EXT:
-   case GL_SRGB8_ALPHA8_EXT:
-      return default_srgba_format( screen, target, sample_count, bindings,
-                                   geom_flags );
-
-   case GL_COMPRESSED_SRGB_EXT:
-   case GL_COMPRESSED_SRGB_S3TC_DXT1_EXT:
-      if (screen->is_format_supported(screen, PIPE_FORMAT_DXT1_SRGB, target,
-                                      sample_count, bindings, geom_flags))
-         return PIPE_FORMAT_DXT1_SRGB;
-      return default_srgba_format( screen, target, sample_count, bindings,
-                                   geom_flags );
-
-   case GL_COMPRESSED_SRGB_ALPHA_S3TC_DXT1_EXT:
-      return PIPE_FORMAT_DXT1_SRGBA;
-
-   case GL_COMPRESSED_SRGB_ALPHA_EXT:
-   case GL_COMPRESSED_SRGB_ALPHA_S3TC_DXT3_EXT:
-      if (screen->is_format_supported(screen, PIPE_FORMAT_DXT3_SRGBA, target,
-                                      sample_count, bindings, geom_flags))
-         return PIPE_FORMAT_DXT3_SRGBA;
-      return default_srgba_format( screen, target, sample_count, bindings,
-                                   geom_flags );
-
-   case GL_COMPRESSED_SRGB_ALPHA_S3TC_DXT5_EXT:
-      return PIPE_FORMAT_DXT5_SRGBA;
-
-   case GL_SLUMINANCE_ALPHA_EXT:
-   case GL_SLUMINANCE8_ALPHA8_EXT:
-   case GL_COMPRESSED_SLUMINANCE_EXT:
-   case GL_COMPRESSED_SLUMINANCE_ALPHA_EXT:
-      if (screen->is_format_supported(screen, PIPE_FORMAT_L8A8_SRGB, target,
-                                      sample_count, bindings, geom_flags))
-         return PIPE_FORMAT_L8A8_SRGB;
-      return default_srgba_format( screen, target, sample_count, bindings,
-                                   geom_flags );
-
-   case GL_SLUMINANCE_EXT:
-   case GL_SLUMINANCE8_EXT:
-      if (screen->is_format_supported(screen, PIPE_FORMAT_L8_SRGB, target,
-                                      sample_count, bindings, geom_flags))
-         return PIPE_FORMAT_L8_SRGB;
-      return default_srgba_format( screen, target, sample_count, bindings,
-                                   geom_flags );
-
-   case GL_RED:
-   case GL_R8:
-      if (screen->is_format_supported(screen, PIPE_FORMAT_R8_UNORM, target,
-				      sample_count, bindings, geom_flags))
-	      return PIPE_FORMAT_R8_UNORM;
-      return PIPE_FORMAT_NONE;
-   case GL_RG:
-   case GL_RG8:
-      if (screen->is_format_supported(screen, PIPE_FORMAT_R8G8_UNORM, target,
-				      sample_count, bindings, geom_flags))
-	      return PIPE_FORMAT_R8G8_UNORM;
-      return PIPE_FORMAT_NONE;
-
-   case GL_R16:
-      if (screen->is_format_supported(screen, PIPE_FORMAT_R16_UNORM, target,
-				      sample_count, bindings, geom_flags))
-	      return PIPE_FORMAT_R16_UNORM;
-      return PIPE_FORMAT_NONE;
-
-   case GL_RG16:
-      if (screen->is_format_supported(screen, PIPE_FORMAT_R16G16_UNORM, target,
-				      sample_count, bindings, geom_flags))
-	      return PIPE_FORMAT_R16G16_UNORM;
-      return PIPE_FORMAT_NONE;
-
-   case GL_COMPRESSED_RED:
-   case GL_COMPRESSED_RED_RGTC1:
-      if (screen->is_format_supported(screen, PIPE_FORMAT_RGTC1_UNORM, target,
-				      sample_count, bindings, geom_flags))
-	      return PIPE_FORMAT_RGTC1_UNORM;
-      if (screen->is_format_supported(screen, PIPE_FORMAT_R8_UNORM, target,
-				      sample_count, bindings, geom_flags))
-	      return PIPE_FORMAT_R8_UNORM;
-      return PIPE_FORMAT_NONE;
-
-   case GL_COMPRESSED_SIGNED_RED_RGTC1:
-      if (screen->is_format_supported(screen, PIPE_FORMAT_RGTC1_SNORM, target,
-				      sample_count, bindings, geom_flags))
-	      return PIPE_FORMAT_RGTC1_SNORM;
-      return PIPE_FORMAT_NONE;
-
-   case GL_COMPRESSED_RG:
-   case GL_COMPRESSED_RG_RGTC2:
-      if (screen->is_format_supported(screen, PIPE_FORMAT_RGTC2_UNORM, target,
-				      sample_count, bindings, geom_flags))
-	      return PIPE_FORMAT_RGTC2_UNORM;
-      if (screen->is_format_supported(screen, PIPE_FORMAT_R8G8_UNORM, target,
-				      sample_count, bindings, geom_flags))
-	      return PIPE_FORMAT_R8G8_UNORM;
-      return PIPE_FORMAT_NONE;
-
-   case GL_COMPRESSED_SIGNED_RG_RGTC2:
-      if (screen->is_format_supported(screen, PIPE_FORMAT_RGTC2_SNORM, target,
-				      sample_count, bindings, geom_flags))
-	      return PIPE_FORMAT_RGTC2_SNORM;
-      return PIPE_FORMAT_NONE;
-
-   case GL_COMPRESSED_LUMINANCE:
-   case GL_COMPRESSED_LUMINANCE_LATC1_EXT:
-      if (screen->is_format_supported(screen, PIPE_FORMAT_LATC1_UNORM, target,
-                                      sample_count, bindings, geom_flags))
-              return PIPE_FORMAT_LATC1_UNORM;
-      if (screen->is_format_supported(screen, PIPE_FORMAT_L8_UNORM, target,
-                                      sample_count, bindings, geom_flags))
-              return PIPE_FORMAT_L8_UNORM;
-      return PIPE_FORMAT_NONE;
-
-   case GL_COMPRESSED_SIGNED_LUMINANCE_LATC1_EXT:
-      if (screen->is_format_supported(screen, PIPE_FORMAT_LATC1_SNORM, target,
-                                      sample_count, bindings, geom_flags))
-              return PIPE_FORMAT_LATC1_SNORM;
-      return PIPE_FORMAT_NONE;
-
-   case GL_COMPRESSED_LUMINANCE_ALPHA:
-   case GL_COMPRESSED_LUMINANCE_ALPHA_LATC2_EXT:
-   case GL_COMPRESSED_LUMINANCE_ALPHA_3DC_ATI:
-      if (screen->is_format_supported(screen, PIPE_FORMAT_LATC2_UNORM, target,
-                                      sample_count, bindings, geom_flags))
-              return PIPE_FORMAT_LATC2_UNORM;
-      if (screen->is_format_supported(screen, PIPE_FORMAT_L8A8_UNORM, target,
-                                      sample_count, bindings, geom_flags))
-              return PIPE_FORMAT_L8A8_UNORM;
-      return PIPE_FORMAT_NONE;
-
-   case GL_COMPRESSED_SIGNED_LUMINANCE_ALPHA_LATC2_EXT:
-      if (screen->is_format_supported(screen, PIPE_FORMAT_LATC2_SNORM, target,
-                                      sample_count, bindings, geom_flags))
-              return PIPE_FORMAT_LATC2_SNORM;
-      return PIPE_FORMAT_NONE;
-
-   /* signed/unsigned integer formats.
-    * XXX Mesa only has formats for RGBA signed/unsigned integer formats.
-    * If/when new formats are added this code should be updated.
-    */
-   case GL_RED_INTEGER_EXT:
-   case GL_GREEN_INTEGER_EXT:
-   case GL_BLUE_INTEGER_EXT:
-   case GL_ALPHA_INTEGER_EXT:
-   case GL_RGB_INTEGER_EXT:
-   case GL_RGBA_INTEGER_EXT:
-   case GL_BGR_INTEGER_EXT:
-   case GL_BGRA_INTEGER_EXT:
-   case GL_LUMINANCE_INTEGER_EXT:
-   case GL_LUMINANCE_ALPHA_INTEGER_EXT:
-      /* fall-through */
-   case GL_RGBA8I_EXT:
-   case GL_RGB8I_EXT:
-   case GL_ALPHA8I_EXT:
-   case GL_INTENSITY8I_EXT:
-   case GL_LUMINANCE8I_EXT:
-   case GL_LUMINANCE_ALPHA8I_EXT:
-      if (screen->is_format_supported(screen, PIPE_FORMAT_R8G8B8A8_SSCALED,
-                                      target,
-				      sample_count, bindings, geom_flags))
-         return PIPE_FORMAT_R8G8B8A8_SSCALED;
-      return PIPE_FORMAT_NONE;
-   case GL_RGBA16I_EXT:
-   case GL_RGB16I_EXT:
-   case GL_ALPHA16I_EXT:
-   case GL_INTENSITY16I_EXT:
-   case GL_LUMINANCE16I_EXT:
-   case GL_LUMINANCE_ALPHA16I_EXT:
-      if (screen->is_format_supported(screen, PIPE_FORMAT_R16G16B16A16_SSCALED,
-                                      target,
-				      sample_count, bindings, geom_flags))
-         return PIPE_FORMAT_R16G16B16A16_SSCALED;
-      return PIPE_FORMAT_NONE;
-   case GL_RGBA32I_EXT:
-   case GL_RGB32I_EXT:
-   case GL_ALPHA32I_EXT:
-   case GL_INTENSITY32I_EXT:
-   case GL_LUMINANCE32I_EXT:
-   case GL_LUMINANCE_ALPHA32I_EXT:
-      /* xxx */
-      if (screen->is_format_supported(screen, PIPE_FORMAT_R32G32B32A32_SSCALED,
-                                      target,
-				      sample_count, bindings, geom_flags))
-         return PIPE_FORMAT_R32G32B32A32_SSCALED;
-      return PIPE_FORMAT_NONE;
-
-   case GL_RGBA8UI_EXT:
-   case GL_RGB8UI_EXT:
-   case GL_ALPHA8UI_EXT:
-   case GL_INTENSITY8UI_EXT:
-   case GL_LUMINANCE8UI_EXT:
-   case GL_LUMINANCE_ALPHA8UI_EXT:
-      if (screen->is_format_supported(screen, PIPE_FORMAT_R8G8B8A8_USCALED,
-                                      target,
-				      sample_count, bindings, geom_flags))
-         return PIPE_FORMAT_R8G8B8A8_USCALED;
-      return PIPE_FORMAT_NONE;
-
-   case GL_RGBA16UI_EXT:
-   case GL_RGB16UI_EXT:
-   case GL_ALPHA16UI_EXT:
-   case GL_INTENSITY16UI_EXT:
-   case GL_LUMINANCE16UI_EXT:
-   case GL_LUMINANCE_ALPHA16UI_EXT:
-      if (screen->is_format_supported(screen, PIPE_FORMAT_R16G16B16A16_USCALED,
-                                      target,
-				      sample_count, bindings, geom_flags))
-         return PIPE_FORMAT_R16G16B16A16_USCALED;
-      return PIPE_FORMAT_NONE;
-
-   case GL_RGBA32UI_EXT:
-   case GL_RGB32UI_EXT:
-   case GL_ALPHA32UI_EXT:
-   case GL_INTENSITY32UI_EXT:
-   case GL_LUMINANCE32UI_EXT:
-   case GL_LUMINANCE_ALPHA32UI_EXT:
-      if (screen->is_format_supported(screen, PIPE_FORMAT_R32G32B32A32_USCALED,
-                                      target,
-				      sample_count, bindings, geom_flags))
-         return PIPE_FORMAT_R32G32B32A32_USCALED;
-      return PIPE_FORMAT_NONE;
-
-   default:
-      return PIPE_FORMAT_NONE;
-   }
-}
-
-
-/**
- * Called by FBO code to choose a PIPE_FORMAT_ for drawing surfaces.
- */
-enum pipe_format
-st_choose_renderbuffer_format(struct pipe_screen *screen,
-                              GLenum internalFormat, unsigned sample_count)
-{
-   uint usage;
-   if (_mesa_is_depth_or_stencil_format(internalFormat))
-      usage = PIPE_BIND_DEPTH_STENCIL;
-   else
-      usage = PIPE_BIND_RENDER_TARGET;
-   return st_choose_format(screen, internalFormat, PIPE_TEXTURE_2D,
-                           sample_count, usage);
-}
-
-
-/**
- * Called via ctx->Driver.chooseTextureFormat().
- */
-gl_format
-st_ChooseTextureFormat_renderable(struct gl_context *ctx, GLint internalFormat,
-				  GLenum format, GLenum type, GLboolean renderable)
-{
-   struct pipe_screen *screen = st_context(ctx)->pipe->screen;
-   enum pipe_format pFormat;
-   uint bindings;
-
-   (void) format;
-   (void) type;
-
-   /* GL textures may wind up being render targets, but we don't know
-    * that in advance.  Specify potential render target flags now.
-    */
-   bindings = PIPE_BIND_SAMPLER_VIEW;
-   if (renderable == GL_TRUE) {
-      if (_mesa_is_depth_format(internalFormat) ||
-	  _mesa_is_depth_or_stencil_format(internalFormat))
-	 bindings |= PIPE_BIND_DEPTH_STENCIL;
-      else 
-	 bindings |= PIPE_BIND_RENDER_TARGET;
-   }
-
-   pFormat = st_choose_format(screen, internalFormat,
-                              PIPE_TEXTURE_2D, 0, bindings);
-
-   if (pFormat == PIPE_FORMAT_NONE) {
-      /* try choosing format again, this time without render target bindings */
-      pFormat = st_choose_format(screen, internalFormat,
-                                 PIPE_TEXTURE_2D, 0, PIPE_BIND_SAMPLER_VIEW);
-   }
-
-   if (pFormat == PIPE_FORMAT_NONE) {
-      /* no luck at all */
-      return MESA_FORMAT_NONE;
-   }
-
-   return st_pipe_format_to_mesa_format(pFormat);
-}
-
-gl_format
-st_ChooseTextureFormat(struct gl_context *ctx, GLint internalFormat,
-                       GLenum format, GLenum type)
-{
-   boolean want_renderable =
-      internalFormat == 3 || internalFormat == 4 ||
-      internalFormat == GL_RGB || internalFormat == GL_RGBA ||
-      internalFormat == GL_RGB8 || internalFormat == GL_RGBA8 ||
-      internalFormat == GL_BGRA;
-
-   return st_ChooseTextureFormat_renderable(ctx, internalFormat,
-					    format, type, want_renderable);
-}
-
-/**
- * Test if a gallium format is equivalent to a GL format/type.
- */
-GLboolean
-st_equal_formats(enum pipe_format pFormat, GLenum format, GLenum type)
-{
-   switch (pFormat) {
-   case PIPE_FORMAT_A8B8G8R8_UNORM:
-      return format == GL_RGBA && type == GL_UNSIGNED_BYTE;
-   case PIPE_FORMAT_A8R8G8B8_UNORM:
-      return format == GL_BGRA && type == GL_UNSIGNED_BYTE;
-   case PIPE_FORMAT_B5G6R5_UNORM:
-      return format == GL_RGB && type == GL_UNSIGNED_SHORT_5_6_5;
-   /* XXX more combos... */
-   default:
-      return GL_FALSE;
-   }
-}
-
-GLboolean
-st_sampler_compat_formats(enum pipe_format format1, enum pipe_format format2)
-{
-   if (format1 == format2)
-      return GL_TRUE;
-
-   if (format1 == PIPE_FORMAT_B8G8R8A8_UNORM &&
-       format2 == PIPE_FORMAT_B8G8R8X8_UNORM)
-      return GL_TRUE;
-
-   if (format1 == PIPE_FORMAT_B8G8R8X8_UNORM &&
-       format2 == PIPE_FORMAT_B8G8R8A8_UNORM)
-      return GL_TRUE;
-
-   if (format1 == PIPE_FORMAT_A8B8G8R8_UNORM &&
-       format2 == PIPE_FORMAT_X8B8G8R8_UNORM)
-      return GL_TRUE;
-
-   if (format1 == PIPE_FORMAT_X8B8G8R8_UNORM &&
-       format2 == PIPE_FORMAT_A8B8G8R8_UNORM)
-      return GL_TRUE;
-
-   if (format1 == PIPE_FORMAT_A8R8G8B8_UNORM &&
-       format2 == PIPE_FORMAT_X8R8G8B8_UNORM)
-      return GL_TRUE;
-
-   if (format1 == PIPE_FORMAT_X8R8G8B8_UNORM &&
-       format2 == PIPE_FORMAT_A8R8G8B8_UNORM)
-      return GL_TRUE;
-
-   return GL_FALSE;
-}
-
-
-
-/**
- * This is used for translating texture border color and the clear
- * color.  For example, the clear color is interpreted according to
- * the renderbuffer's base format.  For example, if clearing a
- * GL_LUMINANCE buffer, ClearColor[0] = luminance and ClearColor[1] =
- * alpha.  Similarly for texture border colors.
- */
-void
-st_translate_color(const GLfloat colorIn[4], GLenum baseFormat,
-                   GLfloat colorOut[4])
-{
-   switch (baseFormat) {
-   case GL_RED:
-      colorOut[0] = colorIn[0];
-      colorOut[1] = 0.0F;
-      colorOut[2] = 0.0F;
-      colorOut[3] = 1.0F;
-      break;
-   case GL_RG:
-      colorOut[0] = colorIn[0];
-      colorOut[1] = colorIn[1];
-      colorOut[2] = 0.0F;
-      colorOut[3] = 1.0F;
-      break;
-   case GL_RGB:
-      colorOut[0] = colorIn[0];
-      colorOut[1] = colorIn[1];
-      colorOut[2] = colorIn[2];
-      colorOut[3] = 1.0F;
-      break;
-   case GL_ALPHA:
-      colorOut[0] = colorOut[1] = colorOut[2] = 0.0;
-      colorOut[3] = colorIn[3];
-      break;
-   case GL_LUMINANCE:
-      colorOut[0] = colorOut[1] = colorOut[2] = colorIn[0];
-      colorOut[3] = 1.0;
-      break;
-   case GL_LUMINANCE_ALPHA:
-      colorOut[0] = colorOut[1] = colorOut[2] = colorIn[0];
-      colorOut[3] = colorIn[3];
-      break;
-   case GL_INTENSITY:
-      colorOut[0] = colorOut[1] = colorOut[2] = colorOut[3] = colorIn[0];
-      break;
-   default:
-      COPY_4V(colorOut, colorIn);
-   }
-}
+/**************************************************************************

+ * 

+ * Copyright 2007 Tungsten Graphics, Inc., Cedar Park, Texas.

+ * Copyright (c) 2008-2010 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, sub license, 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 (including the

+ * next paragraph) 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 NON-INFRINGEMENT.

+ * IN NO EVENT SHALL TUNGSTEN GRAPHICS AND/OR ITS SUPPLIERS 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.

+ * 

+ **************************************************************************/

+

+

+/**

+ * Mesa / Gallium format conversion and format selection code.

+ * \author Brian Paul

+ */

+

+#include "main/imports.h"

+#include "main/context.h"

+#include "main/texstore.h"

+#include "main/image.h"

+#include "main/macros.h"

+#include "main/mfeatures.h"

+

+#include "pipe/p_context.h"

+#include "pipe/p_defines.h"

+#include "pipe/p_screen.h"

+#include "util/u_format.h"

+#include "st_context.h"

+#include "st_format.h"

+

+

+static GLuint

+format_max_bits(enum pipe_format format)

+{

+   GLuint size = util_format_get_component_bits(format, UTIL_FORMAT_COLORSPACE_RGB, 0);

+

+   size = MAX2(size, util_format_get_component_bits(format, UTIL_FORMAT_COLORSPACE_RGB, 1));

+   size = MAX2(size, util_format_get_component_bits(format, UTIL_FORMAT_COLORSPACE_RGB, 2));

+   size = MAX2(size, util_format_get_component_bits(format, UTIL_FORMAT_COLORSPACE_RGB, 3));

+   size = MAX2(size, util_format_get_component_bits(format, UTIL_FORMAT_COLORSPACE_ZS, 0));

+   size = MAX2(size, util_format_get_component_bits(format, UTIL_FORMAT_COLORSPACE_ZS, 1));

+   return size;

+}

+

+

+/**

+ * Return basic GL datatype for the given gallium format.

+ */

+GLenum

+st_format_datatype(enum pipe_format format)

+{

+   const struct util_format_description *desc;

+

+   desc = util_format_description(format);

+   assert(desc);

+

+   if (desc->layout == UTIL_FORMAT_LAYOUT_PLAIN) {

+      if (format == PIPE_FORMAT_B5G5R5A1_UNORM ||

+          format == PIPE_FORMAT_B5G6R5_UNORM) {

+         return GL_UNSIGNED_SHORT;

+      }

+      else if (format == PIPE_FORMAT_Z24_UNORM_S8_USCALED ||

+               format == PIPE_FORMAT_S8_USCALED_Z24_UNORM ||

+               format == PIPE_FORMAT_Z24X8_UNORM ||

+               format == PIPE_FORMAT_X8Z24_UNORM) {

+         return GL_UNSIGNED_INT_24_8;

+      }

+      else {

+         const GLuint size = format_max_bits(format);

+         if (size == 8) {

+            if (desc->channel[0].type == UTIL_FORMAT_TYPE_UNSIGNED)

+               return GL_UNSIGNED_BYTE;

+            else

+               return GL_BYTE;

+         }

+         else if (size == 16) {

+            if (desc->channel[0].type == UTIL_FORMAT_TYPE_UNSIGNED)

+               return GL_UNSIGNED_SHORT;

+            else

+               return GL_SHORT;

+         }

+         else {

+            assert( size <= 32 );

+            if (desc->channel[0].type == UTIL_FORMAT_TYPE_UNSIGNED)

+               return GL_UNSIGNED_INT;

+            else

+               return GL_INT;

+         }

+      }

+   }

+   else if (format == PIPE_FORMAT_UYVY) {

+      return GL_UNSIGNED_SHORT;

+   }

+   else if (format == PIPE_FORMAT_YUYV) {

+      return GL_UNSIGNED_SHORT;

+   }

+   else {

+      /* probably a compressed format, unsupported anyway */

+      return GL_NONE;

+   }

+}

+

+

+/**

+ * Translate Mesa format to Gallium format.

+ */

+enum pipe_format

+st_mesa_format_to_pipe_format(gl_format mesaFormat)

+{

+   switch (mesaFormat) {

+   case MESA_FORMAT_RGBA8888:

+      return PIPE_FORMAT_A8B8G8R8_UNORM;

+   case MESA_FORMAT_RGBA8888_REV:

+      return PIPE_FORMAT_R8G8B8A8_UNORM;

+   case MESA_FORMAT_ARGB8888:

+      return PIPE_FORMAT_B8G8R8A8_UNORM;

+   case MESA_FORMAT_ARGB8888_REV:

+      return PIPE_FORMAT_A8R8G8B8_UNORM;

+   case MESA_FORMAT_XRGB8888:

+      return PIPE_FORMAT_B8G8R8X8_UNORM;

+   case MESA_FORMAT_XRGB8888_REV:

+      return PIPE_FORMAT_X8R8G8B8_UNORM;

+   case MESA_FORMAT_ARGB1555:

+      return PIPE_FORMAT_B5G5R5A1_UNORM;

+   case MESA_FORMAT_ARGB4444:

+      return PIPE_FORMAT_B4G4R4A4_UNORM;

+   case MESA_FORMAT_RGB565:

+      return PIPE_FORMAT_B5G6R5_UNORM;

+   case MESA_FORMAT_RGB332:

+      return PIPE_FORMAT_B2G3R3_UNORM;

+   case MESA_FORMAT_ARGB2101010:

+      return PIPE_FORMAT_B10G10R10A2_UNORM;

+   case MESA_FORMAT_AL44:

+      return PIPE_FORMAT_L4A4_UNORM;

+   case MESA_FORMAT_AL88:

+      return PIPE_FORMAT_L8A8_UNORM;

+   case MESA_FORMAT_AL1616:

+      return PIPE_FORMAT_L16A16_UNORM;

+   case MESA_FORMAT_A8:

+      return PIPE_FORMAT_A8_UNORM;

+   case MESA_FORMAT_A16:

+      return PIPE_FORMAT_A16_UNORM;

+   case MESA_FORMAT_L8:

+      return PIPE_FORMAT_L8_UNORM;

+   case MESA_FORMAT_L16:

+      return PIPE_FORMAT_L16_UNORM;

+   case MESA_FORMAT_I8:

+      return PIPE_FORMAT_I8_UNORM;

+   case MESA_FORMAT_I16:

+      return PIPE_FORMAT_I16_UNORM;

+   case MESA_FORMAT_Z16:

+      return PIPE_FORMAT_Z16_UNORM;

+   case MESA_FORMAT_Z32:

+      return PIPE_FORMAT_Z32_UNORM;

+   case MESA_FORMAT_Z24_S8:

+      return PIPE_FORMAT_S8_USCALED_Z24_UNORM;

+   case MESA_FORMAT_S8_Z24:

+      return PIPE_FORMAT_Z24_UNORM_S8_USCALED;

+   case MESA_FORMAT_Z24_X8:

+      return PIPE_FORMAT_X8Z24_UNORM;

+   case MESA_FORMAT_X8_Z24:

+      return PIPE_FORMAT_Z24X8_UNORM;

+   case MESA_FORMAT_S8:

+      return PIPE_FORMAT_S8_USCALED;

+   case MESA_FORMAT_YCBCR:

+      return PIPE_FORMAT_UYVY;

+#if FEATURE_texture_s3tc

+   case MESA_FORMAT_RGB_DXT1:

+      return PIPE_FORMAT_DXT1_RGB;

+   case MESA_FORMAT_RGBA_DXT1:

+      return PIPE_FORMAT_DXT1_RGBA;

+   case MESA_FORMAT_RGBA_DXT3:

+      return PIPE_FORMAT_DXT3_RGBA;

+   case MESA_FORMAT_RGBA_DXT5:

+      return PIPE_FORMAT_DXT5_RGBA;

+#if FEATURE_EXT_texture_sRGB

+   case MESA_FORMAT_SRGB_DXT1:

+      return PIPE_FORMAT_DXT1_SRGB;

+   case MESA_FORMAT_SRGBA_DXT1:

+      return PIPE_FORMAT_DXT1_SRGBA;

+   case MESA_FORMAT_SRGBA_DXT3:

+      return PIPE_FORMAT_DXT3_SRGBA;

+   case MESA_FORMAT_SRGBA_DXT5:

+      return PIPE_FORMAT_DXT5_SRGBA;

+#endif

+#endif

+#if FEATURE_EXT_texture_sRGB

+   case MESA_FORMAT_SLA8:

+      return PIPE_FORMAT_L8A8_SRGB;

+   case MESA_FORMAT_SL8:

+      return PIPE_FORMAT_L8_SRGB;

+   case MESA_FORMAT_SRGB8:

+      return PIPE_FORMAT_R8G8B8_SRGB;

+   case MESA_FORMAT_SRGBA8:

+      return PIPE_FORMAT_A8B8G8R8_SRGB;

+   case MESA_FORMAT_SARGB8:

+      return PIPE_FORMAT_B8G8R8A8_SRGB;

+#endif

+   case MESA_FORMAT_R8:

+      return PIPE_FORMAT_R8_UNORM;

+   case MESA_FORMAT_R16:

+      return PIPE_FORMAT_R16_UNORM;

+   case MESA_FORMAT_RG88:

+      return PIPE_FORMAT_R8G8_UNORM;

+   case MESA_FORMAT_RG1616:

+      return PIPE_FORMAT_R16G16_UNORM;

+   case MESA_FORMAT_RGBA_16:

+      return PIPE_FORMAT_R16G16B16A16_UNORM;

+

+   /* signed int formats */

+   case MESA_FORMAT_RGBA_INT8:

+      return PIPE_FORMAT_R8G8B8A8_SSCALED;

+   case MESA_FORMAT_RGBA_INT16:

+      return PIPE_FORMAT_R16G16B16A16_SSCALED;

+   case MESA_FORMAT_RGBA_INT32:

+      return PIPE_FORMAT_R32G32B32A32_SSCALED;

+

+   /* unsigned int formats */

+   case MESA_FORMAT_RGBA_UINT8:

+      return PIPE_FORMAT_R8G8B8A8_USCALED;

+   case MESA_FORMAT_RGBA_UINT16:

+      return PIPE_FORMAT_R16G16B16A16_USCALED;

+   case MESA_FORMAT_RGBA_UINT32:

+      return PIPE_FORMAT_R32G32B32A32_USCALED;

+

+   case MESA_FORMAT_RED_RGTC1:

+      return PIPE_FORMAT_RGTC1_UNORM;

+   case MESA_FORMAT_SIGNED_RED_RGTC1:

+      return PIPE_FORMAT_RGTC1_SNORM;

+   case MESA_FORMAT_RG_RGTC2:

+      return PIPE_FORMAT_RGTC2_UNORM;

+   case MESA_FORMAT_SIGNED_RG_RGTC2:

+      return PIPE_FORMAT_RGTC2_SNORM;

+

+   case MESA_FORMAT_L_LATC1:

+      return PIPE_FORMAT_LATC1_UNORM;

+   case MESA_FORMAT_SIGNED_L_LATC1:

+      return PIPE_FORMAT_LATC1_SNORM;

+   case MESA_FORMAT_LA_LATC2:

+      return PIPE_FORMAT_LATC2_UNORM;

+   case MESA_FORMAT_SIGNED_LA_LATC2:

+      return PIPE_FORMAT_LATC2_SNORM;

+

+   default:

+      assert(0);

+      return PIPE_FORMAT_NONE;

+   }

+}

+

+

+/**

+ * Translate Gallium format to Mesa format.

+ */

+gl_format

+st_pipe_format_to_mesa_format(enum pipe_format format)

+{

+   switch (format) {

+   case PIPE_FORMAT_A8B8G8R8_UNORM:

+      return MESA_FORMAT_RGBA8888;

+   case PIPE_FORMAT_R8G8B8A8_UNORM:

+      return MESA_FORMAT_RGBA8888_REV;

+   case PIPE_FORMAT_B8G8R8A8_UNORM:

+      return MESA_FORMAT_ARGB8888;

+   case PIPE_FORMAT_A8R8G8B8_UNORM:

+      return MESA_FORMAT_ARGB8888_REV;

+   case PIPE_FORMAT_B8G8R8X8_UNORM:

+      return MESA_FORMAT_XRGB8888;

+   case PIPE_FORMAT_X8R8G8B8_UNORM:

+      return MESA_FORMAT_XRGB8888_REV;

+   case PIPE_FORMAT_B5G5R5A1_UNORM:

+      return MESA_FORMAT_ARGB1555;

+   case PIPE_FORMAT_B4G4R4A4_UNORM:

+      return MESA_FORMAT_ARGB4444;

+   case PIPE_FORMAT_B5G6R5_UNORM:

+      return MESA_FORMAT_RGB565;

+   case PIPE_FORMAT_B2G3R3_UNORM:

+      return MESA_FORMAT_RGB332;

+   case PIPE_FORMAT_B10G10R10A2_UNORM:

+      return MESA_FORMAT_ARGB2101010;

+   case PIPE_FORMAT_L4A4_UNORM:

+      return MESA_FORMAT_AL44;

+   case PIPE_FORMAT_L8A8_UNORM:

+      return MESA_FORMAT_AL88;

+   case PIPE_FORMAT_L16A16_UNORM:

+      return MESA_FORMAT_AL1616;

+   case PIPE_FORMAT_A8_UNORM:

+      return MESA_FORMAT_A8;

+   case PIPE_FORMAT_A16_UNORM:

+      return MESA_FORMAT_A16;

+   case PIPE_FORMAT_L8_UNORM:

+      return MESA_FORMAT_L8;

+   case PIPE_FORMAT_L16_UNORM:

+      return MESA_FORMAT_L16;

+   case PIPE_FORMAT_I8_UNORM:

+      return MESA_FORMAT_I8;

+   case PIPE_FORMAT_I16_UNORM:

+      return MESA_FORMAT_I16;

+   case PIPE_FORMAT_S8_USCALED:

+      return MESA_FORMAT_S8;

+

+   case PIPE_FORMAT_R16G16B16A16_UNORM:

+      return MESA_FORMAT_RGBA_16;

+   case PIPE_FORMAT_R16G16B16A16_SNORM:

+      return MESA_FORMAT_SIGNED_RGBA_16;

+

+   case PIPE_FORMAT_Z16_UNORM:

+      return MESA_FORMAT_Z16;

+   case PIPE_FORMAT_Z32_UNORM:

+      return MESA_FORMAT_Z32;

+   case PIPE_FORMAT_S8_USCALED_Z24_UNORM:

+      return MESA_FORMAT_Z24_S8;

+   case PIPE_FORMAT_X8Z24_UNORM:

+      return MESA_FORMAT_Z24_X8;

+   case PIPE_FORMAT_Z24X8_UNORM:

+      return MESA_FORMAT_X8_Z24;

+   case PIPE_FORMAT_Z24_UNORM_S8_USCALED:

+      return MESA_FORMAT_S8_Z24;

+

+   case PIPE_FORMAT_UYVY:

+      return MESA_FORMAT_YCBCR;

+   case PIPE_FORMAT_YUYV:

+      return MESA_FORMAT_YCBCR_REV;

+

+#if FEATURE_texture_s3tc

+   case PIPE_FORMAT_DXT1_RGB:

+      return MESA_FORMAT_RGB_DXT1;

+   case PIPE_FORMAT_DXT1_RGBA:

+      return MESA_FORMAT_RGBA_DXT1;

+   case PIPE_FORMAT_DXT3_RGBA:

+      return MESA_FORMAT_RGBA_DXT3;

+   case PIPE_FORMAT_DXT5_RGBA:

+      return MESA_FORMAT_RGBA_DXT5;

+#if FEATURE_EXT_texture_sRGB

+   case PIPE_FORMAT_DXT1_SRGB:

+      return MESA_FORMAT_SRGB_DXT1;

+   case PIPE_FORMAT_DXT1_SRGBA:

+      return MESA_FORMAT_SRGBA_DXT1;

+   case PIPE_FORMAT_DXT3_SRGBA:

+      return MESA_FORMAT_SRGBA_DXT3;

+   case PIPE_FORMAT_DXT5_SRGBA:

+      return MESA_FORMAT_SRGBA_DXT5;

+#endif

+#endif

+

+#if FEATURE_EXT_texture_sRGB

+   case PIPE_FORMAT_L8A8_SRGB:

+      return MESA_FORMAT_SLA8;

+   case PIPE_FORMAT_L8_SRGB:

+      return MESA_FORMAT_SL8;

+   case PIPE_FORMAT_R8G8B8_SRGB:

+      return MESA_FORMAT_SRGB8;

+   case PIPE_FORMAT_A8B8G8R8_SRGB:

+      return MESA_FORMAT_SRGBA8;

+   case PIPE_FORMAT_B8G8R8A8_SRGB:

+      return MESA_FORMAT_SARGB8;

+#endif

+

+   case PIPE_FORMAT_R8_UNORM:

+      return MESA_FORMAT_R8;

+   case PIPE_FORMAT_R16_UNORM:

+      return MESA_FORMAT_R16;

+   case PIPE_FORMAT_R8G8_UNORM:

+      return MESA_FORMAT_RG88;

+   case PIPE_FORMAT_R16G16_UNORM:

+      return MESA_FORMAT_RG1616;

+

+   /* signed int formats */

+   case PIPE_FORMAT_R8G8B8A8_SSCALED:

+      return MESA_FORMAT_RGBA_INT8;

+   case PIPE_FORMAT_R16G16B16A16_SSCALED:

+      return MESA_FORMAT_RGBA_INT16;

+   case PIPE_FORMAT_R32G32B32A32_SSCALED:

+      return MESA_FORMAT_RGBA_INT32;

+

+   /* unsigned int formats */

+   case PIPE_FORMAT_R8G8B8A8_USCALED:

+      return MESA_FORMAT_RGBA_UINT8;

+   case PIPE_FORMAT_R16G16B16A16_USCALED:

+      return MESA_FORMAT_RGBA_UINT16;

+   case PIPE_FORMAT_R32G32B32A32_USCALED:

+      return MESA_FORMAT_RGBA_UINT32;

+

+   case PIPE_FORMAT_RGTC1_UNORM:

+      return MESA_FORMAT_RED_RGTC1;

+   case PIPE_FORMAT_RGTC1_SNORM:

+      return MESA_FORMAT_SIGNED_RED_RGTC1;

+   case PIPE_FORMAT_RGTC2_UNORM:

+      return MESA_FORMAT_RG_RGTC2;

+   case PIPE_FORMAT_RGTC2_SNORM:

+      return MESA_FORMAT_SIGNED_RG_RGTC2;

+

+   case PIPE_FORMAT_LATC1_UNORM:

+      return MESA_FORMAT_L_LATC1;

+   case PIPE_FORMAT_LATC1_SNORM:

+      return MESA_FORMAT_SIGNED_L_LATC1;

+   case PIPE_FORMAT_LATC2_UNORM:

+      return MESA_FORMAT_LA_LATC2;

+   case PIPE_FORMAT_LATC2_SNORM:

+      return MESA_FORMAT_SIGNED_LA_LATC2;

+

+   default:

+      assert(0);

+      return MESA_FORMAT_NONE;

+   }

+}

+

+

+/**

+ * Return first supported format from the given list.

+ */

+static enum pipe_format

+find_supported_format(struct pipe_screen *screen, 

+                      const enum pipe_format formats[],

+                      uint num_formats,

+                      enum pipe_texture_target target,

+                      unsigned sample_count,

+                      unsigned tex_usage)

+{

+   uint i;

+   for (i = 0; i < num_formats; i++) {

+      if (screen->is_format_supported(screen, formats[i], target,

+                                      sample_count, tex_usage)) {

+         return formats[i];

+      }

+   }

+   return PIPE_FORMAT_NONE;

+}

+

+

+/**

+ * Find an RGBA format supported by the context/winsys.

+ */

+static enum pipe_format

+default_rgba_format(struct pipe_screen *screen, 

+                    enum pipe_texture_target target,

+                    unsigned sample_count,

+                    unsigned tex_usage)

+{

+   static const enum pipe_format colorFormats[] = {

+      PIPE_FORMAT_B8G8R8A8_UNORM,

+      PIPE_FORMAT_A8R8G8B8_UNORM,

+      PIPE_FORMAT_A8B8G8R8_UNORM,

+      PIPE_FORMAT_B5G6R5_UNORM

+   };

+   return find_supported_format(screen, colorFormats, Elements(colorFormats),

+                                target, sample_count, tex_usage);

+}

+

+

+/**

+ * Find an RGB format supported by the context/winsys.

+ */

+static enum pipe_format

+default_rgb_format(struct pipe_screen *screen, 

+                   enum pipe_texture_target target,

+                   unsigned sample_count,

+                   unsigned tex_usage)

+{

+   static const enum pipe_format colorFormats[] = {

+      PIPE_FORMAT_B8G8R8X8_UNORM,

+      PIPE_FORMAT_X8R8G8B8_UNORM,

+      PIPE_FORMAT_X8B8G8R8_UNORM,

+      PIPE_FORMAT_B8G8R8A8_UNORM,

+      PIPE_FORMAT_A8R8G8B8_UNORM,

+      PIPE_FORMAT_A8B8G8R8_UNORM,

+      PIPE_FORMAT_B5G6R5_UNORM

+   };

+   return find_supported_format(screen, colorFormats, Elements(colorFormats),

+                                target, sample_count, tex_usage);

+}

+

+/**

+ * Find an sRGBA format supported by the context/winsys.

+ */

+static enum pipe_format

+default_srgba_format(struct pipe_screen *screen, 

+                    enum pipe_texture_target target,

+                    unsigned sample_count,

+                    unsigned tex_usage)

+{

+   static const enum pipe_format colorFormats[] = {

+      PIPE_FORMAT_B8G8R8A8_SRGB,

+      PIPE_FORMAT_A8R8G8B8_SRGB,

+      PIPE_FORMAT_A8B8G8R8_SRGB,

+   };

+   return find_supported_format(screen, colorFormats, Elements(colorFormats),

+                                target, sample_count, tex_usage);

+}

+

+

+/**

+ * Given an OpenGL internalFormat value for a texture or surface, return

+ * the best matching PIPE_FORMAT_x, or PIPE_FORMAT_NONE if there's no match.

+ * This is called during glTexImage2D, for example.

+ *

+ * The bindings parameter typically has PIPE_BIND_SAMPLER_VIEW set, plus

+ * either PIPE_BINDING_RENDER_TARGET or PIPE_BINDING_DEPTH_STENCIL if

+ * we want render-to-texture ability.

+ *

+ * \param internalFormat  the user value passed to glTexImage2D

+ * \param target  one of PIPE_TEXTURE_x

+ * \param bindings  bitmask of PIPE_BIND_x flags.

+ */

+enum pipe_format

+st_choose_format(struct pipe_screen *screen, GLenum internalFormat,

+                 enum pipe_texture_target target, unsigned sample_count,

+                 unsigned bindings)

+{

+

+   switch (internalFormat) {

+   case GL_RGB10:

+   case GL_RGB10_A2:

+      if (screen->is_format_supported( screen, PIPE_FORMAT_B10G10R10A2_UNORM,

+                                       target, sample_count, bindings))

+         return PIPE_FORMAT_B10G10R10A2_UNORM;

+      /* Pass through. */

+   case 4:

+   case GL_RGBA:

+   case GL_RGBA8:

+      return default_rgba_format( screen, target, sample_count, bindings);

+

+   case GL_BGRA:

+      if (screen->is_format_supported( screen, PIPE_FORMAT_B8G8R8A8_UNORM,

+                                       target, sample_count, bindings))

+         return PIPE_FORMAT_B8G8R8A8_UNORM;

+      return default_rgba_format( screen, target, sample_count, bindings);

+

+   case 3:

+   case GL_RGB:

+   case GL_RGB8:

+      return default_rgb_format( screen, target, sample_count, bindings);

+

+   case GL_RGB12:

+   case GL_RGB16:

+   case GL_RGBA12:

+   case GL_RGBA16:

+      if (screen->is_format_supported( screen, PIPE_FORMAT_R16G16B16A16_UNORM,

+                                             target, sample_count, bindings))

+         return PIPE_FORMAT_R16G16B16A16_UNORM;

+      return default_rgba_format( screen, target, sample_count, bindings);

+

+   case GL_RGBA4:

+   case GL_RGBA2:

+      if (screen->is_format_supported( screen, PIPE_FORMAT_B4G4R4A4_UNORM,

+                                       target, sample_count, bindings))

+         return PIPE_FORMAT_B4G4R4A4_UNORM;

+      return default_rgba_format( screen, target, sample_count, bindings);

+

+   case GL_RGB5_A1:

+      if (screen->is_format_supported( screen, PIPE_FORMAT_B5G5R5A1_UNORM,

+                                       target, sample_count, bindings))

+         return PIPE_FORMAT_B5G5R5A1_UNORM;

+      return default_rgba_format( screen, target, sample_count, bindings);

+

+   case GL_R3_G3_B2:

+      if (screen->is_format_supported( screen, PIPE_FORMAT_B2G3R3_UNORM,

+                                       target, sample_count, bindings))

+         return PIPE_FORMAT_B2G3R3_UNORM;

+      /* Pass through. */

+   case GL_RGB5:

+   case GL_RGB4:

+      if (screen->is_format_supported( screen, PIPE_FORMAT_B5G6R5_UNORM,

+                                       target, sample_count, bindings))

+         return PIPE_FORMAT_B5G6R5_UNORM;

+      if (screen->is_format_supported( screen, PIPE_FORMAT_B5G5R5A1_UNORM,

+                                       target, sample_count, bindings))

+         return PIPE_FORMAT_B5G5R5A1_UNORM;

+      return default_rgba_format( screen, target, sample_count, bindings);

+

+   case GL_ALPHA12:

+   case GL_ALPHA16:

+      if (screen->is_format_supported( screen, PIPE_FORMAT_A16_UNORM, target,

+                                       sample_count, bindings))

+         return PIPE_FORMAT_A16_UNORM;

+      /* Pass through. */

+   case GL_ALPHA:

+   case GL_ALPHA4:

+   case GL_ALPHA8:

+   case GL_COMPRESSED_ALPHA:

+      if (screen->is_format_supported( screen, PIPE_FORMAT_A8_UNORM, target,

+                                       sample_count, bindings))

+         return PIPE_FORMAT_A8_UNORM;

+      return default_rgba_format( screen, target, sample_count, bindings);

+

+   case GL_LUMINANCE12:

+   case GL_LUMINANCE16:

+      if (screen->is_format_supported( screen, PIPE_FORMAT_L16_UNORM, target,

+                                       sample_count, bindings))

+         return PIPE_FORMAT_L16_UNORM;

+      /* Pass through. */

+   case 1:

+   case GL_LUMINANCE:

+   case GL_LUMINANCE4:

+   case GL_LUMINANCE8:

+      if (screen->is_format_supported( screen, PIPE_FORMAT_L8_UNORM, target,

+                                       sample_count, bindings))

+         return PIPE_FORMAT_L8_UNORM;

+      return default_rgba_format( screen, target, sample_count, bindings);

+

+   case GL_LUMINANCE12_ALPHA4:

+   case GL_LUMINANCE12_ALPHA12:

+   case GL_LUMINANCE16_ALPHA16:

+      if (screen->is_format_supported( screen, PIPE_FORMAT_L16A16_UNORM, target,

+                                       sample_count, bindings))

+         return PIPE_FORMAT_L16A16_UNORM;

+      /* Pass through. */

+   case 2:

+   case GL_LUMINANCE_ALPHA:

+   case GL_LUMINANCE6_ALPHA2:

+   case GL_LUMINANCE8_ALPHA8:

+      if (screen->is_format_supported( screen, PIPE_FORMAT_L8A8_UNORM, target,

+                                       sample_count, bindings))

+         return PIPE_FORMAT_L8A8_UNORM;

+      return default_rgba_format( screen, target, sample_count, bindings);

+

+   case GL_LUMINANCE4_ALPHA4:

+      if (screen->is_format_supported( screen, PIPE_FORMAT_L4A4_UNORM, target,

+                                       sample_count, bindings))

+         return PIPE_FORMAT_L4A4_UNORM;

+      if (screen->is_format_supported( screen, PIPE_FORMAT_L8A8_UNORM, target,

+                                       sample_count, bindings))

+         return PIPE_FORMAT_L8A8_UNORM;

+      return default_rgba_format( screen, target, sample_count, bindings);

+

+   case GL_INTENSITY12:

+   case GL_INTENSITY16:

+      if (screen->is_format_supported( screen, PIPE_FORMAT_I16_UNORM, target,

+                                       sample_count, bindings))

+         return PIPE_FORMAT_I16_UNORM;

+      /* Pass through. */

+   case GL_INTENSITY:

+   case GL_INTENSITY4:

+   case GL_INTENSITY8:

+   case GL_COMPRESSED_INTENSITY:

+      if (screen->is_format_supported( screen, PIPE_FORMAT_I8_UNORM, target,

+                                       sample_count, bindings))

+         return PIPE_FORMAT_I8_UNORM;

+      return default_rgba_format( screen, target, sample_count, bindings);

+

+   case GL_YCBCR_MESA:

+      if (screen->is_format_supported(screen, PIPE_FORMAT_UYVY, target,

+                                      sample_count, bindings)) {

+         return PIPE_FORMAT_UYVY;

+      }

+      if (screen->is_format_supported(screen, PIPE_FORMAT_YUYV, target,

+                                      sample_count, bindings)) {

+         return PIPE_FORMAT_YUYV;

+      }

+      return PIPE_FORMAT_NONE;

+

+   case GL_COMPRESSED_RGB:

+      /* can only sample from compressed formats */

+      if (bindings & ~PIPE_BIND_SAMPLER_VIEW)

+         return PIPE_FORMAT_NONE;

+      else if (screen->is_format_supported(screen, PIPE_FORMAT_DXT1_RGB,

+                                           target, sample_count, bindings))

+         return PIPE_FORMAT_DXT1_RGB;

+      else

+         return default_rgb_format(screen, target, sample_count, bindings);

+

+   case GL_COMPRESSED_RGBA:

+      /* can only sample from compressed formats */

+      if (bindings & ~PIPE_BIND_SAMPLER_VIEW)

+         return PIPE_FORMAT_NONE;

+      else if (screen->is_format_supported(screen, PIPE_FORMAT_DXT3_RGBA,

+                                           target, sample_count, bindings))

+         return PIPE_FORMAT_DXT3_RGBA;

+      else

+         return default_rgba_format(screen, target, sample_count, bindings);

+

+   case GL_RGB_S3TC:

+   case GL_RGB4_S3TC:

+   case GL_COMPRESSED_RGB_S3TC_DXT1_EXT:

+      if (screen->is_format_supported(screen, PIPE_FORMAT_DXT1_RGB,

+                                      target, sample_count, bindings))

+         return PIPE_FORMAT_DXT1_RGB;

+      else

+         return PIPE_FORMAT_NONE;

+

+   case GL_COMPRESSED_RGBA_S3TC_DXT1_EXT:

+      if (screen->is_format_supported(screen, PIPE_FORMAT_DXT1_RGBA,

+                                      target, sample_count, bindings))

+         return PIPE_FORMAT_DXT1_RGBA;

+      else

+         return PIPE_FORMAT_NONE;

+

+   case GL_RGBA_S3TC:

+   case GL_RGBA4_S3TC:

+   case GL_COMPRESSED_RGBA_S3TC_DXT3_EXT:

+      if (screen->is_format_supported(screen, PIPE_FORMAT_DXT3_RGBA,

+                                      target, sample_count, bindings))

+         return PIPE_FORMAT_DXT3_RGBA;

+      else

+         return PIPE_FORMAT_NONE;

+

+   case GL_COMPRESSED_RGBA_S3TC_DXT5_EXT:

+      if (screen->is_format_supported(screen, PIPE_FORMAT_DXT5_RGBA,

+                                      target, sample_count, bindings))

+         return PIPE_FORMAT_DXT5_RGBA;

+      else

+         return PIPE_FORMAT_NONE;

+

+#if 0

+   case GL_COMPRESSED_RGB_FXT1_3DFX:

+      return PIPE_FORMAT_RGB_FXT1;

+   case GL_COMPRESSED_RGBA_FXT1_3DFX:

+      return PIPE_FORMAT_RGB_FXT1;

+#endif

+

+   case GL_DEPTH_COMPONENT16:

+      if (screen->is_format_supported(screen, PIPE_FORMAT_Z16_UNORM, target,

+                                      sample_count, bindings))

+         return PIPE_FORMAT_Z16_UNORM;

+      /* fall-through */

+   case GL_DEPTH_COMPONENT24:

+      if (screen->is_format_supported(screen, PIPE_FORMAT_Z24_UNORM_S8_USCALED,

+                                      target, sample_count, bindings))

+         return PIPE_FORMAT_Z24_UNORM_S8_USCALED;

+      if (screen->is_format_supported(screen, PIPE_FORMAT_S8_USCALED_Z24_UNORM,

+                                      target, sample_count, bindings))

+         return PIPE_FORMAT_S8_USCALED_Z24_UNORM;

+      /* fall-through */

+   case GL_DEPTH_COMPONENT32:

+      if (screen->is_format_supported(screen, PIPE_FORMAT_Z32_UNORM, target,

+                                      sample_count, bindings))

+         return PIPE_FORMAT_Z32_UNORM;

+      /* fall-through */

+   case GL_DEPTH_COMPONENT:

+      {

+         static const enum pipe_format formats[] = {

+            PIPE_FORMAT_Z32_UNORM,

+            PIPE_FORMAT_Z24_UNORM_S8_USCALED,

+            PIPE_FORMAT_S8_USCALED_Z24_UNORM,

+            PIPE_FORMAT_Z16_UNORM

+         };

+         return find_supported_format(screen, formats, Elements(formats),

+                                      target, sample_count, bindings);

+      }

+

+   case GL_STENCIL_INDEX:

+   case GL_STENCIL_INDEX1_EXT:

+   case GL_STENCIL_INDEX4_EXT:

+   case GL_STENCIL_INDEX8_EXT:

+   case GL_STENCIL_INDEX16_EXT:

+      {

+         static const enum pipe_format formats[] = {

+            PIPE_FORMAT_S8_USCALED,

+            PIPE_FORMAT_Z24_UNORM_S8_USCALED,

+            PIPE_FORMAT_S8_USCALED_Z24_UNORM

+         };

+         return find_supported_format(screen, formats, Elements(formats),

+                                      target, sample_count, bindings);

+      }

+

+   case GL_DEPTH_STENCIL_EXT:

+   case GL_DEPTH24_STENCIL8_EXT:

+      {

+         static const enum pipe_format formats[] = {

+            PIPE_FORMAT_Z24_UNORM_S8_USCALED,

+            PIPE_FORMAT_S8_USCALED_Z24_UNORM

+         };

+         return find_supported_format(screen, formats, Elements(formats),

+                                      target, sample_count, bindings);

+      }

+

+   case GL_SRGB_EXT:

+   case GL_SRGB8_EXT:

+   case GL_SRGB_ALPHA_EXT:

+   case GL_SRGB8_ALPHA8_EXT:

+      return default_srgba_format( screen, target, sample_count, bindings);

+

+   case GL_COMPRESSED_SRGB_EXT:

+   case GL_COMPRESSED_SRGB_S3TC_DXT1_EXT:

+      if (screen->is_format_supported(screen, PIPE_FORMAT_DXT1_SRGB, target,

+                                      sample_count, bindings))

+         return PIPE_FORMAT_DXT1_SRGB;

+      return default_srgba_format( screen, target, sample_count, bindings);

+

+   case GL_COMPRESSED_SRGB_ALPHA_S3TC_DXT1_EXT:

+      return PIPE_FORMAT_DXT1_SRGBA;

+

+   case GL_COMPRESSED_SRGB_ALPHA_EXT:

+   case GL_COMPRESSED_SRGB_ALPHA_S3TC_DXT3_EXT:

+      if (screen->is_format_supported(screen, PIPE_FORMAT_DXT3_SRGBA, target,

+                                      sample_count, bindings))

+         return PIPE_FORMAT_DXT3_SRGBA;

+      return default_srgba_format( screen, target, sample_count, bindings);

+

+   case GL_COMPRESSED_SRGB_ALPHA_S3TC_DXT5_EXT:

+      return PIPE_FORMAT_DXT5_SRGBA;

+

+   case GL_SLUMINANCE_ALPHA_EXT:

+   case GL_SLUMINANCE8_ALPHA8_EXT:

+   case GL_COMPRESSED_SLUMINANCE_EXT:

+   case GL_COMPRESSED_SLUMINANCE_ALPHA_EXT:

+      if (screen->is_format_supported(screen, PIPE_FORMAT_L8A8_SRGB, target,

+                                      sample_count, bindings))

+         return PIPE_FORMAT_L8A8_SRGB;

+      return default_srgba_format( screen, target, sample_count, bindings);

+

+   case GL_SLUMINANCE_EXT:

+   case GL_SLUMINANCE8_EXT:

+      if (screen->is_format_supported(screen, PIPE_FORMAT_L8_SRGB, target,

+                                      sample_count, bindings))

+         return PIPE_FORMAT_L8_SRGB;

+      return default_srgba_format( screen, target, sample_count, bindings);

+

+   case GL_RED:

+   case GL_R8:

+      if (screen->is_format_supported(screen, PIPE_FORMAT_R8_UNORM, target,

+                                      sample_count, bindings))

+	      return PIPE_FORMAT_R8_UNORM;

+      return PIPE_FORMAT_NONE;

+   case GL_RG:

+   case GL_RG8:

+      if (screen->is_format_supported(screen, PIPE_FORMAT_R8G8_UNORM, target,

+                                      sample_count, bindings))

+	      return PIPE_FORMAT_R8G8_UNORM;

+      return PIPE_FORMAT_NONE;

+

+   case GL_R16:

+      if (screen->is_format_supported(screen, PIPE_FORMAT_R16_UNORM, target,

+                                      sample_count, bindings))

+	      return PIPE_FORMAT_R16_UNORM;

+      return PIPE_FORMAT_NONE;

+

+   case GL_RG16:

+      if (screen->is_format_supported(screen, PIPE_FORMAT_R16G16_UNORM, target,

+                                      sample_count, bindings))

+	      return PIPE_FORMAT_R16G16_UNORM;

+      return PIPE_FORMAT_NONE;

+

+   case GL_COMPRESSED_RED:

+   case GL_COMPRESSED_RED_RGTC1:

+      if (screen->is_format_supported(screen, PIPE_FORMAT_RGTC1_UNORM, target,

+                                      sample_count, bindings))

+	      return PIPE_FORMAT_RGTC1_UNORM;

+      if (screen->is_format_supported(screen, PIPE_FORMAT_R8_UNORM, target,

+                                      sample_count, bindings))

+	      return PIPE_FORMAT_R8_UNORM;

+      return PIPE_FORMAT_NONE;

+

+   case GL_COMPRESSED_SIGNED_RED_RGTC1:

+      if (screen->is_format_supported(screen, PIPE_FORMAT_RGTC1_SNORM, target,

+                                      sample_count, bindings))

+	      return PIPE_FORMAT_RGTC1_SNORM;

+      return PIPE_FORMAT_NONE;

+

+   case GL_COMPRESSED_RG:

+   case GL_COMPRESSED_RG_RGTC2:

+      if (screen->is_format_supported(screen, PIPE_FORMAT_RGTC2_UNORM, target,

+                                      sample_count, bindings))

+	      return PIPE_FORMAT_RGTC2_UNORM;

+      if (screen->is_format_supported(screen, PIPE_FORMAT_R8G8_UNORM, target,

+                                      sample_count, bindings))

+	      return PIPE_FORMAT_R8G8_UNORM;

+      return PIPE_FORMAT_NONE;

+

+   case GL_COMPRESSED_SIGNED_RG_RGTC2:

+      if (screen->is_format_supported(screen, PIPE_FORMAT_RGTC2_SNORM, target,

+                                      sample_count, bindings))

+	      return PIPE_FORMAT_RGTC2_SNORM;

+      return PIPE_FORMAT_NONE;

+

+   case GL_COMPRESSED_LUMINANCE:

+   case GL_COMPRESSED_LUMINANCE_LATC1_EXT:

+      if (screen->is_format_supported(screen, PIPE_FORMAT_LATC1_UNORM, target,

+                                      sample_count, bindings))

+              return PIPE_FORMAT_LATC1_UNORM;

+      if (screen->is_format_supported(screen, PIPE_FORMAT_L8_UNORM, target,

+                                      sample_count, bindings))

+              return PIPE_FORMAT_L8_UNORM;

+      return PIPE_FORMAT_NONE;

+

+   case GL_COMPRESSED_SIGNED_LUMINANCE_LATC1_EXT:

+      if (screen->is_format_supported(screen, PIPE_FORMAT_LATC1_SNORM, target,

+                                      sample_count, bindings))

+              return PIPE_FORMAT_LATC1_SNORM;

+      return PIPE_FORMAT_NONE;

+

+   case GL_COMPRESSED_LUMINANCE_ALPHA:

+   case GL_COMPRESSED_LUMINANCE_ALPHA_LATC2_EXT:

+   case GL_COMPRESSED_LUMINANCE_ALPHA_3DC_ATI:

+      if (screen->is_format_supported(screen, PIPE_FORMAT_LATC2_UNORM, target,

+                                      sample_count, bindings))

+              return PIPE_FORMAT_LATC2_UNORM;

+      if (screen->is_format_supported(screen, PIPE_FORMAT_L8A8_UNORM, target,

+                                      sample_count, bindings))

+              return PIPE_FORMAT_L8A8_UNORM;

+      return PIPE_FORMAT_NONE;

+

+   case GL_COMPRESSED_SIGNED_LUMINANCE_ALPHA_LATC2_EXT:

+      if (screen->is_format_supported(screen, PIPE_FORMAT_LATC2_SNORM, target,

+                                      sample_count, bindings))

+              return PIPE_FORMAT_LATC2_SNORM;

+      return PIPE_FORMAT_NONE;

+

+   /* signed/unsigned integer formats.

+    * XXX Mesa only has formats for RGBA signed/unsigned integer formats.

+    * If/when new formats are added this code should be updated.

+    */

+   case GL_RED_INTEGER_EXT:

+   case GL_GREEN_INTEGER_EXT:

+   case GL_BLUE_INTEGER_EXT:

+   case GL_ALPHA_INTEGER_EXT:

+   case GL_RGB_INTEGER_EXT:

+   case GL_RGBA_INTEGER_EXT:

+   case GL_BGR_INTEGER_EXT:

+   case GL_BGRA_INTEGER_EXT:

+   case GL_LUMINANCE_INTEGER_EXT:

+   case GL_LUMINANCE_ALPHA_INTEGER_EXT:

+      /* fall-through */

+   case GL_RGBA8I_EXT:

+   case GL_RGB8I_EXT:

+   case GL_ALPHA8I_EXT:

+   case GL_INTENSITY8I_EXT:

+   case GL_LUMINANCE8I_EXT:

+   case GL_LUMINANCE_ALPHA8I_EXT:

+      if (screen->is_format_supported(screen, PIPE_FORMAT_R8G8B8A8_SSCALED,

+                                      target,

+                                      sample_count, bindings))

+         return PIPE_FORMAT_R8G8B8A8_SSCALED;

+      return PIPE_FORMAT_NONE;

+   case GL_RGBA16I_EXT:

+   case GL_RGB16I_EXT:

+   case GL_ALPHA16I_EXT:

+   case GL_INTENSITY16I_EXT:

+   case GL_LUMINANCE16I_EXT:

+   case GL_LUMINANCE_ALPHA16I_EXT:

+      if (screen->is_format_supported(screen, PIPE_FORMAT_R16G16B16A16_SSCALED,

+                                      target,

+                                      sample_count, bindings))

+         return PIPE_FORMAT_R16G16B16A16_SSCALED;

+      return PIPE_FORMAT_NONE;

+   case GL_RGBA32I_EXT:

+   case GL_RGB32I_EXT:

+   case GL_ALPHA32I_EXT:

+   case GL_INTENSITY32I_EXT:

+   case GL_LUMINANCE32I_EXT:

+   case GL_LUMINANCE_ALPHA32I_EXT:

+      /* xxx */

+      if (screen->is_format_supported(screen, PIPE_FORMAT_R32G32B32A32_SSCALED,

+                                      target,

+                                      sample_count, bindings))

+         return PIPE_FORMAT_R32G32B32A32_SSCALED;

+      return PIPE_FORMAT_NONE;

+

+   case GL_RGBA8UI_EXT:

+   case GL_RGB8UI_EXT:

+   case GL_ALPHA8UI_EXT:

+   case GL_INTENSITY8UI_EXT:

+   case GL_LUMINANCE8UI_EXT:

+   case GL_LUMINANCE_ALPHA8UI_EXT:

+      if (screen->is_format_supported(screen, PIPE_FORMAT_R8G8B8A8_USCALED,

+                                      target,

+                                      sample_count, bindings))

+         return PIPE_FORMAT_R8G8B8A8_USCALED;

+      return PIPE_FORMAT_NONE;

+

+   case GL_RGBA16UI_EXT:

+   case GL_RGB16UI_EXT:

+   case GL_ALPHA16UI_EXT:

+   case GL_INTENSITY16UI_EXT:

+   case GL_LUMINANCE16UI_EXT:

+   case GL_LUMINANCE_ALPHA16UI_EXT:

+      if (screen->is_format_supported(screen, PIPE_FORMAT_R16G16B16A16_USCALED,

+                                      target,

+                                      sample_count, bindings))

+         return PIPE_FORMAT_R16G16B16A16_USCALED;

+      return PIPE_FORMAT_NONE;

+

+   case GL_RGBA32UI_EXT:

+   case GL_RGB32UI_EXT:

+   case GL_ALPHA32UI_EXT:

+   case GL_INTENSITY32UI_EXT:

+   case GL_LUMINANCE32UI_EXT:

+   case GL_LUMINANCE_ALPHA32UI_EXT:

+      if (screen->is_format_supported(screen, PIPE_FORMAT_R32G32B32A32_USCALED,

+                                      target,

+                                      sample_count, bindings))

+         return PIPE_FORMAT_R32G32B32A32_USCALED;

+      return PIPE_FORMAT_NONE;

+

+   default:

+      return PIPE_FORMAT_NONE;

+   }

+}

+

+

+/**

+ * Called by FBO code to choose a PIPE_FORMAT_ for drawing surfaces.

+ */

+enum pipe_format

+st_choose_renderbuffer_format(struct pipe_screen *screen,

+                              GLenum internalFormat, unsigned sample_count)

+{

+   uint usage;

+   if (_mesa_is_depth_or_stencil_format(internalFormat))

+      usage = PIPE_BIND_DEPTH_STENCIL;

+   else

+      usage = PIPE_BIND_RENDER_TARGET;

+   return st_choose_format(screen, internalFormat, PIPE_TEXTURE_2D,

+                           sample_count, usage);

+}

+

+

+/**

+ * Called via ctx->Driver.chooseTextureFormat().

+ */

+gl_format

+st_ChooseTextureFormat_renderable(struct gl_context *ctx, GLint internalFormat,

+				  GLenum format, GLenum type, GLboolean renderable)

+{

+   struct pipe_screen *screen = st_context(ctx)->pipe->screen;

+   enum pipe_format pFormat;

+   uint bindings;

+

+   (void) format;

+   (void) type;

+

+   /* GL textures may wind up being render targets, but we don't know

+    * that in advance.  Specify potential render target flags now.

+    */

+   bindings = PIPE_BIND_SAMPLER_VIEW;

+   if (renderable == GL_TRUE) {

+      if (_mesa_is_depth_format(internalFormat) ||

+	  _mesa_is_depth_or_stencil_format(internalFormat))

+	 bindings |= PIPE_BIND_DEPTH_STENCIL;

+      else 

+	 bindings |= PIPE_BIND_RENDER_TARGET;

+   }

+

+   pFormat = st_choose_format(screen, internalFormat,

+                              PIPE_TEXTURE_2D, 0, bindings);

+

+   if (pFormat == PIPE_FORMAT_NONE) {

+      /* try choosing format again, this time without render target bindings */

+      pFormat = st_choose_format(screen, internalFormat,

+                                 PIPE_TEXTURE_2D, 0, PIPE_BIND_SAMPLER_VIEW);

+   }

+

+   if (pFormat == PIPE_FORMAT_NONE) {

+      /* no luck at all */

+      return MESA_FORMAT_NONE;

+   }

+

+   return st_pipe_format_to_mesa_format(pFormat);

+}

+

+gl_format

+st_ChooseTextureFormat(struct gl_context *ctx, GLint internalFormat,

+                       GLenum format, GLenum type)

+{

+   boolean want_renderable =

+      internalFormat == 3 || internalFormat == 4 ||

+      internalFormat == GL_RGB || internalFormat == GL_RGBA ||

+      internalFormat == GL_RGB8 || internalFormat == GL_RGBA8 ||

+      internalFormat == GL_BGRA;

+

+   return st_ChooseTextureFormat_renderable(ctx, internalFormat,

+					    format, type, want_renderable);

+}

+

+/**

+ * Test if a gallium format is equivalent to a GL format/type.

+ */

+GLboolean

+st_equal_formats(enum pipe_format pFormat, GLenum format, GLenum type)

+{

+   switch (pFormat) {

+   case PIPE_FORMAT_A8B8G8R8_UNORM:

+      return format == GL_RGBA && type == GL_UNSIGNED_BYTE;

+   case PIPE_FORMAT_A8R8G8B8_UNORM:

+      return format == GL_BGRA && type == GL_UNSIGNED_BYTE;

+   case PIPE_FORMAT_B5G6R5_UNORM:

+      return format == GL_RGB && type == GL_UNSIGNED_SHORT_5_6_5;

+   /* XXX more combos... */

+   default:

+      return GL_FALSE;

+   }

+}

+

+GLboolean

+st_sampler_compat_formats(enum pipe_format format1, enum pipe_format format2)

+{

+   if (format1 == format2)

+      return GL_TRUE;

+

+   if (format1 == PIPE_FORMAT_B8G8R8A8_UNORM &&

+       format2 == PIPE_FORMAT_B8G8R8X8_UNORM)

+      return GL_TRUE;

+

+   if (format1 == PIPE_FORMAT_B8G8R8X8_UNORM &&

+       format2 == PIPE_FORMAT_B8G8R8A8_UNORM)

+      return GL_TRUE;

+

+   if (format1 == PIPE_FORMAT_A8B8G8R8_UNORM &&

+       format2 == PIPE_FORMAT_X8B8G8R8_UNORM)

+      return GL_TRUE;

+

+   if (format1 == PIPE_FORMAT_X8B8G8R8_UNORM &&

+       format2 == PIPE_FORMAT_A8B8G8R8_UNORM)

+      return GL_TRUE;

+

+   if (format1 == PIPE_FORMAT_A8R8G8B8_UNORM &&

+       format2 == PIPE_FORMAT_X8R8G8B8_UNORM)

+      return GL_TRUE;

+

+   if (format1 == PIPE_FORMAT_X8R8G8B8_UNORM &&

+       format2 == PIPE_FORMAT_A8R8G8B8_UNORM)

+      return GL_TRUE;

+

+   return GL_FALSE;

+}

+

+

+

+/**

+ * This is used for translating texture border color and the clear

+ * color.  For example, the clear color is interpreted according to

+ * the renderbuffer's base format.  For example, if clearing a

+ * GL_LUMINANCE buffer, ClearColor[0] = luminance and ClearColor[1] =

+ * alpha.  Similarly for texture border colors.

+ */

+void

+st_translate_color(const GLfloat colorIn[4], GLenum baseFormat,

+                   GLfloat colorOut[4])

+{

+   switch (baseFormat) {

+   case GL_RED:

+      colorOut[0] = colorIn[0];

+      colorOut[1] = 0.0F;

+      colorOut[2] = 0.0F;

+      colorOut[3] = 1.0F;

+      break;

+   case GL_RG:

+      colorOut[0] = colorIn[0];

+      colorOut[1] = colorIn[1];

+      colorOut[2] = 0.0F;

+      colorOut[3] = 1.0F;

+      break;

+   case GL_RGB:

+      colorOut[0] = colorIn[0];

+      colorOut[1] = colorIn[1];

+      colorOut[2] = colorIn[2];

+      colorOut[3] = 1.0F;

+      break;

+   case GL_ALPHA:

+      colorOut[0] = colorOut[1] = colorOut[2] = 0.0;

+      colorOut[3] = colorIn[3];

+      break;

+   case GL_LUMINANCE:

+      colorOut[0] = colorOut[1] = colorOut[2] = colorIn[0];

+      colorOut[3] = 1.0;

+      break;

+   case GL_LUMINANCE_ALPHA:

+      colorOut[0] = colorOut[1] = colorOut[2] = colorIn[0];

+      colorOut[3] = colorIn[3];

+      break;

+   case GL_INTENSITY:

+      colorOut[0] = colorOut[1] = colorOut[2] = colorOut[3] = colorIn[0];

+      break;

+   default:

+      COPY_4V(colorOut, colorIn);

+   }

+}

diff --git a/mesalib/src/mesa/state_tracker/st_gen_mipmap.c b/mesalib/src/mesa/state_tracker/st_gen_mipmap.c
index 899161e78..2c37c1107 100644
--- a/mesalib/src/mesa/state_tracker/st_gen_mipmap.c
+++ b/mesalib/src/mesa/state_tracker/st_gen_mipmap.c
@@ -1,451 +1,451 @@
-/**************************************************************************
- * 
- * Copyright 2008 Tungsten Graphics, Inc., Cedar Park, Texas.
- * 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, sub license, 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 (including the
- * next paragraph) 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 NON-INFRINGEMENT.
- * IN NO EVENT SHALL TUNGSTEN GRAPHICS AND/OR ITS SUPPLIERS 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.
- * 
- **************************************************************************/
-
-
-#include "main/imports.h"
-#include "main/mipmap.h"
-#include "main/teximage.h"
-
-#include "pipe/p_context.h"
-#include "pipe/p_defines.h"
-#include "util/u_inlines.h"
-#include "util/u_format.h"
-#include "util/u_gen_mipmap.h"
-
-#include "st_debug.h"
-#include "st_context.h"
-#include "st_texture.h"
-#include "st_gen_mipmap.h"
-#include "st_cb_texture.h"
-
-
-/**
- * one-time init for generate mipmap
- * XXX Note: there may be other times we need no-op/simple state like this.
- * In that case, some code refactoring would be good.
- */
-void
-st_init_generate_mipmap(struct st_context *st)
-{
-   st->gen_mipmap = util_create_gen_mipmap(st->pipe, st->cso_context);
-}
-
-
-void
-st_destroy_generate_mipmap(struct st_context *st)
-{
-   util_destroy_gen_mipmap(st->gen_mipmap);
-   st->gen_mipmap = NULL;
-}
-
-
-/**
- * Generate mipmap levels using hardware rendering.
- * \return TRUE if successful, FALSE if not possible
- */
-static boolean
-st_render_mipmap(struct st_context *st,
-                 GLenum target,
-                 struct st_texture_object *stObj,
-                 uint baseLevel, uint lastLevel)
-{
-   struct pipe_context *pipe = st->pipe;
-   struct pipe_screen *screen = pipe->screen;
-   struct pipe_sampler_view *psv = st_get_texture_sampler_view(stObj, pipe);
-   const uint face = _mesa_tex_target_to_face(target);
-
-   assert(psv->texture == stObj->pt);
-#if 0
-   assert(target != GL_TEXTURE_3D); /* implemented but untested */
-#endif
-
-   /* check if we can render in the texture's format */
-   /* XXX should probably kill this and always use util_gen_mipmap
-      since this implements a sw fallback as well */
-   if (!screen->is_format_supported(screen, psv->format, psv->texture->target,
-                                    0, PIPE_BIND_RENDER_TARGET, 0)) {
-      return FALSE;
-   }
-
-   util_gen_mipmap(st->gen_mipmap, psv, face, baseLevel, lastLevel,
-                   PIPE_TEX_FILTER_LINEAR);
-
-   return TRUE;
-}
-
-
-/**
- * Helper function to decompress an image.  The result is a 32-bpp RGBA
- * image with stride==width.
- */
-static void
-decompress_image(enum pipe_format format, int datatype,
-                 const uint8_t *src, void *dst,
-                 unsigned width, unsigned height, unsigned src_stride)
-{
-   const struct util_format_description *desc = util_format_description(format);
-   const uint bw = util_format_get_blockwidth(format);
-   const uint bh = util_format_get_blockheight(format);
-   uint dst_stride = 4 * MAX2(width, bw);
-
-   if (datatype == GL_FLOAT) {
-      desc->unpack_rgba_float((float *)dst, dst_stride * sizeof(GLfloat), src, src_stride, width, height);
-      if (width < bw || height < bh) {
-	 float *dst_p = (float *)dst;
-	 /* We're decompressing an image smaller than the compression
-	  * block size.  We don't want garbage pixel values in the region
-	  * outside (width x height) so replicate pixels from the (width
-	  * x height) region to fill out the (bw x bh) block size.
-	  */
-	 uint x, y;
-	 for (y = 0; y < bh; y++) {
-	    for (x = 0; x < bw; x++) {
-	       if (x >= width || y >= height) {
-		  uint p = (y * bw + x) * 4;
-		  dst_p[p + 0] = dst_p[0];
-		  dst_p[p + 1] = dst_p[1];
-		  dst_p[p + 2] = dst_p[2];
-		  dst_p[p + 3] = dst_p[3];
-	       }
-	    }
-	 }
-      }
-   } else {
-      desc->unpack_rgba_8unorm((uint8_t *)dst, dst_stride, src, src_stride, width, height);
-      if (width < bw || height < bh) {
-	 uint8_t *dst_p = (uint8_t *)dst;
-	 /* We're decompressing an image smaller than the compression
-	  * block size.  We don't want garbage pixel values in the region
-	  * outside (width x height) so replicate pixels from the (width
-	  * x height) region to fill out the (bw x bh) block size.
-	  */
-	 uint x, y;
-	 for (y = 0; y < bh; y++) {
-	    for (x = 0; x < bw; x++) {
-	       if (x >= width || y >= height) {
-		  uint p = (y * bw + x) * 4;
-		  dst_p[p + 0] = dst_p[0];
-		  dst_p[p + 1] = dst_p[1];
-		  dst_p[p + 2] = dst_p[2];
-		  dst_p[p + 3] = dst_p[3];
-	       }
-	    }
-	 }
-      }
-   }
-}
-
-/**
- * Helper function to compress an image.  The source is a 32-bpp RGBA image
- * with stride==width.
- */
-static void
-compress_image(enum pipe_format format, int datatype,
-               const void *src, uint8_t *dst,
-               unsigned width, unsigned height, unsigned dst_stride)
-{
-   const struct util_format_description *desc = util_format_description(format);
-   const uint src_stride = 4 * width;
-
-   if (datatype == GL_FLOAT)
-      desc->pack_rgba_float(dst, dst_stride, (GLfloat *)src, src_stride * sizeof(GLfloat), width, height);
-   else
-      desc->pack_rgba_8unorm(dst, dst_stride, (uint8_t *)src, src_stride, width, height);
-}
-
-
-/**
- * Software fallback for generate mipmap levels.
- */
-static void
-fallback_generate_mipmap(struct gl_context *ctx, GLenum target,
-                         struct gl_texture_object *texObj)
-{
-   struct pipe_context *pipe = st_context(ctx)->pipe;
-   struct pipe_resource *pt = st_get_texobj_resource(texObj);
-   const uint baseLevel = texObj->BaseLevel;
-   const uint lastLevel = pt->last_level;
-   const uint face = _mesa_tex_target_to_face(target);
-   uint dstLevel;
-   GLenum datatype;
-   GLuint comps;
-   GLboolean compressed;
-
-   if (ST_DEBUG & DEBUG_FALLBACK)
-      debug_printf("%s: fallback processing\n", __FUNCTION__);
-
-   assert(target != GL_TEXTURE_3D); /* not done yet */
-
-   compressed =
-      _mesa_is_format_compressed(texObj->Image[face][baseLevel]->TexFormat);
-
-   if (compressed) {
-      GLenum type =
-         _mesa_get_format_datatype(texObj->Image[face][baseLevel]->TexFormat);
-
-      datatype = type == GL_UNSIGNED_NORMALIZED ? GL_UNSIGNED_BYTE : GL_FLOAT;
-      comps = 4;
-   }
-   else {
-      _mesa_format_to_type_and_comps(texObj->Image[face][baseLevel]->TexFormat,
-                                     &datatype, &comps);
-      assert(comps > 0 && "bad texture format in fallback_generate_mipmap()");
-   }
-
-   for (dstLevel = baseLevel + 1; dstLevel <= lastLevel; dstLevel++) {
-      const uint srcLevel = dstLevel - 1;
-      const uint srcWidth = u_minify(pt->width0, srcLevel);
-      const uint srcHeight = u_minify(pt->height0, srcLevel);
-      const uint srcDepth = u_minify(pt->depth0, srcLevel);
-      const uint dstWidth = u_minify(pt->width0, dstLevel);
-      const uint dstHeight = u_minify(pt->height0, dstLevel);
-      const uint dstDepth = u_minify(pt->depth0, dstLevel);
-      struct pipe_transfer *srcTrans, *dstTrans;
-      const ubyte *srcData;
-      ubyte *dstData;
-      int srcStride, dstStride;
-
-      srcTrans = pipe_get_transfer(st_context(ctx)->pipe, pt, srcLevel,
-                                   face,
-                                   PIPE_TRANSFER_READ, 0, 0,
-                                   srcWidth, srcHeight);
-
-      dstTrans = pipe_get_transfer(st_context(ctx)->pipe, pt, dstLevel,
-                                   face,
-                                   PIPE_TRANSFER_WRITE, 0, 0,
-                                   dstWidth, dstHeight);
-
-      srcData = (ubyte *) pipe_transfer_map(pipe, srcTrans);
-      dstData = (ubyte *) pipe_transfer_map(pipe, dstTrans);
-
-      srcStride = srcTrans->stride / util_format_get_blocksize(srcTrans->resource->format);
-      dstStride = dstTrans->stride / util_format_get_blocksize(dstTrans->resource->format);
-
-     /* this cannot work correctly for 3d since it does
-        not respect layerStride. */
-      if (compressed) {
-         const enum pipe_format format = pt->format;
-         const uint bw = util_format_get_blockwidth(format);
-         const uint bh = util_format_get_blockheight(format);
-         const uint srcWidth2 = align(srcWidth, bw);
-         const uint srcHeight2 = align(srcHeight, bh);
-         const uint dstWidth2 = align(dstWidth, bw);
-         const uint dstHeight2 = align(dstHeight, bh);
-         uint8_t *srcTemp, *dstTemp;
-
-         assert(comps == 4);
-
-         srcTemp = malloc(srcWidth2 * srcHeight2 * comps * (datatype == GL_FLOAT ? 4 : 1));
-         dstTemp = malloc(dstWidth2 * dstHeight2 * comps * (datatype == GL_FLOAT ? 4 : 1));
-
-         /* decompress the src image: srcData -> srcTemp */
-         decompress_image(format, datatype, srcData, srcTemp, srcWidth2, srcHeight2, srcTrans->stride);
-
-         _mesa_generate_mipmap_level(target, datatype, comps,
-                                     0 /*border*/,
-                                     srcWidth2, srcHeight2, srcDepth,
-                                     srcTemp,
-                                     srcWidth2, /* stride in texels */
-                                     dstWidth2, dstHeight2, dstDepth,
-                                     dstTemp,
-                                     dstWidth2); /* stride in texels */
-
-         /* compress the new image: dstTemp -> dstData */
-         compress_image(format, datatype, dstTemp, dstData, dstWidth2, dstHeight2, dstTrans->stride);
-
-         free(srcTemp);
-         free(dstTemp);
-      }
-      else {
-         _mesa_generate_mipmap_level(target, datatype, comps,
-                                     0 /*border*/,
-                                     srcWidth, srcHeight, srcDepth,
-                                     srcData,
-                                     srcStride, /* stride in texels */
-                                     dstWidth, dstHeight, dstDepth,
-                                     dstData,
-                                     dstStride); /* stride in texels */
-      }
-
-      pipe_transfer_unmap(pipe, srcTrans);
-      pipe_transfer_unmap(pipe, dstTrans);
-
-      pipe->transfer_destroy(pipe, srcTrans);
-      pipe->transfer_destroy(pipe, dstTrans);
-   }
-}
-
-
-/**
- * Compute the expected number of mipmap levels in the texture given
- * the width/height/depth of the base image and the GL_TEXTURE_BASE_LEVEL/
- * GL_TEXTURE_MAX_LEVEL settings.  This will tell us how many mipmap
- * levels should be generated.
- */
-static GLuint
-compute_num_levels(struct gl_context *ctx,
-                   struct gl_texture_object *texObj,
-                   GLenum target)
-{
-   if (target == GL_TEXTURE_RECTANGLE_ARB) {
-      return 1;
-   }
-   else {
-      const struct gl_texture_image *baseImage = 
-         _mesa_get_tex_image(ctx, texObj, target, texObj->BaseLevel);
-      GLuint size, numLevels;
-
-      size = MAX2(baseImage->Width2, baseImage->Height2);
-      size = MAX2(size, baseImage->Depth2);
-
-      numLevels = texObj->BaseLevel;
-
-      while (size > 0) {
-         numLevels++;
-         size >>= 1;
-      }
-
-      numLevels = MIN2(numLevels, texObj->MaxLevel + 1);
-
-      assert(numLevels >= 1);
-
-      return numLevels;
-   }
-}
-
-
-/**
- * Called via ctx->Driver.GenerateMipmap().
- */
-void
-st_generate_mipmap(struct gl_context *ctx, GLenum target,
-                   struct gl_texture_object *texObj)
-{
-   struct st_context *st = st_context(ctx);
-   struct st_texture_object *stObj = st_texture_object(texObj);
-   struct pipe_resource *pt = st_get_texobj_resource(texObj);
-   const uint baseLevel = texObj->BaseLevel;
-   uint lastLevel;
-   uint dstLevel;
-
-   if (!pt)
-      return;
-
-   /* not sure if this ultimately actually should work,
-      but we're not supporting multisampled textures yet. */
-   assert(pt->nr_samples < 2);
-
-   /* find expected last mipmap level to generate*/
-   lastLevel = compute_num_levels(ctx, texObj, target) - 1;
-
-   if (lastLevel == 0)
-      return;
-
-   /* The texture isn't in a "complete" state yet so set the expected
-    * lastLevel here, since it won't get done in st_finalize_texture().
-    */
-   stObj->lastLevel = lastLevel;
-
-   if (pt->last_level < lastLevel) {
-      /* The current gallium texture doesn't have space for all the
-       * mipmap levels we need to generate.  So allocate a new texture.
-       */
-      struct pipe_resource *oldTex = stObj->pt;
-
-      /* create new texture with space for more levels */
-      stObj->pt = st_texture_create(st,
-                                    oldTex->target,
-                                    oldTex->format,
-                                    lastLevel,
-                                    oldTex->width0,
-                                    oldTex->height0,
-                                    oldTex->depth0,
-                                    oldTex->array_size,
-                                    oldTex->bind);
-
-      /* This will copy the old texture's base image into the new texture
-       * which we just allocated.
-       */
-      st_finalize_texture(ctx, st->pipe, texObj);
-
-      /* release the old tex (will likely be freed too) */
-      pipe_resource_reference(&oldTex, NULL);
-      pipe_sampler_view_reference(&stObj->sampler_view, NULL);
-   }
-   else {
-      /* Make sure that the base texture image data is present in the
-       * texture buffer.
-       */
-      st_finalize_texture(ctx, st->pipe, texObj);
-   }
-
-   pt = stObj->pt;
-
-   assert(pt->last_level >= lastLevel);
-
-   /* Try to generate the mipmap by rendering/texturing.  If that fails,
-    * use the software fallback.
-    */
-   if (!st_render_mipmap(st, target, stObj, baseLevel, lastLevel)) {
-      /* since the util code actually also has a fallback, should
-         probably make it never fail and kill this */
-      fallback_generate_mipmap(ctx, target, texObj);
-   }
-
-   /* Fill in the Mesa gl_texture_image fields */
-   for (dstLevel = baseLevel + 1; dstLevel <= lastLevel; dstLevel++) {
-      const uint srcLevel = dstLevel - 1;
-      const struct gl_texture_image *srcImage
-         = _mesa_get_tex_image(ctx, texObj, target, srcLevel);
-      struct gl_texture_image *dstImage;
-      struct st_texture_image *stImage;
-      uint dstWidth = u_minify(pt->width0, dstLevel);
-      uint dstHeight = u_minify(pt->height0, dstLevel);
-      uint dstDepth = u_minify(pt->depth0, dstLevel); 
-      uint border = srcImage->Border;
-
-      dstImage = _mesa_get_tex_image(ctx, texObj, target, dstLevel);
-      if (!dstImage) {
-         _mesa_error(ctx, GL_OUT_OF_MEMORY, "generating mipmaps");
-         return;
-      }
-
-      /* Free old image data */
-      if (dstImage->Data)
-         ctx->Driver.FreeTexImageData(ctx, dstImage);
-
-      /* initialize new image */
-      _mesa_init_teximage_fields(ctx, target, dstImage, dstWidth, dstHeight,
-                                 dstDepth, border, srcImage->InternalFormat,
-                                 srcImage->TexFormat);
-
-      stImage = st_texture_image(dstImage);
-      stImage->level = dstLevel;
-
-      pipe_resource_reference(&stImage->pt, pt);
-   }
-}
+/**************************************************************************

+ * 

+ * Copyright 2008 Tungsten Graphics, Inc., Cedar Park, Texas.

+ * 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, sub license, 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 (including the

+ * next paragraph) 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 NON-INFRINGEMENT.

+ * IN NO EVENT SHALL TUNGSTEN GRAPHICS AND/OR ITS SUPPLIERS 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.

+ * 

+ **************************************************************************/

+

+

+#include "main/imports.h"

+#include "main/mipmap.h"

+#include "main/teximage.h"

+

+#include "pipe/p_context.h"

+#include "pipe/p_defines.h"

+#include "util/u_inlines.h"

+#include "util/u_format.h"

+#include "util/u_gen_mipmap.h"

+

+#include "st_debug.h"

+#include "st_context.h"

+#include "st_texture.h"

+#include "st_gen_mipmap.h"

+#include "st_cb_texture.h"

+

+

+/**

+ * one-time init for generate mipmap

+ * XXX Note: there may be other times we need no-op/simple state like this.

+ * In that case, some code refactoring would be good.

+ */

+void

+st_init_generate_mipmap(struct st_context *st)

+{

+   st->gen_mipmap = util_create_gen_mipmap(st->pipe, st->cso_context);

+}

+

+

+void

+st_destroy_generate_mipmap(struct st_context *st)

+{

+   util_destroy_gen_mipmap(st->gen_mipmap);

+   st->gen_mipmap = NULL;

+}

+

+

+/**

+ * Generate mipmap levels using hardware rendering.

+ * \return TRUE if successful, FALSE if not possible

+ */

+static boolean

+st_render_mipmap(struct st_context *st,

+                 GLenum target,

+                 struct st_texture_object *stObj,

+                 uint baseLevel, uint lastLevel)

+{

+   struct pipe_context *pipe = st->pipe;

+   struct pipe_screen *screen = pipe->screen;

+   struct pipe_sampler_view *psv = st_get_texture_sampler_view(stObj, pipe);

+   const uint face = _mesa_tex_target_to_face(target);

+

+   assert(psv->texture == stObj->pt);

+#if 0

+   assert(target != GL_TEXTURE_3D); /* implemented but untested */

+#endif

+

+   /* check if we can render in the texture's format */

+   /* XXX should probably kill this and always use util_gen_mipmap

+      since this implements a sw fallback as well */

+   if (!screen->is_format_supported(screen, psv->format, psv->texture->target,

+                                    0, PIPE_BIND_RENDER_TARGET)) {

+      return FALSE;

+   }

+

+   util_gen_mipmap(st->gen_mipmap, psv, face, baseLevel, lastLevel,

+                   PIPE_TEX_FILTER_LINEAR);

+

+   return TRUE;

+}

+

+

+/**

+ * Helper function to decompress an image.  The result is a 32-bpp RGBA

+ * image with stride==width.

+ */

+static void

+decompress_image(enum pipe_format format, int datatype,

+                 const uint8_t *src, void *dst,

+                 unsigned width, unsigned height, unsigned src_stride)

+{

+   const struct util_format_description *desc = util_format_description(format);

+   const uint bw = util_format_get_blockwidth(format);

+   const uint bh = util_format_get_blockheight(format);

+   uint dst_stride = 4 * MAX2(width, bw);

+

+   if (datatype == GL_FLOAT) {

+      desc->unpack_rgba_float((float *)dst, dst_stride * sizeof(GLfloat), src, src_stride, width, height);

+      if (width < bw || height < bh) {

+	 float *dst_p = (float *)dst;

+	 /* We're decompressing an image smaller than the compression

+	  * block size.  We don't want garbage pixel values in the region

+	  * outside (width x height) so replicate pixels from the (width

+	  * x height) region to fill out the (bw x bh) block size.

+	  */

+	 uint x, y;

+	 for (y = 0; y < bh; y++) {

+	    for (x = 0; x < bw; x++) {

+	       if (x >= width || y >= height) {

+		  uint p = (y * bw + x) * 4;

+		  dst_p[p + 0] = dst_p[0];

+		  dst_p[p + 1] = dst_p[1];

+		  dst_p[p + 2] = dst_p[2];

+		  dst_p[p + 3] = dst_p[3];

+	       }

+	    }

+	 }

+      }

+   } else {

+      desc->unpack_rgba_8unorm((uint8_t *)dst, dst_stride, src, src_stride, width, height);

+      if (width < bw || height < bh) {

+	 uint8_t *dst_p = (uint8_t *)dst;

+	 /* We're decompressing an image smaller than the compression

+	  * block size.  We don't want garbage pixel values in the region

+	  * outside (width x height) so replicate pixels from the (width

+	  * x height) region to fill out the (bw x bh) block size.

+	  */

+	 uint x, y;

+	 for (y = 0; y < bh; y++) {

+	    for (x = 0; x < bw; x++) {

+	       if (x >= width || y >= height) {

+		  uint p = (y * bw + x) * 4;

+		  dst_p[p + 0] = dst_p[0];

+		  dst_p[p + 1] = dst_p[1];

+		  dst_p[p + 2] = dst_p[2];

+		  dst_p[p + 3] = dst_p[3];

+	       }

+	    }

+	 }

+      }

+   }

+}

+

+/**

+ * Helper function to compress an image.  The source is a 32-bpp RGBA image

+ * with stride==width.

+ */

+static void

+compress_image(enum pipe_format format, int datatype,

+               const void *src, uint8_t *dst,

+               unsigned width, unsigned height, unsigned dst_stride)

+{

+   const struct util_format_description *desc = util_format_description(format);

+   const uint src_stride = 4 * width;

+

+   if (datatype == GL_FLOAT)

+      desc->pack_rgba_float(dst, dst_stride, (GLfloat *)src, src_stride * sizeof(GLfloat), width, height);

+   else

+      desc->pack_rgba_8unorm(dst, dst_stride, (uint8_t *)src, src_stride, width, height);

+}

+

+

+/**

+ * Software fallback for generate mipmap levels.

+ */

+static void

+fallback_generate_mipmap(struct gl_context *ctx, GLenum target,

+                         struct gl_texture_object *texObj)

+{

+   struct pipe_context *pipe = st_context(ctx)->pipe;

+   struct pipe_resource *pt = st_get_texobj_resource(texObj);

+   const uint baseLevel = texObj->BaseLevel;

+   const uint lastLevel = pt->last_level;

+   const uint face = _mesa_tex_target_to_face(target);

+   uint dstLevel;

+   GLenum datatype;

+   GLuint comps;

+   GLboolean compressed;

+

+   if (ST_DEBUG & DEBUG_FALLBACK)

+      debug_printf("%s: fallback processing\n", __FUNCTION__);

+

+   assert(target != GL_TEXTURE_3D); /* not done yet */

+

+   compressed =

+      _mesa_is_format_compressed(texObj->Image[face][baseLevel]->TexFormat);

+

+   if (compressed) {

+      GLenum type =

+         _mesa_get_format_datatype(texObj->Image[face][baseLevel]->TexFormat);

+

+      datatype = type == GL_UNSIGNED_NORMALIZED ? GL_UNSIGNED_BYTE : GL_FLOAT;

+      comps = 4;

+   }

+   else {

+      _mesa_format_to_type_and_comps(texObj->Image[face][baseLevel]->TexFormat,

+                                     &datatype, &comps);

+      assert(comps > 0 && "bad texture format in fallback_generate_mipmap()");

+   }

+

+   for (dstLevel = baseLevel + 1; dstLevel <= lastLevel; dstLevel++) {

+      const uint srcLevel = dstLevel - 1;

+      const uint srcWidth = u_minify(pt->width0, srcLevel);

+      const uint srcHeight = u_minify(pt->height0, srcLevel);

+      const uint srcDepth = u_minify(pt->depth0, srcLevel);

+      const uint dstWidth = u_minify(pt->width0, dstLevel);

+      const uint dstHeight = u_minify(pt->height0, dstLevel);

+      const uint dstDepth = u_minify(pt->depth0, dstLevel);

+      struct pipe_transfer *srcTrans, *dstTrans;

+      const ubyte *srcData;

+      ubyte *dstData;

+      int srcStride, dstStride;

+

+      srcTrans = pipe_get_transfer(st_context(ctx)->pipe, pt, srcLevel,

+                                   face,

+                                   PIPE_TRANSFER_READ, 0, 0,

+                                   srcWidth, srcHeight);

+

+      dstTrans = pipe_get_transfer(st_context(ctx)->pipe, pt, dstLevel,

+                                   face,

+                                   PIPE_TRANSFER_WRITE, 0, 0,

+                                   dstWidth, dstHeight);

+

+      srcData = (ubyte *) pipe_transfer_map(pipe, srcTrans);

+      dstData = (ubyte *) pipe_transfer_map(pipe, dstTrans);

+

+      srcStride = srcTrans->stride / util_format_get_blocksize(srcTrans->resource->format);

+      dstStride = dstTrans->stride / util_format_get_blocksize(dstTrans->resource->format);

+

+     /* this cannot work correctly for 3d since it does

+        not respect layerStride. */

+      if (compressed) {

+         const enum pipe_format format = pt->format;

+         const uint bw = util_format_get_blockwidth(format);

+         const uint bh = util_format_get_blockheight(format);

+         const uint srcWidth2 = align(srcWidth, bw);

+         const uint srcHeight2 = align(srcHeight, bh);

+         const uint dstWidth2 = align(dstWidth, bw);

+         const uint dstHeight2 = align(dstHeight, bh);

+         uint8_t *srcTemp, *dstTemp;

+

+         assert(comps == 4);

+

+         srcTemp = malloc(srcWidth2 * srcHeight2 * comps * (datatype == GL_FLOAT ? 4 : 1));

+         dstTemp = malloc(dstWidth2 * dstHeight2 * comps * (datatype == GL_FLOAT ? 4 : 1));

+

+         /* decompress the src image: srcData -> srcTemp */

+         decompress_image(format, datatype, srcData, srcTemp, srcWidth2, srcHeight2, srcTrans->stride);

+

+         _mesa_generate_mipmap_level(target, datatype, comps,

+                                     0 /*border*/,

+                                     srcWidth2, srcHeight2, srcDepth,

+                                     srcTemp,

+                                     srcWidth2, /* stride in texels */

+                                     dstWidth2, dstHeight2, dstDepth,

+                                     dstTemp,

+                                     dstWidth2); /* stride in texels */

+

+         /* compress the new image: dstTemp -> dstData */

+         compress_image(format, datatype, dstTemp, dstData, dstWidth2, dstHeight2, dstTrans->stride);

+

+         free(srcTemp);

+         free(dstTemp);

+      }

+      else {

+         _mesa_generate_mipmap_level(target, datatype, comps,

+                                     0 /*border*/,

+                                     srcWidth, srcHeight, srcDepth,

+                                     srcData,

+                                     srcStride, /* stride in texels */

+                                     dstWidth, dstHeight, dstDepth,

+                                     dstData,

+                                     dstStride); /* stride in texels */

+      }

+

+      pipe_transfer_unmap(pipe, srcTrans);

+      pipe_transfer_unmap(pipe, dstTrans);

+

+      pipe->transfer_destroy(pipe, srcTrans);

+      pipe->transfer_destroy(pipe, dstTrans);

+   }

+}

+

+

+/**

+ * Compute the expected number of mipmap levels in the texture given

+ * the width/height/depth of the base image and the GL_TEXTURE_BASE_LEVEL/

+ * GL_TEXTURE_MAX_LEVEL settings.  This will tell us how many mipmap

+ * levels should be generated.

+ */

+static GLuint

+compute_num_levels(struct gl_context *ctx,

+                   struct gl_texture_object *texObj,

+                   GLenum target)

+{

+   if (target == GL_TEXTURE_RECTANGLE_ARB) {

+      return 1;

+   }

+   else {

+      const struct gl_texture_image *baseImage = 

+         _mesa_get_tex_image(ctx, texObj, target, texObj->BaseLevel);

+      GLuint size, numLevels;

+

+      size = MAX2(baseImage->Width2, baseImage->Height2);

+      size = MAX2(size, baseImage->Depth2);

+

+      numLevels = texObj->BaseLevel;

+

+      while (size > 0) {

+         numLevels++;

+         size >>= 1;

+      }

+

+      numLevels = MIN2(numLevels, texObj->MaxLevel + 1);

+

+      assert(numLevels >= 1);

+

+      return numLevels;

+   }

+}

+

+

+/**

+ * Called via ctx->Driver.GenerateMipmap().

+ */

+void

+st_generate_mipmap(struct gl_context *ctx, GLenum target,

+                   struct gl_texture_object *texObj)

+{

+   struct st_context *st = st_context(ctx);

+   struct st_texture_object *stObj = st_texture_object(texObj);

+   struct pipe_resource *pt = st_get_texobj_resource(texObj);

+   const uint baseLevel = texObj->BaseLevel;

+   uint lastLevel;

+   uint dstLevel;

+

+   if (!pt)

+      return;

+

+   /* not sure if this ultimately actually should work,

+      but we're not supporting multisampled textures yet. */

+   assert(pt->nr_samples < 2);

+

+   /* find expected last mipmap level to generate*/

+   lastLevel = compute_num_levels(ctx, texObj, target) - 1;

+

+   if (lastLevel == 0)

+      return;

+

+   /* The texture isn't in a "complete" state yet so set the expected

+    * lastLevel here, since it won't get done in st_finalize_texture().

+    */

+   stObj->lastLevel = lastLevel;

+

+   if (pt->last_level < lastLevel) {

+      /* The current gallium texture doesn't have space for all the

+       * mipmap levels we need to generate.  So allocate a new texture.

+       */

+      struct pipe_resource *oldTex = stObj->pt;

+

+      /* create new texture with space for more levels */

+      stObj->pt = st_texture_create(st,

+                                    oldTex->target,

+                                    oldTex->format,

+                                    lastLevel,

+                                    oldTex->width0,

+                                    oldTex->height0,

+                                    oldTex->depth0,

+                                    oldTex->array_size,

+                                    oldTex->bind);

+

+      /* This will copy the old texture's base image into the new texture

+       * which we just allocated.

+       */

+      st_finalize_texture(ctx, st->pipe, texObj);

+

+      /* release the old tex (will likely be freed too) */

+      pipe_resource_reference(&oldTex, NULL);

+      pipe_sampler_view_reference(&stObj->sampler_view, NULL);

+   }

+   else {

+      /* Make sure that the base texture image data is present in the

+       * texture buffer.

+       */

+      st_finalize_texture(ctx, st->pipe, texObj);

+   }

+

+   pt = stObj->pt;

+

+   assert(pt->last_level >= lastLevel);

+

+   /* Try to generate the mipmap by rendering/texturing.  If that fails,

+    * use the software fallback.

+    */

+   if (!st_render_mipmap(st, target, stObj, baseLevel, lastLevel)) {

+      /* since the util code actually also has a fallback, should

+         probably make it never fail and kill this */

+      fallback_generate_mipmap(ctx, target, texObj);

+   }

+

+   /* Fill in the Mesa gl_texture_image fields */

+   for (dstLevel = baseLevel + 1; dstLevel <= lastLevel; dstLevel++) {

+      const uint srcLevel = dstLevel - 1;

+      const struct gl_texture_image *srcImage

+         = _mesa_get_tex_image(ctx, texObj, target, srcLevel);

+      struct gl_texture_image *dstImage;

+      struct st_texture_image *stImage;

+      uint dstWidth = u_minify(pt->width0, dstLevel);

+      uint dstHeight = u_minify(pt->height0, dstLevel);

+      uint dstDepth = u_minify(pt->depth0, dstLevel); 

+      uint border = srcImage->Border;

+

+      dstImage = _mesa_get_tex_image(ctx, texObj, target, dstLevel);

+      if (!dstImage) {

+         _mesa_error(ctx, GL_OUT_OF_MEMORY, "generating mipmaps");

+         return;

+      }

+

+      /* Free old image data */

+      if (dstImage->Data)

+         ctx->Driver.FreeTexImageData(ctx, dstImage);

+

+      /* initialize new image */

+      _mesa_init_teximage_fields(ctx, target, dstImage, dstWidth, dstHeight,

+                                 dstDepth, border, srcImage->InternalFormat,

+                                 srcImage->TexFormat);

+

+      stImage = st_texture_image(dstImage);

+      stImage->level = dstLevel;

+

+      pipe_resource_reference(&stImage->pt, pt);

+   }

+}

diff --git a/mesalib/src/mesa/state_tracker/st_manager.c b/mesalib/src/mesa/state_tracker/st_manager.c
index d85bcd4f7..e126c0a1e 100644
--- a/mesalib/src/mesa/state_tracker/st_manager.c
+++ b/mesalib/src/mesa/state_tracker/st_manager.c
@@ -1,923 +1,923 @@
-/*
- * Mesa 3-D graphics library
- * Version:  7.9
- *
- * Copyright (C) 2010 LunarG Inc.
- *
- * 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
- * THE AUTHORS OR COPYRIGHT HOLDERS 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.
- *
- * Authors:
- *    Chia-I Wu <olv@lunarg.com>
- */
-
-#include "state_tracker/st_gl_api.h"
-
-#include "pipe/p_context.h"
-#include "pipe/p_screen.h"
-#include "util/u_format.h"
-#include "util/u_pointer.h"
-#include "util/u_inlines.h"
-#include "util/u_atomic.h"
-#include "util/u_surface.h"
-
-#include "main/mtypes.h"
-#include "main/context.h"
-#include "main/mfeatures.h"
-#include "main/texobj.h"
-#include "main/teximage.h"
-#include "main/texstate.h"
-#include "main/framebuffer.h"
-#include "main/fbobject.h"
-#include "main/renderbuffer.h"
-#include "main/version.h"
-#include "st_texture.h"
-
-#include "st_context.h"
-#include "st_format.h"
-#include "st_cb_fbo.h"
-#include "st_cb_flush.h"
-#include "st_manager.h"
-
-/**
- * Cast wrapper to convert a struct gl_framebuffer to an st_framebuffer.
- * Return NULL if the struct gl_framebuffer is a user-created framebuffer.
- * We'll only return non-null for window system framebuffers.
- * Note that this function may fail.
- */
-static INLINE struct st_framebuffer *
-st_ws_framebuffer(struct gl_framebuffer *fb)
-{
-   /* FBO cannot be casted.  See st_new_framebuffer */
-   return (struct st_framebuffer *) ((fb && !fb->Name) ? fb : NULL);
-}
-
-/**
- * Map an attachment to a buffer index.
- */
-static INLINE gl_buffer_index
-attachment_to_buffer_index(enum st_attachment_type statt)
-{
-   gl_buffer_index index;
-
-   switch (statt) {
-   case ST_ATTACHMENT_FRONT_LEFT:
-      index = BUFFER_FRONT_LEFT;
-      break;
-   case ST_ATTACHMENT_BACK_LEFT:
-      index = BUFFER_BACK_LEFT;
-      break;
-   case ST_ATTACHMENT_FRONT_RIGHT:
-      index = BUFFER_FRONT_RIGHT;
-      break;
-   case ST_ATTACHMENT_BACK_RIGHT:
-      index = BUFFER_BACK_RIGHT;
-      break;
-   case ST_ATTACHMENT_DEPTH_STENCIL:
-      index = BUFFER_DEPTH;
-      break;
-   case ST_ATTACHMENT_ACCUM:
-      index = BUFFER_ACCUM;
-      break;
-   case ST_ATTACHMENT_SAMPLE:
-   default:
-      index = BUFFER_COUNT;
-      break;
-   }
-
-   return index;
-}
-
-/**
- * Map a buffer index to an attachment.
- */
-static INLINE enum st_attachment_type
-buffer_index_to_attachment(gl_buffer_index index)
-{
-   enum st_attachment_type statt;
-
-   switch (index) {
-   case BUFFER_FRONT_LEFT:
-      statt = ST_ATTACHMENT_FRONT_LEFT;
-      break;
-   case BUFFER_BACK_LEFT:
-      statt = ST_ATTACHMENT_BACK_LEFT;
-      break;
-   case BUFFER_FRONT_RIGHT:
-      statt = ST_ATTACHMENT_FRONT_RIGHT;
-      break;
-   case BUFFER_BACK_RIGHT:
-      statt = ST_ATTACHMENT_BACK_RIGHT;
-      break;
-   case BUFFER_DEPTH:
-      statt = ST_ATTACHMENT_DEPTH_STENCIL;
-      break;
-   case BUFFER_ACCUM:
-      statt = ST_ATTACHMENT_ACCUM;
-      break;
-   default:
-      statt = ST_ATTACHMENT_INVALID;
-      break;
-   }
-
-   return statt;
-}
-
-/**
- * Validate a framebuffer to make sure up-to-date pipe_textures are used.
- */
-static void
-st_framebuffer_validate(struct st_framebuffer *stfb, struct st_context *st)
-{
-   struct pipe_context *pipe = st->pipe;
-   struct pipe_resource *textures[ST_ATTACHMENT_COUNT];
-   uint width, height;
-   unsigned i;
-   boolean changed = FALSE;
-
-   if (!p_atomic_read(&stfb->revalidate))
-      return;
-
-   /* validate the fb */
-   if (!stfb->iface->validate(stfb->iface, stfb->statts, stfb->num_statts, textures))
-      return;
-
-   width = stfb->Base.Width;
-   height = stfb->Base.Height;
-
-   for (i = 0; i < stfb->num_statts; i++) {
-      struct st_renderbuffer *strb;
-      struct pipe_surface *ps, surf_tmpl;
-      gl_buffer_index idx;
-
-      if (!textures[i])
-         continue;
-
-      idx = attachment_to_buffer_index(stfb->statts[i]);
-      if (idx >= BUFFER_COUNT) {
-         pipe_resource_reference(&textures[i], NULL);
-         continue;
-      }
-
-      strb = st_renderbuffer(stfb->Base.Attachment[idx].Renderbuffer);
-      assert(strb);
-      if (strb->texture == textures[i]) {
-         pipe_resource_reference(&textures[i], NULL);
-         continue;
-      }
-
-      memset(&surf_tmpl, 0, sizeof(surf_tmpl));
-      u_surface_default_template(&surf_tmpl, textures[i],
-                                 PIPE_BIND_RENDER_TARGET);
-      ps = pipe->create_surface(pipe, textures[i], &surf_tmpl);
-      if (ps) {
-         pipe_surface_reference(&strb->surface, ps);
-         pipe_resource_reference(&strb->texture, ps->texture);
-         /* ownership transfered */
-         pipe_surface_reference(&ps, NULL);
-
-         changed = TRUE;
-
-         strb->Base.Width = strb->surface->width;
-         strb->Base.Height = strb->surface->height;
-
-         width = strb->Base.Width;
-         height = strb->Base.Height;
-      }
-
-      pipe_resource_reference(&textures[i], NULL);
-   }
-
-   if (changed) {
-      st->dirty.st |= ST_NEW_FRAMEBUFFER;
-      _mesa_resize_framebuffer(st->ctx, &stfb->Base, width, height);
-
-      assert(stfb->Base.Width == width);
-      assert(stfb->Base.Height == height);
-   }
-
-   p_atomic_set(&stfb->revalidate, FALSE);
-}
-
-/**
- * Update the attachments to validate by looping the existing renderbuffers.
- */
-static void
-st_framebuffer_update_attachments(struct st_framebuffer *stfb)
-{
-   gl_buffer_index idx;
-
-   stfb->num_statts = 0;
-   for (idx = 0; idx < BUFFER_COUNT; idx++) {
-      struct st_renderbuffer *strb;
-      enum st_attachment_type statt;
-
-      strb = st_renderbuffer(stfb->Base.Attachment[idx].Renderbuffer);
-      if (!strb || strb->software)
-         continue;
-
-      statt = buffer_index_to_attachment(idx);
-      if (statt != ST_ATTACHMENT_INVALID &&
-          st_visual_have_buffers(stfb->iface->visual, 1 << statt))
-         stfb->statts[stfb->num_statts++] = statt;
-   }
-
-   p_atomic_set(&stfb->revalidate, TRUE);
-}
-
-/**
- * Add a renderbuffer to the framebuffer.
- */
-static boolean
-st_framebuffer_add_renderbuffer(struct st_framebuffer *stfb,
-                                gl_buffer_index idx)
-{
-   struct gl_renderbuffer *rb;
-   enum pipe_format format;
-   int samples;
-   boolean sw;
-
-   if (!stfb->iface)
-      return FALSE;
-
-   /* do not distinguish depth/stencil buffers */
-   if (idx == BUFFER_STENCIL)
-      idx = BUFFER_DEPTH;
-
-   switch (idx) {
-   case BUFFER_DEPTH:
-      format = stfb->iface->visual->depth_stencil_format;
-      sw = FALSE;
-      break;
-   case BUFFER_ACCUM:
-      format = stfb->iface->visual->accum_format;
-      sw = TRUE;
-      break;
-   default:
-      format = stfb->iface->visual->color_format;
-      sw = FALSE;
-      break;
-   }
-
-   if (format == PIPE_FORMAT_NONE)
-      return FALSE;
-
-   samples = stfb->iface->visual->samples;
-   if (!samples)
-      samples = st_get_msaa();
-
-   rb = st_new_renderbuffer_fb(format, samples, sw);
-   if (!rb)
-      return FALSE;
-
-   if (idx != BUFFER_DEPTH) {
-      _mesa_add_renderbuffer(&stfb->Base, idx, rb);
-   }
-   else {
-      if (util_format_get_component_bits(format, UTIL_FORMAT_COLORSPACE_ZS, 0))
-         _mesa_add_renderbuffer(&stfb->Base, BUFFER_DEPTH, rb);
-      if (util_format_get_component_bits(format, UTIL_FORMAT_COLORSPACE_ZS, 1))
-         _mesa_add_renderbuffer(&stfb->Base, BUFFER_STENCIL, rb);
-   }
-
-   return TRUE;
-}
-
-/**
- * Intialize a struct gl_config from a visual.
- */
-static void
-st_visual_to_context_mode(const struct st_visual *visual,
-                          struct gl_config *mode)
-{
-   memset(mode, 0, sizeof(*mode));
-
-   if (st_visual_have_buffers(visual, ST_ATTACHMENT_BACK_LEFT_MASK))
-      mode->doubleBufferMode = GL_TRUE;
-   if (st_visual_have_buffers(visual,
-            ST_ATTACHMENT_FRONT_RIGHT_MASK | ST_ATTACHMENT_BACK_RIGHT_MASK))
-      mode->stereoMode = GL_TRUE;
-
-   if (visual->color_format != PIPE_FORMAT_NONE) {
-      mode->rgbMode = GL_TRUE;
-
-      mode->redBits =
-         util_format_get_component_bits(visual->color_format,
-               UTIL_FORMAT_COLORSPACE_RGB, 0);
-      mode->greenBits =
-         util_format_get_component_bits(visual->color_format,
-               UTIL_FORMAT_COLORSPACE_RGB, 1);
-      mode->blueBits =
-         util_format_get_component_bits(visual->color_format,
-               UTIL_FORMAT_COLORSPACE_RGB, 2);
-      mode->alphaBits =
-         util_format_get_component_bits(visual->color_format,
-               UTIL_FORMAT_COLORSPACE_RGB, 3);
-
-      mode->rgbBits = mode->redBits +
-         mode->greenBits + mode->blueBits + mode->alphaBits;
-   }
-
-   if (visual->depth_stencil_format != PIPE_FORMAT_NONE) {
-      mode->depthBits =
-         util_format_get_component_bits(visual->depth_stencil_format,
-               UTIL_FORMAT_COLORSPACE_ZS, 0);
-      mode->stencilBits =
-         util_format_get_component_bits(visual->depth_stencil_format,
-               UTIL_FORMAT_COLORSPACE_ZS, 1);
-
-      mode->haveDepthBuffer = mode->depthBits > 0;
-      mode->haveStencilBuffer = mode->stencilBits > 0;
-   }
-
-   if (visual->accum_format != PIPE_FORMAT_NONE) {
-      mode->haveAccumBuffer = GL_TRUE;
-
-      mode->accumRedBits =
-         util_format_get_component_bits(visual->accum_format,
-               UTIL_FORMAT_COLORSPACE_RGB, 0);
-      mode->accumGreenBits =
-         util_format_get_component_bits(visual->accum_format,
-               UTIL_FORMAT_COLORSPACE_RGB, 1);
-      mode->accumBlueBits =
-         util_format_get_component_bits(visual->accum_format,
-               UTIL_FORMAT_COLORSPACE_RGB, 2);
-      mode->accumAlphaBits =
-         util_format_get_component_bits(visual->accum_format,
-               UTIL_FORMAT_COLORSPACE_RGB, 3);
-   }
-
-   if (visual->samples) {
-      mode->sampleBuffers = 1;
-      mode->samples = visual->samples;
-   }
-}
-
-/**
- * Determine the default draw or read buffer from a visual.
- */
-static void
-st_visual_to_default_buffer(const struct st_visual *visual,
-                            GLenum *buffer, GLint *index)
-{
-   enum st_attachment_type statt;
-   GLenum buf;
-   gl_buffer_index idx;
-
-   statt = visual->render_buffer;
-   /* do nothing if an invalid render buffer is specified */
-   if (statt == ST_ATTACHMENT_INVALID ||
-       !st_visual_have_buffers(visual, 1 << statt))
-      return;
-
-   switch (statt) {
-   case ST_ATTACHMENT_FRONT_LEFT:
-      buf = GL_FRONT_LEFT;
-      idx = BUFFER_FRONT_LEFT;
-      break;
-   case ST_ATTACHMENT_BACK_LEFT:
-      buf = GL_BACK_LEFT;
-      idx = BUFFER_BACK_LEFT;
-      break;
-   case ST_ATTACHMENT_FRONT_RIGHT:
-      buf = GL_FRONT_RIGHT;
-      idx = BUFFER_FRONT_RIGHT;
-      break;
-   case ST_ATTACHMENT_BACK_RIGHT:
-      buf = GL_BACK_RIGHT;
-      idx = BUFFER_BACK_RIGHT;
-      break;
-   default:
-      buf = GL_NONE;
-      idx = BUFFER_COUNT;
-      break;
-   }
-
-   if (buf != GL_NONE) {
-      if (buffer)
-         *buffer = buf;
-      if (index)
-         *index = idx;
-   }
-}
-
-/**
- * Create a framebuffer from a manager interface.
- */
-static struct st_framebuffer *
-st_framebuffer_create(struct st_framebuffer_iface *stfbi)
-{
-   struct st_framebuffer *stfb;
-   struct gl_config mode;
-   gl_buffer_index idx;
-
-   if (!stfbi)
-      return NULL;
-
-   stfb = CALLOC_STRUCT(st_framebuffer);
-   if (!stfb)
-      return NULL;
-
-   st_visual_to_context_mode(stfbi->visual, &mode);
-   _mesa_initialize_window_framebuffer(&stfb->Base, &mode);
-
-   /* modify the draw/read buffers of the fb */
-   st_visual_to_default_buffer(stfbi->visual, &stfb->Base.ColorDrawBuffer[0],
-         &stfb->Base._ColorDrawBufferIndexes[0]);
-   st_visual_to_default_buffer(stfbi->visual, &stfb->Base.ColorReadBuffer,
-         &stfb->Base._ColorReadBufferIndex);
-
-   stfb->iface = stfbi;
-
-   /* add the color buffer */
-   idx = stfb->Base._ColorDrawBufferIndexes[0];
-   if (!st_framebuffer_add_renderbuffer(stfb, idx)) {
-      FREE(stfb);
-      return NULL;
-   }
-
-   st_framebuffer_add_renderbuffer(stfb, BUFFER_DEPTH);
-   st_framebuffer_add_renderbuffer(stfb, BUFFER_ACCUM);
-
-   st_framebuffer_update_attachments(stfb);
-
-   stfb->Base.Initialized = GL_TRUE;
-
-   return stfb;
-}
-
-/**
- * Reference a framebuffer.
- */
-static void
-st_framebuffer_reference(struct st_framebuffer **ptr,
-                         struct st_framebuffer *stfb)
-{
-   struct gl_framebuffer *fb = &stfb->Base;
-   _mesa_reference_framebuffer((struct gl_framebuffer **) ptr, fb);
-}
-
-static void
-st_context_notify_invalid_framebuffer(struct st_context_iface *stctxi,
-                                      struct st_framebuffer_iface *stfbi)
-{
-   struct st_context *st = (struct st_context *) stctxi;
-   struct st_framebuffer *stfb;
-
-   /* either draw or read winsys fb */
-   stfb = st_ws_framebuffer(st->ctx->WinSysDrawBuffer);
-   if (!stfb || stfb->iface != stfbi)
-      stfb = st_ws_framebuffer(st->ctx->WinSysReadBuffer);
-
-   if (stfb && stfb->iface == stfbi) {
-      p_atomic_set(&stfb->revalidate, TRUE);
-   }
-   else {
-      /* This function is probably getting called when we've detected a
-       * change in a window's size but the currently bound context is
-       * not bound to that window.
-       * If the st_framebuffer_iface structure had a pointer to the
-       * corresponding st_framebuffer we'd be able to handle this.
-       */
-   }
-}
-
-static void
-st_context_flush(struct st_context_iface *stctxi, unsigned flags,
-                 struct pipe_fence_handle **fence)
-{
-   struct st_context *st = (struct st_context *) stctxi;
-   st_flush(st, flags, fence);
-   if (flags & PIPE_FLUSH_RENDER_CACHE)
-      st_manager_flush_frontbuffer(st);
-}
-
-static boolean
-st_context_teximage(struct st_context_iface *stctxi,
-                    enum st_texture_type target,
-                    int level, enum pipe_format internal_format,
-                    struct pipe_resource *tex, boolean mipmap)
-{
-   struct st_context *st = (struct st_context *) stctxi;
-   struct gl_context *ctx = st->ctx;
-   struct gl_texture_unit *texUnit = _mesa_get_current_tex_unit(ctx);
-   struct gl_texture_object *texObj;
-   struct gl_texture_image *texImage;
-   struct st_texture_object *stObj;
-   struct st_texture_image *stImage;
-   GLenum internalFormat;
-   GLuint width, height, depth;
-
-   switch (target) {
-   case ST_TEXTURE_1D:
-      target = GL_TEXTURE_1D;
-      break;
-   case ST_TEXTURE_2D:
-      target = GL_TEXTURE_2D;
-      break;
-   case ST_TEXTURE_3D:
-      target = GL_TEXTURE_3D;
-      break;
-   case ST_TEXTURE_RECT:
-      target = GL_TEXTURE_RECTANGLE_ARB;
-      break;
-   default:
-      return FALSE;
-      break;
-   }
-
-   texObj = _mesa_select_tex_object(ctx, texUnit, target);
-   _mesa_lock_texture(ctx, texObj);
-
-   stObj = st_texture_object(texObj);
-   /* switch to surface based */
-   if (!stObj->surface_based) {
-      _mesa_clear_texture_object(ctx, texObj);
-      stObj->surface_based = GL_TRUE;
-   }
-
-   texImage = _mesa_get_tex_image(ctx, texObj, target, level);
-   stImage = st_texture_image(texImage);
-   if (tex) {
-      gl_format texFormat;
-
-      /*
-       * XXX When internal_format and tex->format differ, st_finalize_texture
-       * needs to allocate a new texture with internal_format and copy the
-       * texture here into the new one.  It will result in surface_copy being
-       * called on surfaces whose formats differ.
-       *
-       * To avoid that, internal_format is (wrongly) ignored here.  A sane fix
-       * is to use a sampler view.
-       */
-      if (!st_sampler_compat_formats(tex->format, internal_format))
-	 internal_format = tex->format;
-     
-      if (util_format_get_component_bits(internal_format,
-               UTIL_FORMAT_COLORSPACE_RGB, 3) > 0)
-         internalFormat = GL_RGBA;
-      else
-         internalFormat = GL_RGB;
-
-      texFormat = st_ChooseTextureFormat(ctx, internalFormat,
-                                         GL_RGBA, GL_UNSIGNED_BYTE);
-
-      _mesa_init_teximage_fields(ctx, target, texImage,
-                                 tex->width0, tex->height0, 1, 0,
-                                 internalFormat, texFormat);
-
-      width = tex->width0;
-      height = tex->height0;
-      depth = tex->depth0;
-
-      /* grow the image size until we hit level = 0 */
-      while (level > 0) {
-         if (width != 1)
-            width <<= 1;
-         if (height != 1)
-            height <<= 1;
-         if (depth != 1)
-            depth <<= 1;
-         level--;
-      }
-   }
-   else {
-      _mesa_clear_texture_image(ctx, texImage);
-      width = height = depth = 0;
-   }
-
-   pipe_resource_reference(&stImage->pt, tex);
-   stObj->width0 = width;
-   stObj->height0 = height;
-   stObj->depth0 = depth;
-
-   _mesa_dirty_texobj(ctx, texObj, GL_TRUE);
-   _mesa_unlock_texture(ctx, texObj);
-   
-   return TRUE;
-}
-
-static void
-st_context_copy(struct st_context_iface *stctxi,
-                struct st_context_iface *stsrci, unsigned mask)
-{
-   struct st_context *st = (struct st_context *) stctxi;
-   struct st_context *src = (struct st_context *) stsrci;
-
-   _mesa_copy_context(src->ctx, st->ctx, mask);
-}
-
-static boolean
-st_context_share(struct st_context_iface *stctxi,
-                 struct st_context_iface *stsrci)
-{
-   struct st_context *st = (struct st_context *) stctxi;
-   struct st_context *src = (struct st_context *) stsrci;
-
-   return _mesa_share_state(st->ctx, src->ctx);
-}
-
-static void
-st_context_destroy(struct st_context_iface *stctxi)
-{
-   struct st_context *st = (struct st_context *) stctxi;
-   st_destroy_context(st);
-}
-
-static struct st_context_iface *
-st_api_create_context(struct st_api *stapi, struct st_manager *smapi,
-                      const struct st_context_attribs *attribs,
-                      struct st_context_iface *shared_stctxi)
-{
-   struct st_context *shared_ctx = (struct st_context *) shared_stctxi;
-   struct st_context *st;
-   struct pipe_context *pipe;
-   struct gl_config mode;
-   gl_api api;
-
-   if (!(stapi->profile_mask & (1 << attribs->profile)))
-      return NULL;
-
-   switch (attribs->profile) {
-   case ST_PROFILE_DEFAULT:
-      api = API_OPENGL;
-      break;
-   case ST_PROFILE_OPENGL_ES1:
-      api = API_OPENGLES;
-      break;
-   case ST_PROFILE_OPENGL_ES2:
-      api = API_OPENGLES2;
-      break;
-   case ST_PROFILE_OPENGL_CORE:
-   default:
-      return NULL;
-      break;
-   }
-
-   pipe = smapi->screen->context_create(smapi->screen, NULL);
-   if (!pipe)
-      return NULL;
-
-   st_visual_to_context_mode(&attribs->visual, &mode);
-   st = st_create_context(api, pipe, &mode, shared_ctx);
-   if (!st) {
-      pipe->destroy(pipe);
-      return NULL;
-   }
-
-   /* need to perform version check */
-   if (attribs->major > 1 || attribs->minor > 0) {
-      _mesa_compute_version(st->ctx);
-
-      /* is the actual version less than the requested version? */
-      if (st->ctx->VersionMajor * 10 + st->ctx->VersionMinor <
-          attribs->major * 10 + attribs->minor) {
-         st_destroy_context(st);
-         return NULL;
-      }
-   }
-
-   st->invalidate_on_gl_viewport =
-      smapi->get_param(smapi, ST_MANAGER_BROKEN_INVALIDATE);
-
-   st->iface.destroy = st_context_destroy;
-   st->iface.notify_invalid_framebuffer =
-      st_context_notify_invalid_framebuffer;
-   st->iface.flush = st_context_flush;
-   st->iface.teximage = st_context_teximage;
-   st->iface.copy = st_context_copy;
-   st->iface.share = st_context_share;
-   st->iface.st_context_private = (void *) smapi;
-
-   return &st->iface;
-}
-
-static boolean
-st_api_make_current(struct st_api *stapi, struct st_context_iface *stctxi,
-                    struct st_framebuffer_iface *stdrawi,
-                    struct st_framebuffer_iface *streadi)
-{
-   struct st_context *st = (struct st_context *) stctxi;
-   struct st_framebuffer *stdraw, *stread, *stfb;
-   boolean ret;
-
-   _glapi_check_multithread();
-
-   if (st) {
-      /* reuse/create the draw fb */
-      stfb = st_ws_framebuffer(st->ctx->WinSysDrawBuffer);
-      if (stfb && stfb->iface == stdrawi) {
-         stdraw = NULL;
-         st_framebuffer_reference(&stdraw, stfb);
-      }
-      else {
-         stdraw = st_framebuffer_create(stdrawi);
-      }
-
-      /* reuse/create the read fb */
-      stfb = st_ws_framebuffer(st->ctx->WinSysReadBuffer);
-      if (!stfb || stfb->iface != streadi)
-         stfb = stdraw;
-      if (stfb && stfb->iface == streadi) {
-         stread = NULL;
-         st_framebuffer_reference(&stread, stfb);
-      }
-      else {
-         stread = st_framebuffer_create(streadi);
-      }
-
-      if (stdraw && stread) {
-         st_framebuffer_validate(stdraw, st);
-         if (stread != stdraw)
-            st_framebuffer_validate(stread, st);
-
-         /* modify the draw/read buffers of the context */
-         if (stdraw->iface) {
-            st_visual_to_default_buffer(stdraw->iface->visual,
-                  &st->ctx->Color.DrawBuffer[0], NULL);
-         }
-         if (stread->iface) {
-            st_visual_to_default_buffer(stread->iface->visual,
-                  &st->ctx->Pixel.ReadBuffer, NULL);
-         }
-
-         ret = _mesa_make_current(st->ctx, &stdraw->Base, &stread->Base);
-      }
-      else {
-         struct gl_framebuffer *incomplete = _mesa_get_incomplete_framebuffer();
-         ret = _mesa_make_current(st->ctx, incomplete, incomplete);
-      }
-
-      st_framebuffer_reference(&stdraw, NULL);
-      st_framebuffer_reference(&stread, NULL);
-   }
-   else {
-      ret = _mesa_make_current(NULL, NULL, NULL);
-   }
-
-   return ret;
-}
-
-static struct st_context_iface *
-st_api_get_current(struct st_api *stapi)
-{
-   GET_CURRENT_CONTEXT(ctx);
-   struct st_context *st = (ctx) ? ctx->st : NULL;
-
-   return (st) ? &st->iface : NULL;
-}
-
-static st_proc_t
-st_api_get_proc_address(struct st_api *stapi, const char *procname)
-{
-   return (st_proc_t) _glapi_get_proc_address(procname);
-}
-
-static void
-st_api_destroy(struct st_api *stapi)
-{
-}
-
-/**
- * Flush the front buffer if the current context renders to the front buffer.
- */
-void
-st_manager_flush_frontbuffer(struct st_context *st)
-{
-   struct st_framebuffer *stfb = st_ws_framebuffer(st->ctx->DrawBuffer);
-   struct st_renderbuffer *strb = NULL;
-
-   if (stfb)
-      strb = st_renderbuffer(stfb->Base.Attachment[BUFFER_FRONT_LEFT].Renderbuffer);
-   if (!strb)
-      return;
-
-   /* never a dummy fb */
-   assert(stfb->iface);
-   stfb->iface->flush_front(stfb->iface, ST_ATTACHMENT_FRONT_LEFT);
-}
-
-/**
- * Return the surface of an EGLImage.
- * FIXME: I think this should operate on resources, not surfaces
- */
-struct pipe_surface *
-st_manager_get_egl_image_surface(struct st_context *st,
-                                 void *eglimg, unsigned usage)
-{
-   struct st_manager *smapi =
-      (struct st_manager *) st->iface.st_context_private;
-   struct st_egl_image stimg;
-   struct pipe_surface *ps, surf_tmpl;
-
-   if (!smapi || !smapi->get_egl_image)
-      return NULL;
-
-   memset(&stimg, 0, sizeof(stimg));
-   if (!smapi->get_egl_image(smapi, eglimg, &stimg))
-      return NULL;
-
-   memset(&surf_tmpl, 0, sizeof(surf_tmpl));
-   surf_tmpl.format = stimg.texture->format;
-   surf_tmpl.usage = usage;
-   surf_tmpl.u.tex.level = stimg.level;
-   surf_tmpl.u.tex.first_layer = stimg.layer;
-   surf_tmpl.u.tex.last_layer = stimg.layer;
-   ps = st->pipe->create_surface(st->pipe, stimg.texture, &surf_tmpl);
-   pipe_resource_reference(&stimg.texture, NULL);
-
-   return ps;
-}
-
-/**
- * Re-validate the framebuffers.
- */
-void
-st_manager_validate_framebuffers(struct st_context *st)
-{
-   struct st_framebuffer *stdraw = st_ws_framebuffer(st->ctx->DrawBuffer);
-   struct st_framebuffer *stread = st_ws_framebuffer(st->ctx->ReadBuffer);
-
-   if (stdraw)
-      st_framebuffer_validate(stdraw, st);
-   if (stread && stread != stdraw)
-      st_framebuffer_validate(stread, st);
-}
-
-/**
- * Add a color renderbuffer on demand.
- */
-boolean
-st_manager_add_color_renderbuffer(struct st_context *st,
-                                  struct gl_framebuffer *fb,
-                                  gl_buffer_index idx)
-{
-   struct st_framebuffer *stfb = st_ws_framebuffer(fb);
-
-   /* FBO */
-   if (!stfb)
-      return FALSE;
-
-   if (stfb->Base.Attachment[idx].Renderbuffer)
-      return TRUE;
-
-   switch (idx) {
-   case BUFFER_FRONT_LEFT:
-   case BUFFER_BACK_LEFT:
-   case BUFFER_FRONT_RIGHT:
-   case BUFFER_BACK_RIGHT:
-      break;
-   default:
-      return FALSE;
-      break;
-   }
-
-   if (!st_framebuffer_add_renderbuffer(stfb, idx))
-      return FALSE;
-
-   st_framebuffer_update_attachments(stfb);
-   st_invalidate_state(st->ctx, _NEW_BUFFERS);
-
-   return TRUE;
-}
-
-static const struct st_api st_gl_api = {
-   "Mesa " MESA_VERSION_STRING,
-   ST_API_OPENGL,
-#if FEATURE_GL
-   ST_PROFILE_DEFAULT_MASK |
-#endif
-#if FEATURE_ES1
-   ST_PROFILE_OPENGL_ES1_MASK |
-#endif
-#if FEATURE_ES2
-   ST_PROFILE_OPENGL_ES2_MASK |
-#endif
-   0,
-   st_api_destroy,
-   st_api_get_proc_address,
-   st_api_create_context,
-   st_api_make_current,
-   st_api_get_current,
-};
-
-struct st_api *
-st_gl_api_create(void)
-{
-   return (struct st_api *) &st_gl_api;
-}
+/*

+ * Mesa 3-D graphics library

+ * Version:  7.9

+ *

+ * Copyright (C) 2010 LunarG Inc.

+ *

+ * 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

+ * THE AUTHORS OR COPYRIGHT HOLDERS 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.

+ *

+ * Authors:

+ *    Chia-I Wu <olv@lunarg.com>

+ */

+

+#include "state_tracker/st_gl_api.h"

+

+#include "pipe/p_context.h"

+#include "pipe/p_screen.h"

+#include "util/u_format.h"

+#include "util/u_pointer.h"

+#include "util/u_inlines.h"

+#include "util/u_atomic.h"

+#include "util/u_surface.h"

+

+#include "main/mtypes.h"

+#include "main/context.h"

+#include "main/mfeatures.h"

+#include "main/texobj.h"

+#include "main/teximage.h"

+#include "main/texstate.h"

+#include "main/framebuffer.h"

+#include "main/fbobject.h"

+#include "main/renderbuffer.h"

+#include "main/version.h"

+#include "st_texture.h"

+

+#include "st_context.h"

+#include "st_format.h"

+#include "st_cb_fbo.h"

+#include "st_cb_flush.h"

+#include "st_manager.h"

+

+/**

+ * Cast wrapper to convert a struct gl_framebuffer to an st_framebuffer.

+ * Return NULL if the struct gl_framebuffer is a user-created framebuffer.

+ * We'll only return non-null for window system framebuffers.

+ * Note that this function may fail.

+ */

+static INLINE struct st_framebuffer *

+st_ws_framebuffer(struct gl_framebuffer *fb)

+{

+   /* FBO cannot be casted.  See st_new_framebuffer */

+   return (struct st_framebuffer *) ((fb && !fb->Name) ? fb : NULL);

+}

+

+/**

+ * Map an attachment to a buffer index.

+ */

+static INLINE gl_buffer_index

+attachment_to_buffer_index(enum st_attachment_type statt)

+{

+   gl_buffer_index index;

+

+   switch (statt) {

+   case ST_ATTACHMENT_FRONT_LEFT:

+      index = BUFFER_FRONT_LEFT;

+      break;

+   case ST_ATTACHMENT_BACK_LEFT:

+      index = BUFFER_BACK_LEFT;

+      break;

+   case ST_ATTACHMENT_FRONT_RIGHT:

+      index = BUFFER_FRONT_RIGHT;

+      break;

+   case ST_ATTACHMENT_BACK_RIGHT:

+      index = BUFFER_BACK_RIGHT;

+      break;

+   case ST_ATTACHMENT_DEPTH_STENCIL:

+      index = BUFFER_DEPTH;

+      break;

+   case ST_ATTACHMENT_ACCUM:

+      index = BUFFER_ACCUM;

+      break;

+   case ST_ATTACHMENT_SAMPLE:

+   default:

+      index = BUFFER_COUNT;

+      break;

+   }

+

+   return index;

+}

+

+/**

+ * Map a buffer index to an attachment.

+ */

+static INLINE enum st_attachment_type

+buffer_index_to_attachment(gl_buffer_index index)

+{

+   enum st_attachment_type statt;

+

+   switch (index) {

+   case BUFFER_FRONT_LEFT:

+      statt = ST_ATTACHMENT_FRONT_LEFT;

+      break;

+   case BUFFER_BACK_LEFT:

+      statt = ST_ATTACHMENT_BACK_LEFT;

+      break;

+   case BUFFER_FRONT_RIGHT:

+      statt = ST_ATTACHMENT_FRONT_RIGHT;

+      break;

+   case BUFFER_BACK_RIGHT:

+      statt = ST_ATTACHMENT_BACK_RIGHT;

+      break;

+   case BUFFER_DEPTH:

+      statt = ST_ATTACHMENT_DEPTH_STENCIL;

+      break;

+   case BUFFER_ACCUM:

+      statt = ST_ATTACHMENT_ACCUM;

+      break;

+   default:

+      statt = ST_ATTACHMENT_INVALID;

+      break;

+   }

+

+   return statt;

+}

+

+/**

+ * Validate a framebuffer to make sure up-to-date pipe_textures are used.

+ */

+static void

+st_framebuffer_validate(struct st_framebuffer *stfb, struct st_context *st)

+{

+   struct pipe_context *pipe = st->pipe;

+   struct pipe_resource *textures[ST_ATTACHMENT_COUNT];

+   uint width, height;

+   unsigned i;

+   boolean changed = FALSE;

+

+   if (!p_atomic_read(&stfb->revalidate))

+      return;

+

+   /* validate the fb */

+   if (!stfb->iface->validate(stfb->iface, stfb->statts, stfb->num_statts, textures))

+      return;

+

+   width = stfb->Base.Width;

+   height = stfb->Base.Height;

+

+   for (i = 0; i < stfb->num_statts; i++) {

+      struct st_renderbuffer *strb;

+      struct pipe_surface *ps, surf_tmpl;

+      gl_buffer_index idx;

+

+      if (!textures[i])

+         continue;

+

+      idx = attachment_to_buffer_index(stfb->statts[i]);

+      if (idx >= BUFFER_COUNT) {

+         pipe_resource_reference(&textures[i], NULL);

+         continue;

+      }

+

+      strb = st_renderbuffer(stfb->Base.Attachment[idx].Renderbuffer);

+      assert(strb);

+      if (strb->texture == textures[i]) {

+         pipe_resource_reference(&textures[i], NULL);

+         continue;

+      }

+

+      memset(&surf_tmpl, 0, sizeof(surf_tmpl));

+      u_surface_default_template(&surf_tmpl, textures[i],

+                                 PIPE_BIND_RENDER_TARGET);

+      ps = pipe->create_surface(pipe, textures[i], &surf_tmpl);

+      if (ps) {

+         pipe_surface_reference(&strb->surface, ps);

+         pipe_resource_reference(&strb->texture, ps->texture);

+         /* ownership transfered */

+         pipe_surface_reference(&ps, NULL);

+

+         changed = TRUE;

+

+         strb->Base.Width = strb->surface->width;

+         strb->Base.Height = strb->surface->height;

+

+         width = strb->Base.Width;

+         height = strb->Base.Height;

+      }

+

+      pipe_resource_reference(&textures[i], NULL);

+   }

+

+   if (changed) {

+      st->dirty.st |= ST_NEW_FRAMEBUFFER;

+      _mesa_resize_framebuffer(st->ctx, &stfb->Base, width, height);

+

+      assert(stfb->Base.Width == width);

+      assert(stfb->Base.Height == height);

+   }

+

+   p_atomic_set(&stfb->revalidate, FALSE);

+}

+

+/**

+ * Update the attachments to validate by looping the existing renderbuffers.

+ */

+static void

+st_framebuffer_update_attachments(struct st_framebuffer *stfb)

+{

+   gl_buffer_index idx;

+

+   stfb->num_statts = 0;

+   for (idx = 0; idx < BUFFER_COUNT; idx++) {

+      struct st_renderbuffer *strb;

+      enum st_attachment_type statt;

+

+      strb = st_renderbuffer(stfb->Base.Attachment[idx].Renderbuffer);

+      if (!strb || strb->software)

+         continue;

+

+      statt = buffer_index_to_attachment(idx);

+      if (statt != ST_ATTACHMENT_INVALID &&

+          st_visual_have_buffers(stfb->iface->visual, 1 << statt))

+         stfb->statts[stfb->num_statts++] = statt;

+   }

+

+   p_atomic_set(&stfb->revalidate, TRUE);

+}

+

+/**

+ * Add a renderbuffer to the framebuffer.

+ */

+static boolean

+st_framebuffer_add_renderbuffer(struct st_framebuffer *stfb,

+                                gl_buffer_index idx)

+{

+   struct gl_renderbuffer *rb;

+   enum pipe_format format;

+   int samples;

+   boolean sw;

+

+   if (!stfb->iface)

+      return FALSE;

+

+   /* do not distinguish depth/stencil buffers */

+   if (idx == BUFFER_STENCIL)

+      idx = BUFFER_DEPTH;

+

+   switch (idx) {

+   case BUFFER_DEPTH:

+      format = stfb->iface->visual->depth_stencil_format;

+      sw = FALSE;

+      break;

+   case BUFFER_ACCUM:

+      format = stfb->iface->visual->accum_format;

+      sw = TRUE;

+      break;

+   default:

+      format = stfb->iface->visual->color_format;

+      sw = FALSE;

+      break;

+   }

+

+   if (format == PIPE_FORMAT_NONE)

+      return FALSE;

+

+   samples = stfb->iface->visual->samples;

+   if (!samples)

+      samples = st_get_msaa();

+

+   rb = st_new_renderbuffer_fb(format, samples, sw);

+   if (!rb)

+      return FALSE;

+

+   if (idx != BUFFER_DEPTH) {

+      _mesa_add_renderbuffer(&stfb->Base, idx, rb);

+   }

+   else {

+      if (util_format_get_component_bits(format, UTIL_FORMAT_COLORSPACE_ZS, 0))

+         _mesa_add_renderbuffer(&stfb->Base, BUFFER_DEPTH, rb);

+      if (util_format_get_component_bits(format, UTIL_FORMAT_COLORSPACE_ZS, 1))

+         _mesa_add_renderbuffer(&stfb->Base, BUFFER_STENCIL, rb);

+   }

+

+   return TRUE;

+}

+

+/**

+ * Intialize a struct gl_config from a visual.

+ */

+static void

+st_visual_to_context_mode(const struct st_visual *visual,

+                          struct gl_config *mode)

+{

+   memset(mode, 0, sizeof(*mode));

+

+   if (st_visual_have_buffers(visual, ST_ATTACHMENT_BACK_LEFT_MASK))

+      mode->doubleBufferMode = GL_TRUE;

+   if (st_visual_have_buffers(visual,

+            ST_ATTACHMENT_FRONT_RIGHT_MASK | ST_ATTACHMENT_BACK_RIGHT_MASK))

+      mode->stereoMode = GL_TRUE;

+

+   if (visual->color_format != PIPE_FORMAT_NONE) {

+      mode->rgbMode = GL_TRUE;

+

+      mode->redBits =

+         util_format_get_component_bits(visual->color_format,

+               UTIL_FORMAT_COLORSPACE_RGB, 0);

+      mode->greenBits =

+         util_format_get_component_bits(visual->color_format,

+               UTIL_FORMAT_COLORSPACE_RGB, 1);

+      mode->blueBits =

+         util_format_get_component_bits(visual->color_format,

+               UTIL_FORMAT_COLORSPACE_RGB, 2);

+      mode->alphaBits =

+         util_format_get_component_bits(visual->color_format,

+               UTIL_FORMAT_COLORSPACE_RGB, 3);

+

+      mode->rgbBits = mode->redBits +

+         mode->greenBits + mode->blueBits + mode->alphaBits;

+   }

+

+   if (visual->depth_stencil_format != PIPE_FORMAT_NONE) {

+      mode->depthBits =

+         util_format_get_component_bits(visual->depth_stencil_format,

+               UTIL_FORMAT_COLORSPACE_ZS, 0);

+      mode->stencilBits =

+         util_format_get_component_bits(visual->depth_stencil_format,

+               UTIL_FORMAT_COLORSPACE_ZS, 1);

+

+      mode->haveDepthBuffer = mode->depthBits > 0;

+      mode->haveStencilBuffer = mode->stencilBits > 0;

+   }

+

+   if (visual->accum_format != PIPE_FORMAT_NONE) {

+      mode->haveAccumBuffer = GL_TRUE;

+

+      mode->accumRedBits =

+         util_format_get_component_bits(visual->accum_format,

+               UTIL_FORMAT_COLORSPACE_RGB, 0);

+      mode->accumGreenBits =

+         util_format_get_component_bits(visual->accum_format,

+               UTIL_FORMAT_COLORSPACE_RGB, 1);

+      mode->accumBlueBits =

+         util_format_get_component_bits(visual->accum_format,

+               UTIL_FORMAT_COLORSPACE_RGB, 2);

+      mode->accumAlphaBits =

+         util_format_get_component_bits(visual->accum_format,

+               UTIL_FORMAT_COLORSPACE_RGB, 3);

+   }

+

+   if (visual->samples) {

+      mode->sampleBuffers = 1;

+      mode->samples = visual->samples;

+   }

+}

+

+/**

+ * Determine the default draw or read buffer from a visual.

+ */

+static void

+st_visual_to_default_buffer(const struct st_visual *visual,

+                            GLenum *buffer, GLint *index)

+{

+   enum st_attachment_type statt;

+   GLenum buf;

+   gl_buffer_index idx;

+

+   statt = visual->render_buffer;

+   /* do nothing if an invalid render buffer is specified */

+   if (statt == ST_ATTACHMENT_INVALID ||

+       !st_visual_have_buffers(visual, 1 << statt))

+      return;

+

+   switch (statt) {

+   case ST_ATTACHMENT_FRONT_LEFT:

+      buf = GL_FRONT_LEFT;

+      idx = BUFFER_FRONT_LEFT;

+      break;

+   case ST_ATTACHMENT_BACK_LEFT:

+      buf = GL_BACK_LEFT;

+      idx = BUFFER_BACK_LEFT;

+      break;

+   case ST_ATTACHMENT_FRONT_RIGHT:

+      buf = GL_FRONT_RIGHT;

+      idx = BUFFER_FRONT_RIGHT;

+      break;

+   case ST_ATTACHMENT_BACK_RIGHT:

+      buf = GL_BACK_RIGHT;

+      idx = BUFFER_BACK_RIGHT;

+      break;

+   default:

+      buf = GL_NONE;

+      idx = BUFFER_COUNT;

+      break;

+   }

+

+   if (buf != GL_NONE) {

+      if (buffer)

+         *buffer = buf;

+      if (index)

+         *index = idx;

+   }

+}

+

+/**

+ * Create a framebuffer from a manager interface.

+ */

+static struct st_framebuffer *

+st_framebuffer_create(struct st_framebuffer_iface *stfbi)

+{

+   struct st_framebuffer *stfb;

+   struct gl_config mode;

+   gl_buffer_index idx;

+

+   if (!stfbi)

+      return NULL;

+

+   stfb = CALLOC_STRUCT(st_framebuffer);

+   if (!stfb)

+      return NULL;

+

+   st_visual_to_context_mode(stfbi->visual, &mode);

+   _mesa_initialize_window_framebuffer(&stfb->Base, &mode);

+

+   /* modify the draw/read buffers of the fb */

+   st_visual_to_default_buffer(stfbi->visual, &stfb->Base.ColorDrawBuffer[0],

+         &stfb->Base._ColorDrawBufferIndexes[0]);

+   st_visual_to_default_buffer(stfbi->visual, &stfb->Base.ColorReadBuffer,

+         &stfb->Base._ColorReadBufferIndex);

+

+   stfb->iface = stfbi;

+

+   /* add the color buffer */

+   idx = stfb->Base._ColorDrawBufferIndexes[0];

+   if (!st_framebuffer_add_renderbuffer(stfb, idx)) {

+      FREE(stfb);

+      return NULL;

+   }

+

+   st_framebuffer_add_renderbuffer(stfb, BUFFER_DEPTH);

+   st_framebuffer_add_renderbuffer(stfb, BUFFER_ACCUM);

+

+   st_framebuffer_update_attachments(stfb);

+

+   stfb->Base.Initialized = GL_TRUE;

+

+   return stfb;

+}

+

+/**

+ * Reference a framebuffer.

+ */

+static void

+st_framebuffer_reference(struct st_framebuffer **ptr,

+                         struct st_framebuffer *stfb)

+{

+   struct gl_framebuffer *fb = &stfb->Base;

+   _mesa_reference_framebuffer((struct gl_framebuffer **) ptr, fb);

+}

+

+static void

+st_context_notify_invalid_framebuffer(struct st_context_iface *stctxi,

+                                      struct st_framebuffer_iface *stfbi)

+{

+   struct st_context *st = (struct st_context *) stctxi;

+   struct st_framebuffer *stfb;

+

+   /* either draw or read winsys fb */

+   stfb = st_ws_framebuffer(st->ctx->WinSysDrawBuffer);

+   if (!stfb || stfb->iface != stfbi)

+      stfb = st_ws_framebuffer(st->ctx->WinSysReadBuffer);

+

+   if (stfb && stfb->iface == stfbi) {

+      p_atomic_set(&stfb->revalidate, TRUE);

+   }

+   else {

+      /* This function is probably getting called when we've detected a

+       * change in a window's size but the currently bound context is

+       * not bound to that window.

+       * If the st_framebuffer_iface structure had a pointer to the

+       * corresponding st_framebuffer we'd be able to handle this.

+       */

+   }

+}

+

+static void

+st_context_flush(struct st_context_iface *stctxi, unsigned flags,

+                 struct pipe_fence_handle **fence)

+{

+   struct st_context *st = (struct st_context *) stctxi;

+   st_flush(st, fence);

+   if (flags & ST_FLUSH_FRONT)

+      st_manager_flush_frontbuffer(st);

+}

+

+static boolean

+st_context_teximage(struct st_context_iface *stctxi,

+                    enum st_texture_type target,

+                    int level, enum pipe_format internal_format,

+                    struct pipe_resource *tex, boolean mipmap)

+{

+   struct st_context *st = (struct st_context *) stctxi;

+   struct gl_context *ctx = st->ctx;

+   struct gl_texture_unit *texUnit = _mesa_get_current_tex_unit(ctx);

+   struct gl_texture_object *texObj;

+   struct gl_texture_image *texImage;

+   struct st_texture_object *stObj;

+   struct st_texture_image *stImage;

+   GLenum internalFormat;

+   GLuint width, height, depth;

+

+   switch (target) {

+   case ST_TEXTURE_1D:

+      target = GL_TEXTURE_1D;

+      break;

+   case ST_TEXTURE_2D:

+      target = GL_TEXTURE_2D;

+      break;

+   case ST_TEXTURE_3D:

+      target = GL_TEXTURE_3D;

+      break;

+   case ST_TEXTURE_RECT:

+      target = GL_TEXTURE_RECTANGLE_ARB;

+      break;

+   default:

+      return FALSE;

+      break;

+   }

+

+   texObj = _mesa_select_tex_object(ctx, texUnit, target);

+   _mesa_lock_texture(ctx, texObj);

+

+   stObj = st_texture_object(texObj);

+   /* switch to surface based */

+   if (!stObj->surface_based) {

+      _mesa_clear_texture_object(ctx, texObj);

+      stObj->surface_based = GL_TRUE;

+   }

+

+   texImage = _mesa_get_tex_image(ctx, texObj, target, level);

+   stImage = st_texture_image(texImage);

+   if (tex) {

+      gl_format texFormat;

+

+      /*

+       * XXX When internal_format and tex->format differ, st_finalize_texture

+       * needs to allocate a new texture with internal_format and copy the

+       * texture here into the new one.  It will result in surface_copy being

+       * called on surfaces whose formats differ.

+       *

+       * To avoid that, internal_format is (wrongly) ignored here.  A sane fix

+       * is to use a sampler view.

+       */

+      if (!st_sampler_compat_formats(tex->format, internal_format))

+	 internal_format = tex->format;

+     

+      if (util_format_get_component_bits(internal_format,

+               UTIL_FORMAT_COLORSPACE_RGB, 3) > 0)

+         internalFormat = GL_RGBA;

+      else

+         internalFormat = GL_RGB;

+

+      texFormat = st_ChooseTextureFormat(ctx, internalFormat,

+                                         GL_RGBA, GL_UNSIGNED_BYTE);

+

+      _mesa_init_teximage_fields(ctx, target, texImage,

+                                 tex->width0, tex->height0, 1, 0,

+                                 internalFormat, texFormat);

+

+      width = tex->width0;

+      height = tex->height0;

+      depth = tex->depth0;

+

+      /* grow the image size until we hit level = 0 */

+      while (level > 0) {

+         if (width != 1)

+            width <<= 1;

+         if (height != 1)

+            height <<= 1;

+         if (depth != 1)

+            depth <<= 1;

+         level--;

+      }

+   }

+   else {

+      _mesa_clear_texture_image(ctx, texImage);

+      width = height = depth = 0;

+   }

+

+   pipe_resource_reference(&stImage->pt, tex);

+   stObj->width0 = width;

+   stObj->height0 = height;

+   stObj->depth0 = depth;

+

+   _mesa_dirty_texobj(ctx, texObj, GL_TRUE);

+   _mesa_unlock_texture(ctx, texObj);

+   

+   return TRUE;

+}

+

+static void

+st_context_copy(struct st_context_iface *stctxi,

+                struct st_context_iface *stsrci, unsigned mask)

+{

+   struct st_context *st = (struct st_context *) stctxi;

+   struct st_context *src = (struct st_context *) stsrci;

+

+   _mesa_copy_context(src->ctx, st->ctx, mask);

+}

+

+static boolean

+st_context_share(struct st_context_iface *stctxi,

+                 struct st_context_iface *stsrci)

+{

+   struct st_context *st = (struct st_context *) stctxi;

+   struct st_context *src = (struct st_context *) stsrci;

+

+   return _mesa_share_state(st->ctx, src->ctx);

+}

+

+static void

+st_context_destroy(struct st_context_iface *stctxi)

+{

+   struct st_context *st = (struct st_context *) stctxi;

+   st_destroy_context(st);

+}

+

+static struct st_context_iface *

+st_api_create_context(struct st_api *stapi, struct st_manager *smapi,

+                      const struct st_context_attribs *attribs,

+                      struct st_context_iface *shared_stctxi)

+{

+   struct st_context *shared_ctx = (struct st_context *) shared_stctxi;

+   struct st_context *st;

+   struct pipe_context *pipe;

+   struct gl_config mode;

+   gl_api api;

+

+   if (!(stapi->profile_mask & (1 << attribs->profile)))

+      return NULL;

+

+   switch (attribs->profile) {

+   case ST_PROFILE_DEFAULT:

+      api = API_OPENGL;

+      break;

+   case ST_PROFILE_OPENGL_ES1:

+      api = API_OPENGLES;

+      break;

+   case ST_PROFILE_OPENGL_ES2:

+      api = API_OPENGLES2;

+      break;

+   case ST_PROFILE_OPENGL_CORE:

+   default:

+      return NULL;

+      break;

+   }

+

+   pipe = smapi->screen->context_create(smapi->screen, NULL);

+   if (!pipe)

+      return NULL;

+

+   st_visual_to_context_mode(&attribs->visual, &mode);

+   st = st_create_context(api, pipe, &mode, shared_ctx);

+   if (!st) {

+      pipe->destroy(pipe);

+      return NULL;

+   }

+

+   /* need to perform version check */

+   if (attribs->major > 1 || attribs->minor > 0) {

+      _mesa_compute_version(st->ctx);

+

+      /* is the actual version less than the requested version? */

+      if (st->ctx->VersionMajor * 10 + st->ctx->VersionMinor <

+          attribs->major * 10 + attribs->minor) {

+         st_destroy_context(st);

+         return NULL;

+      }

+   }

+

+   st->invalidate_on_gl_viewport =

+      smapi->get_param(smapi, ST_MANAGER_BROKEN_INVALIDATE);

+

+   st->iface.destroy = st_context_destroy;

+   st->iface.notify_invalid_framebuffer =

+      st_context_notify_invalid_framebuffer;

+   st->iface.flush = st_context_flush;

+   st->iface.teximage = st_context_teximage;

+   st->iface.copy = st_context_copy;

+   st->iface.share = st_context_share;

+   st->iface.st_context_private = (void *) smapi;

+

+   return &st->iface;

+}

+

+static boolean

+st_api_make_current(struct st_api *stapi, struct st_context_iface *stctxi,

+                    struct st_framebuffer_iface *stdrawi,

+                    struct st_framebuffer_iface *streadi)

+{

+   struct st_context *st = (struct st_context *) stctxi;

+   struct st_framebuffer *stdraw, *stread, *stfb;

+   boolean ret;

+

+   _glapi_check_multithread();

+

+   if (st) {

+      /* reuse/create the draw fb */

+      stfb = st_ws_framebuffer(st->ctx->WinSysDrawBuffer);

+      if (stfb && stfb->iface == stdrawi) {

+         stdraw = NULL;

+         st_framebuffer_reference(&stdraw, stfb);

+      }

+      else {

+         stdraw = st_framebuffer_create(stdrawi);

+      }

+

+      /* reuse/create the read fb */

+      stfb = st_ws_framebuffer(st->ctx->WinSysReadBuffer);

+      if (!stfb || stfb->iface != streadi)

+         stfb = stdraw;

+      if (stfb && stfb->iface == streadi) {

+         stread = NULL;

+         st_framebuffer_reference(&stread, stfb);

+      }

+      else {

+         stread = st_framebuffer_create(streadi);

+      }

+

+      if (stdraw && stread) {

+         st_framebuffer_validate(stdraw, st);

+         if (stread != stdraw)

+            st_framebuffer_validate(stread, st);

+

+         /* modify the draw/read buffers of the context */

+         if (stdraw->iface) {

+            st_visual_to_default_buffer(stdraw->iface->visual,

+                  &st->ctx->Color.DrawBuffer[0], NULL);

+         }

+         if (stread->iface) {

+            st_visual_to_default_buffer(stread->iface->visual,

+                  &st->ctx->Pixel.ReadBuffer, NULL);

+         }

+

+         ret = _mesa_make_current(st->ctx, &stdraw->Base, &stread->Base);

+      }

+      else {

+         struct gl_framebuffer *incomplete = _mesa_get_incomplete_framebuffer();

+         ret = _mesa_make_current(st->ctx, incomplete, incomplete);

+      }

+

+      st_framebuffer_reference(&stdraw, NULL);

+      st_framebuffer_reference(&stread, NULL);

+   }

+   else {

+      ret = _mesa_make_current(NULL, NULL, NULL);

+   }

+

+   return ret;

+}

+

+static struct st_context_iface *

+st_api_get_current(struct st_api *stapi)

+{

+   GET_CURRENT_CONTEXT(ctx);

+   struct st_context *st = (ctx) ? ctx->st : NULL;

+

+   return (st) ? &st->iface : NULL;

+}

+

+static st_proc_t

+st_api_get_proc_address(struct st_api *stapi, const char *procname)

+{

+   return (st_proc_t) _glapi_get_proc_address(procname);

+}

+

+static void

+st_api_destroy(struct st_api *stapi)

+{

+}

+

+/**

+ * Flush the front buffer if the current context renders to the front buffer.

+ */

+void

+st_manager_flush_frontbuffer(struct st_context *st)

+{

+   struct st_framebuffer *stfb = st_ws_framebuffer(st->ctx->DrawBuffer);

+   struct st_renderbuffer *strb = NULL;

+

+   if (stfb)

+      strb = st_renderbuffer(stfb->Base.Attachment[BUFFER_FRONT_LEFT].Renderbuffer);

+   if (!strb)

+      return;

+

+   /* never a dummy fb */

+   assert(stfb->iface);

+   stfb->iface->flush_front(stfb->iface, ST_ATTACHMENT_FRONT_LEFT);

+}

+

+/**

+ * Return the surface of an EGLImage.

+ * FIXME: I think this should operate on resources, not surfaces

+ */

+struct pipe_surface *

+st_manager_get_egl_image_surface(struct st_context *st,

+                                 void *eglimg, unsigned usage)

+{

+   struct st_manager *smapi =

+      (struct st_manager *) st->iface.st_context_private;

+   struct st_egl_image stimg;

+   struct pipe_surface *ps, surf_tmpl;

+

+   if (!smapi || !smapi->get_egl_image)

+      return NULL;

+

+   memset(&stimg, 0, sizeof(stimg));

+   if (!smapi->get_egl_image(smapi, eglimg, &stimg))

+      return NULL;

+

+   memset(&surf_tmpl, 0, sizeof(surf_tmpl));

+   surf_tmpl.format = stimg.texture->format;

+   surf_tmpl.usage = usage;

+   surf_tmpl.u.tex.level = stimg.level;

+   surf_tmpl.u.tex.first_layer = stimg.layer;

+   surf_tmpl.u.tex.last_layer = stimg.layer;

+   ps = st->pipe->create_surface(st->pipe, stimg.texture, &surf_tmpl);

+   pipe_resource_reference(&stimg.texture, NULL);

+

+   return ps;

+}

+

+/**

+ * Re-validate the framebuffers.

+ */

+void

+st_manager_validate_framebuffers(struct st_context *st)

+{

+   struct st_framebuffer *stdraw = st_ws_framebuffer(st->ctx->DrawBuffer);

+   struct st_framebuffer *stread = st_ws_framebuffer(st->ctx->ReadBuffer);

+

+   if (stdraw)

+      st_framebuffer_validate(stdraw, st);

+   if (stread && stread != stdraw)

+      st_framebuffer_validate(stread, st);

+}

+

+/**

+ * Add a color renderbuffer on demand.

+ */

+boolean

+st_manager_add_color_renderbuffer(struct st_context *st,

+                                  struct gl_framebuffer *fb,

+                                  gl_buffer_index idx)

+{

+   struct st_framebuffer *stfb = st_ws_framebuffer(fb);

+

+   /* FBO */

+   if (!stfb)

+      return FALSE;

+

+   if (stfb->Base.Attachment[idx].Renderbuffer)

+      return TRUE;

+

+   switch (idx) {

+   case BUFFER_FRONT_LEFT:

+   case BUFFER_BACK_LEFT:

+   case BUFFER_FRONT_RIGHT:

+   case BUFFER_BACK_RIGHT:

+      break;

+   default:

+      return FALSE;

+      break;

+   }

+

+   if (!st_framebuffer_add_renderbuffer(stfb, idx))

+      return FALSE;

+

+   st_framebuffer_update_attachments(stfb);

+   st_invalidate_state(st->ctx, _NEW_BUFFERS);

+

+   return TRUE;

+}

+

+static const struct st_api st_gl_api = {

+   "Mesa " MESA_VERSION_STRING,

+   ST_API_OPENGL,

+#if FEATURE_GL

+   ST_PROFILE_DEFAULT_MASK |

+#endif

+#if FEATURE_ES1

+   ST_PROFILE_OPENGL_ES1_MASK |

+#endif

+#if FEATURE_ES2

+   ST_PROFILE_OPENGL_ES2_MASK |

+#endif

+   0,

+   st_api_destroy,

+   st_api_get_proc_address,

+   st_api_create_context,

+   st_api_make_current,

+   st_api_get_current,

+};

+

+struct st_api *

+st_gl_api_create(void)

+{

+   return (struct st_api *) &st_gl_api;

+}

diff --git a/mesalib/src/mesa/state_tracker/st_texture.c b/mesalib/src/mesa/state_tracker/st_texture.c
index 0d5dc8140..22ec1306c 100644
--- a/mesalib/src/mesa/state_tracker/st_texture.c
+++ b/mesalib/src/mesa/state_tracker/st_texture.c
@@ -78,7 +78,7 @@ st_texture_create(struct st_context *st,
 

    assert(format);

    assert(screen->is_format_supported(screen, format, target, 0,

-                                      PIPE_BIND_SAMPLER_VIEW, 0));

+                                      PIPE_BIND_SAMPLER_VIEW));

 

    memset(&pt, 0, sizeof(pt));

    pt.target = target;

diff --git a/mesalib/src/mesa/swrast/s_aatriangle.c b/mesalib/src/mesa/swrast/s_aatriangle.c
index ba92fc14a..07667226a 100644
--- a/mesalib/src/mesa/swrast/s_aatriangle.c
+++ b/mesalib/src/mesa/swrast/s_aatriangle.c
@@ -33,6 +33,7 @@
 #include "main/colormac.h"

 #include "main/macros.h"

 #include "main/imports.h"

+#include "main/state.h"

 #include "s_aatriangle.h"

 #include "s_context.h"

 #include "s_span.h"

@@ -305,7 +306,7 @@ _swrast_set_aa_triangle_function(struct gl_context *ctx)
    if (ctx->Texture._EnabledCoordUnits != 0

        || ctx->FragmentProgram._Current

        || swrast->_FogEnabled

-       || NEED_SECONDARY_COLOR(ctx)) {

+       || _mesa_need_secondary_color(ctx)) {

       SWRAST_CONTEXT(ctx)->Triangle = general_aa_tri;

    }

    else {

diff --git a/mesalib/src/mesa/swrast/s_triangle.c b/mesalib/src/mesa/swrast/s_triangle.c
index 10a1dc1c1..c2c1ce221 100644
--- a/mesalib/src/mesa/swrast/s_triangle.c
+++ b/mesalib/src/mesa/swrast/s_triangle.c
@@ -35,6 +35,7 @@
 #include "main/imports.h"

 #include "main/macros.h"

 #include "main/mtypes.h"

+#include "main/state.h"

 #include "program/prog_instruction.h"

 

 #include "s_aatriangle.h"

@@ -1032,7 +1033,7 @@ _swrast_choose_triangle( struct gl_context *ctx )
       if (ctx->Texture._EnabledCoordUnits ||

           ctx->FragmentProgram._Current ||

           ctx->ATIFragmentShader._Enabled ||

-          NEED_SECONDARY_COLOR(ctx) ||

+          _mesa_need_secondary_color(ctx) ||

           swrast->_FogEnabled) {

          /* Ugh, we do a _lot_ of tests to pick the best textured tri func */

          const struct gl_texture_object *texObj2D;

@@ -1113,7 +1114,7 @@ _swrast_choose_triangle( struct gl_context *ctx )
       }

       else {

          ASSERT(!swrast->_FogEnabled);

-         ASSERT(!NEED_SECONDARY_COLOR(ctx));

+         ASSERT(!_mesa_need_secondary_color(ctx));

 	 if (ctx->Light.ShadeModel==GL_SMOOTH) {

 	    /* smooth shaded, no texturing, stippled or some raster ops */

 #if CHAN_BITS != 8

diff --git a/mesalib/src/mesa/tnl/t_context.c b/mesalib/src/mesa/tnl/t_context.c
index f27f2d090..9faa54fdf 100644
--- a/mesalib/src/mesa/tnl/t_context.c
+++ b/mesalib/src/mesa/tnl/t_context.c
@@ -34,6 +34,7 @@
 #include "main/light.h"

 #include "math/m_translate.h"

 #include "math/m_xform.h"

+#include "main/state.h"

 

 #include "tnl.h"

 #include "t_context.h"

@@ -127,7 +128,7 @@ _tnl_InvalidateState( struct gl_context *ctx, GLuint new_state )
      RENDERINPUTS_SET( tnl->render_inputs_bitset, _TNL_ATTRIB_COLOR0 );

    }

 

-   if (NEED_SECONDARY_COLOR(ctx))

+   if (_mesa_need_secondary_color(ctx))

      RENDERINPUTS_SET( tnl->render_inputs_bitset, _TNL_ATTRIB_COLOR1 );

 

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

diff --git a/pixman/test/affine-test.c b/pixman/test/affine-test.c
index 3c224d220..529ea8f63 100644
--- a/pixman/test/affine-test.c
+++ b/pixman/test/affine-test.c
@@ -95,8 +95,8 @@ test_composite (int      testnum,
     dst_img = pixman_image_create_bits (

         dst_fmt, dst_width, dst_height, dstbuf, dst_stride);

 

-    image_endian_swap (src_img, src_bpp * 8);

-    image_endian_swap (dst_img, dst_bpp * 8);

+    image_endian_swap (src_img);

+    image_endian_swap (dst_img);

 

     pixman_transform_init_identity (&transform);

     

@@ -251,7 +251,7 @@ test_composite (int      testnum,
 	    dstbuf[i] &= 0xFFFFFF;

     }

 

-    image_endian_swap (dst_img, dst_bpp * 8);

+    image_endian_swap (dst_img);

 

     if (verbose)

     {

diff --git a/pixman/test/blitters-test.c b/pixman/test/blitters-test.c
index 3b27cd8c1..5a867f23a 100644
--- a/pixman/test/blitters-test.c
+++ b/pixman/test/blitters-test.c
@@ -61,7 +61,7 @@ create_random_image (pixman_format_code_t *allowed_formats,
 	pixman_image_set_indexed (img, &(y_palette[PIXMAN_FORMAT_BPP (fmt)]));

     }

 

-    image_endian_swap (img, PIXMAN_FORMAT_BPP (fmt));

+    image_endian_swap (img);

 

     if (used_fmt) *used_fmt = fmt;

     return img;

@@ -101,7 +101,7 @@ free_random_image (uint32_t initcrc,
 	/* swap endiannes in order to provide identical results on both big

 	 * and litte endian systems

 	 */

-	image_endian_swap (img, PIXMAN_FORMAT_BPP (fmt));

+	image_endian_swap (img);

 	crc32 = compute_crc32 (initcrc, data, stride * height);

     }

 

diff --git a/pixman/test/composite-traps-test.c b/pixman/test/composite-traps-test.c
index c601d8135..9ea7293ce 100644
--- a/pixman/test/composite-traps-test.c
+++ b/pixman/test/composite-traps-test.c
@@ -139,6 +139,8 @@ test_composite (int      testnum,
 	    pixman_image_set_source_clipping (src_img, 1);

 	    pixman_region_fini (&clip);

 	}

+

+	image_endian_swap (src_img);

     }

 

     /* Create destination image */

@@ -157,6 +159,8 @@ test_composite (int      testnum,
 	

 	dst_img = pixman_image_create_bits (

 	    dst_format, dst_width, dst_height, dst_bits, dst_stride);

+

+	image_endian_swap (dst_img);

     }

 

     /* Create traps */

@@ -218,7 +222,7 @@ test_composite (int      testnum,
 	    dst_bits[i] &= 0xFFFFFF;

     }

 

-    image_endian_swap (dst_img, dst_bpp * 8);

+    image_endian_swap (dst_img);

 

     if (verbose)

     {

diff --git a/pixman/test/scaling-test.c b/pixman/test/scaling-test.c
index dbb9d39b0..f247e1e9a 100644
--- a/pixman/test/scaling-test.c
+++ b/pixman/test/scaling-test.c
@@ -1,368 +1,368 @@
-/*
- * Test program, which can detect some problems with nearest neighbour
- * and bilinear scaling in pixman. Testing is done by running lots
- * of random SRC and OVER compositing operations a8r8g8b8, x8a8r8g8b8
- * and r5g6b5 color formats.
- *
- * Script 'fuzzer-find-diff.pl' can be used to narrow down the problem in
- * the case of test failure.
- */
-#include <assert.h>
-#include <stdlib.h>
-#include <stdio.h>
-#include "utils.h"
-
-#define MAX_SRC_WIDTH  48
-#define MAX_SRC_HEIGHT 8
-#define MAX_DST_WIDTH  48
-#define MAX_DST_HEIGHT 8
-#define MAX_STRIDE     4
-
-/*
- * Composite operation with pseudorandom images
- */
-uint32_t
-test_composite (int      testnum,
-		int      verbose)
-{
-    int                i;
-    pixman_image_t *   src_img;
-    pixman_image_t *   mask_img;
-    pixman_image_t *   dst_img;
-    pixman_transform_t transform;
-    pixman_region16_t  clip;
-    int                src_width, src_height;
-    int                mask_width, mask_height;
-    int                dst_width, dst_height;
-    int                src_stride, mask_stride, dst_stride;
-    int                src_x, src_y;
-    int                mask_x, mask_y;
-    int                dst_x, dst_y;
-    int                src_bpp;
-    int                mask_bpp = 1;
-    int                dst_bpp;
-    int                w, h;
-    pixman_fixed_t     scale_x = 65536, scale_y = 65536;
-    pixman_fixed_t     translate_x = 0, translate_y = 0;
-    pixman_fixed_t     mask_scale_x = 65536, mask_scale_y = 65536;
-    pixman_fixed_t     mask_translate_x = 0, mask_translate_y = 0;
-    pixman_op_t        op;
-    pixman_repeat_t    repeat = PIXMAN_REPEAT_NONE;
-    pixman_repeat_t    mask_repeat = PIXMAN_REPEAT_NONE;
-    pixman_format_code_t src_fmt, dst_fmt;
-    uint32_t *         srcbuf;
-    uint32_t *         dstbuf;
-    uint32_t *         maskbuf;
-    uint32_t           crc32;
-    FLOAT_REGS_CORRUPTION_DETECTOR_START ();
-
-    lcg_srand (testnum);
-
-    src_bpp = (lcg_rand_n (2) == 0) ? 2 : 4;
-    dst_bpp = (lcg_rand_n (2) == 0) ? 2 : 4;
-    switch (lcg_rand_n (3))
-    {
-    case 0:
-	op = PIXMAN_OP_SRC;
-	break;
-    case 1:
-	op = PIXMAN_OP_OVER;
-	break;
-    default:
-	op = PIXMAN_OP_ADD;
-	break;
-    }
-
-    src_width = lcg_rand_n (MAX_SRC_WIDTH) + 1;
-    src_height = lcg_rand_n (MAX_SRC_HEIGHT) + 1;
-
-    if (lcg_rand_n (2))
-    {
-	mask_width = lcg_rand_n (MAX_SRC_WIDTH) + 1;
-	mask_height = lcg_rand_n (MAX_SRC_HEIGHT) + 1;
-    }
-    else
-    {
-	mask_width = mask_height = 1;
-    }
-
-    dst_width = lcg_rand_n (MAX_DST_WIDTH) + 1;
-    dst_height = lcg_rand_n (MAX_DST_HEIGHT) + 1;
-    src_stride = src_width * src_bpp + lcg_rand_n (MAX_STRIDE) * src_bpp;
-    mask_stride = mask_width * mask_bpp + lcg_rand_n (MAX_STRIDE) * mask_bpp;
-    dst_stride = dst_width * dst_bpp + lcg_rand_n (MAX_STRIDE) * dst_bpp;
-
-    if (src_stride & 3)
-	src_stride += 2;
-
-    if (mask_stride & 1)
-	mask_stride += 1;
-    if (mask_stride & 2)
-	mask_stride += 2;
-
-    if (dst_stride & 3)
-	dst_stride += 2;
-
-    src_x = -(src_width / 4) + lcg_rand_n (src_width * 3 / 2);
-    src_y = -(src_height / 4) + lcg_rand_n (src_height * 3 / 2);
-    mask_x = -(mask_width / 4) + lcg_rand_n (mask_width * 3 / 2);
-    mask_y = -(mask_height / 4) + lcg_rand_n (mask_height * 3 / 2);
-    dst_x = -(dst_width / 4) + lcg_rand_n (dst_width * 3 / 2);
-    dst_y = -(dst_height / 4) + lcg_rand_n (dst_height * 3 / 2);
-    w = lcg_rand_n (dst_width * 3 / 2 - dst_x);
-    h = lcg_rand_n (dst_height * 3 / 2 - dst_y);
-
-    srcbuf = (uint32_t *)malloc (src_stride * src_height);
-    maskbuf = (uint32_t *)malloc (mask_stride * mask_height);
-    dstbuf = (uint32_t *)malloc (dst_stride * dst_height);
-
-    for (i = 0; i < src_stride * src_height; i++)
-	*((uint8_t *)srcbuf + i) = lcg_rand_n (256);
-
-    for (i = 0; i < mask_stride * mask_height; i++)
-	*((uint8_t *)maskbuf + i) = lcg_rand_n (256);
-
-    for (i = 0; i < dst_stride * dst_height; i++)
-	*((uint8_t *)dstbuf + i) = lcg_rand_n (256);
-
-    src_fmt = src_bpp == 4 ? (lcg_rand_n (2) == 0 ?
-                              PIXMAN_a8r8g8b8 : PIXMAN_x8r8g8b8) : PIXMAN_r5g6b5;
-
-    dst_fmt = dst_bpp == 4 ? (lcg_rand_n (2) == 0 ?
-                              PIXMAN_a8r8g8b8 : PIXMAN_x8r8g8b8) : PIXMAN_r5g6b5;
-
-    src_img = pixman_image_create_bits (
-        src_fmt, src_width, src_height, srcbuf, src_stride);
-
-    mask_img = pixman_image_create_bits (
-        PIXMAN_a8, mask_width, mask_height, maskbuf, mask_stride);
-
-    dst_img = pixman_image_create_bits (
-        dst_fmt, dst_width, dst_height, dstbuf, dst_stride);
-
-    image_endian_swap (src_img, src_bpp * 8);
-    image_endian_swap (dst_img, dst_bpp * 8);
-
-    if (lcg_rand_n (4) > 0)
-    {
-	scale_x = -32768 * 3 + lcg_rand_N (65536 * 5);
-	scale_y = -32768 * 3 + lcg_rand_N (65536 * 5);
-	translate_x = lcg_rand_N (65536);
-	translate_y = lcg_rand_N (65536);
-	pixman_transform_init_scale (&transform, scale_x, scale_y);
-	pixman_transform_translate (&transform, NULL, translate_x, translate_y);
-	pixman_image_set_transform (src_img, &transform);
-    }
-
-    if (lcg_rand_n (2) > 0)
-    {
-	mask_scale_x = -32768 * 3 + lcg_rand_N (65536 * 5);
-	mask_scale_y = -32768 * 3 + lcg_rand_N (65536 * 5);
-	mask_translate_x = lcg_rand_N (65536);
-	mask_translate_y = lcg_rand_N (65536);
-	pixman_transform_init_scale (&transform, mask_scale_x, mask_scale_y);
-	pixman_transform_translate (&transform, NULL, mask_translate_x, mask_translate_y);
-	pixman_image_set_transform (mask_img, &transform);
-    }
-
-    switch (lcg_rand_n (4))
-    {
-    case 0:
-	mask_repeat = PIXMAN_REPEAT_NONE;
-	break;
-
-    case 1:
-	mask_repeat = PIXMAN_REPEAT_NORMAL;
-	break;
-
-    case 2:
-	mask_repeat = PIXMAN_REPEAT_PAD;
-	break;
-
-    case 3:
-	mask_repeat = PIXMAN_REPEAT_REFLECT;
-	break;
-
-    default:
-        break;
-    }
-    pixman_image_set_repeat (mask_img, mask_repeat);
-
-    switch (lcg_rand_n (4))
-    {
-    case 0:
-	repeat = PIXMAN_REPEAT_NONE;
-	break;
-
-    case 1:
-	repeat = PIXMAN_REPEAT_NORMAL;
-	break;
-
-    case 2:
-	repeat = PIXMAN_REPEAT_PAD;
-	break;
-
-    case 3:
-	repeat = PIXMAN_REPEAT_REFLECT;
-	break;
-
-    default:
-        break;
-    }
-    pixman_image_set_repeat (src_img, repeat);
-
-    if (lcg_rand_n (2))
-	pixman_image_set_filter (src_img, PIXMAN_FILTER_NEAREST, NULL, 0);
-    else
-	pixman_image_set_filter (src_img, PIXMAN_FILTER_BILINEAR, NULL, 0);
-
-    if (lcg_rand_n (2))
-	pixman_image_set_filter (mask_img, PIXMAN_FILTER_NEAREST, NULL, 0);
-    else
-	pixman_image_set_filter (mask_img, PIXMAN_FILTER_BILINEAR, NULL, 0);
-
-    if (verbose)
-    {
-	printf ("src_fmt=%08X, dst_fmt=%08X\n", src_fmt, dst_fmt);
-	printf ("op=%d, scale_x=%d, scale_y=%d, repeat=%d\n",
-	        op, scale_x, scale_y, repeat);
-	printf ("translate_x=%d, translate_y=%d\n",
-	        translate_x, translate_y);
-	printf ("src_width=%d, src_height=%d, dst_width=%d, dst_height=%d\n",
-	        src_width, src_height, dst_width, dst_height);
-	printf ("src_x=%d, src_y=%d, dst_x=%d, dst_y=%d\n",
-	        src_x, src_y, dst_x, dst_y);
-	printf ("w=%d, h=%d\n", w, h);
-    }
-
-    if (lcg_rand_n (8) == 0)
-    {
-	pixman_box16_t clip_boxes[2];
-	int            n = lcg_rand_n (2) + 1;
-
-	for (i = 0; i < n; i++)
-	{
-	    clip_boxes[i].x1 = lcg_rand_n (src_width);
-	    clip_boxes[i].y1 = lcg_rand_n (src_height);
-	    clip_boxes[i].x2 =
-		clip_boxes[i].x1 + lcg_rand_n (src_width - clip_boxes[i].x1);
-	    clip_boxes[i].y2 =
-		clip_boxes[i].y1 + lcg_rand_n (src_height - clip_boxes[i].y1);
-
-	    if (verbose)
-	    {
-		printf ("source clip box: [%d,%d-%d,%d]\n",
-		        clip_boxes[i].x1, clip_boxes[i].y1,
-		        clip_boxes[i].x2, clip_boxes[i].y2);
-	    }
-	}
-
-	pixman_region_init_rects (&clip, clip_boxes, n);
-	pixman_image_set_clip_region (src_img, &clip);
-	pixman_image_set_source_clipping (src_img, 1);
-	pixman_region_fini (&clip);
-    }
-
-    if (lcg_rand_n (8) == 0)
-    {
-	pixman_box16_t clip_boxes[2];
-	int            n = lcg_rand_n (2) + 1;
-
-	for (i = 0; i < n; i++)
-	{
-	    clip_boxes[i].x1 = lcg_rand_n (mask_width);
-	    clip_boxes[i].y1 = lcg_rand_n (mask_height);
-	    clip_boxes[i].x2 =
-		clip_boxes[i].x1 + lcg_rand_n (mask_width - clip_boxes[i].x1);
-	    clip_boxes[i].y2 =
-		clip_boxes[i].y1 + lcg_rand_n (mask_height - clip_boxes[i].y1);
-
-	    if (verbose)
-	    {
-		printf ("mask clip box: [%d,%d-%d,%d]\n",
-		        clip_boxes[i].x1, clip_boxes[i].y1,
-		        clip_boxes[i].x2, clip_boxes[i].y2);
-	    }
-	}
-
-	pixman_region_init_rects (&clip, clip_boxes, n);
-	pixman_image_set_clip_region (mask_img, &clip);
-	pixman_image_set_source_clipping (mask_img, 1);
-	pixman_region_fini (&clip);
-    }
-
-    if (lcg_rand_n (8) == 0)
-    {
-	pixman_box16_t clip_boxes[2];
-	int            n = lcg_rand_n (2) + 1;
-	for (i = 0; i < n; i++)
-	{
-	    clip_boxes[i].x1 = lcg_rand_n (dst_width);
-	    clip_boxes[i].y1 = lcg_rand_n (dst_height);
-	    clip_boxes[i].x2 =
-		clip_boxes[i].x1 + lcg_rand_n (dst_width - clip_boxes[i].x1);
-	    clip_boxes[i].y2 =
-		clip_boxes[i].y1 + lcg_rand_n (dst_height - clip_boxes[i].y1);
-
-	    if (verbose)
-	    {
-		printf ("destination clip box: [%d,%d-%d,%d]\n",
-		        clip_boxes[i].x1, clip_boxes[i].y1,
-		        clip_boxes[i].x2, clip_boxes[i].y2);
-	    }
-	}
-	pixman_region_init_rects (&clip, clip_boxes, n);
-	pixman_image_set_clip_region (dst_img, &clip);
-	pixman_region_fini (&clip);
-    }
-
-    if (lcg_rand_n (2) == 0)
-	pixman_image_composite (op, src_img, NULL, dst_img,
-                            src_x, src_y, 0, 0, dst_x, dst_y, w, h);
-    else
-	pixman_image_composite (op, src_img, mask_img, dst_img,
-                            src_x, src_y, mask_x, mask_y, dst_x, dst_y, w, h);
-
-    if (dst_fmt == PIXMAN_x8r8g8b8)
-    {
-	/* ignore unused part */
-	for (i = 0; i < dst_stride * dst_height / 4; i++)
-	    dstbuf[i] &= 0xFFFFFF;
-    }
-
-    image_endian_swap (dst_img, dst_bpp * 8);
-
-    if (verbose)
-    {
-	int j;
-	
-	for (i = 0; i < dst_height; i++)
-	{
-	    for (j = 0; j < dst_stride; j++)
-		printf ("%02X ", *((uint8_t *)dstbuf + i * dst_stride + j));
-
-	    printf ("\n");
-	}
-    }
-
-    pixman_image_unref (src_img);
-    pixman_image_unref (mask_img);
-    pixman_image_unref (dst_img);
-
-    crc32 = compute_crc32 (0, dstbuf, dst_stride * dst_height);
-    free (srcbuf);
-    free (maskbuf);
-    free (dstbuf);
-
-    FLOAT_REGS_CORRUPTION_DETECTOR_FINISH ();
-    return crc32;
-}
-
-int
-main (int argc, const char *argv[])
-{
-    pixman_disable_out_of_bounds_workaround ();
-
-    return fuzzer_test_main("scaling", 8000000, 0x80DF1CB2,
-			    test_composite, argc, argv);
-}
+/*

+ * Test program, which can detect some problems with nearest neighbour

+ * and bilinear scaling in pixman. Testing is done by running lots

+ * of random SRC and OVER compositing operations a8r8g8b8, x8a8r8g8b8

+ * and r5g6b5 color formats.

+ *

+ * Script 'fuzzer-find-diff.pl' can be used to narrow down the problem in

+ * the case of test failure.

+ */

+#include <assert.h>

+#include <stdlib.h>

+#include <stdio.h>

+#include "utils.h"

+

+#define MAX_SRC_WIDTH  48

+#define MAX_SRC_HEIGHT 8

+#define MAX_DST_WIDTH  48

+#define MAX_DST_HEIGHT 8

+#define MAX_STRIDE     4

+

+/*

+ * Composite operation with pseudorandom images

+ */

+uint32_t

+test_composite (int      testnum,

+		int      verbose)

+{

+    int                i;

+    pixman_image_t *   src_img;

+    pixman_image_t *   mask_img;

+    pixman_image_t *   dst_img;

+    pixman_transform_t transform;

+    pixman_region16_t  clip;

+    int                src_width, src_height;

+    int                mask_width, mask_height;

+    int                dst_width, dst_height;

+    int                src_stride, mask_stride, dst_stride;

+    int                src_x, src_y;

+    int                mask_x, mask_y;

+    int                dst_x, dst_y;

+    int                src_bpp;

+    int                mask_bpp = 1;

+    int                dst_bpp;

+    int                w, h;

+    pixman_fixed_t     scale_x = 65536, scale_y = 65536;

+    pixman_fixed_t     translate_x = 0, translate_y = 0;

+    pixman_fixed_t     mask_scale_x = 65536, mask_scale_y = 65536;

+    pixman_fixed_t     mask_translate_x = 0, mask_translate_y = 0;

+    pixman_op_t        op;

+    pixman_repeat_t    repeat = PIXMAN_REPEAT_NONE;

+    pixman_repeat_t    mask_repeat = PIXMAN_REPEAT_NONE;

+    pixman_format_code_t src_fmt, dst_fmt;

+    uint32_t *         srcbuf;

+    uint32_t *         dstbuf;

+    uint32_t *         maskbuf;

+    uint32_t           crc32;

+    FLOAT_REGS_CORRUPTION_DETECTOR_START ();

+

+    lcg_srand (testnum);

+

+    src_bpp = (lcg_rand_n (2) == 0) ? 2 : 4;

+    dst_bpp = (lcg_rand_n (2) == 0) ? 2 : 4;

+    switch (lcg_rand_n (3))

+    {

+    case 0:

+	op = PIXMAN_OP_SRC;

+	break;

+    case 1:

+	op = PIXMAN_OP_OVER;

+	break;

+    default:

+	op = PIXMAN_OP_ADD;

+	break;

+    }

+

+    src_width = lcg_rand_n (MAX_SRC_WIDTH) + 1;

+    src_height = lcg_rand_n (MAX_SRC_HEIGHT) + 1;

+

+    if (lcg_rand_n (2))

+    {

+	mask_width = lcg_rand_n (MAX_SRC_WIDTH) + 1;

+	mask_height = lcg_rand_n (MAX_SRC_HEIGHT) + 1;

+    }

+    else

+    {

+	mask_width = mask_height = 1;

+    }

+

+    dst_width = lcg_rand_n (MAX_DST_WIDTH) + 1;

+    dst_height = lcg_rand_n (MAX_DST_HEIGHT) + 1;

+    src_stride = src_width * src_bpp + lcg_rand_n (MAX_STRIDE) * src_bpp;

+    mask_stride = mask_width * mask_bpp + lcg_rand_n (MAX_STRIDE) * mask_bpp;

+    dst_stride = dst_width * dst_bpp + lcg_rand_n (MAX_STRIDE) * dst_bpp;

+

+    if (src_stride & 3)

+	src_stride += 2;

+

+    if (mask_stride & 1)

+	mask_stride += 1;

+    if (mask_stride & 2)

+	mask_stride += 2;

+

+    if (dst_stride & 3)

+	dst_stride += 2;

+

+    src_x = -(src_width / 4) + lcg_rand_n (src_width * 3 / 2);

+    src_y = -(src_height / 4) + lcg_rand_n (src_height * 3 / 2);

+    mask_x = -(mask_width / 4) + lcg_rand_n (mask_width * 3 / 2);

+    mask_y = -(mask_height / 4) + lcg_rand_n (mask_height * 3 / 2);

+    dst_x = -(dst_width / 4) + lcg_rand_n (dst_width * 3 / 2);

+    dst_y = -(dst_height / 4) + lcg_rand_n (dst_height * 3 / 2);

+    w = lcg_rand_n (dst_width * 3 / 2 - dst_x);

+    h = lcg_rand_n (dst_height * 3 / 2 - dst_y);

+

+    srcbuf = (uint32_t *)malloc (src_stride * src_height);

+    maskbuf = (uint32_t *)malloc (mask_stride * mask_height);

+    dstbuf = (uint32_t *)malloc (dst_stride * dst_height);

+

+    for (i = 0; i < src_stride * src_height; i++)

+	*((uint8_t *)srcbuf + i) = lcg_rand_n (256);

+

+    for (i = 0; i < mask_stride * mask_height; i++)

+	*((uint8_t *)maskbuf + i) = lcg_rand_n (256);

+

+    for (i = 0; i < dst_stride * dst_height; i++)

+	*((uint8_t *)dstbuf + i) = lcg_rand_n (256);

+

+    src_fmt = src_bpp == 4 ? (lcg_rand_n (2) == 0 ?

+                              PIXMAN_a8r8g8b8 : PIXMAN_x8r8g8b8) : PIXMAN_r5g6b5;

+

+    dst_fmt = dst_bpp == 4 ? (lcg_rand_n (2) == 0 ?

+                              PIXMAN_a8r8g8b8 : PIXMAN_x8r8g8b8) : PIXMAN_r5g6b5;

+

+    src_img = pixman_image_create_bits (

+        src_fmt, src_width, src_height, srcbuf, src_stride);

+

+    mask_img = pixman_image_create_bits (

+        PIXMAN_a8, mask_width, mask_height, maskbuf, mask_stride);

+

+    dst_img = pixman_image_create_bits (

+        dst_fmt, dst_width, dst_height, dstbuf, dst_stride);

+

+    image_endian_swap (src_img);

+    image_endian_swap (dst_img);

+

+    if (lcg_rand_n (4) > 0)

+    {

+	scale_x = -32768 * 3 + lcg_rand_N (65536 * 5);

+	scale_y = -32768 * 3 + lcg_rand_N (65536 * 5);

+	translate_x = lcg_rand_N (65536);

+	translate_y = lcg_rand_N (65536);

+	pixman_transform_init_scale (&transform, scale_x, scale_y);

+	pixman_transform_translate (&transform, NULL, translate_x, translate_y);

+	pixman_image_set_transform (src_img, &transform);

+    }

+

+    if (lcg_rand_n (2) > 0)

+    {

+	mask_scale_x = -32768 * 3 + lcg_rand_N (65536 * 5);

+	mask_scale_y = -32768 * 3 + lcg_rand_N (65536 * 5);

+	mask_translate_x = lcg_rand_N (65536);

+	mask_translate_y = lcg_rand_N (65536);

+	pixman_transform_init_scale (&transform, mask_scale_x, mask_scale_y);

+	pixman_transform_translate (&transform, NULL, mask_translate_x, mask_translate_y);

+	pixman_image_set_transform (mask_img, &transform);

+    }

+

+    switch (lcg_rand_n (4))

+    {

+    case 0:

+	mask_repeat = PIXMAN_REPEAT_NONE;

+	break;

+

+    case 1:

+	mask_repeat = PIXMAN_REPEAT_NORMAL;

+	break;

+

+    case 2:

+	mask_repeat = PIXMAN_REPEAT_PAD;

+	break;

+

+    case 3:

+	mask_repeat = PIXMAN_REPEAT_REFLECT;

+	break;

+

+    default:

+        break;

+    }

+    pixman_image_set_repeat (mask_img, mask_repeat);

+

+    switch (lcg_rand_n (4))

+    {

+    case 0:

+	repeat = PIXMAN_REPEAT_NONE;

+	break;

+

+    case 1:

+	repeat = PIXMAN_REPEAT_NORMAL;

+	break;

+

+    case 2:

+	repeat = PIXMAN_REPEAT_PAD;

+	break;

+

+    case 3:

+	repeat = PIXMAN_REPEAT_REFLECT;

+	break;

+

+    default:

+        break;

+    }

+    pixman_image_set_repeat (src_img, repeat);

+

+    if (lcg_rand_n (2))

+	pixman_image_set_filter (src_img, PIXMAN_FILTER_NEAREST, NULL, 0);

+    else

+	pixman_image_set_filter (src_img, PIXMAN_FILTER_BILINEAR, NULL, 0);

+

+    if (lcg_rand_n (2))

+	pixman_image_set_filter (mask_img, PIXMAN_FILTER_NEAREST, NULL, 0);

+    else

+	pixman_image_set_filter (mask_img, PIXMAN_FILTER_BILINEAR, NULL, 0);

+

+    if (verbose)

+    {

+	printf ("src_fmt=%08X, dst_fmt=%08X\n", src_fmt, dst_fmt);

+	printf ("op=%d, scale_x=%d, scale_y=%d, repeat=%d\n",

+	        op, scale_x, scale_y, repeat);

+	printf ("translate_x=%d, translate_y=%d\n",

+	        translate_x, translate_y);

+	printf ("src_width=%d, src_height=%d, dst_width=%d, dst_height=%d\n",

+	        src_width, src_height, dst_width, dst_height);

+	printf ("src_x=%d, src_y=%d, dst_x=%d, dst_y=%d\n",

+	        src_x, src_y, dst_x, dst_y);

+	printf ("w=%d, h=%d\n", w, h);

+    }

+

+    if (lcg_rand_n (8) == 0)

+    {

+	pixman_box16_t clip_boxes[2];

+	int            n = lcg_rand_n (2) + 1;

+

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

+	{

+	    clip_boxes[i].x1 = lcg_rand_n (src_width);

+	    clip_boxes[i].y1 = lcg_rand_n (src_height);

+	    clip_boxes[i].x2 =

+		clip_boxes[i].x1 + lcg_rand_n (src_width - clip_boxes[i].x1);

+	    clip_boxes[i].y2 =

+		clip_boxes[i].y1 + lcg_rand_n (src_height - clip_boxes[i].y1);

+

+	    if (verbose)

+	    {

+		printf ("source clip box: [%d,%d-%d,%d]\n",

+		        clip_boxes[i].x1, clip_boxes[i].y1,

+		        clip_boxes[i].x2, clip_boxes[i].y2);

+	    }

+	}

+

+	pixman_region_init_rects (&clip, clip_boxes, n);

+	pixman_image_set_clip_region (src_img, &clip);

+	pixman_image_set_source_clipping (src_img, 1);

+	pixman_region_fini (&clip);

+    }

+

+    if (lcg_rand_n (8) == 0)

+    {

+	pixman_box16_t clip_boxes[2];

+	int            n = lcg_rand_n (2) + 1;

+

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

+	{

+	    clip_boxes[i].x1 = lcg_rand_n (mask_width);

+	    clip_boxes[i].y1 = lcg_rand_n (mask_height);

+	    clip_boxes[i].x2 =

+		clip_boxes[i].x1 + lcg_rand_n (mask_width - clip_boxes[i].x1);

+	    clip_boxes[i].y2 =

+		clip_boxes[i].y1 + lcg_rand_n (mask_height - clip_boxes[i].y1);

+

+	    if (verbose)

+	    {

+		printf ("mask clip box: [%d,%d-%d,%d]\n",

+		        clip_boxes[i].x1, clip_boxes[i].y1,

+		        clip_boxes[i].x2, clip_boxes[i].y2);

+	    }

+	}

+

+	pixman_region_init_rects (&clip, clip_boxes, n);

+	pixman_image_set_clip_region (mask_img, &clip);

+	pixman_image_set_source_clipping (mask_img, 1);

+	pixman_region_fini (&clip);

+    }

+

+    if (lcg_rand_n (8) == 0)

+    {

+	pixman_box16_t clip_boxes[2];

+	int            n = lcg_rand_n (2) + 1;

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

+	{

+	    clip_boxes[i].x1 = lcg_rand_n (dst_width);

+	    clip_boxes[i].y1 = lcg_rand_n (dst_height);

+	    clip_boxes[i].x2 =

+		clip_boxes[i].x1 + lcg_rand_n (dst_width - clip_boxes[i].x1);

+	    clip_boxes[i].y2 =

+		clip_boxes[i].y1 + lcg_rand_n (dst_height - clip_boxes[i].y1);

+

+	    if (verbose)

+	    {

+		printf ("destination clip box: [%d,%d-%d,%d]\n",

+		        clip_boxes[i].x1, clip_boxes[i].y1,

+		        clip_boxes[i].x2, clip_boxes[i].y2);

+	    }

+	}

+	pixman_region_init_rects (&clip, clip_boxes, n);

+	pixman_image_set_clip_region (dst_img, &clip);

+	pixman_region_fini (&clip);

+    }

+

+    if (lcg_rand_n (2) == 0)

+	pixman_image_composite (op, src_img, NULL, dst_img,

+                            src_x, src_y, 0, 0, dst_x, dst_y, w, h);

+    else

+	pixman_image_composite (op, src_img, mask_img, dst_img,

+                            src_x, src_y, mask_x, mask_y, dst_x, dst_y, w, h);

+

+    if (dst_fmt == PIXMAN_x8r8g8b8)

+    {

+	/* ignore unused part */

+	for (i = 0; i < dst_stride * dst_height / 4; i++)

+	    dstbuf[i] &= 0xFFFFFF;

+    }

+

+    image_endian_swap (dst_img);

+

+    if (verbose)

+    {

+	int j;

+	

+	for (i = 0; i < dst_height; i++)

+	{

+	    for (j = 0; j < dst_stride; j++)

+		printf ("%02X ", *((uint8_t *)dstbuf + i * dst_stride + j));

+

+	    printf ("\n");

+	}

+    }

+

+    pixman_image_unref (src_img);

+    pixman_image_unref (mask_img);

+    pixman_image_unref (dst_img);

+

+    crc32 = compute_crc32 (0, dstbuf, dst_stride * dst_height);

+    free (srcbuf);

+    free (maskbuf);

+    free (dstbuf);

+

+    FLOAT_REGS_CORRUPTION_DETECTOR_FINISH ();

+    return crc32;

+}

+

+int

+main (int argc, const char *argv[])

+{

+    pixman_disable_out_of_bounds_workaround ();

+

+    return fuzzer_test_main("scaling", 8000000, 0x80DF1CB2,

+			    test_composite, argc, argv);

+}

diff --git a/pixman/test/utils.c b/pixman/test/utils.c
index a896e5be1..ee68d272c 100644
--- a/pixman/test/utils.c
+++ b/pixman/test/utils.c
@@ -133,11 +133,12 @@ compute_crc32 (uint32_t    in_crc32,
 /* perform endian conversion of pixel data

  */

 void

-image_endian_swap (pixman_image_t *img, int bpp)

+image_endian_swap (pixman_image_t *img)

 {

     int stride = pixman_image_get_stride (img);

     uint32_t *data = pixman_image_get_data (img);

     int height = pixman_image_get_height (img);

+    int bpp = PIXMAN_FORMAT_BPP (pixman_image_get_format (img));

     int i, j;

 

     /* swap bytes only on big endian systems */

@@ -145,10 +146,13 @@ image_endian_swap (pixman_image_t *img, int bpp)
     if (*(volatile uint8_t *)&endian_check_var != 0x12)

 	return;

 

+    if (bpp == 8)

+	return;

+

     for (i = 0; i < height; i++)

     {

 	uint8_t *line_data = (uint8_t *)data + stride * i;

-	/* swap bytes only for 16, 24 and 32 bpp for now */

+	

 	switch (bpp)

 	{

 	case 1:

@@ -208,6 +212,7 @@ image_endian_swap (pixman_image_t *img, int bpp)
 	    }

 	    break;

 	default:

+	    assert (FALSE);

 	    break;

 	}

     }

diff --git a/pixman/test/utils.h b/pixman/test/utils.h
index 90a84cd0e..5643c1228 100644
--- a/pixman/test/utils.h
+++ b/pixman/test/utils.h
@@ -60,7 +60,7 @@ compute_crc32 (uint32_t    in_crc32,
 /* perform endian conversion of pixel data

  */

 void

-image_endian_swap (pixman_image_t *img, int bpp);

+image_endian_swap (pixman_image_t *img);

 

 /* Allocate memory that is bounded by protected pages,

  * so that out-of-bounds access will cause segfaults