Move the transform and lighting code to two new directories

	math:  Provides basic matrix and vector functionality that
               might be useful to multiple software t&l
	       implementations, and is used by core mesa to
	       manage the Model, Project, etc matrices.

	tnl:   The real transform & lighting code from core mesa,
	       including everything from glVertex3f through vertex
	       buffer handling, transformation, clipping, lighting
	       and handoff to a driver for rasterization.

The interfaces of these can be further tightened up, but the basic
splitting up of state and code move is done.

1 files changed, 1 insertions, 1396 deletions

diff --git a/src/mesa/main/eval.c b/src/mesa/main/eval.c
index 1c779eb5e32..1cb8e26d1ac 100644
--- a/src/mesa/main/eval.c
+++ b/src/mesa/main/eval.c
@@ -1,4 +1,4 @@
-/* $Id: eval.c,v 1.14 2000/10/30 13:32:00 keithw Exp $ */
+/* $Id: eval.c,v 1.15 2000/11/16 21:05:35 keithw Exp $ */
 
 /*
  * Mesa 3-D graphics library
@@ -49,479 +49,9 @@
 #include "mem.h"
 #include "mmath.h"
 #include "types.h"
-#include "vb.h"
-#include "vbcull.h"
-#include "vbfill.h"
-#include "vbxform.h"
 #endif
 
 
-static GLfloat inv_tab[MAX_EVAL_ORDER];
-
-/*
- * Do one-time initialization for evaluators.
- */
-void gl_init_eval( void )
-{
-  static int init_flag = 0;
-  GLuint i;
-
-  /* Compute a table of nCr (combination) values used by the
-   * Bernstein polynomial generator.
-   */
-
-  /* KW: precompute 1/x for useful x.
-   */
-  if (init_flag==0) 
-  { 
-     for (i = 1 ; i < MAX_EVAL_ORDER ; i++)
-	inv_tab[i] = 1.0 / i;
-  }
-
-  init_flag = 1;
-}
-
-
-
-/*
- * Horner scheme for Bezier curves
- * 
- * Bezier curves can be computed via a Horner scheme.
- * Horner is numerically less stable than the de Casteljau
- * algorithm, but it is faster. For curves of degree n 
- * the complexity of Horner is O(n) and de Casteljau is O(n^2).
- * Since stability is not important for displaying curve 
- * points I decided to use the Horner scheme.
- *
- * A cubic Bezier curve with control points b0, b1, b2, b3 can be 
- * written as
- *
- *        (([3]        [3]     )     [3]       )     [3]
- * c(t) = (([0]*s*b0 + [1]*t*b1)*s + [2]*t^2*b2)*s + [3]*t^2*b3
- *
- *                                           [n]
- * where s=1-t and the binomial coefficients [i]. These can 
- * be computed iteratively using the identity:
- *
- * [n]               [n  ]             [n]
- * [i] = (n-i+1)/i * [i-1]     and     [0] = 1
- */
-
-
-static void
-horner_bezier_curve(const GLfloat *cp, GLfloat *out, GLfloat t,
-                    GLuint dim, GLuint order)
-{
-  GLfloat s, powert;
-  GLuint i, k, bincoeff;
-
-  if(order >= 2)
-  { 
-    bincoeff = order-1;
-    s = 1.0-t;
-
-    for(k=0; k<dim; k++)
-      out[k] = s*cp[k] + bincoeff*t*cp[dim+k];
-
-    for(i=2, cp+=2*dim, powert=t*t; i<order; i++, powert*=t, cp +=dim)
-    {
-      bincoeff *= order-i;
-      bincoeff *= inv_tab[i];
-
-      for(k=0; k<dim; k++)
-        out[k] = s*out[k] + bincoeff*powert*cp[k];
-    }
-  }
-  else /* order=1 -> constant curve */
-  { 
-    for(k=0; k<dim; k++)
-      out[k] = cp[k];
-  } 
-}
-
-/*
- * Tensor product Bezier surfaces
- *
- * Again the Horner scheme is used to compute a point on a 
- * TP Bezier surface. First a control polygon for a curve
- * on the surface in one parameter direction is computed,
- * then the point on the curve for the other parameter 
- * direction is evaluated.
- *
- * To store the curve control polygon additional storage
- * for max(uorder,vorder) points is needed in the 
- * control net cn.
- */
-
-static void
-horner_bezier_surf(GLfloat *cn, GLfloat *out, GLfloat u, GLfloat v,
-                   GLuint dim, GLuint uorder, GLuint vorder)
-{
-  GLfloat *cp = cn + uorder*vorder*dim;
-  GLuint i, uinc = vorder*dim;
-
-  if(vorder > uorder)
-  {
-    if(uorder >= 2)
-    { 
-      GLfloat s, poweru;
-      GLuint j, k, bincoeff;
-
-      /* Compute the control polygon for the surface-curve in u-direction */
-      for(j=0; j<vorder; j++)
-      {
-        GLfloat *ucp = &cn[j*dim];
-
-        /* Each control point is the point for parameter u on a */ 
-        /* curve defined by the control polygons in u-direction */
-	bincoeff = uorder-1;
-	s = 1.0-u;
-
-	for(k=0; k<dim; k++)
-	  cp[j*dim+k] = s*ucp[k] + bincoeff*u*ucp[uinc+k];
-
-	for(i=2, ucp+=2*uinc, poweru=u*u; i<uorder; 
-            i++, poweru*=u, ucp +=uinc)
-	{
-	  bincoeff *= uorder-i;
-          bincoeff *= inv_tab[i];
-
-	  for(k=0; k<dim; k++)
-	    cp[j*dim+k] = s*cp[j*dim+k] + bincoeff*poweru*ucp[k];
-	}
-      }
-        
-      /* Evaluate curve point in v */
-      horner_bezier_curve(cp, out, v, dim, vorder);
-    }
-    else /* uorder=1 -> cn defines a curve in v */
-      horner_bezier_curve(cn, out, v, dim, vorder);
-  }
-  else /* vorder <= uorder */
-  {
-    if(vorder > 1)
-    {
-      GLuint i;
-
-      /* Compute the control polygon for the surface-curve in u-direction */
-      for(i=0; i<uorder; i++, cn += uinc)
-      {
-	/* For constant i all cn[i][j] (j=0..vorder) are located */
-	/* on consecutive memory locations, so we can use        */
-	/* horner_bezier_curve to compute the control points     */
-
-	horner_bezier_curve(cn, &cp[i*dim], v, dim, vorder);
-      }
-
-      /* Evaluate curve point in u */
-      horner_bezier_curve(cp, out, u, dim, uorder);
-    }
-    else  /* vorder=1 -> cn defines a curve in u */
-      horner_bezier_curve(cn, out, u, dim, uorder);
-  }
-}
-
-/*
- * The direct de Casteljau algorithm is used when a point on the
- * surface and the tangent directions spanning the tangent plane
- * should be computed (this is needed to compute normals to the
- * surface). In this case the de Casteljau algorithm approach is
- * nicer because a point and the partial derivatives can be computed 
- * at the same time. To get the correct tangent length du and dv
- * must be multiplied with the (u2-u1)/uorder-1 and (v2-v1)/vorder-1. 
- * Since only the directions are needed, this scaling step is omitted.
- *
- * De Casteljau needs additional storage for uorder*vorder
- * values in the control net cn.
- */
-
-static void
-de_casteljau_surf(GLfloat *cn, GLfloat *out, GLfloat *du, GLfloat *dv,
-                  GLfloat u, GLfloat v, GLuint dim, 
-                  GLuint uorder, GLuint vorder)
-{
-  GLfloat *dcn = cn + uorder*vorder*dim;
-  GLfloat us = 1.0-u, vs = 1.0-v;
-  GLuint h, i, j, k;
-  GLuint minorder = uorder < vorder ? uorder : vorder;
-  GLuint uinc = vorder*dim;
-  GLuint dcuinc = vorder;
- 
-  /* Each component is evaluated separately to save buffer space  */
-  /* This does not drasticaly decrease the performance of the     */
-  /* algorithm. If additional storage for (uorder-1)*(vorder-1)   */
-  /* points would be available, the components could be accessed  */
-  /* in the innermost loop which could lead to less cache misses. */
-
-#define CN(I,J,K) cn[(I)*uinc+(J)*dim+(K)] 
-#define DCN(I, J) dcn[(I)*dcuinc+(J)]
-  if(minorder < 3)
-  {
-    if(uorder==vorder)
-    {
-      for(k=0; k<dim; k++)
-      {
-	/* Derivative direction in u */
-	du[k] = vs*(CN(1,0,k) - CN(0,0,k)) +
-	         v*(CN(1,1,k) - CN(0,1,k));
-
-	/* Derivative direction in v */
-	dv[k] = us*(CN(0,1,k) - CN(0,0,k)) + 
-	         u*(CN(1,1,k) - CN(1,0,k));
-
-	/* bilinear de Casteljau step */
-        out[k] =  us*(vs*CN(0,0,k) + v*CN(0,1,k)) +
-	           u*(vs*CN(1,0,k) + v*CN(1,1,k));
-      }
-    }
-    else if(minorder == uorder)
-    {
-      for(k=0; k<dim; k++)
-      {
-	/* bilinear de Casteljau step */
-	DCN(1,0) =    CN(1,0,k) -   CN(0,0,k);
-	DCN(0,0) = us*CN(0,0,k) + u*CN(1,0,k);
-
-	for(j=0; j<vorder-1; j++)
-	{
-	  /* for the derivative in u */
-	  DCN(1,j+1) =    CN(1,j+1,k) -   CN(0,j+1,k);
-	  DCN(1,j)   = vs*DCN(1,j)    + v*DCN(1,j+1);
-
-	  /* for the `point' */
-	  DCN(0,j+1) = us*CN(0,j+1,k) + u*CN(1,j+1,k);
-	  DCN(0,j)   = vs*DCN(0,j)    + v*DCN(0,j+1);
-	}
-        
-	/* remaining linear de Casteljau steps until the second last step */
-	for(h=minorder; h<vorder-1; h++)
-	  for(j=0; j<vorder-h; j++)
-	  {
-	    /* for the derivative in u */
-	    DCN(1,j) = vs*DCN(1,j) + v*DCN(1,j+1);
-
-	    /* for the `point' */
-	    DCN(0,j) = vs*DCN(0,j) + v*DCN(0,j+1);
-	  }
-
-	/* derivative direction in v */
-	dv[k] = DCN(0,1) - DCN(0,0);
-
-	/* derivative direction in u */
-	du[k] =   vs*DCN(1,0) + v*DCN(1,1);
-
-	/* last linear de Casteljau step */
-	out[k] =  vs*DCN(0,0) + v*DCN(0,1);
-      }
-    }
-    else /* minorder == vorder */
-    {
-      for(k=0; k<dim; k++)
-      {
-	/* bilinear de Casteljau step */
-	DCN(0,1) =    CN(0,1,k) -   CN(0,0,k);
-	DCN(0,0) = vs*CN(0,0,k) + v*CN(0,1,k);
-	for(i=0; i<uorder-1; i++)
-	{
-	  /* for the derivative in v */
-	  DCN(i+1,1) =    CN(i+1,1,k) -   CN(i+1,0,k);
-	  DCN(i,1)   = us*DCN(i,1)    + u*DCN(i+1,1);
-
-	  /* for the `point' */
-	  DCN(i+1,0) = vs*CN(i+1,0,k) + v*CN(i+1,1,k);
-	  DCN(i,0)   = us*DCN(i,0)    + u*DCN(i+1,0);
-	}
-        
-	/* remaining linear de Casteljau steps until the second last step */
-	for(h=minorder; h<uorder-1; h++)
-	  for(i=0; i<uorder-h; i++)
-	  {
-	    /* for the derivative in v */
-	    DCN(i,1) = us*DCN(i,1) + u*DCN(i+1,1);
-
-	    /* for the `point' */
-	    DCN(i,0) = us*DCN(i,0) + u*DCN(i+1,0);
-	  }
-
-	/* derivative direction in u */
-	du[k] = DCN(1,0) - DCN(0,0);
-
-	/* derivative direction in v */
-	dv[k] =   us*DCN(0,1) + u*DCN(1,1);
-
-	/* last linear de Casteljau step */
-	out[k] =  us*DCN(0,0) + u*DCN(1,0);
-      }
-    }
-  }
-  else if(uorder == vorder)
-  {
-    for(k=0; k<dim; k++)
-    {
-      /* first bilinear de Casteljau step */
-      for(i=0; i<uorder-1; i++)
-      {
-	DCN(i,0) = us*CN(i,0,k) + u*CN(i+1,0,k);
-	for(j=0; j<vorder-1; j++)
-	{
-	  DCN(i,j+1) = us*CN(i,j+1,k) + u*CN(i+1,j+1,k);
-	  DCN(i,j)   = vs*DCN(i,j)    + v*DCN(i,j+1);
-	}
-      }
-
-      /* remaining bilinear de Casteljau steps until the second last step */
-      for(h=2; h<minorder-1; h++)
-	for(i=0; i<uorder-h; i++)
-	{
-	  DCN(i,0) = us*DCN(i,0) + u*DCN(i+1,0);
-	  for(j=0; j<vorder-h; j++)
-	  {
-	    DCN(i,j+1) = us*DCN(i,j+1) + u*DCN(i+1,j+1);
-	    DCN(i,j)   = vs*DCN(i,j)   + v*DCN(i,j+1);
-	  }
-	}
-
-      /* derivative direction in u */
-      du[k] = vs*(DCN(1,0) - DCN(0,0)) +
-	       v*(DCN(1,1) - DCN(0,1));
-
-      /* derivative direction in v */
-      dv[k] = us*(DCN(0,1) - DCN(0,0)) + 
-	       u*(DCN(1,1) - DCN(1,0));
-
-      /* last bilinear de Casteljau step */
-      out[k] =  us*(vs*DCN(0,0) + v*DCN(0,1)) +
-	         u*(vs*DCN(1,0) + v*DCN(1,1));
-    }
-  }
-  else if(minorder == uorder)
-  {
-    for(k=0; k<dim; k++)
-    {
-      /* first bilinear de Casteljau step */
-      for(i=0; i<uorder-1; i++)
-      {
-	DCN(i,0) = us*CN(i,0,k) + u*CN(i+1,0,k);
-	for(j=0; j<vorder-1; j++)
-	{
-	  DCN(i,j+1) = us*CN(i,j+1,k) + u*CN(i+1,j+1,k);
-	  DCN(i,j)   = vs*DCN(i,j)    + v*DCN(i,j+1);
-	}
-      }
-
-      /* remaining bilinear de Casteljau steps until the second last step */
-      for(h=2; h<minorder-1; h++)
-	for(i=0; i<uorder-h; i++)
-	{
-	  DCN(i,0) = us*DCN(i,0) + u*DCN(i+1,0);
-	  for(j=0; j<vorder-h; j++)
-	  {
-	    DCN(i,j+1) = us*DCN(i,j+1) + u*DCN(i+1,j+1);
-	    DCN(i,j)   = vs*DCN(i,j)   + v*DCN(i,j+1);
-	  }
-	}
-
-      /* last bilinear de Casteljau step */
-      DCN(2,0) =    DCN(1,0) -   DCN(0,0);
-      DCN(0,0) = us*DCN(0,0) + u*DCN(1,0);
-      for(j=0; j<vorder-1; j++)
-      {
-	/* for the derivative in u */
-	DCN(2,j+1) =    DCN(1,j+1) -    DCN(0,j+1);
-	DCN(2,j)   = vs*DCN(2,j)    + v*DCN(2,j+1);
-	
-	/* for the `point' */
-	DCN(0,j+1) = us*DCN(0,j+1 ) + u*DCN(1,j+1);
-	DCN(0,j)   = vs*DCN(0,j)    + v*DCN(0,j+1);
-      }
-        
-      /* remaining linear de Casteljau steps until the second last step */
-      for(h=minorder; h<vorder-1; h++)
-	for(j=0; j<vorder-h; j++)
-	{
-	  /* for the derivative in u */
-	  DCN(2,j) = vs*DCN(2,j) + v*DCN(2,j+1);
-	  
-	  /* for the `point' */
-	  DCN(0,j) = vs*DCN(0,j) + v*DCN(0,j+1);
-	}
-      
-      /* derivative direction in v */
-      dv[k] = DCN(0,1) - DCN(0,0);
-      
-      /* derivative direction in u */
-      du[k] =   vs*DCN(2,0) + v*DCN(2,1);
-      
-      /* last linear de Casteljau step */
-      out[k] =  vs*DCN(0,0) + v*DCN(0,1);
-    }
-  }
-  else /* minorder == vorder */
-  {
-    for(k=0; k<dim; k++)
-    {
-      /* first bilinear de Casteljau step */
-      for(i=0; i<uorder-1; i++)
-      {
-	DCN(i,0) = us*CN(i,0,k) + u*CN(i+1,0,k);
-	for(j=0; j<vorder-1; j++)
-	{
-	  DCN(i,j+1) = us*CN(i,j+1,k) + u*CN(i+1,j+1,k);
-	  DCN(i,j)   = vs*DCN(i,j)    + v*DCN(i,j+1);
-	}
-      }
-
-      /* remaining bilinear de Casteljau steps until the second last step */
-      for(h=2; h<minorder-1; h++)
-	for(i=0; i<uorder-h; i++)
-	{
-	  DCN(i,0) = us*DCN(i,0) + u*DCN(i+1,0);
-	  for(j=0; j<vorder-h; j++)
-	  {
-	    DCN(i,j+1) = us*DCN(i,j+1) + u*DCN(i+1,j+1);
-	    DCN(i,j)   = vs*DCN(i,j)   + v*DCN(i,j+1);
-	  }
-	}
-
-      /* last bilinear de Casteljau step */
-      DCN(0,2) =    DCN(0,1) -   DCN(0,0);
-      DCN(0,0) = vs*DCN(0,0) + v*DCN(0,1);
-      for(i=0; i<uorder-1; i++)
-      {
-	/* for the derivative in v */
-	DCN(i+1,2) =    DCN(i+1,1)  -   DCN(i+1,0);
-	DCN(i,2)   = us*DCN(i,2)    + u*DCN(i+1,2);
-	
-	/* for the `point' */
-	DCN(i+1,0) = vs*DCN(i+1,0)  + v*DCN(i+1,1);
-	DCN(i,0)   = us*DCN(i,0)    + u*DCN(i+1,0);
-      }
-      
-      /* remaining linear de Casteljau steps until the second last step */
-      for(h=minorder; h<uorder-1; h++)
-	for(i=0; i<uorder-h; i++)
-	{
-	  /* for the derivative in v */
-	  DCN(i,2) = us*DCN(i,2) + u*DCN(i+1,2);
-	  
-	  /* for the `point' */
-	  DCN(i,0) = us*DCN(i,0) + u*DCN(i+1,0);
-	}
-      
-      /* derivative direction in u */
-      du[k] = DCN(1,0) - DCN(0,0);
-      
-      /* derivative direction in v */
-      dv[k] =   us*DCN(0,2) + u*DCN(1,2);
-      
-      /* last linear de Casteljau step */
-      out[k] =  us*DCN(0,0) + u*DCN(1,0);
-    }
-  }
-#undef DCN
-#undef CN
-}
-
 /*
  * Return the number of components per control point for any type of
  * evaluator.  Return 0 if bad target.
@@ -1982,656 +1512,6 @@ _mesa_GetMapiv( GLenum target, GLenum query, GLint *v )
 
 
 
-static void eval_points1( GLfloat outcoord[][4], 
-			  GLfloat coord[][4],
-			  const GLuint *flags,
-			  GLuint start,
-			  GLfloat du, GLfloat u1 )
-{
-   GLuint i;
-   for (i = start ; !(flags[i] & VERT_END_VB) ; i++)
-      if (flags[i] & VERT_EVAL_P1) 
-	 outcoord[i][0] = coord[i][0] * du + u1;
-      else if (flags[i] & VERT_EVAL_ANY) {
-	 outcoord[i][0] = coord[i][0];
-	 outcoord[i][1] = coord[i][1];
-      }
-}
-
-static void eval_points2( GLfloat outcoord[][4], 
-			  GLfloat coord[][4],
-			  const GLuint *flags,
-			  GLuint start,
-			  GLfloat du, GLfloat u1,
-			  GLfloat dv, GLfloat v1 )
-{
-   GLuint i;
-   for (i = start ; !(flags[i] & VERT_END_VB) ; i++)
-      if (flags[i] & VERT_EVAL_P2) {
-	 outcoord[i][0] = coord[i][0] * du + u1;
-	 outcoord[i][1] = coord[i][1] * dv + v1;
-      } else if (flags[i] & VERT_EVAL_ANY) {
-	 outcoord[i][0] = coord[i][0];
-	 outcoord[i][1] = coord[i][1];
-      }
-}
-
-
-static const GLubyte dirty_flags[5] = {
-   0,				/* not possible */
-   VEC_DIRTY_0,
-   VEC_DIRTY_1, 
-   VEC_DIRTY_2, 
-   VEC_DIRTY_3
-};
-
-
-static GLvector4f *eval1_4f( GLvector4f *dest, 
-			     GLfloat coord[][4], 
-			     const GLuint *flags,
-			     GLuint start,
-			     GLuint dimension,
-			     struct gl_1d_map *map )
-{
-   const GLfloat u1 = map->u1;
-   const GLfloat du = map->du;
-   GLfloat (*to)[4] = dest->data;
-   GLuint i;
-   
-   for (i = start ; !(flags[i] & VERT_END_VB) ; i++)
-      if (flags[i] & (VERT_EVAL_C1|VERT_EVAL_P1)) {
-	 GLfloat u = (coord[i][0] - u1) * du;
-	 ASSIGN_4V(to[i], 0,0,0,1);
-	 horner_bezier_curve(map->Points, to[i], u, dimension, map->Order);
-      }
-
-   dest->count = i;
-   dest->start = VEC_ELT(dest, GLfloat, start);
-   dest->size = MAX2(dest->size, dimension);
-   dest->flags |= dirty_flags[dimension];
-   return dest;
-}
-
-
-static GLvector1ui *eval1_1ui( GLvector1ui *dest, 
-			       GLfloat coord[][4], 
-			       const GLuint *flags,
-			       GLuint start,
-			       struct gl_1d_map *map )
-{
-   const GLfloat u1 = map->u1;
-   const GLfloat du = map->du;
-   GLuint *to = dest->data;
-   GLuint i;
-
-   for (i = start ; !(flags[i] & VERT_END_VB) ; i++)
-      if (flags[i] & (VERT_EVAL_C1|VERT_EVAL_P1)) {
-	 GLfloat u = (coord[i][0] - u1) * du;
-	 GLfloat tmp;
-	 horner_bezier_curve(map->Points, &tmp, u, 1, map->Order);
-	 to[i] = (GLuint) (GLint) tmp;
-      }
-
-   dest->start = VEC_ELT(dest, GLuint, start);
-   dest->count = i;
-   return dest;
-}
-
-static GLvector3f *eval1_norm( GLvector3f *dest, 
-			       GLfloat coord[][4],
-			       GLuint *flags, /* not const */
-			       GLuint start,
-			       struct gl_1d_map *map )
-{
-   const GLfloat u1 = map->u1;
-   const GLfloat du = map->du;
-   GLfloat (*to)[3] = dest->data;
-   GLuint i;
-
-   for (i = start ; !(flags[i] & VERT_END_VB) ; i++)
-      if (flags[i] & (VERT_EVAL_C1|VERT_EVAL_P1)) {
-	 GLfloat u = (coord[i][0] - u1) * du;
-	 horner_bezier_curve(map->Points, to[i], u, 3, map->Order);
-	 flags[i+1] |= VERT_NORM; /* reset */
-      }
-
-   dest->start = VEC_ELT(dest, GLfloat, start);
-   dest->count = i;
-   return dest;
-}
-
-static GLvector4ub *eval1_color( GLvector4ub *dest, 
-				 GLfloat coord[][4],
-				 GLuint *flags, /* not const */
-				 GLuint start,
-				 struct gl_1d_map *map )
-{   
-   const GLfloat u1 = map->u1;
-   const GLfloat du = map->du;
-   GLubyte (*to)[4] = dest->data;
-   GLuint i;
-
-   for (i = start ; !(flags[i] & VERT_END_VB) ; i++)
-      if (flags[i] & (VERT_EVAL_C1|VERT_EVAL_P1)) {
-	 GLfloat u = (coord[i][0] - u1) * du;
-	 GLfloat fcolor[4];
-	 horner_bezier_curve(map->Points, fcolor, u, 4, map->Order);
-	 FLOAT_RGBA_TO_CHAN_RGBA(to[i], fcolor);
-	 flags[i+1] |= VERT_RGBA; /* reset */
-      }
-
-   dest->start = VEC_ELT(dest, GLubyte, start);
-   dest->count = i;
-   return dest;
-}
-
-
-
-
-static GLvector4f *eval2_obj_norm( GLvector4f *obj_ptr, 
-				   GLvector3f *norm_ptr,
-				   GLfloat coord[][4], 
-				   GLuint *flags, 
-				   GLuint start,
-				   GLuint dimension,
-				   struct gl_2d_map *map )
-{
-   const GLfloat u1 = map->u1;
-   const GLfloat du = map->du;
-   const GLfloat v1 = map->v1;
-   const GLfloat dv = map->dv;
-   GLfloat (*obj)[4] = obj_ptr->data;
-   GLfloat (*normal)[3] = norm_ptr->data;
-   GLuint i;
-   
-   for (i = start ; !(flags[i] & VERT_END_VB) ; i++)
-      if (flags[i] & (VERT_EVAL_C2|VERT_EVAL_P2)) {
-	 GLfloat u = (coord[i][0] - u1) * du;
-	 GLfloat v = (coord[i][1] - v1) * dv;
-	 GLfloat du[4], dv[4];
-
-	 ASSIGN_4V(obj[i], 0,0,0,1);
-	 de_casteljau_surf(map->Points, obj[i], du, dv, u, v, dimension,
-			   map->Uorder, map->Vorder);
-	       
-	 CROSS3(normal[i], du, dv);
-	 NORMALIZE_3FV(normal[i]);
-	 flags[i+1] |= VERT_NORM;
-      }
- 
-   obj_ptr->start = VEC_ELT(obj_ptr, GLfloat, start);
-   obj_ptr->count = i;
-   obj_ptr->size = MAX2(obj_ptr->size, dimension);
-   obj_ptr->flags |= dirty_flags[dimension];
-   return obj_ptr;
-}
-
-
-static GLvector4f *eval2_4f( GLvector4f *dest, 
-			     GLfloat coord[][4], 
-			     const GLuint *flags,
-			     GLuint start,
-			     GLuint dimension,
-			     struct gl_2d_map *map )
-{
-   const GLfloat u1 = map->u1;
-   const GLfloat du = map->du;
-   const GLfloat v1 = map->v1;
-   const GLfloat dv = map->dv;
-   GLfloat (*to)[4] = dest->data;
-   GLuint i;
-
-   for (i = start ; !(flags[i] & VERT_END_VB) ; i++)
-      if (flags[i] & (VERT_EVAL_C2|VERT_EVAL_P2)) {
-	 GLfloat u = (coord[i][0] - u1) * du;
-	 GLfloat v = (coord[i][1] - v1) * dv;
-	 horner_bezier_surf(map->Points, to[i], u, v, dimension,
-			    map->Uorder, map->Vorder);
-      }
-
-   dest->start = VEC_ELT(dest, GLfloat, start);
-   dest->count = i;
-   dest->size = MAX2(dest->size, dimension);
-   dest->flags |= dirty_flags[dimension];
-   return dest;
-}
-
-
-static GLvector3f *eval2_norm( GLvector3f *dest, 
-			       GLfloat coord[][4], 
-			       GLuint *flags, 
-			       GLuint start,
-			       struct gl_2d_map *map )
-{
-   const GLfloat u1 = map->u1;
-   const GLfloat du = map->du;
-   const GLfloat v1 = map->v1;
-   const GLfloat dv = map->dv;
-   GLfloat (*to)[3] = dest->data;
-   GLuint i;
-
-   for (i = start ; !(flags[i] & VERT_END_VB) ; i++)
-      if (flags[i] & (VERT_EVAL_C2|VERT_EVAL_P2)) {
-	 GLfloat u = (coord[i][0] - u1) * du;
-	 GLfloat v = (coord[i][1] - v1) * dv;
-	 horner_bezier_surf(map->Points, to[i], u, v, 3,
-			    map->Uorder, map->Vorder);
- 	 flags[i+1] |= VERT_NORM; /* reset */
-     }
-
-   dest->start = VEC_ELT(dest, GLfloat, start);
-   dest->count = i;
-   return dest;
-}
-
-
-static GLvector1ui *eval2_1ui( GLvector1ui *dest, 
-			       GLfloat coord[][4], 
-			       const GLuint *flags,
-			       GLuint start,
-			       struct gl_2d_map *map )
-{
-   const GLfloat u1 = map->u1;
-   const GLfloat du = map->du;
-   const GLfloat v1 = map->v1;
-   const GLfloat dv = map->dv;
-   GLuint *to = dest->data;
-   GLuint i;
-
-   for (i = start ; !(flags[i] & VERT_END_VB) ; i++)
-      if (flags[i] & (VERT_EVAL_C2|VERT_EVAL_P2)) {
-	 GLfloat u = (coord[i][0] - u1) * du;
-	 GLfloat v = (coord[i][1] - v1) * dv;
-	 GLfloat tmp;
-	 horner_bezier_surf(map->Points, &tmp, u, v, 1,
-			    map->Uorder, map->Vorder);
-
-	 to[i] = (GLuint) (GLint) tmp;
-      }
-
-   dest->start = VEC_ELT(dest, GLuint, start);
-   dest->count = i;
-   return dest;
-}
-
-
-
-static GLvector4ub *eval2_color( GLvector4ub *dest,
-				 GLfloat coord[][4], 
-				 GLuint *flags,
-				 GLuint start,
-				 struct gl_2d_map *map )
-{
-   const GLfloat u1 = map->u1;
-   const GLfloat du = map->du;
-   const GLfloat v1 = map->v1;
-   const GLfloat dv = map->dv;
-   GLubyte (*to)[4] = dest->data;
-   GLuint i;
-
-   for (i = start ; !(flags[i] & VERT_END_VB) ; i++)
-      if (flags[i] & (VERT_EVAL_C2|VERT_EVAL_P2)) {
-	 GLfloat u = (coord[i][0] - u1) * du;
-	 GLfloat v = (coord[i][1] - v1) * dv;
-	 GLfloat fcolor[4];
-	 horner_bezier_surf(map->Points, fcolor, u, v, 4,
-			    map->Uorder, map->Vorder);
-	 FLOAT_RGBA_TO_CHAN_RGBA(to[i], fcolor);
-	 flags[i+1] |= VERT_RGBA; /* reset */
-      }
-
-   dest->start = VEC_ELT(dest, GLubyte, start);
-   dest->count = i;
-   return dest;
-}
-
-
-static GLvector4f *copy_4f( GLvector4f *out, CONST GLvector4f *in, 
-			    const GLuint *flags,
-			    GLuint start )
-{
-   GLfloat (*to)[4] = out->data;
-   GLfloat (*from)[4] = in->data;
-   GLuint i;
-   
-   for ( i = start ; !(flags[i] & VERT_END_VB) ; i++) 
-      if (!(flags[i] & VERT_EVAL_ANY)) 
-	 COPY_4FV( to[i], from[i] );
-   
-   out->start = VEC_ELT(out, GLfloat, start);
-   return out;
-}
-
-static GLvector3f *copy_3f( GLvector3f *out, CONST GLvector3f *in, 
-			    const GLuint *flags,
-			    GLuint start )
-{
-   GLfloat (*to)[3] = out->data;
-   GLfloat (*from)[3] = in->data;
-   GLuint i;
-   
-   for ( i = start ; !(flags[i] & VERT_END_VB) ; i++) 
-      if (!(flags[i] & VERT_EVAL_ANY)) 
-	 COPY_3V( to[i], from[i] );
-   
-   out->start = VEC_ELT(out, GLfloat, start);
-   return out;
-}
-
-static GLvector4ub *copy_4ub( GLvector4ub *out, 
-			      CONST GLvector4ub *in, 
-			      const GLuint *flags,
-			      GLuint start )
-{
-   GLubyte (*to)[4] = out->data;
-   GLubyte (*from)[4] = in->data;
-   GLuint i;
-   
-   for ( i = start ; !(flags[i] & VERT_END_VB) ; i++) 
-      if (!(flags[i] & VERT_EVAL_ANY)) 
-	 COPY_4UBV( to[i], from[i] );
-
-   out->start = VEC_ELT(out, GLubyte, start);
-   return out;
-}
-
-static GLvector1ui *copy_1ui( GLvector1ui *out, 
-			      CONST GLvector1ui *in, 
-			      const GLuint *flags,
-			      GLuint start )
-{
-   GLuint *to = out->data;
-   CONST GLuint *from = in->data;
-   GLuint i;
-   
-   for ( i = start ; !(flags[i] & VERT_END_VB) ; i++) 
-      if (!(flags[i] & VERT_EVAL_ANY)) 
-	 to[i] = from[i];
-
-   out->start = VEC_ELT(out, GLuint, start);
-   return out;
-}
-
-
-/* KW: Rewrote this to perform eval on a whole buffer at once.
- *     Only evaluates active data items, and avoids scribbling
- *     the source buffer if we are running from a display list.
- *
- *     If the user (in this case looser) sends eval coordinates
- *     or runs a display list containing eval coords with no
- *     vertex maps enabled, we have to either copy all non-eval
- *     data to a new buffer, or find a way of working around
- *     the eval data.  I choose the second option.
- *
- * KW: This code not reached by cva - use IM to access storage.
- */
-void gl_eval_vb( struct vertex_buffer *VB )
-{
-   struct immediate *IM = VB->IM;
-   GLcontext *ctx = VB->ctx;
-   GLuint req = ctx->CVA.elt.inputs;
-   GLfloat (*coord)[4] = VB->ObjPtr->data;
-   GLuint *flags = VB->Flag;
-   GLuint new_flags = 0;
-   
-
-   GLuint any_eval1 = VB->OrFlag & (VERT_EVAL_C1|VERT_EVAL_P1);
-   GLuint any_eval2 = VB->OrFlag & (VERT_EVAL_C2|VERT_EVAL_P2);
-   GLuint all_eval = IM->AndFlag & VERT_EVAL_ANY;
-
-   /* Handle the degenerate cases.
-    */
-   if (any_eval1 && !ctx->Eval.Map1Vertex4 && !ctx->Eval.Map1Vertex3) {
-      VB->PurgeFlags |= (VERT_EVAL_C1|VERT_EVAL_P1);
-      VB->EarlyCull = 0;
-      any_eval1 = GL_FALSE;
-   }
-  
-   if (any_eval2 && !ctx->Eval.Map2Vertex4 && !ctx->Eval.Map2Vertex3) {
-      VB->PurgeFlags |= (VERT_EVAL_C2|VERT_EVAL_P2);
-      VB->EarlyCull = 0;
-      any_eval2 = GL_FALSE;
-   }
-
-   /* KW: This really is a degenerate case - doing this disables
-    * culling, and causes dummy values for the missing vertices to be
-    * transformed and clip tested.  It also forces the individual
-    * cliptesting of each primitive in vb_render.  I wish there was a
-    * nice alternative, but I can't say I want to put effort into
-    * optimizing such a bad usage of the library - I'd much rather
-    * work on useful changes.
-    */
-   if (VB->PurgeFlags) {
-      if (!any_eval1 && !any_eval2 && all_eval) VB->Count = VB->Start;
-      gl_purge_vertices( VB );
-      if (!any_eval1 && !any_eval2) return;
-   } else
-      VB->IndirectCount = VB->Count;
-
-   /* Translate points into coords.
-    */
-   if (any_eval1 && (VB->OrFlag & VERT_EVAL_P1)) 
-   {
-      eval_points1( IM->Obj, coord, flags, IM->Start,
-		    ctx->Eval.MapGrid1du,
-		    ctx->Eval.MapGrid1u1);
-
-      coord = IM->Obj;
-   }
-
-   if (any_eval2 && (VB->OrFlag & VERT_EVAL_P2)) 
-   {
-      eval_points2( IM->Obj, coord, flags, IM->Start,
-		    ctx->Eval.MapGrid2du,
-		    ctx->Eval.MapGrid2u1,
-		    ctx->Eval.MapGrid2dv,
-		    ctx->Eval.MapGrid2v1 );
-
-      coord = IM->Obj;
-   }
-
-   /* Perform the evaluations on active data elements.
-    */
-   if (req & VERT_INDEX) 
-   {
-      GLvector1ui  *in_index = VB->IndexPtr;
-      GLvector1ui  *out_index = &IM->v.Index;
-
-      if (ctx->Eval.Map1Index && any_eval1) 
-	 VB->IndexPtr = eval1_1ui( out_index, coord, flags, IM->Start,
-				   &ctx->EvalMap.Map1Index );
-      
-      if (ctx->Eval.Map2Index && any_eval2)
-	 VB->IndexPtr = eval2_1ui( out_index, coord, flags, IM->Start,
-				   &ctx->EvalMap.Map2Index );
-	 
-      if (VB->IndexPtr != in_index) {
-	 new_flags |= VERT_INDEX;
-	 if (!all_eval)
-	    VB->IndexPtr = copy_1ui( out_index, in_index, flags, IM->Start );
-      }
-   }
-
-   if (req & VERT_RGBA) 
-   {   
-      GLvector4ub  *in_color = VB->ColorPtr;
-      GLvector4ub  *out_color = &IM->v.Color;
-
-      if (ctx->Eval.Map1Color4 && any_eval1) 
-	 VB->ColorPtr = eval1_color( out_color, coord, flags, IM->Start,
-				     &ctx->EvalMap.Map1Color4 );
-      
-      if (ctx->Eval.Map2Color4 && any_eval2)
-	 VB->ColorPtr = eval2_color( out_color, coord, flags, IM->Start,
-				     &ctx->EvalMap.Map2Color4 );
-	 
-      if (VB->ColorPtr != in_color) {
-	 new_flags |= VERT_RGBA;
-	 if (!all_eval)
-	    VB->ColorPtr = copy_4ub( out_color, in_color, flags, IM->Start );
-      }
-
-      VB->Color[0] = VB->Color[1] = VB->ColorPtr;
-   }
-
-
-   if (req & VERT_NORM) 
-   {   
-      GLvector3f  *in_normal = VB->NormalPtr;
-      GLvector3f  *out_normal = &IM->v.Normal;
-
-      if (ctx->Eval.Map1Normal && any_eval1) 
-	 VB->NormalPtr = eval1_norm( out_normal, coord, flags, IM->Start,
-				     &ctx->EvalMap.Map1Normal );
-      
-      if (ctx->Eval.Map2Normal && any_eval2)
-	 VB->NormalPtr = eval2_norm( out_normal, coord, flags, IM->Start,
-				     &ctx->EvalMap.Map2Normal );
-	 
-      new_flags |= VERT_NORM;
-
-      if (VB->NormalPtr != in_normal) {
-	 if (!all_eval)
-	    VB->NormalPtr = copy_3f( out_normal, in_normal, flags, IM->Start );
-      }
-   }
-
-     
-   if (req & VERT_TEX_ANY(0)) 
-   {
-      GLvector4f *tc = VB->TexCoordPtr[0];
-      GLvector4f *in = tc;
-      GLvector4f *out = &IM->v.TexCoord[0];
-
-      if (any_eval1) {
-	 if (ctx->Eval.Map1TextureCoord4) 
-	    tc = eval1_4f( out, coord, flags, IM->Start, 
-			   4, &ctx->EvalMap.Map1Texture4);
-	 else if (ctx->Eval.Map1TextureCoord3) 
-	    tc = eval1_4f( out, coord, flags, IM->Start, 3,
-			   &ctx->EvalMap.Map1Texture3);
-	 else if (ctx->Eval.Map1TextureCoord2) 
-	    tc = eval1_4f( out, coord, flags, IM->Start, 2,
-			   &ctx->EvalMap.Map1Texture2);
-	 else if (ctx->Eval.Map1TextureCoord1) 
-	    tc = eval1_4f( out, coord, flags, IM->Start, 1,
-			   &ctx->EvalMap.Map1Texture1);
-      }
-
-      if (any_eval2) {
-	 if (ctx->Eval.Map2TextureCoord4) 
-	    tc = eval2_4f( out, coord, flags, IM->Start,
-			   4, &ctx->EvalMap.Map2Texture4);
-	 else if (ctx->Eval.Map2TextureCoord3) 
-	    tc = eval2_4f( out, coord, flags, IM->Start,
-			   3, &ctx->EvalMap.Map2Texture3);
-	 else if (ctx->Eval.Map2TextureCoord2) 
-	    tc = eval2_4f( out, coord, flags, IM->Start,
-			   2, &ctx->EvalMap.Map2Texture2);
-	 else if (ctx->Eval.Map2TextureCoord1) 
-	    tc = eval2_4f( out, coord, flags, IM->Start,
-			   1, &ctx->EvalMap.Map2Texture1);
-      }
-
-      if (tc != in) {
-	 new_flags |= VERT_TEX_ANY(0); /* fix for sizes.. */
-	 if (!all_eval)
-	    tc = copy_4f( out, in, flags, IM->Start );
-      }
-
-      VB->TexCoordPtr[0] = tc;
-   }
-
-
-   {
-      GLvector4f *in = VB->ObjPtr;
-      GLvector4f *out = &IM->v.Obj;
-      GLvector4f *obj = in;
-   
-      if (any_eval1) {
-	 if (ctx->Eval.Map1Vertex4) 
-	    obj = eval1_4f( out, coord, flags, IM->Start,
-			    4, &ctx->EvalMap.Map1Vertex4);
-	 else 
-	    obj = eval1_4f( out, coord, flags, IM->Start,
-			    3, &ctx->EvalMap.Map1Vertex3);
-      }
-
-      if (any_eval2) {
-	 GLvector3f  *in_normal = VB->NormalPtr;
-	 GLvector3f  *out_normal = &IM->v.Normal;
-
-	 if (ctx->Eval.Map2Vertex4) 
-	 {
-	    if (ctx->Eval.AutoNormal && (req & VERT_NORM)) {
-	       obj = eval2_obj_norm( out, out_normal, coord, flags, 
-				     IM->Start, 4, &ctx->EvalMap.Map2Vertex4 );
-	       VB->NormalPtr = out_normal;
-	       new_flags |= VERT_NORM;
-	    }
-	    else
-	       obj = eval2_4f( out, coord, flags, IM->Start,
-			       4, &ctx->EvalMap.Map2Vertex4 );
-	 }
-	 else if (ctx->Eval.Map2Vertex3) 
-	 {
-	    if (ctx->Eval.AutoNormal && (req & VERT_NORM)) {
-	       obj = eval2_obj_norm( out, out_normal, coord, flags, 
-				     IM->Start, 3, &ctx->EvalMap.Map2Vertex3 );
-	       VB->NormalPtr = out_normal;
-	       new_flags |= VERT_NORM;
-	    }
-	    else
-	       obj = eval2_4f( out, coord, flags, IM->Start,
-			       3, &ctx->EvalMap.Map2Vertex3 );
-	 }
-
-
-	 if (VB->NormalPtr != in_normal) {
-	    if (!all_eval)
-	       VB->NormalPtr = copy_3f( out_normal, in_normal, flags, 
-					IM->Start );
-	 }
-      }
-      
-      if (obj != in && !all_eval)
-	 obj = copy_4f( out, in, flags, IM->Start );
-
-      VB->ObjPtr = obj;
-   }
-
-   if (new_flags) {
-      GLuint *oldflags = VB->Flag;
-      GLuint *flags = VB->Flag = VB->EvaluatedFlags;
-      GLuint i;
-      GLuint count = VB->Count;
-      GLuint andflag = VB->IM->AndFlag;
-
-      if (!flags) {
-	 VB->EvaluatedFlags = (GLuint *) MALLOC(VB->Size * sizeof(GLuint));
-	 flags = VB->Flag = VB->EvaluatedFlags;
-      }
-
-      if (all_eval) {
-	 for (i = 0 ; i <= count ; i++) 
-	    flags[i] = oldflags[i] | new_flags;
-	 andflag |= new_flags;
-      } else {
-	 andflag = ~0;
-	 for (i = 0 ; i <= count ; i++) {
-	    flags[i] = oldflags[i];
-	    if (flags[i] & VERT_EVAL_ANY) 
-	       flags[i] |= new_flags;
-	    andflag &= flags[i];
-	 }
-      }
-
-      VB->OrFlag |= new_flags;
-      VB->CullMode = (GLubyte) ((andflag & VERT_NORM) ? 0 : COMPACTED_NORMALS);
-   }
-}
-
-
 void
 _mesa_MapGrid1f( GLint un, GLfloat u1, GLfloat u2 )
 {
@@ -2694,279 +1574,4 @@ _mesa_MapGrid2d( GLint un, GLdouble u1, GLdouble u2,
 
 
 
-/* KW: If are compiling, we don't know whether eval will produce a
- *     vertex when it is run in the future.  If this is pure immediate
- *     mode, eval is a noop if neither vertex map is enabled.
- *
- *     Thus we need to have a check in the display list code or
- *     elsewhere for eval(1,2) vertices in the case where
- *     map(1,2)_vertex is disabled, and to purge those vertices from
- *     the vb.  This is currently done
- *     via  modifications to the cull_vb and render_vb operations, and
- *     by using the existing cullmask mechanism for all other operations.  
- */
-
-
-/* KW: Because the eval values don't become 'current', fixup will flow
- *     through these vertices, and then evaluation will write on top
- *     of the fixup results.  
- *
- *     This is a little inefficient, but at least it is correct.  This
- *     could be short-circuited in the case where all vertices are
- *     eval-vertices, or more generally by a cullmask in fixup.
- *
- *     Note: using Obj to hold eval coord data.  This data is actually
- *     transformed if eval is disabled.  But disabling eval & sending
- *     eval coords is stupid, right?
- */
-
-
-#define EVALCOORD1(IM, x)				\
-{							\
-   GLuint count = IM->Count++;				\
-   IM->Flag[count] |= VERT_EVAL_C1;			\
-   ASSIGN_4V(IM->Obj[count], x, 0, 0, 1);		\
-   if (count == VB_MAX-1)				\
-      _mesa_maybe_transform_vb( IM );			\
-}
-
-#define EVALCOORD2(IM, x, y)				\
-{							\
-   GLuint count = IM->Count++;				\
-   IM->Flag[count] |= VERT_EVAL_C2;			\
-   ASSIGN_4V(IM->Obj[count], x, y, 0, 1);		\
-   if (count == VB_MAX-1)				\
-      _mesa_maybe_transform_vb( IM );			\
-}
-
-#define EVALPOINT1(IM, x)				\
-{							\
-   GLuint count = IM->Count++;				\
-   IM->Flag[count] |= VERT_EVAL_P1;			\
-   ASSIGN_4V(IM->Obj[count], x, 0, 0, 1);		\
-   if (count == VB_MAX-1)				\
-      _mesa_maybe_transform_vb( IM );			\
-}
- 
-#define EVALPOINT2(IM, x, y)				\
-{							\
-   GLuint count = IM->Count++;				\
-   IM->Flag[count] |= VERT_EVAL_P2;			\
-   ASSIGN_4V(IM->Obj[count], x, y, 0, 1);		\
-   if (count == VB_MAX-1)				\
-      _mesa_maybe_transform_vb( IM );			\
-}
-
-
-/* Lame internal function:
- */
-static void
-eval_coord1f( GLcontext *CC, GLfloat u )
-{
-   struct immediate *i = CC->input;
-   EVALCOORD1( i, u );
-}
-
-
-void
-_mesa_EvalCoord1d( GLdouble u )
-{
-   GET_IMMEDIATE;
-   EVALCOORD1( IM, (GLfloat) u );
-}
-
-
-void
-_mesa_EvalCoord1f( GLfloat u )
-{
-   GET_IMMEDIATE;
-   EVALCOORD1( IM, u );
-}
-
-
-void
-_mesa_EvalCoord1dv( const GLdouble *u )
-{
-   GET_IMMEDIATE;
-   EVALCOORD1( IM, (GLfloat) *u );
-}
-
-
-void
-_mesa_EvalCoord1fv( const GLfloat *u )
-{
-   GET_IMMEDIATE;
-   EVALCOORD1( IM, (GLfloat) *u );
-}
-
-
-void
-_mesa_EvalCoord2d( GLdouble u, GLdouble v )
-{
-   GET_IMMEDIATE;
-   EVALCOORD2( IM, (GLfloat) u, (GLfloat) v );
-}
-
-
-void
-_mesa_EvalCoord2f( GLfloat u, GLfloat v )
-{
-   GET_IMMEDIATE;
-   EVALCOORD2( IM, u, v );
-}
-
-
-/* Lame internal function:
- */
-static void
-eval_coord2f( GLcontext *CC, GLfloat u, GLfloat v )
-{
-   struct immediate *i = CC->input;
-   EVALCOORD2( i, u, v );
-}
-
-
-void
-_mesa_EvalCoord2dv( const GLdouble *u )
-{
-   GET_IMMEDIATE;
-   EVALCOORD2( IM, (GLfloat) u[0], (GLfloat) u[1] );
-}
-
-
-void
-_mesa_EvalCoord2fv( const GLfloat *u )
-{
-   GET_IMMEDIATE;
-   EVALCOORD2( IM, u[0], u[1] );
-}
-
-
-void
-_mesa_EvalPoint1( GLint i )
-{
-   GET_IMMEDIATE;
-   EVALPOINT1( IM, i );
-}
-
-
-void
-_mesa_EvalPoint2( GLint i, GLint j )
-{
-   GET_IMMEDIATE;
-   EVALPOINT2( IM, i, j );
-}
-
-
-
-
-void
-_mesa_EvalMesh1( GLenum mode, GLint i1, GLint i2 )
-{
-   GET_CURRENT_CONTEXT(ctx);
-   GLint i;
-   GLfloat u, du;
-   GLenum prim;
-
-   ASSERT_OUTSIDE_BEGIN_END_AND_FLUSH(ctx, "glEvalMesh1");
-
-   switch (mode) {
-      case GL_POINT:
-         prim = GL_POINTS;
-         break;
-      case GL_LINE:
-         prim = GL_LINE_STRIP;
-         break;
-      default:
-         gl_error( ctx, GL_INVALID_ENUM, "glEvalMesh1(mode)" );
-         return;
-   }
-
-   /* No effect if vertex maps disabled.
-    */
-   if (!ctx->Eval.Map1Vertex4 && !ctx->Eval.Map1Vertex3) 
-      return;
-
-   du = ctx->Eval.MapGrid1du;
-   u = ctx->Eval.MapGrid1u1 + i1 * du;
-
-   /* KW: Could short-circuit this to avoid the immediate mechanism.
-    */
-   RESET_IMMEDIATE(ctx);
-
-   gl_Begin( ctx, prim );
-   for (i=i1;i<=i2;i++,u+=du) {
-      eval_coord1f( ctx, u );
-   }
-   gl_End(ctx);
-}
-
-
-
-void
-_mesa_EvalMesh2( GLenum mode, GLint i1, GLint i2, GLint j1, GLint j2 )
-{
-   GET_CURRENT_CONTEXT(ctx);
-   GLint i, j;
-   GLfloat u, du, v, dv, v1, u1;
-
-   ASSERT_OUTSIDE_BEGIN_END_AND_FLUSH(ctx, "glEvalMesh2");
-
-   /* No effect if vertex maps disabled.
-    */
-   if (!ctx->Eval.Map2Vertex4 && !ctx->Eval.Map2Vertex3) 
-      return;
-
-   du = ctx->Eval.MapGrid2du;
-   dv = ctx->Eval.MapGrid2dv;
-   v1 = ctx->Eval.MapGrid2v1 + j1 * dv;
-   u1 = ctx->Eval.MapGrid2u1 + i1 * du;
-
-   RESET_IMMEDIATE(ctx);
-
-   switch (mode) {
-   case GL_POINT:
-      gl_Begin( ctx, GL_POINTS );
-      for (v=v1,j=j1;j<=j2;j++,v+=dv) {
-	 for (u=u1,i=i1;i<=i2;i++,u+=du) {
-	    eval_coord2f( ctx, u, v );
-	 }
-      }
-      gl_End(ctx);
-      break;
-   case GL_LINE:
-      for (v=v1,j=j1;j<=j2;j++,v+=dv) {
-	 gl_Begin( ctx, GL_LINE_STRIP );
-	 for (u=u1,i=i1;i<=i2;i++,u+=du) {
-	    eval_coord2f( ctx, u, v );
-	 }
-	 gl_End(ctx);
-      }
-      for (u=u1,i=i1;i<=i2;i++,u+=du) {
-	 gl_Begin( ctx, GL_LINE_STRIP );
-	 for (v=v1,j=j1;j<=j2;j++,v+=dv) {
-	    eval_coord2f( ctx, u, v );
-	 }
-	 gl_End(ctx);
-      }
-      break;
-   case GL_FILL:
-      for (v=v1,j=j1;j<j2;j++,v+=dv) {
-	 /* NOTE: a quad strip can't be used because the four */
-	 /* can't be guaranteed to be coplanar! */
-	 gl_Begin( ctx, GL_TRIANGLE_STRIP );
-	 for (u=u1,i=i1;i<=i2;i++,u+=du) {
-	    eval_coord2f( ctx, u, v );
-	    eval_coord2f( ctx, u, v+dv );
-	 }
-	 gl_End(ctx);
-      }
-      break;
-   default:
-      gl_error( ctx, GL_INVALID_ENUM, "glEvalMesh2(mode)" );
-      return;
-   }
-}
-
-