SCI: Add a 'SELECTOR' macro

svn-id: r47918

19 files changed, 402 insertions, 390 deletions

diff --git a/engines/sci/console.cpp b/engines/sci/console.cpp
index 19022e8b64..c26c6285b2 100644
--- a/engines/sci/console.cpp
+++ b/engines/sci/console.cpp
@@ -1519,9 +1519,9 @@ bool Console::cmdToggleSound(int argc, const char **argv) {
 		SegManager *segMan = _engine->_gamestate->_segMan;	// for PUT_SEL32V
 		_engine->_gamestate->_sound.sfx_song_set_status(handle, SOUND_STATUS_STOPPED);
 		_engine->_gamestate->_sound.sfx_remove_song(handle);
-		PUT_SEL32V(segMan, id, signal, SIGNAL_OFFSET);
-		PUT_SEL32V(segMan, id, nodePtr, 0);
-		PUT_SEL32V(segMan, id, handle, 0);
+		PUT_SEL32V(segMan, id, SELECTOR(signal), SIGNAL_OFFSET);
+		PUT_SEL32V(segMan, id, SELECTOR(nodePtr), 0);
+		PUT_SEL32V(segMan, id, SELECTOR(handle), 0);
 	}
 #else
 
diff --git a/engines/sci/engine/kernel32.cpp b/engines/sci/engine/kernel32.cpp
index 06a24caffc..4669256df4 100644
--- a/engines/sci/engine/kernel32.cpp
+++ b/engines/sci/engine/kernel32.cpp
@@ -499,7 +499,7 @@ reg_t kArray(EngineState *s, int argc, reg_t *argv) {
 		if (!s->_segMan->isHeapObject(argv[1]))
 			return argv[1];
 
-		return GET_SEL32(s->_segMan, argv[1], data);
+		return GET_SEL32(s->_segMan, argv[1], SELECTOR(data));
 	default:
 		error("Unknown kArray subop %d", argv[0].toUint16());
 	}
