X-Git-Url: https://git.libre-soc.org/?a=blobdiff_plain;f=src%2Fmesa%2Fmain%2Feval.c;h=86c8f75a1d25df5542d79fcf6378b80998e7cf46;hb=68cfc65ccbca748f0dfdc85876b9b5c02e598c11;hp=b1b2823a1372af0cfdbd92e34226d1afa44322da;hpb=441a4af435b46e1b475318fbaf4e80b774390cb0;p=mesa.git

diff --git a/src/mesa/main/eval.c b/src/mesa/main/eval.c
index b1b2823a137..86c8f75a1d2 100644
--- a/src/mesa/main/eval.c
+++ b/src/mesa/main/eval.c
@@ -1,10 +1,8 @@
-/* $Id: eval.c,v 1.20 2001/05/16 17:06:28 brianp Exp $ */
 
 /*
  * Mesa 3-D graphics library
- * Version:  3.5
  *
- * Copyright (C) 1999-2001  Brian Paul   All Rights Reserved.
+ * Copyright (C) 1999-2003  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"),
@@ -19,9 +17,10 @@
  * 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.
+ * 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.
  */
 
 
@@ -38,18 +37,13 @@
  */
 
 
-#ifdef PC_HEADER
-#include "all.h"
-#else
 #include "glheader.h"
-#include "colormac.h"
+#include "imports.h"
 #include "context.h"
 #include "eval.h"
 #include "macros.h"
-#include "mem.h"
-#include "mmath.h"
 #include "mtypes.h"
-#endif
+#include "main/dispatch.h"
 
 
 /*
@@ -78,7 +72,71 @@ GLuint _mesa_evaluator_components( GLenum target )
       case GL_MAP2_TEXTURE_COORD_2:	return 2;
       case GL_MAP2_TEXTURE_COORD_3:	return 3;
       case GL_MAP2_TEXTURE_COORD_4:	return 4;
-      default:				return 0;
+      default:				break;
+   }
+
+   return 0;
+}
+
+
+/*
+ * Return pointer to the gl_1d_map struct for the named target.
+ */
+static struct gl_1d_map *
+get_1d_map( struct gl_context *ctx, GLenum target )
+{
+   switch (target) {
+      case GL_MAP1_VERTEX_3:
+         return &ctx->EvalMap.Map1Vertex3;
+      case GL_MAP1_VERTEX_4:
+         return &ctx->EvalMap.Map1Vertex4;
+      case GL_MAP1_INDEX:
+         return &ctx->EvalMap.Map1Index;
+      case GL_MAP1_COLOR_4:
+         return &ctx->EvalMap.Map1Color4;
+      case GL_MAP1_NORMAL:
+         return &ctx->EvalMap.Map1Normal;
+      case GL_MAP1_TEXTURE_COORD_1:
+         return &ctx->EvalMap.Map1Texture1;
+      case GL_MAP1_TEXTURE_COORD_2:
+         return &ctx->EvalMap.Map1Texture2;
+      case GL_MAP1_TEXTURE_COORD_3:
+         return &ctx->EvalMap.Map1Texture3;
+      case GL_MAP1_TEXTURE_COORD_4:
+         return &ctx->EvalMap.Map1Texture4;
+      default:
+         return NULL;
+   }
+}
+
+
+/*
+ * Return pointer to the gl_2d_map struct for the named target.
+ */
+static struct gl_2d_map *
+get_2d_map( struct gl_context *ctx, GLenum target )
+{
+   switch (target) {
+      case GL_MAP2_VERTEX_3:
+         return &ctx->EvalMap.Map2Vertex3;
+      case GL_MAP2_VERTEX_4:
+         return &ctx->EvalMap.Map2Vertex4;
+      case GL_MAP2_INDEX:
+         return &ctx->EvalMap.Map2Index;
+      case GL_MAP2_COLOR_4:
+         return &ctx->EvalMap.Map2Color4;
+      case GL_MAP2_NORMAL:
+         return &ctx->EvalMap.Map2Normal;
+      case GL_MAP2_TEXTURE_COORD_1:
+         return &ctx->EvalMap.Map2Texture1;
+      case GL_MAP2_TEXTURE_COORD_2:
+         return &ctx->EvalMap.Map2Texture2;
+      case GL_MAP2_TEXTURE_COORD_3:
+         return &ctx->EvalMap.Map2Texture3;
+      case GL_MAP2_TEXTURE_COORD_4:
+         return &ctx->EvalMap.Map2Texture4;
+      default:
+         return NULL;
    }
 }
 
