Merge remote-tracking branch 'origin/released'

Conflicts:
	apps/xwininfo/configure.ac
	apps/xwininfo/xwininfo.c
	libX11/configure.ac
	libX11/specs/libX11/AppC.xml
	libX11/specs/libX11/AppD.xml
	libX11/specs/libX11/CH03.xml
	libX11/specs/libX11/CH04.xml
	libX11/specs/libX11/CH05.xml
	libX11/specs/libX11/CH06.xml
	libX11/specs/libX11/CH07.xml
	libX11/specs/libX11/CH08.xml
	libX11/specs/libX11/CH09.xml
	libX11/specs/libX11/CH11.xml
	libX11/specs/libX11/CH12.xml
	libX11/specs/libX11/CH13.xml
	libX11/specs/libX11/CH14.xml
	libX11/specs/libX11/CH15.xml
	libX11/specs/libX11/CH16.xml
	libxcb/configure.ac
	libxcb/src/c_client.py
	libxcb/src/xcb_auth.c
	libxcb/src/xcb_util.c
	mesalib/common.py
	mesalib/configs/linux-dri
	mesalib/docs/GL3.txt
	mesalib/docs/download.html
	mesalib/docs/install.html
	mesalib/include/GL/internal/dri_interface.h
	mesalib/scons/custom.py
	mesalib/scons/gallium.py
	mesalib/src/gallium/auxiliary/util/u_math.h
	mesalib/src/gallium/auxiliary/util/u_vbuf_mgr.c
	mesalib/src/glsl/ast_function.cpp
	mesalib/src/glsl/ast_to_hir.cpp
	mesalib/src/glsl/glcpp/glcpp-parse.y
	mesalib/src/glsl/glsl_parser_extras.cpp
	mesalib/src/glsl/glsl_parser_extras.h
	mesalib/src/glsl/ir.cpp
	mesalib/src/glsl/ir.h
	mesalib/src/glsl/ir_clone.cpp
	mesalib/src/glsl/ir_print_visitor.cpp
	mesalib/src/glsl/ir_validate.cpp
	mesalib/src/glsl/linker.cpp
	mesalib/src/glsl/main.cpp
	mesalib/src/glsl/opt_tree_grafting.cpp
	mesalib/src/mapi/glapi/gen/Makefile
	mesalib/src/mapi/glapi/gen/gl_XML.py
	mesalib/src/mapi/glapi/gen/gl_table.py
	mesalib/src/mapi/glapi/glapi_mapi_tmp.h
	mesalib/src/mapi/glapi/glapi_sparc.S
	mesalib/src/mapi/glapi/glapi_x86-64.S
	mesalib/src/mapi/glapi/glapi_x86.S
	mesalib/src/mapi/glapi/glapitemp.h
	mesalib/src/mapi/glapi/glprocs.h
	mesalib/src/mapi/mapi/u_thread.c
	mesalib/src/mapi/mapi/u_thread.h
	mesalib/src/mesa/SConscript
	mesalib/src/mesa/drivers/common/driverfuncs.c
	mesalib/src/mesa/drivers/windows/gldirect/dglcontext.c
	mesalib/src/mesa/main/api_arrayelt.c
	mesalib/src/mesa/main/bufferobj.c
	mesalib/src/mesa/main/compiler.h
	mesalib/src/mesa/main/dd.h
	mesalib/src/mesa/main/dlist.c
	mesalib/src/mesa/main/enums.c
	mesalib/src/mesa/main/es_generator.py
	mesalib/src/mesa/main/fbobject.c
	mesalib/src/mesa/main/imports.h
	mesalib/src/mesa/main/mtypes.h
	mesalib/src/mesa/main/pbo.c
	mesalib/src/mesa/main/remap_helper.h
	mesalib/src/mesa/main/shared.c
	mesalib/src/mesa/main/texgetimage.c
	mesalib/src/mesa/main/teximage.c
	mesalib/src/mesa/main/uniforms.c
	mesalib/src/mesa/program/ir_to_mesa.cpp
	mesalib/src/mesa/program/prog_optimize.c
	mesalib/src/mesa/program/register_allocate.c
	mesalib/src/mesa/program/register_allocate.h
	mesalib/src/mesa/sources.mak
	mesalib/src/mesa/state_tracker/st_cb_bufferobjects.c
	mesalib/src/mesa/state_tracker/st_cb_texture.c
	mesalib/src/mesa/state_tracker/st_texture.h
	mesalib/src/mesa/swrast/s_context.c
	mesalib/src/mesa/tnl/t_draw.c
	mesalib/src/mesa/vbo/vbo_exec_array.c
	mesalib/src/mesa/vbo/vbo_save_api.c
	pixman/pixman/pixman-arm-common.h
	pixman/pixman/pixman-fast-path.c
	pixman/pixman/pixman-inlines.h
	pixman/test/Makefile.am
	pixman/test/utils.c
	pixman/test/utils.h
	xorg-server/configure.ac
	xorg-server/fb/fbblt.c
	xorg-server/hw/xquartz/darwin.c
	xorg-server/xkeyboard-config/symbols/de

