diff -U3 -N -r mapserver-classes/layerobject.c mapserver-beforeclasses/layerobject.c
--- mapserver-classes/layerobject.c	2007-03-11 11:12:27.000000000 +0100
+++ mapserver-beforeclasses/layerobject.c	2007-03-11 17:54:04.000000000 +0100
@@ -79,12 +79,12 @@
     }
     else if (nIndex < 0) { /* Insert at the end by default */
 #ifndef __cplusplus
-        initClass(&(layer->class[layer->numclasses]));
-        msCopyClass(&(layer->class[layer->numclasses]), classobj, layer);
+        layer->class[layer->numclasses]=classobj;
 #else
         initClass(&(layer->_class[layer->numclasses]));
         msCopyClass(&(layer->_class[layer->numclasses]), classobj, layer);
 #endif
+	MS_REFCNT_INCR(classobj);
         layer->numclasses++;
         return layer->numclasses-1;
     }
@@ -94,11 +94,9 @@
         /* to an index one higher */
 
 #ifndef __cplusplus
-        initClass(&(layer->class[layer->numclasses]));
         for (i=layer->numclasses-1; i>=nIndex; i--)
             layer->class[i+1] = layer->class[i];
-        initClass(&(layer->class[nIndex]));
-        msCopyClass(&(layer->class[nIndex]), classobj, layer);
+        layer->class[nIndex]=classobj;
 #else
         initClass(&(layer->_class[layer->numclasses]));
         for (i=layer->numclasses-1; i>=nIndex; i--)
@@ -107,6 +105,7 @@
         msCopyClass(&(layer->_class[nIndex]), classobj, layer);
 #endif
 
+	MS_REFCNT_INCR(classobj);
         /* increment number of layers and return */
         layer->numclasses++;
         return nIndex;
@@ -145,7 +144,7 @@
         }
         initClass(classobj);
 #ifndef __cplusplus
-        msCopyClass(classobj, &(layer->class[nIndex]), NULL);
+        msCopyClass(classobj, layer->class[nIndex], NULL);
 #else
         msCopyClass(classobj, &(layer->_class[nIndex]), NULL);
 #endif
@@ -154,9 +153,9 @@
         for (i=nIndex; i<layer->numclasses-1; i++)
         {
 #ifndef __cplusplus
-            freeClass(&(layer->class[i]));
-            initClass(&(layer->class[i]));
-            msCopyClass(&layer->class[i], &layer->class[i+1], layer);
+            freeClass(layer->class[i]);
+            initClass(layer->class[i]);
+            msCopyClass(layer->class[i], layer->class[i+1], layer);
 #else
             freeClass(&(layer->_class[i]));
             initClass(&(layer->_class[i]));
@@ -165,7 +164,7 @@
         }
         /* Free the extra class at the end */
 #ifndef __cplusplus
-        freeClass(&(layer->class[layer->numclasses-1]));
+        freeClass(layer->class[layer->numclasses-1]);
 #else  
         freeClass(&(layer->_class[layer->numclasses-1]));
 #endif
@@ -187,12 +186,12 @@
         psTmpClass = (classObj *)malloc(sizeof(classObj));
         initClass(psTmpClass);
         
-        msCopyClass(psTmpClass, &layer->class[nClassIndex], layer);
+        msCopyClass(psTmpClass, layer->class[nClassIndex], layer);
 
-        msCopyClass(&layer->class[nClassIndex], 
-                    &layer->class[nClassIndex-1], layer);
+        msCopyClass(layer->class[nClassIndex],
+                    layer->class[nClassIndex-1], layer);
         
-        msCopyClass(&layer->class[nClassIndex-1], psTmpClass, layer);
+        msCopyClass(layer->class[nClassIndex-1], psTmpClass, layer);
 
         return(MS_SUCCESS);
     }
@@ -213,12 +212,12 @@
         psTmpClass = (classObj *)malloc(sizeof(classObj));
         initClass(psTmpClass);
         
-        msCopyClass(psTmpClass, &layer->class[nClassIndex], layer);
+        msCopyClass(psTmpClass, layer->class[nClassIndex], layer);
 
-        msCopyClass(&layer->class[nClassIndex], 
-                    &layer->class[nClassIndex+1], layer);
+        msCopyClass(layer->class[nClassIndex], 
+                    layer->class[nClassIndex+1], layer);
         
-        msCopyClass(&layer->class[nClassIndex+1], psTmpClass, layer);
+        msCopyClass(layer->class[nClassIndex+1], psTmpClass, layer);
 
         return(MS_SUCCESS);
     }