@@ -91,25 +149,24 @@ GLuint _mesa_evaluator_components( GLenum target )
 /*
  * Copy 1-parametric evaluator control points from user-specified
  * memory space to a buffer of contiguous control points.
- * Input:  see glMap1f for details
- * Return:  pointer to buffer of contiguous control points or NULL if out
+ * \param see glMap1f for details
+ * \return pointer to buffer of contiguous control points or NULL if out
  *          of memory.
  */
 GLfloat *_mesa_copy_map_points1f( GLenum target, GLint ustride, GLint uorder,
-                               const GLfloat *points )
+                                  const GLfloat *points )
 {
    GLfloat *buffer, *p;
    GLint i, k, size = _mesa_evaluator_components(target);
 
-   if (!points || size==0) {
+   if (!points || !size)
       return NULL;
-   }
 
-   buffer = (GLfloat *) MALLOC(uorder * size * sizeof(GLfloat));
+   buffer = malloc(uorder * size * sizeof(GLfloat));
 
-   if(buffer)
-      for(i=0, p=buffer; i<uorder; i++, points+=ustride)
-	for(k=0; k<size; k++)
+   if (buffer)
+      for (i = 0, p = buffer; i < uorder; i++, points += ustride)
+	for (k = 0; k < size; k++)
 	  *p++ = points[k];
 
    return buffer;
@@ -121,20 +178,19 @@ GLfloat *_mesa_copy_map_points1f( GLenum target, GLint ustride, GLint uorder,
  * Same as above but convert doubles to floats.
  */
 GLfloat *_mesa_copy_map_points1d( GLenum target, GLint ustride, GLint uorder,
-                               const GLdouble *points )
+                                  const GLdouble *points )
 {
    GLfloat *buffer, *p;
    GLint i, k, size = _mesa_evaluator_components(target);
 
-   if (!points || size==0) {
+   if (!points || !size)
       return NULL;
-   }
 
-   buffer = (GLfloat *) MALLOC(uorder * size * sizeof(GLfloat));
+   buffer = malloc(uorder * size * sizeof(GLfloat));
 
-   if(buffer)
-      for(i=0, p=buffer; i<uorder; i++, points+=ustride)
-	for(k=0; k<size; k++)
+   if (buffer)
+      for (i = 0, p = buffer; i < uorder; i++, points += ustride)
+	for (k = 0; k < size; k++)
 	  *p++ = (GLfloat) points[k];
 
    return buffer;
@@ -148,14 +204,14 @@ GLfloat *_mesa_copy_map_points1d( GLenum target, GLint ustride, GLint uorder,
  * Additional memory is allocated to be used by the horner and
  * de Casteljau evaluation schemes.
  *
- * Input:  see glMap2f for details
- * Return:  pointer to buffer of contiguous control points or NULL if out
+ * \param see glMap2f for details
+ * \return pointer to buffer of contiguous control points or NULL if out
  *          of memory.
  */
 GLfloat *_mesa_copy_map_points2f( GLenum target,
-                               GLint ustride, GLint uorder,
-                               GLint vstride, GLint vorder,
-                               const GLfloat *points )
+                                  GLint ustride, GLint uorder,
+                                  GLint vstride, GLint vorder,
+                                  const GLfloat *points )
 {
    GLfloat *buffer, *p;
    GLint i, j, k, size, dsize, hsize;
@@ -174,9 +230,9 @@ GLfloat *_mesa_copy_map_points2f( GLenum target,
    hsize = (uorder > vorder ? uorder : vorder)*size;
 
    if(hsize>dsize)
-     buffer = (GLfloat *) MALLOC((uorder*vorder*size+hsize)*sizeof(GLfloat));
+     buffer = malloc((uorder*vorder*size+hsize)*sizeof(GLfloat));
    else
-     buffer = (GLfloat *) MALLOC((uorder*vorder*size+dsize)*sizeof(GLfloat));
+     buffer = malloc((uorder*vorder*size+dsize)*sizeof(GLfloat));
 
    /* compute the increment value for the u-loop */
    uinc = ustride - vorder*vstride;
@@ -196,9 +252,9 @@ GLfloat *_mesa_copy_map_points2f( GLenum target,
  * Same as above but convert doubles to floats.
  */
 GLfloat *_mesa_copy_map_points2d(GLenum target,
-                              GLint ustride, GLint uorder,
-                              GLint vstride, GLint vorder,
-                              const GLdouble *points )
+                                 GLint ustride, GLint uorder,
+                                 GLint vstride, GLint vorder,
+                                 const GLdouble *points )
 {
    GLfloat *buffer, *p;
    GLint i, j, k, size, hsize, dsize;
@@ -217,9 +273,9 @@ GLfloat *_mesa_copy_map_points2d(GLenum target,
    hsize = (uorder > vorder ? uorder : vorder)*size;
 
    if(hsize>dsize)
-     buffer = (GLfloat *) MALLOC((uorder*vorder*size+hsize)*sizeof(GLfloat));
+     buffer = malloc((uorder*vorder*size+hsize)*sizeof(GLfloat));
    else
-     buffer = (GLfloat *) MALLOC((uorder*vorder*size+dsize)*sizeof(GLfloat));
+     buffer = malloc((uorder*vorder*size+dsize)*sizeof(GLfloat));
 
    /* compute the increment value for the u-loop */
    uinc = ustride - vorder*vstride;
@@ -251,8 +307,7 @@ map1(GLenum target, GLfloat u1, GLfloat u2, GLint ustride,
    GET_CURRENT_CONTEXT(ctx);
    GLint k;
    GLfloat *pnts;
-   struct gl_1d_map *map = 0;
-   ASSERT_OUTSIDE_BEGIN_END(ctx);
+   struct gl_1d_map *map = NULL;
 
    assert(type == GL_FLOAT || type == GL_DOUBLE);
 
@@ -272,6 +327,7 @@ map1(GLenum target, GLfloat u1, GLfloat u2, GLint ustride,
    k = _mesa_evaluator_components( target );
    if (k == 0) {
       _mesa_error( ctx, GL_INVALID_ENUM, "glMap1(target)" );
+      return;
    }
 
    if (ustride < k) {
@@ -285,37 +341,10 @@ map1(GLenum target, GLfloat u1, GLfloat u2, GLint ustride,
       return;
    }
 
-   switch (target) {
-      case GL_MAP1_VERTEX_3:
-         map = &ctx->EvalMap.Map1Vertex3;
-	 break;
-      case GL_MAP1_VERTEX_4:
-         map = &ctx->EvalMap.Map1Vertex4;
-	 break;
-      case GL_MAP1_INDEX:
-         map = &ctx->EvalMap.Map1Index;
-	 break;
-      case GL_MAP1_COLOR_4:
-         map = &ctx->EvalMap.Map1Color4;
-	 break;
-      case GL_MAP1_NORMAL:
-         map = &ctx->EvalMap.Map1Normal;
-	 break;
-      case GL_MAP1_TEXTURE_COORD_1:
-         map = &ctx->EvalMap.Map1Texture1;
-	 break;
-      case GL_MAP1_TEXTURE_COORD_2:
-         map = &ctx->EvalMap.Map1Texture2;
-	 break;
-      case GL_MAP1_TEXTURE_COORD_3:
-         map = &ctx->EvalMap.Map1Texture3;
-	 break;
-      case GL_MAP1_TEXTURE_COORD_4:
-         map = &ctx->EvalMap.Map1Texture4;
-	 break;
-      default:
-         _mesa_error( ctx, GL_INVALID_ENUM, "glMap1(target)" );
-	 return;
+   map = get_1d_map(ctx, target);
+   if (!map) {
+      _mesa_error( ctx, GL_INVALID_ENUM, "glMap1(target)" );
+      return;
    }
 
    /* make copy of the control points */
@@ -329,15 +358,14 @@ map1(GLenum target, GLfloat u1, GLfloat u2, GLint ustride,
    map->Order = uorder;
    map->u1 = u1;
    map->u2 = u2;
-   map->du = 1.0 / (u2 - u1);
-   if (map->Points)
-      FREE( map->Points );
+   map->du = 1.0F / (u2 - u1);
+   free(map->Points);
    map->Points = pnts;
 }
 
 
 
-void
+void GLAPIENTRY
 _mesa_Map1f( GLenum target, GLfloat u1, GLfloat u2, GLint stride,
              GLint order, const GLfloat *points )
 {
@@ -345,11 +373,11 @@ _mesa_Map1f( GLenum target, GLfloat u1, GLfloat u2, GLint stride,
 }
 
 
-void
+void GLAPIENTRY
 _mesa_Map1d( GLenum target, GLdouble u1, GLdouble u2, GLint stride,
              GLint order, const GLdouble *points )
 {
-   map1(target, u1, u2, stride, order, points, GL_DOUBLE);
+   map1(target, (GLfloat) u1, (GLfloat) u2, stride, order, points, GL_DOUBLE);
 }
 
 
@@ -361,8 +389,9 @@ map2( GLenum target, GLfloat u1, GLfloat u2, GLint ustride, GLint uorder,
    GET_CURRENT_CONTEXT(ctx);
    GLint k;
    GLfloat *pnts;
-   struct gl_2d_map *map = 0;
-   ASSERT_OUTSIDE_BEGIN_END(ctx);
+   struct gl_2d_map *map = NULL;
+
+   assert(type == GL_FLOAT || type == GL_DOUBLE);
 
    if (u1==u2) {
       _mesa_error( ctx, GL_INVALID_VALUE, "glMap2(u1,u2)" );
@@ -387,6 +416,7 @@ map2( GLenum target, GLfloat u1, GLfloat u2, GLint ustride, GLint uorder,
    k = _mesa_evaluator_components( target );
    if (k==0) {
       _mesa_error( ctx, GL_INVALID_ENUM, "glMap2(target)" );
+      return;
    }
 
    if (ustride < k) {
@@ -404,37 +434,10 @@ map2( GLenum target, GLfloat u1, GLfloat u2, GLint ustride, GLint uorder,
       return;
    }
 
-   switch (target) {
-      case GL_MAP2_VERTEX_3:
-         map = &ctx->EvalMap.Map2Vertex3;
-	 break;
-      case GL_MAP2_VERTEX_4:
-         map = &ctx->EvalMap.Map2Vertex4;
-	 break;
-      case GL_MAP2_INDEX:
-         map = &ctx->EvalMap.Map2Index;
-	 break;
-      case GL_MAP2_COLOR_4:
-         map = &ctx->EvalMap.Map2Color4;
-	 break;
-      case GL_MAP2_NORMAL:
-         map = &ctx->EvalMap.Map2Normal;
-	 break;
-      case GL_MAP2_TEXTURE_COORD_1:
-         map = &ctx->EvalMap.Map2Texture1;
-	 break;
-      case GL_MAP2_TEXTURE_COORD_2:
-         map = &ctx->EvalMap.Map2Texture2;
-	 break;
-      case GL_MAP2_TEXTURE_COORD_3:
-         map = &ctx->EvalMap.Map2Texture3;
-	 break;
-      case GL_MAP2_TEXTURE_COORD_4:
-         map = &ctx->EvalMap.Map2Texture4;
-	 break;
-      default:
-         _mesa_error( ctx, GL_INVALID_ENUM, "glMap2(target)" );
-	 return;
+   map = get_2d_map(ctx, target);
+   if (!map) {
+      _mesa_error( ctx, GL_INVALID_ENUM, "glMap2(target)" );
+      return;
    }
 
    /* make copy of the control points */
@@ -450,18 +453,17 @@ map2( GLenum target, GLfloat u1, GLfloat u2, GLint ustride, GLint uorder,
    map->Uorder = uorder;
    map->u1 = u1;
    map->u2 = u2;
-   map->du = 1.0 / (u2 - u1);
+   map->du = 1.0F / (u2 - u1);
    map->Vorder = vorder;
    map->v1 = v1;
    map->v2 = v2;
-   map->dv = 1.0 / (v2 - v1);
-   if (map->Points)
-      FREE( map->Points );
+   map->dv = 1.0F / (v2 - v1);
+   free(map->Points);
    map->Points = pnts;
 }
 
 
-void
+void GLAPIENTRY
 _mesa_Map2f( GLenum target,
              GLfloat u1, GLfloat u2, GLint ustride, GLint uorder,
              GLfloat v1, GLfloat v2, GLint vstride, GLint vorder,
@@ -472,846 +474,296 @@ _mesa_Map2f( GLenum target,
 }
 
 
-void
+void GLAPIENTRY
 _mesa_Map2d( GLenum target,
              GLdouble u1, GLdouble u2, GLint ustride, GLint uorder,
              GLdouble v1, GLdouble v2, GLint vstride, GLint vorder,
              const GLdouble *points )
 {
-   map2(target, u1, u2, ustride, uorder, v1, v2, vstride, vorder,
-        points, GL_DOUBLE);
+   map2(target, (GLfloat) u1, (GLfloat) u2, ustride, uorder, 
+	(GLfloat) v1, (GLfloat) v2, vstride, vorder, points, GL_DOUBLE);
 }
 
 
 
-void
-_mesa_GetMapdv( GLenum target, GLenum query, GLdouble *v )
+void GLAPIENTRY
+_mesa_GetnMapdvARB( GLenum target, GLenum query, GLsizei bufSize, GLdouble *v )
 {
    GET_CURRENT_CONTEXT(ctx);
+   struct gl_1d_map *map1d;
+   struct gl_2d_map *map2d;
    GLint i, n;
    GLfloat *data;
-   ASSERT_OUTSIDE_BEGIN_END(ctx);
+   GLuint comps;
+   GLsizei numBytes;
+
+   comps = _mesa_evaluator_components(target);
+   if (!comps) {
+      _mesa_error( ctx, GL_INVALID_ENUM, "glGetMapdv(target)" );
+      return;
+   }
+
+   map1d = get_1d_map(ctx, target);
+   map2d = get_2d_map(ctx, target);
+   assert(map1d || map2d);
 
    switch (query) {
       case GL_COEFF:
-	 switch (target) {
-	    case GL_MAP1_COLOR_4:
-	       data = ctx->EvalMap.Map1Color4.Points;
-	       n = ctx->EvalMap.Map1Color4.Order * 4;
-	       break;
-	    case GL_MAP1_INDEX:
-	       data = ctx->EvalMap.Map1Index.Points;
-	       n = ctx->EvalMap.Map1Index.Order;
-	       break;
-	    case GL_MAP1_NORMAL:
-	       data = ctx->EvalMap.Map1Normal.Points;
-	       n = ctx->EvalMap.Map1Normal.Order * 3;
-	       break;
-	    case GL_MAP1_TEXTURE_COORD_1:
-	       data = ctx->EvalMap.Map1Texture1.Points;
-	       n = ctx->EvalMap.Map1Texture1.Order * 1;
-	       break;
-	    case GL_MAP1_TEXTURE_COORD_2:
-	       data = ctx->EvalMap.Map1Texture2.Points;
-	       n = ctx->EvalMap.Map1Texture2.Order * 2;
-	       break;
-	    case GL_MAP1_TEXTURE_COORD_3:
-	       data = ctx->EvalMap.Map1Texture3.Points;
-	       n = ctx->EvalMap.Map1Texture3.Order * 3;
-	       break;
-	    case GL_MAP1_TEXTURE_COORD_4:
-	       data = ctx->EvalMap.Map1Texture4.Points;
-	       n = ctx->EvalMap.Map1Texture4.Order * 4;
-	       break;
-	    case GL_MAP1_VERTEX_3:
-	       data = ctx->EvalMap.Map1Vertex3.Points;
-	       n = ctx->EvalMap.Map1Vertex3.Order * 3;
-	       break;
-	    case GL_MAP1_VERTEX_4:
-	       data = ctx->EvalMap.Map1Vertex4.Points;
-	       n = ctx->EvalMap.Map1Vertex4.Order * 4;
-	       break;
-	    case GL_MAP2_COLOR_4:
-	       data = ctx->EvalMap.Map2Color4.Points;
-	       n = ctx->EvalMap.Map2Color4.Uorder
-                 * ctx->EvalMap.Map2Color4.Vorder * 4;
-	       break;
-	    case GL_MAP2_INDEX:
-	       data = ctx->EvalMap.Map2Index.Points;
-	       n = ctx->EvalMap.Map2Index.Uorder
-                 * ctx->EvalMap.Map2Index.Vorder;
-	       break;
-	    case GL_MAP2_NORMAL:
-	       data = ctx->EvalMap.Map2Normal.Points;
-	       n = ctx->EvalMap.Map2Normal.Uorder
-                 * ctx->EvalMap.Map2Normal.Vorder * 3;
-	       break;
-	    case GL_MAP2_TEXTURE_COORD_1:
-	       data = ctx->EvalMap.Map2Texture1.Points;
-	       n = ctx->EvalMap.Map2Texture1.Uorder
-                 * ctx->EvalMap.Map2Texture1.Vorder * 1;
-	       break;
-	    case GL_MAP2_TEXTURE_COORD_2:
-	       data = ctx->EvalMap.Map2Texture2.Points;
-	       n = ctx->EvalMap.Map2Texture2.Uorder
-                 * ctx->EvalMap.Map2Texture2.Vorder * 2;
-	       break;
-	    case GL_MAP2_TEXTURE_COORD_3:
-	       data = ctx->EvalMap.Map2Texture3.Points;
-	       n = ctx->EvalMap.Map2Texture3.Uorder
-                 * ctx->EvalMap.Map2Texture3.Vorder * 3;
-	       break;
-	    case GL_MAP2_TEXTURE_COORD_4:
-	       data = ctx->EvalMap.Map2Texture4.Points;
-	       n = ctx->EvalMap.Map2Texture4.Uorder
-                 * ctx->EvalMap.Map2Texture4.Vorder * 4;
-	       break;
-	    case GL_MAP2_VERTEX_3:
-	       data = ctx->EvalMap.Map2Vertex3.Points;
-	       n = ctx->EvalMap.Map2Vertex3.Uorder
-                 * ctx->EvalMap.Map2Vertex3.Vorder * 3;
-	       break;
-	    case GL_MAP2_VERTEX_4:
-	       data = ctx->EvalMap.Map2Vertex4.Points;
-	       n = ctx->EvalMap.Map2Vertex4.Uorder
-                 * ctx->EvalMap.Map2Vertex4.Vorder * 4;
-	       break;
-	    default:
-	       _mesa_error( ctx, GL_INVALID_ENUM, "glGetMapdv(target)" );
-	       return;
-	 }
+         if (map1d) {
+            data = map1d->Points;
+            n = map1d->Order * comps;
+         }
+         else {
+            data = map2d->Points;
+            n = map2d->Uorder * map2d->Vorder * comps;
+         }
 	 if (data) {
+            numBytes = n * sizeof *v;
+            if (bufSize < numBytes)
+               goto overflow;
 	    for (i=0;i<n;i++) {
 	       v[i] = data[i];
 	    }
 	 }
          break;
       case GL_ORDER:
-	 switch (target) {
-	    case GL_MAP1_COLOR_4:
-	       *v = ctx->EvalMap.Map1Color4.Order;
-	       break;
-	    case GL_MAP1_INDEX:
-	       *v = ctx->EvalMap.Map1Index.Order;
-	       break;
-	    case GL_MAP1_NORMAL:
-	       *v = ctx->EvalMap.Map1Normal.Order;
-	       break;
-	    case GL_MAP1_TEXTURE_COORD_1:
-	       *v = ctx->EvalMap.Map1Texture1.Order;
-	       break;
-	    case GL_MAP1_TEXTURE_COORD_2:
-	       *v = ctx->EvalMap.Map1Texture2.Order;
-	       break;
-	    case GL_MAP1_TEXTURE_COORD_3:
-	       *v = ctx->EvalMap.Map1Texture3.Order;
-	       break;
-	    case GL_MAP1_TEXTURE_COORD_4:
-	       *v = ctx->EvalMap.Map1Texture4.Order;
-	       break;
-	    case GL_MAP1_VERTEX_3:
-	       *v = ctx->EvalMap.Map1Vertex3.Order;
-	       break;
-	    case GL_MAP1_VERTEX_4:
-	       *v = ctx->EvalMap.Map1Vertex4.Order;
-	       break;
-	    case GL_MAP2_COLOR_4:
-	       v[0] = ctx->EvalMap.Map2Color4.Uorder;
-	       v[1] = ctx->EvalMap.Map2Color4.Vorder;
-	       break;
-	    case GL_MAP2_INDEX:
-	       v[0] = ctx->EvalMap.Map2Index.Uorder;
-	       v[1] = ctx->EvalMap.Map2Index.Vorder;
-	       break;
-	    case GL_MAP2_NORMAL:
-	       v[0] = ctx->EvalMap.Map2Normal.Uorder;
-	       v[1] = ctx->EvalMap.Map2Normal.Vorder;
-	       break;
-	    case GL_MAP2_TEXTURE_COORD_1:
-	       v[0] = ctx->EvalMap.Map2Texture1.Uorder;
-	       v[1] = ctx->EvalMap.Map2Texture1.Vorder;
-	       break;
-	    case GL_MAP2_TEXTURE_COORD_2:
-	       v[0] = ctx->EvalMap.Map2Texture2.Uorder;
-	       v[1] = ctx->EvalMap.Map2Texture2.Vorder;
-	       break;
-	    case GL_MAP2_TEXTURE_COORD_3:
-	       v[0] = ctx->EvalMap.Map2Texture3.Uorder;
-	       v[1] = ctx->EvalMap.Map2Texture3.Vorder;
-	       break;
-	    case GL_MAP2_TEXTURE_COORD_4:
-	       v[0] = ctx->EvalMap.Map2Texture4.Uorder;
-	       v[1] = ctx->EvalMap.Map2Texture4.Vorder;
-	       break;
-	    case GL_MAP2_VERTEX_3:
-	       v[0] = ctx->EvalMap.Map2Vertex3.Uorder;
-	       v[1] = ctx->EvalMap.Map2Vertex3.Vorder;
-	       break;
-	    case GL_MAP2_VERTEX_4:
-	       v[0] = ctx->EvalMap.Map2Vertex4.Uorder;
-	       v[1] = ctx->EvalMap.Map2Vertex4.Vorder;
-	       break;
-	    default:
-	       _mesa_error( ctx, GL_INVALID_ENUM, "glGetMapdv(target)" );
-	       return;
-	 }
+         if (map1d) {
+            numBytes = 1 * sizeof *v;
+            if (bufSize < numBytes)
+               goto overflow;
+            v[0] = (GLdouble) map1d->Order;
+         }
+         else {
+            numBytes = 2 * sizeof *v;
+            if (bufSize < numBytes)
+               goto overflow;
+            v[0] = (GLdouble) map2d->Uorder;
+            v[1] = (GLdouble) map2d->Vorder;
+         }
          break;
       case GL_DOMAIN:
-	 switch (target) {
-	    case GL_MAP1_COLOR_4:
-	       v[0] = ctx->EvalMap.Map1Color4.u1;
-	       v[1] = ctx->EvalMap.Map1Color4.u2;
-	       break;
-	    case GL_MAP1_INDEX:
-	       v[0] = ctx->EvalMap.Map1Index.u1;
-	       v[1] = ctx->EvalMap.Map1Index.u2;
-	       break;
-	    case GL_MAP1_NORMAL:
-	       v[0] = ctx->EvalMap.Map1Normal.u1;
-	       v[1] = ctx->EvalMap.Map1Normal.u2;
-	       break;
-	    case GL_MAP1_TEXTURE_COORD_1:
-	       v[0] = ctx->EvalMap.Map1Texture1.u1;
-	       v[1] = ctx->EvalMap.Map1Texture1.u2;
-	       break;
-	    case GL_MAP1_TEXTURE_COORD_2:
-	       v[0] = ctx->EvalMap.Map1Texture2.u1;
-	       v[1] = ctx->EvalMap.Map1Texture2.u2;
-	       break;
-	    case GL_MAP1_TEXTURE_COORD_3:
-	       v[0] = ctx->EvalMap.Map1Texture3.u1;
-	       v[1] = ctx->EvalMap.Map1Texture3.u2;
-	       break;
-	    case GL_MAP1_TEXTURE_COORD_4:
-	       v[0] = ctx->EvalMap.Map1Texture4.u1;
-	       v[1] = ctx->EvalMap.Map1Texture4.u2;
-	       break;
-	    case GL_MAP1_VERTEX_3:
-	       v[0] = ctx->EvalMap.Map1Vertex3.u1;
-	       v[1] = ctx->EvalMap.Map1Vertex3.u2;
-	       break;
-	    case GL_MAP1_VERTEX_4:
-	       v[0] = ctx->EvalMap.Map1Vertex4.u1;
-	       v[1] = ctx->EvalMap.Map1Vertex4.u2;
-	       break;
-	    case GL_MAP2_COLOR_4:
-	       v[0] = ctx->EvalMap.Map2Color4.u1;
-	       v[1] = ctx->EvalMap.Map2Color4.u2;
-	       v[2] = ctx->EvalMap.Map2Color4.v1;
-	       v[3] = ctx->EvalMap.Map2Color4.v2;
-	       break;
-	    case GL_MAP2_INDEX:
-	       v[0] = ctx->EvalMap.Map2Index.u1;
-	       v[1] = ctx->EvalMap.Map2Index.u2;
-	       v[2] = ctx->EvalMap.Map2Index.v1;
-	       v[3] = ctx->EvalMap.Map2Index.v2;
-	       break;
-	    case GL_MAP2_NORMAL:
-	       v[0] = ctx->EvalMap.Map2Normal.u1;
-	       v[1] = ctx->EvalMap.Map2Normal.u2;
-	       v[2] = ctx->EvalMap.Map2Normal.v1;
-	       v[3] = ctx->EvalMap.Map2Normal.v2;
-	       break;
-	    case GL_MAP2_TEXTURE_COORD_1:
-	       v[0] = ctx->EvalMap.Map2Texture1.u1;
-	       v[1] = ctx->EvalMap.Map2Texture1.u2;
-	       v[2] = ctx->EvalMap.Map2Texture1.v1;
-	       v[3] = ctx->EvalMap.Map2Texture1.v2;
-	       break;
-	    case GL_MAP2_TEXTURE_COORD_2:
-	       v[0] = ctx->EvalMap.Map2Texture2.u1;
-	       v[1] = ctx->EvalMap.Map2Texture2.u2;
-	       v[2] = ctx->EvalMap.Map2Texture2.v1;
-	       v[3] = ctx->EvalMap.Map2Texture2.v2;
-	       break;
-	    case GL_MAP2_TEXTURE_COORD_3:
-	       v[0] = ctx->EvalMap.Map2Texture3.u1;
-	       v[1] = ctx->EvalMap.Map2Texture3.u2;
-	       v[2] = ctx->EvalMap.Map2Texture3.v1;
-	       v[3] = ctx->EvalMap.Map2Texture3.v2;
-	       break;
-	    case GL_MAP2_TEXTURE_COORD_4:
-	       v[0] = ctx->EvalMap.Map2Texture4.u1;
-	       v[1] = ctx->EvalMap.Map2Texture4.u2;
-	       v[2] = ctx->EvalMap.Map2Texture4.v1;
-	       v[3] = ctx->EvalMap.Map2Texture4.v2;
-	       break;
-	    case GL_MAP2_VERTEX_3:
-	       v[0] = ctx->EvalMap.Map2Vertex3.u1;
-	       v[1] = ctx->EvalMap.Map2Vertex3.u2;
-	       v[2] = ctx->EvalMap.Map2Vertex3.v1;
-	       v[3] = ctx->EvalMap.Map2Vertex3.v2;
-	       break;
-	    case GL_MAP2_VERTEX_4:
-	       v[0] = ctx->EvalMap.Map2Vertex4.u1;
-	       v[1] = ctx->EvalMap.Map2Vertex4.u2;
-	       v[2] = ctx->EvalMap.Map2Vertex4.v1;
-	       v[3] = ctx->EvalMap.Map2Vertex4.v2;
-	       break;
-	    default:
-	       _mesa_error( ctx, GL_INVALID_ENUM, "glGetMapdv(target)" );
-	 }
+         if (map1d) {
+            numBytes = 2 * sizeof *v;
+            if (bufSize < numBytes)
+              goto overflow;
+            v[0] = (GLdouble) map1d->u1;
+            v[1] = (GLdouble) map1d->u2;
+         }
+         else {
+            numBytes = 4 * sizeof *v;
+            if (bufSize < numBytes)
+               goto overflow;
+            v[0] = (GLdouble) map2d->u1;
+            v[1] = (GLdouble) map2d->u2;
+            v[2] = (GLdouble) map2d->v1;
+            v[3] = (GLdouble) map2d->v2;
+         }
          break;
       default:
          _mesa_error( ctx, GL_INVALID_ENUM, "glGetMapdv(query)" );
    }
+   return;
+
+overflow:
+   _mesa_error( ctx, GL_INVALID_OPERATION,
+               "glGetnMapdvARB(out of bounds: bufSize is %d,"
+               " but %d bytes are required)", bufSize, numBytes );
 }
 
+void GLAPIENTRY
+_mesa_GetMapdv( GLenum target, GLenum query, GLdouble *v )
+{
+   _mesa_GetnMapdvARB(target, query, INT_MAX, v);
+}
 
-void
-_mesa_GetMapfv( GLenum target, GLenum query, GLfloat *v )
+void GLAPIENTRY
+_mesa_GetnMapfvARB( GLenum target, GLenum query, GLsizei bufSize, GLfloat *v )
 {
    GET_CURRENT_CONTEXT(ctx);
+   struct gl_1d_map *map1d;
+   struct gl_2d_map *map2d;
    GLint i, n;
    GLfloat *data;
-   ASSERT_OUTSIDE_BEGIN_END(ctx);
+   GLuint comps;
+   GLsizei numBytes;
+
+   comps = _mesa_evaluator_components(target);
+   if (!comps) {
+      _mesa_error( ctx, GL_INVALID_ENUM, "glGetMapfv(target)" );
+      return;
+   }
+
+   map1d = get_1d_map(ctx, target);
+   map2d = get_2d_map(ctx, target);
+   assert(map1d || map2d);
 
    switch (query) {
       case GL_COEFF:
-	 switch (target) {
-	    case GL_MAP1_COLOR_4:
-	       data = ctx->EvalMap.Map1Color4.Points;
-	       n = ctx->EvalMap.Map1Color4.Order * 4;
-	       break;
-	    case GL_MAP1_INDEX:
-	       data = ctx->EvalMap.Map1Index.Points;
-	       n = ctx->EvalMap.Map1Index.Order;
-	       break;
-	    case GL_MAP1_NORMAL:
-	       data = ctx->EvalMap.Map1Normal.Points;
-	       n = ctx->EvalMap.Map1Normal.Order * 3;
-	       break;
-	    case GL_MAP1_TEXTURE_COORD_1:
-	       data = ctx->EvalMap.Map1Texture1.Points;
-	       n = ctx->EvalMap.Map1Texture1.Order * 1;
-	       break;
-	    case GL_MAP1_TEXTURE_COORD_2:
-	       data = ctx->EvalMap.Map1Texture2.Points;
-	       n = ctx->EvalMap.Map1Texture2.Order * 2;
-	       break;
-	    case GL_MAP1_TEXTURE_COORD_3:
-	       data = ctx->EvalMap.Map1Texture3.Points;
-	       n = ctx->EvalMap.Map1Texture3.Order * 3;
-	       break;
-	    case GL_MAP1_TEXTURE_COORD_4:
-	       data = ctx->EvalMap.Map1Texture4.Points;
-	       n = ctx->EvalMap.Map1Texture4.Order * 4;
-	       break;
-	    case GL_MAP1_VERTEX_3:
-	       data = ctx->EvalMap.Map1Vertex3.Points;
-	       n = ctx->EvalMap.Map1Vertex3.Order * 3;
-	       break;
-	    case GL_MAP1_VERTEX_4:
-	       data = ctx->EvalMap.Map1Vertex4.Points;
-	       n = ctx->EvalMap.Map1Vertex4.Order * 4;
-	       break;
-	    case GL_MAP2_COLOR_4:
-	       data = ctx->EvalMap.Map2Color4.Points;
-	       n = ctx->EvalMap.Map2Color4.Uorder
-                 * ctx->EvalMap.Map2Color4.Vorder * 4;
-	       break;
-	    case GL_MAP2_INDEX:
-	       data = ctx->EvalMap.Map2Index.Points;
-	       n = ctx->EvalMap.Map2Index.Uorder
-                 * ctx->EvalMap.Map2Index.Vorder;
-	       break;
-	    case GL_MAP2_NORMAL:
-	       data = ctx->EvalMap.Map2Normal.Points;
-	       n = ctx->EvalMap.Map2Normal.Uorder
-                 * ctx->EvalMap.Map2Normal.Vorder * 3;
-	       break;
-	    case GL_MAP2_TEXTURE_COORD_1:
-	       data = ctx->EvalMap.Map2Texture1.Points;
-	       n = ctx->EvalMap.Map2Texture1.Uorder
-                 * ctx->EvalMap.Map2Texture1.Vorder * 1;
-	       break;
-	    case GL_MAP2_TEXTURE_COORD_2:
-	       data = ctx->EvalMap.Map2Texture2.Points;
-	       n = ctx->EvalMap.Map2Texture2.Uorder
-                 * ctx->EvalMap.Map2Texture2.Vorder * 2;
-	       break;
-	    case GL_MAP2_TEXTURE_COORD_3:
-	       data = ctx->EvalMap.Map2Texture3.Points;
-	       n = ctx->EvalMap.Map2Texture3.Uorder
-                 * ctx->EvalMap.Map2Texture3.Vorder * 3;
-	       break;
-	    case GL_MAP2_TEXTURE_COORD_4:
-	       data = ctx->EvalMap.Map2Texture4.Points;
-	       n = ctx->EvalMap.Map2Texture4.Uorder
-                 * ctx->EvalMap.Map2Texture4.Vorder * 4;
-	       break;
-	    case GL_MAP2_VERTEX_3:
-	       data = ctx->EvalMap.Map2Vertex3.Points;
-	       n = ctx->EvalMap.Map2Vertex3.Uorder
-                 * ctx->EvalMap.Map2Vertex3.Vorder * 3;
-	       break;
-	    case GL_MAP2_VERTEX_4:
-	       data = ctx->EvalMap.Map2Vertex4.Points;
-	       n = ctx->EvalMap.Map2Vertex4.Uorder
-                 * ctx->EvalMap.Map2Vertex4.Vorder * 4;
-	       break;
-	    default:
-	       _mesa_error( ctx, GL_INVALID_ENUM, "glGetMapfv(target)" );
-	       return;
-	 }
+         if (map1d) {
+            data = map1d->Points;
+            n = map1d->Order * comps;
+         }
+         else {
+            data = map2d->Points;
+            n = map2d->Uorder * map2d->Vorder * comps;
+         }
 	 if (data) {
+            numBytes = n * sizeof *v;
+            if (bufSize < numBytes)
+               goto overflow;
 	    for (i=0;i<n;i++) {
 	       v[i] = data[i];
 	    }
 	 }
          break;
       case GL_ORDER:
-	 switch (target) {
-	    case GL_MAP1_COLOR_4:
-	       *v = ctx->EvalMap.Map1Color4.Order;
-	       break;
-	    case GL_MAP1_INDEX:
-	       *v = ctx->EvalMap.Map1Index.Order;
-	       break;
-	    case GL_MAP1_NORMAL:
-	       *v = ctx->EvalMap.Map1Normal.Order;
-	       break;
-	    case GL_MAP1_TEXTURE_COORD_1:
-	       *v = ctx->EvalMap.Map1Texture1.Order;
-	       break;
-	    case GL_MAP1_TEXTURE_COORD_2:
-	       *v = ctx->EvalMap.Map1Texture2.Order;
-	       break;
-	    case GL_MAP1_TEXTURE_COORD_3:
-	       *v = ctx->EvalMap.Map1Texture3.Order;
-	       break;
-	    case GL_MAP1_TEXTURE_COORD_4:
-	       *v = ctx->EvalMap.Map1Texture4.Order;
-	       break;
-	    case GL_MAP1_VERTEX_3:
-	       *v = ctx->EvalMap.Map1Vertex3.Order;
-	       break;
-	    case GL_MAP1_VERTEX_4:
-	       *v = ctx->EvalMap.Map1Vertex4.Order;
-	       break;
-	    case GL_MAP2_COLOR_4:
-	       v[0] = ctx->EvalMap.Map2Color4.Uorder;
-	       v[1] = ctx->EvalMap.Map2Color4.Vorder;
-	       break;
-	    case GL_MAP2_INDEX:
-	       v[0] = ctx->EvalMap.Map2Index.Uorder;
-	       v[1] = ctx->EvalMap.Map2Index.Vorder;
-	       break;
-	    case GL_MAP2_NORMAL:
-	       v[0] = ctx->EvalMap.Map2Normal.Uorder;
-	       v[1] = ctx->EvalMap.Map2Normal.Vorder;
-	       break;
-	    case GL_MAP2_TEXTURE_COORD_1:
-	       v[0] = ctx->EvalMap.Map2Texture1.Uorder;
-	       v[1] = ctx->EvalMap.Map2Texture1.Vorder;
-	       break;
-	    case GL_MAP2_TEXTURE_COORD_2:
-	       v[0] = ctx->EvalMap.Map2Texture2.Uorder;
-	       v[1] = ctx->EvalMap.Map2Texture2.Vorder;
-	       break;
-	    case GL_MAP2_TEXTURE_COORD_3:
-	       v[0] = ctx->EvalMap.Map2Texture3.Uorder;
-	       v[1] = ctx->EvalMap.Map2Texture3.Vorder;
-	       break;
-	    case GL_MAP2_TEXTURE_COORD_4:
-	       v[0] = ctx->EvalMap.Map2Texture4.Uorder;
-	       v[1] = ctx->EvalMap.Map2Texture4.Vorder;
-	       break;
-	    case GL_MAP2_VERTEX_3:
-	       v[0] = ctx->EvalMap.Map2Vertex3.Uorder;
-	       v[1] = ctx->EvalMap.Map2Vertex3.Vorder;
-	       break;
-	    case GL_MAP2_VERTEX_4:
-	       v[0] = ctx->EvalMap.Map2Vertex4.Uorder;
-	       v[1] = ctx->EvalMap.Map2Vertex4.Vorder;
-	       break;
-	    default:
-	       _mesa_error( ctx, GL_INVALID_ENUM, "glGetMapfv(target)" );
-	       return;
-	 }
+         if (map1d) {
+            numBytes = 1 * sizeof *v;
+            if (bufSize < numBytes)
+               goto overflow;
+            v[0] = (GLfloat) map1d->Order;
+         }
+         else {
+            numBytes = 2 * sizeof *v;
+            if (bufSize < numBytes)
+               goto overflow;
+            v[0] = (GLfloat) map2d->Uorder;
+            v[1] = (GLfloat) map2d->Vorder;
+         }
          break;
       case GL_DOMAIN:
-	 switch (target) {
-	    case GL_MAP1_COLOR_4:
-	       v[0] = ctx->EvalMap.Map1Color4.u1;
-	       v[1] = ctx->EvalMap.Map1Color4.u2;
-	       break;
-	    case GL_MAP1_INDEX:
-	       v[0] = ctx->EvalMap.Map1Index.u1;
-	       v[1] = ctx->EvalMap.Map1Index.u2;
-	       break;
-	    case GL_MAP1_NORMAL:
-	       v[0] = ctx->EvalMap.Map1Normal.u1;
-	       v[1] = ctx->EvalMap.Map1Normal.u2;
-	       break;
-	    case GL_MAP1_TEXTURE_COORD_1:
-	       v[0] = ctx->EvalMap.Map1Texture1.u1;
-	       v[1] = ctx->EvalMap.Map1Texture1.u2;
-	       break;
-	    case GL_MAP1_TEXTURE_COORD_2:
-	       v[0] = ctx->EvalMap.Map1Texture2.u1;
-	       v[1] = ctx->EvalMap.Map1Texture2.u2;
-	       break;
-	    case GL_MAP1_TEXTURE_COORD_3:
-	       v[0] = ctx->EvalMap.Map1Texture3.u1;
-	       v[1] = ctx->EvalMap.Map1Texture3.u2;
-	       break;
-	    case GL_MAP1_TEXTURE_COORD_4:
-	       v[0] = ctx->EvalMap.Map1Texture4.u1;
-	       v[1] = ctx->EvalMap.Map1Texture4.u2;
-	       break;
-	    case GL_MAP1_VERTEX_3:
-	       v[0] = ctx->EvalMap.Map1Vertex3.u1;
-	       v[1] = ctx->EvalMap.Map1Vertex3.u2;
-	       break;
-	    case GL_MAP1_VERTEX_4:
-	       v[0] = ctx->EvalMap.Map1Vertex4.u1;
-	       v[1] = ctx->EvalMap.Map1Vertex4.u2;
-	       break;
-	    case GL_MAP2_COLOR_4:
-	       v[0] = ctx->EvalMap.Map2Color4.u1;
-	       v[1] = ctx->EvalMap.Map2Color4.u2;
-	       v[2] = ctx->EvalMap.Map2Color4.v1;
-	       v[3] = ctx->EvalMap.Map2Color4.v2;
-	       break;
-	    case GL_MAP2_INDEX:
-	       v[0] = ctx->EvalMap.Map2Index.u1;
-	       v[1] = ctx->EvalMap.Map2Index.u2;
-	       v[2] = ctx->EvalMap.Map2Index.v1;
-	       v[3] = ctx->EvalMap.Map2Index.v2;
-	       break;
-	    case GL_MAP2_NORMAL:
-	       v[0] = ctx->EvalMap.Map2Normal.u1;
-	       v[1] = ctx->EvalMap.Map2Normal.u2;
-	       v[2] = ctx->EvalMap.Map2Normal.v1;
-	       v[3] = ctx->EvalMap.Map2Normal.v2;
-	       break;
-	    case GL_MAP2_TEXTURE_COORD_1:
-	       v[0] = ctx->EvalMap.Map2Texture1.u1;
-	       v[1] = ctx->EvalMap.Map2Texture1.u2;
-	       v[2] = ctx->EvalMap.Map2Texture1.v1;
-	       v[3] = ctx->EvalMap.Map2Texture1.v2;
-	       break;
-	    case GL_MAP2_TEXTURE_COORD_2:
-	       v[0] = ctx->EvalMap.Map2Texture2.u1;
-	       v[1] = ctx->EvalMap.Map2Texture2.u2;
-	       v[2] = ctx->EvalMap.Map2Texture2.v1;
-	       v[3] = ctx->EvalMap.Map2Texture2.v2;
-	       break;
-	    case GL_MAP2_TEXTURE_COORD_3:
-	       v[0] = ctx->EvalMap.Map2Texture3.u1;
-	       v[1] = ctx->EvalMap.Map2Texture3.u2;
-	       v[2] = ctx->EvalMap.Map2Texture3.v1;
-	       v[3] = ctx->EvalMap.Map2Texture3.v2;
-	       break;
-	    case GL_MAP2_TEXTURE_COORD_4:
-	       v[0] = ctx->EvalMap.Map2Texture4.u1;
-	       v[1] = ctx->EvalMap.Map2Texture4.u2;
-	       v[2] = ctx->EvalMap.Map2Texture4.v1;
-	       v[3] = ctx->EvalMap.Map2Texture4.v2;
-	       break;
-	    case GL_MAP2_VERTEX_3:
-	       v[0] = ctx->EvalMap.Map2Vertex3.u1;
-	       v[1] = ctx->EvalMap.Map2Vertex3.u2;
-	       v[2] = ctx->EvalMap.Map2Vertex3.v1;
-	       v[3] = ctx->EvalMap.Map2Vertex3.v2;
-	       break;
-	    case GL_MAP2_VERTEX_4:
-	       v[0] = ctx->EvalMap.Map2Vertex4.u1;
-	       v[1] = ctx->EvalMap.Map2Vertex4.u2;
-	       v[2] = ctx->EvalMap.Map2Vertex4.v1;
-	       v[3] = ctx->EvalMap.Map2Vertex4.v2;
-	       break;
-	    default:
-	       _mesa_error( ctx, GL_INVALID_ENUM, "glGetMapfv(target)" );
-	 }
+         if (map1d) {
+            numBytes = 2 * sizeof *v;
+            if (bufSize < numBytes)
+               goto overflow;
+            v[0] = map1d->u1;
+            v[1] = map1d->u2;
+         }
+         else {
+            numBytes = 4 * sizeof *v;
+            if (bufSize < numBytes)
+               goto overflow;
+            v[0] = map2d->u1;
+            v[1] = map2d->u2;
+            v[2] = map2d->v1;
+            v[3] = map2d->v2;
+         }
          break;
       default:
          _mesa_error( ctx, GL_INVALID_ENUM, "glGetMapfv(query)" );
    }
+   return;
+
+overflow:
+   _mesa_error( ctx, GL_INVALID_OPERATION,
+               "glGetnMapfvARB(out of bounds: bufSize is %d,"
+               " but %d bytes are required)", bufSize, numBytes );
 }
 
 
-void
-_mesa_GetMapiv( GLenum target, GLenum query, GLint *v )
+void GLAPIENTRY
+_mesa_GetMapfv( GLenum target, GLenum query, GLfloat *v )
+{
+   _mesa_GetnMapfvARB(target, query, INT_MAX, v);
+}
+
+
+void GLAPIENTRY
+_mesa_GetnMapivARB( GLenum target, GLenum query, GLsizei bufSize, GLint *v )
 {
    GET_CURRENT_CONTEXT(ctx);
+   struct gl_1d_map *map1d;
+   struct gl_2d_map *map2d;
    GLuint i, n;
    GLfloat *data;
-   ASSERT_OUTSIDE_BEGIN_END(ctx);
+   GLuint comps;
+   GLsizei numBytes;
+
+   comps = _mesa_evaluator_components(target);
+   if (!comps) {
+      _mesa_error( ctx, GL_INVALID_ENUM, "glGetMapiv(target)" );
+      return;
+   }
+
+   map1d = get_1d_map(ctx, target);
+   map2d = get_2d_map(ctx, target);
+   assert(map1d || map2d);
 
    switch (query) {
       case GL_COEFF:
-	 switch (target) {
-	    case GL_MAP1_COLOR_4:
-	       data = ctx->EvalMap.Map1Color4.Points;
-	       n = ctx->EvalMap.Map1Color4.Order * 4;
-	       break;
-	    case GL_MAP1_INDEX:
-	       data = ctx->EvalMap.Map1Index.Points;
-	       n = ctx->EvalMap.Map1Index.Order;
-	       break;
-	    case GL_MAP1_NORMAL:
-	       data = ctx->EvalMap.Map1Normal.Points;
-	       n = ctx->EvalMap.Map1Normal.Order * 3;
-	       break;
-	    case GL_MAP1_TEXTURE_COORD_1:
-	       data = ctx->EvalMap.Map1Texture1.Points;
-	       n = ctx->EvalMap.Map1Texture1.Order * 1;
-	       break;
-	    case GL_MAP1_TEXTURE_COORD_2:
-	       data = ctx->EvalMap.Map1Texture2.Points;
-	       n = ctx->EvalMap.Map1Texture2.Order * 2;
-	       break;
-	    case GL_MAP1_TEXTURE_COORD_3:
-	       data = ctx->EvalMap.Map1Texture3.Points;
-	       n = ctx->EvalMap.Map1Texture3.Order * 3;
-	       break;
-	    case GL_MAP1_TEXTURE_COORD_4:
-	       data = ctx->EvalMap.Map1Texture4.Points;
-	       n = ctx->EvalMap.Map1Texture4.Order * 4;
-	       break;
-	    case GL_MAP1_VERTEX_3:
-	       data = ctx->EvalMap.Map1Vertex3.Points;
-	       n = ctx->EvalMap.Map1Vertex3.Order * 3;
-	       break;
-	    case GL_MAP1_VERTEX_4:
-	       data = ctx->EvalMap.Map1Vertex4.Points;
-	       n = ctx->EvalMap.Map1Vertex4.Order * 4;
-	       break;
-	    case GL_MAP2_COLOR_4:
-	       data = ctx->EvalMap.Map2Color4.Points;
-	       n = ctx->EvalMap.Map2Color4.Uorder
-                 * ctx->EvalMap.Map2Color4.Vorder * 4;
-	       break;
-	    case GL_MAP2_INDEX:
-	       data = ctx->EvalMap.Map2Index.Points;
-	       n = ctx->EvalMap.Map2Index.Uorder
-                 * ctx->EvalMap.Map2Index.Vorder;
-	       break;
-	    case GL_MAP2_NORMAL:
-	       data = ctx->EvalMap.Map2Normal.Points;
-	       n = ctx->EvalMap.Map2Normal.Uorder
-                 * ctx->EvalMap.Map2Normal.Vorder * 3;
-	       break;
-	    case GL_MAP2_TEXTURE_COORD_1:
-	       data = ctx->EvalMap.Map2Texture1.Points;
-	       n = ctx->EvalMap.Map2Texture1.Uorder
-                 * ctx->EvalMap.Map2Texture1.Vorder * 1;
-	       break;
-	    case GL_MAP2_TEXTURE_COORD_2:
-	       data = ctx->EvalMap.Map2Texture2.Points;
-	       n = ctx->EvalMap.Map2Texture2.Uorder
-                 * ctx->EvalMap.Map2Texture2.Vorder * 2;
-	       break;
-	    case GL_MAP2_TEXTURE_COORD_3:
-	       data = ctx->EvalMap.Map2Texture3.Points;
-	       n = ctx->EvalMap.Map2Texture3.Uorder
-                 * ctx->EvalMap.Map2Texture3.Vorder * 3;
-	       break;
-	    case GL_MAP2_TEXTURE_COORD_4:
-	       data = ctx->EvalMap.Map2Texture4.Points;
-	       n = ctx->EvalMap.Map2Texture4.Uorder
-                 * ctx->EvalMap.Map2Texture4.Vorder * 4;
-	       break;
-	    case GL_MAP2_VERTEX_3:
-	       data = ctx->EvalMap.Map2Vertex3.Points;
-	       n = ctx->EvalMap.Map2Vertex3.Uorder
-                 * ctx->EvalMap.Map2Vertex3.Vorder * 3;
-	       break;
-	    case GL_MAP2_VERTEX_4:
-	       data = ctx->EvalMap.Map2Vertex4.Points;
-	       n = ctx->EvalMap.Map2Vertex4.Uorder
-                 * ctx->EvalMap.Map2Vertex4.Vorder * 4;
-	       break;
-	    default:
-	       _mesa_error( ctx, GL_INVALID_ENUM, "glGetMapiv(target)" );
-	       return;
-	 }
+         if (map1d) {
+            data = map1d->Points;
+            n = map1d->Order * comps;
+         }
+         else {
+            data = map2d->Points;
+            n = map2d->Uorder * map2d->Vorder * comps;
+         }
 	 if (data) {
+            numBytes = n * sizeof *v;
+            if (bufSize < numBytes)
+               goto overflow;
 	    for (i=0;i<n;i++) {
-	       v[i] = ROUNDF(data[i]);
+	       v[i] = IROUND(data[i]);
 	    }
 	 }
          break;
       case GL_ORDER:
-	 switch (target) {
-	    case GL_MAP1_COLOR_4:
-	       *v = ctx->EvalMap.Map1Color4.Order;
-	       break;
-	    case GL_MAP1_INDEX:
-	       *v = ctx->EvalMap.Map1Index.Order;
-	       break;
-	    case GL_MAP1_NORMAL:
-	       *v = ctx->EvalMap.Map1Normal.Order;
-	       break;
-	    case GL_MAP1_TEXTURE_COORD_1:
-	       *v = ctx->EvalMap.Map1Texture1.Order;
-	       break;
-	    case GL_MAP1_TEXTURE_COORD_2:
-	       *v = ctx->EvalMap.Map1Texture2.Order;
-	       break;
-	    case GL_MAP1_TEXTURE_COORD_3:
-	       *v = ctx->EvalMap.Map1Texture3.Order;
-	       break;
-	    case GL_MAP1_TEXTURE_COORD_4:
-	       *v = ctx->EvalMap.Map1Texture4.Order;
-	       break;
-	    case GL_MAP1_VERTEX_3:
-	       *v = ctx->EvalMap.Map1Vertex3.Order;
-	       break;
-	    case GL_MAP1_VERTEX_4:
-	       *v = ctx->EvalMap.Map1Vertex4.Order;
-	       break;
-	    case GL_MAP2_COLOR_4:
-	       v[0] = ctx->EvalMap.Map2Color4.Uorder;
-	       v[1] = ctx->EvalMap.Map2Color4.Vorder;
-	       break;
-	    case GL_MAP2_INDEX:
-	       v[0] = ctx->EvalMap.Map2Index.Uorder;
-	       v[1] = ctx->EvalMap.Map2Index.Vorder;
-	       break;
-	    case GL_MAP2_NORMAL:
-	       v[0] = ctx->EvalMap.Map2Normal.Uorder;
-	       v[1] = ctx->EvalMap.Map2Normal.Vorder;
-	       break;
-	    case GL_MAP2_TEXTURE_COORD_1:
-	       v[0] = ctx->EvalMap.Map2Texture1.Uorder;
-	       v[1] = ctx->EvalMap.Map2Texture1.Vorder;
-	       break;
-	    case GL_MAP2_TEXTURE_COORD_2:
-	       v[0] = ctx->EvalMap.Map2Texture2.Uorder;
-	       v[1] = ctx->EvalMap.Map2Texture2.Vorder;
-	       break;
-	    case GL_MAP2_TEXTURE_COORD_3:
-	       v[0] = ctx->EvalMap.Map2Texture3.Uorder;
-	       v[1] = ctx->EvalMap.Map2Texture3.Vorder;
-	       break;
-	    case GL_MAP2_TEXTURE_COORD_4:
-	       v[0] = ctx->EvalMap.Map2Texture4.Uorder;
-	       v[1] = ctx->EvalMap.Map2Texture4.Vorder;
-	       break;
-	    case GL_MAP2_VERTEX_3:
-	       v[0] = ctx->EvalMap.Map2Vertex3.Uorder;
-	       v[1] = ctx->EvalMap.Map2Vertex3.Vorder;
-	       break;
-	    case GL_MAP2_VERTEX_4:
-	       v[0] = ctx->EvalMap.Map2Vertex4.Uorder;
-	       v[1] = ctx->EvalMap.Map2Vertex4.Vorder;
-	       break;
-	    default:
-	       _mesa_error( ctx, GL_INVALID_ENUM, "glGetMapiv(target)" );
-	       return;
-	 }
+         if (map1d) {
+            numBytes = 1 * sizeof *v;
+            if (bufSize < numBytes)
+               goto overflow;
+            v[0] = map1d->Order;
+         }
+         else {
+            numBytes = 2 * sizeof *v;
+            if (bufSize < numBytes)
+               goto overflow;
+            v[0] = map2d->Uorder;
+            v[1] = map2d->Vorder;
+         }
          break;
       case GL_DOMAIN:
-	 switch (target) {
-	    case GL_MAP1_COLOR_4:
-	       v[0] = ROUNDF(ctx->EvalMap.Map1Color4.u1);
-	       v[1] = ROUNDF(ctx->EvalMap.Map1Color4.u2);
-	       break;
-	    case GL_MAP1_INDEX:
-	       v[0] = ROUNDF(ctx->EvalMap.Map1Index.u1);
-	       v[1] = ROUNDF(ctx->EvalMap.Map1Index.u2);
-	       break;
-	    case GL_MAP1_NORMAL:
-	       v[0] = ROUNDF(ctx->EvalMap.Map1Normal.u1);
-	       v[1] = ROUNDF(ctx->EvalMap.Map1Normal.u2);
-	       break;
-	    case GL_MAP1_TEXTURE_COORD_1:
-	       v[0] = ROUNDF(ctx->EvalMap.Map1Texture1.u1);
-	       v[1] = ROUNDF(ctx->EvalMap.Map1Texture1.u2);
-	       break;
-	    case GL_MAP1_TEXTURE_COORD_2:
-	       v[0] = ROUNDF(ctx->EvalMap.Map1Texture2.u1);
-	       v[1] = ROUNDF(ctx->EvalMap.Map1Texture2.u2);
-	       break;
-	    case GL_MAP1_TEXTURE_COORD_3:
-	       v[0] = ROUNDF(ctx->EvalMap.Map1Texture3.u1);
-	       v[1] = ROUNDF(ctx->EvalMap.Map1Texture3.u2);
-	       break;
-	    case GL_MAP1_TEXTURE_COORD_4:
-	       v[0] = ROUNDF(ctx->EvalMap.Map1Texture4.u1);
-	       v[1] = ROUNDF(ctx->EvalMap.Map1Texture4.u2);
-	       break;
-	    case GL_MAP1_VERTEX_3:
-	       v[0] = ROUNDF(ctx->EvalMap.Map1Vertex3.u1);
-	       v[1] = ROUNDF(ctx->EvalMap.Map1Vertex3.u2);
-	       break;
-	    case GL_MAP1_VERTEX_4:
-	       v[0] = ROUNDF(ctx->EvalMap.Map1Vertex4.u1);
-	       v[1] = ROUNDF(ctx->EvalMap.Map1Vertex4.u2);
-	       break;
-	    case GL_MAP2_COLOR_4:
-	       v[0] = ROUNDF(ctx->EvalMap.Map2Color4.u1);
-	       v[1] = ROUNDF(ctx->EvalMap.Map2Color4.u2);
-	       v[2] = ROUNDF(ctx->EvalMap.Map2Color4.v1);
-	       v[3] = ROUNDF(ctx->EvalMap.Map2Color4.v2);
-	       break;
-	    case GL_MAP2_INDEX:
-	       v[0] = ROUNDF(ctx->EvalMap.Map2Index.u1);
-	       v[1] = ROUNDF(ctx->EvalMap.Map2Index.u2);
-	       v[2] = ROUNDF(ctx->EvalMap.Map2Index.v1);
-	       v[3] = ROUNDF(ctx->EvalMap.Map2Index.v2);
-	       break;
-	    case GL_MAP2_NORMAL:
-	       v[0] = ROUNDF(ctx->EvalMap.Map2Normal.u1);
-	       v[1] = ROUNDF(ctx->EvalMap.Map2Normal.u2);
-	       v[2] = ROUNDF(ctx->EvalMap.Map2Normal.v1);
-	       v[3] = ROUNDF(ctx->EvalMap.Map2Normal.v2);
-	       break;
-	    case GL_MAP2_TEXTURE_COORD_1:
-	       v[0] = ROUNDF(ctx->EvalMap.Map2Texture1.u1);
-	       v[1] = ROUNDF(ctx->EvalMap.Map2Texture1.u2);
-	       v[2] = ROUNDF(ctx->EvalMap.Map2Texture1.v1);
-	       v[3] = ROUNDF(ctx->EvalMap.Map2Texture1.v2);
-	       break;
-	    case GL_MAP2_TEXTURE_COORD_2:
-	       v[0] = ROUNDF(ctx->EvalMap.Map2Texture2.u1);
-	       v[1] = ROUNDF(ctx->EvalMap.Map2Texture2.u2);
-	       v[2] = ROUNDF(ctx->EvalMap.Map2Texture2.v1);
-	       v[3] = ROUNDF(ctx->EvalMap.Map2Texture2.v2);
-	       break;
-	    case GL_MAP2_TEXTURE_COORD_3:
-	       v[0] = ROUNDF(ctx->EvalMap.Map2Texture3.u1);
-	       v[1] = ROUNDF(ctx->EvalMap.Map2Texture3.u2);
-	       v[2] = ROUNDF(ctx->EvalMap.Map2Texture3.v1);
-	       v[3] = ROUNDF(ctx->EvalMap.Map2Texture3.v2);
-	       break;
-	    case GL_MAP2_TEXTURE_COORD_4:
-	       v[0] = ROUNDF(ctx->EvalMap.Map2Texture4.u1);
-	       v[1] = ROUNDF(ctx->EvalMap.Map2Texture4.u2);
-	       v[2] = ROUNDF(ctx->EvalMap.Map2Texture4.v1);
-	       v[3] = ROUNDF(ctx->EvalMap.Map2Texture4.v2);
-	       break;
-	    case GL_MAP2_VERTEX_3:
-	       v[0] = ROUNDF(ctx->EvalMap.Map2Vertex3.u1);
-	       v[1] = ROUNDF(ctx->EvalMap.Map2Vertex3.u2);
-	       v[2] = ROUNDF(ctx->EvalMap.Map2Vertex3.v1);
-	       v[3] = ROUNDF(ctx->EvalMap.Map2Vertex3.v2);
-	       break;
-	    case GL_MAP2_VERTEX_4:
-	       v[0] = ROUNDF(ctx->EvalMap.Map2Vertex4.u1);
-	       v[1] = ROUNDF(ctx->EvalMap.Map2Vertex4.u2);
-	       v[2] = ROUNDF(ctx->EvalMap.Map2Vertex4.v1);
-	       v[3] = ROUNDF(ctx->EvalMap.Map2Vertex4.v2);
-	       break;
-	    default:
-	       _mesa_error( ctx, GL_INVALID_ENUM, "glGetMapiv(target)" );
-	 }
+         if (map1d) {
+            numBytes = 2 * sizeof *v;
+            if (bufSize < numBytes)
+               goto overflow;
+            v[0] = IROUND(map1d->u1);
+            v[1] = IROUND(map1d->u2);
+         }
+         else {
+            numBytes = 4 * sizeof *v;
+            if (bufSize < numBytes)
+               goto overflow;
+            v[0] = IROUND(map2d->u1);
+            v[1] = IROUND(map2d->u2);
+            v[2] = IROUND(map2d->v1);
+            v[3] = IROUND(map2d->v2);
+         }
          break;
       default:
          _mesa_error( ctx, GL_INVALID_ENUM, "glGetMapiv(query)" );
    }
+   return;
+
+overflow:
+   _mesa_error( ctx, GL_INVALID_OPERATION,
+               "glGetnMapivARB(out of bounds: bufSize is %d,"
+               " but %d bytes are required)", bufSize, numBytes );
 }
 
 
+void GLAPIENTRY
+_mesa_GetMapiv( GLenum target, GLenum query, GLint *v )
+{
+   _mesa_GetnMapivARB(target, query, INT_MAX, v);
+}
 
-void
+
+void GLAPIENTRY
 _mesa_MapGrid1f( GLint un, GLfloat u1, GLfloat u2 )
 {
    GET_CURRENT_CONTEXT(ctx);
-   ASSERT_OUTSIDE_BEGIN_END(ctx);
 
    if (un<1) {
       _mesa_error( ctx, GL_INVALID_VALUE, "glMapGrid1f" );
@@ -1325,19 +777,18 @@ _mesa_MapGrid1f( GLint un, GLfloat u1, GLfloat u2 )
 }
 
 
-void
+void GLAPIENTRY
 _mesa_MapGrid1d( GLint un, GLdouble u1, GLdouble u2 )
 {
-   _mesa_MapGrid1f( un, u1, u2 );
+   _mesa_MapGrid1f( un, (GLfloat) u1, (GLfloat) u2 );
 }
 
 
-void
+void GLAPIENTRY
 _mesa_MapGrid2f( GLint un, GLfloat u1, GLfloat u2,
                  GLint vn, GLfloat v1, GLfloat v2 )
 {
    GET_CURRENT_CONTEXT(ctx);
-   ASSERT_OUTSIDE_BEGIN_END(ctx);
 
    if (un<1) {
       _mesa_error( ctx, GL_INVALID_VALUE, "glMapGrid2f(un)" );
@@ -1360,9 +811,154 @@ _mesa_MapGrid2f( GLint un, GLfloat u1, GLfloat u2,
 }
 
 
-void
+void GLAPIENTRY
 _mesa_MapGrid2d( GLint un, GLdouble u1, GLdouble u2,
                  GLint vn, GLdouble v1, GLdouble v2 )
 {
-   _mesa_MapGrid2f( un, u1, u2, vn, v1, v2 );
+   _mesa_MapGrid2f( un, (GLfloat) u1, (GLfloat) u2, 
+		    vn, (GLfloat) v1, (GLfloat) v2 );
+}
+
+
+void
+_mesa_install_eval_vtxfmt(struct _glapi_table *disp,
+                          const GLvertexformat *vfmt)
+{
+   SET_EvalCoord1f(disp, vfmt->EvalCoord1f);
+   SET_EvalCoord1fv(disp, vfmt->EvalCoord1fv);
+   SET_EvalCoord2f(disp, vfmt->EvalCoord2f);
+   SET_EvalCoord2fv(disp, vfmt->EvalCoord2fv);
+   SET_EvalPoint1(disp, vfmt->EvalPoint1);
+   SET_EvalPoint2(disp, vfmt->EvalPoint2);
+}
+
+
+/**********************************************************************/
+/*****                      Initialization                        *****/
+/**********************************************************************/
+
+/**
+ * Initialize a 1-D evaluator map.
+ */
+static void
+init_1d_map( struct gl_1d_map *map, int n, const float *initial )
+{
+   map->Order = 1;
+   map->u1 = 0.0;
+   map->u2 = 1.0;
+   map->Points = malloc(n * sizeof(GLfloat));
+   if (map->Points) {
+      GLint i;
+      for (i=0;i<n;i++)
+         map->Points[i] = initial[i];
+   }
+}
+
+
+/**
+ * Initialize a 2-D evaluator map 
+ */
+static void
+init_2d_map( struct gl_2d_map *map, int n, const float *initial )
+{
+   map->Uorder = 1;
+   map->Vorder = 1;
+   map->u1 = 0.0;
+   map->u2 = 1.0;
+   map->v1 = 0.0;
+   map->v2 = 1.0;
+   map->Points = malloc(n * sizeof(GLfloat));
+   if (map->Points) {
+      GLint i;
+      for (i=0;i<n;i++)
+         map->Points[i] = initial[i];
+   }
+}
+
+
+void _mesa_init_eval( struct gl_context *ctx )
+{
+   /* Evaluators group */
+   ctx->Eval.Map1Color4 = GL_FALSE;
+   ctx->Eval.Map1Index = GL_FALSE;
+   ctx->Eval.Map1Normal = GL_FALSE;
+   ctx->Eval.Map1TextureCoord1 = GL_FALSE;
+   ctx->Eval.Map1TextureCoord2 = GL_FALSE;
+   ctx->Eval.Map1TextureCoord3 = GL_FALSE;
+   ctx->Eval.Map1TextureCoord4 = GL_FALSE;
+   ctx->Eval.Map1Vertex3 = GL_FALSE;
+   ctx->Eval.Map1Vertex4 = GL_FALSE;
+   ctx->Eval.Map2Color4 = GL_FALSE;
+   ctx->Eval.Map2Index = GL_FALSE;
+   ctx->Eval.Map2Normal = GL_FALSE;
+   ctx->Eval.Map2TextureCoord1 = GL_FALSE;
+   ctx->Eval.Map2TextureCoord2 = GL_FALSE;
+   ctx->Eval.Map2TextureCoord3 = GL_FALSE;
+   ctx->Eval.Map2TextureCoord4 = GL_FALSE;
+   ctx->Eval.Map2Vertex3 = GL_FALSE;
+   ctx->Eval.Map2Vertex4 = GL_FALSE;
+   ctx->Eval.AutoNormal = GL_FALSE;
+   ctx->Eval.MapGrid1un = 1;
+   ctx->Eval.MapGrid1u1 = 0.0;
+   ctx->Eval.MapGrid1u2 = 1.0;
+   ctx->Eval.MapGrid2un = 1;
+   ctx->Eval.MapGrid2vn = 1;
+   ctx->Eval.MapGrid2u1 = 0.0;
+   ctx->Eval.MapGrid2u2 = 1.0;
+   ctx->Eval.MapGrid2v1 = 0.0;
+   ctx->Eval.MapGrid2v2 = 1.0;
+
+   /* Evaluator data */
+   {
+      static GLfloat vertex[4] = { 0.0, 0.0, 0.0, 1.0 };
+      static GLfloat normal[3] = { 0.0, 0.0, 1.0 };
+      static GLfloat index[1] = { 1.0 };
+      static GLfloat color[4] = { 1.0, 1.0, 1.0, 1.0 };
+      static GLfloat texcoord[4] = { 0.0, 0.0, 0.0, 1.0 };
+
+      init_1d_map( &ctx->EvalMap.Map1Vertex3, 3, vertex );
+      init_1d_map( &ctx->EvalMap.Map1Vertex4, 4, vertex );
+      init_1d_map( &ctx->EvalMap.Map1Index, 1, index );
+      init_1d_map( &ctx->EvalMap.Map1Color4, 4, color );
+      init_1d_map( &ctx->EvalMap.Map1Normal, 3, normal );
+      init_1d_map( &ctx->EvalMap.Map1Texture1, 1, texcoord );
+      init_1d_map( &ctx->EvalMap.Map1Texture2, 2, texcoord );
+      init_1d_map( &ctx->EvalMap.Map1Texture3, 3, texcoord );
+      init_1d_map( &ctx->EvalMap.Map1Texture4, 4, texcoord );
+
+      init_2d_map( &ctx->EvalMap.Map2Vertex3, 3, vertex );
+      init_2d_map( &ctx->EvalMap.Map2Vertex4, 4, vertex );
+      init_2d_map( &ctx->EvalMap.Map2Index, 1, index );
+      init_2d_map( &ctx->EvalMap.Map2Color4, 4, color );
+      init_2d_map( &ctx->EvalMap.Map2Normal, 3, normal );
+      init_2d_map( &ctx->EvalMap.Map2Texture1, 1, texcoord );
+      init_2d_map( &ctx->EvalMap.Map2Texture2, 2, texcoord );
+      init_2d_map( &ctx->EvalMap.Map2Texture3, 3, texcoord );
+      init_2d_map( &ctx->EvalMap.Map2Texture4, 4, texcoord );
+   }
+}
+
+
+void _mesa_free_eval_data( struct gl_context *ctx )
+{
+   /* Free evaluator data */
+   free(ctx->EvalMap.Map1Vertex3.Points);
+   free(ctx->EvalMap.Map1Vertex4.Points);
+   free(ctx->EvalMap.Map1Index.Points);
+   free(ctx->EvalMap.Map1Color4.Points);
+   free(ctx->EvalMap.Map1Normal.Points);
+   free(ctx->EvalMap.Map1Texture1.Points);
+   free(ctx->EvalMap.Map1Texture2.Points);
+   free(ctx->EvalMap.Map1Texture3.Points);
+   free(ctx->EvalMap.Map1Texture4.Points);
+
+   free(ctx->EvalMap.Map2Vertex3.Points);
+   free(ctx->EvalMap.Map2Vertex4.Points);
+   free(ctx->EvalMap.Map2Index.Points);
+   free(ctx->EvalMap.Map2Color4.Points);
+   free(ctx->EvalMap.Map2Normal.Points);
+   free(ctx->EvalMap.Map2Texture1.Points);
+   free(ctx->EvalMap.Map2Texture2.Points);
+   free(ctx->EvalMap.Map2Texture3.Points);
+   free(ctx->EvalMap.Map2Texture4.Points);
 }