1 files changed, 212 insertions, 212 deletions

diff --git a/mesalib/src/mesa/main/querymatrix.c b/mesalib/src/mesa/main/querymatrix.c
index aade8a614..eaedf7cd2 100644
--- a/mesalib/src/mesa/main/querymatrix.c
+++ b/mesalib/src/mesa/main/querymatrix.c
@@ -1,212 +1,212 @@
-/**************************************************************************

- *

- * Copyright 2008 Tungsten Graphics, Inc., Cedar Park, Texas.

- * All Rights Reserved.

- *

- **************************************************************************/

-

-

-/**

- * Code to implement GL_OES_query_matrix.  See the spec at:

- * http://www.khronos.org/registry/gles/extensions/OES/OES_query_matrix.txt

- */

-

-

-#include <stdlib.h>

-#include <math.h>

-#include "GLES/gl.h"

-#include "GLES/glext.h"

-

-

-/**

- * This is from the GL_OES_query_matrix extension specification:

- *

- *  GLbitfield glQueryMatrixxOES( GLfixed mantissa[16],

- *                                GLint   exponent[16] )

- *  mantissa[16] contains the contents of the current matrix in GLfixed

- *  format.  exponent[16] contains the unbiased exponents applied to the

- *  matrix components, so that the internal representation of component i

- *  is close to mantissa[i] * 2^exponent[i].  The function returns a status

- *  word which is zero if all the components are valid. If

- *  status & (1<<i) != 0, the component i is invalid (e.g., NaN, Inf).

- *  The implementations are not required to keep track of overflows.  In

- *  that case, the invalid bits are never set.

- */

-

-#define INT_TO_FIXED(x) ((GLfixed) ((x) << 16))

-#define FLOAT_TO_FIXED(x) ((GLfixed) ((x) * 65536.0))

-

-#if defined(_MSC_VER)

-/* Oddly, the fpclassify() function doesn't exist in such a form

- * on MSVC.  This is an implementation using slightly different

- * lower-level Windows functions.

- */

-#include <float.h>

-

-enum {FP_NAN, FP_INFINITE, FP_ZERO, FP_SUBNORMAL, FP_NORMAL}

-fpclassify(double x)

-{

-    switch(_fpclass(x)) {

-        case _FPCLASS_SNAN: /* signaling NaN */

-        case _FPCLASS_QNAN: /* quiet NaN */

-            return FP_NAN;

-        case _FPCLASS_NINF: /* negative infinity */

-        case _FPCLASS_PINF: /* positive infinity */

-            return FP_INFINITE;

-        case _FPCLASS_NN:   /* negative normal */

-        case _FPCLASS_PN:   /* positive normal */

-            return FP_NORMAL;

-        case _FPCLASS_ND:   /* negative denormalized */

-        case _FPCLASS_PD:   /* positive denormalized */

-            return FP_SUBNORMAL;

-        case _FPCLASS_NZ:   /* negative zero */

-        case _FPCLASS_PZ:   /* positive zero */

-            return FP_ZERO;

-        default:

-            /* Should never get here; but if we do, this will guarantee

-             * that the pattern is not treated like a number.

-             */

-            return FP_NAN;

-    }

-}

-

-#elif defined(__APPLE__) || defined(__CYGWIN__) || defined(__FreeBSD__) || \

-     defined(__OpenBSD__) || defined(__NetBSD__) || defined(__DragonFly__) || \

-     (defined(__sun) && defined(__C99FEATURES__)) || defined(__MINGW32__) || \

-     (defined(__sun) && defined(__GNUC__))

-

-/* fpclassify is available. */

-

-#elif !defined(_XOPEN_SOURCE) || _XOPEN_SOURCE < 600

