Index: trunk/src/crosshair.c
===================================================================
--- trunk/src/crosshair.c	(revision 28094)
+++ trunk/src/crosshair.c	(revision 28095)
@@ -175,7 +175,7 @@
 	y = pcb_crosshair.AttachedObject.ty - Buffer->Y;
 
 	/* draw all visible layers */
-	for (i = 0; i < pcb_max_layer; i++)
+	for (i = 0; i < pcb_max_layer(PCB); i++)
 		if (PCB->Data->Layer[i].meta.real.vis) {
 			pcb_layer_t *layer = &Buffer->Data->Layer[i];
 
@@ -693,7 +693,7 @@
 	info.X = X;
 	info.Y = Y;
 
-	for (i = 0; i < pcb_max_layer; i++) {
+	for (i = 0; i < pcb_max_layer(PCB); i++) {
 		pcb_layer_t *layer = &PCB->Data->Layer[i];
 		/* Only find points of arcs and lines on currently visible layers. */
 		if (!layer->meta.real.vis)
Index: trunk/src/data.h
===================================================================
--- trunk/src/data.h	(revision 28094)
+++ trunk/src/data.h	(revision 28095)
@@ -68,12 +68,10 @@
 };
 
 #define pcb_max_group(pcb) ((pcb)->LayerGroups.len)
+#define pcb_max_layer(pcb) ((pcb)->Data->LayerN)
 
-/* DO NOT USE this macro, it is not PCB-safe */
-#define pcb_max_layer (PCB->Data->LayerN)
 
 
-
 extern pcb_buffer_t pcb_buffers[PCB_MAX_BUFFER];
 extern int pcb_added_lines;
 extern int pcb_layer_stack[PCB_MAX_LAYER];
Index: trunk/src/draw.c
===================================================================
--- trunk/src/draw.c	(revision 28094)
+++ trunk/src/draw.c	(revision 28095)
@@ -358,7 +358,7 @@
 	memset(do_group, 0, sizeof(do_group));
 	lvly.top_fab = -1;
 	lvly.top_assy = lvly.bot_assy = -1;
-	for (ngroups = 0, i = 0; i < pcb_max_layer; i++) {
+	for (ngroups = 0, i = 0; i < pcb_max_layer(PCB); i++) {
 		pcb_layer_t *l = PCB_STACKLAYER(PCB, i);
 		pcb_layergrp_id_t group = pcb_layer_get_group(PCB, pcb_layer_stack[i]);
 		pcb_layergrp_t *grp = pcb_get_layergrp(PCB, group);
Index: trunk/src/layer.c
===================================================================
--- trunk/src/layer.c	(revision 28094)
+++ trunk/src/layer.c	(revision 28095)
@@ -741,7 +741,7 @@
 				memmove(pcb_layer_stack + l, pcb_layer_stack + l + 1, (pcb->Data->LayerN - l - 1) * sizeof(pcb_layer_stack[0]));
 
 		/* remove layer from the logical layer array */
-		pcb_max_layer--;
+		pcb_max_layer(PCB)--;
 		for (l = 0; l < pcb->Data->LayerN; l++)
 			if (pcb_layer_stack[l] > old_index)
 				pcb_layer_stack[l]--;
Index: trunk/src/layer_it.h
===================================================================
--- trunk/src/layer_it.h	(revision 28094)
+++ trunk/src/layer_it.h	(revision 28095)
@@ -56,7 +56,7 @@
 {
 	if (it->global) {
 		/* over all layers, random order, without any checks - go the cheap way, bypassing groups */
-		if (it->lidx < pcb_max_layer)
+		if (it->lidx < pcb_max_layer(PCB))
 			return it->lidx++;
 		return -1;
 	}
Index: trunk/src/layer_vis.c
===================================================================
--- trunk/src/layer_vis.c	(revision 28094)
+++ trunk/src/layer_vis.c	(revision 28095)
@@ -60,9 +60,9 @@
 	int i;
 
 	/* ignore silk layers */
-	if (NewTop < pcb_max_layer) {
+	if (NewTop < pcb_max_layer(PCB)) {
 		/* first find position of passed one */
-		for (i = 0; i < pcb_max_layer; i++)
+		for (i = 0; i < pcb_max_layer(PCB); i++)
 			if (pcb_layer_stack[i] == NewTop)
 				break;
 
@@ -99,7 +99,7 @@
 			pcb_layer_id_t layer = PCB->LayerGroups.grp[group].lid[--i];
 
 			/* don't count the passed member of the group */
-			if (layer != Layer && layer < pcb_max_layer) {
+			if (layer != Layer && layer < pcb_max_layer(PCB)) {
 				PCB->Data->Layer[layer].meta.real.vis = On;
 
 				/* push layer on top of stack if switched on */
@@ -128,7 +128,7 @@
 	pcb_cardinal_t i;
 
 	assert(PCB->Data->LayerN <= PCB_MAX_LAYER);
-	for (i = 0; i < pcb_max_layer; i++) {
+	for (i = 0; i < pcb_max_layer(PCB); i++) {
 		pcb_layergrp_t *grp = pcb_get_layergrp(PCB, PCB->Data->Layer[i].meta.real.grp);
 
 		if (!(pcb_layer_flags(PCB, i) & PCB_LYT_SILK))
@@ -167,7 +167,7 @@
 	if (SavedStack.cnt != 0)
 		pcb_message(PCB_MSG_ERROR, "pcb_layervis_save_stack()  layerstack was already saved and not yet restored.  cnt = %d\n", SavedStack.cnt);
 
-	for (i = 0; i < pcb_max_layer; i++) {
+	for (i = 0; i < pcb_max_layer(PCB); i++) {
 		if (!(pcb_layer_flags(PCB, i) & PCB_LYT_SILK))
 			SavedStack.pcb_layer_stack[i] = pcb_layer_stack[i];
 		SavedStack.LayerOn[i] = PCB->Data->Layer[i].meta.real.vis;
@@ -194,7 +194,7 @@
 		pcb_message(PCB_MSG_ERROR, "pcb_layervis_restore_stack()  layerstack save count is" " wrong.  cnt = %d\n", SavedStack.cnt);
 	}
 
-	for (i = 0; i < pcb_max_layer; i++) {
+	for (i = 0; i < pcb_max_layer(PCB); i++) {
 		if (!(pcb_layer_flags(PCB, i) & PCB_LYT_SILK))
 			pcb_layer_stack[i] = SavedStack.pcb_layer_stack[i];
 		PCB->Data->Layer[i].meta.real.vis = SavedStack.LayerOn[i];
@@ -218,7 +218,7 @@
 		return;
 
 	in = 1;
-	for(n = 0; n < pcb_max_layer; n++) {
+	for(n = 0; n < pcb_max_layer(PCB); n++) {
 		if (pcb_layer_flags(PCB, n) & PCB_LYT_MASK) {
 			if (PCB->Data->Layer[n].meta.real.vis != *cfg->val.boolean) {
 				chg = 1;
@@ -312,7 +312,7 @@
 void pcb_hid_save_and_show_layer_ons(int *save_array)
 {
 	pcb_layer_id_t i;
-	for (i = 0; i < pcb_max_layer; i++) {
+	for (i = 0; i < pcb_max_layer(PCB); i++) {
 		save_array[i] = PCB->Data->Layer[i].meta.real.vis;
 		PCB->Data->Layer[i].meta.real.vis = 1;
 	}
@@ -328,7 +328,7 @@
 void pcb_hid_restore_layer_ons(int *save_array)
 {
 	pcb_layer_id_t i;
-	for (i = 0; i < pcb_max_layer; i++)
+	for (i = 0; i < pcb_max_layer(PCB); i++)
 		PCB->Data->Layer[i].meta.real.vis = save_array[i];
 }
 
Index: trunk/src/object_act.c
===================================================================
--- trunk/src/object_act.c	(revision 28094)
+++ trunk/src/object_act.c	(revision 28095)
@@ -92,7 +92,7 @@
 			if (layername) {
 				int i;
 				layer = NULL;
-				for (i = 0; i < pcb_max_layer; i++)
+				for (i = 0; i < pcb_max_layer(PCB); i++)
 					if (strcmp(pcb->Data->Layer[i].name, layername) == 0) {
 						layer = &(pcb->Data->Layer[i]);
 						break;
@@ -847,7 +847,7 @@
 	}
 	else if (strcmp(a1, "down") == 0) {
 		new_index = PCB_CURRLID(pcb) + 1;
-		if (new_index >= pcb_max_layer) {
+		if (new_index >= pcb_max_layer(PCB)) {
 			PCB_ACT_IRES(1);
 			return 0;
 		}
Index: trunk/src/polygon.c
===================================================================
--- trunk/src/polygon.c	(revision 28094)
+++ trunk/src/polygon.c	(revision 28095)
@@ -1426,7 +1426,7 @@
 		if (Data->parent_type != PCB_PARENT_BOARD)
 			return 0;
 		if (ptr1 == NULL) { /* no layer specified: run on all layers */
-			LAYER_LOOP(Data, pcb_max_layer);
+			LAYER_LOOP(Data, pcb_max_layer(PCB));
 			{
 				if (!(pcb_layer_flags_(layer) & PCB_LYT_COPPER))
 					continue;
Index: trunk/src/search.c
===================================================================
--- trunk/src/search.c	(revision 28094)
+++ trunk/src/search.c	(revision 28095)
@@ -1253,7 +1253,7 @@
 			return found;
 	}
 
-	for(i = 0; i < pcb_max_layer; i++) {
+	for(i = 0; i < pcb_max_layer(PCB); i++) {
 		int found;
 		if (pcb_layer_flags(PCB, i) & PCB_LYT_SILK) /* special order: silks are searched before/after this loop, if we meet them elsewhere, skip */
 			continue;
Index: trunk/src/select.c
===================================================================
--- trunk/src/select.c	(revision 28094)
+++ trunk/src/select.c	(revision 28095)
@@ -240,7 +240,7 @@
 	PCB_END_LOOP;
 
 	/* check layers */
-	LAYER_LOOP(pcb->Data, pcb_max_layer);
+	LAYER_LOOP(pcb->Data, pcb_max_layer(PCB));
 	{
 		unsigned int lflg = pcb_layer_flags(pcb, n);
 
Index: trunk/src_plugins/diag/diag.c
===================================================================
--- trunk/src_plugins/diag/diag.c	(revision 28094)
+++ trunk/src_plugins/diag/diag.c	(revision 28095)
@@ -210,7 +210,7 @@
 		return 0;
 	}
 
-	printf("Max: theoretical=%d current_board=%d\n", PCB_MAX_LAYER, pcb_max_layer);
+	printf("Max: theoretical=%d current_board=%d\n", PCB_MAX_LAYER, pcb_max_layer(PCB));
 	used = pcb_layer_list_any(PCB, PCB_LYT_ANYTHING | PCB_LYT_ANYWHERE | PCB_LYT_VIRTUAL, arr, sizeof(arr)/sizeof(arr[0]));
 	for(n = 0; n < used; n++) {
 		pcb_layer_id_t layer_id = arr[n];
Index: trunk/src_plugins/djopt/djopt.c
===================================================================
--- trunk/src_plugins/djopt/djopt.c	(revision 28094)
+++ trunk/src_plugins/djopt/djopt.c	(revision 28095)
@@ -1694,7 +1694,7 @@
 			counts[c->lines[i]->layer]++;
 			directions[c->lines[i]->layer] |= o;
 		}
-		for (o = 0, i = 0; i < pcb_max_layer; i++) {
+		for (o = 0, i = 0; i < pcb_max_layer(PCB); i++) {
 			if (!(pcb_layer_flags(PCB, i) & PCB_LYT_COPPER))
 				continue;
 			if (counts[i] == 1) {
@@ -1714,7 +1714,7 @@
 		default:
 			continue;
 		}
-		for (i = 0; i < pcb_max_layer; i++) {
+		for (i = 0; i < pcb_max_layer(PCB); i++) {
 			if (!(pcb_layer_flags(PCB, i) & PCB_LYT_COPPER))
 				continue;
 			if (counts[i] && directions[i] != o && directions[i] != oboth)
@@ -2211,7 +2211,7 @@
 			bottom = pin->BoundingBox.Y2;
 
 			dprintf("%s x %#mS-%#mS y %#mS-%#mS\n", corner_name(c), left, right, bottom, top);
-			for (l = 0; l <= pcb_max_layer; l++) {
+			for (l = 0; l <= pcb_max_layer(PCB); l++) {
 				if (!(pcb_layer_flags(PCB, l) & PCB_LYT_COPPER))
 					continue;
 				best_dist[l] = close * 2;
@@ -2248,10 +2248,10 @@
 					}
 				}
 				if (!got_one && c->n_lines == (c->pad ? 1 : 0)) {
-					for (l = 0; l <= pcb_max_layer; l++)
+					for (l = 0; l <= pcb_max_layer(PCB); l++)
 						if (best_c[l])
 							dprintf("best[%d] = %s\n", l, corner_name(best_c[l]));
-					for (l = 0; l <= pcb_max_layer; l++)
+					for (l = 0; l <= pcb_max_layer(PCB); l++)
 						if (best_c[l]) {
 							dprintf("move %s to %s\n", corner_name(best_c[l]), corner_name(c));
 							connect_corners(best_c[l], c);
@@ -2405,7 +2405,7 @@
 	pcb_layer_stack_t *l = &(PCB->LayerGroups);
 
 	solder_layer = component_layer = -1;
-	for (i = 0; i < pcb_max_layer; i++) {
+	for (i = 0; i < pcb_max_layer(PCB); i++) {
 		layer_type[i] = 0;
 		layer_groupings[i] = 0;
 	}
@@ -2419,7 +2419,7 @@
 				f |= LT_COMPONENT;
 		}
 		for (j = 0; j < l->grp[i].len; j++) {
-			if (l->grp[i].lid[j] < pcb_max_layer) {
+			if (l->grp[i].lid[j] < pcb_max_layer(PCB)) {
 				layer_type[l->grp[i].lid[j]] |= f;
 				layer_groupings[l->grp[i].lid[j]] = i;
 				if (solder_layer == -1 && f == LT_SOLDER)
@@ -2488,7 +2488,7 @@
 		return 0;
 	}
 
-	for (layn = 0; layn < pcb_max_layer; layn++) {
+	for (layn = 0; layn < pcb_max_layer(PCB); layn++) {
 		pcb_layer_t *layer = pcb_get_layer(PCB->Data, layn);
 
 		if (!(pcb_layer_flags(PCB, layn) & PCB_LYT_COPPER))
Index: trunk/src_plugins/draw_fab/draw_fab.c
===================================================================
--- trunk/src_plugins/draw_fab/draw_fab.c	(revision 28094)
+++ trunk/src_plugins/draw_fab/draw_fab.c	(revision 28095)
@@ -298,7 +298,7 @@
 		strcpy(utcTime, "<date>");
 
 	yoff = -TEXT_LINE;
-	for (found = 0, i = 0; i < pcb_max_layer; i++) {
+	for (found = 0, i = 0; i < pcb_max_layer(PCB); i++) {
 		pcb_layer_t *l = &PCB->Data->Layer[i];
 		pcb_layer_type_t flags = pcb_layer_flags(PCB, i);
 		int purpi = pcb_layer_purpose(PCB, i, NULL);
Index: trunk/src_plugins/export_fidocadj/fidocadj.c
===================================================================
--- trunk/src_plugins/export_fidocadj/fidocadj.c	(revision 28094)
+++ trunk/src_plugins/export_fidocadj/fidocadj.c	(revision 28095)
@@ -198,7 +198,7 @@
 	fprintf(f, "[FIDOCAD]\n");
 
 	fidoly_next = 3;
-	for(lid = 0; lid < pcb_max_layer; lid++) {
+	for(lid = 0; lid < pcb_max_layer(PCB); lid++) {
 		pcb_layer_t *ly = PCB->Data->Layer+lid;
 		unsigned int lflg = pcb_layer_flags(PCB, lid);
 		int fidoly = layer_map(lflg, &fidoly_next, ly->name);
Index: trunk/src_plugins/export_gcode/gcode.c
===================================================================
--- trunk/src_plugins/export_gcode/gcode.c	(revision 28094)
+++ trunk/src_plugins/export_gcode/gcode.c	(revision 28095)
@@ -277,7 +277,7 @@
 	/* Set entire array to 0 (don't export any layer groups by default */
 	memset(gcode_export_group, 0, sizeof(gcode_export_group));
 
-	for (n = 0; n < pcb_max_layer; n++) {
+	for (n = 0; n < pcb_max_layer(PCB); n++) {
 		unsigned int flags = pcb_layer_flags(PCB, n);
 		if (flags & PCB_LYT_SILK)
 			continue;
Index: trunk/src_plugins/export_gerber/gerber.c
===================================================================
--- trunk/src_plugins/export_gerber/gerber.c	(revision 28094)
+++ trunk/src_plugins/export_gerber/gerber.c	(revision 28095)
@@ -273,7 +273,7 @@
 
 static pcb_layergrp_id_t group_for_layer(int l)
 {
-	if (l < pcb_max_layer && l >= 0)
+	if (l < pcb_max_layer(PCB) && l >= 0)
 		return pcb_layer_get_group(PCB, l);
 	/* else something unique */
 	return pcb_max_group(PCB) + 3 + l;
@@ -576,7 +576,7 @@
 		pcb_hid_save_and_show_layer_ons(save_ons);
 
 	memcpy(saved_layer_stack, pcb_layer_stack, sizeof(pcb_layer_stack));
-	qsort(pcb_layer_stack, pcb_max_layer, sizeof(pcb_layer_stack[0]), layer_sort);
+	qsort(pcb_layer_stack, pcb_max_layer(PCB), sizeof(pcb_layer_stack[0]), layer_sort);
 	linewidth = -1;
 	lastcap = -1;
 	lastgroup = -1;
Index: trunk/src_plugins/export_png/png.c
===================================================================
--- trunk/src_plugins/export_png/png.c	(revision 28094)
+++ trunk/src_plugins/export_png/png.c	(revision 28095)
@@ -412,7 +412,7 @@
 
 static pcb_layergrp_id_t group_for_layer(int l)
 {
-	if (l < pcb_max_layer && l >= 0)
+	if (l < pcb_max_layer(PCB) && l >= 0)
 		return pcb_layer_get_group(PCB, l);
 	/* else something unique */
 	return pcb_max_group(PCB) + 3 + l;
@@ -429,7 +429,7 @@
 	pcb_layergrp_id_t bl = group_for_layer(b);
 	int d = bl - al;
 
-	if (a >= 0 && a < pcb_max_layer) {
+	if (a >= 0 && a < pcb_max_layer(PCB)) {
 		int aside = (is_solder(al) ? 0 : is_component(al) ? 2 : 1);
 		int bside = (is_solder(bl) ? 0 : is_component(bl) ? 2 : 1);
 
@@ -550,7 +550,7 @@
 /*		conf_force_set_bool(conf_core.editor.check_planes, 0);*/
 		conf_force_set_bool(conf_core.editor.show_solder_side, 0);
 
-		qsort(pcb_layer_stack, pcb_max_layer, sizeof(pcb_layer_stack[0]), layer_sort);
+		qsort(pcb_layer_stack, pcb_max_layer(PCB), sizeof(pcb_layer_stack[0]), layer_sort);
 
 		if (photo_mode)
 			png_photo_as_shown();
@@ -561,7 +561,7 @@
 
 	if (!photo_mode && conf_core.editor.show_solder_side) {
 		int i, j;
-		for (i = 0, j = pcb_max_layer - 1; i < j; i++, j--) {
+		for (i = 0, j = pcb_max_layer(PCB) - 1; i < j; i++, j--) {
 			int k = pcb_layer_stack[i];
 			pcb_layer_stack[i] = pcb_layer_stack[j];
 			pcb_layer_stack[j] = k;
Index: trunk/src_plugins/export_ps/eps.c
===================================================================
--- trunk/src_plugins/export_ps/eps.c	(revision 28094)
+++ trunk/src_plugins/export_ps/eps.c	(revision 28095)
@@ -129,7 +129,7 @@
 
 static pcb_layergrp_id_t group_for_layer(int l)
 {
-	if (l < pcb_max_layer && l >= 0)
+	if (l < pcb_max_layer(PCB) && l >= 0)
 		return pcb_layer_get_group(PCB, l);
 	/* else something unique */
 	return pcb_max_group(PCB) + 3 + l;
@@ -146,7 +146,7 @@
 	pcb_layergrp_id_t bl = group_for_layer(b);
 	int d = bl - al;
 
-	if (a >= 0 && a < pcb_max_layer) {
+	if (a >= 0 && a < pcb_max_layer(PCB)) {
 		int aside = (is_solder(al) ? 0 : is_component(al) ? 2 : 1);
 		int bside = (is_solder(bl) ? 0 : is_component(bl) ? 2 : 1);
 		if (bside != aside)
@@ -241,7 +241,7 @@
 	memset(print_layer, 0, sizeof(print_layer));
 
 	/* Figure out which layers actually have stuff on them.  */
-	for (i = 0; i < pcb_max_layer; i++) {
+	for (i = 0; i < pcb_max_layer(PCB); i++) {
 		pcb_layer_t *layer = PCB->Data->Layer + i;
 		if (pcb_layer_flags(PCB, i) & PCB_LYT_SILK)
 			continue;
@@ -273,7 +273,7 @@
 
 	/* Now, for each group we're printing, mark its layers for
 	   printing.  */
-	for (i = 0; i < pcb_max_layer; i++) {
+	for (i = 0; i < pcb_max_layer(PCB); i++) {
 		if (pcb_layer_flags(PCB, i) & PCB_LYT_SILK)
 			continue;
 		if (print_group[pcb_layer_get_group(PCB, i)])
@@ -283,7 +283,7 @@
 	memcpy(saved_layer_stack, pcb_layer_stack, sizeof(pcb_layer_stack));
 	as_shown = options[HA_as_shown].lng;
 	if (!options[HA_as_shown].lng) {
-		qsort(pcb_layer_stack, pcb_max_layer, sizeof(pcb_layer_stack[0]), layer_sort);
+		qsort(pcb_layer_stack, pcb_max_layer(PCB), sizeof(pcb_layer_stack[0]), layer_sort);
 	}
 	linewidth = -1;
 	lastcap = -1;
Index: trunk/src_plugins/export_ps/ps.c
===================================================================
--- trunk/src_plugins/export_ps/ps.c	(revision 28094)
+++ trunk/src_plugins/export_ps/ps.c	(revision 28095)
@@ -350,7 +350,7 @@
 
 static pcb_layergrp_id_t group_for_layer(int l)
 {
-	if (l < pcb_max_layer && l >= 0)
+	if (l < pcb_max_layer(PCB) && l >= 0)
 		return pcb_layer_get_group(PCB, l);
 	/* else something unique */
 	return pcb_max_group(PCB) + 3 + l;
@@ -568,7 +568,7 @@
 
 	global.has_outline = pcb_has_explicit_outline(PCB);
 	memcpy(saved_layer_stack, pcb_layer_stack, sizeof(pcb_layer_stack));
-	qsort(pcb_layer_stack, pcb_max_layer, sizeof(pcb_layer_stack[0]), layer_sort);
+	qsort(pcb_layer_stack, pcb_max_layer(PCB), sizeof(pcb_layer_stack[0]), layer_sort);
 
 	global.linewidth = -1;
 	/* reset static vars */
Index: trunk/src_plugins/export_stat/stat.c
===================================================================
--- trunk/src_plugins/export_stat/stat.c	(revision 28094)
+++ trunk/src_plugins/export_stat/stat.c	(revision 28095)
@@ -181,7 +181,7 @@
 	fprintf(f, "	}\n");
 
 	fprintf(f, "	li:logical_layers {\n");
-	for(lid = 0; lid < pcb_max_layer; lid++) {
+	for(lid = 0; lid < pcb_max_layer(PCB); lid++) {
 		pcb_layer_t *l = PCB->Data->Layer+lid;
 		int empty = pcb_layer_is_empty_(PCB, l);
 		unsigned int lflg = pcb_layer_flags(PCB, lid);
Index: trunk/src_plugins/io_lihata/write.c
===================================================================
--- trunk/src_plugins/io_lihata/write.c	(revision 28094)
+++ trunk/src_plugins/io_lihata/write.c	(revision 28095)
@@ -217,7 +217,7 @@
 	/* thermal flags per layer */
 	lst = lht_dom_node_alloc(LHT_HASH, "thermal");
 
-	for(layer = 0; layer < pcb_max_layer; layer++) {
+	for(layer = 0; layer < pcb_max_layer(PCB); layer++) {
 		if (PCB_FLAG_THERM_TEST_ANY(&fh)) {
 			int t = PCB_FLAG_THERM_GET(layer, &fh);
 			if (t != 0) {
@@ -1052,7 +1052,7 @@
 		grp[g - PCB->LayerGroups.grp] = gtop;
 
 		/* v1 needs to have silk at the end of the list */
-		for(n = 0; n < pcb_max_layer; n++) {
+		for(n = 0; n < pcb_max_layer(PCB); n++) {
 			if ((pcb_layer_flags(PCB, n) & PCB_LYT_SILK) == 0) {
 				pcb_layergrp_id_t gid = pcb_layer_get_group(PCB, n);
 				LAYER_GID_FIX_V1();
@@ -1059,7 +1059,7 @@
 				lht_dom_list_append(layers, build_data_layer(data, data->Layer+n, gid, n));
 			}
 		}
-		for(n = 0; n < pcb_max_layer; n++) {
+		for(n = 0; n < pcb_max_layer(PCB); n++) {
 			if (pcb_layer_flags(PCB, n) & PCB_LYT_SILK) {
 				pcb_layer_id_t gid = pcb_layer_get_group(PCB, n);
 				LAYER_GID_FIX_V1();
Index: trunk/src_plugins/io_pcb/file.c
===================================================================
--- trunk/src_plugins/io_pcb/file.c	(revision 28094)
+++ trunk/src_plugins/io_pcb/file.c	(revision 28095)
@@ -695,8 +695,8 @@
 		return;
 	}
 
-	if (bs != pcb_max_layer - 2) {
-		pcb_layer_swap(PCB, bs, pcb_max_layer - 2);
+	if (bs != pcb_max_layer(PCB) - 2) {
+		pcb_layer_swap(PCB, bs, pcb_max_layer(PCB) - 2);
 		chg = 1;
 	}
 
@@ -703,8 +703,8 @@
 	bs = pcb_layer_get_bottom_silk();
 	ts = pcb_layer_get_top_silk();
 
-	if (ts != pcb_max_layer - 1) {
-		pcb_layer_swap(PCB, ts, pcb_max_layer - 1);
+	if (ts != pcb_max_layer(PCB) - 1) {
+		pcb_layer_swap(PCB, ts, pcb_max_layer(PCB) - 1);
 		chg = 1;
 	}
 
Index: trunk/src_plugins/lib_hid_pcbui/rendering.c
===================================================================
--- trunk/src_plugins/lib_hid_pcbui/rendering.c	(revision 28094)
+++ trunk/src_plugins/lib_hid_pcbui/rendering.c	(revision 28095)
@@ -40,7 +40,7 @@
 		int n = PCB->LayerGroups.grp[group].len;
 		for (idx = 0; idx < n - 1; idx++) {
 			int ni = PCB->LayerGroups.grp[group].lid[idx];
-			if (ni >= 0 && ni < pcb_max_layer && PCB->Data->Layer[ni].meta.real.vis)
+			if (ni >= 0 && ni < pcb_max_layer(PCB) && PCB->Data->Layer[ni].meta.real.vis)
 				break;
 		}
 		idx = PCB->LayerGroups.grp[group].lid[idx];
@@ -53,7 +53,7 @@
 			return (PCB_LAYERFLG_ON_VISIBLE_SIDE(flags) && PCB->LayerGroups.grp[group].vis);
 	}
 
-	if (idx >= 0 && idx < pcb_max_layer && ((flags & PCB_LYT_ANYTHING) != PCB_LYT_SILK))
+	if (idx >= 0 && idx < pcb_max_layer(PCB) && ((flags & PCB_LYT_ANYTHING) != PCB_LYT_SILK))
 		return PCB->Data->Layer[idx].meta.real.vis;
 
 	/* virtual layers */
Index: trunk/src_plugins/teardrops/teardrops.c
===================================================================
--- trunk/src_plugins/teardrops/teardrops.c	(revision 28094)
+++ trunk/src_plugins/teardrops/teardrops.c	(revision 28095)
@@ -178,7 +178,7 @@
 {
 	pstk = ps;
 
-	for (layer = 0; layer < pcb_max_layer; layer++) {
+	for (layer = 0; layer < pcb_max_layer(PCB); layer++) {
 		pcb_layer_t *l = &(PCB->Data->Layer[layer]);
 		pcb_pstk_shape_t *shp, tmpshp;
 		pcb_box_t spot;