diff -U3 -N -r mapserver-classes/mapcopy.c mapserver-beforeclasses/mapcopy.c
--- mapserver-classes/mapcopy.c	2007-03-13 15:33:56.000000000 +0100
+++ mapserver-beforeclasses/mapcopy.c	2007-03-11 10:56:34.000000000 +0100
@@ -729,9 +729,9 @@
 
     for (i = 0; i < dst->numclasses; i++) {
 #ifndef __cplusplus
-        initClass(&(dst->class[i]));
+        initClass(dst->class[i]);
 
-        return_value = msCopyClass(&(dst->class[i]), &(src->class[i]), dst);
+        return_value = msCopyClass(dst->class[i], src->class[i], dst);
         if (return_value != MS_SUCCESS) {
             msSetError(MS_MEMERR, "Failed to copy class.", "msCopyLayer()");
             return MS_FAILURE;
@@ -739,7 +739,7 @@
 #else
         initClass(&(dst->_class[i]));
 
-        return_value = msCopyClass(&(dst->_class[i]), &(src->_class[i]), dst);
+        return_value = msCopyClass(dst->_class[i], src->_class[i], dst);
         if (return_value != MS_SUCCESS) {
             msSetError(MS_MEMERR, "Failed to copy _class.", "msCopyLayer()");
             return MS_FAILURE;
diff -U3 -N -r mapserver-classes/mapdraw.c mapserver-beforeclasses/mapdraw.c
--- mapserver-classes/mapdraw.c	2007-03-13 15:33:56.000000000 +0100
+++ mapserver-beforeclasses/mapdraw.c	2007-03-11 10:53:44.000000000 +0100
@@ -155,16 +155,16 @@
   int i, j;  
 
   for(i=0; i<layer->numclasses; i++) {
-    layer->class[i].label.backgroundcolor.pen = MS_PEN_UNSET; /* set in billboardXX function */
-    layer->class[i].label.backgroundshadowcolor.pen = MS_PEN_UNSET;
-    layer->class[i].label.color.pen = MS_PEN_UNSET; /* set in MSXXDrawText function */
-    layer->class[i].label.outlinecolor.pen = MS_PEN_UNSET;
-    layer->class[i].label.shadowcolor.pen = MS_PEN_UNSET;      
-
-    for(j=0; j<layer->class[i].numstyles; j++) {
-      layer->class[i].styles[j].backgroundcolor.pen = MS_PEN_UNSET; /* set in various symbol drawing functions */
-	  layer->class[i].styles[j].color.pen = MS_PEN_UNSET;
-      layer->class[i].styles[j].outlinecolor.pen = MS_PEN_UNSET; 
+    layer->class[i]->label.backgroundcolor.pen = MS_PEN_UNSET; /* set in billboardXX function */
+    layer->class[i]->label.backgroundshadowcolor.pen = MS_PEN_UNSET;
+    layer->class[i]->label.color.pen = MS_PEN_UNSET; /* set in MSXXDrawText function */
+    layer->class[i]->label.outlinecolor.pen = MS_PEN_UNSET;
+    layer->class[i]->label.shadowcolor.pen = MS_PEN_UNSET;      
+
+    for(j=0; j<layer->class[i]->numstyles; j++) {
+      layer->class[i]->styles[j].backgroundcolor.pen = MS_PEN_UNSET; /* set in various symbol drawing functions */
+	  layer->class[i]->styles[j].color.pen = MS_PEN_UNSET;
+      layer->class[i]->styles[j].outlinecolor.pen = MS_PEN_UNSET; 
     }
   }
 }
@@ -837,9 +837,9 @@
     /* now check class scale boundaries (all layers *must* pass these tests) */
     if(layer->numclasses > 0) {
       for(i=0; i<layer->numclasses; i++) {
-        if((layer->class[i].maxscale > 0) && (map->scale > layer->class[i].maxscale))
+        if((layer->class[i]->maxscale > 0) && (map->scale > layer->class[i]->maxscale))
           continue; /* can skip this one, next class */
-        if((layer->class[i].minscale > 0) && (map->scale <= layer->class[i].minscale))
+        if((layer->class[i]->minscale > 0) && (map->scale <= layer->class[i]->minscale))
           continue; /* can skip this one, next class */
 
         break; /* can't skip this class (or layer for that matter) */
@@ -1087,19 +1087,19 @@
   while((status = msLayerNextShape(layer, &shape)) == MS_SUCCESS) {
 
     shape.classindex = msShapeGetClass(layer, &shape, map->scale);
-    if((shape.classindex == -1) || (layer->class[shape.classindex].status == MS_OFF)) {
+    if((shape.classindex == -1) || (layer->class[shape.classindex]->status == MS_OFF)) {
        msFreeShape(&shape);
        continue;
     }
   
     cache = MS_FALSE;
-    if(layer->type == MS_LAYER_LINE && layer->class[shape.classindex].numstyles > 1) 
+    if(layer->type == MS_LAYER_LINE && layer->class[shape.classindex]->numstyles > 1) 
       cache = MS_TRUE; /* only line layers with multiple styles need be cached (I don't think POLYLINE layers need caching - SDL) */
          
     /* With 'STYLEITEM AUTO', we will have the datasource fill the class' */
     /* style parameters for this shape. */
     if(layer->styleitem && strcasecmp(layer->styleitem, "AUTO") == 0) {
-      if(msLayerGetAutoStyle(map, layer, &(layer->class[shape.classindex]), shape.tileindex, shape.index) != MS_SUCCESS) {
+      if(msLayerGetAutoStyle(map, layer, layer->class[shape.classindex], shape.tileindex, shape.index) != MS_SUCCESS) {
         retcode = MS_FAILURE;
         break;
       }
@@ -1108,7 +1108,7 @@
       cache = MS_FALSE;
     }
   
-    if(annotate && (layer->class[shape.classindex].text.string || layer->labelitem) && layer->class[shape.classindex].label.size != -1)
+    if(annotate && (layer->class[shape.classindex]->text.string || layer->labelitem) && layer->class[shape.classindex]->label.size != -1)
       shape.text = msShapeGetAnnotation(layer, &shape);
 
     if(cache)
@@ -1133,7 +1133,7 @@
       }
     }  
 
-    maxnumstyles = MS_MAX(maxnumstyles, layer->class[shape.classindex].numstyles);
+    maxnumstyles = MS_MAX(maxnumstyles, layer->class[shape.classindex]->numstyles);
     msFreeShape(&shape);
   }
     
@@ -1147,8 +1147,8 @@
       
     for(s=1; s<maxnumstyles; s++) {
       for(current=shpcache; current; current=current->next) {        
-        if(layer->class[current->shape.classindex].numstyles > s)
-	  msDrawLineSymbol(&map->symbolset, image, &current->shape, &(layer->class[current->shape.classindex].styles[s]), layer->scalefactor);
+        if(layer->class[current->shape.classindex]->numstyles > s)
+	  msDrawLineSymbol(&map->symbolset, image, &current->shape, &(layer->class[current->shape.classindex]->styles[s]), layer->scalefactor);
       }
     }
     
@@ -1209,25 +1209,25 @@
   if(map->querymap.style == MS_HILITE) {
     for(i=0; i<layer->numclasses; i++) {
       if(layer->type == MS_LAYER_POLYGON) { /* alter BOTTOM style since that's almost always the fill */
-        if(MS_VALID_COLOR(layer->class[i].styles[0].color)) {
-          colorbuffer[i] = layer->class[i].styles[0].color; /* save the color from the BOTTOM style */
-          layer->class[i].styles[0].color = map->querymap.color;
-        } else if(MS_VALID_COLOR(layer->class[i].styles[0].outlinecolor)) {
-          colorbuffer[i] = layer->class[i].styles[0].outlinecolor; /* if no color, save the outlinecolor from the BOTTOM style */
-          layer->class[i].styles[0].outlinecolor = map->querymap.color;
+        if(MS_VALID_COLOR(layer->class[i]->styles[0].color)) {
+          colorbuffer[i] = layer->class[i]->styles[0].color; /* save the color from the BOTTOM style */
+          layer->class[i]->styles[0].color = map->querymap.color;
+        } else if(MS_VALID_COLOR(layer->class[i]->styles[0].outlinecolor)) {
+          colorbuffer[i] = layer->class[i]->styles[0].outlinecolor; /* if no color, save the outlinecolor from the BOTTOM style */
+          layer->class[i]->styles[0].outlinecolor = map->querymap.color;
         }
       } else {
-        if(MS_VALID_COLOR(layer->class[i].styles[layer->class[i].numstyles-1].color)) {
-          colorbuffer[i] = layer->class[i].styles[layer->class[i].numstyles-1].color; /* save the color from the TOP style */
-          layer->class[i].styles[layer->class[i].numstyles-1].color = map->querymap.color;
-        } else if(MS_VALID_COLOR(layer->class[i].styles[layer->class[i].numstyles-1].outlinecolor)) {
-	  colorbuffer[i] = layer->class[i].styles[layer->class[i].numstyles-1].outlinecolor; /* if no color, save the outlinecolor from the TOP style */
-          layer->class[i].styles[layer->class[i].numstyles-1].outlinecolor = map->querymap.color;
+        if(MS_VALID_COLOR(layer->class[i]->styles[layer->class[i]->numstyles-1].color)) {
+          colorbuffer[i] = layer->class[i]->styles[layer->class[i]->numstyles-1].color; /* save the color from the TOP style */
+          layer->class[i]->styles[layer->class[i]->numstyles-1].color = map->querymap.color;
+        } else if(MS_VALID_COLOR(layer->class[i]->styles[layer->class[i]->numstyles-1].outlinecolor)) {
+	  colorbuffer[i] = layer->class[i]->styles[layer->class[i]->numstyles-1].outlinecolor; /* if no color, save the outlinecolor from the TOP style */
+          layer->class[i]->styles[layer->class[i]->numstyles-1].outlinecolor = map->querymap.color;
         }
       }
 
-      mindistancebuffer[i] = layer->class[i].label.mindistance;
-      layer->class[i].label.mindistance = MS_MAX(0, layer->class[i].label.mindistance);
+      mindistancebuffer[i] = layer->class[i]->label.mindistance;
+      layer->class[i]->label.mindistance = MS_MAX(0, layer->class[i]->label.mindistance);
     }
   }
 
@@ -1255,16 +1255,16 @@
      */
     if(shape.classindex==-1 
        || shape.classindex >= layer->numclasses
-       || layer->class[shape.classindex].status == MS_OFF) {
+       || layer->class[shape.classindex]->status == MS_OFF) {
       msFreeShape(&shape);
       continue;
     }
 
     cache = MS_FALSE;
-    if(layer->type == MS_LAYER_LINE && layer->class[shape.classindex].numstyles > 1) 
+    if(layer->type == MS_LAYER_LINE && layer->class[shape.classindex]->numstyles > 1) 
       cache = MS_TRUE; /* only line layers with multiple styles need be cached (I don't think POLYLINE layers need caching - SDL) */
 
-    if(annotate && (layer->class[shape.classindex].text.string || layer->labelitem) && layer->class[shape.classindex].label.size != -1)
+    if(annotate && (layer->class[shape.classindex]->text.string || layer->labelitem) && layer->class[shape.classindex]->label.size != -1)
       shape.text = msShapeGetAnnotation(layer, &shape);
 
     if(cache)
@@ -1285,7 +1285,7 @@
       if(insertFeatureList(&shpcache, &shape) == NULL) return(MS_FAILURE); /* problem adding to the cache */
     }
 
-    maxnumstyles = MS_MAX(maxnumstyles, layer->class[shape.classindex].numstyles);
+    maxnumstyles = MS_MAX(maxnumstyles, layer->class[shape.classindex]->numstyles);
     msFreeShape(&shape);
   }
 
@@ -1294,8 +1294,8 @@
   
     for(s=1; s<maxnumstyles; s++) {
       for(current=shpcache; current; current=current->next) {        
-        if(layer->class[current->shape.classindex].numstyles > s)
-	  msDrawLineSymbol(&map->symbolset, image, &current->shape, &(layer->class[current->shape.classindex].styles[s]), layer->scalefactor);
+        if(layer->class[current->shape.classindex]->numstyles > s)
+	  msDrawLineSymbol(&map->symbolset, image, &current->shape, &(layer->class[current->shape.classindex]->styles[s]), layer->scalefactor);
       }
     }
     
@@ -1307,18 +1307,18 @@
   if(map->querymap.style == MS_HILITE) {
     for(i=0; i<layer->numclasses; i++) {
       if(layer->type == MS_LAYER_POLYGON) {
-	if(MS_VALID_COLOR(layer->class[i].styles[0].color))
-          layer->class[i].styles[0].color = colorbuffer[i];
-        else if(MS_VALID_COLOR(layer->class[i].styles[0].outlinecolor))
-          layer->class[i].styles[0].outlinecolor = colorbuffer[i]; /* if no color, restore outlinecolor for the BOTTOM style */
+	if(MS_VALID_COLOR(layer->class[i]->styles[0].color))
+          layer->class[i]->styles[0].color = colorbuffer[i];
+        else if(MS_VALID_COLOR(layer->class[i]->styles[0].outlinecolor))
+          layer->class[i]->styles[0].outlinecolor = colorbuffer[i]; /* if no color, restore outlinecolor for the BOTTOM style */
       } else {
-        if(MS_VALID_COLOR(layer->class[i].styles[layer->class[i].numstyles-1].color))
-          layer->class[i].styles[layer->class[i].numstyles-1].color = colorbuffer[i];        
-        else if(MS_VALID_COLOR(layer->class[i].styles[layer->class[i].numstyles-1].outlinecolor))
-	  layer->class[i].styles[layer->class[i].numstyles-1].outlinecolor = colorbuffer[i]; /* if no color, restore outlinecolor for the TOP style */
+        if(MS_VALID_COLOR(layer->class[i]->styles[layer->class[i]->numstyles-1].color))
+          layer->class[i]->styles[layer->class[i]->numstyles-1].color = colorbuffer[i];        
+        else if(MS_VALID_COLOR(layer->class[i]->styles[layer->class[i]->numstyles-1].outlinecolor))
+	  layer->class[i]->styles[layer->class[i]->numstyles-1].outlinecolor = colorbuffer[i]; /* if no color, restore outlinecolor for the TOP style */
       }
     }
-    layer->class[i].label.mindistance = mindistancebuffer[i];
+    layer->class[i]->label.mindistance = mindistancebuffer[i];
   }
 
   msLayerClose(layer);
@@ -1467,17 +1467,17 @@
 /* Before we do anything else, we will check for a rangeitem.
    If its there, we need to change the style's color to map
    the range to the shape */
-  for(s=0; s<layer->class[c].numstyles; s++)
+  for(s=0; s<layer->class[c]->numstyles; s++)
     {
-      if (layer->class[c].styles[s].rangeitem !=  NULL)
-	msShapeToRange(&(layer->class[c].styles[s]), shape);
+      if (layer->class[c]->styles[s].rangeitem !=  NULL)
+	msShapeToRange(&(layer->class[c]->styles[s]), shape);
     }
   
   /* changed when Tomas added CARTOLINE symbols */
-  if(layer->class[c].styles[0].size == -1)
-      csz = MS_NINT(((msSymbolGetDefaultSize(&(map->symbolset.symbol[layer->class[c].styles[0].symbol]))) * layer->scalefactor) / 2.0);
+  if(layer->class[c]->styles[0].size == -1)
+      csz = MS_NINT(((msSymbolGetDefaultSize(&(map->symbolset.symbol[layer->class[c]->styles[0].symbol]))) * layer->scalefactor) / 2.0);
   else
-      csz = MS_NINT((layer->class[c].styles[0].size*layer->scalefactor)/2.0);
+      csz = MS_NINT((layer->class[c]->styles[0].size*layer->scalefactor)/2.0);
   cliprect.minx = map->extent.minx - csz*map->cellsize;
   cliprect.miny = map->extent.miny - csz*map->cellsize;
   cliprect.maxx = map->extent.maxx + csz*map->cellsize;
@@ -1508,10 +1508,10 @@
 
     /* shade symbol drawing will call outline function if color not set */
     if(style != -1)
-      msCircleDrawShadeSymbol(&map->symbolset, image, &center, r, &(layer->class[c].styles[style]), layer->scalefactor);
+      msCircleDrawShadeSymbol(&map->symbolset, image, &center, r, &(layer->class[c]->styles[style]), layer->scalefactor);
     else
-      for(s=0; s<layer->class[c].numstyles; s++)
-        msCircleDrawShadeSymbol(&map->symbolset, image, &center, r, &(layer->class[c].styles[s]), layer->scalefactor);
+      for(s=0; s<layer->class[c]->numstyles; s++)
+        msCircleDrawShadeSymbol(&map->symbolset, image, &center, r, &(layer->class[c]->styles[s]), layer->scalefactor);
 
     /* TO DO: need to handle circle annotation */
 
@@ -1536,15 +1536,15 @@
 	msOffsetShapeRelativeTo(shape, layer);
 
       /* Bug #1620 implementation */
-      if ( layer->class[c].label.autofollow == MS_TRUE ) {
+      if ( layer->class[c]->label.autofollow == MS_TRUE ) {
 
-        annopath = msPolylineLabelPath(shape, layer->class[c].label.minfeaturesize, &(map->fontset), shape->text, &(layer->class[c].label), layer->scalefactor, &status);
+        annopath = msPolylineLabelPath(shape, layer->class[c]->label.minfeaturesize, &(map->fontset), shape->text, &(layer->class[c]->label), layer->scalefactor, &status);
 
         if( annopath ) {
 
           labelObj label;
         
-          label = layer->class[c].label;
+          label = layer->class[c]->label;
           
           /* Label path derived from line overrides the rotation and position
              values, so ignore the specified angle and set the position to
@@ -1558,9 +1558,9 @@
           } else {
             /* FIXME: Not sure how this should work with the label path yet */
             /*
-              if(MS_VALID_COLOR(layer->class[c].styles[0].color)) {
-              for(s=0; s<layer->class[c].numstyles; s++)
-              msDrawMarkerSymbol(&map->symbolset, image, &(label_line->point[0]), &(layer->class[c].styles[s]), layer->scalefactor);
+              if(MS_VALID_COLOR(layer->class[c]->styles[0].color)) {
+              for(s=0; s<layer->class[c]->numstyles; s++)
+              msDrawMarkerSymbol(&map->symbolset, image, &(label_line->point[0]), &(layer->class[c]->styles[s]), layer->scalefactor);
               }
             */
             /* FIXME: need to call msDrawTextLineGD() from here eventually */
@@ -1574,13 +1574,13 @@
       }
 
       /* Use regular label algorithm if angle is AUTO or a number, or if ANGLE FOLLOW failed */
-      if ( layer->class[c].label.autofollow == MS_FALSE || (!annopath && status != MS_FAILURE) ) {
+      if ( layer->class[c]->label.autofollow == MS_FALSE || (!annopath && status != MS_FAILURE) ) {
 
         /* Regular labels */
-        if(msPolylineLabelPoint(shape, &annopnt, layer->class[c].label.minfeaturesize, &angle, &length) == MS_SUCCESS) {
+        if(msPolylineLabelPoint(shape, &annopnt, layer->class[c]->label.minfeaturesize, &angle, &length) == MS_SUCCESS) {
         labelObj label;
         
-        label = layer->class[c].label;
+        label = layer->class[c]->label;
           
         if(layer->labelangleitemindex != -1) label.angle = atof(shape->values[layer->labelangleitemindex]);
         if((layer->labelsizeitemindex != -1) && (label.type == MS_TRUETYPE)) label.size = atoi(shape->values[layer->labelsizeitemindex]);
@@ -1594,9 +1594,9 @@
         if(layer->labelcache) {
             if(msAddLabel(map, layer->index, c, shape->index, shape->tileindex, &annopnt, NULL, shape->text, length, &label) != MS_SUCCESS) return(MS_FAILURE);
 	} else {
-          if(MS_VALID_COLOR(layer->class[c].styles[0].color)) {
-            for(s=0; s<layer->class[c].numstyles; s++)
-              msDrawMarkerSymbol(&map->symbolset, image, &annopnt, &(layer->class[c].styles[s]), layer->scalefactor);
+          if(MS_VALID_COLOR(layer->class[c]->styles[0].color)) {
+            for(s=0; s<layer->class[c]->numstyles; s++)
+              msDrawMarkerSymbol(&map->symbolset, image, &annopnt, &(layer->class[c]->styles[s]), layer->scalefactor);
 	  }
 	  msDrawLabel(image, annopnt, shape->text, &label, &map->fontset, layer->scalefactor);
 
@@ -1614,11 +1614,11 @@
       } else
 	msOffsetShapeRelativeTo(shape, layer);
 
-      if(msPolygonLabelPoint(shape, &annopnt, layer->class[c].label.minfeaturesize) == MS_SUCCESS) {
+      if(msPolygonLabelPoint(shape, &annopnt, layer->class[c]->label.minfeaturesize) == MS_SUCCESS) {
 
         labelObj label;
         
-        label = layer->class[c].label;
+        label = layer->class[c]->label;
 
         if(layer->labelangleitemindex != -1) label.angle = atof(shape->values[layer->labelangleitemindex]);
         if((layer->labelsizeitemindex != -1) && (label.type == MS_TRUETYPE)) label.size = atoi(shape->values[layer->labelsizeitemindex]);
@@ -1629,9 +1629,9 @@
         if(layer->labelcache) {
           if(msAddLabel(map, layer->index, c, shape->index, shape->tileindex, &annopnt, NULL, shape->text, length, &label) != MS_SUCCESS) return(MS_FAILURE);
         } else {
-	  if(MS_VALID_COLOR(layer->class[c].styles[0].color)) {
-            for(s=0; s<layer->class[c].numstyles; s++)
-	      msDrawMarkerSymbol(&map->symbolset, image, &annopnt, &(layer->class[c].styles[s]), layer->scalefactor);
+	  if(MS_VALID_COLOR(layer->class[c]->styles[0].color)) {
+            for(s=0; s<layer->class[c]->numstyles; s++)
+	      msDrawMarkerSymbol(&map->symbolset, image, &annopnt, &(layer->class[c]->styles[s]), layer->scalefactor);
 	  }
 	  msDrawLabel(image, annopnt, shape->text, &label, &map->fontset, layer->scalefactor);
         }
@@ -1652,7 +1652,7 @@
 	  } else
             msOffsetPointRelativeTo(point, layer);
 
-          label = layer->class[c].label;
+          label = layer->class[c]->label;
 
 	  if(layer->labelangleitemindex != -1) 
               label.angle = atof(shape->values[layer->labelangleitemindex]);
@@ -1666,9 +1666,9 @@
 	    if(layer->labelcache) {
 	      if(msAddLabel(map, layer->index, c, shape->index, shape->tileindex, point, NULL, shape->text, -1, &label) != MS_SUCCESS) return(MS_FAILURE);
 	    } else {
-	      if(MS_VALID_COLOR(layer->class[c].styles[0].color)) {
-                for(s=0; s<layer->class[c].numstyles; s++)
-	          msDrawMarkerSymbol(&map->symbolset, image, point, &(layer->class[c].styles[s]), layer->scalefactor);
+	      if(MS_VALID_COLOR(layer->class[c]->styles[0].color)) {
+                for(s=0; s<layer->class[c]->numstyles; s++)
+	          msDrawMarkerSymbol(&map->symbolset, image, point, &(layer->class[c]->styles[s]), layer->scalefactor);
 	      }
 	      msDrawLabel(image, *point, shape->text, &label, &map->fontset, layer->scalefactor);
 	    }
@@ -1699,16 +1699,16 @@
 	} else
           msOffsetPointRelativeTo(point, layer);
 
-	for(s=0; s<layer->class[c].numstyles; s++) {
-	  if(layer->class[c].styles[s].angleitemindex != -1) layer->class[c].styles[s].angle = atof(shape->values[layer->class[c].styles[s].angleitemindex]);
-	  if(layer->class[c].styles[s].sizeitemindex != -1) layer->class[c].styles[s].size = atoi(shape->values[layer->class[c].styles[s].sizeitemindex]);      
-  	  msDrawMarkerSymbol(&map->symbolset, image, point, &(layer->class[c].styles[s]), layer->scalefactor);
+	for(s=0; s<layer->class[c]->numstyles; s++) {
+	  if(layer->class[c]->styles[s].angleitemindex != -1) layer->class[c]->styles[s].angle = atof(shape->values[layer->class[c]->styles[s].angleitemindex]);
+	  if(layer->class[c]->styles[s].sizeitemindex != -1) layer->class[c]->styles[s].size = atoi(shape->values[layer->class[c]->styles[s].sizeitemindex]);      
+  	  msDrawMarkerSymbol(&map->symbolset, image, point, &(layer->class[c]->styles[s]), layer->scalefactor);
 	}
 
 	if(shape->text) {
           labelObj label;
 
-          label = layer->class[c].label;
+          label = layer->class[c]->label;
 
 	  if(layer->labelangleitemindex != -1) label.angle = atof(shape->values[layer->labelangleitemindex]);
 	  if((layer->labelsizeitemindex != -1) && (label.type == MS_TRUETYPE)) label.size = atoi(shape->values[layer->labelsizeitemindex]);
@@ -1746,28 +1746,28 @@
       msOffsetShapeRelativeTo(shape, layer);
  
     if(style != -1) {
-      if(layer->class[c].styles[style].angleitemindex != -1) layer->class[c].styles[style].angle = atof(shape->values[layer->class[c].styles[style].angleitemindex]);
-      if(layer->class[c].styles[style].sizeitemindex != -1) layer->class[c].styles[style].size = atoi(shape->values[layer->class[c].styles[style].sizeitemindex]);
-      msDrawLineSymbol(&map->symbolset, image, shape, &(layer->class[c].styles[style]), layer->scalefactor);
+      if(layer->class[c]->styles[style].angleitemindex != -1) layer->class[c]->styles[style].angle = atof(shape->values[layer->class[c]->styles[style].angleitemindex]);
+      if(layer->class[c]->styles[style].sizeitemindex != -1) layer->class[c]->styles[style].size = atoi(shape->values[layer->class[c]->styles[style].sizeitemindex]);
+      msDrawLineSymbol(&map->symbolset, image, shape, &(layer->class[c]->styles[style]), layer->scalefactor);
     } else {
-      for(s=0; s<layer->class[c].numstyles; s++) {
-        if(layer->class[c].styles[s].angleitemindex != -1) layer->class[c].styles[s].angle = atof(shape->values[layer->class[c].styles[s].angleitemindex]);
-        if(layer->class[c].styles[s].sizeitemindex != -1) layer->class[c].styles[s].size = atoi(shape->values[layer->class[c].styles[s].sizeitemindex]);
-        msDrawLineSymbol(&map->symbolset, image, shape, &(layer->class[c].styles[s]), layer->scalefactor);
+      for(s=0; s<layer->class[c]->numstyles; s++) {
+        if(layer->class[c]->styles[s].angleitemindex != -1) layer->class[c]->styles[s].angle = atof(shape->values[layer->class[c]->styles[s].angleitemindex]);
+        if(layer->class[c]->styles[s].sizeitemindex != -1) layer->class[c]->styles[s].size = atoi(shape->values[layer->class[c]->styles[s].sizeitemindex]);
+        msDrawLineSymbol(&map->symbolset, image, shape, &(layer->class[c]->styles[s]), layer->scalefactor);
       }
     }
 
     if(shape->text) {
 
       /* Bug #1620 implementation */
-      if ( layer->class[c].label.autofollow == MS_TRUE ) {
+      if ( layer->class[c]->label.autofollow == MS_TRUE ) {
 
-        annopath = msPolylineLabelPath(shape, layer->class[c].label.minfeaturesize, &(map->fontset), shape->text, &(layer->class[c].label), layer->scalefactor, &status);
+        annopath = msPolylineLabelPath(shape, layer->class[c]->label.minfeaturesize, &(map->fontset), shape->text, &(layer->class[c]->label), layer->scalefactor, &status);
         if( annopath ) {
 
           labelObj label;
 
-          label = layer->class[c].label;
+          label = layer->class[c]->label;
           /* Label path derived from line overrides the rotation and position
              values, so ignore the specified angle and set the position to
              auto. */
@@ -1789,10 +1789,10 @@
       }
 
       /* Use regular label algorithm if angle is AUTO or a number, or if ANGLE FOLLOW failed */
-      if ( layer->class[c].label.autofollow == MS_FALSE || (!annopath && status != MS_FAILURE) ) {
+      if ( layer->class[c]->label.autofollow == MS_FALSE || (!annopath && status != MS_FAILURE) ) {
 
-      if(msPolylineLabelPoint(shape, &annopnt, layer->class[c].label.minfeaturesize, &angle, &length) == MS_SUCCESS) {
-        labelObj label = layer->class[c].label;
+      if(msPolylineLabelPoint(shape, &annopnt, layer->class[c]->label.minfeaturesize, &angle, &length) == MS_SUCCESS) {
+        labelObj label = layer->class[c]->label;
 
 	if(layer->labelangleitemindex != -1) 
             label.angle = atof(shape->values[layer->labelangleitemindex]);
@@ -1852,15 +1852,15 @@
     } else
       msOffsetShapeRelativeTo(shape, layer);
  
-    for(s=0; s<layer->class[c].numstyles; s++) {
-      if(layer->class[c].styles[s].angleitemindex != -1) layer->class[c].styles[s].angle = atof(shape->values[layer->class[c].styles[s].angleitemindex]);
-      if(layer->class[c].styles[s].sizeitemindex != -1) layer->class[c].styles[s].size = atoi(shape->values[layer->class[c].styles[s].sizeitemindex]);
-      msDrawShadeSymbol(&map->symbolset, image, shape, &(layer->class[c].styles[s]), layer->scalefactor);
+    for(s=0; s<layer->class[c]->numstyles; s++) {
+      if(layer->class[c]->styles[s].angleitemindex != -1) layer->class[c]->styles[s].angle = atof(shape->values[layer->class[c]->styles[s].angleitemindex]);
+      if(layer->class[c]->styles[s].sizeitemindex != -1) layer->class[c]->styles[s].size = atoi(shape->values[layer->class[c]->styles[s].sizeitemindex]);
+      msDrawShadeSymbol(&map->symbolset, image, shape, &(layer->class[c]->styles[s]), layer->scalefactor);
     }    
 
     if(shape->text) {
-      if(msPolygonLabelPoint(shape, &annopnt, layer->class[c].label.minfeaturesize) == MS_SUCCESS) {	
-        labelObj label = layer->class[c].label;
+      if(msPolygonLabelPoint(shape, &annopnt, layer->class[c]->label.minfeaturesize) == MS_SUCCESS) {	
+        labelObj label = layer->class[c]->label;
 
 	if(layer->labelangleitemindex != -1) 
             label.angle = atof(shape->values[layer->labelangleitemindex]);
@@ -1917,11 +1917,11 @@
       if(layer->labelcache) {
         if(msAddLabel(map, layer->index, c, -1, -1, point, NULL, labeltext, -1,NULL) != MS_SUCCESS) return(MS_FAILURE);
       } else {
-	if(MS_VALID_COLOR(layer->class[c].styles[0].color)) {
-          for(s=0; s<layer->class[c].numstyles; s++)
-  	    msDrawMarkerSymbol(&map->symbolset, image, point, &(layer->class[c].styles[s]), layer->scalefactor);
+	if(MS_VALID_COLOR(layer->class[c]->styles[0].color)) {
+          for(s=0; s<layer->class[c]->numstyles; s++)
+  	    msDrawMarkerSymbol(&map->symbolset, image, point, &(layer->class[c]->styles[s]), layer->scalefactor);
 	}
-	msDrawLabel(image, *point, labeltext, &layer->class[c].label, &map->fontset, layer->scalefactor);
+	msDrawLabel(image, *point, labeltext, &layer->class[c]->label, &map->fontset, layer->scalefactor);
       }
     }
     break;
@@ -1934,14 +1934,14 @@
     } else
       msOffsetPointRelativeTo(point, layer);
 
-    for(s=0; s<layer->class[c].numstyles; s++)
-      msDrawMarkerSymbol(&map->symbolset, image, point, &(layer->class[c].styles[s]), layer->scalefactor);
+    for(s=0; s<layer->class[c]->numstyles; s++)
+      msDrawMarkerSymbol(&map->symbolset, image, point, &(layer->class[c]->styles[s]), layer->scalefactor);
 
     if(labeltext) {
       if(layer->labelcache) {
         if(msAddLabel(map, layer->index, c, -1, -1, point, NULL, labeltext, -1,NULL) != MS_SUCCESS) return(MS_FAILURE);
       } else
-	msDrawLabel(image, *point, labeltext, &layer->class[c].label, &map->fontset, layer->scalefactor);
+	msDrawLabel(image, *point, labeltext, &layer->class[c]->label, &map->fontset, layer->scalefactor);
     }
     break;
   default:
diff -U3 -N -r mapserver-classes/mapdrawgdal.c mapserver-beforeclasses/mapdrawgdal.c
--- mapserver-classes/mapdrawgdal.c	2007-03-06 12:22:39.000000000 +0100
+++ mapserver-beforeclasses/mapdrawgdal.c	2007-03-08 18:27:38.000000000 +0100
@@ -453,17 +453,17 @@
       int s;
 
       /* change colour based on colour range? */
-      for(s=0; s<layer->class[i].numstyles; s++)
+      for(s=0; s<layer->class[i]->numstyles; s++)
       {
-          if( MS_VALID_COLOR(layer->class[i].styles[s].mincolor)
-              && MS_VALID_COLOR(layer->class[i].styles[s].maxcolor) )
+          if( MS_VALID_COLOR(layer->class[i]->styles[s].mincolor)
+              && MS_VALID_COLOR(layer->class[i]->styles[s].maxcolor) )
           {
               classified = TRUE;
               break;
           }
       }
       
-      if( layer->class[i].expression.string != NULL )
+      if( layer->class[i]->expression.string != NULL )
       {
           classified = TRUE;
           break;
@@ -572,7 +572,7 @@
   {
       int iClass;
       for( iClass = 0; iClass < layer->numclasses; iClass++ )
-          layer->class[iClass].styles[0].color.pen = MS_PEN_UNSET;
+          layer->class[iClass]->styles[0].color.pen = MS_PEN_UNSET;
   }
 
   /*
@@ -712,21 +712,21 @@
                 /* change colour based on colour range?  Currently we 
                    only address the greyscale case properly. */
 
-                for(s=0; s<layer->class[c].numstyles; s++)
+                for(s=0; s<layer->class[c]->numstyles; s++)
                 {
-                    if( MS_VALID_COLOR(layer->class[c].styles[s].mincolor)
-                        && MS_VALID_COLOR(layer->class[c].styles[s].maxcolor) )
-                        msValueToRange(&layer->class[c].styles[s],
+                    if( MS_VALID_COLOR(layer->class[c]->styles[s].mincolor)
+                        && MS_VALID_COLOR(layer->class[c]->styles[s].maxcolor) )
+                        msValueToRange(&layer->class[c]->styles[s],
                                        sEntry.c1 );
                 }
 
-                RESOLVE_PEN_GD(gdImg, layer->class[c].styles[0].color);
-                if( MS_TRANSPARENT_COLOR(layer->class[c].styles[0].color) )
+                RESOLVE_PEN_GD(gdImg, layer->class[c]->styles[0].color);
+                if( MS_TRANSPARENT_COLOR(layer->class[c]->styles[0].color) )
                     cmap[i] = -1;
-                else if( MS_VALID_COLOR(layer->class[c].styles[0].color))
+                else if( MS_VALID_COLOR(layer->class[c]->styles[0].color))
                 {
                     /* use class color */
-                    cmap[i] = layer->class[c].styles[0].color.pen;
+                    cmap[i] = layer->class[c]->styles[0].color.pen;
                 }
                 else /* Use raster color */
                     cmap[i] = msAddColorGD(map, gdImg, cmt,
@@ -2115,20 +2115,20 @@
             int s;
 
             /* change colour based on colour range? */
-            for(s=0; s<layer->class[c].numstyles; s++)
+            for(s=0; s<layer->class[c]->numstyles; s++)
             {
-                if( MS_VALID_COLOR(layer->class[c].styles[s].mincolor)
-                    && MS_VALID_COLOR(layer->class[c].styles[s].maxcolor) )
-                    msValueToRange(&layer->class[c].styles[s],dfOriginalValue);
+                if( MS_VALID_COLOR(layer->class[c]->styles[s].mincolor)
+                    && MS_VALID_COLOR(layer->class[c]->styles[s].maxcolor) )
+                    msValueToRange(&layer->class[c]->styles[s],dfOriginalValue);
             }
 
-            RESOLVE_PEN_GD(gdImg, layer->class[c].styles[0].color);
-            if( MS_TRANSPARENT_COLOR(layer->class[c].styles[0].color) )
+            RESOLVE_PEN_GD(gdImg, layer->class[c]->styles[0].color);
+            if( MS_TRANSPARENT_COLOR(layer->class[c]->styles[0].color) )
                 cmap[i] = -1;
-            else if( MS_VALID_COLOR(layer->class[c].styles[0].color))
+            else if( MS_VALID_COLOR(layer->class[c]->styles[0].color))
             {
                 /* use class color */
-                cmap[i] = layer->class[c].styles[0].color.pen;
+                cmap[i] = layer->class[c]->styles[0].color.pen;
             }
         }
     }
diff -U3 -N -r mapserver-classes/mapfile.c mapserver-beforeclasses/mapfile.c
--- mapserver-classes/mapfile.c	2007-03-13 15:33:56.000000000 +0100
+++ mapserver-beforeclasses/mapfile.c	2007-03-11 20:04:14.000000000 +0100
@@ -2040,6 +2040,7 @@
 
   class->status = MS_ON;
   class->debug = MS_OFF;
+  MS_REFCNT_INIT(class);
 
   initExpression(&(class->expression));
   class->name = NULL;
@@ -2071,10 +2072,12 @@
   return(0);
 }
 
-void freeClass(classObj *class)
+int freeClass(classObj *class)
 {
   int i;
 
+  if( MS_REFCNT_IS_NOT_ZERO(class) ) { return MS_FAILURE; }
+
   freeLabel(&(class->label));
   freeExpression(&(class->expression));
   freeExpression(&(class->text));
@@ -2085,10 +2088,12 @@
   if (&(class->metadata)) msFreeHashItems(&(class->metadata));
   
   
-  for(i=0;i<class->numstyles;i++) /* each style     */
+  /*for(i=0;i<class->numstyles;i++) LEAK: we should free MS_MAXSTYLES!!! */
+  for(i=0;i<MS_MAXSTYLES;i++) /* each style     */
     freeStyle(&(class->styles[i]));
   msFree(class->styles);
   msFree(class->keyimage);
+  return MS_SUCCESS;
 }
 
 /*
@@ -2440,6 +2445,7 @@
 */
 int initLayer(layerObj *layer, mapObj *map)
 {
+  int i=0;
   if (layer==NULL) {
     msSetError(MS_MEMERR, "Layer is null", "initLayer()");
     return(-1);
@@ -2448,10 +2454,13 @@
   MS_REFCNT_INIT(layer);
 
   layer->numclasses = 0;
-  if((layer->class = (classObj *)malloc(sizeof(classObj)*MS_MAXCLASSES)) == NULL) {
+  if((layer->class = (classObj **)malloc(sizeof(classObj*)*MS_MAXCLASSES)) == NULL) {
     msSetError(MS_MEMERR, NULL, "initLayer()");
     return(-1);
   }
+  for (i=0;i<MS_MAXCLASSES;i++) {
+  	layer->class[i]=NULL;
+  }
   
   layer->name = NULL;
   layer->group = NULL;
@@ -2582,8 +2591,15 @@
 
   msFreeProjection(&(layer->projection));
 
-  for(i=0;i<layer->numclasses;i++)
-    freeClass(&(layer->class[i]));
+  /*for(i=0;i<layer->numclasses;i++) {*/
+  for(i=0;i<MS_MAXCLASSES;i++) {
+    if (layer->class[i] != NULL) {
+    	layer->class[i]->layer=NULL;
+    	if ( freeClass(layer->class[i]) == MS_SUCCESS ) {
+		msFree(layer->class[i]);
+	}
+    }
+  }
   msFree(layer->class);
 
   if(layer->features)
@@ -2630,9 +2646,14 @@
 	msSetError(MS_IDENTERR, "Maximum number of classes reached.", "loadLayer()");
 	return(-1);
       }
-
-      if(loadClass(&(layer->class[layer->numclasses]), map, layer) == -1) return(-1);
-      if(layer->class[layer->numclasses].type == -1) layer->class[layer->numclasses].type = layer->type;
+      layer->class[layer->numclasses]=(classObj*)malloc(sizeof(classObj));
+      if (layer->class[layer->numclasses]==NULL) {
+	  msSetError(MS_MEMERR, NULL, "loadLayer()");
+	  return(-1);
+      }
+      initClass(layer->class[layer->numclasses]);
+      if(loadClass(layer->class[layer->numclasses], map, layer) == -1) return(-1);
+      if(layer->class[layer->numclasses]->type == -1) layer->class[layer->numclasses]->type = layer->type;
       layer->numclasses++;
       break;
     case(CLASSITEM):
@@ -2870,7 +2891,7 @@
       if((i < 0) || (i >= layer->numclasses))
         break;
     }
-    loadClassString(map, &(layer->class[i]), value, layer->type);
+    loadClassString(map, layer->class[i], value, layer->type);
     break;
   case(CLASSITEM):
     msFree(layer->classitem);
@@ -3092,10 +3113,10 @@
     break;
   case(MS_STRING):    
     for(i=0;i<layer->numclasses; i++) {
-      if(!layer->class[i].name) /* skip it */
+      if(!layer->class[i]->name) /* skip it */
 	continue;
-      if(strcmp(msyytext, layer->class[i].name) == 0) {	
-	loadClassString(map, &(layer->class[i]), value, layer->type);
+      if(strcmp(msyytext, layer->class[i]->name) == 0) {	
+	loadClassString(map, layer->class[i], value, layer->type);
 	break;
       }
     }
@@ -3243,7 +3264,7 @@
   fprintf(stream, "    UNITS %s\n", msUnits[layer->units]);
 
   /* write potentially multiply occuring features last */
-  for(i=0; i<layer->numclasses; i++) writeClass(&(layer->class[i]), stream);
+  for(i=0; i<layer->numclasses; i++) writeClass(layer->class[i], stream);
 
   if( layer->layerinfo &&  layer->connectiontype == MS_GRATICULE)
     writeGrid( (graticuleObj *) layer->layerinfo, stream );
@@ -4676,10 +4697,10 @@
       /* step through layers and classes to resolve symbol names */
       for(i=0; i<map->numlayers; i++) {
         for(j=0; j<GET_LAYER(map, i)->numclasses; j++){
-	  for(k=0; k<GET_LAYER(map, i)->class[j].numstyles; k++) {
-            if(GET_LAYER(map, i)->class[j].styles[k].symbolname) {
-              if((GET_LAYER(map, i)->class[j].styles[k].symbol =  msGetSymbolIndex(&(map->symbolset), GET_LAYER(map, i)->class[j].styles[k].symbolname, MS_TRUE)) == -1) {
-                msSetError(MS_MISCERR, "Undefined overlay symbol \"%s\" in class %d, style %d of layer %s.", "msLoadMap()", GET_LAYER(map, i)->class[j].styles[k].symbolname, j, k, GET_LAYER(map, i)->name);
+	  for(k=0; k<GET_LAYER(map, i)->class[j]->numstyles; k++) {
+            if(GET_LAYER(map, i)->class[j]->styles[k].symbolname) {
+              if((GET_LAYER(map, i)->class[j]->styles[k].symbol =  msGetSymbolIndex(&(map->symbolset), GET_LAYER(map, i)->class[j]->styles[k].symbolname, MS_TRUE)) == -1) {
+                msSetError(MS_MISCERR, "Undefined overlay symbol \"%s\" in class %d, style %d of layer %s.", "msLoadMap()", GET_LAYER(map, i)->class[j]->styles[k].symbolname, j, k, GET_LAYER(map, i)->name);
                 return(NULL);
               }
             }
diff -U3 -N -r mapserver-classes/mapgd.c mapserver-beforeclasses/mapgd.c
--- mapserver-classes/mapgd.c	2007-03-13 15:33:56.000000000 +0100
+++ mapserver-beforeclasses/mapgd.c	2007-03-11 10:54:29.000000000 +0100
@@ -187,7 +187,7 @@
     lp = (GET_LAYER(map, i));
     if(lp->status == MS_ON || lp->status == MS_DEFAULT) {
       for(j=0; j<lp->numclasses; j++) {
-        cp = &(lp->class[j]);
+        cp = lp->class[j];
 	msImageSetPenGD(image->img.gd, &(cp->label.backgroundcolor));
 	msImageSetPenGD(image->img.gd, &(cp->label.backgroundshadowcolor));
 	msImageSetPenGD(image->img.gd, &(cp->label.color)); 
diff -U3 -N -r mapserver-classes/mapgraticule.c mapserver-beforeclasses/mapgraticule.c
--- mapserver-classes/mapgraticule.c	2007-03-13 15:33:56.000000000 +0100
+++ mapserver-beforeclasses/mapgraticule.c	2007-03-11 10:55:42.000000000 +0100
@@ -128,7 +128,7 @@
   pInfo->dwhichlongitude = -180.0;
   pInfo->bvertical = 1;
   
-  if( layer->class->label.size == -1 )
+  if( layer->class[0]->label.size == -1 )
     pInfo->blabelaxes = 0;
   else
     pInfo->blabelaxes = 1;
@@ -703,7 +703,7 @@
     if( pLayer->transform ) 
 		msTransformShapeToPixel( pShape, pLayer->map->extent, pLayer->map->cellsize );
 
-	if (msGetLabelSize( pShape->text, &pLayer->class[0].label, &rectLabel, &pLayer->map->fontset, 1.0, MS_FALSE) != 0)
+	if (msGetLabelSize( pShape->text, &pLayer->class[0]->label, &rectLabel, &pLayer->map->fontset, 1.0, MS_FALSE) != 0)
         return MS_FAILURE;  /* msSetError already called */
 
 	switch( ePosition )
diff -U3 -N -r mapserver-classes/map.h mapserver-beforeclasses/map.h
--- mapserver-classes/map.h	2007-03-13 15:33:56.000000000 +0100
+++ mapserver-beforeclasses/map.h	2007-03-11 19:05:40.000000000 +0100
@@ -413,7 +413,7 @@
 
 #define GET_LAYER(map, pos) map->layers[pos]
 #define MS_REFCNT_INCR(obj) obj->refcount++
-#define MS_REFCNT_DECR(obj) obj->refcount--
+#define MS_REFCNT_DECR(obj) --(obj->refcount)
 #define MS_REFCNT_INIT(obj) obj->refcount=1
 #define MS_REFCNT_IS_NOT_ZERO(obj) (MS_REFCNT_DECR(obj))>0
 #define MS_REFCNT_IS_ZERO(obj) (MS_REFCNT_DECR(obj))<=0
@@ -781,6 +781,7 @@
 #ifdef SWIG
 %immutable;
 #endif /* SWIG */
+  int refcount;
   struct layer_obj *layer;
 #ifdef SWIG
 %mutable;
@@ -1001,7 +1002,7 @@
   int annotate; /* boolean flag for annotation */
   double scalefactor; /* computed, not set */
 #ifndef __cplusplus
-  classObj *class; /* always at least 1 class */
+  classObj **class; /* always at least 1 class */
 #else /* __cplusplus */
   classObj *_class;
 #endif /* __cplusplus */
@@ -1370,7 +1371,7 @@
 MS_DLL_EXPORT int initLayer(layerObj *layer, mapObj *map);
 MS_DLL_EXPORT int freeLayer( layerObj * );
 MS_DLL_EXPORT int initClass(classObj *_class);
-MS_DLL_EXPORT void freeClass( classObj * );
+MS_DLL_EXPORT int freeClass( classObj * );
 MS_DLL_EXPORT void initLabel(labelObj *label);
 MS_DLL_EXPORT void resetClassStyle(classObj *_class);
 MS_DLL_EXPORT int initStyle(styleObj *style);
diff -U3 -N -r mapserver-classes/maplabel.c mapserver-beforeclasses/maplabel.c
--- mapserver-classes/maplabel.c	2007-03-13 15:33:56.000000000 +0100
+++ mapserver-beforeclasses/maplabel.c	2007-03-11 10:49:58.000000000 +0100
@@ -106,7 +106,7 @@
 
   cachePtr = &(map->labelcache.labels[map->labelcache.numlabels]); /* set up a few pointers for clarity */
   layerPtr = (GET_LAYER(map, layerindex));
-  classPtr = &(GET_LAYER(map, layerindex)->class[classindex]);
+  classPtr = GET_LAYER(map, layerindex)->class[classindex];
 
   if( label == NULL )
       label = &(classPtr->label);
diff -U3 -N -r mapserver-classes/maplayer.c mapserver-beforeclasses/maplayer.c
--- mapserver-classes/maplayer.c	2006-08-22 15:56:58.000000000 +0200
+++ mapserver-beforeclasses/maplayer.c	2007-03-13 16:53:49.000000000 +0100
@@ -27,6 +27,9 @@
  ******************************************************************************
  *
  * $Log: maplayer.c,v $
+ * Revision 1.113  2007/03/09 15:58:53  sdlime
+ * Cleaned up comment for msLayerWhichItems, removed any tabs in that function too.
+ *
  * Revision 1.112  2006/08/22 13:56:58  hobu
  * ssh!  comment out "tile;" which was unused and
  * causing compiler to complain
@@ -91,7 +94,7 @@
 #include "mapogcfilter.h"
 
 #include <assert.h>
-MS_CVSID("$Id: maplayer.c,v 1.112 2006/08/22 13:56:58 hobu Exp $")
+MS_CVSID("$Id: maplayer.c,v 1.113 2007/03/09 15:58:53 sdlime Exp $")
 
 
 static int populateVirtualTable(layerVTableObj *vtable);
@@ -412,20 +415,18 @@
 /*
 ** This function builds a list of items necessary to draw or query a particular layer by
 ** examining the contents of the various xxxxitem parameters and expressions. That list is
-** then used to set the iteminfo variable. SDE is kinda special, we always need to retrieve
-** the shape column and a virtual record number column. Most sources should not have to 
-** modify this function.
+** then used to set the iteminfo variable. 
 */
 int msLayerWhichItems(layerObj *layer, int classify, int annotate, char *metadata) 
 {
   int i, j, rv;
   int nt=0, ne=0;
 
-  if ( ! layer->vtable) {
-      rv =  msInitializeVirtualTable(layer);
-      if (rv != MS_SUCCESS) {
-            return rv;
-      }
+  if (!layer->vtable) {
+    rv =  msInitializeVirtualTable(layer);
+    if (rv != MS_SUCCESS) {
+      return rv;
+    }
   }
 
   /*  */
@@ -452,10 +453,10 @@
     if(layer->filteritem) nt++;
 
     for(i=0; i<layer->numclasses; i++) {
-      for(j=0; j<layer->class[i].numstyles; j++) {
-        if(layer->class[i].styles[j].angleitem) nt++;
-	if(layer->class[i].styles[j].sizeitem) nt++;
-	if(layer->class[i].styles[j].rangeitem) nt++;
+      for(j=0; j<layer->class[i]->numstyles; j++) {
+        if(layer->class[i]->styles[j].angleitem) nt++;
+	if(layer->class[i]->styles[j].sizeitem) nt++;
+	if(layer->class[i]->styles[j].rangeitem) nt++;
       }
     }
 
@@ -463,18 +464,18 @@
     if(layer->filter.type == MS_EXPRESSION) {
       ne = countChars(layer->filter.string, '[');
       if(ne > 0) {
-	layer->filter.items = (char **)calloc(ne, sizeof(char *)); /* should be more than enough space */
-	if(!(layer->filter.items)) {
-	  msSetError(MS_MEMERR, NULL, "msLayerWhichItems()");
-	  return(MS_FAILURE);
-	}
-	layer->filter.indexes = (int *)malloc(ne*sizeof(int));
-	if(!(layer->filter.indexes)) {
-	  msSetError(MS_MEMERR, NULL, "msLayerWhichItems()");
-	  return(MS_FAILURE);
-	}
-	layer->filter.numitems = 0;
-	nt += ne;
+	      layer->filter.items = (char **)calloc(ne, sizeof(char *)); /* should be more than enough space */
+        if(!(layer->filter.items)) {
+          msSetError(MS_MEMERR, NULL, "msLayerWhichItems()");
+          return(MS_FAILURE);
+        }
+        layer->filter.indexes = (int *)malloc(ne*sizeof(int));
+        if(!(layer->filter.indexes)) {
+          msSetError(MS_MEMERR, NULL, "msLayerWhichItems()");
+          return(MS_FAILURE);
+        }
+        layer->filter.numitems = 0;
+        nt += ne;
       }
     }
   }
@@ -487,39 +488,39 @@
 
   for(i=0; i<layer->numclasses; i++) {
     ne = 0;
-    if(classify && layer->class[i].expression.type == MS_EXPRESSION) { 
-      ne = countChars(layer->class[i].expression.string, '[');
+    if(classify && layer->class[i]->expression.type == MS_EXPRESSION) { 
+      ne = countChars(layer->class[i]->expression.string, '[');
       if(ne > 0) {
-	layer->class[i].expression.items = (char **)calloc(ne, sizeof(char *)); /* should be more than enough space */
-	if(!(layer->class[i].expression.items)) {
+	layer->class[i]->expression.items = (char **)calloc(ne, sizeof(char *)); /* should be more than enough space */
+	if(!(layer->class[i]->expression.items)) {
 	  msSetError(MS_MEMERR, NULL, "msLayerWhichItems()");
 	  return(MS_FAILURE);
 	}
-	layer->class[i].expression.indexes = (int *)malloc(ne*sizeof(int));
-	if(!(layer->class[i].expression.indexes)) {
+	layer->class[i]->expression.indexes = (int *)malloc(ne*sizeof(int));
+	if(!(layer->class[i]->expression.indexes)) {
 	  msSetError(MS_MEMERR, NULL, "msLayerWhichItems()");
 	  return(MS_FAILURE);
 	}
-	layer->class[i].expression.numitems = 0;
+	layer->class[i]->expression.numitems = 0;
 	nt += ne;
       }
     }
 
     ne = 0;
-    if(annotate && layer->class[i].text.type == MS_EXPRESSION) { 
-      ne = countChars(layer->class[i].text.string, '[');
+    if(annotate && layer->class[i]->text.type == MS_EXPRESSION) { 
+      ne = countChars(layer->class[i]->text.string, '[');
       if(ne > 0) {
-	layer->class[i].text.items = (char **)calloc(ne, sizeof(char *)); /* should be more than enough space */
-	if(!(layer->class[i].text.items)) {
+	layer->class[i]->text.items = (char **)calloc(ne, sizeof(char *)); /* should be more than enough space */
+	if(!(layer->class[i]->text.items)) {
 	  msSetError(MS_MEMERR, NULL, "msLayerWhichItems()");
 	  return(MS_FAILURE);
 	}
-	layer->class[i].text.indexes = (int *)malloc(ne*sizeof(int));
-	if(!(layer->class[i].text.indexes)) {
+	layer->class[i]->text.indexes = (int *)malloc(ne*sizeof(int));
+	if(!(layer->class[i]->text.indexes)) {
 	  msSetError(MS_MEMERR, NULL, "msLayerWhichItems()");
 	  return(MS_FAILURE);
 	}
-	layer->class[i].text.numitems = 0;
+	layer->class[i]->text.numitems = 0;
 	nt += ne;
       }
     }
@@ -527,7 +528,7 @@
 
   rv = layer->vtable->LayerCreateItems(layer, nt);
   if (rv != MS_SUCCESS) {
-      return rv;
+    return rv;
   }
 
   if(nt > 0) {
@@ -536,10 +537,10 @@
       if(layer->filteritem) layer->filteritemindex = string2list(layer->items, &(layer->numitems), layer->filteritem);
 
       for(i=0; i<layer->numclasses; i++) {
-	for(j=0; j<layer->class[i].numstyles; j++) {
-	  if(layer->class[i].styles[j].angleitem) layer->class[i].styles[j].angleitemindex = string2list(layer->items, &(layer->numitems), layer->class[i].styles[j].angleitem);
-	  if(layer->class[i].styles[j].sizeitem) layer->class[i].styles[j].sizeitemindex = string2list(layer->items, &(layer->numitems), layer->class[i].styles[j].sizeitem); 
-	  if(layer->class[i].styles[j].rangeitem) layer->class[i].styles[j].rangeitemindex = string2list(layer->items, &(layer->numitems), layer->class[i].styles[j].rangeitem); 
+	for(j=0; j<layer->class[i]->numstyles; j++) {
+	  if(layer->class[i]->styles[j].angleitem) layer->class[i]->styles[j].angleitemindex = string2list(layer->items, &(layer->numitems), layer->class[i]->styles[j].angleitem);
+	  if(layer->class[i]->styles[j].sizeitem) layer->class[i]->styles[j].sizeitemindex = string2list(layer->items, &(layer->numitems), layer->class[i]->styles[j].sizeitem); 
+	  if(layer->class[i]->styles[j].rangeitem) layer->class[i]->styles[j].rangeitemindex = string2list(layer->items, &(layer->numitems), layer->class[i]->styles[j].rangeitem); 
 	}
       }
 
@@ -552,8 +553,8 @@
     }  
 
     for(i=0; i<layer->numclasses; i++) {
-      if(classify && layer->class[i].expression.type == MS_EXPRESSION) expression2list(layer->items, &(layer->numitems), &(layer->class[i].expression));
-      if(annotate && layer->class[i].text.type == MS_EXPRESSION) expression2list(layer->items, &(layer->numitems), &(layer->class[i].text));
+      if(classify && layer->class[i]->expression.type == MS_EXPRESSION) expression2list(layer->items, &(layer->numitems), &(layer->class[i]->expression));
+      if(annotate && layer->class[i]->text.type == MS_EXPRESSION) expression2list(layer->items, &(layer->numitems), &(layer->class[i]->text));
     }
   }
 
diff -U3 -N -r mapserver-classes/maplegend.c mapserver-beforeclasses/maplegend.c
--- mapserver-classes/maplegend.c	2007-03-13 15:33:56.000000000 +0100
+++ mapserver-beforeclasses/maplegend.c	2007-03-11 10:47:24.000000000 +0100
@@ -249,7 +249,7 @@
       msDrawLegendIcon(map, lp, class, width, height, image->img.gd, 0, 0);
     } else {
       for (i=0; i<lp->numclasses; i++) {
-        msDrawLegendIcon(map, lp, &lp->class[i], width, height, image->img.gd, 0, 0);
+        msDrawLegendIcon(map, lp, lp->class[i], width, height, image->img.gd, 0, 0);
       }
     }
   }
@@ -300,7 +300,7 @@
       continue;
 
     for(j=0;j<lp->numclasses;j++) {
-      if(!lp->class[j].name) continue; /* skip it */
+      if(!lp->class[j]->name) continue; /* skip it */
       n++;
     }
   }
@@ -326,17 +326,17 @@
     }
  
     for(j=0;j<lp->numclasses;j++) {
-      if(!lp->class[j].name)
+      if(!lp->class[j]->name)
 	continue; /* skip it */
 
       if(!scale_independent && map->scale > 0) {  /* verify class scale here */
-	if((lp->class[j].maxscale > 0) && (map->scale > lp->class[j].maxscale))
+	if((lp->class[j]->maxscale > 0) && (map->scale > lp->class[j]->maxscale))
 	  continue;
-	if((lp->class[j].minscale > 0) && (map->scale <= lp->class[j].minscale))
+	if((lp->class[j]->minscale > 0) && (map->scale <= lp->class[j]->minscale))
 	  continue;
       }
 
-      if(msGetLabelSize(lp->class[j].name, &map->legend.label, &rect, &(map->fontset), 1.0, MS_FALSE) != 0)
+      if(msGetLabelSize(lp->class[j]->name, &map->legend.label, &rect, &(map->fontset), 1.0, MS_FALSE) != 0)
 	return(NULL); /* something bad happened */
 
       maxheight = MS_MAX(maxheight, MS_NINT(rect.maxy - rect.miny));
@@ -398,24 +398,24 @@
 
     for(j=0; j<lp->numclasses; j++) { /* always at least 1 class */
 
-      if(!lp->class[j].name) continue; /* skip it */
+      if(!lp->class[j]->name) continue; /* skip it */
      
       if(!scale_independent && map->scale > 0) {  /* verify class scale here */
-        if((lp->class[j].maxscale > 0) && (map->scale > lp->class[j].maxscale))
+        if((lp->class[j]->maxscale > 0) && (map->scale > lp->class[j]->maxscale))
           continue;
-        if((lp->class[j].minscale > 0) && (map->scale <= lp->class[j].minscale))
+        if((lp->class[j]->minscale > 0) && (map->scale <= lp->class[j]->minscale))
           continue;
       }
  
       pnt.x = HMARGIN + map->legend.keysizex + map->legend.keyspacingx;
       
       /* TODO */
-      if(msDrawLegendIcon(map, lp, &(lp->class[j]),  map->legend.keysizex,  map->legend.keysizey, image->img.gd, HMARGIN, (int) pnt.y) != MS_SUCCESS)
+      if(msDrawLegendIcon(map, lp, lp->class[j],  map->legend.keysizex,  map->legend.keysizey, image->img.gd, HMARGIN, (int) pnt.y) != MS_SUCCESS)
         return NULL;
 
       pnt.y += MS_MAX(map->legend.keysizey, maxheight);
       /* TODO */
-      msDrawLabel(image, pnt, lp->class[j].name, &(map->legend.label), &map->fontset, 1.0);
+      msDrawLabel(image, pnt, lp->class[j]->name, &(map->legend.label), &map->fontset, 1.0);
 
       pnt.y += map->legend.keyspacingy; /* bump y for next label */
 	
@@ -499,7 +499,7 @@
     GET_LAYER(map, l)->name = strdup("__embed__legend");
     GET_LAYER(map, l)->type = MS_LAYER_ANNOTATION;
 
-    if(initClass(&(GET_LAYER(map, l)->class[0])) == -1) return(-1);
+    if(initClass(GET_LAYER(map, l)->class[0]) == -1) return(-1);
     GET_LAYER(map, l)->numclasses = 1; /* so we make sure to free it */
         
     /* update the layer order list with the layer's index. */
@@ -508,14 +508,14 @@
 
   GET_LAYER(map, l)->status = MS_ON;
 
-  GET_LAYER(map, l)->class[0].numstyles = 1;
-  GET_LAYER(map, l)->class[0].styles[0].symbol = s;
-  GET_LAYER(map, l)->class[0].styles[0].color.pen = -1;
-  GET_LAYER(map, l)->class[0].label.force = MS_TRUE;
-  GET_LAYER(map, l)->class[0].label.size = MS_MEDIUM; /* must set a size to have a valid label definition */
+  GET_LAYER(map, l)->class[0]->numstyles = 1;
+  GET_LAYER(map, l)->class[0]->styles[0].symbol = s;
+  GET_LAYER(map, l)->class[0]->styles[0].color.pen = -1;
+  GET_LAYER(map, l)->class[0]->label.force = MS_TRUE;
+  GET_LAYER(map, l)->class[0]->label.size = MS_MEDIUM; /* must set a size to have a valid label definition */
 
   if(map->legend.postlabelcache) /* add it directly to the image */
-    msDrawMarkerSymbolGD(&map->symbolset, img, &point, &(GET_LAYER(map, l)->class[0].styles[0]), 1.0);
+    msDrawMarkerSymbolGD(&map->symbolset, img, &point, &(GET_LAYER(map, l)->class[0]->styles[0]), 1.0);
   else
     msAddLabel(map, l, 0, -1, -1, &point, NULL, " ", 1.0, NULL);
 
diff -U3 -N -r mapserver-classes/mapobject.c mapserver-beforeclasses/mapobject.c
--- mapserver-classes/mapobject.c	2007-03-13 15:33:56.000000000 +0100
+++ mapserver-beforeclasses/mapobject.c	2007-03-11 19:07:33.000000000 +0100
@@ -170,9 +170,11 @@
 
   if(!map) return;
 
+  /*printf("msFreeMap(): maybe freeing map at %p count=%d.\n",map, map->refcount);*/
   if ( MS_REFCNT_IS_NOT_ZERO(map) ) { return; }
   if (map->debug)
      msDebug("msFreeMap(): freeing map at %p.",map);
+  /*printf("msFreeMap(): freeing map at %p.\n",map);*/
   
   msCloseConnections(map);
 
diff -U3 -N -r mapserver-classes/mapogcfilter.c mapserver-beforeclasses/mapogcfilter.c
--- mapserver-classes/mapogcfilter.c	2007-03-13 15:33:56.000000000 +0100
+++ mapserver-beforeclasses/mapogcfilter.c	2007-03-08 18:27:38.000000000 +0100
@@ -372,11 +372,11 @@
     {
         szClassItem = FLTGetMapserverExpressionClassItem(psNode);
                 
-        initClass(&(lp->class[0]));
+        initClass(&(lp->class[0]->);
 
-        lp->class[0].type = lp->type;
+        lp->class[0]->type = lp->type;
         lp->numclasses = 1;
-        msLoadExpressionString(&lp->class[0].expression, 
+        msLoadExpressionString(&lp->class[0]->expression, 
                                szExpression);
 /* -------------------------------------------------------------------- */
 /*      classitems are necessary for filter type PropertyIsLike         */
@@ -399,20 +399,20 @@
                   FLTGetMapserverIsPropertyExpression(psNode);
                 if (szExpression)
                 {
-                    initClass(&(lp->class[1]));
+                    initClass(&(lp->class[1]->);
                     
-                    lp->class[1].type = lp->type;
+                    lp->class[1]->type = lp->type;
                     lp->numclasses++;
-                    msLoadExpressionString(&lp->class[1].expression, 
+                    msLoadExpressionString(&lp->class[1]->expression, 
                                          szExpression);
-                    if (!lp->class[1].template)
-                      lp->class[1].template = strdup("ttt.html");
+                    if (!lp->class[1]->template)
+                      lp->class[1]->template = strdup("ttt.html");
                 }
             }
         }
 
-        if (!lp->class[0].template)
-          lp->class[0].template = strdup("ttt.html");
+        if (!lp->class[0]->template)
+          lp->class[0]->template = strdup("ttt.html");
 /* -------------------------------------------------------------------- */
 /*      Need to free the template so the all shapes's will not end      */
 /*      up being queried. The query is dependent on the class           */
@@ -1038,9 +1038,9 @@
     }
 
     lp->numclasses = 1; /* set 1 so the query would work */
-    initClass(&(lp->class[0]));
-    lp->class[0].type = lp->type;
-    lp->class[0].template = strdup("ttt.html");
+    initClass(&(lp->class[0]->);
+    lp->class[0]->type = lp->type;
+    lp->class[0]->template = strdup("ttt.html");
 
     szExpression = FLTGetSQLExpression(psNode, lp->connectiontype);
     if (szExpression)
diff -U3 -N -r mapserver-classes/mapogcsld.c mapserver-beforeclasses/mapogcsld.c
--- mapserver-classes/mapogcsld.c	2007-03-13 15:33:56.000000000 +0100
+++ mapserver-beforeclasses/mapogcsld.c	2007-03-08 18:27:38.000000000 +0100
@@ -445,11 +445,11 @@
                     iClass = 0;
                     for (k=0; k < pasLayers[j].numclasses; k++)
                     {
-                        initClass(&GET_LAYER(map, i)->class[iClass]);
-                        msCopyClass(&GET_LAYER(map, i)->class[iClass], 
+                        initClass(&GET_LAYER(map, i)->class[iClass]->;
+                        msCopyClass(&GET_LAYER(map, i)->class[iClass]-> 
                                     &pasLayers[j].class[k], NULL);
-                        GET_LAYER(map, i)->class[iClass].layer = &GET_LAYER(map, i);
-                        GET_LAYER(map, i)->class[iClass].type = GET_LAYER(map, i)->type;
+                        GET_LAYER(map, i)->class[iClass]->layer = &GET_LAYER(map, i);
+                        GET_LAYER(map, i)->class[iClass]->type = GET_LAYER(map, i)->type;
                         GET_LAYER(map, i)->numclasses++;
                         iClass++;
                     }
@@ -506,8 +506,8 @@
                         {
                             for (k=0; k<GET_LAYER(map, i)->numclasses; k++)
                             {
-                                if (!GET_LAYER(map, i)->class[k].template)
-                                  GET_LAYER(map, i)->class[k].template = strdup("ttt.html");
+                                if (!GET_LAYER(map, i)->class[k]->template)
+                                  GET_LAYER(map, i)->class[k]->template = strdup("ttt.html");
                             }
                         }
                         else if (!GET_LAYER(map, i)->template)
@@ -743,9 +743,9 @@
             for (i=0; i<nNewClasses; i++)
             {
                 if (dfMinScale > 0)
-                  psLayer->class[psLayer->numclasses-1-i].minscale = dfMinScale;
+                  psLayer->class[psLayer->numclasses-1-i]->minscale = dfMinScale;
                 if (dfMaxScale)
-                  psLayer->class[psLayer->numclasses-1-i].maxscale = dfMaxScale;
+                  psLayer->class[psLayer->numclasses-1-i]->maxscale = dfMaxScale;
             }                           
         }
 /* -------------------------------------------------------------------- */
@@ -753,21 +753,21 @@
 /* -------------------------------------------------------------------- */
         for (i=0; i<nNewClasses; i++)
         {
-            if (!psLayer->class[psLayer->numclasses-1-i].name)
+            if (!psLayer->class[psLayer->numclasses-1-i]->name)
             {
                 if (pszName)
-                  psLayer->class[psLayer->numclasses-1-i].name = strdup(pszName);
+                  psLayer->class[psLayer->numclasses-1-i]->name = strdup(pszName);
                 else if (pszTitle)
-                  psLayer->class[psLayer->numclasses-1-i].name = strdup(pszTitle);
+                  psLayer->class[psLayer->numclasses-1-i]->name = strdup(pszTitle);
                 else
-                  psLayer->class[psLayer->numclasses-1-i].name = strdup("Unknown");
+                  psLayer->class[psLayer->numclasses-1-i]->name = strdup("Unknown");
             }
         }
         if (pszTitle)
         {
             for (i=0; i<nNewClasses; i++)
             {
-                psLayer->class[psLayer->numclasses-1-i].title = 
+                psLayer->class[psLayer->numclasses-1-i]->title = 
                   strdup(pszTitle);
             }                           
         }
@@ -1144,18 +1144,18 @@
         {
             if (bNewClass || psLayer->numclasses <= 0)
             {
-                initClass(&(psLayer->class[psLayer->numclasses]));
+                initClass(&(psLayer->class[psLayer->numclasses]->);
                 nClassId = psLayer->numclasses;
                 psLayer->numclasses++;
             }
             else
               nClassId = psLayer->numclasses-1;
 
-            iStyle = psLayer->class[nClassId].numstyles;
-            initStyle(&(psLayer->class[nClassId].styles[iStyle]));
-            psLayer->class[nClassId].numstyles++;
+            iStyle = psLayer->class[nClassId]->numstyles;
+            initStyle(&(psLayer->class[nClassId]->styles[iStyle]));
+            psLayer->class[nClassId]->numstyles++;
             
-            msSLDParseStroke(psStroke, &psLayer->class[nClassId].styles[iStyle],
+            msSLDParseStroke(psStroke, &psLayer->class[nClassId]->styles[iStyle],
                              psLayer->map, 0); 
         }
     }
@@ -1377,18 +1377,18 @@
         {
             if (bNewClass || psLayer->numclasses <= 0)
             {
-                initClass(&(psLayer->class[psLayer->numclasses]));
+                initClass(&(psLayer->class[psLayer->numclasses]->);
                 nClassId = psLayer->numclasses;
                 psLayer->numclasses++;
             }
             else
                nClassId = psLayer->numclasses-1;
 
-            iStyle = psLayer->class[nClassId].numstyles;
-            initStyle(&(psLayer->class[nClassId].styles[iStyle]));
-            psLayer->class[nClassId].numstyles++;
+            iStyle = psLayer->class[nClassId]->numstyles;
+            initStyle(&(psLayer->class[nClassId]->styles[iStyle]));
+            psLayer->class[nClassId]->numstyles++;
             
-            msSLDParsePolygonFill(psFill, &psLayer->class[nClassId].styles[iStyle],
+            msSLDParsePolygonFill(psFill, &psLayer->class[nClassId]->styles[iStyle],
                                   psLayer->map);
         }
         /* stroke wich corresponds to the outilne in mapserver */
@@ -1403,27 +1403,27 @@
             if (psFill && psLayer->numclasses > 0) 
             {
                 nClassId =psLayer->numclasses-1;
-                iStyle = psLayer->class[nClassId].numstyles;
-                initStyle(&(psLayer->class[nClassId].styles[iStyle]));
-                psLayer->class[nClassId].numstyles++;
+                iStyle = psLayer->class[nClassId]->numstyles;
+                initStyle(&(psLayer->class[nClassId]->styles[iStyle]));
+                psLayer->class[nClassId]->numstyles++;
             }
             else
             {
                 if (bNewClass || psLayer->numclasses <= 0)
                 {
-                    initClass(&(psLayer->class[psLayer->numclasses]));
+                    initClass(&(psLayer->class[psLayer->numclasses]->);
                     nClassId = psLayer->numclasses;
                     psLayer->numclasses++;
                 }
                 else
                   nClassId = psLayer->numclasses-1;
 
-                iStyle = psLayer->class[nClassId].numstyles;
-                initStyle(&(psLayer->class[nClassId].styles[iStyle]));
-                psLayer->class[nClassId].numstyles++;
+                iStyle = psLayer->class[nClassId]->numstyles;
+                initStyle(&(psLayer->class[nClassId]->styles[iStyle]));
+                psLayer->class[nClassId]->numstyles++;
                 
             }
-            msSLDParseStroke(psStroke, &psLayer->class[nClassId].styles[iStyle],
+            msSLDParseStroke(psStroke, &psLayer->class[nClassId]->styles[iStyle],
                              psLayer->map, 1);
         }
     }
@@ -2176,25 +2176,25 @@
     {
         if (bNewClass || psLayer->numclasses <= 0)
         {
-            initClass(&(psLayer->class[psLayer->numclasses]));
+            initClass(&(psLayer->class[psLayer->numclasses]->);
             nClassId = psLayer->numclasses;
             psLayer->numclasses++;
         }
         else
           nClassId = psLayer->numclasses-1;
 
-        iStyle = psLayer->class[nClassId].numstyles;
-        initStyle(&(psLayer->class[nClassId].styles[iStyle]));
-        psLayer->class[nClassId].numstyles++;
+        iStyle = psLayer->class[nClassId]->numstyles;
+        initStyle(&(psLayer->class[nClassId]->styles[iStyle]));
+        psLayer->class[nClassId]->numstyles++;
         
 
         /* set the default color */
-        psLayer->class[nClassId].styles[iStyle].color.red = 128;
-        psLayer->class[nClassId].styles[iStyle].color.green = 128;
-        psLayer->class[nClassId].styles[iStyle].color.blue = 128;
+        psLayer->class[nClassId]->styles[iStyle].color.red = 128;
+        psLayer->class[nClassId]->styles[iStyle].color.green = 128;
+        psLayer->class[nClassId]->styles[iStyle].color.blue = 128;
 
         msSLDParseGraphicFillOrStroke(psRoot, NULL,
-                                      &psLayer->class[nClassId].styles[iStyle],
+                                      &psLayer->class[nClassId]->styles[iStyle],
                                       psLayer->map, 1);
     }
 }
@@ -2402,23 +2402,23 @@
     {
         if (!bOtherSymboliser)
         {
-            initClass(&(psLayer->class[psLayer->numclasses]));
+            initClass(&(psLayer->class[psLayer->numclasses]->);
             nClassId = psLayer->numclasses;
             psLayer->numclasses++;
-            initStyle(&(psLayer->class[nClassId].styles[0]));
-            psLayer->class[nClassId].numstyles = 1;
+            initStyle(&(psLayer->class[nClassId]->styles[0]));
+            psLayer->class[nClassId]->numstyles = 1;
             nStyleId = 0;
         }
         else
         {
             nClassId = psLayer->numclasses - 1;
             if (nClassId >= 0)/* should always be true */
-              nStyleId = psLayer->class[nClassId].numstyles -1;
+              nStyleId = psLayer->class[nClassId]->numstyles -1;
         }
 
         if (nStyleId >= 0 && nClassId >= 0) /* should always be true */
           msSLDParseTextParams(psRoot, psLayer,
-                               &psLayer->class[nClassId]);
+                               &psLayer->class[nClassId]->;
     }
 }
 
@@ -2549,25 +2549,25 @@
 
                         if (psLayer->numclasses < MS_MAXCLASSES)
                         {
-                            initClass(&(psLayer->class[psLayer->numclasses]));
+                            initClass(&(psLayer->class[psLayer->numclasses]->);
                             psLayer->numclasses++;
                             nClassId = psLayer->numclasses-1;
 
                             /*set the class name using the label. If label not defined
                               set it with the quantity*/
                             if (pszPreviousLabel)
-                              psLayer->class[nClassId].name = strdup(pszPreviousLabel);
+                              psLayer->class[nClassId]->name = strdup(pszPreviousLabel);
                             else
-                              psLayer->class[nClassId].name = strdup(pszPreviousQuality);
+                              psLayer->class[nClassId]->name = strdup(pszPreviousQuality);
 
-                            initStyle(&(psLayer->class[nClassId].styles[0]));
-                            psLayer->class[nClassId].numstyles = 1;
+                            initStyle(&(psLayer->class[nClassId]->styles[0]));
+                            psLayer->class[nClassId]->numstyles = 1;
 
-                            psLayer->class[nClassId].styles[0].color.red = 
+                            psLayer->class[nClassId]->styles[0].color.red = 
                               sColor.red;
-                            psLayer->class[nClassId].styles[0].color.green = 
+                            psLayer->class[nClassId]->styles[0].color.green = 
                               sColor.green;
-                            psLayer->class[nClassId].styles[0].color.blue = 
+                            psLayer->class[nClassId]->styles[0].color.blue = 
                               sColor.blue;
 
                             if (psLayer->classitem && 
@@ -2575,7 +2575,7 @@
                               free(psLayer->classitem);
                             psLayer->classitem = strdup("[pixel]");
 
-                            msLoadExpressionString(&psLayer->class[nClassId].expression,
+                            msLoadExpressionString(&psLayer->class[nClassId]->expression,
                                                  szExpression);
                             
                             
@@ -2616,20 +2616,20 @@
 
                 if (psLayer->numclasses < MS_MAXCLASSES)
                 {
-                    initClass(&(psLayer->class[psLayer->numclasses]));
+                    initClass(&(psLayer->class[psLayer->numclasses]->);
                     psLayer->numclasses++;
                     nClassId = psLayer->numclasses-1;
-                    initStyle(&(psLayer->class[nClassId].styles[0]));
+                    initStyle(&(psLayer->class[nClassId]->styles[0]));
                     if (pszLabel)
-                      psLayer->class[nClassId].name = strdup(pszLabel);
+                      psLayer->class[nClassId]->name = strdup(pszLabel);
                     else
-                      psLayer->class[nClassId].name = strdup(pszQuantity);
-                    psLayer->class[nClassId].numstyles = 1;
-                    psLayer->class[nClassId].styles[0].color.red = 
+                      psLayer->class[nClassId]->name = strdup(pszQuantity);
+                    psLayer->class[nClassId]->numstyles = 1;
+                    psLayer->class[nClassId]->styles[0].color.red = 
                       sColor.red;
-                    psLayer->class[nClassId].styles[0].color.green = 
+                    psLayer->class[nClassId]->styles[0].color.green = 
                               sColor.green;
-                    psLayer->class[nClassId].styles[0].color.blue = 
+                    psLayer->class[nClassId]->styles[0].color.blue = 
                       sColor.blue;
 
                     if (psLayer->classitem && 
@@ -2637,7 +2637,7 @@
                       free(psLayer->classitem);
                     psLayer->classitem = strdup("[pixel]");
 
-                    msLoadExpressionString(&psLayer->class[nClassId].expression,
+                    msLoadExpressionString(&psLayer->class[nClassId]->expression,
                                          szExpression);
                 }
             }
@@ -3938,9 +3938,9 @@
                 pszFinalSLD = strcatalloc(pszFinalSLD, szTmp);
 
                 /* if class has a name, use it as the RULE name */
-                if (psLayer->class[i].name)
+                if (psLayer->class[i]->name)
                 {
-                    pszEncoded = msEncodeHTMLEntities(psLayer->class[i].name);
+                    pszEncoded = msEncodeHTMLEntities(psLayer->class[i]->name);
                     sprintf(szTmp, "<Name>%s</Name>\n",  pszEncoded);
                     msFree(pszEncoded);
 
@@ -3949,7 +3949,7 @@
 /* -------------------------------------------------------------------- */
 /*      get the Filter if there is a class expression.                  */
 /* -------------------------------------------------------------------- */
-                pszFilter = msSLDGetFilter(&psLayer->class[i], 
+                pszFilter = msSLDGetFilter(&psLayer->class[i]-> 
                                            pszWfsFilter);/* pszWfsFilterEncoded); */
                     
                 if (pszFilter)
@@ -3961,8 +3961,8 @@
 /*      generate the min/max scale.                                     */
 /* -------------------------------------------------------------------- */
                 dfMinScale = -1.0;
-                if (psLayer->class[i].minscale > 0)
-                  dfMinScale = psLayer->class[i].minscale;      
+                if (psLayer->class[i]->minscale > 0)
+                  dfMinScale = psLayer->class[i]->minscale;      
                 else if (psLayer->minscale > 0)
                   dfMinScale = psLayer->minscale;
                 else if (psLayer->map && psLayer->map->web.minscale > 0)
@@ -3975,8 +3975,8 @@
                 }
                
                 dfMaxScale = -1.0;
-                if (psLayer->class[i].maxscale > 0)
-                  dfMaxScale = psLayer->class[i].maxscale;      
+                if (psLayer->class[i]->maxscale > 0)
+                  dfMaxScale = psLayer->class[i]->maxscale;      
                 else if (psLayer->maxscale > 0)
                   dfMaxScale = psLayer->maxscale;
                 else if (psLayer->map && psLayer->map->web.maxscale > 0)
@@ -3999,9 +3999,9 @@
 /* -------------------------------------------------------------------- */
                 if (psLayer->type == MS_LAYER_LINE)
                 {
-                    for (j=0; j<psLayer->class[i].numstyles; j++)
+                    for (j=0; j<psLayer->class[i]->numstyles; j++)
                     {
-                        psStyle = &psLayer->class[i].styles[j];
+                        psStyle = &psLayer->class[i]->styles[j];
                         pszSLD = msSLDGenerateLineSLD(psStyle, psLayer);
                         if (pszSLD)
                         {
@@ -4013,9 +4013,9 @@
                 }
                 else if (psLayer->type == MS_LAYER_POLYGON)
                 {
-                    for (j=0; j<psLayer->class[i].numstyles; j++)
+                    for (j=0; j<psLayer->class[i]->numstyles; j++)
                     {
-                        psStyle = &psLayer->class[i].styles[j];
+                        psStyle = &psLayer->class[i]->styles[j];
                         pszSLD = msSLDGeneratePolygonSLD(psStyle, psLayer);
                         if (pszSLD)
                         {
@@ -4027,9 +4027,9 @@
                 }
                 else if (psLayer->type == MS_LAYER_POINT)
                 {
-                    for (j=0; j<psLayer->class[i].numstyles; j++)
+                    for (j=0; j<psLayer->class[i]->numstyles; j++)
                     {
-                        psStyle = &psLayer->class[i].styles[j];
+                        psStyle = &psLayer->class[i]->styles[j];
                         pszSLD = msSLDGeneratePointSLD(psStyle, psLayer);
                         if (pszSLD)
                         {
@@ -4041,9 +4041,9 @@
                 }
                 else if (psLayer->type == MS_LAYER_ANNOTATION)
                 {
-                    for (j=0; j<psLayer->class[i].numstyles; j++)
+                    for (j=0; j<psLayer->class[i]->numstyles; j++)
                     {
-                        psStyle = &psLayer->class[i].styles[j];
+                        psStyle = &psLayer->class[i]->styles[j];
                         pszSLD = msSLDGeneratePointSLD(psStyle, psLayer);
                         if (pszSLD)
                         {
@@ -4054,7 +4054,7 @@
                     
                 }
                 /* label if it exists */
-                pszSLD = msSLDGenerateTextSLD(&psLayer->class[i], psLayer);
+                pszSLD = msSLDGenerateTextSLD(&psLayer->class[i]-> psLayer);
                 if (pszSLD)
                 {
                     pszFinalSLD = strcatalloc(pszFinalSLD, pszSLD);
diff -U3 -N -r mapserver-classes/mapquery.c mapserver-beforeclasses/mapquery.c
--- mapserver-classes/mapquery.c	2007-03-13 15:33:56.000000000 +0100
+++ mapserver-beforeclasses/mapquery.c	2007-03-08 18:27:39.000000000 +0100
@@ -76,7 +76,7 @@
   if(lp->template && strlen(lp->template) > 0) return MS_TRUE;
 
   for(i=0; i<lp->numclasses; i++) {
-    if(lp->class[i].template && strlen(lp->class[i].template) > 0)
+    if(lp->class[i]->template && strlen(lp->class[i]->template) > 0)
         return MS_TRUE;
   }
 
@@ -241,13 +241,13 @@
   }
 
   shape.classindex = msShapeGetClass(lp, &shape, map->scale);
-  if(!(lp->template) && ((shape.classindex == -1) || (lp->class[shape.classindex].status == MS_OFF))) { /* not a valid shape */
+  if(!(lp->template) && ((shape.classindex == -1) || (lp->class[shape.classindex]->status == MS_OFF))) { /* not a valid shape */
     msSetError(MS_NOTFOUND, "Shape %d not valid against layer classification.", "msQueryByIndex()", shapeindex);
     msFreeShape(&shape);
     return(MS_FAILURE);
   }
     
-  if(!(lp->template) && !(lp->class[shape.classindex].template)) { /* no valid template */
+  if(!(lp->template) && !(lp->class[shape.classindex]->template)) { /* no valid template */
     msFreeShape(&shape);
     msSetError(MS_NOTFOUND, "Shape does not have a valid template, no way to present results.", "msQueryByIndex()"); 
     return(MS_FAILURE);
@@ -367,12 +367,12 @@
   while((status = msLayerNextShape(lp, &shape)) == MS_SUCCESS) { /* step through the shapes */
 
     shape.classindex = msShapeGetClass(lp, &shape, map->scale);    
-    if(!(lp->template) && ((shape.classindex == -1) || (lp->class[shape.classindex].status == MS_OFF))) { /* not a valid shape */
+    if(!(lp->template) && ((shape.classindex == -1) || (lp->class[shape.classindex]->status == MS_OFF))) { /* not a valid shape */
       msFreeShape(&shape);
       continue;
     }
     
-    if(!(lp->template) && !(lp->class[shape.classindex].template)) { /* no valid template */
+    if(!(lp->template) && !(lp->class[shape.classindex]->template)) { /* no valid template */
       msFreeShape(&shape);
       continue;
     }
@@ -510,12 +510,12 @@
     while((status = msLayerNextShape(lp, &shape)) == MS_SUCCESS) { /* step through the shapes */
 
       shape.classindex = msShapeGetClass(lp, &shape, map->scale);
-      if(!(lp->template) && ((shape.classindex == -1) || (lp->class[shape.classindex].status == MS_OFF))) { /* not a valid shape */
+      if(!(lp->template) && ((shape.classindex == -1) || (lp->class[shape.classindex]->status == MS_OFF))) { /* not a valid shape */
 	msFreeShape(&shape);
 	continue;
       }
 
-      if(!(lp->template) && !(lp->class[shape.classindex].template)) { /* no valid template */
+      if(!(lp->template) && !(lp->class[shape.classindex]->template)) { /* no valid template */
 	msFreeShape(&shape);
 	continue;
       }
@@ -726,12 +726,12 @@
 	if(i > 0 && is_duplicate(lp->resultcache, shape.index, shape.tileindex)) continue;
 
 	shape.classindex = msShapeGetClass(lp, &shape, map->scale);
-	if(!(lp->template) && ((shape.classindex == -1) || (lp->class[shape.classindex].status == MS_OFF))) { /* not a valid shape */
+	if(!(lp->template) && ((shape.classindex == -1) || (lp->class[shape.classindex]->status == MS_OFF))) { /* not a valid shape */
 	  msFreeShape(&shape);
 	  continue;
 	}
 
-	if(!(lp->template) && !(lp->class[shape.classindex].template)) { /* no valid template */
+	if(!(lp->template) && !(lp->class[shape.classindex]->template)) { /* no valid template */
 	  msFreeShape(&shape);
 	  continue;
 	}
@@ -917,12 +917,12 @@
     while((status = msLayerNextShape(lp, &shape)) == MS_SUCCESS) { /* step through the shapes */
 
       shape.classindex = msShapeGetClass(lp, &shape, map->scale);
-      if(!(lp->template) && ((shape.classindex == -1) || (lp->class[shape.classindex].status == MS_OFF))) { /* not a valid shape */
+      if(!(lp->template) && ((shape.classindex == -1) || (lp->class[shape.classindex]->status == MS_OFF))) { /* not a valid shape */
 	msFreeShape(&shape);
 	continue;
       }
 
-      if(!(lp->template) && !(lp->class[shape.classindex].template)) { /* no valid template */
+      if(!(lp->template) && !(lp->class[shape.classindex]->template)) { /* no valid template */
 	msFreeShape(&shape);
 	continue;
       }
@@ -1077,12 +1077,12 @@
     while((status = msLayerNextShape(lp, &shape)) == MS_SUCCESS) { /* step through the shapes */
 
       shape.classindex = msShapeGetClass(lp, &shape, map->scale);
-      if(!(lp->template) && ((shape.classindex == -1) || (lp->class[shape.classindex].status == MS_OFF))) { /* not a valid shape */
+      if(!(lp->template) && ((shape.classindex == -1) || (lp->class[shape.classindex]->status == MS_OFF))) { /* not a valid shape */
 	msFreeShape(&shape);
 	continue;
       }
 
-      if(!(lp->template) && !(lp->class[shape.classindex].template)) { /* no valid template */
+      if(!(lp->template) && !(lp->class[shape.classindex]->template)) { /* no valid template */
 	msFreeShape(&shape);
 	continue;
       }
diff -U3 -N -r mapserver-classes/mapraster.c mapserver-beforeclasses/mapraster.c
--- mapserver-classes/mapraster.c	2007-03-13 15:33:57.000000000 +0100
+++ mapserver-beforeclasses/mapraster.c	2007-03-08 18:27:39.000000000 +0100
@@ -178,37 +178,37 @@
   int status;
   int expresult;
   
-  if((layer->numclasses == 1) && !(layer->class[0].expression.string)) /* no need to do lookup */
+  if((layer->numclasses == 1) && !(layer->class[0]->expression.string)) /* no need to do lookup */
     return(0);
 
   if(!color) return(-1);
 
   for(i=0; i<layer->numclasses; i++) {
-    if (layer->class[i].expression.string == NULL) /* Empty expression - always matches */
+    if (layer->class[i]->expression.string == NULL) /* Empty expression - always matches */
       return(i);
-    switch(layer->class[i].expression.type) {
+    switch(layer->class[i]->expression.type) {
     case(MS_STRING):
       sprintf(tmpstr2, "%d %d %d", color->red, color->green, color->blue);
-      if(strcmp(layer->class[i].expression.string, tmpstr2) == 0) return(i); /* matched */
+      if(strcmp(layer->class[i]->expression.string, tmpstr2) == 0) return(i); /* matched */
       sprintf(tmpstr2, "%d", color->pen);
-      if(strcmp(layer->class[i].expression.string, tmpstr2) == 0) return(i); /* matched */
+      if(strcmp(layer->class[i]->expression.string, tmpstr2) == 0) return(i); /* matched */
       break;
     case(MS_REGEX):
-      if(!layer->class[i].expression.compiled) {
-	if(ms_regcomp(&(layer->class[i].expression.regex), layer->class[i].expression.string, MS_REG_EXTENDED|MS_REG_NOSUB) != 0) { /* compile the expression  */
+      if(!layer->class[i]->expression.compiled) {
+	if(ms_regcomp(&(layer->class[i]->expression.regex), layer->class[i]->expression.string, MS_REG_EXTENDED|MS_REG_NOSUB) != 0) { /* compile the expression  */
 	  msSetError(MS_REGEXERR, "Invalid regular expression.", "msGetClass()");
 	  return(-1);
 	}
-	layer->class[i].expression.compiled = MS_TRUE;
+	layer->class[i]->expression.compiled = MS_TRUE;
       }
 
       sprintf(tmpstr2, "%d %d %d", color->red, color->green, color->blue);
-      if(ms_regexec(&(layer->class[i].expression.regex), tmpstr2, 0, NULL, 0) == 0) return(i); /* got a match */
+      if(ms_regexec(&(layer->class[i]->expression.regex), tmpstr2, 0, NULL, 0) == 0) return(i); /* got a match */
       sprintf(tmpstr2, "%d", color->pen);
-      if(ms_regexec(&(layer->class[i].expression.regex), tmpstr2, 0, NULL, 0) == 0) return(i); /* got a match */
+      if(ms_regexec(&(layer->class[i]->expression.regex), tmpstr2, 0, NULL, 0) == 0) return(i); /* got a match */
       break;
     case(MS_EXPRESSION):
-      tmpstr1 = strdup(layer->class[i].expression.string);
+      tmpstr1 = strdup(layer->class[i]->expression.string);
 
       sprintf(tmpstr2, "%d", color->red);
       tmpstr1 = gsub(tmpstr1, "[red]", tmpstr2);
@@ -250,34 +250,34 @@
     char tmpstr2[100];
     int status, expresult;
   
-    if((layer->numclasses == 1) && !(layer->class[0].expression.string)) /* no need to do lookup */
+    if((layer->numclasses == 1) && !(layer->class[0]->expression.string)) /* no need to do lookup */
         return(0);
 
     for(i=0; i<layer->numclasses; i++) {
-        if (layer->class[i].expression.string == NULL) /* Empty expression - always matches */
+        if (layer->class[i]->expression.string == NULL) /* Empty expression - always matches */
             return(i);
 
-        switch(layer->class[i].expression.type) {
+        switch(layer->class[i]->expression.type) {
           case(MS_STRING):
             sprintf(tmpstr2, "%18g", fValue );
-            if(strcmp(layer->class[i].expression.string, tmpstr2) == 0) return(i); /* matched */
+            if(strcmp(layer->class[i]->expression.string, tmpstr2) == 0) return(i); /* matched */
             break;
 
           case(MS_REGEX):
-            if(!layer->class[i].expression.compiled) {
-                if(ms_regcomp(&(layer->class[i].expression.regex), layer->class[i].expression.string, MS_REG_EXTENDED|MS_REG_NOSUB) != 0) { /* compile the expression  */
+            if(!layer->class[i]->expression.compiled) {
+                if(ms_regcomp(&(layer->class[i]->expression.regex), layer->class[i]->expression.string, MS_REG_EXTENDED|MS_REG_NOSUB) != 0) { /* compile the expression  */
                     msSetError(MS_REGEXERR, "Invalid regular expression.", "msGetClass()");
                     return(-1);
                 }
-                layer->class[i].expression.compiled = MS_TRUE;
+                layer->class[i]->expression.compiled = MS_TRUE;
             }
 
             sprintf(tmpstr2, "%18g", fValue );
-            if(ms_regexec(&(layer->class[i].expression.regex), tmpstr2, 0, NULL, 0) == 0) return(i); /* got a match */
+            if(ms_regexec(&(layer->class[i]->expression.regex), tmpstr2, 0, NULL, 0) == 0) return(i); /* got a match */
             break;
 
           case(MS_EXPRESSION):
-            tmpstr1 = strdup(layer->class[i].expression.string);
+            tmpstr1 = strdup(layer->class[i]->expression.string);
 
             sprintf(tmpstr2, "%18g", fValue);
             tmpstr1 = gsub(tmpstr1, "[pixel]", tmpstr2);
@@ -627,10 +627,10 @@
 	  if(c == -1) /* doesn't belong to any class, so handle like offsite */
 	    cmap[i] = -1;
 	  else {
-            RESOLVE_PEN_GD(img, layer->class[c].styles[0].color);
-	    if(MS_VALID_COLOR(layer->class[c].styles[0].color)) 
-	      cmap[i] = msAddColorGD(map,img, 0, layer->class[c].styles[0].color.red, layer->class[c].styles[0].color.green, layer->class[c].styles[0].color.blue); /* use class color */
-	    else if(MS_TRANSPARENT_COLOR(layer->class[c].styles[0].color)) 
+            RESOLVE_PEN_GD(img, layer->class[c]->styles[0].color);
+	    if(MS_VALID_COLOR(layer->class[c]->styles[0].color)) 
+	      cmap[i] = msAddColorGD(map,img, 0, layer->class[c]->styles[0].color.red, layer->class[c]->styles[0].color.green, layer->class[c]->styles[0].color.blue); /* use class color */
+	    else if(MS_TRANSPARENT_COLOR(layer->class[c]->styles[0].color)) 
 	      cmap[i] = -1; /* make transparent */
 	    else
               cmap[i] = msAddColorGD(map,img, 0, pixel.red, pixel.green, pixel.blue); /* use raster color */
@@ -845,10 +845,10 @@
 	if(c == -1) /* doesn't belong to any class, so handle like offsite */
 	  cmap[i] = -1;
 	else {
-          RESOLVE_PEN_GD(img, layer->class[c].styles[0].color);
-          if(MS_VALID_COLOR(layer->class[c].styles[0].color)) 
-	    cmap[i] = msAddColorGD(map,img, 0, layer->class[c].styles[0].color.red, layer->class[c].styles[0].color.green, layer->class[c].styles[0].color.blue); /* use class color */
-	  else if(MS_TRANSPARENT_COLOR(layer->class[c].styles[0].color)) 
+          RESOLVE_PEN_GD(img, layer->class[c]->styles[0].color);
+          if(MS_VALID_COLOR(layer->class[c]->styles[0].color)) 
+	    cmap[i] = msAddColorGD(map,img, 0, layer->class[c]->styles[0].color.red, layer->class[c]->styles[0].color.green, layer->class[c]->styles[0].color.blue); /* use class color */
+	  else if(MS_TRANSPARENT_COLOR(layer->class[c]->styles[0].color)) 
 	    cmap[i] = -1; /* make transparent */
 	  else
             cmap[i] = msAddColorGD(map,img, 0, pixel.red, pixel.green, pixel.blue); /* use raster color	   */
@@ -966,10 +966,10 @@
         if(c == -1) /* doesn't belong to any class, so handle like offsite */
 	  cmap[i] = -1;
 	else {
-          RESOLVE_PEN_GD(img, layer->class[c].styles[0].color);
-          if(MS_VALID_COLOR(layer->class[c].styles[0].color)) 
-	    cmap[i] = msAddColorGD(map,img, 0, layer->class[c].styles[0].color.red, layer->class[c].styles[0].color.green, layer->class[c].styles[0].color.blue); /* use class color */
-	  else if(MS_TRANSPARENT_COLOR(layer->class[c].styles[0].color)) 
+          RESOLVE_PEN_GD(img, layer->class[c]->styles[0].color);
+          if(MS_VALID_COLOR(layer->class[c]->styles[0].color)) 
+	    cmap[i] = msAddColorGD(map,img, 0, layer->class[c]->styles[0].color.red, layer->class[c]->styles[0].color.green, layer->class[c]->styles[0].color.blue); /* use class color */
+	  else if(MS_TRANSPARENT_COLOR(layer->class[c]->styles[0].color)) 
 	    cmap[i] = -1; /* make transparent */
 	  else
             cmap[i] = msAddColorGD(map,img, 0, pixel.red, pixel.green, pixel.blue); /* use raster color	   */
@@ -1213,10 +1213,10 @@
 	  if(c == -1) 
 	    cmap[i] = -1;
 	  else {
-            RESOLVE_PEN_GD(img, layer->class[c].styles[0].color);
-	    if(MS_VALID_COLOR(layer->class[c].styles[0].color)) 
-	      cmap[i] = msAddColorGD(map,img, 0, layer->class[c].styles[0].color.red, layer->class[c].styles[0].color.green, layer->class[c].styles[0].color.blue); /* use class color */
-	    else if(MS_TRANSPARENT_COLOR(layer->class[c].styles[0].color)) 
+            RESOLVE_PEN_GD(img, layer->class[c]->styles[0].color);
+	    if(MS_VALID_COLOR(layer->class[c]->styles[0].color)) 
+	      cmap[i] = msAddColorGD(map,img, 0, layer->class[c]->styles[0].color.red, layer->class[c]->styles[0].color.green, layer->class[c]->styles[0].color.blue); /* use class color */
+	    else if(MS_TRANSPARENT_COLOR(layer->class[c]->styles[0].color)) 
 	      cmap[i] = -1; /* make transparent */
 	    else {              
 	      clrget(&clr,i,&color);
diff -U3 -N -r mapserver-classes/maprasterquery.c mapserver-beforeclasses/maprasterquery.c
--- mapserver-classes/maprasterquery.c	2007-03-13 15:33:57.000000000 +0100
+++ mapserver-beforeclasses/maprasterquery.c	2007-03-08 18:27:39.000000000 +0100
@@ -391,9 +391,9 @@
         else
         {
             rlinfo->qc_class[rlinfo->query_results] = p_class;
-            red   = layer->class[p_class].styles[0].color.red;
-            green = layer->class[p_class].styles[0].color.green;
-            blue  = layer->class[p_class].styles[0].color.blue;
+            red   = layer->class[p_class]->styles[0].color.red;
+            green = layer->class[p_class]->styles[0].color.green;
+            blue  = layer->class[p_class]->styles[0].color.blue;
         }
     }
 
@@ -1274,8 +1274,8 @@
             else if( EQUAL(layer->items[i],"class") && rlinfo->qc_class ) 
             {
                 int p_class = rlinfo->qc_class[record];
-                if( layer->class[p_class].name != NULL )
-                    sprintf( szWork, "%.999s", layer->class[p_class].name );
+                if( layer->class[p_class]->name != NULL )
+                    sprintf( szWork, "%.999s", layer->class[p_class]->name );
                 else
                     sprintf( szWork, "%d", p_class );
             }
diff -U3 -N -r mapserver-classes/mapscale.c mapserver-beforeclasses/mapscale.c
--- mapserver-classes/mapscale.c	2007-03-13 15:33:57.000000000 +0100
+++ mapserver-beforeclasses/mapscale.c	2007-03-11 11:37:04.000000000 +0100
@@ -460,8 +460,13 @@
     if(initLayer((GET_LAYER(map, l)), map) == -1) return(-1);
     GET_LAYER(map, l)->name = strdup("__embed__scalebar");
     GET_LAYER(map, l)->type = MS_LAYER_ANNOTATION;
-
-    if(initClass(&(GET_LAYER(map, l)->class[0])) == -1) return(-1);
+      
+      GET_LAYER(map, l)->class[0]=(classObj*)malloc(sizeof(classObj));
+      if (GET_LAYER(map, l)->class[0]==NULL) {
+         msSetError(MS_MEMERR, "Malloc of a new class failed.", "msLoadMap()");
+	  return(NULL);
+      }
+    if(initClass(GET_LAYER(map, l)->class[0]) == -1) return(-1);
     GET_LAYER(map, l)->numclasses = 1; /* so we make sure to free it */
     
     /* update the layer order list with the layer's index. */
@@ -473,15 +478,15 @@
   
   GET_LAYER(map, l)->status = MS_ON;
 
-  GET_LAYER(map, l)->class[0].numstyles = 1;
-  GET_LAYER(map, l)->class[0].styles[0].symbol = s;
-  GET_LAYER(map, l)->class[0].styles[0].color.pen = -1;
-  GET_LAYER(map, l)->class[0].label.force = MS_TRUE;
-  GET_LAYER(map, l)->class[0].label.size = MS_MEDIUM; /* must set a size to have a valid label definition */
+  GET_LAYER(map, l)->class[0]->numstyles = 1;
+  GET_LAYER(map, l)->class[0]->styles[0].symbol = s;
+  GET_LAYER(map, l)->class[0]->styles[0].color.pen = -1;
+  GET_LAYER(map, l)->class[0]->label.force = MS_TRUE;
+  GET_LAYER(map, l)->class[0]->label.size = MS_MEDIUM; /* must set a size to have a valid label definition */
 
   if(map->scalebar.postlabelcache) /* add it directly to the image //TODO */
   {
-    msDrawMarkerSymbolGD(&map->symbolset, img, &point, &(GET_LAYER(map, l)->class[0].styles[0]), 1.0);
+    msDrawMarkerSymbolGD(&map->symbolset, img, &point, &(GET_LAYER(map, l)->class[0]->styles[0]), 1.0);
   }
   else
     msAddLabel(map, l, 0, -1, -1, &point, NULL, " ", 1.0, NULL);
diff -U3 -N -r mapserver-classes/mapscript/python/tests/cases/refcount.py mapserver-beforeclasses/mapscript/python/tests/cases/refcount.py
--- mapserver-classes/mapscript/python/tests/cases/refcount.py	2007-03-13 15:33:57.000000000 +0100
+++ mapserver-beforeclasses/mapscript/python/tests/cases/refcount.py	2007-03-11 18:40:02.000000000 +0100
@@ -159,6 +159,62 @@
 	assert copy.refcount == 1, copy.refcount
 	assert layer.name == copy.name
 	assert copy.map == None
+    
+    def testBehaveWhenParentIsNotNull(self):
+        """behave when parent (map) is not null"""
+	self.initMap()
+        layer = mapscript.layerObj(self.map)
+        layer.name = 'new'
+	assert layer.refcount == 2, layer.refcount
+
+    def testDummyClass(self):
+        """basic refcounting for classObj"""
+	clazz = mapscript.classObj()
+	assert clazz.refcount == 1, clazz.refcount
+
+    def testClassWithMapArgument(self):
+        """classObj constructor with not null layer"""
+	self.initMap()
+	clazz = mapscript.classObj(self.map.getLayer(0))
+	assert clazz.refcount == 2, clazz.refcount
+
+    def testClassGetter(self):
+        """classObj getter"""
+	self.initMap()
+	clazz = self.map.getLayer(1).getClass(0)
+	assert clazz.refcount == 2, clazz.refcount
+    
+    def testClassClone(self):
+        """classObj clone"""
+	self.initMap()
+	clazz = self.map.getLayer(1).getClass(0)
+	assert clazz.refcount == 2, clazz.refcount
+	clone = clazz.clone()
+	assert clone.refcount == 1, clone.refcount
+
+    def testClassInsert(self):
+        """classObj insert at end"""
+	self.initMap()
+	clazz = mapscript.classObj()
+	clazz.minscale = 666
+	assert clazz.refcount == 1, clazz.refcount
+	idx=self.map.getLayer(1).insertClass(clazz)
+	assert clazz.refcount == 2, clazz.refcount
+	assert self.map.getLayer(1).getClass(idx).refcount == 3, self.map.getLayer(1).getClass(idx).refcount
+	assert self.map.getLayer(1).getClass(idx).minscale == 666, self.map.getLayer(1).getClass(idx).minscale
+
+    def testClassInsertAtMiddle(self):
+        """classObj insert at pos. 1"""
+	self.initMap()
+	clazz = mapscript.classObj()
+	clazz.minscale = 666
+	assert clazz.refcount == 1, clazz.refcount
+	idx=self.map.getLayer(1).insertClass(clazz, 1)
+	assert idx == 1, idx
+	assert clazz.refcount == 2, clazz.refcount
+	assert self.map.getLayer(1).getClass(idx).refcount == 3, self.map.getLayer(1).getClass(idx).refcount
+	assert self.map.getLayer(1).getClass(idx).thisown , self.map.getLayer(1).getClass(idx).thisown
+	assert self.map.getLayer(1).getClass(idx).minscale == 666, self.map.getLayer(1).getClass(idx).minscale
 
 # ===========================================================================
 # Run the tests outside of the main suite
diff -U3 -N -r mapserver-classes/mapscript/swiginc/class.i mapserver-beforeclasses/mapscript/swiginc/class.i
--- mapserver-classes/mapscript/swiginc/class.i	2006-09-01 06:51:42.000000000 +0200
+++ mapserver-beforeclasses/mapscript/swiginc/class.i	2007-03-11 18:20:16.000000000 +0100
@@ -57,12 +57,21 @@
                            "classObj()");
                 return NULL;
             }
-            if (initClass(&(layer->class[layer->numclasses])) == -1)
+	    layer->class[layer->numclasses]=(classObj *) malloc(sizeof(classObj));
+            if ( layer->class[layer->numclasses] == NULL )
+            {
+                msSetError(MS_MEMERR,
+                    "Could not allocate memory for new classObj instance",
+                    "classObj()");
                 return NULL;
-            layer->class[layer->numclasses].type = layer->type;
-            layer->class[layer->numclasses].layer = layer;
+            }
+            if (initClass(layer->class[layer->numclasses]) == -1)
+                return NULL;
+            layer->class[layer->numclasses]->type = layer->type;
+            layer->class[layer->numclasses]->layer = layer;
+	    MS_REFCNT_INCR(layer->class[layer->numclasses]);
             layer->numclasses++;
-            return &(layer->class[layer->numclasses-1]);
+            return (layer->class[layer->numclasses-1]);
         }
 
         return NULL;
@@ -70,10 +79,11 @@
 
     ~classObj() 
     {
-        if (!self->layer)
+        if (self)
         {
-            freeClass(self);
-            free(self);
+            if (freeClass(self)==MS_SUCCESS) {
+            	free(self);
+	    }
         }
     }
 
diff -U3 -N -r mapserver-classes/mapscript/swiginc/layer.i mapserver-beforeclasses/mapscript/swiginc/layer.i
--- mapserver-classes/mapscript/swiginc/layer.i	2007-03-13 15:34:15.000000000 +0100
+++ mapserver-beforeclasses/mapscript/swiginc/layer.i	2007-03-11 18:18:29.000000000 +0100
@@ -214,13 +214,15 @@
             return NULL;
     }
 
+    %newobject getClass;
     classObj *getClass(int i) 
     {
-
-        if (i >= 0 && i < self->numclasses)
-            return &(self->class[i]); 
-        else
-            return NULL;
+	classObj *result=NULL;
+        if (i >= 0 && i < self->numclasses) {
+            result=self->class[i]; 
+	    MS_REFCNT_INCR(result);
+	}
+	return result;
     }
 
     char *getItem(int i) 
diff -U3 -N -r mapserver-classes/mapserv.c mapserver-beforeclasses/mapserv.c
--- mapserver-classes/mapserv.c	2007-03-13 15:33:57.000000000 +0100
+++ mapserver-beforeclasses/mapserv.c	2007-03-08 18:27:39.000000000 +0100
@@ -329,8 +329,8 @@
       if(GET_LAYER(map, j)->filter.string && (strstr(GET_LAYER(map, j)->filter.string, tmpstr) != NULL)) 
         GET_LAYER(map, j)->filter.string = gsub(GET_LAYER(map, j)->filter.string, tmpstr, msObj->request->ParamValues[i]);
       for(k=0; k<GET_LAYER(map, j)->numclasses; k++) {
-	      if(GET_LAYER(map, j)->class[k].expression.string && (strstr(GET_LAYER(map, j)->class[k].expression.string, tmpstr) != NULL)) 
-          GET_LAYER(map, j)->class[k].expression.string = gsub(GET_LAYER(map, j)->class[k].expression.string, tmpstr, msObj->request->ParamValues[i]);
+	      if(GET_LAYER(map, j)->class[k]->expression.string && (strstr(GET_LAYER(map, j)->class[k]->expression.string, tmpstr) != NULL)) 
+          GET_LAYER(map, j)->class[k]->expression.string = gsub(GET_LAYER(map, j)->class[k]->expression.string, tmpstr, msObj->request->ParamValues[i]);
       }
     }
     
diff -U3 -N -r mapserver-classes/maptemplate.c mapserver-beforeclasses/maptemplate.c
--- mapserver-classes/maptemplate.c	2007-03-13 15:33:57.000000000 +0100
+++ mapserver-beforeclasses/maptemplate.c	2007-03-11 10:33:31.000000000 +0100
@@ -1413,7 +1413,7 @@
          else
          {
             img = msCreateLegendIcon(map, GET_LAYER(map, nIdxLayer), 
-                                     &(GET_LAYER(map, nIdxLayer)->class[nIdxClass]), 
+                                     GET_LAYER(map, nIdxLayer)->class[nIdxClass], 
                                      nWidth, nHeight);
          }
 
@@ -1861,16 +1861,16 @@
    /*
     * Change class tags
     */
-   *pszTemp = gsub(*pszTemp, "[leg_class_name]", GET_LAYER(map, nIdxLayer)->class[nIdxClass].name);
-   *pszTemp = gsub(*pszTemp, "[leg_class_title]", GET_LAYER(map, nIdxLayer)->class[nIdxClass].title);
+   *pszTemp = gsub(*pszTemp, "[leg_class_name]", GET_LAYER(map, nIdxLayer)->class[nIdxClass]->name);
+   *pszTemp = gsub(*pszTemp, "[leg_class_title]", GET_LAYER(map, nIdxLayer)->class[nIdxClass]->title);
    *pszTemp = gsub(*pszTemp, "[leg_layer_name]", GET_LAYER(map, nIdxLayer)->name);
 
    snprintf(szTmpstr, 128, "%d", nIdxClass); 
    *pszTemp = gsub(*pszTemp, "[leg_class_index]", szTmpstr);
 
-   snprintf(szTmpstr, 128, "%g", GET_LAYER(map, nIdxLayer)->class[nIdxClass].minscale); 
+   snprintf(szTmpstr, 128, "%g", GET_LAYER(map, nIdxLayer)->class[nIdxClass]->minscale); 
    *pszTemp = gsub(*pszTemp, "[leg_class_minscale]", szTmpstr);
-   snprintf(szTmpstr, 128, "%g", GET_LAYER(map, nIdxLayer)->class[nIdxClass].maxscale); 
+   snprintf(szTmpstr, 128, "%g", GET_LAYER(map, nIdxLayer)->class[nIdxClass]->maxscale); 
    *pszTemp = gsub(*pszTemp, "[leg_class_maxscale]", szTmpstr);
 
    /*
@@ -1891,7 +1891,7 @@
    msInsertHashTable(myHashTable, "layer_name", GET_LAYER(map, nIdxLayer)->name);
    msInsertHashTable(myHashTable, "layer_group", GET_LAYER(map, nIdxLayer)->group);
    msInsertHashTable(myHashTable, "layer_visible", msLayerIsVisible(map, GET_LAYER(map, nIdxLayer))?"1":"0" );
-   msInsertHashTable(myHashTable, "class_name", GET_LAYER(map, nIdxLayer)->class[nIdxClass].name);
+   msInsertHashTable(myHashTable, "class_name", GET_LAYER(map, nIdxLayer)->class[nIdxClass]->name);
 
    if (processIf(pszTemp, myHashTable, MS_FALSE) != MS_SUCCESS)
       return MS_FAILURE;
@@ -2207,7 +2207,7 @@
                  if (legClassHtml) {
                     for (k=0; k<GET_LAYER(msObj->Map, msObj->Map->layerorder[j])->numclasses; k++) {
                        /* process all class tags */
-                       if (!GET_LAYER(msObj->Map, msObj->Map->layerorder[j])->class[k].name)
+                       if (!GET_LAYER(msObj->Map, msObj->Map->layerorder[j])->class[k]->name)
                          continue;
 
                        if (generateClassTemplate(legClassHtml, msObj->Map, msObj->Map->layerorder[j], k, classArgs, &legClassHtmlCopy, pszPrefix) != MS_SUCCESS)
@@ -2253,7 +2253,7 @@
                  if (legClassHtml) {
                     for (k=0; k<GET_LAYER(msObj->Map, msObj->Map->layerorder[j])->numclasses; k++) {
                        /* process all class tags */
-                       if (!GET_LAYER(msObj->Map, msObj->Map->layerorder[j])->class[k].name)
+                       if (!GET_LAYER(msObj->Map, msObj->Map->layerorder[j])->class[k]->name)
                          continue;
 
                        if (generateClassTemplate(legClassHtml, msObj->Map, msObj->Map->layerorder[j], k, classArgs, &legClassHtmlCopy, pszPrefix) != MS_SUCCESS)
@@ -2320,7 +2320,7 @@
             if (legClassHtml) {
                for (k=0; k<GET_LAYER(msObj->Map, msObj->Map->layerorder[j])->numclasses; k++) {
                   /* process all class tags */
-                  if (!GET_LAYER(msObj->Map, msObj->Map->layerorder[j])->class[k].name)
+                  if (!GET_LAYER(msObj->Map, msObj->Map->layerorder[j])->class[k]->name)
                     continue;
 
                   if (generateClassTemplate(legClassHtml, msObj->Map, msObj->Map->layerorder[j], k, classArgs, &legClassHtmlCopy, pszPrefix) != MS_SUCCESS)
@@ -2361,7 +2361,7 @@
                }
 
                for (k=0; k<GET_LAYER(msObj->Map, msObj->Map->layerorder[j])->numclasses; k++) {
-                  if (!GET_LAYER(msObj->Map, msObj->Map->layerorder[j])->class[k].name)
+                  if (!GET_LAYER(msObj->Map, msObj->Map->layerorder[j])->class[k]->name)
                     continue;
                   
                   if (generateClassTemplate(legClassHtml, msObj->Map, msObj->Map->layerorder[j], k, classArgs, &legClassHtmlCopy, pszPrefix) != MS_SUCCESS)
@@ -3164,8 +3164,8 @@
 
     if(i >= 0) { /* at least if no result found, mapserver will display an empty template. */
 
-      if(lp->resultcache->results[0].classindex >= 0 && lp->class[(int)(lp->resultcache->results[0].classindex)].template) 
-        template = lp->class[(int)(lp->resultcache->results[0].classindex)].template;
+      if(lp->resultcache->results[0].classindex >= 0 && lp->class[(int)(lp->resultcache->results[0].classindex)]->template) 
+        template = lp->class[(int)(lp->resultcache->results[0].classindex)]->template;
       else 
         template = lp->template;
 
@@ -3289,8 +3289,8 @@
         }
       }
 
-      if(lp->resultcache->results[j].classindex >= 0 && lp->class[(int)(lp->resultcache->results[j].classindex)].template) 
-        template = lp->class[(int)(lp->resultcache->results[j].classindex)].template;
+      if(lp->resultcache->results[j].classindex >= 0 && lp->class[(int)(lp->resultcache->results[j].classindex)]->template) 
+        template = lp->class[(int)(lp->resultcache->results[j].classindex)]->template;
       else 
         template = lp->template;
 
diff -U3 -N -r mapserver-classes/maputil.c mapserver-beforeclasses/maputil.c
--- mapserver-classes/maputil.c	2007-03-13 15:33:57.000000000 +0100
+++ mapserver-beforeclasses/maputil.c	2007-03-08 18:27:39.000000000 +0100
@@ -388,7 +388,7 @@
  *   int i;
  * 
  *   for(i=0; i<layer->numclasses; i++) {
- *     if(layer->class[i].status != MS_DELETE && msEvalExpression(&(layer->class[i].expression), layer->classitemindex, shape->values, layer->numitems) == MS_TRUE)
+ *     if(layer->class[i]->status != MS_DELETE && msEvalExpression(&(layer->class[i]->expression), layer->classitemindex, shape->values, layer->numitems) == MS_TRUE)
  *       return(i);
  *   }
  * 
@@ -406,9 +406,9 @@
     if(shape->classindex < 0 || shape->classindex >= layer->numclasses) return(-1);
 
     if(scale > 0) {  /* verify scale here */
-      if((layer->class[shape->classindex].maxscale > 0) && (scale > layer->class[shape->classindex].maxscale))
+      if((layer->class[shape->classindex]->maxscale > 0) && (scale > layer->class[shape->classindex]->maxscale))
         return(-1); /* can skip this feature */
-      if((layer->class[shape->classindex].minscale > 0) && (scale <= layer->class[shape->classindex].minscale))
+      if((layer->class[shape->classindex]->minscale > 0) && (scale <= layer->class[shape->classindex]->minscale))
         return(-1); /* can skip this feature */
     }
 
@@ -418,13 +418,13 @@
   for(i=0; i<layer->numclasses; i++) {
     
     if(scale > 0) {  /* verify scale here  */
-      if((layer->class[i].maxscale > 0) && (scale > layer->class[i].maxscale))
+      if((layer->class[i]->maxscale > 0) && (scale > layer->class[i]->maxscale))
         continue; /* can skip this one, next class */
-      if((layer->class[i].minscale > 0) && (scale <= layer->class[i].minscale))
+      if((layer->class[i]->minscale > 0) && (scale <= layer->class[i]->minscale))
         continue; /* can skip this one, next class */
     }
 
-    if(layer->class[i].status != MS_DELETE && msEvalExpression(&(layer->class[i].expression), layer->classitemindex, shape->values, layer->numitems) == MS_TRUE)
+    if(layer->class[i]->status != MS_DELETE && msEvalExpression(&(layer->class[i]->expression), layer->classitemindex, shape->values, layer->numitems) == MS_TRUE)
       return(i);
   }
 
@@ -436,16 +436,16 @@
   int i;
   char *tmpstr=NULL;
 
-  if(layer->class[shape->classindex].text.string) { /* test for global label first */
-    tmpstr = strdup(layer->class[shape->classindex].text.string);
-    switch(layer->class[shape->classindex].text.type) {
+  if(layer->class[shape->classindex]->text.string) { /* test for global label first */
+    tmpstr = strdup(layer->class[shape->classindex]->text.string);
+    switch(layer->class[shape->classindex]->text.type) {
     case(MS_STRING):
       break;
     case(MS_EXPRESSION):
-      tmpstr = strdup(layer->class[shape->classindex].text.string);
+      tmpstr = strdup(layer->class[shape->classindex]->text.string);
 
-      for(i=0; i<layer->class[shape->classindex].text.numitems; i++)
-	tmpstr = gsub(tmpstr, layer->class[shape->classindex].text.items[i], shape->values[layer->class[shape->classindex].text.indexes[i]]);
+      for(i=0; i<layer->class[shape->classindex]->text.numitems; i++)
+	tmpstr = gsub(tmpstr, layer->class[shape->classindex]->text.items[i], shape->values[layer->class[shape->classindex]->text.indexes[i]]);
       break;
     }
   } else {
diff -U3 -N -r mapserver-classes/mapwms.c mapserver-beforeclasses/mapwms.c
--- mapserver-classes/mapwms.c	2007-03-13 15:33:57.000000000 +0100
+++ mapserver-beforeclasses/mapwms.c	2007-03-11 10:52:04.000000000 +0100
@@ -1433,8 +1433,8 @@
                    int classnameset = 0, i=0;
                    for (i=0; i<lp->numclasses; i++)
                    {
-                       if (lp->class[i].name && 
-                           strlen(lp->class[i].name) > 0)
+                       if (lp->class[i]->name && 
+                           strlen(lp->class[i]->name) > 0)
                        {
                            classnameset = 1;
                            break;
@@ -2747,9 +2747,9 @@
          
          for (i=0; i<GET_LAYER(map, iLayerIndex)->numclasses; i++)
          {
-             if (GET_LAYER(map, iLayerIndex)->class[i].name && 
-                 strlen(GET_LAYER(map, iLayerIndex)->class[i].name) > 0 &&
-                 strcasecmp(GET_LAYER(map, iLayerIndex)->class[i].name,psRule) == 0)
+             if (GET_LAYER(map, iLayerIndex)->class[i]->name && 
+                 strlen(GET_LAYER(map, iLayerIndex)->class[i]->name) > 0 &&
+                 strcasecmp(GET_LAYER(map, iLayerIndex)->class[i]->name,psRule) == 0)
                break;
              
          }
@@ -2772,7 +2772,7 @@
              }
              
              img = msCreateLegendIcon(map, GET_LAYER(map, iLayerIndex), 
-                                      &(GET_LAYER(map, iLayerIndex)->class[i]),
+                                      GET_LAYER(map, iLayerIndex)->class[i],
                                       nWidth, nHeight);
          }
          if (img == NULL)