@@ -623,7 +623,7 @@ reg_t kString(EngineState *s, int argc, reg_t *argv) {
 		if (!s->_segMan->isHeapObject(argv[1]))
 			return argv[1];
 
-		return GET_SEL32(s->_segMan, argv[1], data);
+		return GET_SEL32(s->_segMan, argv[1], SELECTOR(data));
 	case 10: // Stringlen
 		return make_reg(0, s->_segMan->strlen(argv[1]));
 	case 11: { // Printf
@@ -688,12 +688,12 @@ reg_t kDeleteScreenItem(EngineState *s, int argc, reg_t *argv) {
 
 	/*
 	reg_t viewObj = argv[0];
-	uint16 viewId = GET_SEL32V(s->_segMan, viewObj, view);
-	int16 loopNo = GET_SEL32V(s->_segMan, viewObj, loop);
-	int16 celNo = GET_SEL32V(s->_segMan, viewObj, cel);
+	uint16 viewId = GET_SEL32V(s->_segMan, viewObj, SELECTOR(view));
+	int16 loopNo = GET_SEL32V(s->_segMan, viewObj, SELECTOR(loop));
+	int16 celNo = GET_SEL32V(s->_segMan, viewObj, SELECTOR(cel));
 	//int16 leftPos = 0;
 	//int16 topPos = 0;
-	int16 priority = GET_SEL32V(s->_segMan, viewObj, priority);
+	int16 priority = GET_SEL32V(s->_segMan, viewObj, SELECTOR(priority));
 	//int16 control = 0;
 	*/
 
@@ -760,10 +760,10 @@ reg_t kOnMe(EngineState *s, int argc, reg_t *argv) {
 	Common::Rect nsRect;
 
 	// Get the bounding rectangle of the object
-	nsRect.left = GET_SEL32V(s->_segMan, targetObject, nsLeft);
-	nsRect.top = GET_SEL32V(s->_segMan, targetObject, nsTop);
-	nsRect.right = GET_SEL32V(s->_segMan, targetObject, nsRight);
-	nsRect.bottom = GET_SEL32V(s->_segMan, targetObject, nsBottom);
+	nsRect.left = GET_SEL32V(s->_segMan, targetObject, SELECTOR(nsLeft));
+	nsRect.top = GET_SEL32V(s->_segMan, targetObject, SELECTOR(nsTop));
+	nsRect.right = GET_SEL32V(s->_segMan, targetObject, SELECTOR(nsRight));
+	nsRect.bottom = GET_SEL32V(s->_segMan, targetObject, SELECTOR(nsBottom));
 
 	//warning("kOnMe: (%d, %d) on object %04x:%04x, parameter %d", argv[0].toUint16(), argv[1].toUint16(), PRINT_REG(argv[2]), argv[3].toUint16());
 
@@ -778,7 +778,7 @@ reg_t kInPolygon(EngineState *s, int argc, reg_t *argv) {
 reg_t kCreateTextBitmap(EngineState *s, int argc, reg_t *argv) {
 	// TODO: argument 0 is usually 0, and arguments 1 and 2 are usually 1
 	reg_t object = argv[3];
-	Common::String text = s->_segMan->getString(GET_SEL32(s->_segMan, object, text));
+	Common::String text = s->_segMan->getString(GET_SEL32(s->_segMan, object, SELECTOR(text)));
 	debug("kCreateTextBitmap: %s", text.c_str());
 
 	return NULL_REG;
diff --git a/engines/sci/engine/kevent.cpp b/engines/sci/engine/kevent.cpp
index 2f7a6e1068..3099c87ff4 100644
--- a/engines/sci/engine/kevent.cpp
+++ b/engines/sci/engine/kevent.cpp
@@ -53,11 +53,11 @@ reg_t kGetEvent(EngineState *s, int argc, reg_t *argv) {
 	// If there's a simkey pending, and the game wants a keyboard event, use the
 	// simkey instead of a normal event
 	if (g_debug_simulated_key && (mask & SCI_EVENT_KEYBOARD)) {
-		PUT_SEL32V(segMan, obj, type, SCI_EVENT_KEYBOARD); // Keyboard event
-		PUT_SEL32V(segMan, obj, message, g_debug_simulated_key);
-		PUT_SEL32V(segMan, obj, modifiers, SCI_KEYMOD_NUMLOCK); // Numlock on
-		PUT_SEL32V(segMan, obj, x, mousePos.x);
-		PUT_SEL32V(segMan, obj, y, mousePos.y);
+		PUT_SEL32V(segMan, obj, SELECTOR(type), SCI_EVENT_KEYBOARD); // Keyboard event
+		PUT_SEL32V(segMan, obj, SELECTOR(message), g_debug_simulated_key);
+		PUT_SEL32V(segMan, obj, SELECTOR(modifiers), SCI_KEYMOD_NUMLOCK); // Numlock on
+		PUT_SEL32V(segMan, obj, SELECTOR(x), mousePos.x);
+		PUT_SEL32V(segMan, obj, SELECTOR(y), mousePos.y);
 		g_debug_simulated_key = 0;
 		return make_reg(0, 1);
 	}
@@ -69,8 +69,8 @@ reg_t kGetEvent(EngineState *s, int argc, reg_t *argv) {
 	if (s->_voc)
 		s->_voc->parser_event = NULL_REG; // Invalidate parser event
 
-	PUT_SEL32V(segMan, obj, x, mousePos.x);
-	PUT_SEL32V(segMan, obj, y, mousePos.y);
+	PUT_SEL32V(segMan, obj, SELECTOR(x), mousePos.x);
+	PUT_SEL32V(segMan, obj, SELECTOR(y), mousePos.y);
 
 	//s->_gui->moveCursor(s->gfx_state->pointer_pos.x, s->gfx_state->pointer_pos.y);
 
@@ -80,12 +80,12 @@ reg_t kGetEvent(EngineState *s, int argc, reg_t *argv) {
 		break;
 
 	case SCI_EVENT_KEYBOARD:
-		PUT_SEL32V(segMan, obj, type, SCI_EVENT_KEYBOARD); // Keyboard event
+		PUT_SEL32V(segMan, obj, SELECTOR(type), SCI_EVENT_KEYBOARD); // Keyboard event
 		s->r_acc = make_reg(0, 1);
 
-		PUT_SEL32V(segMan, obj, message, curEvent.character);
+		PUT_SEL32V(segMan, obj, SELECTOR(message), curEvent.character);
 		// We only care about the translated character
-		PUT_SEL32V(segMan, obj, modifiers, curEvent.modifiers & modifier_mask);
+		PUT_SEL32V(segMan, obj, SELECTOR(modifiers), curEvent.modifiers & modifier_mask);
 		break;
 
 	case SCI_EVENT_MOUSE_RELEASE:
@@ -110,9 +110,9 @@ reg_t kGetEvent(EngineState *s, int argc, reg_t *argv) {
 				break;
 			}
 
-			PUT_SEL32V(segMan, obj, type, curEvent.type);
-			PUT_SEL32V(segMan, obj, message, 0);
-			PUT_SEL32V(segMan, obj, modifiers, (curEvent.modifiers | extra_bits) & modifier_mask);
+			PUT_SEL32V(segMan, obj, SELECTOR(type), curEvent.type);
+			PUT_SEL32V(segMan, obj, SELECTOR(message), 0);
+			PUT_SEL32V(segMan, obj, SELECTOR(modifiers), (curEvent.modifiers | extra_bits) & modifier_mask);
 			s->r_acc = make_reg(0, 1);
 		}
 		break;
@@ -164,9 +164,9 @@ reg_t kMapKeyToDir(EngineState *s, int argc, reg_t *argv) {
 	reg_t obj = argv[0];
 	SegManager *segMan = s->_segMan;
 
-	if (GET_SEL32V(segMan, obj, type) == SCI_EVENT_KEYBOARD) { // Keyboard
+	if (GET_SEL32V(segMan, obj, SELECTOR(type)) == SCI_EVENT_KEYBOARD) { // Keyboard
 		int mover = -1;
-		switch (GET_SEL32V(segMan, obj, message)) {
+		switch (GET_SEL32V(segMan, obj, SELECTOR(message))) {
 		case SCI_KEY_HOME:
 			mover = 8;
 			break;
@@ -200,8 +200,8 @@ reg_t kMapKeyToDir(EngineState *s, int argc, reg_t *argv) {
 		}
 
 		if (mover >= 0) {
-			PUT_SEL32V(segMan, obj, type, SCI_EVENT_JOYSTICK);
-			PUT_SEL32V(segMan, obj, message, mover);
+			PUT_SEL32V(segMan, obj, SELECTOR(type), SCI_EVENT_JOYSTICK);
+			PUT_SEL32V(segMan, obj, SELECTOR(message), mover);
 			return make_reg(0, 1);
 		} else
 			return NULL_REG;
@@ -216,13 +216,13 @@ reg_t kGlobalToLocal(EngineState *s, int argc, reg_t *argv) {
 	SegManager *segMan = s->_segMan;
 
 	if (obj.segment) {
-		int16 x = GET_SEL32V(segMan, obj, x);
-		int16 y = GET_SEL32V(segMan, obj, y);
+		int16 x = GET_SEL32V(segMan, obj, SELECTOR(x));
+		int16 y = GET_SEL32V(segMan, obj, SELECTOR(y));
 
 		s->_gfxCoordAdjuster->kernelGlobalToLocal(x, y, planeObject);
 
-		PUT_SEL32V(segMan, obj, x, x);
-		PUT_SEL32V(segMan, obj, y, y);
+		PUT_SEL32V(segMan, obj, SELECTOR(x), x);
+		PUT_SEL32V(segMan, obj, SELECTOR(y), y);
 	}
 
 	return s->r_acc;
@@ -235,13 +235,13 @@ reg_t kLocalToGlobal(EngineState *s, int argc, reg_t *argv) {
 	SegManager *segMan = s->_segMan;
 
 	if (obj.segment) {
-		int16 x = GET_SEL32V(segMan, obj, x);
-		int16 y = GET_SEL32V(segMan, obj, y);
+		int16 x = GET_SEL32V(segMan, obj, SELECTOR(x));
+		int16 y = GET_SEL32V(segMan, obj, SELECTOR(y));
 
 		s->_gfxCoordAdjuster->kernelLocalToGlobal(x, y, planeObject);
 
-		PUT_SEL32V(segMan, obj, x, x);
-		PUT_SEL32V(segMan, obj, y, y);
+		PUT_SEL32V(segMan, obj, SELECTOR(x), x);
+		PUT_SEL32V(segMan, obj, SELECTOR(y), y);
 	}
 
 	return s->r_acc;
diff --git a/engines/sci/engine/kgraphics.cpp b/engines/sci/engine/kgraphics.cpp
index 6358db450b..e7d1a0a52f 100644
--- a/engines/sci/engine/kgraphics.cpp
+++ b/engines/sci/engine/kgraphics.cpp
@@ -50,8 +50,8 @@
 namespace Sci {
 
 void _k_dirloop(reg_t object, uint16 angle, EngineState *s, int argc, reg_t *argv) {
-	GuiResourceId viewId = GET_SEL32V(s->_segMan, object, view);
-	uint16 signal = GET_SEL32V(s->_segMan, object, signal);
+	GuiResourceId viewId = GET_SEL32V(s->_segMan, object, SELECTOR(view));
+	uint16 signal = GET_SEL32V(s->_segMan, object, SELECTOR(signal));
 	int16 loopNo;
 	int16 maxLoops;
 	bool oldScriptHeader = (getSciVersion() == SCI_VERSION_0_EARLY);
@@ -90,7 +90,7 @@ void _k_dirloop(reg_t object, uint16 angle, EngineState *s, int argc, reg_t *arg
 	if ((loopNo > 1) && (maxLoops < 4))
 		return;
 
-	PUT_SEL32V(s->_segMan, object, loop, loopNo);
+	PUT_SEL32V(s->_segMan, object, SELECTOR(loop), loopNo);
 }
 
 static reg_t kSetCursorSci0(EngineState *s, int argc, reg_t *argv) {
@@ -446,7 +446,7 @@ reg_t kCelWide(EngineState *s, int argc, reg_t *argv) {
 
 reg_t kNumLoops(EngineState *s, int argc, reg_t *argv) {
 	reg_t object = argv[0];
-	GuiResourceId viewId = GET_SEL32V(s->_segMan, object, view);
+	GuiResourceId viewId = GET_SEL32V(s->_segMan, object, SELECTOR(view));
 	int16 loopCount;
 
 	loopCount = s->_gfxCache->kernelViewGetLoopCount(viewId);
@@ -458,8 +458,8 @@ reg_t kNumLoops(EngineState *s, int argc, reg_t *argv) {
 
 reg_t kNumCels(EngineState *s, int argc, reg_t *argv) {
 	reg_t object = argv[0];
-	GuiResourceId viewId = GET_SEL32V(s->_segMan, object, view);
-	int16 loopNo = GET_SEL32V(s->_segMan, object, loop);
+	GuiResourceId viewId = GET_SEL32V(s->_segMan, object, SELECTOR(view));
+	int16 loopNo = GET_SEL32V(s->_segMan, object, SELECTOR(loop));
 	int16 celCount;
 
 	celCount = s->_gfxCache->kernelViewGetCelCount(viewId, loopNo);
@@ -535,8 +535,8 @@ reg_t kBaseSetter(EngineState *s, int argc, reg_t *argv) {
 	// WORKAROUND for a problem in LSL1VGA. This allows the casino door to be opened,
 	// till the actual problem is found
 	if (s->_gameId == "lsl1sci" && s->currentRoomNumber() == 300) {
-		int top = GET_SEL32V(s->_segMan, object, brTop);
-		PUT_SEL32V(s->_segMan, object, brTop, top + 2);
+		int top = GET_SEL32V(s->_segMan, object, SELECTOR(brTop));
+		PUT_SEL32V(s->_segMan, object, SELECTOR(brTop), top + 2);
 	}
 
 	return s->r_acc;
@@ -738,12 +738,12 @@ Common::Rect kControlCreateRect(int16 x, int16 y, int16 x1, int16 y1) {
 }
 
 void _k_GenericDrawControl(EngineState *s, reg_t controlObject, bool hilite) {
-	int16 type = GET_SEL32V(s->_segMan, controlObject, type);
-	int16 style = GET_SEL32V(s->_segMan, controlObject, state);
-	int16 x = GET_SEL32V(s->_segMan, controlObject, nsLeft);
-	int16 y = GET_SEL32V(s->_segMan, controlObject, nsTop);
-	GuiResourceId fontId = GET_SEL32V(s->_segMan, controlObject, font);
-	reg_t textReference = GET_SEL32(s->_segMan, controlObject, text);
+	int16 type = GET_SEL32V(s->_segMan, controlObject, SELECTOR(type));
+	int16 style = GET_SEL32V(s->_segMan, controlObject, SELECTOR(state));
+	int16 x = GET_SEL32V(s->_segMan, controlObject, SELECTOR(nsLeft));
+	int16 y = GET_SEL32V(s->_segMan, controlObject, SELECTOR(nsTop));
+	GuiResourceId fontId = GET_SEL32V(s->_segMan, controlObject, SELECTOR(font));
+	reg_t textReference = GET_SEL32(s->_segMan, controlObject, SELECTOR(text));
 	Common::String text;
 	Common::Rect rect;
 	TextAlignment alignment;
@@ -758,7 +758,9 @@ void _k_GenericDrawControl(EngineState *s, reg_t controlObject, bool hilite) {
 	const char **listEntries = NULL;
 	bool isAlias = false;
 
-	rect = kControlCreateRect(x, y, GET_SEL32V(s->_segMan, controlObject, nsRight), GET_SEL32V(s->_segMan, controlObject, nsBottom));
+	rect = kControlCreateRect(x, y,
+				GET_SEL32V(s->_segMan, controlObject, SELECTOR(nsRight)),
+				GET_SEL32V(s->_segMan, controlObject, SELECTOR(nsBottom)));
 
 	if (!textReference.isNull())
 		text = s->_segMan->getString(textReference);
@@ -770,32 +772,32 @@ void _k_GenericDrawControl(EngineState *s, reg_t controlObject, bool hilite) {
 		return;
 
 	case SCI_CONTROLS_TYPE_TEXT:
-		alignment = GET_SEL32V(s->_segMan, controlObject, mode);
+		alignment = GET_SEL32V(s->_segMan, controlObject, SELECTOR(mode));
 		debugC(2, kDebugLevelGraphics, "drawing text %04x:%04x ('%s') to %d,%d, mode=%d", PRINT_REG(controlObject), text.c_str(), x, y, alignment);
 		s->_gfxControls->kernelDrawText(rect, controlObject, s->strSplit(text.c_str()).c_str(), fontId, alignment, style, hilite);
 		return;
 
 	case SCI_CONTROLS_TYPE_TEXTEDIT:
-		mode = GET_SEL32V(s->_segMan, controlObject, mode);
-		maxChars = GET_SEL32V(s->_segMan, controlObject, max);
-		cursorPos = GET_SEL32V(s->_segMan, controlObject, cursor);
+		mode = GET_SEL32V(s->_segMan, controlObject, SELECTOR(mode));
+		maxChars = GET_SEL32V(s->_segMan, controlObject, SELECTOR(max));
+		cursorPos = GET_SEL32V(s->_segMan, controlObject, SELECTOR(cursor));
 		debugC(2, kDebugLevelGraphics, "drawing edit control %04x:%04x (text %04x:%04x, '%s') to %d,%d", PRINT_REG(controlObject), PRINT_REG(textReference), text.c_str(), x, y);
 		s->_gfxControls->kernelDrawTextEdit(rect, controlObject, s->strSplit(text.c_str(), NULL).c_str(), fontId, mode, style, cursorPos, maxChars, hilite);
 		return;
 
 	case SCI_CONTROLS_TYPE_ICON:
-		viewId = GET_SEL32V(s->_segMan, controlObject, view);
+		viewId = GET_SEL32V(s->_segMan, controlObject, SELECTOR(view));
 		{
-			int l = GET_SEL32V(s->_segMan, controlObject, loop);
+			int l = GET_SEL32V(s->_segMan, controlObject, SELECTOR(loop));
 			loopNo = (l & 0x80) ? l - 256 : l;
-			int c = GET_SEL32V(s->_segMan, controlObject, cel);
+			int c = GET_SEL32V(s->_segMan, controlObject, SELECTOR(cel));
 			celNo = (c & 0x80) ? c - 256 : c;
 			// Game-specific: *ONLY* the jones EGA/VGA sierra interpreter contain code using priority selector
 			//  ALL other games use a hardcoded -1 (madness!)
 			// We are detecting jones/talkie as "jones" as well, but the sierra interpreter of talkie doesnt have this
 			//  "hack". Hopefully it wont cause regressions (the code causes regressions if used against kq5/floppy)
 			if (s->_gameId == "jones")
-				priority = GET_SEL32V(s->_segMan, controlObject, priority);
+				priority = GET_SEL32V(s->_segMan, controlObject, SELECTOR(priority));
 			else
 				priority = -1;
 		}
@@ -808,17 +810,17 @@ void _k_GenericDrawControl(EngineState *s, reg_t controlObject, bool hilite) {
 		if (type == SCI_CONTROLS_TYPE_LIST_ALIAS)
 			isAlias = true;
 
-		maxChars = GET_SEL32V(s->_segMan, controlObject, x); // max chars per entry
-		cursorOffset = GET_SEL32V(s->_segMan, controlObject, cursor);
+		maxChars = GET_SEL32V(s->_segMan, controlObject, SELECTOR(x)); // max chars per entry
+		cursorOffset = GET_SEL32V(s->_segMan, controlObject, SELECTOR(cursor));
 		if (s->_kernel->_selectorCache.topString != -1) {
 			// Games from early SCI1 onwards use topString
-			upperOffset = GET_SEL32V(s->_segMan, controlObject, topString);
+			upperOffset = GET_SEL32V(s->_segMan, controlObject, SELECTOR(topString));
 		} else {
 			// Earlier games use lsTop or brTop
 			if (lookup_selector(s->_segMan, controlObject, s->_kernel->_selectorCache.brTop, NULL, NULL) == kSelectorVariable)
-				upperOffset = GET_SEL32V(s->_segMan, controlObject, brTop);
+				upperOffset = GET_SEL32V(s->_segMan, controlObject, SELECTOR(brTop));
 			else
-				upperOffset = GET_SEL32V(s->_segMan, controlObject, lsTop);
+				upperOffset = GET_SEL32V(s->_segMan, controlObject, SELECTOR(lsTop));
 		}
 
 		// Count string entries in NULL terminated string list
@@ -869,8 +871,8 @@ reg_t kDrawControl(EngineState *s, int argc, reg_t *argv) {
 	// Disable the "Change Directory" button, as we don't allow the game engine to
 	// change the directory where saved games are placed
 	if (objName == "changeDirI") {
-		int state = GET_SEL32V(s->_segMan, controlObject, state);
-		PUT_SEL32V(s->_segMan, controlObject, state, (state | kControlStateDisabled) & ~kControlStateEnabled);
+		int state = GET_SEL32V(s->_segMan, controlObject, SELECTOR(state));
+		PUT_SEL32V(s->_segMan, controlObject, SELECTOR(state), (state | kControlStateDisabled) & ~kControlStateEnabled);
 	}
 
 	_k_GenericDrawControl(s, controlObject, false);
@@ -889,7 +891,7 @@ reg_t kEditControl(EngineState *s, int argc, reg_t *argv) {
 	reg_t eventObject = argv[1];
 
 	if (!controlObject.isNull()) {
-		int16 controlType = GET_SEL32V(s->_segMan, controlObject, type);
+		int16 controlType = GET_SEL32V(s->_segMan, controlObject, SELECTOR(type));
 
 		switch (controlType) {
 		case SCI_CONTROLS_TYPE_TEXTEDIT:
diff --git a/engines/sci/engine/klists.cpp b/engines/sci/engine/klists.cpp
index d9ebcd3286..37f60d2830 100644
--- a/engines/sci/engine/klists.cpp
+++ b/engines/sci/engine/klists.cpp
@@ -415,11 +415,11 @@ reg_t kSort(EngineState *s, int argc, reg_t *argv) {
 	reg_t dest = argv[1];
 	reg_t order_func = argv[2];
 
-	int input_size = (int16)GET_SEL32V(segMan, source, size);
+	int input_size = (int16)GET_SEL32V(segMan, source, SELECTOR(size));
 	int i;
 
-	reg_t input_data = GET_SEL32(segMan, source, elements);
-	reg_t output_data = GET_SEL32(segMan, dest, elements);
+	reg_t input_data = GET_SEL32(segMan, source, SELECTOR(elements));
+	reg_t output_data = GET_SEL32(segMan, dest, SELECTOR(elements));
 
 	List *list;
 	Node *node;
@@ -430,10 +430,10 @@ reg_t kSort(EngineState *s, int argc, reg_t *argv) {
 	if (output_data.isNull()) {
 		list = s->_segMan->allocateList(&output_data);
 		list->first = list->last = NULL_REG;
-		PUT_SEL32(segMan, dest, elements, output_data);
+		PUT_SEL32(segMan, dest, SELECTOR(elements), output_data);
 	}
 
-	PUT_SEL32V(segMan, dest, size, input_size);
+	PUT_SEL32V(segMan, dest, SELECTOR(size), input_size);
 
 	list = s->_segMan->lookupList(input_data);
 	node = s->_segMan->lookupNode(list->first);
diff --git a/engines/sci/engine/kmovement.cpp b/engines/sci/engine/kmovement.cpp
index 6a2d468531..67fd835d67 100644
--- a/engines/sci/engine/kmovement.cpp
+++ b/engines/sci/engine/kmovement.cpp
@@ -157,8 +157,8 @@ reg_t kSetJump(EngineState *s, int argc, reg_t *argv) {
 	debugC(2, kDebugLevelBresen, "SetJump for object at %04x:%04x", PRINT_REG(object));
 	debugC(2, kDebugLevelBresen, "xStep: %d, yStep: %d", vx, vy);
 
-	PUT_SEL32V(segMan, object, xStep, vx);
-	PUT_SEL32V(segMan, object, yStep, vy);
+	PUT_SEL32V(segMan, object, SELECTOR(xStep), vx);
+	PUT_SEL32V(segMan, object, SELECTOR(yStep), vy);
 
 	return s->r_acc;
 }
@@ -167,9 +167,9 @@ reg_t kSetJump(EngineState *s, int argc, reg_t *argv) {
 #define _K_BRESEN_AXIS_Y 1
 
 static void initialize_bresen(SegManager *segMan, int argc, reg_t *argv, reg_t mover, int step_factor, int deltax, int deltay) {
-	reg_t client = GET_SEL32(segMan, mover, client);
-	int stepx = (int16)GET_SEL32V(segMan, client, xStep) * step_factor;
-	int stepy = (int16)GET_SEL32V(segMan, client, yStep) * step_factor;
+	reg_t client = GET_SEL32(segMan, mover, SELECTOR(client));
+	int stepx = (int16)GET_SEL32V(segMan, client, SELECTOR(xStep)) * step_factor;
+	int stepy = (int16)GET_SEL32V(segMan, client, SELECTOR(yStep)) * step_factor;
 	int numsteps_x = stepx ? (abs(deltax) + stepx - 1) / stepx : 0;
 	int numsteps_y = stepy ? (abs(deltay) + stepy - 1) / stepy : 0;
 	int bdi, i1;
@@ -190,15 +190,15 @@ static void initialize_bresen(SegManager *segMan, int argc, reg_t *argv, reg_t m
 /*	if (abs(deltax) > abs(deltay)) {*/ // Bresenham on y
 	if (numsteps_y < numsteps_x) {
 
-		PUT_SEL32V(segMan, mover, b_xAxis, _K_BRESEN_AXIS_Y);
-		PUT_SEL32V(segMan, mover, b_incr, (deltay < 0) ? -1 : 1);
+		PUT_SEL32V(segMan, mover, SELECTOR(b_xAxis), _K_BRESEN_AXIS_Y);
+		PUT_SEL32V(segMan, mover, SELECTOR(b_incr), (deltay < 0) ? -1 : 1);
 		//i1 = 2 * (abs(deltay) - abs(deltay_step * numsteps)) * abs(deltax_step);
 		//bdi = -abs(deltax);
 		i1 = 2 * (abs(deltay) - abs(deltay_step * (numsteps - 1))) * abs(deltax_step);
 		bdi = -abs(deltax);
 	} else { // Bresenham on x
-		PUT_SEL32V(segMan, mover, b_xAxis, _K_BRESEN_AXIS_X);
-		PUT_SEL32V(segMan, mover, b_incr, (deltax < 0) ? -1 : 1);
+		PUT_SEL32V(segMan, mover, SELECTOR(b_xAxis), _K_BRESEN_AXIS_X);
+		PUT_SEL32V(segMan, mover, SELECTOR(b_incr), (deltax < 0) ? -1 : 1);
 		//i1= 2 * (abs(deltax) - abs(deltax_step * numsteps)) * abs(deltay_step);
 		//bdi = -abs(deltay);
 		i1 = 2 * (abs(deltax) - abs(deltax_step * (numsteps - 1))) * abs(deltay_step);
@@ -206,26 +206,26 @@ static void initialize_bresen(SegManager *segMan, int argc, reg_t *argv, reg_t m
 
 	}
 
-	PUT_SEL32V(segMan, mover, dx, deltax_step);
-	PUT_SEL32V(segMan, mover, dy, deltay_step);
+	PUT_SEL32V(segMan, mover, SELECTOR(dx), deltax_step);
+	PUT_SEL32V(segMan, mover, SELECTOR(dy), deltay_step);
 
 	debugC(2, kDebugLevelBresen, "Init bresen for mover %04x:%04x: d=(%d,%d)", PRINT_REG(mover), deltax, deltay);
 	debugC(2, kDebugLevelBresen, "    steps=%d, mv=(%d, %d), i1= %d, i2=%d",
 	          numsteps, deltax_step, deltay_step, i1, bdi*2);
 
-	//PUT_SEL32V(segMan, mover, b_movCnt, numsteps); // Needed for HQ1/Ogre?
-	PUT_SEL32V(segMan, mover, b_di, bdi);
-	PUT_SEL32V(segMan, mover, b_i1, i1);
-	PUT_SEL32V(segMan, mover, b_i2, bdi * 2);
+	//PUT_SEL32V(segMan, mover, SELECTOR(b_movCnt), numsteps); // Needed for HQ1/Ogre?
+	PUT_SEL32V(segMan, mover, SELECTOR(b_di), bdi);
+	PUT_SEL32V(segMan, mover, SELECTOR(b_i1), i1);
+	PUT_SEL32V(segMan, mover, SELECTOR(b_i2), bdi * 2);
 }
 
 reg_t kInitBresen(EngineState *s, int argc, reg_t *argv) {
 	SegManager *segMan = s->_segMan;
 	reg_t mover = argv[0];
-	reg_t client = GET_SEL32(segMan, mover, client);
+	reg_t client = GET_SEL32(segMan, mover, SELECTOR(client));
 
-	int deltax = (int16)GET_SEL32V(segMan, mover, x) - (int16)GET_SEL32V(segMan, client, x);
-	int deltay = (int16)GET_SEL32V(segMan, mover, y) - (int16)GET_SEL32V(segMan, client, y);
+	int deltax = (int16)GET_SEL32V(segMan, mover, SELECTOR(x)) - (int16)GET_SEL32V(segMan, client, SELECTOR(x));
+	int deltay = (int16)GET_SEL32V(segMan, mover, SELECTOR(y)) - (int16)GET_SEL32V(segMan, client, SELECTOR(y));
 	int step_factor = (argc < 1) ? argv[1].toUint16() : 1;
 
 	initialize_bresen(s->_segMan, argc, argv, mover, step_factor, deltax, deltay);
@@ -239,42 +239,42 @@ reg_t kInitBresen(EngineState *s, int argc, reg_t *argv) {
 reg_t kDoBresen(EngineState *s, int argc, reg_t *argv) {
 	SegManager *segMan = s->_segMan;
 	reg_t mover = argv[0];
-	reg_t client = GET_SEL32(segMan, mover, client);
+	reg_t client = GET_SEL32(segMan, mover, SELECTOR(client));
 
-	int x = (int16)GET_SEL32V(segMan, client, x);
-	int y = (int16)GET_SEL32V(segMan, client, y);
+	int x = (int16)GET_SEL32V(segMan, client, SELECTOR(x));
+	int y = (int16)GET_SEL32V(segMan, client, SELECTOR(y));
 	int oldx, oldy, destx, desty, dx, dy, bdi, bi1, bi2, movcnt, bdelta, axis;
-	uint16 signal = GET_SEL32V(segMan, client, signal);
+	uint16 signal = GET_SEL32V(segMan, client, SELECTOR(signal));
 	int completed = 0;
-	int max_movcnt = GET_SEL32V(segMan, client, moveSpeed);
+	int max_movcnt = GET_SEL32V(segMan, client, SELECTOR(moveSpeed));
 
 	if (getSciVersion() > SCI_VERSION_01)
 		signal &= ~kSignalHitObstacle;
 
-	PUT_SEL32(segMan, client, signal, make_reg(0, signal)); // This is a NOP for SCI0
+	PUT_SEL32(segMan, client, SELECTOR(signal), make_reg(0, signal)); // This is a NOP for SCI0
 	oldx = x;
 	oldy = y;
-	destx = (int16)GET_SEL32V(segMan, mover, x);
-	desty = (int16)GET_SEL32V(segMan, mover, y);
-	dx = (int16)GET_SEL32V(segMan, mover, dx);
-	dy = (int16)GET_SEL32V(segMan, mover, dy);
-	bdi = (int16)GET_SEL32V(segMan, mover, b_di);
-	bi1 = (int16)GET_SEL32V(segMan, mover, b_i1);
-	bi2 = (int16)GET_SEL32V(segMan, mover, b_i2);
-	movcnt = GET_SEL32V(segMan, mover, b_movCnt);
-	bdelta = (int16)GET_SEL32V(segMan, mover, b_incr);
-	axis = (int16)GET_SEL32V(segMan, mover, b_xAxis);
+	destx = (int16)GET_SEL32V(segMan, mover, SELECTOR(x));
+	desty = (int16)GET_SEL32V(segMan, mover, SELECTOR(y));
+	dx = (int16)GET_SEL32V(segMan, mover, SELECTOR(dx));
+	dy = (int16)GET_SEL32V(segMan, mover, SELECTOR(dy));
+	bdi = (int16)GET_SEL32V(segMan, mover, SELECTOR(b_di));
+	bi1 = (int16)GET_SEL32V(segMan, mover, SELECTOR(b_i1));
+	bi2 = (int16)GET_SEL32V(segMan, mover, SELECTOR(b_i2));
+	movcnt = GET_SEL32V(segMan, mover, SELECTOR(b_movCnt));
+	bdelta = (int16)GET_SEL32V(segMan, mover, SELECTOR(b_incr));
+	axis = (int16)GET_SEL32V(segMan, mover, SELECTOR(b_xAxis));
 
 	//printf("movecnt %d, move speed %d\n", movcnt, max_movcnt);
 
 	if (s->_features->handleMoveCount()) {
 		if (max_movcnt > movcnt) {
 			++movcnt;
-			PUT_SEL32V(segMan, mover, b_movCnt, movcnt); // Needed for HQ1/Ogre?
+			PUT_SEL32V(segMan, mover, SELECTOR(b_movCnt), movcnt); // Needed for HQ1/Ogre?
 			return NULL_REG;
 		} else {
 			movcnt = 0;
-			PUT_SEL32V(segMan, mover, b_movCnt, movcnt); // Needed for HQ1/Ogre?
+			PUT_SEL32V(segMan, mover, SELECTOR(b_movCnt), movcnt); // Needed for HQ1/Ogre?
 		}
 	}
 
@@ -287,7 +287,7 @@ reg_t kDoBresen(EngineState *s, int argc, reg_t *argv) {
 			dy += bdelta;
 	}
 
-	PUT_SEL32V(segMan, mover, b_di, bdi);
+	PUT_SEL32V(segMan, mover, SELECTOR(b_di), bdi);
 
 	x += dx;
 	y += dy;
@@ -309,8 +309,8 @@ reg_t kDoBresen(EngineState *s, int argc, reg_t *argv) {
 		debugC(2, kDebugLevelBresen, "Finished mover %04x:%04x", PRINT_REG(mover));
 	}
 
-	PUT_SEL32V(segMan, client, x, x);
-	PUT_SEL32V(segMan, client, y, y);
+	PUT_SEL32V(segMan, client, SELECTOR(x), x);
+	PUT_SEL32V(segMan, client, SELECTOR(y), y);
 
 	debugC(2, kDebugLevelBresen, "New data: (x,y)=(%d,%d), di=%d", x, y, bdi);
 
@@ -322,11 +322,11 @@ reg_t kDoBresen(EngineState *s, int argc, reg_t *argv) {
 	}
 
 	if (!s->r_acc.offset) { // Contains the return value
-		signal = GET_SEL32V(segMan, client, signal);
+		signal = GET_SEL32V(segMan, client, SELECTOR(signal));
 
-		PUT_SEL32V(segMan, client, x, oldx);
-		PUT_SEL32V(segMan, client, y, oldy);
-		PUT_SEL32V(segMan, client, signal, (signal | kSignalHitObstacle));
+		PUT_SEL32V(segMan, client, SELECTOR(x), oldx);
+		PUT_SEL32V(segMan, client, SELECTOR(y), oldy);
+		PUT_SEL32V(segMan, client, SELECTOR(signal), (signal | kSignalHitObstacle));
 
 		debugC(2, kDebugLevelBresen, "Finished mover %04x:%04x by collision", PRINT_REG(mover));
 		completed = 1;
@@ -377,15 +377,15 @@ reg_t kDoAvoider(EngineState *s, int argc, reg_t *argv) {
 		return NULL_REG;
 	}
 
-	client = GET_SEL32(segMan, avoider, client);
+	client = GET_SEL32(segMan, avoider, SELECTOR(client));
 
 	if (!s->_segMan->isHeapObject(client)) {
 		warning("DoAvoider() where client %04x:%04x is not an object", PRINT_REG(client));
 		return NULL_REG;
 	}
 
-	looper = GET_SEL32(segMan, client, looper);
-	mover = GET_SEL32(segMan, client, mover);
+	looper = GET_SEL32(segMan, client, SELECTOR(looper));
+	mover = GET_SEL32(segMan, client, SELECTOR(mover));
 
 	if (!s->_segMan->isHeapObject(mover)) {
 		if (mover.segment) {
@@ -394,8 +394,8 @@ reg_t kDoAvoider(EngineState *s, int argc, reg_t *argv) {
 		return s->r_acc;
 	}
 
-	destx = GET_SEL32V(segMan, mover, x);
-	desty = GET_SEL32V(segMan, mover, y);
+	destx = GET_SEL32V(segMan, mover, SELECTOR(x));
+	desty = GET_SEL32V(segMan, mover, SELECTOR(y));
 
 	debugC(2, kDebugLevelBresen, "Doing avoider %04x:%04x (dest=%d,%d)", PRINT_REG(avoider), destx, desty);
 
@@ -404,7 +404,7 @@ reg_t kDoAvoider(EngineState *s, int argc, reg_t *argv) {
 		return NULL_REG;
 	}
 
-	mover = GET_SEL32(segMan, client, mover);
+	mover = GET_SEL32(segMan, client, SELECTOR(mover));
 	if (!mover.segment) // Mover has been disposed?
 		return s->r_acc; // Return gracefully.
 
@@ -414,18 +414,18 @@ reg_t kDoAvoider(EngineState *s, int argc, reg_t *argv) {
 		return NULL_REG;
 	}
 
-	dx = destx - GET_SEL32V(segMan, client, x);
-	dy = desty - GET_SEL32V(segMan, client, y);
+	dx = destx - GET_SEL32V(segMan, client, SELECTOR(x));
+	dy = desty - GET_SEL32V(segMan, client, SELECTOR(y));
 	angle = getAngle(dx, dy);
 
 	debugC(2, kDebugLevelBresen, "Movement (%d,%d), angle %d is %sblocked", dx, dy, angle, (s->r_acc.offset) ? " " : "not ");
 
 	if (s->r_acc.offset) { // isBlocked() returned non-zero
 		int rotation = (rand() & 1) ? 45 : (360 - 45); // Clockwise/counterclockwise
-		int oldx = GET_SEL32V(segMan, client, x);
-		int oldy = GET_SEL32V(segMan, client, y);
-		int xstep = GET_SEL32V(segMan, client, xStep);
-		int ystep = GET_SEL32V(segMan, client, yStep);
+		int oldx = GET_SEL32V(segMan, client, SELECTOR(x));
+		int oldy = GET_SEL32V(segMan, client, SELECTOR(y));
+		int xstep = GET_SEL32V(segMan, client, SELECTOR(xStep));
+		int ystep = GET_SEL32V(segMan, client, SELECTOR(yStep));
 		int moves;
 
 		debugC(2, kDebugLevelBresen, " avoider %04x:%04x", PRINT_REG(avoider));
@@ -434,8 +434,8 @@ reg_t kDoAvoider(EngineState *s, int argc, reg_t *argv) {
 			int move_x = (int)(sin(angle * PI / 180.0) * (xstep));
 			int move_y = (int)(-cos(angle * PI / 180.0) * (ystep));
 
-			PUT_SEL32V(segMan, client, x, oldx + move_x);
-			PUT_SEL32V(segMan, client, y, oldy + move_y);
+			PUT_SEL32V(segMan, client, SELECTOR(x), oldx + move_x);
+			PUT_SEL32V(segMan, client, SELECTOR(y), oldy + move_y);
 
 			debugC(2, kDebugLevelBresen, "Pos (%d,%d): Trying angle %d; delta=(%d,%d)", oldx, oldy, angle, move_x, move_y);
 
@@ -445,12 +445,12 @@ reg_t kDoAvoider(EngineState *s, int argc, reg_t *argv) {
 				return NULL_REG;
 			}
 
-			PUT_SEL32V(segMan, client, x, oldx);
-			PUT_SEL32V(segMan, client, y, oldy);
+			PUT_SEL32V(segMan, client, SELECTOR(x), oldx);
+			PUT_SEL32V(segMan, client, SELECTOR(y), oldy);
 
 			if (s->r_acc.offset) { // We can be here
 				debugC(2, kDebugLevelBresen, "Success");
-				PUT_SEL32V(segMan, client, heading, angle);
+				PUT_SEL32V(segMan, client, SELECTOR(heading), angle);
 
 				return make_reg(0, angle);
 			}
@@ -463,12 +463,12 @@ reg_t kDoAvoider(EngineState *s, int argc, reg_t *argv) {
 
 		warning("DoAvoider failed for avoider %04x:%04x", PRINT_REG(avoider));
 	} else {
-		int heading = GET_SEL32V(segMan, client, heading);
+		int heading = GET_SEL32V(segMan, client, SELECTOR(heading));
 
 		if (heading == -1)
 			return s->r_acc; // No change
 
-		PUT_SEL32V(segMan, client, heading, angle);
+		PUT_SEL32V(segMan, client, SELECTOR(heading), angle);
 
 		s->r_acc = make_reg(0, angle);
 
diff --git a/engines/sci/engine/kparse.cpp b/engines/sci/engine/kparse.cpp
index 4423b6928e..6901274575 100644
--- a/engines/sci/engine/kparse.cpp
+++ b/engines/sci/engine/kparse.cpp
@@ -63,7 +63,7 @@ reg_t kSaid(EngineState *s, int argc, reg_t *argv) {
 		s->_voc->decipherSaidBlock(said_block);
 #endif
 
-	if (s->_voc->parser_event.isNull() || (GET_SEL32V(s->_segMan, s->_voc->parser_event, claimed))) {
+	if (s->_voc->parser_event.isNull() || (GET_SEL32V(s->_segMan, s->_voc->parser_event, SELECTOR(claimed)))) {
 		return NULL_REG;
 	}
 
@@ -77,7 +77,7 @@ reg_t kSaid(EngineState *s, int argc, reg_t *argv) {
 		s->r_acc = make_reg(0, 1);
 
 		if (new_lastmatch != SAID_PARTIAL_MATCH)
-			PUT_SEL32V(s->_segMan, s->_voc->parser_event, claimed, 1);
+			PUT_SEL32V(s->_segMan, s->_voc->parser_event, SELECTOR(claimed), 1);
 
 	} else {
 		return NULL_REG;
@@ -115,7 +115,7 @@ reg_t kParse(EngineState *s, int argc, reg_t *argv) {
 
 		if (syntax_fail) {
 			s->r_acc = make_reg(0, 1);
-			PUT_SEL32V(segMan, event, claimed, 1);
+			PUT_SEL32V(segMan, event, SELECTOR(claimed), 1);
 
 			invoke_selector(INV_SEL(s->_gameObj, syntaxFail, kStopOnInvalidSelector), 2, s->_voc->parser_base, stringpos);
 			/* Issue warning */
@@ -124,7 +124,7 @@ reg_t kParse(EngineState *s, int argc, reg_t *argv) {
 
 		} else {
 			s->_voc->parserIsValid = true;
-			PUT_SEL32V(segMan, event, claimed, 0);
+			PUT_SEL32V(segMan, event, SELECTOR(claimed), 0);
 
 #ifdef DEBUG_PARSER
 			s->_voc->dumpParseTree();
@@ -134,7 +134,7 @@ reg_t kParse(EngineState *s, int argc, reg_t *argv) {
 	} else {
 
 		s->r_acc = make_reg(0, 0);
-		PUT_SEL32V(segMan, event, claimed, 1);
+		PUT_SEL32V(segMan, event, SELECTOR(claimed), 1);
 		if (error) {
 			s->_segMan->strcpy(s->_voc->parser_base, error);
 			debugC(2, kDebugLevelParser, "Word unknown: %s", error);
@@ -163,14 +163,14 @@ reg_t kSetSynonyms(EngineState *s, int argc, reg_t *argv) {
 
 	s->_voc->clearSynonyms();
 
-	list = s->_segMan->lookupList(GET_SEL32(segMan, object, elements));
+	list = s->_segMan->lookupList(GET_SEL32(segMan, object, SELECTOR(elements)));
 	node = s->_segMan->lookupNode(list->first);
 
 	while (node) {
 		reg_t objpos = node->value;
 		int seg;
 
-		script = GET_SEL32V(segMan, objpos, number);
+		script = GET_SEL32V(segMan, objpos, SELECTOR(number));
 		seg = s->_segMan->getScriptSegment(script);
 
 		if (seg > 0)
diff --git a/engines/sci/engine/kpathing.cpp b/engines/sci/engine/kpathing.cpp
index 5598b966a9..2865e0fdac 100644
--- a/engines/sci/engine/kpathing.cpp
+++ b/engines/sci/engine/kpathing.cpp
@@ -335,15 +335,15 @@ static void draw_point(EngineState *s, Common::Point p, int start, int width, in
 
 static void draw_polygon(EngineState *s, reg_t polygon, int width, int height) {
 	SegManager *segMan = s->_segMan;
-	reg_t points = GET_SEL32(segMan, polygon, points);
+	reg_t points = GET_SEL32(segMan, polygon, SELECTOR(points));
 
 #ifdef ENABLE_SCI32
 	if (segMan->isHeapObject(points))
-		points = GET_SEL32(segMan, points, data);
+		points = GET_SEL32(segMan, points, SELECTOR(data));
 #endif
 
-	int size = GET_SEL32(segMan, polygon, size).toUint16();
-	int type = GET_SEL32(segMan, polygon, type).toUint16();
+	int size = GET_SEL32V(segMan, polygon, SELECTOR(size));
+	int type = GET_SEL32V(segMan, polygon, SELECTOR(type));
 	Common::Point first, prev;
 	int i;
 
@@ -384,15 +384,15 @@ static void draw_input(EngineState *s, reg_t poly_list, Common::Point start, Com
 }
 
 static void print_polygon(SegManager *segMan, reg_t polygon) {
-	reg_t points = GET_SEL32(segMan, polygon, points);
+	reg_t points = GET_SEL32(segMan, polygon, SELECTOR(points));
 
 #ifdef ENABLE_SCI32
 	if (segMan->isHeapObject(points))
-		points = GET_SEL32(segMan, points, data);
+		points = GET_SEL32(segMan, points, SELECTOR(data));
 #endif
 
-	int size = GET_SEL32(segMan, polygon, size).toUint16();
-	int type = GET_SEL32(segMan, polygon, type).toUint16();
+	int size = GET_SEL32V(segMan, polygon, SELECTOR(size));
+	int type = GET_SEL32V(segMan, polygon, SELECTOR(type));
 	int i;
 	Common::Point point;
 
@@ -1034,13 +1034,13 @@ static Polygon *convert_polygon(EngineState *s, reg_t polygon) {
 	// Returns   : (Polygon *) The converted polygon, or NULL on error
 	SegManager *segMan = s->_segMan;
 	int i;
-	reg_t points = GET_SEL32(segMan, polygon, points);
-	int size = GET_SEL32(segMan, polygon, size).toUint16();
+	reg_t points = GET_SEL32(segMan, polygon, SELECTOR(points));
+	int size = GET_SEL32V(segMan, polygon, SELECTOR(size));
 
 #ifdef ENABLE_SCI32
 	// SCI32 stores the actual points in the data property of points (in a new array)
 	if (segMan->isHeapObject(points))
-		points = GET_SEL32(segMan, points, data);
+		points = GET_SEL32(segMan, points, SELECTOR(data));
 #endif
 
 	if (size == 0) {
@@ -1048,7 +1048,7 @@ static Polygon *convert_polygon(EngineState *s, reg_t polygon) {
 		return NULL;
 	}
 
-	Polygon *poly = new Polygon(GET_SEL32(segMan, polygon, type).toUint16());
+	Polygon *poly = new Polygon(GET_SEL32V(segMan, polygon, SELECTOR(type)));
 
 	int skip = 0;
 
@@ -1119,7 +1119,7 @@ static PathfindingState *convert_polygon_set(EngineState *s, reg_t poly_list, Co
 
 			if (polygon) {
 				pf_s->polygons.push_back(polygon);
-				count += GET_SEL32(segMan, node->value, size).toUint16();
+				count += GET_SEL32V(segMan, node->value, SELECTOR(size));
 			}
 
 			node = s->_segMan->lookupNode(node->succ);
@@ -1392,7 +1392,7 @@ reg_t kAvoidPath(EngineState *s, int argc, reg_t *argv) {
 			if (argc < 7)
 				error("[avoidpath] Not enough arguments");
 
-			poly_list = GET_SEL32(s->_segMan, argv[4], elements);
+			poly_list = GET_SEL32(s->_segMan, argv[4], SELECTOR(elements));
 			width = argv[5].toUint16();
 			height = argv[6].toUint16();
 			if (argc > 7)
diff --git a/engines/sci/engine/kstring.cpp b/engines/sci/engine/kstring.cpp
index dad3727f32..c11e7fc28b 100644
--- a/engines/sci/engine/kstring.cpp
+++ b/engines/sci/engine/kstring.cpp
@@ -275,7 +275,7 @@ reg_t kFormat(EngineState *s, int argc, reg_t *argv) {
 #ifdef ENABLE_SCI32
 				// If the string is a string object, get to the actual string in the data selector
 				if (s->_segMan->isObject(reg)) 
-					reg = GET_SEL32(s->_segMan, reg, data);
+					reg = GET_SEL32(s->_segMan, reg, SELECTOR(data));
 #endif
 
 				Common::String tempsource = (reg == NULL_REG) ? "" : kernel_lookup_text(s, reg,
diff --git a/engines/sci/engine/selector.h b/engines/sci/engine/selector.h
index 0cc0935377..f74ec45213 100644
--- a/engines/sci/engine/selector.h
+++ b/engines/sci/engine/selector.h
@@ -42,16 +42,23 @@ enum SelectorInvocation {
 	kContinueOnInvalidSelector = 1
 };
 
+
+/**
+ * Map a selector name to a selector id. Shortcut for accessing the selector cache.
+ */
+#define SELECTOR(_slc_)		(((SciEngine *)g_engine)->getKernel()->_selectorCache._slc_)
+//#define SELECTOR(_slc_)		_slc_
+
 /**
  * Retrieves a selector from an object.
  * @param segMan	the segment mananger
  * @param _obj_		the address of the object which the selector should be read from
- * @param _slc_		the selector to read
+ * @param _slc_		the selector to refad
  * @return			the selector value as a reg_t
  * This macro halts on error. 'selector' must be a selector name registered in vm.h's
  * SelectorCache and mapped in script.cpp.
  */
-#define GET_SEL32(segMan, _obj_, _slc_) read_selector(segMan, _obj_, ((SciEngine *)g_engine)->getKernel()->_selectorCache._slc_)
+#define GET_SEL32(segMan, _obj_, _slc_) read_selector(segMan, _obj_, _slc_)
 #define GET_SEL32V(segMan, _obj_, _slc_) (GET_SEL32(segMan, _obj_, _slc_).offset)
 
 /**
@@ -63,7 +70,7 @@ enum SelectorInvocation {
  * This macro halts on error. 'selector' must be a selector name registered in vm.h's
  * SelectorCache and mapped in script.cpp.
  */
-#define PUT_SEL32(segMan, _obj_, _slc_, _val_) write_selector(segMan, _obj_, ((SciEngine *)g_engine)->getKernel()->_selectorCache._slc_, _val_)
+#define PUT_SEL32(segMan, _obj_, _slc_, _val_) write_selector(segMan, _obj_, _slc_, _val_)
 #define PUT_SEL32V(segMan, _obj_, _slc_, _val_) PUT_SEL32(segMan, _obj_, _slc_, make_reg(0, _val_))
 
 
diff --git a/engines/sci/engine/state.cpp b/engines/sci/engine/state.cpp
index 89078e6381..f557bf618b 100644
--- a/engines/sci/engine/state.cpp
+++ b/engines/sci/engine/state.cpp
@@ -149,7 +149,7 @@ kLanguage EngineState::getLanguage() {
 	lang = K_LANG_ENGLISH;
 
 	if (_kernel->_selectorCache.printLang != -1) {
-		lang = (kLanguage)GET_SEL32V(_segMan, _gameObj, printLang);
+		lang = (kLanguage)GET_SEL32V(_segMan, _gameObj, SELECTOR(printLang));
 
 		if ((getSciVersion() >= SCI_VERSION_1_1) || (lang == K_LANG_NONE)) {
 			// If language is set to none, we use the language from the game detector.
@@ -184,7 +184,7 @@ kLanguage EngineState::getLanguage() {
 			}
 
 			// Store language in printLang selector
-			PUT_SEL32V(_segMan, _gameObj, printLang, lang);
+			PUT_SEL32V(_segMan, _gameObj, SELECTOR(printLang), lang);
 		}
 	}
 
@@ -196,7 +196,7 @@ Common::String EngineState::strSplit(const char *str, const char *sep) {
 	kLanguage subLang = K_LANG_NONE;
 
 	if (_kernel->_selectorCache.subtitleLang != -1) {
-		subLang = (kLanguage)GET_SEL32V(_segMan, _gameObj, subtitleLang);
+		subLang = (kLanguage)GET_SEL32V(_segMan, _gameObj, SELECTOR(subtitleLang));
 	}
 
 	Common::String retval = getLanguageString(str, lang);
diff --git a/engines/sci/graphics/animate.cpp b/engines/sci/graphics/animate.cpp
index abf386d934..b42a794399 100644
--- a/engines/sci/graphics/animate.cpp
+++ b/engines/sci/graphics/animate.cpp
@@ -92,7 +92,7 @@ bool GfxAnimate::invoke(List *list, int argc, reg_t *argv) {
 			}
 		}
 
-		signal = GET_SEL32V(_s->_segMan, curObject, signal);
+		signal = GET_SEL32V(_s->_segMan, curObject, SELECTOR(signal));
 		if (!(signal & kSignalFrozen)) {
 			// Call .doit method of that object
 			invoke_selector(_s, curObject, _s->_kernel->_selectorCache.doit, kContinueOnInvalidSelector, argc, argv, 0);
@@ -153,21 +153,21 @@ void GfxAnimate::makeSortedList(List *list) {
 		listEntry->object = curObject;
 
 		// Get data from current object
-		listEntry->viewId = GET_SEL32V(_s->_segMan, curObject, view);
-		listEntry->loopNo = GET_SEL32V(_s->_segMan, curObject, loop);
-		listEntry->celNo = GET_SEL32V(_s->_segMan, curObject, cel);
-		listEntry->paletteNo = GET_SEL32V(_s->_segMan, curObject, palette);
-		listEntry->x = GET_SEL32V(_s->_segMan, curObject, x);
-		listEntry->y = GET_SEL32V(_s->_segMan, curObject, y);
-		listEntry->z = GET_SEL32V(_s->_segMan, curObject, z);
-		listEntry->priority = GET_SEL32V(_s->_segMan, curObject, priority);
-		listEntry->signal = GET_SEL32V(_s->_segMan, curObject, signal);
+		listEntry->viewId = GET_SEL32V(_s->_segMan, curObject, SELECTOR(view));
+		listEntry->loopNo = GET_SEL32V(_s->_segMan, curObject, SELECTOR(loop));
+		listEntry->celNo = GET_SEL32V(_s->_segMan, curObject, SELECTOR(cel));
+		listEntry->paletteNo = GET_SEL32V(_s->_segMan, curObject, SELECTOR(palette));
+		listEntry->x = GET_SEL32V(_s->_segMan, curObject, SELECTOR(x));
+		listEntry->y = GET_SEL32V(_s->_segMan, curObject, SELECTOR(y));
+		listEntry->z = GET_SEL32V(_s->_segMan, curObject, SELECTOR(z));
+		listEntry->priority = GET_SEL32V(_s->_segMan, curObject, SELECTOR(priority));
+		listEntry->signal = GET_SEL32V(_s->_segMan, curObject, SELECTOR(signal));
 		if (getSciVersion() >= SCI_VERSION_1_1) {
 			// Cel scaling
-			listEntry->scaleSignal = GET_SEL32V(_s->_segMan, curObject, scaleSignal);
+			listEntry->scaleSignal = GET_SEL32V(_s->_segMan, curObject, SELECTOR(scaleSignal));
 			if (listEntry->scaleSignal & kScaleSignalDoScaling) {
-				listEntry->scaleX = GET_SEL32V(_s->_segMan, curObject, scaleX);
-				listEntry->scaleY = GET_SEL32V(_s->_segMan, curObject, scaleY);
+				listEntry->scaleX = GET_SEL32V(_s->_segMan, curObject, SELECTOR(scaleX));
+				listEntry->scaleY = GET_SEL32V(_s->_segMan, curObject, SELECTOR(scaleY));
 			} else {
 				listEntry->scaleX = 128;
 				listEntry->scaleY = 128;
@@ -219,11 +219,11 @@ void GfxAnimate::fill(byte &old_picNotValid) {
 		// adjust loop and cel, if any of those is invalid
 		if (listEntry->loopNo >= view->getLoopCount()) {
 			listEntry->loopNo = 0;
-			PUT_SEL32V(_s->_segMan, curObject, loop, listEntry->loopNo);
+			PUT_SEL32V(_s->_segMan, curObject, SELECTOR(loop), listEntry->loopNo);
 		}
 		if (listEntry->celNo >= view->getCelCount(listEntry->loopNo)) {
 			listEntry->celNo = 0;
-			PUT_SEL32V(_s->_segMan, curObject, cel, listEntry->celNo);
+			PUT_SEL32V(_s->_segMan, curObject, SELECTOR(cel), listEntry->celNo);
 		}
 
 		// Create rect according to coordinates and given cel
@@ -232,17 +232,17 @@ void GfxAnimate::fill(byte &old_picNotValid) {
 		} else {
 			view->getCelRect(listEntry->loopNo, listEntry->celNo, listEntry->x, listEntry->y, listEntry->z, &listEntry->celRect);
 		}
-		PUT_SEL32V(_s->_segMan, curObject, nsLeft, listEntry->celRect.left);
-		PUT_SEL32V(_s->_segMan, curObject, nsTop, listEntry->celRect.top);
-		PUT_SEL32V(_s->_segMan, curObject, nsRight, listEntry->celRect.right);
-		PUT_SEL32V(_s->_segMan, curObject, nsBottom, listEntry->celRect.bottom);
+		PUT_SEL32V(_s->_segMan, curObject, SELECTOR(nsLeft), listEntry->celRect.left);
+		PUT_SEL32V(_s->_segMan, curObject, SELECTOR(nsTop), listEntry->celRect.top);
+		PUT_SEL32V(_s->_segMan, curObject, SELECTOR(nsRight), listEntry->celRect.right);
+		PUT_SEL32V(_s->_segMan, curObject, SELECTOR(nsBottom), listEntry->celRect.bottom);
 
 		signal = listEntry->signal;
 
 		// Calculate current priority according to y-coordinate
 		if (!(signal & kSignalFixedPriority)) {
 			listEntry->priority = _ports->kernelCoordinateToPriority(listEntry->y);
-			PUT_SEL32V(_s->_segMan, curObject, priority, listEntry->priority);
+			PUT_SEL32V(_s->_segMan, curObject, SELECTOR(priority), listEntry->priority);
 		}
 
 		if (signal & kSignalNoUpdate) {
@@ -282,14 +282,14 @@ void GfxAnimate::update() {
 
 		if (signal & kSignalNoUpdate) {
 			if (!(signal & kSignalRemoveView)) {
-				bitsHandle = GET_SEL32(_s->_segMan, curObject, underBits);
+				bitsHandle = GET_SEL32(_s->_segMan, curObject, SELECTOR(underBits));
 				if (_screen->_picNotValid != 1) {
 					_paint16->bitsRestore(bitsHandle);
 					listEntry->showBitsFlag = true;
 				} else	{
 					_paint16->bitsFree(bitsHandle);
 				}
-				PUT_SEL32V(_s->_segMan, curObject, underBits, 0);
+				PUT_SEL32V(_s->_segMan, curObject, SELECTOR(underBits), 0);
 			}
 			signal &= 0xFFFF ^ kSignalForceUpdate;
 			signal &= signal & kSignalViewUpdated ? 0xFFFF ^ (kSignalViewUpdated | kSignalNoUpdate) : 0xFFFF;
@@ -339,7 +339,7 @@ void GfxAnimate::update() {
 					bitsHandle = _paint16->bitsSave(listEntry->celRect, SCI_SCREEN_MASK_VISUAL|SCI_SCREEN_MASK_PRIORITY);
 				else
 					bitsHandle = _paint16->bitsSave(listEntry->celRect, SCI_SCREEN_MASK_ALL);
-				PUT_SEL32(_s->_segMan, curObject, underBits, bitsHandle);
+				PUT_SEL32(_s->_segMan, curObject, SELECTOR(underBits), bitsHandle);
 			}
 			listEntry->signal = signal;
 		}
@@ -387,7 +387,7 @@ void GfxAnimate::drawCels() {
 		if (!(signal & (kSignalNoUpdate | kSignalHidden | kSignalAlwaysUpdate))) {
 			// Save background
 			bitsHandle = _paint16->bitsSave(listEntry->celRect, SCI_SCREEN_MASK_ALL);
-			PUT_SEL32(_s->_segMan, curObject, underBits, bitsHandle);
+			PUT_SEL32(_s->_segMan, curObject, SELECTOR(underBits), bitsHandle);
 
 			// draw corresponding cel
 			_paint16->drawCel(listEntry->viewId, listEntry->loopNo, listEntry->celNo, listEntry->celRect, listEntry->priority, listEntry->paletteNo, listEntry->scaleX, listEntry->scaleY);
@@ -423,10 +423,10 @@ void GfxAnimate::updateScreen(byte oldPicNotValid) {
 
 		if (listEntry->showBitsFlag || !(signal & (kSignalRemoveView | kSignalNoUpdate) ||
 										(!(signal & kSignalRemoveView) && (signal & kSignalNoUpdate) && oldPicNotValid))) {
-			lsRect.left = GET_SEL32V(_s->_segMan, curObject, lsLeft);
-			lsRect.top = GET_SEL32V(_s->_segMan, curObject, lsTop);
-			lsRect.right = GET_SEL32V(_s->_segMan, curObject, lsRight);
-			lsRect.bottom = GET_SEL32V(_s->_segMan, curObject, lsBottom);
+			lsRect.left = GET_SEL32V(_s->_segMan, curObject, SELECTOR(lsLeft));
+			lsRect.top = GET_SEL32V(_s->_segMan, curObject, SELECTOR(lsTop));
+			lsRect.right = GET_SEL32V(_s->_segMan, curObject, SELECTOR(lsRight));
+			lsRect.bottom = GET_SEL32V(_s->_segMan, curObject, SELECTOR(lsBottom));
 
 			workerRect = lsRect;
 			workerRect.clip(listEntry->celRect);
@@ -438,10 +438,10 @@ void GfxAnimate::updateScreen(byte oldPicNotValid) {
 				_paint16->bitsShow(lsRect);
 				workerRect = listEntry->celRect;
 			}
-			PUT_SEL32V(_s->_segMan, curObject, lsLeft, workerRect.left);
-			PUT_SEL32V(_s->_segMan, curObject, lsTop, workerRect.top);
-			PUT_SEL32V(_s->_segMan, curObject, lsRight, workerRect.right);
-			PUT_SEL32V(_s->_segMan, curObject, lsBottom, workerRect.bottom);
+			PUT_SEL32V(_s->_segMan, curObject, SELECTOR(lsLeft), workerRect.left);
+			PUT_SEL32V(_s->_segMan, curObject, SELECTOR(lsTop), workerRect.top);
+			PUT_SEL32V(_s->_segMan, curObject, SELECTOR(lsRight), workerRect.right);
+			PUT_SEL32V(_s->_segMan, curObject, SELECTOR(lsBottom), workerRect.bottom);
 			_paint16->bitsShow(workerRect);
 
 			if (signal & kSignalHidden) {
@@ -472,7 +472,7 @@ void GfxAnimate::restoreAndDelete(int argc, reg_t *argv) {
 		signal = listEntry->signal;
 
 		// Finally update signal
-		PUT_SEL32V(_s->_segMan, curObject, signal, signal);
+		PUT_SEL32V(_s->_segMan, curObject, SELECTOR(signal), signal);
 		listIterator++;
 	}
 
@@ -481,11 +481,11 @@ void GfxAnimate::restoreAndDelete(int argc, reg_t *argv) {
 		listEntry = *listIterator;
 		curObject = listEntry->object;
 		// We read out signal here again, this is not by accident but to ensure that we got an up-to-date signal
-		signal = GET_SEL32V(_s->_segMan, curObject, signal);
+		signal = GET_SEL32V(_s->_segMan, curObject, SELECTOR(signal));
 
 		if ((signal & (kSignalNoUpdate | kSignalRemoveView)) == 0) {
-			_paint16->bitsRestore(GET_SEL32(_s->_segMan, curObject, underBits));
-			PUT_SEL32V(_s->_segMan, curObject, underBits, 0);
+			_paint16->bitsRestore(GET_SEL32(_s->_segMan, curObject, SELECTOR(underBits)));
+			PUT_SEL32V(_s->_segMan, curObject, SELECTOR(underBits), 0);
 		}
 
 		if (signal & kSignalDisposeMe) {
diff --git a/engines/sci/graphics/compare.cpp b/engines/sci/graphics/compare.cpp
index 82a5d04c44..f3d7e4b6cc 100644
--- a/engines/sci/graphics/compare.cpp
+++ b/engines/sci/graphics/compare.cpp
@@ -86,14 +86,17 @@ bool GfxCompare::canBeHereCheckRectList(reg_t checkObject, Common::Rect checkRec
 	while (curNode) {
 		curObject = curNode->value;
 		if (curObject != checkObject) {
-			signal = GET_SEL32V(_segMan, curObject, signal);
+			signal = GET_SEL32V(_segMan, curObject, SELECTOR(signal));
 			if ((signal & (kSignalIgnoreActor | kSignalRemoveView | kSignalNoUpdate)) == 0) {
-				curRect.left = GET_SEL32V(_segMan, curObject, brLeft);
-				curRect.top = GET_SEL32V(_segMan, curObject, brTop);
-				curRect.right = GET_SEL32V(_segMan, curObject, brRight);
-				curRect.bottom = GET_SEL32V(_segMan, curObject, brBottom);
+				curRect.left = GET_SEL32V(_segMan, curObject, SELECTOR(brLeft));
+				curRect.top = GET_SEL32V(_segMan, curObject, SELECTOR(brTop));
+				curRect.right = GET_SEL32V(_segMan, curObject, SELECTOR(brRight));
+				curRect.bottom = GET_SEL32V(_segMan, curObject, SELECTOR(brBottom));
 				// Check if curRect is within checkRect
-				if (curRect.right > checkRect.left && curRect.left < checkRect.right && curRect.bottom > checkRect.top && curRect.top < checkRect.bottom) {
+				if (curRect.right > checkRect.left &&
+				    curRect.left < checkRect.right &&
+				    curRect.bottom > checkRect.top &&
+				    curRect.top < checkRect.bottom) {
 					return false;
 				}
 			}
@@ -114,14 +117,14 @@ uint16 GfxCompare::kernelOnControl(byte screenMask, Common::Rect rect) {
 void GfxCompare::kernelSetNowSeen(reg_t objectReference) {
 	GfxView *view = NULL;
 	Common::Rect celRect(0, 0);
-	GuiResourceId viewId = (GuiResourceId)GET_SEL32V(_segMan, objectReference, view);
-	int16 loopNo = sign_extend_byte((int16)GET_SEL32V(_segMan, objectReference, loop));
-	int16 celNo = sign_extend_byte((int16)GET_SEL32V(_segMan, objectReference, cel));
-	int16 x = (int16)GET_SEL32V(_segMan, objectReference, x);
-	int16 y = (int16)GET_SEL32V(_segMan, objectReference, y);
+	GuiResourceId viewId = (GuiResourceId)GET_SEL32V(_segMan, objectReference, SELECTOR(view));
+	int16 loopNo = sign_extend_byte((int16)GET_SEL32V(_segMan, objectReference, SELECTOR(loop)));
+	int16 celNo = sign_extend_byte((int16)GET_SEL32V(_segMan, objectReference, SELECTOR(cel)));
+	int16 x = (int16)GET_SEL32V(_segMan, objectReference, SELECTOR(x));
+	int16 y = (int16)GET_SEL32V(_segMan, objectReference, SELECTOR(y));
 	int16 z = 0;
 	if (_kernel->_selectorCache.z > -1)
-		z = (int16)GET_SEL32V(_segMan, objectReference, z);
+		z = (int16)GET_SEL32V(_segMan, objectReference, SELECTOR(z));
 
 	// now get cel rectangle
 	view = _cache->getView(viewId);
@@ -129,10 +132,10 @@ void GfxCompare::kernelSetNowSeen(reg_t objectReference) {
 
 	// TODO: sometimes loop is negative. Check what it means
 	if (lookup_selector(_segMan, objectReference, _kernel->_selectorCache.nsTop, NULL, NULL) == kSelectorVariable) {
-		PUT_SEL32V(_segMan, objectReference, nsLeft, celRect.left);
-		PUT_SEL32V(_segMan, objectReference, nsRight, celRect.right);
-		PUT_SEL32V(_segMan, objectReference, nsTop, celRect.top);
-		PUT_SEL32V(_segMan, objectReference, nsBottom, celRect.bottom);
+		PUT_SEL32V(_segMan, objectReference, SELECTOR(nsLeft), celRect.left);
+		PUT_SEL32V(_segMan, objectReference, SELECTOR(nsRight), celRect.right);
+		PUT_SEL32V(_segMan, objectReference, SELECTOR(nsTop), celRect.top);
+		PUT_SEL32V(_segMan, objectReference, SELECTOR(nsBottom), celRect.bottom);
 	}
 }
 
@@ -142,15 +145,15 @@ bool GfxCompare::kernelCanBeHere(reg_t curObject, reg_t listReference) {
 	uint16 signal, controlMask;
 	bool result;
 
-	checkRect.left = GET_SEL32V(_segMan, curObject, brLeft);
-	checkRect.top = GET_SEL32V(_segMan, curObject, brTop);
-	checkRect.right = GET_SEL32V(_segMan, curObject, brRight);
-	checkRect.bottom = GET_SEL32V(_segMan, curObject, brBottom);
+	checkRect.left = GET_SEL32V(_segMan, curObject, SELECTOR(brLeft));
+	checkRect.top = GET_SEL32V(_segMan, curObject, SELECTOR(brTop));
+	checkRect.right = GET_SEL32V(_segMan, curObject, SELECTOR(brRight));
+	checkRect.bottom = GET_SEL32V(_segMan, curObject, SELECTOR(brBottom));
 
 	adjustedRect = _coordAdjuster->onControl(checkRect);
 
-	signal = GET_SEL32V(_segMan, curObject, signal);
-	controlMask = GET_SEL32V(_segMan, curObject, illegalBits);
+	signal = GET_SEL32V(_segMan, curObject, SELECTOR(signal));
+	controlMask = GET_SEL32V(_segMan, curObject, SELECTOR(illegalBits));
 	result = (isOnControl(SCI_SCREEN_MASK_CONTROL, adjustedRect) & controlMask) ? false : true;
 	if ((result) && (signal & (kSignalIgnoreActor | kSignalRemoveView)) == 0) {
 		List *list = _segMan->lookupList(listReference);
@@ -174,13 +177,13 @@ bool GfxCompare::kernelIsItSkip(GuiResourceId viewId, int16 loopNo, int16 celNo,
 
 void GfxCompare::kernelBaseSetter(reg_t object) {
 	if (lookup_selector(_segMan, object, _kernel->_selectorCache.brLeft, NULL, NULL) == kSelectorVariable) {
-		int16 x = GET_SEL32V(_segMan, object, x);
-		int16 y = GET_SEL32V(_segMan, object, y);
-		int16 z = (_kernel->_selectorCache.z > -1) ? GET_SEL32V(_segMan, object, z) : 0;
-		int16 yStep = GET_SEL32V(_segMan, object, yStep);
-		GuiResourceId viewId = GET_SEL32V(_segMan, object, view);
-		int16 loopNo = GET_SEL32V(_segMan, object, loop);
-		int16 celNo = GET_SEL32V(_segMan, object, cel);
+		int16 x = GET_SEL32V(_segMan, object, SELECTOR(x));
+		int16 y = GET_SEL32V(_segMan, object, SELECTOR(y));
+		int16 z = (_kernel->_selectorCache.z > -1) ? GET_SEL32V(_segMan, object, SELECTOR(z)) : 0;
+		int16 yStep = GET_SEL32V(_segMan, object, SELECTOR(yStep));
+		GuiResourceId viewId = GET_SEL32V(_segMan, object, SELECTOR(view));
+		int16 loopNo = GET_SEL32V(_segMan, object, SELECTOR(loop));
+		int16 celNo = GET_SEL32V(_segMan, object, SELECTOR(cel));
 
 		GfxView *tmpView = _cache->getView(viewId);
 		Common::Rect celRect;
@@ -189,10 +192,10 @@ void GfxCompare::kernelBaseSetter(reg_t object) {
 		celRect.bottom = y + 1;
 		celRect.top = celRect.bottom - yStep;
 
-		PUT_SEL32V(_segMan, object, brLeft, celRect.left);
-		PUT_SEL32V(_segMan, object, brRight, celRect.right);
-		PUT_SEL32V(_segMan, object, brTop, celRect.top);
-		PUT_SEL32V(_segMan, object, brBottom, celRect.bottom);
+		PUT_SEL32V(_segMan, object, SELECTOR(brLeft), celRect.left);
+		PUT_SEL32V(_segMan, object, SELECTOR(brRight), celRect.right);
+		PUT_SEL32V(_segMan, object, SELECTOR(brTop), celRect.top);
+		PUT_SEL32V(_segMan, object, SELECTOR(brBottom), celRect.bottom);
 	}
 }
 
diff --git a/engines/sci/graphics/controls.cpp b/engines/sci/graphics/controls.cpp
index 7bfe050db9..5572d04ec5 100644
--- a/engines/sci/graphics/controls.cpp
+++ b/engines/sci/graphics/controls.cpp
@@ -142,9 +142,9 @@ void GfxControls::texteditSetBlinkTime() {
 }
 
 void GfxControls::kernelTexteditChange(reg_t controlObject, reg_t eventObject) {
-	uint16 cursorPos = GET_SEL32V(_segMan, controlObject, cursor);
-	uint16 maxChars = GET_SEL32V(_segMan, controlObject, max);
-	reg_t textReference = GET_SEL32(_segMan, controlObject, text);
+	uint16 cursorPos = GET_SEL32V(_segMan, controlObject, SELECTOR(cursor));
+	uint16 maxChars = GET_SEL32V(_segMan, controlObject, SELECTOR(max));
+	reg_t textReference = GET_SEL32(_segMan, controlObject, SELECTOR(text));
 	Common::String text;
 	uint16 textSize, eventType, eventKey;
 	bool textChanged = false;
@@ -156,14 +156,14 @@ void GfxControls::kernelTexteditChange(reg_t controlObject, reg_t eventObject) {
 
 	if (!eventObject.isNull()) {
 		textSize = text.size();
-		eventType = GET_SEL32V(_segMan, eventObject, type);
+		eventType = GET_SEL32V(_segMan, eventObject, SELECTOR(type));
 
 		switch (eventType) {
 		case SCI_EVENT_MOUSE_PRESS:
 			// TODO: Implement mouse support for cursor change
 			break;
 		case SCI_EVENT_KEYBOARD:
-			eventKey = GET_SEL32V(_segMan, eventObject, message);
+			eventKey = GET_SEL32V(_segMan, eventObject, SELECTOR(message));
 			switch (eventKey) {
 			case SCI_KEY_BACKSPACE:
 				if (cursorPos > 0) {
@@ -207,9 +207,9 @@ void GfxControls::kernelTexteditChange(reg_t controlObject, reg_t eventObject) {
 
 	if (textChanged) {
 		GuiResourceId oldFontId = _text16->GetFontId();
-		GuiResourceId fontId = GET_SEL32V(_segMan, controlObject, font);
-		rect = Common::Rect(GET_SEL32V(_segMan, controlObject, nsLeft), GET_SEL32V(_segMan, controlObject, nsTop),
-							  GET_SEL32V(_segMan, controlObject, nsRight), GET_SEL32V(_segMan, controlObject, nsBottom));
+		GuiResourceId fontId = GET_SEL32V(_segMan, controlObject, SELECTOR(font));
+		rect = Common::Rect(GET_SEL32V(_segMan, controlObject, SELECTOR(nsLeft)), GET_SEL32V(_segMan, controlObject, SELECTOR(nsTop)),
+							  GET_SEL32V(_segMan, controlObject, SELECTOR(nsRight)), GET_SEL32V(_segMan, controlObject, SELECTOR(nsBottom)));
 		texteditCursorErase();
 		_paint16->eraseRect(rect);
 		_text16->Box(text.c_str(), 0, rect, SCI_TEXT16_ALIGNMENT_LEFT, fontId);
@@ -228,7 +228,7 @@ void GfxControls::kernelTexteditChange(reg_t controlObject, reg_t eventObject) {
 		}
 	}
 
-	PUT_SEL32V(_segMan, controlObject, cursor, cursorPos);
+	PUT_SEL32V(_segMan, controlObject, SELECTOR(cursor), cursorPos);
 }
 
 int GfxControls::getPicNotValid() {
diff --git a/engines/sci/graphics/coordadjuster.cpp b/engines/sci/graphics/coordadjuster.cpp
index 3c9e30c8c8..48f6d0161c 100644
--- a/engines/sci/graphics/coordadjuster.cpp
+++ b/engines/sci/graphics/coordadjuster.cpp
@@ -87,18 +87,18 @@ GfxCoordAdjuster32::~GfxCoordAdjuster32() {
 }
 
 void GfxCoordAdjuster32::kernelGlobalToLocal(int16 &x, int16 &y, reg_t planeObject) {
-	//int16 resY = GET_SEL32V(_s->_segMan, planeObj, resY);
-	//int16 resX = GET_SEL32V(_s->_segMan, planeObj, resX);
+	//int16 resY = GET_SEL32V(_s->_segMan, planeObj, SELECTOR(resY));
+	//int16 resX = GET_SEL32V(_s->_segMan, planeObj, SELECTOR(resX));
 	//*x = ( *x * _screen->getWidth()) / resX;
 	//*y = ( *y * _screen->getHeight()) / resY;
-	x -= GET_SEL32V(_segMan, planeObject, left);
-	y -= GET_SEL32V(_segMan, planeObject, top);
+	x -= GET_SEL32V(_segMan, planeObject, SELECTOR(left));
+	y -= GET_SEL32V(_segMan, planeObject, SELECTOR(top));
 }
 void GfxCoordAdjuster32::kernelLocalToGlobal(int16 &x, int16 &y, reg_t planeObject) {
-	//int16 resY = GET_SEL32V(_s->_segMan, planeObj, resY);
-	//int16 resX = GET_SEL32V(_s->_segMan, planeObj, resX);
-	x += GET_SEL32V(_segMan, planeObject, left);
-	y += GET_SEL32V(_segMan, planeObject, top);
+	//int16 resY = GET_SEL32V(_s->_segMan, planeObj, SELECTOR(resY));
+	//int16 resX = GET_SEL32V(_s->_segMan, planeObj, SELECTOR(resX));
+	x += GET_SEL32V(_segMan, planeObject, SELECTOR(left));
+	y += GET_SEL32V(_segMan, planeObject, SELECTOR(top));
 	//*x = ( *x * resX) / _screen->getWidth();
 	//*y = ( *y * resY) / _screen->getHeight();
 }
diff --git a/engines/sci/graphics/frameout.cpp b/engines/sci/graphics/frameout.cpp
index b00776fda9..f8f44ca1c4 100644
--- a/engines/sci/graphics/frameout.cpp
+++ b/engines/sci/graphics/frameout.cpp
@@ -52,7 +52,7 @@ GfxFrameout::~GfxFrameout() {
 
 void GfxFrameout::kernelAddPlane(reg_t object) {
 	_planes.push_back(object);
-	int16 planePri = GET_SEL32V(_segMan, object, priority) & 0xFFFF;
+	int16 planePri = GET_SEL32V(_segMan, object, SELECTOR(priority)) & 0xFFFF;
 	if (planePri > _highPlanePri)
 		_highPlanePri = planePri;
 }
@@ -72,7 +72,7 @@ void GfxFrameout::kernelDeletePlane(reg_t object) {
 	_highPlanePri = 0;
 
 	for (uint32 planeNr = 0; planeNr < _planes.size(); planeNr++) {
-		int16 planePri = GET_SEL32V(_segMan, _planes[planeNr], priority) & 0xFFFF;
+		int16 planePri = GET_SEL32V(_segMan, _planes[planeNr], SELECTOR(priority)) & 0xFFFF;
 		if (planePri > _highPlanePri)
 			_highPlanePri = planePri;
 	}
@@ -124,29 +124,29 @@ void GfxFrameout::kernelFrameout() {
 
 	for (uint32 planeNr = 0; planeNr < _planes.size(); planeNr++) {
 		planeObject = _planes[planeNr];
-		planePriority = GET_SEL32V(_segMan, planeObject, priority);
+		planePriority = GET_SEL32V(_segMan, planeObject, SELECTOR(priority));
 
 		if (planePriority == -1) // Plane currently not meant to be shown
 			continue;
 
-		planeRect.top = GET_SEL32V(_segMan, planeObject, top);
-		planeRect.left = GET_SEL32V(_segMan, planeObject, left);
-		planeRect.bottom = GET_SEL32V(_segMan, planeObject, bottom);
-		planeRect.right = GET_SEL32V(_segMan, planeObject, right);
-		planeResY = GET_SEL32V(_segMan, planeObject, resY);
-		planeResX = GET_SEL32V(_segMan, planeObject, resX);
+		planeRect.top = GET_SEL32V(_segMan, planeObject, SELECTOR(top));
+		planeRect.left = GET_SEL32V(_segMan, planeObject, SELECTOR(left));
+		planeRect.bottom = GET_SEL32V(_segMan, planeObject, SELECTOR(bottom));
+		planeRect.right = GET_SEL32V(_segMan, planeObject, SELECTOR(right));
+		planeResY = GET_SEL32V(_segMan, planeObject, SELECTOR(resY));
+		planeResX = GET_SEL32V(_segMan, planeObject, SELECTOR(resX));
 
 		planeRect.top = (planeRect.top * _screen->getHeight()) / planeResY;
 		planeRect.left = (planeRect.left * _screen->getWidth()) / planeResX;
 		planeRect.bottom = (planeRect.bottom * _screen->getHeight()) / planeResY;
 		planeRect.right = (planeRect.right * _screen->getWidth()) / planeResX;
 
-		planeBack = GET_SEL32V(_segMan, planeObject, back);
+		planeBack = GET_SEL32V(_segMan, planeObject, SELECTOR(back));
 		if (planeBack) {
 			_paint32->fillRect(planeRect, planeBack);
 		}
 
-		planePictureNr = GET_SEL32V(_segMan, planeObject, picture);
+		planePictureNr = GET_SEL32V(_segMan, planeObject, SELECTOR(picture));
 		if ((planePictureNr != 0xFFFF) && (planePictureNr != 0xFFFE)) {
 			planePicture = new GfxPicture(_resMan, 0, _screen, _palette, planePictureNr, false);
 			planePictureCels = planePicture->getSci32celCount();
@@ -157,19 +157,19 @@ void GfxFrameout::kernelFrameout() {
 		itemEntry = itemData;
 		for (uint32 itemNr = 0; itemNr < _screenItems.size(); itemNr++) {
 			itemObject = _screenItems[itemNr];
-			itemPlane = GET_SEL32(_segMan, itemObject, plane);
+			itemPlane = GET_SEL32(_segMan, itemObject, SELECTOR(plane));
 			if (planeObject == itemPlane) {
 				// Found an item on current plane
-				itemEntry->viewId = GET_SEL32V(_segMan, itemObject, view);
-				itemEntry->loopNo = GET_SEL32V(_segMan, itemObject, loop);
-				itemEntry->celNo = GET_SEL32V(_segMan, itemObject, cel);
-				itemEntry->x = GET_SEL32V(_segMan, itemObject, x);
-				itemEntry->y = GET_SEL32V(_segMan, itemObject, y);
-				itemEntry->z = GET_SEL32V(_segMan, itemObject, z);
-				itemEntry->priority = GET_SEL32V(_segMan, itemObject, priority);
-				itemEntry->signal = GET_SEL32V(_segMan, itemObject, signal);
-				itemEntry->scaleX = GET_SEL32V(_segMan, itemObject, scaleX);
-				itemEntry->scaleY = GET_SEL32V(_segMan, itemObject, scaleY);
+				itemEntry->viewId = GET_SEL32V(_segMan, itemObject, SELECTOR(view));
+				itemEntry->loopNo = GET_SEL32V(_segMan, itemObject, SELECTOR(loop));
+				itemEntry->celNo = GET_SEL32V(_segMan, itemObject, SELECTOR(cel));
+				itemEntry->x = GET_SEL32V(_segMan, itemObject, SELECTOR(x));
+				itemEntry->y = GET_SEL32V(_segMan, itemObject, SELECTOR(y));
+				itemEntry->z = GET_SEL32V(_segMan, itemObject, SELECTOR(z));
+				itemEntry->priority = GET_SEL32V(_segMan, itemObject, SELECTOR(priority));
+				itemEntry->signal = GET_SEL32V(_segMan, itemObject, SELECTOR(signal));
+				itemEntry->scaleX = GET_SEL32V(_segMan, itemObject, SELECTOR(scaleX));
+				itemEntry->scaleY = GET_SEL32V(_segMan, itemObject, SELECTOR(scaleY));
 				itemEntry->object = itemObject;
 
 				itemEntry->y = ((itemEntry->y * _screen->getHeight()) / planeResY);
@@ -235,11 +235,11 @@ void GfxFrameout::kernelFrameout() {
 				// TODO: rewrite this the "SCI2" way (i.e. implement the text buffer to draw inside kCreateTextBitmap)
 				Kernel *kernel = ((SciEngine *)g_engine)->getKernel();
 				if (lookup_selector(_segMan, itemEntry->object, kernel->_selectorCache.text, NULL, NULL) == kSelectorVariable) {
-					Common::String text = _segMan->getString(GET_SEL32(_segMan, itemEntry->object, text));
-					int16 fontRes = GET_SEL32V(_segMan, itemEntry->object, font);
+					Common::String text = _segMan->getString(GET_SEL32(_segMan, itemEntry->object, SELECTOR(text)));
+					int16 fontRes = GET_SEL32V(_segMan, itemEntry->object, SELECTOR(font));
 					GfxFont *font = new GfxFont(_resMan, _screen, fontRes);
-					bool dimmed = GET_SEL32V(_segMan, itemEntry->object, dimmed);
-					uint16 foreColor = GET_SEL32V(_segMan, itemEntry->object, fore);
+					bool dimmed = GET_SEL32V(_segMan, itemEntry->object, SELECTOR(dimmed));
+					uint16 foreColor = GET_SEL32V(_segMan, itemEntry->object, SELECTOR(fore));
 					uint16 curX = itemEntry->x;
 					uint16 curY = itemEntry->y;
 					for (uint32 i = 0; i < text.size(); i++) {
diff --git a/engines/sci/graphics/menu.cpp b/engines/sci/graphics/menu.cpp
index ead575fc80..b5f4335b59 100644
--- a/engines/sci/graphics/menu.cpp
+++ b/engines/sci/graphics/menu.cpp
@@ -352,7 +352,7 @@ void GfxMenu::calculateTextWidth() {
 }
 
 reg_t GfxMenu::kernelSelect(reg_t eventObject) {
-	int16 eventType = GET_SEL32V(_segMan, eventObject, type);
+	int16 eventType = GET_SEL32V(_segMan, eventObject, SELECTOR(type));
 	int16 keyPress, keyModifier;
 	Common::Point mousePosition;
 	GuiMenuItemList::iterator itemIterator = _itemList.begin();
@@ -364,8 +364,8 @@ reg_t GfxMenu::kernelSelect(reg_t eventObject) {
 
 	switch (eventType) {
 	case SCI_EVENT_KEYBOARD:
-		keyPress = GET_SEL32V(_segMan, eventObject, message);
-		keyModifier = GET_SEL32V(_segMan, eventObject, modifiers);
+		keyPress = GET_SEL32V(_segMan, eventObject, SELECTOR(message));
+		keyModifier = GET_SEL32V(_segMan, eventObject, SELECTOR(modifiers));
 		switch (keyPress) {
 		case 0:
 			break;
@@ -434,7 +434,7 @@ reg_t GfxMenu::kernelSelect(reg_t eventObject) {
 		_ports->setPort(_oldPort);
 
 	if ((itemEntry) || (forceClaimed))
-		PUT_SEL32(_segMan, eventObject, claimed, make_reg(0, 1));
+		PUT_SEL32(_segMan, eventObject, SELECTOR(claimed), make_reg(0, 1));
 	if (itemEntry)
 		return make_reg(0, (itemEntry->menuId << 8) | (itemEntry->id));
 	return NULL_REG;
diff --git a/engines/sci/sound/audio.cpp b/engines/sci/sound/audio.cpp
index eecab76f5d..336aa04aef 100644
--- a/engines/sci/sound/audio.cpp
+++ b/engines/sci/sound/audio.cpp
@@ -267,11 +267,11 @@ void AudioPlayer::setSoundSync(ResourceId id, reg_t syncObjAddr, SegManager *seg
 	_syncOffset = 0;
 
 	if (_syncResource) {
-		PUT_SEL32V(segMan, syncObjAddr, syncCue, 0);
+		PUT_SEL32V(segMan, syncObjAddr, SELECTOR(syncCue), 0);
 	} else {
 		warning("setSoundSync: failed to find resource %s", id.toString().c_str());
 		// Notify the scripts to stop sound sync
-		PUT_SEL32V(segMan, syncObjAddr, syncCue, SIGNAL_OFFSET);
+		PUT_SEL32V(segMan, syncObjAddr, SELECTOR(syncCue), SIGNAL_OFFSET);
 	}
 }
 
@@ -287,8 +287,8 @@ void AudioPlayer::doSoundSync(reg_t syncObjAddr, SegManager *segMan) {
 			_syncOffset += 2;
 		}
 
-		PUT_SEL32V(segMan, syncObjAddr, syncTime, syncTime);
-		PUT_SEL32V(segMan, syncObjAddr, syncCue, syncCue);
+		PUT_SEL32V(segMan, syncObjAddr, SELECTOR(syncTime), syncTime);
+		PUT_SEL32V(segMan, syncObjAddr, SELECTOR(syncCue), syncCue);
 	}
 }
 
diff --git a/engines/sci/sound/soundcmd.cpp b/engines/sci/sound/soundcmd.cpp
index a0f0a06ec8..318adf01c9 100644
--- a/engines/sci/sound/soundcmd.cpp
+++ b/engines/sci/sound/soundcmd.cpp
@@ -49,9 +49,9 @@ namespace Sci {
 
 #ifdef USE_OLD_MUSIC_FUNCTIONS
 static void script_set_priority(ResourceManager *resMan, SegManager *segMan, SfxState *state, reg_t obj, int priority) {
-	int song_nr = GET_SEL32V(segMan, obj, number);
+	int song_nr = GET_SEL32V(segMan, obj, SELECTOR(number));
 	Resource *song = resMan->findResource(ResourceId(kResourceTypeSound, song_nr), 0);
-	int flags = GET_SEL32V(segMan, obj, flags);
+	int flags = GET_SEL32V(segMan, obj, SELECTOR(flags));
 
 	if (priority == -1) {
 		if (song->data[0] == 0xf0)
@@ -63,7 +63,7 @@ static void script_set_priority(ResourceManager *resMan, SegManager *segMan, Sfx
 	} else flags |= SCI1_SOUND_FLAG_SCRIPTED_PRI;
 
 	state->sfx_song_renice(FROBNICATE_HANDLE(obj), priority);
-	PUT_SEL32V(segMan, obj, flags, flags);
+	PUT_SEL32V(segMan, obj, SELECTOR(flags), flags);
 }
 
 SongIterator *build_iterator(ResourceManager *resMan, int song_nr, SongIteratorType type, songit_id_t id) {
@@ -97,27 +97,27 @@ void process_sound_events(EngineState *s) { /* Get all sound events, apply their
 		case SI_LOOP:
 			debugC(2, kDebugLevelSound, "[process-sound] Song %04x:%04x looped (to %d)",
 			          PRINT_REG(obj), cue);
-			/*			PUT_SEL32V(segMan, obj, loops, GET_SEL32V(segMan, obj, loop) - 1);*/
-			PUT_SEL32V(segMan, obj, signal, SIGNAL_OFFSET);
+			/*			PUT_SEL32V(segMan, obj, SELECTOR(loops), GET_SEL32V(segMan, obj, SELECTOR(loop));; - 1);*/
+			PUT_SEL32V(segMan, obj, SELECTOR(signal), SIGNAL_OFFSET);
 			break;
 
 		case SI_RELATIVE_CUE:
 			debugC(2, kDebugLevelSound, "[process-sound] Song %04x:%04x received relative cue %d",
 			          PRINT_REG(obj), cue);
-			PUT_SEL32V(segMan, obj, signal, cue + 0x7f);
+			PUT_SEL32V(segMan, obj, SELECTOR(signal), cue + 0x7f);
 			break;
 
 		case SI_ABSOLUTE_CUE:
 			debugC(2, kDebugLevelSound, "[process-sound] Song %04x:%04x received absolute cue %d",
 			          PRINT_REG(obj), cue);
-			PUT_SEL32V(segMan, obj, signal, cue);
+			PUT_SEL32V(segMan, obj, SELECTOR(signal), cue);
 			break;
 
 		case SI_FINISHED:
 			debugC(2, kDebugLevelSound, "[process-sound] Song %04x:%04x finished",
 			          PRINT_REG(obj));
-			PUT_SEL32V(segMan, obj, signal, SIGNAL_OFFSET);
-			PUT_SEL32V(segMan, obj, state, kSoundStopped);
+			PUT_SEL32V(segMan, obj, SELECTOR(signal), SIGNAL_OFFSET);
+			PUT_SEL32V(segMan, obj, SELECTOR(state), kSoundStopped);
 			break;
 
 		default:
@@ -252,7 +252,7 @@ void SoundCommandParser::cmdInitSound(reg_t obj, int16 value) {
 	if (!obj.segment)
 		return;
 
-	int number = GET_SEL32V(_segMan, obj, number);
+	int number = GET_SEL32V(_segMan, obj, SELECTOR(number));
 
 #ifdef USE_OLD_MUSIC_FUNCTIONS
 
@@ -266,7 +266,7 @@ void SoundCommandParser::cmdInitSound(reg_t obj, int16 value) {
 	SongIteratorType type = (_soundVersion <= SCI_VERSION_0_LATE) ? SCI_SONG_ITERATOR_TYPE_SCI0 : SCI_SONG_ITERATOR_TYPE_SCI1;
 
 	if (_soundVersion <= SCI_VERSION_0_LATE) {
-		if (GET_SEL32V(_segMan, obj, nodePtr)) {
+		if (GET_SEL32V(_segMan, obj, SELECTOR(nodePtr));) {
 			_state->sfx_song_set_status(handle, SOUND_STATUS_STOPPED);
 			_state->sfx_remove_song(handle);
 		}
@@ -280,11 +280,11 @@ void SoundCommandParser::cmdInitSound(reg_t obj, int16 value) {
 
 	// Notify the engine
 	if (_soundVersion <= SCI_VERSION_0_LATE)
-		PUT_SEL32V(_segMan, obj, state, kSoundInitialized);
+		PUT_SEL32V(_segMan, obj, SELECTOR(state), kSoundInitialized);
 	else
-		PUT_SEL32(_segMan, obj, nodePtr, obj);
+		PUT_SEL32(_segMan, obj, SELECTOR(nodePtr), obj);
 
-	PUT_SEL32(_segMan, obj, handle, obj);
+	PUT_SEL32(_segMan, obj, SELECTOR(handle), obj);
 
 #else
 
@@ -301,10 +301,10 @@ void SoundCommandParser::cmdInitSound(reg_t obj, int16 value) {
 		newSound->soundRes = 0;
 
 	newSound->soundObj = obj;
-	newSound->loop = GET_SEL32V(_segMan, obj, loop);
-	newSound->prio = GET_SEL32V(_segMan, obj, pri) & 0xFF;
+	newSound->loop = GET_SEL32V(_segMan, obj, SELECTOR(loop));
+	newSound->prio = GET_SEL32V(_segMan, obj, SELECTOR(pri)) & 0xFF;
 	if (_soundVersion >= SCI_VERSION_1_LATE)
-		newSound->volume = CLIP<int>(GET_SEL32V(_segMan, obj, vol), 0, MUSIC_VOLUME_MAX);
+		newSound->volume = CLIP<int>(GET_SEL32V(_segMan, obj, SELECTOR(vol)), 0, MUSIC_VOLUME_MAX);
 
 	// In SCI1.1 games, sound effects are started from here. If we can find
 	// a relevant audio resource, play it, otherwise switch to synthesized
@@ -326,11 +326,11 @@ void SoundCommandParser::cmdInitSound(reg_t obj, int16 value) {
 	if (newSound->soundRes || newSound->pStreamAud) {
 		// Notify the engine
 		if (_soundVersion <= SCI_VERSION_0_LATE)
-			PUT_SEL32V(_segMan, obj, state, kSoundInitialized);
+			PUT_SEL32V(_segMan, obj, SELECTOR(state), kSoundInitialized);
 		else
-			PUT_SEL32(_segMan, obj, nodePtr, obj);
+			PUT_SEL32(_segMan, obj, SELECTOR(nodePtr), obj);
 
-		PUT_SEL32(_segMan, obj, handle, obj);
+		PUT_SEL32(_segMan, obj, SELECTOR(handle), obj);
 	}
 #endif
 
@@ -345,30 +345,30 @@ void SoundCommandParser::cmdPlaySound(reg_t obj, int16 value) {
 
 	if (_soundVersion <= SCI_VERSION_0_LATE) {
 		_state->sfx_song_set_status(handle, SOUND_STATUS_PLAYING);
-		_state->sfx_song_set_loops(handle, GET_SEL32V(_segMan, obj, loop));
-		PUT_SEL32V(_segMan, obj, state, kSoundPlaying);
+		_state->sfx_song_set_loops(handle, GET_SEL32V(_segMan, obj, SELECTOR(loop)););
+		PUT_SEL32V(_segMan, obj, SELECTOR(state), kSoundPlaying);
 	} else if (_soundVersion == SCI_VERSION_1_EARLY) {
 		_state->sfx_song_set_status(handle, SOUND_STATUS_PLAYING);
-		_state->sfx_song_set_loops(handle, GET_SEL32V(_segMan, obj, loop));
-		_state->sfx_song_renice(handle, GET_SEL32V(_segMan, obj, pri));
+		_state->sfx_song_set_loops(handle, GET_SEL32V(_segMan, obj, SELECTOR(loop)););
+		_state->sfx_song_renice(handle, GET_SEL32V(_segMan, obj, SELECTOR(pri)););
 		RESTORE_BEHAVIOR rb = (RESTORE_BEHAVIOR) value;		/* Too lazy to look up a default value for this */
 		_state->_songlib.setSongRestoreBehavior(handle, rb);
-		PUT_SEL32V(_segMan, obj, signal, 0);
+		PUT_SEL32V(_segMan, obj, SELECTOR(signal), 0);
 	} else if (_soundVersion == SCI_VERSION_1_LATE) {
-		int looping = GET_SEL32V(_segMan, obj, loop);
-		//int vol = GET_SEL32V(_segMan, obj, vol);
-		int pri = GET_SEL32V(_segMan, obj, pri);
+		int looping = GET_SEL32V(_segMan, obj, SELECTOR(loop));
+		//int vol = GET_SEL32V(_segMan, obj, SELECTOR(vol));
+		int pri = GET_SEL32V(_segMan, obj, SELECTOR(pri));
 		int sampleLen = 0;
 		Song *song = _state->_songlib.findSong(handle);
-		int songNumber = GET_SEL32V(_segMan, obj, number);
+		int songNumber = GET_SEL32V(_segMan, obj, SELECTOR(number));
 
-		if (GET_SEL32V(_segMan, obj, nodePtr) && (song && songNumber != song->_resourceNum)) {
+		if (GET_SEL32V(_segMan, obj, SELECTOR(nodePtr)); && (song && songNumber != song->_resourceNum)) {
 			_state->sfx_song_set_status(handle, SOUND_STATUS_STOPPED);
 			_state->sfx_remove_song(handle);
-			PUT_SEL32(_segMan, obj, nodePtr, NULL_REG);
+			PUT_SEL32(_segMan, obj, SELECTOR(nodePtr), NULL_REG);
 		}
 
-		if (!GET_SEL32V(_segMan, obj, nodePtr) && obj.segment) {
+		if (!GET_SEL32V(_segMan, obj, SELECTOR(nodePtr)); && obj.segment) {
 			// In SCI1.1 games, sound effects are started from here. If we can find
 			// a relevant audio resource, play it, otherwise switch to synthesized
 			// effects. If the resource exists, play it using map 65535 (sound
@@ -386,7 +386,7 @@ void SoundCommandParser::cmdPlaySound(reg_t obj, int16 value) {
 					warning("Could not open song number %d", songNumber);
 					// Send a "stop handle" event so that the engine won't wait forever here
 					_state->sfx_song_set_status(handle, SOUND_STATUS_STOPPED);
-					PUT_SEL32V(_segMan, obj, signal, SIGNAL_OFFSET);
+					PUT_SEL32V(_segMan, obj, SELECTOR(signal), SIGNAL_OFFSET);
 					return;
 				}
 				debugC(2, kDebugLevelSound, "Initializing song number %d", songNumber);
@@ -394,15 +394,15 @@ void SoundCommandParser::cmdPlaySound(reg_t obj, int16 value) {
 				                          handle), 0, handle, songNumber);
 			}
 
-			PUT_SEL32(_segMan, obj, nodePtr, obj);
-			PUT_SEL32(_segMan, obj, handle, obj);
+			PUT_SEL32(_segMan, obj, SELECTOR(nodePtr), obj);
+			PUT_SEL32(_segMan, obj, SELECTOR(handle), obj);
 		}
 
 		if (obj.segment) {
 			_state->sfx_song_set_status(handle, SOUND_STATUS_PLAYING);
 			_state->sfx_song_set_loops(handle, looping);
 			_state->sfx_song_renice(handle, pri);
-			PUT_SEL32V(_segMan, obj, signal, 0);
+			PUT_SEL32V(_segMan, obj, SELECTOR(signal), 0);
 		}
 	}
 
@@ -414,7 +414,7 @@ void SoundCommandParser::cmdPlaySound(reg_t obj, int16 value) {
 		return;
 	}
 
-	int number = obj.segment ? GET_SEL32V(_segMan, obj, number) : -1;
+	int number = obj.segment ? GET_SEL32V(_segMan, obj, SELECTOR(number)) : -1;
 
 	if (musicSlot->resnum != number) { // another sound loaded into struct
 		cmdDisposeSound(obj, value);
@@ -422,25 +422,25 @@ void SoundCommandParser::cmdPlaySound(reg_t obj, int16 value) {
 		// Find slot again :)
 		musicSlot = _music->getSlot(obj);
 	}
-	int16 loop = GET_SEL32V(_segMan, obj, loop);
+	int16 loop = GET_SEL32V(_segMan, obj, SELECTOR(loop));
 	debugC(2, kDebugLevelSound, "cmdPlaySound: resource number %d, loop %d", number, loop);
 
-	PUT_SEL32(_segMan, obj, handle, obj);
+	PUT_SEL32(_segMan, obj, SELECTOR(handle), obj);
 
 	if (_soundVersion >= SCI_VERSION_1_EARLY) {
-		PUT_SEL32(_segMan, obj, nodePtr, obj);
-		PUT_SEL32V(_segMan, obj, min, 0);
-		PUT_SEL32V(_segMan, obj, sec, 0);
-		PUT_SEL32V(_segMan, obj, frame, 0);
-		PUT_SEL32V(_segMan, obj, signal, 0);
+		PUT_SEL32(_segMan, obj, SELECTOR(nodePtr), obj);
+		PUT_SEL32V(_segMan, obj, SELECTOR(min), 0);
+		PUT_SEL32V(_segMan, obj, SELECTOR(sec), 0);
+		PUT_SEL32V(_segMan, obj, SELECTOR(frame), 0);
+		PUT_SEL32V(_segMan, obj, SELECTOR(signal), 0);
 	} else {
-		PUT_SEL32V(_segMan, obj, state, kSoundPlaying);
+		PUT_SEL32V(_segMan, obj, SELECTOR(state), kSoundPlaying);
 	}
 
-	musicSlot->loop = GET_SEL32V(_segMan, obj, loop);
-	musicSlot->prio = GET_SEL32V(_segMan, obj, priority);
+	musicSlot->loop = GET_SEL32V(_segMan, obj, SELECTOR(loop));
+	musicSlot->prio = GET_SEL32V(_segMan, obj, SELECTOR(priority));
 	if (_soundVersion >= SCI_VERSION_1_LATE)
-		musicSlot->volume = GET_SEL32V(_segMan, obj, vol);
+		musicSlot->volume = GET_SEL32V(_segMan, obj, SELECTOR(vol));
 	_music->soundPlay(musicSlot);
 
 #endif
@@ -457,7 +457,7 @@ void SoundCommandParser::changeSoundStatus(reg_t obj, int newStatus) {
 	if (obj.segment) {
 		_state->sfx_song_set_status(handle, newStatus);
 		if (_soundVersion <= SCI_VERSION_0_LATE)
-			PUT_SEL32V(_segMan, obj, state, newStatus);
+			PUT_SEL32V(_segMan, obj, SELECTOR(state), newStatus);
 	}
 }
 #endif
@@ -474,7 +474,7 @@ void SoundCommandParser::cmdDisposeSound(reg_t obj, int16 value) {
 		_state->sfx_remove_song(handle);
 
 		if (_soundVersion <= SCI_VERSION_0_LATE)
-			PUT_SEL32V(_segMan, obj, handle, 0x0000);
+			PUT_SEL32V(_segMan, obj, SELECTOR(handle), 0x0000);
 	}
 
 #else
@@ -488,11 +488,11 @@ void SoundCommandParser::cmdDisposeSound(reg_t obj, int16 value) {
 	cmdStopSound(obj, value);
 
 	_music->soundKill(musicSlot);
-	PUT_SEL32V(_segMan, obj, handle, 0);
+	PUT_SEL32V(_segMan, obj, SELECTOR(handle), 0);
 	if (_soundVersion >= SCI_VERSION_1_EARLY)
-		PUT_SEL32(_segMan, obj, nodePtr, NULL_REG);
+		PUT_SEL32(_segMan, obj, SELECTOR(nodePtr), NULL_REG);
 	else
-		PUT_SEL32V(_segMan, obj, state, kSoundStopped);
+		PUT_SEL32V(_segMan, obj, SELECTOR(state), kSoundStopped);
 #endif
 }
 
@@ -504,7 +504,7 @@ void SoundCommandParser::cmdStopSound(reg_t obj, int16 value) {
 	changeSoundStatus(obj, SOUND_STATUS_STOPPED);
 
 	if (_soundVersion >= SCI_VERSION_1_EARLY)
-		PUT_SEL32V(_segMan, obj, signal, SIGNAL_OFFSET);
+		PUT_SEL32V(_segMan, obj, SELECTOR(signal), SIGNAL_OFFSET);
 #else
 	MusicEntry *musicSlot = _music->getSlot(obj);
 	if (!musicSlot) {
@@ -513,10 +513,10 @@ void SoundCommandParser::cmdStopSound(reg_t obj, int16 value) {
 	}
 
 	if (_soundVersion <= SCI_VERSION_0_LATE) {
-		PUT_SEL32V(_segMan, obj, state, kSoundStopped);
+		PUT_SEL32V(_segMan, obj, SELECTOR(state), kSoundStopped);
 	} else {
-		PUT_SEL32V(_segMan, obj, handle, 0);
-		PUT_SEL32V(_segMan, obj, signal, SIGNAL_OFFSET);
+		PUT_SEL32V(_segMan, obj, SELECTOR(handle), 0);
+		PUT_SEL32V(_segMan, obj, SELECTOR(signal), SIGNAL_OFFSET);
 	}
 
 	musicSlot->dataInc = 0;
@@ -553,7 +553,7 @@ void SoundCommandParser::cmdPauseSound(reg_t obj, int16 value) {
 
 		if (_soundVersion <= SCI_VERSION_0_LATE) {
 			// Always pause the sound in SCI0 games. It's resumed in cmdResumeSound()
-			PUT_SEL32V(_segMan, musicSlot->soundObj, state, kSoundPaused);
+			PUT_SEL32V(_segMan, musicSlot->soundObj, SELECTOR(state), kSoundPaused);
 			_music->soundPause(musicSlot);
 		} else {
 			_music->soundToggle(musicSlot, value);
@@ -578,7 +578,7 @@ void SoundCommandParser::cmdResumeSound(reg_t obj, int16 value) {
 		return;
 	}
 
-	PUT_SEL32V(_segMan, musicSlot->soundObj, state, kSoundPlaying);
+	PUT_SEL32V(_segMan, musicSlot->soundObj, SELECTOR(state), kSoundPlaying);
 	_music->soundResume(musicSlot);
 #endif
 }
@@ -623,8 +623,8 @@ void SoundCommandParser::cmdFadeSound(reg_t obj, int16 value) {
 		** than fading it! */
 		_state->sfx_song_set_status(handle, SOUND_STATUS_STOPPED);
 		if (_soundVersion <= SCI_VERSION_0_LATE)
-			PUT_SEL32V(_segMan, obj, state, SOUND_STATUS_STOPPED);
-		PUT_SEL32V(_segMan, obj, signal, SIGNAL_OFFSET);
+			PUT_SEL32V(_segMan, obj, SELECTOR(state), SOUND_STATUS_STOPPED);
+		PUT_SEL32V(_segMan, obj, SELECTOR(signal), SIGNAL_OFFSET);
 	} else {
 		fade_params_t fade;
 		fade.final_volume = _argv[2].toUint16();
@@ -639,11 +639,11 @@ void SoundCommandParser::cmdFadeSound(reg_t obj, int16 value) {
 		/* FIXME: The next couple of lines actually STOP the handle, rather
 		** than fading it! */
 		if (_argv[5].toUint16()) {
-			PUT_SEL32V(_segMan, obj, signal, SIGNAL_OFFSET);
+			PUT_SEL32V(_segMan, obj, SELECTOR(signal), SIGNAL_OFFSET);
 			_state->sfx_song_set_status(handle, SOUND_STATUS_STOPPED);
 		} else {
 			// FIXME: Support fade-and-continue. For now, send signal right away.
-			PUT_SEL32V(_segMan, obj, signal, SIGNAL_OFFSET);
+			PUT_SEL32V(_segMan, obj, SELECTOR(signal), SIGNAL_OFFSET);
 		}
 	}
 #else
@@ -696,8 +696,8 @@ void SoundCommandParser::cmdUpdateSound(reg_t obj, int16 value) {
 #ifdef USE_OLD_MUSIC_FUNCTIONS
 	SongHandle handle = FROBNICATE_HANDLE(obj);
 	if (_soundVersion <= SCI_VERSION_0_LATE && obj.segment) {
- 		_state->sfx_song_set_loops(handle, GET_SEL32V(_segMan, obj, loop));
- 		script_set_priority(_resMan, _segMan, _state, obj, GET_SEL32V(_segMan, obj, pri));
+ 		_state->sfx_song_set_loops(handle, GET_SEL32V(_segMan, obj, SELECTOR(loop)););
+ 		script_set_priority(_resMan, _segMan, _state, obj, GET_SEL32V(_segMan, obj, SELECTOR(pri)););
  	}
 #else
 	MusicEntry *musicSlot = _music->getSlot(obj);
@@ -706,11 +706,11 @@ void SoundCommandParser::cmdUpdateSound(reg_t obj, int16 value) {
 		return;
 	}
 
-	musicSlot->loop = GET_SEL32V(_segMan, obj, loop);
-	int16 objVol = CLIP<int>(GET_SEL32V(_segMan, obj, vol), 0, 255);
+	musicSlot->loop = GET_SEL32V(_segMan, obj, SELECTOR(loop));
+	int16 objVol = CLIP<int>(GET_SEL32V(_segMan, obj, SELECTOR(vol)), 0, 255);
 	if (objVol != musicSlot->volume)
 		_music->soundSetVolume(musicSlot, objVol);
-	uint32 objPrio = GET_SEL32V(_segMan, obj, pri);
+	uint32 objPrio = GET_SEL32V(_segMan, obj, SELECTOR(pri));
 	if (objPrio != musicSlot->prio)
 		_music->soundSetPriority(musicSlot, objPrio);
 
@@ -737,7 +737,7 @@ void SoundCommandParser::cmdUpdateCues(reg_t obj, int16 value) {
 		debugC(2, kDebugLevelSound, "---    [CUE] %04x:%04x Absolute Cue: %d",
 		          PRINT_REG(obj), signal);
 		debugC(2, kDebugLevelSound, "abs-signal %04X", signal);
-		PUT_SEL32V(_segMan, obj, signal, signal);
+		PUT_SEL32V(_segMan, obj, SELECTOR(signal), signal);
 		break;
 
 	case SI_RELATIVE_CUE:
@@ -747,17 +747,17 @@ void SoundCommandParser::cmdUpdateCues(reg_t obj, int16 value) {
 		/* FIXME to match commented-out semantics
 		 * below, with proper storage of dataInc and
 		 * signal in the iterator code. */
-		PUT_SEL32V(_segMan, obj, dataInc, signal);
+		PUT_SEL32V(_segMan, obj, SELECTOR(dataInc), signal);
 		debugC(2, kDebugLevelSound, "rel-signal %04X", signal);
 		if (_soundVersion == SCI_VERSION_1_EARLY)
-			PUT_SEL32V(_segMan, obj, signal, signal);
+			PUT_SEL32V(_segMan, obj, SELECTOR(signal), signal);
 		else
-			PUT_SEL32V(_segMan, obj, signal, signal + 127);
+			PUT_SEL32V(_segMan, obj, SELECTOR(signal), signal + 127);
 		break;
 
 	case SI_FINISHED:
 		debugC(2, kDebugLevelSound, "---    [FINISHED] %04x:%04x", PRINT_REG(obj));
-		PUT_SEL32V(_segMan, obj, signal, SIGNAL_OFFSET);
+		PUT_SEL32V(_segMan, obj, SELECTOR(signal), SIGNAL_OFFSET);
 		break;
 
 	case SI_LOOP:
@@ -766,30 +766,30 @@ void SoundCommandParser::cmdUpdateCues(reg_t obj, int16 value) {
 
 	//switch (signal) {
 	//case 0x00:
-	//	if (dataInc!=GET_SEL32V(segMan, obj, dataInc)) {
-	//		PUT_SEL32V(segMan, obj, dataInc, dataInc);
-	//		PUT_SEL32V(segMan, obj, signal, dataInc+0x7f);
+	//	if (dataInc!=GET_SEL32V(segMan, obj, SELECTOR(dataInc));) {
+	//		PUT_SEL32V(segMan, obj, SELECTOR(dataInc), dataInc);
+	//		PUT_SEL32V(segMan, obj, SELECTOR(signal), dataInc+0x7f);
 	//	} else {
-	//		PUT_SEL32V(segMan, obj, signal, signal);
+	//		PUT_SEL32V(segMan, obj, SELECTOR(signal), signal);
 	//	}
 	//	break;
 	//case 0xFF: // May be unnecessary
 	//	s->_sound.sfx_song_set_status(handle, SOUND_STATUS_STOPPED);
 	//	break;
 	//default :
-	//	if (dataInc!=GET_SEL32V(segMan, obj, dataInc)) {
-	//		PUT_SEL32V(segMan, obj, dataInc, dataInc);
-	//		PUT_SEL32V(segMan, obj, signal, dataInc + 0x7f);
+	//	if (dataInc!=GET_SEL32V(segMan, obj, SELECTOR(dataInc));) {
+	//		PUT_SEL32V(segMan, obj, SELECTOR(dataInc), dataInc);
+	//		PUT_SEL32V(segMan, obj, SELECTOR(signal), dataInc + 0x7f);
 	//	} else {
-	//		PUT_SEL32V(segMan, obj, signal, signal);
+	//		PUT_SEL32V(segMan, obj, SELECTOR(signal), signal);
 	//	}
 	//	break;
 	//}
 
 	if (_soundVersion == SCI_VERSION_1_EARLY) {
-		PUT_SEL32V(_segMan, obj, min, min);
-		PUT_SEL32V(_segMan, obj, sec, sec);
-		PUT_SEL32V(_segMan, obj, frame, frame);
+		PUT_SEL32V(_segMan, obj, SELECTOR(min), min);
+		PUT_SEL32V(_segMan, obj, SELECTOR(sec), sec);
+		PUT_SEL32V(_segMan, obj, SELECTOR(frame), frame);
 	}
 #else
 	MusicEntry *musicSlot = _music->getSlot(obj);
@@ -823,14 +823,14 @@ void SoundCommandParser::cmdUpdateCues(reg_t obj, int16 value) {
 	} else {
 		// Update MIDI slots
 		if (musicSlot->signal == 0) {
-			if (musicSlot->dataInc != GET_SEL32V(_segMan, obj, dataInc)) {
+			if (musicSlot->dataInc != GET_SEL32V(_segMan, obj, SELECTOR(dataInc))) {
 				if (_kernel->_selectorCache.dataInc > -1)
-					PUT_SEL32V(_segMan, obj, dataInc, musicSlot->dataInc);
-				PUT_SEL32V(_segMan, obj, signal, musicSlot->dataInc + 127);
+					PUT_SEL32V(_segMan, obj, SELECTOR(dataInc), musicSlot->dataInc);
+				PUT_SEL32V(_segMan, obj, SELECTOR(signal), musicSlot->dataInc + 127);
 			}
 		} else {
 			// Sync the signal of the sound object
-			PUT_SEL32V(_segMan, obj, signal, musicSlot->signal);
+			PUT_SEL32V(_segMan, obj, SELECTOR(signal), musicSlot->signal);
 			// We need to do this especially because state selector needs to get updated
 			if (musicSlot->signal == SIGNAL_OFFSET)
 				cmdStopSound(obj, 0);
@@ -842,7 +842,7 @@ void SoundCommandParser::cmdUpdateCues(reg_t obj, int16 value) {
 		if (_soundVersion <= SCI_VERSION_0_LATE) {
 			cmdStopSound(obj, 0);
 		} else {
-			PUT_SEL32V(_segMan, obj, signal, SIGNAL_OFFSET);
+			PUT_SEL32V(_segMan, obj, SELECTOR(signal), SIGNAL_OFFSET);
 			if (musicSlot->stopAfterFading)
 				cmdStopSound(obj, 0);
 		}
@@ -850,14 +850,14 @@ void SoundCommandParser::cmdUpdateCues(reg_t obj, int16 value) {
 
 	// Sync loop selector for SCI0
 	if (_soundVersion <= SCI_VERSION_0_LATE)
-		PUT_SEL32V(_segMan, obj, loop, musicSlot->loop);
+		PUT_SEL32V(_segMan, obj, SELECTOR(loop), musicSlot->loop);
 
 	musicSlot->signal = 0;
 
 	if (_soundVersion >= SCI_VERSION_1_EARLY) {
-		PUT_SEL32V(_segMan, obj, min, musicSlot->ticker / 3600);
-		PUT_SEL32V(_segMan, obj, sec, musicSlot->ticker % 3600 / 60);
-		PUT_SEL32V(_segMan, obj, frame, musicSlot->ticker);
+		PUT_SEL32V(_segMan, obj, SELECTOR(min), musicSlot->ticker / 3600);
+		PUT_SEL32V(_segMan, obj, SELECTOR(sec), musicSlot->ticker % 3600 / 60);
+		PUT_SEL32V(_segMan, obj, SELECTOR(frame), musicSlot->ticker);
 	}
 
 #endif
@@ -906,10 +906,10 @@ void SoundCommandParser::cmdStopAllSounds(reg_t obj, int16 value) {
 	const MusicList::iterator end = _music->getPlayListEnd();
 	for (MusicList::iterator i = _music->getPlayListStart(); i != end; ++i) {
 		if (_soundVersion <= SCI_VERSION_0_LATE) {
-			PUT_SEL32V(_segMan, (*i)->soundObj, state, kSoundStopped);
+			PUT_SEL32V(_segMan, (*i)->soundObj, SELECTOR(state), kSoundStopped);
 		} else {
-			PUT_SEL32V(_segMan, obj, handle, 0);
-			PUT_SEL32V(_segMan, (*i)->soundObj, signal, SIGNAL_OFFSET);
+			PUT_SEL32V(_segMan, obj, SELECTOR(handle), 0);
+			PUT_SEL32V(_segMan, (*i)->soundObj, SELECTOR(signal), SIGNAL_OFFSET);
 		}
 
 		(*i)->dataInc = 0;
@@ -940,7 +940,7 @@ void SoundCommandParser::cmdSetSoundVolume(reg_t obj, int16 value) {
 	if (musicSlot->volume != value) {
 		musicSlot->volume = value;
 		_music->soundSetVolume(musicSlot, value);
-		PUT_SEL32V(_segMan, obj, vol, value);
+		PUT_SEL32V(_segMan, obj, SELECTOR(vol), value);
 	}
 #endif
 }
@@ -967,12 +967,12 @@ void SoundCommandParser::cmdSetSoundPriority(reg_t obj, int16 value) {
 			warning("cmdSetSoundPriority: Attempt to unset song priority when there is no built-in value");
 
 		//pSnd->prio=0;field_15B=0
-		PUT_SEL32V(_segMan, obj, flags, GET_SEL32V(_segMan, obj, flags) & 0xFD);
+		PUT_SEL32V(_segMan, obj, SELECTOR(flags), GET_SEL32V(_segMan, obj, SELECTOR(flags)) & 0xFD);
 	} else {
 		// Scripted priority
 
 		//pSnd->field_15B=1;
-		PUT_SEL32V(_segMan, obj, flags, GET_SEL32V(_segMan, obj, flags) | 2);
+		PUT_SEL32V(_segMan, obj, SELECTOR(flags), GET_SEL32V(_segMan, obj, SELECTOR(flags)) | 2);
 		//DoSOund(0xF,hobj,w)
 	}
 #endif
@@ -983,7 +983,7 @@ void SoundCommandParser::cmdSetSoundLoop(reg_t obj, int16 value) {
 		return;
 
 #ifdef USE_OLD_MUSIC_FUNCTIONS
-	if (!GET_SEL32(_segMan, obj, nodePtr).isNull()) {
+	if (!GET_SEL32(_segMan, obj, SELECTOR(nodePtr));.isNull()) {
 		SongHandle handle = FROBNICATE_HANDLE(obj);
 		_state->sfx_song_set_loops(handle, value);
 	}
@@ -1008,7 +1008,7 @@ void SoundCommandParser::cmdSetSoundLoop(reg_t obj, int16 value) {
 		musicSlot->loop = 1; // actually plays the music once
 	}
 
-	PUT_SEL32V(_segMan, obj, loop, musicSlot->loop);
+	PUT_SEL32V(_segMan, obj, SELECTOR(loop), musicSlot->loop);
 #endif
 }
 
@@ -1061,11 +1061,11 @@ void SoundCommandParser::reconstructPlayList(int savegame_version) {
 		}
 		if ((*i)->status == kSoundPlaying) {
 			if (savegame_version < 14) {
-				(*i)->dataInc = GET_SEL32V(_segMan, (*i)->soundObj, dataInc);
-				(*i)->signal = GET_SEL32V(_segMan, (*i)->soundObj, signal);
+				(*i)->dataInc = GET_SEL32V(_segMan, (*i)->soundObj, SELECTOR(dataInc));
+				(*i)->signal = GET_SEL32V(_segMan, (*i)->soundObj, SELECTOR(signal));
 
 				if (_soundVersion >= SCI_VERSION_1_LATE)
-					(*i)->volume = GET_SEL32V(_segMan, (*i)->soundObj, vol);
+					(*i)->volume = GET_SEL32V(_segMan, (*i)->soundObj, SELECTOR(vol));
 			}
 
 			cmdPlaySound((*i)->soundObj, 0);
@@ -1101,7 +1101,7 @@ void SoundCommandParser::startNewSound(int number) {
 	MusicEntry *song = *_music->getPlayListStart();
 	reg_t soundObj = song->soundObj;
 	cmdDisposeSound(soundObj, 0);
-	PUT_SEL32V(_segMan, soundObj, number, number);
+	PUT_SEL32V(_segMan, soundObj, SELECTOR(number), number);
 	cmdInitSound(soundObj, 0);
 	cmdPlaySound(soundObj, 0);
 #endif