-

-enum {FP_NAN, FP_INFINITE, FP_ZERO, FP_SUBNORMAL, FP_NORMAL}

-fpclassify(double x)

-{

-   /* XXX do something better someday */

-   return FP_NORMAL;

-}

-

-#endif

-

-extern GLbitfield GL_APIENTRY _es_QueryMatrixxOES(GLfixed mantissa[16], GLint exponent[16]);

-

-/* The Mesa functions we'll need */

-extern void GL_APIENTRY _mesa_GetIntegerv(GLenum pname, GLint *params);

-extern void GL_APIENTRY _mesa_GetFloatv(GLenum pname, GLfloat *params);

-

-GLbitfield GL_APIENTRY _es_QueryMatrixxOES(GLfixed mantissa[16], GLint exponent[16])

-{

-    GLfloat matrix[16];

-    GLint tmp;

-    GLenum currentMode = GL_FALSE;

-    GLenum desiredMatrix = GL_FALSE;

-    /* The bitfield returns 1 for each component that is invalid (i.e.

-     * NaN or Inf).  In case of error, everything is invalid.

-     */

-    GLbitfield rv;

-    register unsigned int i;

-    unsigned int bit;

-

-    /* This data structure defines the mapping between the current matrix

-     * mode and the desired matrix identifier.

-     */

-    static struct {

-        GLenum currentMode;

-        GLenum desiredMatrix;

-    } modes[] = {

-        {GL_MODELVIEW, GL_MODELVIEW_MATRIX},

-        {GL_PROJECTION, GL_PROJECTION_MATRIX},

-        {GL_TEXTURE, GL_TEXTURE_MATRIX},

-    };

-

-    /* Call Mesa to get the current matrix in floating-point form.  First,

-     * we have to figure out what the current matrix mode is.

-     */

-    _mesa_GetIntegerv(GL_MATRIX_MODE, &tmp);

-    currentMode = (GLenum) tmp;

-

-    /* The mode is either GL_FALSE, if for some reason we failed to query

-     * the mode, or a given mode from the above table.  Search for the

-     * returned mode to get the desired matrix; if we don't find it,

-     * we can return immediately, as _mesa_GetInteger() will have

-     * logged the necessary error already.

-     */

-    for (i = 0; i < sizeof(modes)/sizeof(modes[0]); i++) {

-        if (modes[i].currentMode == currentMode) {

-            desiredMatrix = modes[i].desiredMatrix;

-            break;

-        }

-    }

-    if (desiredMatrix == GL_FALSE) {

-        /* Early error means all values are invalid. */

-        return 0xffff;

-    }

-

-    /* Now pull the matrix itself. */

-    _mesa_GetFloatv(desiredMatrix, matrix);

-

-    rv = 0;

-    for (i = 0, bit = 1; i < 16; i++, bit<<=1) {

-        float normalizedFraction;

-        int exp;

-

-        switch (fpclassify(matrix[i])) {

-            /* A "subnormal" or denormalized number is too small to be

-             * represented in normal format; but despite that it's a

-             * valid floating point number.  FP_ZERO and FP_NORMAL

-             * are both valid as well.  We should be fine treating

-             * these three cases as legitimate floating-point numbers.

-             */

-            case FP_SUBNORMAL:

-            case FP_NORMAL:

-            case FP_ZERO:

-                normalizedFraction = (GLfloat)frexp(matrix[i], &exp);

-                mantissa[i] = FLOAT_TO_FIXED(normalizedFraction);

-                exponent[i] = (GLint) exp;

-                break;

-

-            /* If the entry is not-a-number or an infinity, then the

-             * matrix component is invalid.  The invalid flag for

-             * the component is already set; might as well set the

-             * other return values to known values.  We'll set

-             * distinct values so that a savvy end user could determine

-             * whether the matrix component was a NaN or an infinity,

-             * but this is more useful for debugging than anything else

-             * since the standard doesn't specify any such magic

-             * values to return.

-             */

-            case FP_NAN:

-                mantissa[i] = INT_TO_FIXED(0);

-                exponent[i] = (GLint) 0;

-                rv |= bit;

-                break;

-

-            case FP_INFINITE:

-                /* Return +/- 1 based on whether it's a positive or

-                 * negative infinity.

-                 */

-                if (matrix[i] > 0) {

-                    mantissa[i] = INT_TO_FIXED(1);

-                }

-                else {

-                    mantissa[i] = -INT_TO_FIXED(1);

-                }

-                exponent[i] = (GLint) 0;

-                rv |= bit;

-                break;

-

-            /* We should never get here; but here's a catching case

-             * in case fpclassify() is returnings something unexpected.

-             */

-            default:

-                mantissa[i] = INT_TO_FIXED(2);

-                exponent[i] = (GLint) 0;

-                rv |= bit;

-                break;

-        }

-

-    } /* for each component */

-

-    /* All done */

-    return rv;

-}

