vbo: run 'indent' on vbo_save_api.c

1 files changed, 456 insertions, 362 deletions

diff --git a/src/mesa/vbo/vbo_save_api.c b/src/mesa/vbo/vbo_save_api.c
index dd6e89942f2..9041f791edd 100644
--- a/src/mesa/vbo/vbo_save_api.c
+++ b/src/mesa/vbo/vbo_save_api.c
@@ -100,12 +100,13 @@ USE OR OTHER DEALINGS IN THE SOFTWARE.
  * NOTE: Old 'parity' issue is gone, but copying can still be
  * wrong-footed on replay.
  */
-static GLuint _save_copy_vertices( struct gl_context *ctx, 
-				   const struct vbo_save_vertex_list *node,
-				   const GLfloat *src_buffer)
+static GLuint
+_save_copy_vertices(struct gl_context *ctx,
+                    const struct vbo_save_vertex_list *node,
+                    const GLfloat * src_buffer)
 {
-   struct vbo_save_context *save = &vbo_context( ctx )->save;
-   const struct _mesa_prim *prim = &node->prim[node->prim_count-1];
+   struct vbo_save_context *save = &vbo_context(ctx)->save;
+   const struct _mesa_prim *prim = &node->prim[node->prim_count - 1];
    GLuint nr = prim->count;
    GLuint sz = save->vertex_size;
    const GLfloat *src = src_buffer + prim->start * sz;
@@ -114,55 +115,65 @@ static GLuint _save_copy_vertices( struct gl_context *ctx,
 
    if (prim->end)
       return 0;
-	 
-   switch( prim->mode )
-   {
+
+   switch (prim->mode) {
    case GL_POINTS:
       return 0;
    case GL_LINES:
-      ovf = nr&1;
-      for (i = 0 ; i < ovf ; i++)
-	 memcpy( dst+i*sz, src+(nr-ovf+i)*sz, sz*sizeof(GLfloat) );
+      ovf = nr & 1;
+      for (i = 0; i < ovf; i++)
+         memcpy(dst + i * sz, src + (nr - ovf + i) * sz,
+                sz * sizeof(GLfloat));
       return i;
    case GL_TRIANGLES:
-      ovf = nr%3;
-      for (i = 0 ; i < ovf ; i++)
-	 memcpy( dst+i*sz, src+(nr-ovf+i)*sz, sz*sizeof(GLfloat) );
+      ovf = nr % 3;
+      for (i = 0; i < ovf; i++)
+         memcpy(dst + i * sz, src + (nr - ovf + i) * sz,
+                sz * sizeof(GLfloat));
       return i;
    case GL_QUADS:
-      ovf = nr&3;
-      for (i = 0 ; i < ovf ; i++)
-	 memcpy( dst+i*sz, src+(nr-ovf+i)*sz, sz*sizeof(GLfloat) );
+      ovf = nr & 3;
+      for (i = 0; i < ovf; i++)
+         memcpy(dst + i * sz, src + (nr - ovf + i) * sz,
+                sz * sizeof(GLfloat));
       return i;
    case GL_LINE_STRIP:
-      if (nr == 0) 
-	 return 0;
+      if (nr == 0)
+         return 0;
       else {
-	 memcpy( dst, src+(nr-1)*sz, sz*sizeof(GLfloat) );
-	 return 1;
+         memcpy(dst, src + (nr - 1) * sz, sz * sizeof(GLfloat));
+         return 1;
       }
    case GL_LINE_LOOP:
    case GL_TRIANGLE_FAN:
    case GL_POLYGON:
-      if (nr == 0) 
-	 return 0;
+      if (nr == 0)
+         return 0;
       else if (nr == 1) {
-	 memcpy( dst, src+0, sz*sizeof(GLfloat) );
-	 return 1;
-      } else {
-	 memcpy( dst, src+0, sz*sizeof(GLfloat) );
-	 memcpy( dst+sz, src+(nr-1)*sz, sz*sizeof(GLfloat) );
-	 return 2;
+         memcpy(dst, src + 0, sz * sizeof(GLfloat));
+         return 1;
+      }
+      else {
+         memcpy(dst, src + 0, sz * sizeof(GLfloat));
+         memcpy(dst + sz, src + (nr - 1) * sz, sz * sizeof(GLfloat));
+         return 2;
       }
    case GL_TRIANGLE_STRIP:
    case GL_QUAD_STRIP:
       switch (nr) {
-      case 0: ovf = 0; break;
-      case 1: ovf = 1; break;
-      default: ovf = 2 + (nr&1); break;
+      case 0:
+         ovf = 0;
+         break;
+      case 1:
+         ovf = 1;
+         break;
+      default:
+         ovf = 2 + (nr & 1);
+         break;
       }
-      for (i = 0 ; i < ovf ; i++)
-	 memcpy( dst+i*sz, src+(nr-ovf+i)*sz, sz*sizeof(GLfloat) );
+      for (i = 0; i < ovf; i++)
+         memcpy(dst + i * sz, src + (nr - ovf + i) * sz,
+                sz * sizeof(GLfloat));
       return i;
    default:
       assert(0);
@@ -171,9 +182,11 @@ static GLuint _save_copy_vertices( struct gl_context *ctx,
 }
 
 
-static struct vbo_save_vertex_store *alloc_vertex_store( struct gl_context *ctx )
+static struct vbo_save_vertex_store *
+alloc_vertex_store(struct gl_context *ctx)
 {
-   struct vbo_save_vertex_store *vertex_store = CALLOC_STRUCT(vbo_save_vertex_store);
+   struct vbo_save_vertex_store *vertex_store =
+      CALLOC_STRUCT(vbo_save_vertex_store);
 
    /* obj->Name needs to be non-zero, but won't ever be examined more
     * closely than that.  In particular these buffers won't be entered
@@ -185,12 +198,10 @@ static struct vbo_save_vertex_store *alloc_vertex_store( struct gl_context *ctx
                                                          VBO_BUF_ID,
                                                          GL_ARRAY_BUFFER_ARB);
 
-   ctx->Driver.BufferData( ctx, 
-			   GL_ARRAY_BUFFER_ARB, 
-			   VBO_SAVE_BUFFER_SIZE * sizeof(GLfloat),
-			   NULL,
-			   GL_STATIC_DRAW_ARB,
-			   vertex_store->bufferobj);
+   ctx->Driver.BufferData(ctx,
+                          GL_ARRAY_BUFFER_ARB,
+                          VBO_SAVE_BUFFER_SIZE * sizeof(GLfloat),
+                          NULL, GL_STATIC_DRAW_ARB, vertex_store->bufferobj);
 
    vertex_store->buffer = NULL;
    vertex_store->used = 0;
@@ -199,7 +210,10 @@ static struct vbo_save_vertex_store *alloc_vertex_store( struct gl_context *ctx
    return vertex_store;
 }
 
-static void free_vertex_store( struct gl_context *ctx, struct vbo_save_vertex_store *vertex_store )
+
+static void
+free_vertex_store(struct gl_context *ctx,
+                  struct vbo_save_vertex_store *vertex_store)
 {
    assert(!vertex_store->buffer);
 
@@ -207,51 +221,62 @@ static void free_vertex_store( struct gl_context *ctx, struct vbo_save_vertex_st
       _mesa_reference_buffer_object(ctx, &vertex_store->bufferobj, NULL);
    }
 
-   FREE( vertex_store );
+   FREE(vertex_store);
 }
 
-static GLfloat *map_vertex_store( struct gl_context *ctx, struct vbo_save_vertex_store *vertex_store )
+
+static GLfloat *
+map_vertex_store(struct gl_context *ctx,
+                 struct vbo_save_vertex_store *vertex_store)
 {
    assert(vertex_store->bufferobj);
    assert(!vertex_store->buffer);
-   vertex_store->buffer = (GLfloat *)ctx->Driver.MapBuffer(ctx, 
-							   GL_ARRAY_BUFFER_ARB,	/* not used */
-							   GL_WRITE_ONLY, /* not used */
-							   vertex_store->bufferobj); 
+   vertex_store->buffer =
+      (GLfloat *) ctx->Driver.MapBuffer(ctx,
+                                        GL_ARRAY_BUFFER_ARB,   /* not used */
+                                        GL_WRITE_ONLY,      /* not used */
+                                        vertex_store->
+                                        bufferobj);
 
    assert(vertex_store->buffer);
    return vertex_store->buffer + vertex_store->used;
 }
 
-static void unmap_vertex_store( struct gl_context *ctx, struct vbo_save_vertex_store *vertex_store )
+
+static void
+unmap_vertex_store(struct gl_context *ctx,
+                   struct vbo_save_vertex_store *vertex_store)
 {
-   ctx->Driver.UnmapBuffer( ctx, GL_ARRAY_BUFFER_ARB, vertex_store->bufferobj );
+   ctx->Driver.UnmapBuffer(ctx, GL_ARRAY_BUFFER_ARB, vertex_store->bufferobj);
    vertex_store->buffer = NULL;
 }
 
 
-static struct vbo_save_primitive_store *alloc_prim_store( struct gl_context *ctx )
+static struct vbo_save_primitive_store *
+alloc_prim_store(struct gl_context *ctx)
 {
-   struct vbo_save_primitive_store *store = CALLOC_STRUCT(vbo_save_primitive_store);
+   struct vbo_save_primitive_store *store =
+      CALLOC_STRUCT(vbo_save_primitive_store);
    (void) ctx;
    store->used = 0;
    store->refcount = 1;
    return store;
 }
 
-static void _save_reset_counters( struct gl_context *ctx )
+
+static void
+_save_reset_counters(struct gl_context *ctx)
 {
    struct vbo_save_context *save = &vbo_context(ctx)->save;
 
    save->prim = save->prim_store->buffer + save->prim_store->used;
-   save->buffer = (save->vertex_store->buffer + 
-		   save->vertex_store->used);
+   save->buffer = save->vertex_store->buffer + save->vertex_store->used;
 
    assert(save->buffer == save->buffer_ptr);
 
    if (save->vertex_size)
-      save->max_vert = ((VBO_SAVE_BUFFER_SIZE - save->vertex_store->used) / 
-			 save->vertex_size);
+      save->max_vert = ((VBO_SAVE_BUFFER_SIZE - save->vertex_store->used) /
+                        save->vertex_size);
    else
       save->max_vert = 0;
 
@@ -262,10 +287,12 @@ static void _save_reset_counters( struct gl_context *ctx )
 }
 
 
-/* Insert the active immediate struct onto the display list currently
+/**
+ * Insert the active immediate struct onto the display list currently
  * being built.
  */
-static void _save_compile_vertex_list( struct gl_context *ctx )
+static void
+_save_compile_vertex_list(struct gl_context *ctx)
 {
    struct vbo_save_context *save = &vbo_context(ctx)->save;
    struct vbo_save_vertex_list *node;
@@ -283,7 +310,8 @@ static void _save_compile_vertex_list( struct gl_context *ctx )
     */
    memcpy(node->attrsz, save->attrsz, sizeof(node->attrsz));
    node->vertex_size = save->vertex_size;
-   node->buffer_offset = (save->buffer - save->vertex_store->buffer) * sizeof(GLfloat); 
+   node->buffer_offset =
+      (save->buffer - save->vertex_store->buffer) * sizeof(GLfloat);
    node->count = save->vert_count;
    node->wrap_count = save->copied.nr;
    node->dangling_attr_ref = save->dangling_attr_ref;
@@ -298,34 +326,33 @@ static void _save_compile_vertex_list( struct gl_context *ctx )
    if (node->prim[0].no_current_update) {
       node->current_size = 0;
       node->current_data = NULL;
-   } else {
+   }
+   else {
       node->current_size = node->vertex_size - node->attrsz[0];
       node->current_data = NULL;
-     
+
       if (node->current_size) {
          /* If the malloc fails, we just pull the data out of the VBO
           * later instead.
           */
-         node->current_data = MALLOC( node->current_size * sizeof(GLfloat) );
+         node->current_data = MALLOC(node->current_size * sizeof(GLfloat));
          if (node->current_data) {
-            const char *buffer = (const char *)save->vertex_store->buffer;
+            const char *buffer = (const char *) save->vertex_store->buffer;
             unsigned attr_offset = node->attrsz[0] * sizeof(GLfloat);
             unsigned vertex_offset = 0;
-            
+
             if (node->count)
-               vertex_offset = (node->count-1) * node->vertex_size * sizeof(GLfloat);
-         
-            memcpy( node->current_data,
-                    buffer + node->buffer_offset + vertex_offset + attr_offset,
-                    node->current_size * sizeof(GLfloat) );
+               vertex_offset =
+                  (node->count - 1) * node->vertex_size * sizeof(GLfloat);
+
+            memcpy(node->current_data,
+                   buffer + node->buffer_offset + vertex_offset + attr_offset,
+                   node->current_size * sizeof(GLfloat));
          }
       }
    }
 
-
-
-   assert(node->attrsz[VBO_ATTRIB_POS] != 0 ||
-	  node->count == 0);
+   assert(node->attrsz[VBO_ATTRIB_POS] != 0 || node->count == 0);
 
    if (save->dangling_attr_ref)
       ctx->ListState.CurrentList->Flags |= DLIST_DANGLING_REFS;
@@ -333,11 +360,9 @@ static void _save_compile_vertex_list( struct gl_context *ctx )
    save->vertex_store->used += save->vertex_size * node->count;
    save->prim_store->used += node->prim_count;
 
-
    /* Copy duplicated vertices 
     */
-   save->copied.nr = _save_copy_vertices( ctx, node, save->buffer );
-
+   save->copied.nr = _save_copy_vertices(ctx, node, save->buffer);
 
    /* Deal with GL_COMPILE_AND_EXECUTE:
     */
@@ -346,57 +371,55 @@ static void _save_compile_vertex_list( struct gl_context *ctx )
 
       _glapi_set_dispatch(ctx->Exec);
 
-      vbo_loopback_vertex_list( ctx,
-				(const GLfloat *)((const char *)save->vertex_store->buffer + 
-						  node->buffer_offset),
-				node->attrsz,
-				node->prim,
-				node->prim_count,
-				node->wrap_count,
-				node->vertex_size);
+      vbo_loopback_vertex_list(ctx,
+                               (const GLfloat *) ((const char *) save->
+                                                  vertex_store->buffer +
+                                                  node->buffer_offset),
+                               node->attrsz, node->prim, node->prim_count,
+                               node->wrap_count, node->vertex_size);
 
       _glapi_set_dispatch(dispatch);
    }
 
-
    /* Decide whether the storage structs are full, or can be used for
     * the next vertex lists as well.
     */
-   if (save->vertex_store->used > 
+   if (save->vertex_store->used >
        VBO_SAVE_BUFFER_SIZE - 16 * (save->vertex_size + 4)) {
 
       /* Unmap old store:
        */
-      unmap_vertex_store( ctx, save->vertex_store );
+      unmap_vertex_store(ctx, save->vertex_store);
 
       /* Release old reference:
        */
-      save->vertex_store->refcount--; 
+      save->vertex_store->refcount--;
       assert(save->vertex_store->refcount != 0);
       save->vertex_store = NULL;
 
       /* Allocate and map new store:
        */
-      save->vertex_store = alloc_vertex_store( ctx );
-      save->buffer_ptr = map_vertex_store( ctx, save->vertex_store );
-   } 
+      save->vertex_store = alloc_vertex_store(ctx);
+      save->buffer_ptr = map_vertex_store(ctx, save->vertex_store);
+   }
 
    if (save->prim_store->used > VBO_SAVE_PRIM_SIZE - 6) {
-      save->prim_store->refcount--; 
+      save->prim_store->refcount--;
       assert(save->prim_store->refcount != 0);
-      save->prim_store = alloc_prim_store( ctx );
-   } 
+      save->prim_store = alloc_prim_store(ctx);
+   }
 
    /* Reset our structures for the next run of vertices:
     */
-   _save_reset_counters( ctx );
+   _save_reset_counters(ctx);
 }
 
 
-/* TODO -- If no new vertices have been stored, don't bother saving
- * it.
+/**
+ * TODO -- If no new vertices have been stored, don't bother saving it.
  */
-static void _save_wrap_buffers( struct gl_context *ctx )
+static void
+_save_wrap_buffers(struct gl_context *ctx)
 {
    struct vbo_save_context *save = &vbo_context(ctx)->save;
    GLint i = save->prim_count - 1;
@@ -409,15 +432,14 @@ static void _save_wrap_buffers( struct gl_context *ctx )
 
    /* Close off in-progress primitive.
     */
-   save->prim[i].count = (save->vert_count - 
-			  save->prim[i].start);
+   save->prim[i].count = (save->vert_count - save->prim[i].start);
    mode = save->prim[i].mode;
    weak = save->prim[i].weak;
    no_current_update = save->prim[i].no_current_update;
-   
+
    /* store the copied vertices, and allocate a new list.
     */
-   _save_compile_vertex_list( ctx );
+   _save_compile_vertex_list(ctx);
 
    /* Restart interrupted primitive
     */
@@ -434,11 +456,12 @@ static void _save_wrap_buffers( struct gl_context *ctx )
 }
 
 
-
-/* Called only when buffers are wrapped as the result of filling the
+/**
+ * Called only when buffers are wrapped as the result of filling the
  * vertex_store struct.  
  */
-static void _save_wrap_filled_vertex( struct gl_context *ctx )
+static void
+_save_wrap_filled_vertex(struct gl_context *ctx)
 {
    struct vbo_save_context *save = &vbo_context(ctx)->save;
    GLfloat *data = save->copied.buffer;
@@ -446,14 +469,14 @@ static void _save_wrap_filled_vertex( struct gl_context *ctx )
 
    /* Emit a glEnd to close off the last vertex list.
     */
-   _save_wrap_buffers( ctx );
-   
-    /* Copy stored stored vertices to start of new list.
+   _save_wrap_buffers(ctx);
+
+   /* Copy stored stored vertices to start of new list.
     */
    assert(save->max_vert - save->vert_count > save->copied.nr);
 
-   for (i = 0 ; i < save->copied.nr ; i++) {
-      memcpy( save->buffer_ptr, data, save->vertex_size * sizeof(GLfloat));
+   for (i = 0; i < save->copied.nr; i++) {
+      memcpy(save->buffer_ptr, data, save->vertex_size * sizeof(GLfloat));
       data += save->vertex_size;
       save->buffer_ptr += save->vertex_size;
       save->vert_count++;
@@ -461,46 +484,48 @@ static void _save_wrap_filled_vertex( struct gl_context *ctx )
 }
 
 
-static void _save_copy_to_current( struct gl_context *ctx )
+static void
+_save_copy_to_current(struct gl_context *ctx)
 {
-   struct vbo_save_context *save = &vbo_context(ctx)->save; 
+   struct vbo_save_context *save = &vbo_context(ctx)->save;
    GLuint i;
 
-   for (i = VBO_ATTRIB_POS+1 ; i < VBO_ATTRIB_MAX ; i++) {
+   for (i = VBO_ATTRIB_POS + 1; i < VBO_ATTRIB_MAX; i++) {
       if (save->attrsz[i]) {
-	 save->currentsz[i][0] = save->attrsz[i];
-	 COPY_CLEAN_4V(save->current[i], 
-		       save->attrsz[i], 
-		       save->attrptr[i]);
+         save->currentsz[i][0] = save->attrsz[i];
+         COPY_CLEAN_4V(save->current[i], save->attrsz[i], save->attrptr[i]);
       }
    }
 }
 
 
-static void _save_copy_from_current( struct gl_context *ctx )
+static void
+_save_copy_from_current(struct gl_context *ctx)
 {
-   struct vbo_save_context *save = &vbo_context(ctx)->save; 
+   struct vbo_save_context *save = &vbo_context(ctx)->save;
    GLint i;
 
-   for (i = VBO_ATTRIB_POS+1 ; i < VBO_ATTRIB_MAX ; i++) {
+   for (i = VBO_ATTRIB_POS + 1; i < VBO_ATTRIB_MAX; i++) {
       switch (save->attrsz[i]) {
-      case 4: save->attrptr[i][3] = save->current[i][3];
-      case 3: save->attrptr[i][2] = save->current[i][2];
-      case 2: save->attrptr[i][1] = save->current[i][1];
-      case 1: save->attrptr[i][0] = save->current[i][0];
-      case 0: break;
+      case 4:
+         save->attrptr[i][3] = save->current[i][3];
+      case 3:
+         save->attrptr[i][2] = save->current[i][2];
+      case 2:
+         save->attrptr[i][1] = save->current[i][1];
+      case 1:
+         save->attrptr[i][0] = save->current[i][0];
+      case 0:
+         break;
       }
    }
 }
 
 
-
-
 /* Flush existing data, set new attrib size, replay copied vertices.
- */ 
-static void _save_upgrade_vertex( struct gl_context *ctx, 
-				 GLuint attr,
-				 GLuint newsz )
+ */
+static void
+_save_upgrade_vertex(struct gl_context *ctx, GLuint attr, GLuint newsz)
 {
    struct vbo_save_context *save = &vbo_context(ctx)->save;
    GLuint oldsz;
@@ -510,16 +535,16 @@ static void _save_upgrade_vertex( struct gl_context *ctx,
    /* Store the current run of vertices, and emit a GL_END.  Emit a
     * BEGIN in the new buffer.
     */
-   if (save->vert_count) 
-      _save_wrap_buffers( ctx );
+   if (save->vert_count)
+      _save_wrap_buffers(ctx);
    else
-      assert( save->copied.nr == 0 );
+      assert(save->copied.nr == 0);
 
    /* Do a COPY_TO_CURRENT to ensure back-copying works for the case
     * when the attribute already exists in the vertex and is having
     * its size increased.  
     */
-   _save_copy_to_current( ctx );
+   _save_copy_to_current(ctx);
 
    /* Fix up sizes:
     */
@@ -527,24 +552,25 @@ static void _save_upgrade_vertex( struct gl_context *ctx,
    save->attrsz[attr] = newsz;
 
    save->vertex_size += newsz - oldsz;
-   save->max_vert = ((VBO_SAVE_BUFFER_SIZE - save->vertex_store->used) / 
-		      save->vertex_size);
+   save->max_vert = ((VBO_SAVE_BUFFER_SIZE - save->vertex_store->used) /
+                     save->vertex_size);
    save->vert_count = 0;
 
    /* Recalculate all the attrptr[] values:
     */
-   for (i = 0, tmp = save->vertex ; i < VBO_ATTRIB_MAX ; i++) {
+   for (i = 0, tmp = save->vertex; i < VBO_ATTRIB_MAX; i++) {
       if (save->attrsz[i]) {
-	 save->attrptr[i] = tmp;
-	 tmp += save->attrsz[i];
+         save->attrptr[i] = tmp;
+         tmp += save->attrsz[i];
+      }
+      else {
+         save->attrptr[i] = NULL;       /* will not be dereferenced. */
       }
-      else 
-	 save->attrptr[i] = NULL; /* will not be dereferenced. */
    }
 
    /* Copy from current to repopulate the vertex with correct values.
     */
-   _save_copy_from_current( ctx );
+   _save_copy_from_current(ctx);
 
    /* Replay stored vertices to translate them to new format here.
     *
@@ -552,8 +578,7 @@ static void _save_upgrade_vertex( struct gl_context *ctx,
     * has not been defined before, this list is somewhat degenerate,
     * and will need fixup at runtime.
     */
-   if (save->copied.nr)
-   {
+   if (save->copied.nr) {
       GLfloat *data = save->copied.buffer;
       GLfloat *dest = save->buffer;
       GLuint j;
@@ -561,32 +586,32 @@ static void _save_upgrade_vertex( struct gl_context *ctx,
       /* Need to note this and fix up at runtime (or loopback):
        */
       if (attr != VBO_ATTRIB_POS && save->currentsz[attr][0] == 0) {
-	 assert(oldsz == 0);
-	 save->dangling_attr_ref = GL_TRUE;
+         assert(oldsz == 0);
+         save->dangling_attr_ref = GL_TRUE;
       }
 
-      for (i = 0 ; i < save->copied.nr ; i++) {
-	 for (j = 0 ; j < VBO_ATTRIB_MAX ; j++) {
-	    if (save->attrsz[j]) {
-	       if (j == attr) {
-		  if (oldsz) {
-		     COPY_CLEAN_4V( dest, oldsz, data );
-		     data += oldsz;
-		     dest += newsz;
-		  }
-		  else {
-		     COPY_SZ_4V( dest, newsz, save->current[attr] );
-		     dest += newsz;
-		  }
-	       }
-	       else {
-		  GLint sz = save->attrsz[j];
-		  COPY_SZ_4V( dest, sz, data );
-		  data += sz;
-		  dest += sz;
-	       }
-	    }
-	 }
+      for (i = 0; i < save->copied.nr; i++) {
+         for (j = 0; j < VBO_ATTRIB_MAX; j++) {
+            if (save->attrsz[j]) {
+               if (j == attr) {
+                  if (oldsz) {
+                     COPY_CLEAN_4V(dest, oldsz, data);
+                     data += oldsz;
+                     dest += newsz;
+                  }
+                  else {
+                     COPY_SZ_4V(dest, newsz, save->current[attr]);
+                     dest += newsz;
+                  }
+               }
+               else {
+                  GLint sz = save->attrsz[j];
+                  COPY_SZ_4V(dest, sz, data);
+                  data += sz;
+                  dest += sz;
+               }
+            }
+         }
       }
 
       save->buffer_ptr = dest;
@@ -594,15 +619,17 @@ static void _save_upgrade_vertex( struct gl_context *ctx,
    }
 }
 
-static void save_fixup_vertex( struct gl_context *ctx, GLuint attr, GLuint sz )
+
+static void
+save_fixup_vertex(struct gl_context *ctx, GLuint attr, GLuint sz)
 {
-   struct vbo_save_context *save = &vbo_context(ctx)->save; 
+   struct vbo_save_context *save = &vbo_context(ctx)->save;
 
    if (sz > save->attrsz[attr]) {
       /* New size is larger.  Need to flush existing vertices and get
        * an enlarged vertex format.
        */
-      _save_upgrade_vertex( ctx, attr, sz );
+      _save_upgrade_vertex(ctx, attr, sz);
    }
    else if (sz < save->active_sz[attr]) {
       static GLfloat id[4] = { 0, 0, 0, 1 };
@@ -611,29 +638,31 @@ static void save_fixup_vertex( struct gl_context *ctx, GLuint attr, GLuint sz )
       /* New size is equal or smaller - just need to fill in some
        * zeros.
        */
-      for (i = sz ; i <= save->attrsz[attr] ; i++)
-	 save->attrptr[attr][i-1] = id[i-1];
+      for (i = sz; i <= save->attrsz[attr]; i++)
+         save->attrptr[attr][i - 1] = id[i - 1];
    }
 
    save->active_sz[attr] = sz;
 }
 
-static void _save_reset_vertex( struct gl_context *ctx )
+
+static void
+_save_reset_vertex(struct gl_context *ctx)
 {
    struct vbo_save_context *save = &vbo_context(ctx)->save;
    GLuint i;
 
-   for (i = 0 ; i < VBO_ATTRIB_MAX ; i++) {
+   for (i = 0; i < VBO_ATTRIB_MAX; i++) {
       save->attrsz[i] = 0;
       save->active_sz[i] = 0;
    }
-      
+
    save->vertex_size = 0;
 }
 
 
 
-#define ERROR(err)   _mesa_compile_error( ctx, err, __FUNCTION__ );
+#define ERROR(err)   _mesa_compile_error(ctx, err, __FUNCTION__);
 
 
 /* Only one size for each attribute may be active at once.  Eg. if
@@ -642,7 +671,7 @@ static void _save_reset_vertex( struct gl_context *ctx )
  * 3f version won't otherwise set color[3] to 1.0 -- this is the job
  * of the chooser function when switching between Color4f and Color3f.
  */
-#define ATTR( A, N, V0, V1, V2, V3 )				\
+#define ATTR(A, N, V0, V1, V2, V3)				\
 do {								\
    struct vbo_save_context *save = &vbo_context(ctx)->save;	\
 								\
@@ -666,7 +695,7 @@ do {								\
       save->buffer_ptr += save->vertex_size;			\
 								\
       if (++save->vert_count >= save->max_vert)			\
-	 _save_wrap_filled_vertex( ctx );			\
+	 _save_wrap_filled_vertex(ctx);				\
    }								\
 } while (0)
 
@@ -681,7 +710,8 @@ do {								\
  *     -- Flush current buffer
  *     -- Fallback to opcodes for the rest of the begin/end object.
  */
-static void dlist_fallback( struct gl_context *ctx )
+static void
+dlist_fallback(struct gl_context *ctx)
 {
    struct vbo_save_context *save = &vbo_context(ctx)->save;
 
@@ -697,67 +727,76 @@ static void dlist_fallback( struct gl_context *ctx )
        * properly:
        */
       save->dangling_attr_ref = 1;
-      
-      _save_compile_vertex_list( ctx );
+
+      _save_compile_vertex_list(ctx);
    }
 
-   _save_copy_to_current( ctx );
-   _save_reset_vertex( ctx );
-   _save_reset_counters( ctx );
-   _mesa_install_save_vtxfmt( ctx, &ctx->ListState.ListVtxfmt );
+   _save_copy_to_current(ctx);
+   _save_reset_vertex(ctx);
+   _save_reset_counters(ctx);
+   _mesa_install_save_vtxfmt(ctx, &ctx->ListState.ListVtxfmt);
    ctx->Driver.SaveNeedFlush = 0;
 }
 
-static void GLAPIENTRY _save_EvalCoord1f( GLfloat u )
+
+static void GLAPIENTRY
+_save_EvalCoord1f(GLfloat u)
 {
    GET_CURRENT_CONTEXT(ctx);
    dlist_fallback(ctx);
    CALL_EvalCoord1f(ctx->Save, (u));
 }
 
-static void GLAPIENTRY _save_EvalCoord1fv( const GLfloat *v )
+static void GLAPIENTRY
+_save_EvalCoord1fv(const GLfloat * v)
 {
    GET_CURRENT_CONTEXT(ctx);
    dlist_fallback(ctx);
    CALL_EvalCoord1fv(ctx->Save, (v));
 }
 
-static void GLAPIENTRY _save_EvalCoord2f( GLfloat u, GLfloat v )
+static void GLAPIENTRY
+_save_EvalCoord2f(GLfloat u, GLfloat v)
 {
    GET_CURRENT_CONTEXT(ctx);
    dlist_fallback(ctx);
    CALL_EvalCoord2f(ctx->Save, (u, v));
 }
 
-static void GLAPIENTRY _save_EvalCoord2fv( const GLfloat *v )
+static void GLAPIENTRY
+_save_EvalCoord2fv(const GLfloat * v)
 {
    GET_CURRENT_CONTEXT(ctx);
    dlist_fallback(ctx);
    CALL_EvalCoord2fv(ctx->Save, (v));
 }
 
-static void GLAPIENTRY _save_EvalPoint1( GLint i )
+static void GLAPIENTRY
+_save_EvalPoint1(GLint i)
 {
    GET_CURRENT_CONTEXT(ctx);
    dlist_fallback(ctx);
    CALL_EvalPoint1(ctx->Save, (i));
 }
 
-static void GLAPIENTRY _save_EvalPoint2( GLint i, GLint j )
+static void GLAPIENTRY
+_save_EvalPoint2(GLint i, GLint j)
 {
    GET_CURRENT_CONTEXT(ctx);
    dlist_fallback(ctx);
    CALL_EvalPoint2(ctx->Save, (i, j));
 }
 
-static void GLAPIENTRY _save_CallList( GLuint l )
+static void GLAPIENTRY
+_save_CallList(GLuint l)
 {
    GET_CURRENT_CONTEXT(ctx);
    dlist_fallback(ctx);
    CALL_CallList(ctx->Save, (l));
 }
 
-static void GLAPIENTRY _save_CallLists( GLsizei n, GLenum type, const GLvoid *v )
+static void GLAPIENTRY
+_save_CallLists(GLsizei n, GLenum type, const GLvoid * v)
 {
    GET_CURRENT_CONTEXT(ctx);
    dlist_fallback(ctx);
@@ -766,13 +805,13 @@ static void GLAPIENTRY _save_CallLists( GLsizei n, GLenum type, const GLvoid *v
 
 
 
-
 /* This begin is hooked into ...  Updating of
  * ctx->Driver.CurrentSavePrimitive is already taken care of.
  */
-GLboolean vbo_save_NotifyBegin( struct gl_context *ctx, GLenum mode )
+GLboolean
+vbo_save_NotifyBegin(struct gl_context *ctx, GLenum mode)
 {
-   struct vbo_save_context *save = &vbo_context(ctx)->save; 
+   struct vbo_save_context *save = &vbo_context(ctx)->save;
 
    GLuint i = save->prim_count++;
 
@@ -781,133 +820,169 @@ GLboolean vbo_save_NotifyBegin( struct gl_context *ctx, GLenum mode )
    save->prim[i].begin = 1;
    save->prim[i].end = 0;
    save->prim[i].weak = (mode & VBO_SAVE_PRIM_WEAK) ? 1 : 0;
-   save->prim[i].no_current_update = (mode & VBO_SAVE_PRIM_NO_CURRENT_UPDATE) ? 1 : 0;
+   save->prim[i].no_current_update =
+      (mode & VBO_SAVE_PRIM_NO_CURRENT_UPDATE) ? 1 : 0;
    save->prim[i].pad = 0;
    save->prim[i].start = save->vert_count;
-   save->prim[i].count = 0;   
-   save->prim[i].num_instances = 1;   
+   save->prim[i].count = 0;
+   save->prim[i].num_instances = 1;
 
-   _mesa_install_save_vtxfmt( ctx, &save->vtxfmt );      
+   _mesa_install_save_vtxfmt(ctx, &save->vtxfmt);
    ctx->Driver.SaveNeedFlush = 1;
    return GL_TRUE;
 }
 
 
-
-static void GLAPIENTRY _save_End( void )
+static void GLAPIENTRY
+_save_End(void)
 {
-   GET_CURRENT_CONTEXT( ctx ); 
-   struct vbo_save_context *save = &vbo_context(ctx)->save; 
+   GET_CURRENT_CONTEXT(ctx);
+   struct vbo_save_context *save = &vbo_context(ctx)->save;
    GLint i = save->prim_count - 1;
 
    ctx->Driver.CurrentSavePrimitive = PRIM_OUTSIDE_BEGIN_END;
    save->prim[i].end = 1;
-   save->prim[i].count = (save->vert_count - 
-			  save->prim[i].start);
+   save->prim[i].count = (save->vert_count - save->prim[i].start);
 
    if (i == (GLint) save->prim_max - 1) {
-      _save_compile_vertex_list( ctx );
+      _save_compile_vertex_list(ctx);
       assert(save->copied.nr == 0);
    }
 
    /* Swap out this vertex format while outside begin/end.  Any color,
     * etc. received between here and the next begin will be compiled
     * as opcodes.
-    */   
-   _mesa_install_save_vtxfmt( ctx, &ctx->ListState.ListVtxfmt );
+    */
+   _mesa_install_save_vtxfmt(ctx, &ctx->ListState.ListVtxfmt);
 }
 
 
 /* These are all errors as this vtxfmt is only installed inside
  * begin/end pairs.
  */
-static void GLAPIENTRY _save_DrawElements(GLenum mode, GLsizei count, GLenum type,
-			       const GLvoid *indices)
+static void GLAPIENTRY
+_save_DrawElements(GLenum mode, GLsizei count, GLenum type,
+                   const GLvoid * indices)
 {
    GET_CURRENT_CONTEXT(ctx);
-   (void) mode; (void) count; (void) type; (void) indices;
-   _mesa_compile_error( ctx, GL_INVALID_OPERATION, "glDrawElements" );
+   (void) mode;
+   (void) count;
+   (void) type;
+   (void) indices;
+   _mesa_compile_error(ctx, GL_INVALID_OPERATION, "glDrawElements");
 }
 
 
-static void GLAPIENTRY _save_DrawRangeElements(GLenum mode,
-				    GLuint start, GLuint end,
-				    GLsizei count, GLenum type,
-				    const GLvoid *indices)
+static void GLAPIENTRY
+_save_DrawRangeElements(GLenum mode, GLuint start, GLuint end,
+                        GLsizei count, GLenum type, const GLvoid * indices)
 {
    GET_CURRENT_CONTEXT(ctx);
-   (void) mode; (void) start; (void) end; (void) count; (void) type; (void) indices;
-   _mesa_compile_error( ctx, GL_INVALID_OPERATION, "glDrawRangeElements" );
+   (void) mode;
+   (void) start;
+   (void) end;
+   (void) count;
+   (void) type;
+   (void) indices;
+   _mesa_compile_error(ctx, GL_INVALID_OPERATION, "glDrawRangeElements");
 }
 
-static void GLAPIENTRY _save_DrawElementsBaseVertex(GLenum mode,
-						    GLsizei count,
-						    GLenum type,
-						    const GLvoid *indices,
-						    GLint basevertex)
+
+static void GLAPIENTRY
+_save_DrawElementsBaseVertex(GLenum mode, GLsizei count, GLenum type,
+                             const GLvoid * indices, GLint basevertex)
 {
    GET_CURRENT_CONTEXT(ctx);
-   (void) mode; (void) count; (void) type; (void) indices; (void)basevertex;
-
-   _mesa_compile_error( ctx, GL_INVALID_OPERATION, "glDrawElements" );
+   (void) mode;
+   (void) count;
+   (void) type;
+   (void) indices;
+   (void) basevertex;
+   _mesa_compile_error(ctx, GL_INVALID_OPERATION, "glDrawElements");
 }
 
-static void GLAPIENTRY _save_DrawRangeElementsBaseVertex(GLenum mode,
-							 GLuint start,
-							 GLuint end,
-							 GLsizei count,
-							 GLenum type,
-							 const GLvoid *indices,
-							 GLint basevertex)
+
+static void GLAPIENTRY
+_save_DrawRangeElementsBaseVertex(GLenum mode,
+                                  GLuint start,
+                                  GLuint end,
+                                  GLsizei count,
+                                  GLenum type,
+                                  const GLvoid * indices, GLint basevertex)
 {
    GET_CURRENT_CONTEXT(ctx);
-   (void) mode; (void) start; (void) end; (void) count; (void) type;
-   (void) indices; (void)basevertex;
-
-   _mesa_compile_error( ctx, GL_INVALID_OPERATION, "glDrawRangeElements" );
+   (void) mode;
+   (void) start;
+   (void) end;
+   (void) count;
+   (void) type;
+   (void) indices;
+   (void) basevertex;
+   _mesa_compile_error(ctx, GL_INVALID_OPERATION, "glDrawRangeElements");
 }
 
-static void GLAPIENTRY _save_DrawArrays(GLenum mode, GLint start, GLsizei count)
+
+static void GLAPIENTRY
+_save_DrawArrays(GLenum mode, GLint start, GLsizei count)
 {
    GET_CURRENT_CONTEXT(ctx);
-   (void) mode; (void) start; (void) count;
-   _mesa_compile_error( ctx, GL_INVALID_OPERATION, "glDrawArrays" );
+   (void) mode;
+   (void) start;
+   (void) count;
+   _mesa_compile_error(ctx, GL_INVALID_OPERATION, "glDrawArrays");
 }
 
-static void GLAPIENTRY _save_Rectf( GLfloat x1, GLfloat y1, GLfloat x2, GLfloat y2 )
+
+static void GLAPIENTRY
+_save_Rectf(GLfloat x1, GLfloat y1, GLfloat x2, GLfloat y2)
 {
    GET_CURRENT_CONTEXT(ctx);
-   (void) x1; (void) y1; (void) x2; (void) y2;
-   _mesa_compile_error( ctx, GL_INVALID_OPERATION, "glRectf" );
+   (void) x1;
+   (void) y1;
+   (void) x2;
+   (void) y2;
+   _mesa_compile_error(ctx, GL_INVALID_OPERATION, "glRectf");
 }
 
-static void GLAPIENTRY _save_EvalMesh1( GLenum mode, GLint i1, GLint i2 )
+
+static void GLAPIENTRY
+_save_EvalMesh1(GLenum mode, GLint i1, GLint i2)
 {
    GET_CURRENT_CONTEXT(ctx);
-   (void) mode; (void) i1; (void) i2;
-   _mesa_compile_error( ctx, GL_INVALID_OPERATION, "glEvalMesh1" );
+   (void) mode;
+   (void) i1;
+   (void) i2;
+   _mesa_compile_error(ctx, GL_INVALID_OPERATION, "glEvalMesh1");
 }
 
-static void GLAPIENTRY _save_EvalMesh2( GLenum mode, GLint i1, GLint i2,
-				  GLint j1, GLint j2 )
+
+static void GLAPIENTRY
+_save_EvalMesh2(GLenum mode, GLint i1, GLint i2, GLint j1, GLint j2)
 {
    GET_CURRENT_CONTEXT(ctx);
-   (void) mode; (void) i1; (void) i2; (void) j1; (void) j2;
-   _mesa_compile_error( ctx, GL_INVALID_OPERATION, "glEvalMesh2" );
+   (void) mode;
+   (void) i1;
+   (void) i2;
+   (void) j1;
+   (void) j2;
+   _mesa_compile_error(ctx, GL_INVALID_OPERATION, "glEvalMesh2");
 }
 
-static void GLAPIENTRY _save_Begin( GLenum mode )
+
+static void GLAPIENTRY
+_save_Begin(GLenum mode)
 {
-   GET_CURRENT_CONTEXT( ctx );
+   GET_CURRENT_CONTEXT(ctx);
    (void) mode;
-   _mesa_compile_error( ctx, GL_INVALID_OPERATION, "Recursive glBegin" );
+   _mesa_compile_error(ctx, GL_INVALID_OPERATION, "Recursive glBegin");
 }
 
 
-static void GLAPIENTRY _save_PrimitiveRestartNV( void )
+static void GLAPIENTRY
+_save_PrimitiveRestartNV(void)
 {
    GLenum curPrim;
-   GET_CURRENT_CONTEXT( ctx ); 
+   GET_CURRENT_CONTEXT(ctx);
 
    curPrim = ctx->Driver.CurrentSavePrimitive;
 
@@ -920,96 +995,102 @@ static void GLAPIENTRY _save_PrimitiveRestartNV( void )
  * maintained in ctx->ListState, active when the list is known or
  * suspected to be outside any begin/end primitive.
  */
-static void GLAPIENTRY _save_OBE_Rectf( GLfloat x1, GLfloat y1, GLfloat x2, GLfloat y2 )
+static void GLAPIENTRY
+_save_OBE_Rectf(GLfloat x1, GLfloat y1, GLfloat x2, GLfloat y2)
 {
    GET_CURRENT_CONTEXT(ctx);
-   vbo_save_NotifyBegin( ctx, GL_QUADS | VBO_SAVE_PRIM_WEAK );
-   CALL_Vertex2f(GET_DISPATCH(), ( x1, y1 ));
-   CALL_Vertex2f(GET_DISPATCH(), ( x2, y1 ));
-   CALL_Vertex2f(GET_DISPATCH(), ( x2, y2 ));
-   CALL_Vertex2f(GET_DISPATCH(), ( x1, y2 ));
+   vbo_save_NotifyBegin(ctx, GL_QUADS | VBO_SAVE_PRIM_WEAK);
+   CALL_Vertex2f(GET_DISPATCH(), (x1, y1));
+   CALL_Vertex2f(GET_DISPATCH(), (x2, y1));
+   CALL_Vertex2f(GET_DISPATCH(), (x2, y2));
+   CALL_Vertex2f(GET_DISPATCH(), (x1, y2));
    CALL_End(GET_DISPATCH(), ());
 }
 
 
-static void GLAPIENTRY _save_OBE_DrawArrays(GLenum mode, GLint start, GLsizei count)
+static void GLAPIENTRY
+_save_OBE_DrawArrays(GLenum mode, GLint start, GLsizei count)
 {
    GET_CURRENT_CONTEXT(ctx);
    GLint i;
 
-   if (!_mesa_validate_DrawArrays( ctx, mode, start, count ))
+   if (!_mesa_validate_DrawArrays(ctx, mode, start, count))
       return;
 
-   _ae_map_vbos( ctx );
+   _ae_map_vbos(ctx);
 
-   vbo_save_NotifyBegin( ctx, mode | VBO_SAVE_PRIM_WEAK | VBO_SAVE_PRIM_NO_CURRENT_UPDATE);
+   vbo_save_NotifyBegin(ctx, (mode | VBO_SAVE_PRIM_WEAK
+                              | VBO_SAVE_PRIM_NO_CURRENT_UPDATE));
 
    for (i = 0; i < count; i++)
-       CALL_ArrayElement(GET_DISPATCH(), (start + i));
+      CALL_ArrayElement(GET_DISPATCH(), (start + i));
    CALL_End(GET_DISPATCH(), ());
 
-   _ae_unmap_vbos( ctx );
+   _ae_unmap_vbos(ctx);
 }
 
+
 /* Could do better by copying the arrays and element list intact and
  * then emitting an indexed prim at runtime.
  */
-static void GLAPIENTRY _save_OBE_DrawElements(GLenum mode, GLsizei count, GLenum type,
-				   const GLvoid *indices)
+static void GLAPIENTRY
+_save_OBE_DrawElements(GLenum mode, GLsizei count, GLenum type,
+                       const GLvoid * indices)
 {
    GET_CURRENT_CONTEXT(ctx);
    GLint i;
 
-   if (!_mesa_validate_DrawElements( ctx, mode, count, type, indices, 0 ))
+   if (!_mesa_validate_DrawElements(ctx, mode, count, type, indices, 0))
       return;
 
-   _ae_map_vbos( ctx );
+   _ae_map_vbos(ctx);
 
    if (_mesa_is_bufferobj(ctx->Array.ElementArrayBufferObj))
-      indices = ADD_POINTERS(ctx->Array.ElementArrayBufferObj->Pointer, indices);
+      indices =
+         ADD_POINTERS(ctx->Array.ElementArrayBufferObj->Pointer, indices);
 
-   vbo_save_NotifyBegin( ctx, mode | VBO_SAVE_PRIM_WEAK | VBO_SAVE_PRIM_NO_CURRENT_UPDATE );
+   vbo_save_NotifyBegin(ctx, (mode | VBO_SAVE_PRIM_WEAK |
+                              VBO_SAVE_PRIM_NO_CURRENT_UPDATE));
 
    switch (type) {
    case GL_UNSIGNED_BYTE:
-      for (i = 0 ; i < count ; i++)
-	  CALL_ArrayElement(GET_DISPATCH(), ( ((GLubyte *)indices)[i] ));
+      for (i = 0; i < count; i++)
+         CALL_ArrayElement(GET_DISPATCH(), (((GLubyte *) indices)[i]));
       break;
    case GL_UNSIGNED_SHORT:
-      for (i = 0 ; i < count ; i++)
-	  CALL_ArrayElement(GET_DISPATCH(), ( ((GLushort *)indices)[i] ));
+      for (i = 0; i < count; i++)
+         CALL_ArrayElement(GET_DISPATCH(), (((GLushort *) indices)[i]));
       break;
    case GL_UNSIGNED_INT:
-      for (i = 0 ; i < count ; i++)
-	  CALL_ArrayElement(GET_DISPATCH(), ( ((GLuint *)indices)[i] ));
+      for (i = 0; i < count; i++)
+         CALL_ArrayElement(GET_DISPATCH(), (((GLuint *) indices)[i]));
       break;
    default:
-      _mesa_error( ctx, GL_INVALID_ENUM, "glDrawElements(type)" );
+      _mesa_error(ctx, GL_INVALID_ENUM, "glDrawElements(type)");
       break;
    }
 
    CALL_End(GET_DISPATCH(), ());
 
-   _ae_unmap_vbos( ctx );
+   _ae_unmap_vbos(ctx);
 }
 
-static void GLAPIENTRY _save_OBE_DrawRangeElements(GLenum mode,
-					GLuint start, GLuint end,
-					GLsizei count, GLenum type,
-					const GLvoid *indices)
+
+static void GLAPIENTRY
+_save_OBE_DrawRangeElements(GLenum mode, GLuint start, GLuint end,
+                            GLsizei count, GLenum type,
+                            const GLvoid * indices)
 {
    GET_CURRENT_CONTEXT(ctx);
-   if (_mesa_validate_DrawRangeElements( ctx, mode,
-					 start, end,
-					 count, type, indices, 0 ))
-      _save_OBE_DrawElements( mode, count, type, indices );
+   if (_mesa_validate_DrawRangeElements(ctx, mode,
+                                        start, end, count, type, indices, 0)) {
+      _save_OBE_DrawElements(mode, count, type, indices);
+   }
 }
 
 
-
-
-
-static void _save_vtxfmt_init( struct gl_context *ctx )
+static void
+_save_vtxfmt_init(struct gl_context *ctx)
 {
    struct vbo_save_context *save = &vbo_context(ctx)->save;
    GLvertexformat *vfmt = &save->vtxfmt;
@@ -1072,7 +1153,7 @@ static void _save_vtxfmt_init( struct gl_context *ctx )
    vfmt->VertexAttrib3fvNV = _save_VertexAttrib3fvNV;
    vfmt->VertexAttrib4fNV = _save_VertexAttrib4fNV;
    vfmt->VertexAttrib4fvNV = _save_VertexAttrib4fvNV;
-   
+
    /* integer-valued */
    vfmt->VertexAttribI1i = _save_VertexAttribI1i;
    vfmt->VertexAttribI2i = _save_VertexAttribI2i;
@@ -1092,8 +1173,8 @@ static void _save_vtxfmt_init( struct gl_context *ctx )
    vfmt->VertexAttribI4uiv = _save_VertexAttribI4uiv;
 
    /* This will all require us to fallback to saving the list as opcodes:
-    */ 
-   _MESA_INIT_DLIST_VTXFMT(vfmt, _save_); /* inside begin/end */
+    */
+   _MESA_INIT_DLIST_VTXFMT(vfmt, _save_);       /* inside begin/end */
 
    _MESA_INIT_EVAL_VTXFMT(vfmt, _save_);
 
@@ -1113,7 +1194,8 @@ static void _save_vtxfmt_init( struct gl_context *ctx )
 }
 
 
-void vbo_save_SaveFlushVertices( struct gl_context *ctx )
+void
+vbo_save_SaveFlushVertices(struct gl_context *ctx)
 {
    struct vbo_save_context *save = &vbo_context(ctx)->save;
 
@@ -1123,36 +1205,40 @@ void vbo_save_SaveFlushVertices( struct gl_context *ctx )
        ctx->Driver.CurrentSavePrimitive <= GL_POLYGON)
       return;
 
-   if (save->vert_count ||
-       save->prim_count) 
-      _save_compile_vertex_list( ctx );
-   
-   _save_copy_to_current( ctx );
-   _save_reset_vertex( ctx );
-   _save_reset_counters( ctx );  
+   if (save->vert_count || save->prim_count)
+      _save_compile_vertex_list(ctx);
+
+   _save_copy_to_current(ctx);
+   _save_reset_vertex(ctx);
+   _save_reset_counters(ctx);
    ctx->Driver.SaveNeedFlush = 0;
 }
 
-void vbo_save_NewList( struct gl_context *ctx, GLuint list, GLenum mode )
+
+void
+vbo_save_NewList(struct gl_context *ctx, GLuint list, GLenum mode)
 {
    struct vbo_save_context *save = &vbo_context(ctx)->save;
 
-   (void) list; (void) mode;
+   (void) list;
+   (void) mode;
 
    if (!save->prim_store)
-      save->prim_store = alloc_prim_store( ctx );
-
-   if (!save->vertex_store) 
-      save->vertex_store = alloc_vertex_store( ctx );
-      
-   save->buffer_ptr = map_vertex_store( ctx, save->vertex_store );
-   
-   _save_reset_vertex( ctx );
-   _save_reset_counters( ctx );  
+      save->prim_store = alloc_prim_store(ctx);
+
+   if (!save->vertex_store)
+      save->vertex_store = alloc_vertex_store(ctx);
+
+   save->buffer_ptr = map_vertex_store(ctx, save->vertex_store);
+
+   _save_reset_vertex(ctx);
+   _save_reset_counters(ctx);
    ctx->Driver.SaveNeedFlush = 0;
 }
 
-void vbo_save_EndList( struct gl_context *ctx )
+
+void
+vbo_save_EndList(struct gl_context *ctx)
 {
    struct vbo_save_context *save = &vbo_context(ctx)->save;
 
@@ -1164,38 +1250,41 @@ void vbo_save_EndList( struct gl_context *ctx )
          GLint i = save->prim_count - 1;
          ctx->Driver.CurrentSavePrimitive = PRIM_OUTSIDE_BEGIN_END;
          save->prim[i].end = 0;
-         save->prim[i].count = (save->vert_count - 
-                                save->prim[i].start);
+         save->prim[i].count = (save->vert_count - save->prim[i].start);
       }
 
       /* Make sure this vertex list gets replayed by the "loopback"
        * mechanism:
        */
       save->dangling_attr_ref = 1;
-      vbo_save_SaveFlushVertices( ctx );
+      vbo_save_SaveFlushVertices(ctx);
 
       /* Swap out this vertex format while outside begin/end.  Any color,
        * etc. received between here and the next begin will be compiled
        * as opcodes.
-       */   
-      _mesa_install_save_vtxfmt( ctx, &ctx->ListState.ListVtxfmt );
+       */
+      _mesa_install_save_vtxfmt(ctx, &ctx->ListState.ListVtxfmt);
    }
 
-   unmap_vertex_store( ctx, save->vertex_store );
+   unmap_vertex_store(ctx, save->vertex_store);
 
    assert(save->vertex_size == 0);
 }
- 
-void vbo_save_BeginCallList( struct gl_context *ctx, struct gl_display_list *dlist )
+
+
+void
+vbo_save_BeginCallList(struct gl_context *ctx, struct gl_display_list *dlist)
 {
    struct vbo_save_context *save = &vbo_context(ctx)->save;
    save->replay_flags |= dlist->Flags;
 }
 
-void vbo_save_EndCallList( struct gl_context *ctx )
+
+void
+vbo_save_EndCallList(struct gl_context *ctx)
 {
    struct vbo_save_context *save = &vbo_context(ctx)->save;
-   
+
    if (ctx->ListState.CallDepth == 1) {
       /* This is correct: want to keep only the VBO_SAVE_FALLBACK
        * flag, if it is set:
@@ -1205,16 +1294,17 @@ void vbo_save_EndCallList( struct gl_context *ctx )
 }
 
 
-static void vbo_destroy_vertex_list( struct gl_context *ctx, void *data )
+static void
+vbo_destroy_vertex_list(struct gl_context *ctx, void *data)
 {
-   struct vbo_save_vertex_list *node = (struct vbo_save_vertex_list *)data;
+   struct vbo_save_vertex_list *node = (struct vbo_save_vertex_list *) data;
    (void) ctx;
 
-   if ( --node->vertex_store->refcount == 0 ) 
-      free_vertex_store( ctx, node->vertex_store );
+   if (--node->vertex_store->refcount == 0)
+      free_vertex_store(ctx, node->vertex_store);
 
-   if ( --node->prim_store->refcount == 0 )
-      FREE( node->prim_store );
+   if (--node->prim_store->refcount == 0)
+      FREE(node->prim_store);
 
    if (node->current_data) {
       FREE(node->current_data);
@@ -1223,32 +1313,32 @@ static void vbo_destroy_vertex_list( struct gl_context *ctx, void *data )
 }
 
 
-static void vbo_print_vertex_list( struct gl_context *ctx, void *data )
+static void
+vbo_print_vertex_list(struct gl_context *ctx, void *data)
 {
-   struct vbo_save_vertex_list *node = (struct vbo_save_vertex_list *)data;
+   struct vbo_save_vertex_list *node = (struct vbo_save_vertex_list *) data;
    GLuint i;
    (void) ctx;
 
    printf("VBO-VERTEX-LIST, %u vertices %d primitives, %d vertsize\n",
-	  node->count,
-	  node->prim_count,
-	  node->vertex_size);
+          node->count, node->prim_count, node->vertex_size);
 
-   for (i = 0 ; i < node->prim_count ; i++) {
+   for (i = 0; i < node->prim_count; i++) {
       struct _mesa_prim *prim = &node->prim[i];
       _mesa_debug(NULL, "   prim %d: %s%s %d..%d %s %s\n",
-		  i, 
-		  _mesa_lookup_prim_by_nr(prim->mode),
-		  prim->weak ? " (weak)" : "",
-		  prim->start, 
-		  prim->start + prim->count,
-		  (prim->begin) ? "BEGIN" : "(wrap)",
-		  (prim->end) ? "END" : "(wrap)");
+                  i,
+                  _mesa_lookup_prim_by_nr(prim->mode),
+                  prim->weak ? " (weak)" : "",
+                  prim->start,
+                  prim->start + prim->count,
+                  (prim->begin) ? "BEGIN" : "(wrap)",
+                  (prim->end) ? "END" : "(wrap)");
    }
 }
 
 
-static void _save_current_init( struct gl_context *ctx ) 
+static void
+_save_current_init(struct gl_context *ctx)
 {
    struct vbo_save_context *save = &vbo_context(ctx)->save;
    GLint i;
@@ -1268,25 +1358,27 @@ static void _save_current_init( struct gl_context *ctx )
    }
 }
 
+
 /**
  * Initialize the display list compiler
  */
-void vbo_save_api_init( struct vbo_save_context *save )
+void
+vbo_save_api_init(struct vbo_save_context *save)
 {
    struct gl_context *ctx = save->ctx;
    GLuint i;
 
    save->opcode_vertex_list =
-      _mesa_dlist_alloc_opcode( ctx,
-                                sizeof(struct vbo_save_vertex_list),
-                                vbo_save_playback_vertex_list,
-                                vbo_destroy_vertex_list,
-                                vbo_print_vertex_list );
+      _mesa_dlist_alloc_opcode(ctx,
+                               sizeof(struct vbo_save_vertex_list),
+                               vbo_save_playback_vertex_list,
+                               vbo_destroy_vertex_list,
+                               vbo_print_vertex_list);
 
    ctx->Driver.NotifySaveBegin = vbo_save_NotifyBegin;
 
-   _save_vtxfmt_init( ctx );
-   _save_current_init( ctx );
+   _save_vtxfmt_init(ctx);
+   _save_current_init(ctx);
 
    /* These will actually get set again when binding/drawing */
    for (i = 0; i < VBO_ATTRIB_MAX; i++)
@@ -1300,9 +1392,11 @@ void vbo_save_api_init( struct vbo_save_context *save )
    ctx->ListState.ListVtxfmt.DrawElements = _save_OBE_DrawElements;
    ctx->ListState.ListVtxfmt.DrawRangeElements = _save_OBE_DrawRangeElements;
    /* loops back into _save_OBE_DrawElements */
-   ctx->ListState.ListVtxfmt.MultiDrawElementsEXT = _mesa_noop_MultiDrawElements;
-   ctx->ListState.ListVtxfmt.MultiDrawElementsBaseVertex = _mesa_noop_MultiDrawElementsBaseVertex;
-   _mesa_install_save_vtxfmt( ctx, &ctx->ListState.ListVtxfmt );
+   ctx->ListState.ListVtxfmt.MultiDrawElementsEXT =
+      _mesa_noop_MultiDrawElements;
+   ctx->ListState.ListVtxfmt.MultiDrawElementsBaseVertex =
+      _mesa_noop_MultiDrawElementsBaseVertex;
+   _mesa_install_save_vtxfmt(ctx, &ctx->ListState.ListVtxfmt);
 }