+/**************************************************************************
+ *
+ * Copyright 2008 Tungsten Graphics, Inc., Cedar Park, Texas.
+ * All Rights Reserved.
+ *
+ **************************************************************************/
+
+
+/**
+ * Code to implement GL_OES_query_matrix.  See the spec at:
+ * http://www.khronos.org/registry/gles/extensions/OES/OES_query_matrix.txt
+ */
+
+
+#include <stdlib.h>
+#include <math.h>
+#include "GLES/gl.h"
+#include "GLES/glext.h"
+
+
+/**
+ * This is from the GL_OES_query_matrix extension specification:
+ *
+ *  GLbitfield glQueryMatrixxOES( GLfixed mantissa[16],
+ *                                GLint   exponent[16] )
+ *  mantissa[16] contains the contents of the current matrix in GLfixed
+ *  format.  exponent[16] contains the unbiased exponents applied to the
+ *  matrix components, so that the internal representation of component i
+ *  is close to mantissa[i] * 2^exponent[i].  The function returns a status
+ *  word which is zero if all the components are valid. If
+ *  status & (1<<i) != 0, the component i is invalid (e.g., NaN, Inf).
+ *  The implementations are not required to keep track of overflows.  In
+ *  that case, the invalid bits are never set.
+ */
+
+#define INT_TO_FIXED(x) ((GLfixed) ((x) << 16))
+#define FLOAT_TO_FIXED(x) ((GLfixed) ((x) * 65536.0))
+
+#if defined(_MSC_VER)
+/* Oddly, the fpclassify() function doesn't exist in such a form
+ * on MSVC.  This is an implementation using slightly different
+ * lower-level Windows functions.
+ */
+#include <float.h>
+
+enum {FP_NAN, FP_INFINITE, FP_ZERO, FP_SUBNORMAL, FP_NORMAL}
+fpclassify(double x)
+{
+    switch(_fpclass(x)) {
+        case _FPCLASS_SNAN: /* signaling NaN */
+        case _FPCLASS_QNAN: /* quiet NaN */
+            return FP_NAN;
+        case _FPCLASS_NINF: /* negative infinity */
+        case _FPCLASS_PINF: /* positive infinity */
+            return FP_INFINITE;
+        case _FPCLASS_NN:   /* negative normal */
+        case _FPCLASS_PN:   /* positive normal */
+            return FP_NORMAL;
+        case _FPCLASS_ND:   /* negative denormalized */
+        case _FPCLASS_PD:   /* positive denormalized */
+            return FP_SUBNORMAL;
+        case _FPCLASS_NZ:   /* negative zero */
+        case _FPCLASS_PZ:   /* positive zero */
+            return FP_ZERO;
+        default:
+            /* Should never get here; but if we do, this will guarantee
+             * that the pattern is not treated like a number.
+             */
+            return FP_NAN;
+    }
+}
+
+#elif defined(__APPLE__) || defined(__CYGWIN__) || defined(__FreeBSD__) || \
+     defined(__OpenBSD__) || defined(__NetBSD__) || defined(__DragonFly__) || \
+     (defined(__sun) && defined(__C99FEATURES__)) || defined(__MINGW32__) || \
+     (defined(__sun) && defined(__GNUC__)) || defined(ANDROID)
+
+/* fpclassify is available. */
+
+#elif !defined(_XOPEN_SOURCE) || _XOPEN_SOURCE < 600
+
+enum {FP_NAN, FP_INFINITE, FP_ZERO, FP_SUBNORMAL, FP_NORMAL}
+fpclassify(double x)
+{
+   /* XXX do something better someday */
+   return FP_NORMAL;
+}
+
+#endif
+
+extern GLbitfield GL_APIENTRY _es_QueryMatrixxOES(GLfixed mantissa[16], GLint exponent[16]);
+
+/* The Mesa functions we'll need */
+extern void GL_APIENTRY _mesa_GetIntegerv(GLenum pname, GLint *params);
+extern void GL_APIENTRY _mesa_GetFloatv(GLenum pname, GLfloat *params);
+
+GLbitfield GL_APIENTRY _es_QueryMatrixxOES(GLfixed mantissa[16], GLint exponent[16])
+{
+    GLfloat matrix[16];
+    GLint tmp;
+    GLenum currentMode = GL_FALSE;
+    GLenum desiredMatrix = GL_FALSE;
+    /* The bitfield returns 1 for each component that is invalid (i.e.
+     * NaN or Inf).  In case of error, everything is invalid.
+     */
+    GLbitfield rv;
+    register unsigned int i;
+    unsigned int bit;
+
+    /* This data structure defines the mapping between the current matrix
+     * mode and the desired matrix identifier.
+     */
+    static struct {
+        GLenum currentMode;
+        GLenum desiredMatrix;
+    } modes[] = {
+        {GL_MODELVIEW, GL_MODELVIEW_MATRIX},
+        {GL_PROJECTION, GL_PROJECTION_MATRIX},
+        {GL_TEXTURE, GL_TEXTURE_MATRIX},
+    };
+
+    /* Call Mesa to get the current matrix in floating-point form.  First,
+     * we have to figure out what the current matrix mode is.
+     */
+    _mesa_GetIntegerv(GL_MATRIX_MODE, &tmp);
+    currentMode = (GLenum) tmp;
+
+    /* The mode is either GL_FALSE, if for some reason we failed to query
+     * the mode, or a given mode from the above table.  Search for the
+     * returned mode to get the desired matrix; if we don't find it,
+     * we can return immediately, as _mesa_GetInteger() will have
+     * logged the necessary error already.
+     */
+    for (i = 0; i < sizeof(modes)/sizeof(modes[0]); i++) {
+        if (modes[i].currentMode == currentMode) {
+            desiredMatrix = modes[i].desiredMatrix;
+            break;
+        }
+    }
+    if (desiredMatrix == GL_FALSE) {
+        /* Early error means all values are invalid. */
+        return 0xffff;
+    }
+
+    /* Now pull the matrix itself. */
+    _mesa_GetFloatv(desiredMatrix, matrix);
+
+    rv = 0;
+    for (i = 0, bit = 1; i < 16; i++, bit<<=1) {
+        float normalizedFraction;
+        int exp;
+
+        switch (fpclassify(matrix[i])) {
+            /* A "subnormal" or denormalized number is too small to be
+             * represented in normal format; but despite that it's a
+             * valid floating point number.  FP_ZERO and FP_NORMAL
+             * are both valid as well.  We should be fine treating
+             * these three cases as legitimate floating-point numbers.
+             */
+            case FP_SUBNORMAL:
+            case FP_NORMAL:
+            case FP_ZERO:
+                normalizedFraction = (GLfloat)frexp(matrix[i], &exp);
+                mantissa[i] = FLOAT_TO_FIXED(normalizedFraction);
+                exponent[i] = (GLint) exp;
+                break;
+
+            /* If the entry is not-a-number or an infinity, then the
+             * matrix component is invalid.  The invalid flag for
+             * the component is already set; might as well set the
+             * other return values to known values.  We'll set
+             * distinct values so that a savvy end user could determine
+             * whether the matrix component was a NaN or an infinity,
+             * but this is more useful for debugging than anything else
+             * since the standard doesn't specify any such magic
+             * values to return.
+             */
+            case FP_NAN:
+                mantissa[i] = INT_TO_FIXED(0);
+                exponent[i] = (GLint) 0;
+                rv |= bit;
+                break;
+
+            case FP_INFINITE:
+                /* Return +/- 1 based on whether it's a positive or
+                 * negative infinity.
+                 */
+                if (matrix[i] > 0) {
+                    mantissa[i] = INT_TO_FIXED(1);
+                }
+                else {
+                    mantissa[i] = -INT_TO_FIXED(1);
+                }
+                exponent[i] = (GLint) 0;
+                rv |= bit;
+                break;
+
+            /* We should never get here; but here's a catching case
+             * in case fpclassify() is returnings something unexpected.
+             */
+            default:
+                mantissa[i] = INT_TO_FIXED(2);
+                exponent[i] = (GLint) 0;
+                rv |= bit;
+                break;
+        }
+
+    } /* for each component */
+
+    /* All done */
+    return rv;
+}