Mass renaming of selector-related functions, and removed some defines which were just cloaking functions with a different name

- GET_SEL32 -> readSelector
- GET_SEL32V -> readSelectorValue
- PUT_SEL32 -> writeSelector
- PUT_SEL32V -> writeSelectorValue
Also, changed some selector-related function names and variables to CamelCase

svn-id: r49317

16 files changed, 222 insertions, 229 deletions

diff --git a/engines/sci/engine/features.cpp b/engines/sci/engine/features.cpp
index a592805a28..1539b3d190 100644
--- a/engines/sci/engine/features.cpp
+++ b/engines/sci/engine/features.cpp
@@ -56,7 +56,7 @@ reg_t GameFeatures::getDetectionAddr(const Common::String &objName, Selector slc
 	}
 
 	if (methodNum == -1) {
-		if (lookup_selector(_segMan, objAddr, slc, NULL, &addr) != kSelectorMethod) {
+		if (lookupSelector(_segMan, objAddr, slc, NULL, &addr) != kSelectorMethod) {
 			warning("getDetectionAddr: target selector is not a method of object %s", objName.c_str());
 			return NULL_REG;
 		}
@@ -189,7 +189,7 @@ SciVersion GameFeatures::detectSetCursorType() {
 			}
 
 			// Now we check what the number variable holds in the handCursor object.
-			uint16 number = GET_SEL32V(_segMan, objAddr, SELECTOR(number));
+			uint16 number = readSelectorValue(_segMan, objAddr, SELECTOR(number));
 
 			// If the number is 0, it uses views and therefore the SCI1.1 kSetCursor semantics,
 			// otherwise it uses the SCI0 early kSetCursor semantics.
@@ -346,7 +346,7 @@ SciVersion GameFeatures::detectGfxFunctionsType() {
 				// The game has an overlay selector, check how it calls kDrawPicto determine
 				// the graphics functions type used
 				reg_t objAddr = _segMan->findObjectByName("Rm");
-				if (lookup_selector(_segMan, objAddr, _kernel->_selectorCache.overlay, NULL, NULL) == kSelectorMethod) {
+				if (lookupSelector(_segMan, objAddr, _kernel->_selectorCache.overlay, NULL, NULL) == kSelectorMethod) {
 					if (!autoDetectGfxFunctionsType()) {
 						warning("Graphics functions detection failed, taking an educated guess");
 
diff --git a/engines/sci/engine/kernel32.cpp b/engines/sci/engine/kernel32.cpp
index 465e0e92df..b705bbb794 100644
--- a/engines/sci/engine/kernel32.cpp
+++ b/engines/sci/engine/kernel32.cpp
@@ -501,7 +501,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], SELECTOR(data));
+		return readSelector(s->_segMan, argv[1], SELECTOR(data));
 	default:
 		error("Unknown kArray subop %d", argv[0].toUint16());
 	}
@@ -624,7 +624,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], SELECTOR(data));
+		return readSelector(s->_segMan, argv[1], SELECTOR(data));
 	case 10: // Stringlen
 		return make_reg(0, s->_segMan->strlen(argv[1]));
 	case 11: { // Printf
@@ -689,12 +689,12 @@ reg_t kDeleteScreenItem(EngineState *s, int argc, reg_t *argv) {
 
 	/*
 	reg_t viewObj = argv[0];
-	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));
+	uint16 viewId = readSelectorValue(s->_segMan, viewObj, SELECTOR(view));
+	int16 loopNo = readSelectorValue(s->_segMan, viewObj, SELECTOR(loop));
+	int16 celNo = readSelectorValue(s->_segMan, viewObj, SELECTOR(cel));
 	//int16 leftPos = 0;
 	//int16 topPos = 0;
-	int16 priority = GET_SEL32V(s->_segMan, viewObj, SELECTOR(priority));
+	int16 priority = readSelectorValue(s->_segMan, viewObj, SELECTOR(priority));
 	//int16 control = 0;
 	*/
 
@@ -761,10 +761,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, 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));
+	nsRect.left = readSelectorValue(s->_segMan, targetObject, SELECTOR(nsLeft));
+	nsRect.top = readSelectorValue(s->_segMan, targetObject, SELECTOR(nsTop));
+	nsRect.right = readSelectorValue(s->_segMan, targetObject, SELECTOR(nsRight));
+	nsRect.bottom = readSelectorValue(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());
 
@@ -779,7 +779,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, SELECTOR(text)));
+	Common::String text = s->_segMan->getString(readSelector(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 156035b30d..f0432f0c96 100644
--- a/engines/sci/engine/kevent.cpp
+++ b/engines/sci/engine/kevent.cpp
@@ -54,11 +54,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, 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);
+		writeSelectorValue(segMan, obj, SELECTOR(type), SCI_EVENT_KEYBOARD); // Keyboard event
+		writeSelectorValue(segMan, obj, SELECTOR(message), g_debug_simulated_key);
+		writeSelectorValue(segMan, obj, SELECTOR(modifiers), SCI_KEYMOD_NUMLOCK); // Numlock on
+		writeSelectorValue(segMan, obj, SELECTOR(x), mousePos.x);
+		writeSelectorValue(segMan, obj, SELECTOR(y), mousePos.y);
 		g_debug_simulated_key = 0;
 		return make_reg(0, 1);
 	}
@@ -70,8 +70,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, SELECTOR(x), mousePos.x);
-	PUT_SEL32V(segMan, obj, SELECTOR(y), mousePos.y);
+	writeSelectorValue(segMan, obj, SELECTOR(x), mousePos.x);
+	writeSelectorValue(segMan, obj, SELECTOR(y), mousePos.y);
 
 	//s->_gui->moveCursor(s->gfx_state->pointer_pos.x, s->gfx_state->pointer_pos.y);
 
@@ -81,12 +81,12 @@ reg_t kGetEvent(EngineState *s, int argc, reg_t *argv) {
 		break;
 
 	case SCI_EVENT_KEYBOARD:
-		PUT_SEL32V(segMan, obj, SELECTOR(type), SCI_EVENT_KEYBOARD); // Keyboard event
+		writeSelectorValue(segMan, obj, SELECTOR(type), SCI_EVENT_KEYBOARD); // Keyboard event
 		s->r_acc = make_reg(0, 1);
 
-		PUT_SEL32V(segMan, obj, SELECTOR(message), curEvent.character);
+		writeSelectorValue(segMan, obj, SELECTOR(message), curEvent.character);
 		// We only care about the translated character
-		PUT_SEL32V(segMan, obj, SELECTOR(modifiers), curEvent.modifiers & modifier_mask);
+		writeSelectorValue(segMan, obj, SELECTOR(modifiers), curEvent.modifiers & modifier_mask);
 		break;
 
 	case SCI_EVENT_MOUSE_RELEASE:
@@ -111,9 +111,9 @@ reg_t kGetEvent(EngineState *s, int argc, reg_t *argv) {
 				break;
 			}
 
-			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);
+			writeSelectorValue(segMan, obj, SELECTOR(type), curEvent.type);
+			writeSelectorValue(segMan, obj, SELECTOR(message), 0);
+			writeSelectorValue(segMan, obj, SELECTOR(modifiers), (curEvent.modifiers | extra_bits) & modifier_mask);
 			s->r_acc = make_reg(0, 1);
 		}
 		break;
@@ -165,9 +165,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, SELECTOR(type)) == SCI_EVENT_KEYBOARD) { // Keyboard
+	if (readSelectorValue(segMan, obj, SELECTOR(type)) == SCI_EVENT_KEYBOARD) { // Keyboard
 		int mover = -1;
-		switch (GET_SEL32V(segMan, obj, SELECTOR(message))) {
+		switch (readSelectorValue(segMan, obj, SELECTOR(message))) {
 		case SCI_KEY_HOME:
 			mover = 8;
 			break;
@@ -201,8 +201,8 @@ reg_t kMapKeyToDir(EngineState *s, int argc, reg_t *argv) {
 		}
 
 		if (mover >= 0) {
-			PUT_SEL32V(segMan, obj, SELECTOR(type), SCI_EVENT_JOYSTICK);
-			PUT_SEL32V(segMan, obj, SELECTOR(message), mover);
+			writeSelectorValue(segMan, obj, SELECTOR(type), SCI_EVENT_JOYSTICK);
+			writeSelectorValue(segMan, obj, SELECTOR(message), mover);
 			return make_reg(0, 1);
 		} else
 			return NULL_REG;
@@ -217,13 +217,13 @@ reg_t kGlobalToLocal(EngineState *s, int argc, reg_t *argv) {
 	SegManager *segMan = s->_segMan;
 
 	if (obj.segment) {
-		int16 x = GET_SEL32V(segMan, obj, SELECTOR(x));
-		int16 y = GET_SEL32V(segMan, obj, SELECTOR(y));
+		int16 x = readSelectorValue(segMan, obj, SELECTOR(x));
+		int16 y = readSelectorValue(segMan, obj, SELECTOR(y));
 
 		g_sci->_gfxCoordAdjuster->kernelGlobalToLocal(x, y, planeObject);
 
-		PUT_SEL32V(segMan, obj, SELECTOR(x), x);
-		PUT_SEL32V(segMan, obj, SELECTOR(y), y);
+		writeSelectorValue(segMan, obj, SELECTOR(x), x);
+		writeSelectorValue(segMan, obj, SELECTOR(y), y);
 	}
 
 	return s->r_acc;
@@ -236,13 +236,13 @@ reg_t kLocalToGlobal(EngineState *s, int argc, reg_t *argv) {
 	SegManager *segMan = s->_segMan;
 
 	if (obj.segment) {
-		int16 x = GET_SEL32V(segMan, obj, SELECTOR(x));
-		int16 y = GET_SEL32V(segMan, obj, SELECTOR(y));
+		int16 x = readSelectorValue(segMan, obj, SELECTOR(x));
+		int16 y = readSelectorValue(segMan, obj, SELECTOR(y));
 
 		g_sci->_gfxCoordAdjuster->kernelLocalToGlobal(x, y, planeObject);
 
-		PUT_SEL32V(segMan, obj, SELECTOR(x), x);
-		PUT_SEL32V(segMan, obj, SELECTOR(y), y);
+		writeSelectorValue(segMan, obj, SELECTOR(x), x);
+		writeSelectorValue(segMan, obj, SELECTOR(y), y);
 	}
 
 	return s->r_acc;
diff --git a/engines/sci/engine/kgraphics.cpp b/engines/sci/engine/kgraphics.cpp
index aaf361d85c..17d2cd630e 100644
--- a/engines/sci/engine/kgraphics.cpp
+++ b/engines/sci/engine/kgraphics.cpp
@@ -53,8 +53,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, SELECTOR(view));
-	uint16 signal = GET_SEL32V(s->_segMan, object, SELECTOR(signal));
+	GuiResourceId viewId = readSelectorValue(s->_segMan, object, SELECTOR(view));
+	uint16 signal = readSelectorValue(s->_segMan, object, SELECTOR(signal));
 	int16 loopNo;
 	int16 maxLoops;
 	bool oldScriptHeader = (getSciVersion() == SCI_VERSION_0_EARLY);
@@ -93,7 +93,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, SELECTOR(loop), loopNo);
+	writeSelectorValue(s->_segMan, object, SELECTOR(loop), loopNo);
 }
 
 static reg_t kSetCursorSci0(EngineState *s, int argc, reg_t *argv) {
@@ -439,7 +439,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, SELECTOR(view));
+	GuiResourceId viewId = readSelectorValue(s->_segMan, object, SELECTOR(view));
 	int16 loopCount;
 
 	loopCount = g_sci->_gfxCache->kernelViewGetLoopCount(viewId);
@@ -451,8 +451,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, SELECTOR(view));
-	int16 loopNo = GET_SEL32V(s->_segMan, object, SELECTOR(loop));
+	GuiResourceId viewId = readSelectorValue(s->_segMan, object, SELECTOR(view));
+	int16 loopNo = readSelectorValue(s->_segMan, object, SELECTOR(loop));
 	int16 celCount;
 
 	celCount = g_sci->_gfxCache->kernelViewGetCelCount(viewId, loopNo);
@@ -528,8 +528,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 (!strcmp(g_sci->getGameID(), "lsl1sci") && s->currentRoomNumber() == 300) {
-		int top = GET_SEL32V(s->_segMan, object, SELECTOR(brTop));
-		PUT_SEL32V(s->_segMan, object, SELECTOR(brTop), top + 2);
+		int top = readSelectorValue(s->_segMan, object, SELECTOR(brTop));
+		writeSelectorValue(s->_segMan, object, SELECTOR(brTop), top + 2);
 	}
 
 	return s->r_acc;
@@ -743,12 +743,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, 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));
+	int16 type = readSelectorValue(s->_segMan, controlObject, SELECTOR(type));
+	int16 style = readSelectorValue(s->_segMan, controlObject, SELECTOR(state));
+	int16 x = readSelectorValue(s->_segMan, controlObject, SELECTOR(nsLeft));
+	int16 y = readSelectorValue(s->_segMan, controlObject, SELECTOR(nsTop));
+	GuiResourceId fontId = readSelectorValue(s->_segMan, controlObject, SELECTOR(font));
+	reg_t textReference = readSelector(s->_segMan, controlObject, SELECTOR(text));
 	Common::String text;
 	Common::Rect rect;
 	TextAlignment alignment;
@@ -764,8 +764,8 @@ void _k_GenericDrawControl(EngineState *s, reg_t controlObject, bool hilite) {
 	bool isAlias = false;
 
 	rect = kControlCreateRect(x, y,
-				GET_SEL32V(s->_segMan, controlObject, SELECTOR(nsRight)),
-				GET_SEL32V(s->_segMan, controlObject, SELECTOR(nsBottom)));
+				readSelectorValue(s->_segMan, controlObject, SELECTOR(nsRight)),
+				readSelectorValue(s->_segMan, controlObject, SELECTOR(nsBottom)));
 
 	if (!textReference.isNull())
 		text = s->_segMan->getString(textReference);
@@ -777,32 +777,32 @@ void _k_GenericDrawControl(EngineState *s, reg_t controlObject, bool hilite) {
 		return;
 
 	case SCI_CONTROLS_TYPE_TEXT:
-		alignment = GET_SEL32V(s->_segMan, controlObject, SELECTOR(mode));
+		alignment = readSelectorValue(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);
 		g_sci->_gfxControls->kernelDrawText(rect, controlObject, g_sci->strSplit(text.c_str()).c_str(), fontId, alignment, style, hilite);
 		return;
 
 	case SCI_CONTROLS_TYPE_TEXTEDIT:
-		mode = GET_SEL32V(s->_segMan, controlObject, SELECTOR(mode));
-		maxChars = GET_SEL32V(s->_segMan, controlObject, SELECTOR(max));
-		cursorPos = GET_SEL32V(s->_segMan, controlObject, SELECTOR(cursor));
+		mode = readSelectorValue(s->_segMan, controlObject, SELECTOR(mode));
+		maxChars = readSelectorValue(s->_segMan, controlObject, SELECTOR(max));
+		cursorPos = readSelectorValue(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);
 		g_sci->_gfxControls->kernelDrawTextEdit(rect, controlObject, g_sci->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, SELECTOR(view));
+		viewId = readSelectorValue(s->_segMan, controlObject, SELECTOR(view));
 		{
-			int l = GET_SEL32V(s->_segMan, controlObject, SELECTOR(loop));
+			int l = readSelectorValue(s->_segMan, controlObject, SELECTOR(loop));
 			loopNo = (l & 0x80) ? l - 256 : l;
-			int c = GET_SEL32V(s->_segMan, controlObject, SELECTOR(cel));
+			int c = readSelectorValue(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 (!strcmp(g_sci->getGameID(), "jones"))
-				priority = GET_SEL32V(s->_segMan, controlObject, SELECTOR(priority));
+				priority = readSelectorValue(s->_segMan, controlObject, SELECTOR(priority));
 			else
 				priority = -1;
 		}
@@ -815,17 +815,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, SELECTOR(x)); // max chars per entry
-		cursorOffset = GET_SEL32V(s->_segMan, controlObject, SELECTOR(cursor));
+		maxChars = readSelectorValue(s->_segMan, controlObject, SELECTOR(x)); // max chars per entry
+		cursorOffset = readSelectorValue(s->_segMan, controlObject, SELECTOR(cursor));
 		if (g_sci->getKernel()->_selectorCache.topString != -1) {
 			// Games from early SCI1 onwards use topString
-			upperOffset = GET_SEL32V(s->_segMan, controlObject, SELECTOR(topString));
+			upperOffset = readSelectorValue(s->_segMan, controlObject, SELECTOR(topString));
 		} else {
 			// Earlier games use lsTop or brTop
-			if (lookup_selector(s->_segMan, controlObject, g_sci->getKernel()->_selectorCache.brTop, NULL, NULL) == kSelectorVariable)
-				upperOffset = GET_SEL32V(s->_segMan, controlObject, SELECTOR(brTop));
+			if (lookupSelector(s->_segMan, controlObject, g_sci->getKernel()->_selectorCache.brTop, NULL, NULL) == kSelectorVariable)
+				upperOffset = readSelectorValue(s->_segMan, controlObject, SELECTOR(brTop));
 			else
-				upperOffset = GET_SEL32V(s->_segMan, controlObject, SELECTOR(lsTop));
+				upperOffset = readSelectorValue(s->_segMan, controlObject, SELECTOR(lsTop));
 		}
 
 		// Count string entries in NULL terminated string list
@@ -876,8 +876,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, SELECTOR(state));
-		PUT_SEL32V(s->_segMan, controlObject, SELECTOR(state), (state | SCI_CONTROLS_STYLE_DISABLED) & ~SCI_CONTROLS_STYLE_ENABLED);
+		int state = readSelectorValue(s->_segMan, controlObject, SELECTOR(state));
+		writeSelectorValue(s->_segMan, controlObject, SELECTOR(state), (state | SCI_CONTROLS_STYLE_DISABLED) & ~SCI_CONTROLS_STYLE_ENABLED);
 	}
 
 	_k_GenericDrawControl(s, controlObject, false);
@@ -896,7 +896,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, SELECTOR(type));
+		int16 controlType = readSelectorValue(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 7fefccd9d7..f06f3eec77 100644
--- a/engines/sci/engine/klists.cpp
+++ b/engines/sci/engine/klists.cpp
@@ -397,11 +397,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, SELECTOR(size));
+	int input_size = (int16)readSelectorValue(segMan, source, SELECTOR(size));
 	int i;
 
-	reg_t input_data = GET_SEL32(segMan, source, SELECTOR(elements));
-	reg_t output_data = GET_SEL32(segMan, dest, SELECTOR(elements));
+	reg_t input_data = readSelector(segMan, source, SELECTOR(elements));
+	reg_t output_data = readSelector(segMan, dest, SELECTOR(elements));
 
 	List *list;
 	Node *node;
@@ -412,10 +412,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, SELECTOR(elements), output_data);
+		writeSelector(segMan, dest, SELECTOR(elements), output_data);
 	}
 
-	PUT_SEL32V(segMan, dest, SELECTOR(size), input_size);
+	writeSelectorValue(segMan, dest, SELECTOR(size), input_size);
 
 	list = s->_segMan->lookupList(input_data);
 	node = s->_segMan->lookupNode(list->first);
@@ -424,7 +424,7 @@ reg_t kSort(EngineState *s, int argc, reg_t *argv) {
 
 	i = 0;
 	while (node) {
-		invoke_selector(INV_SEL(s, order_func, doit, kStopOnInvalidSelector), 1, node->value);
+		invokeSelector(INV_SEL(s, order_func, doit, kStopOnInvalidSelector), 1, node->value);
 		temp_array[i].key = node->key;
 		temp_array[i].value = node->value;
 		temp_array[i].order = s->r_acc;
@@ -515,15 +515,15 @@ reg_t kListEachElementDo(EngineState *s, int argc, reg_t *argv) {
 		curObject = curNode->value;
 
 		// First, check if the target selector is a variable
-		if (lookup_selector(s->_segMan, curObject, slc, &address, NULL) == kSelectorVariable) {
+		if (lookupSelector(s->_segMan, curObject, slc, &address, NULL) == kSelectorVariable) {
 			// This can only happen with 3 params (list, target selector, variable)
 			if (argc != 3) {
 				warning("kListEachElementDo: Attempted to modify a variable selector with %d params", argc);
 			} else {
-				write_selector(s->_segMan, curObject, slc, argv[2]);
+				writeSelector(s->_segMan, curObject, slc, argv[2]);
 			}
 		} else {
-			invoke_selector_argv(s, curObject, slc, kContinueOnInvalidSelector, argc, argv, argc - 2, argv + 2);
+			invokeSelectorArgv(s, curObject, slc, kContinueOnInvalidSelector, argc, argv, argc - 2, argv + 2);
 		}
 
 		curNode = s->_segMan->lookupNode(nextNode);
@@ -548,11 +548,11 @@ reg_t kListFirstTrue(EngineState *s, int argc, reg_t *argv) {
 		curObject = curNode->value;
 
 		// First, check if the target selector is a variable
-		if (lookup_selector(s->_segMan, curObject, slc, &address, NULL) == kSelectorVariable) {
+		if (lookupSelector(s->_segMan, curObject, slc, &address, NULL) == kSelectorVariable) {
 			// Can this happen with variable selectors?
 			warning("kListFirstTrue: Attempted to access a variable selector");
 		} else {
-			invoke_selector_argv(s, curObject, slc, kContinueOnInvalidSelector, argc, argv, argc - 2, argv + 2);
+			invokeSelectorArgv(s, curObject, slc, kContinueOnInvalidSelector, argc, argv, argc - 2, argv + 2);
 
 			// Check if the result is true
 			if (!s->r_acc.isNull())
@@ -582,11 +582,11 @@ reg_t kListAllTrue(EngineState *s, int argc, reg_t *argv) {
 		curObject = curNode->value;
 
 		// First, check if the target selector is a variable
-		if (lookup_selector(s->_segMan, curObject, slc, &address, NULL) == kSelectorVariable) {
+		if (lookupSelector(s->_segMan, curObject, slc, &address, NULL) == kSelectorVariable) {
 			// Can this happen with variable selectors?
 			warning("kListAllTrue: Attempted to access a variable selector");
 		} else {
-			invoke_selector_argv(s, curObject, slc, kContinueOnInvalidSelector, argc, argv, argc - 2, argv + 2);
+			invokeSelectorArgv(s, curObject, slc, kContinueOnInvalidSelector, argc, argv, argc - 2, argv + 2);
 
 			// Check if the result isn't true
 			if (s->r_acc.isNull())
diff --git a/engines/sci/engine/kmovement.cpp b/engines/sci/engine/kmovement.cpp
index 42e690422c..499aeabcc6 100644
--- a/engines/sci/engine/kmovement.cpp
+++ b/engines/sci/engine/kmovement.cpp
@@ -158,8 +158,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, SELECTOR(xStep), vx);
-	PUT_SEL32V(segMan, object, SELECTOR(yStep), vy);
+	writeSelectorValue(segMan, object, SELECTOR(xStep), vx);
+	writeSelectorValue(segMan, object, SELECTOR(yStep), vy);
 
 	return s->r_acc;
 }
@@ -168,9 +168,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, SELECTOR(client));
-	int stepx = (int16)GET_SEL32V(segMan, client, SELECTOR(xStep)) * step_factor;
-	int stepy = (int16)GET_SEL32V(segMan, client, SELECTOR(yStep)) * step_factor;
+	reg_t client = readSelector(segMan, mover, SELECTOR(client));
+	int stepx = (int16)readSelectorValue(segMan, client, SELECTOR(xStep)) * step_factor;
+	int stepy = (int16)readSelectorValue(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;
@@ -191,15 +191,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, SELECTOR(b_xAxis), _K_BRESEN_AXIS_Y);
-		PUT_SEL32V(segMan, mover, SELECTOR(b_incr), (deltay < 0) ? -1 : 1);
+		writeSelectorValue(segMan, mover, SELECTOR(b_xAxis), _K_BRESEN_AXIS_Y);
+		writeSelectorValue(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, SELECTOR(b_xAxis), _K_BRESEN_AXIS_X);
-		PUT_SEL32V(segMan, mover, SELECTOR(b_incr), (deltax < 0) ? -1 : 1);
+		writeSelectorValue(segMan, mover, SELECTOR(b_xAxis), _K_BRESEN_AXIS_X);
+		writeSelectorValue(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);
@@ -207,26 +207,26 @@ static void initialize_bresen(SegManager *segMan, int argc, reg_t *argv, reg_t m
 
 	}
 
-	PUT_SEL32V(segMan, mover, SELECTOR(dx), deltax_step);
-	PUT_SEL32V(segMan, mover, SELECTOR(dy), deltay_step);
+	writeSelectorValue(segMan, mover, SELECTOR(dx), deltax_step);
+	writeSelectorValue(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, 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);
+	//writeSelectorValue(segMan, mover, SELECTOR(b_movCnt), numsteps); // Needed for HQ1/Ogre?
+	writeSelectorValue(segMan, mover, SELECTOR(b_di), bdi);
+	writeSelectorValue(segMan, mover, SELECTOR(b_i1), i1);
+	writeSelectorValue(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, SELECTOR(client));
+	reg_t client = readSelector(segMan, mover, SELECTOR(client));
 
-	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 deltax = (int16)readSelectorValue(segMan, mover, SELECTOR(x)) - (int16)readSelectorValue(segMan, client, SELECTOR(x));
+	int deltay = (int16)readSelectorValue(segMan, mover, SELECTOR(y)) - (int16)readSelectorValue(segMan, client, SELECTOR(y));
 	int step_factor = (argc < 1) ? argv[1].toUint16() : 1;
 
 	initialize_bresen(s->_segMan, argc, argv, mover, step_factor, deltax, deltay);
@@ -240,42 +240,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, SELECTOR(client));
+	reg_t client = readSelector(segMan, mover, SELECTOR(client));
 
-	int x = (int16)GET_SEL32V(segMan, client, SELECTOR(x));
-	int y = (int16)GET_SEL32V(segMan, client, SELECTOR(y));
+	int x = (int16)readSelectorValue(segMan, client, SELECTOR(x));
+	int y = (int16)readSelectorValue(segMan, client, SELECTOR(y));
 	int oldx, oldy, destx, desty, dx, dy, bdi, bi1, bi2, movcnt, bdelta, axis;
-	uint16 signal = GET_SEL32V(segMan, client, SELECTOR(signal));
+	uint16 signal = readSelectorValue(segMan, client, SELECTOR(signal));
 	int completed = 0;
-	int max_movcnt = GET_SEL32V(segMan, client, SELECTOR(moveSpeed));
+	int max_movcnt = readSelectorValue(segMan, client, SELECTOR(moveSpeed));
 
 	if (getSciVersion() > SCI_VERSION_01)
 		signal &= ~kSignalHitObstacle;
 
-	PUT_SEL32(segMan, client, SELECTOR(signal), make_reg(0, signal)); // This is a NOP for SCI0
+	writeSelector(segMan, client, SELECTOR(signal), make_reg(0, signal)); // This is a NOP for SCI0
 	oldx = x;
 	oldy = y;
-	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));
+	destx = (int16)readSelectorValue(segMan, mover, SELECTOR(x));
+	desty = (int16)readSelectorValue(segMan, mover, SELECTOR(y));
+	dx = (int16)readSelectorValue(segMan, mover, SELECTOR(dx));
+	dy = (int16)readSelectorValue(segMan, mover, SELECTOR(dy));
+	bdi = (int16)readSelectorValue(segMan, mover, SELECTOR(b_di));
+	bi1 = (int16)readSelectorValue(segMan, mover, SELECTOR(b_i1));
+	bi2 = (int16)readSelectorValue(segMan, mover, SELECTOR(b_i2));
+	movcnt = readSelectorValue(segMan, mover, SELECTOR(b_movCnt));
+	bdelta = (int16)readSelectorValue(segMan, mover, SELECTOR(b_incr));
+	axis = (int16)readSelectorValue(segMan, mover, SELECTOR(b_xAxis));
 
 	//printf("movecnt %d, move speed %d\n", movcnt, max_movcnt);
 
 	if (g_sci->_features->handleMoveCount()) {
 		if (max_movcnt > movcnt) {
 			++movcnt;
-			PUT_SEL32V(segMan, mover, SELECTOR(b_movCnt), movcnt); // Needed for HQ1/Ogre?
+			writeSelectorValue(segMan, mover, SELECTOR(b_movCnt), movcnt); // Needed for HQ1/Ogre?
 			return NULL_REG;
 		} else {
 			movcnt = 0;
-			PUT_SEL32V(segMan, mover, SELECTOR(b_movCnt), movcnt); // Needed for HQ1/Ogre?
+			writeSelectorValue(segMan, mover, SELECTOR(b_movCnt), movcnt); // Needed for HQ1/Ogre?
 		}
 	}
 
@@ -288,7 +288,7 @@ reg_t kDoBresen(EngineState *s, int argc, reg_t *argv) {
 			dy += bdelta;
 	}
 
-	PUT_SEL32V(segMan, mover, SELECTOR(b_di), bdi);
+	writeSelectorValue(segMan, mover, SELECTOR(b_di), bdi);
 
 	x += dx;
 	y += dy;
@@ -310,24 +310,24 @@ reg_t kDoBresen(EngineState *s, int argc, reg_t *argv) {
 		debugC(2, kDebugLevelBresen, "Finished mover %04x:%04x", PRINT_REG(mover));
 	}
 
-	PUT_SEL32V(segMan, client, SELECTOR(x), x);
-	PUT_SEL32V(segMan, client, SELECTOR(y), y);
+	writeSelectorValue(segMan, client, SELECTOR(x), x);
+	writeSelectorValue(segMan, client, SELECTOR(y), y);
 
 	debugC(2, kDebugLevelBresen, "New data: (x,y)=(%d,%d), di=%d", x, y, bdi);
 
 	if (g_sci->getKernel()->_selectorCache.cantBeHere != -1) {
-		invoke_selector(INV_SEL(s, client, cantBeHere, kStopOnInvalidSelector), 0);
+		invokeSelector(INV_SEL(s, client, cantBeHere, kStopOnInvalidSelector), 0);
 		s->r_acc = make_reg(0, !s->r_acc.offset);
 	} else {
-		invoke_selector(INV_SEL(s, client, canBeHere, kStopOnInvalidSelector), 0);
+		invokeSelector(INV_SEL(s, client, canBeHere, kStopOnInvalidSelector), 0);
 	}
 
 	if (!s->r_acc.offset) { // Contains the return value
-		signal = GET_SEL32V(segMan, client, SELECTOR(signal));
+		signal = readSelectorValue(segMan, client, SELECTOR(signal));
 
-		PUT_SEL32V(segMan, client, SELECTOR(x), oldx);
-		PUT_SEL32V(segMan, client, SELECTOR(y), oldy);
-		PUT_SEL32V(segMan, client, SELECTOR(signal), (signal | kSignalHitObstacle));
+		writeSelectorValue(segMan, client, SELECTOR(x), oldx);
+		writeSelectorValue(segMan, client, SELECTOR(y), oldy);
+		writeSelectorValue(segMan, client, SELECTOR(signal), (signal | kSignalHitObstacle));
 
 		debugC(2, kDebugLevelBresen, "Finished mover %04x:%04x by collision", PRINT_REG(mover));
 		completed = 1;
@@ -335,7 +335,7 @@ reg_t kDoBresen(EngineState *s, int argc, reg_t *argv) {
 
 	if ((getSciVersion() >= SCI_VERSION_1_EGA))
 		if (completed)
-			invoke_selector(INV_SEL(s, mover, moveDone, kStopOnInvalidSelector), 0);
+			invokeSelector(INV_SEL(s, mover, moveDone, kStopOnInvalidSelector), 0);
 
 	return make_reg(0, completed);
 }
@@ -377,15 +377,15 @@ reg_t kDoAvoider(EngineState *s, int argc, reg_t *argv) {
 		return NULL_REG;
 	}
 
-	client = GET_SEL32(segMan, avoider, SELECTOR(client));
+	client = readSelector(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, SELECTOR(looper));
-	mover = GET_SEL32(segMan, client, SELECTOR(mover));
+	looper = readSelector(segMan, client, SELECTOR(looper));
+	mover = readSelector(segMan, client, SELECTOR(mover));
 
 	if (!s->_segMan->isHeapObject(mover)) {
 		if (mover.segment) {
@@ -394,38 +394,38 @@ reg_t kDoAvoider(EngineState *s, int argc, reg_t *argv) {
 		return s->r_acc;
 	}
 
-	destx = GET_SEL32V(segMan, mover, SELECTOR(x));
-	desty = GET_SEL32V(segMan, mover, SELECTOR(y));
+	destx = readSelectorValue(segMan, mover, SELECTOR(x));
+	desty = readSelectorValue(segMan, mover, SELECTOR(y));
 
 	debugC(2, kDebugLevelBresen, "Doing avoider %04x:%04x (dest=%d,%d)", PRINT_REG(avoider), destx, desty);
 
-	if (invoke_selector(INV_SEL(s, mover, doit, kContinueOnInvalidSelector) , 0)) {
+	if (invokeSelector(INV_SEL(s, mover, doit, kContinueOnInvalidSelector) , 0)) {
 		error("Mover %04x:%04x of avoider %04x:%04x doesn't have a doit() funcselector", PRINT_REG(mover), PRINT_REG(avoider));
 		return NULL_REG;
 	}
 
-	mover = GET_SEL32(segMan, client, SELECTOR(mover));
+	mover = readSelector(segMan, client, SELECTOR(mover));
 	if (!mover.segment) // Mover has been disposed?
 		return s->r_acc; // Return gracefully.
 
-	if (invoke_selector(INV_SEL(s, client, isBlocked, kContinueOnInvalidSelector) , 0)) {
+	if (invokeSelector(INV_SEL(s, client, isBlocked, kContinueOnInvalidSelector) , 0)) {
 		error("Client %04x:%04x of avoider %04x:%04x doesn't"
 		         " have an isBlocked() funcselector", PRINT_REG(client), PRINT_REG(avoider));
 		return NULL_REG;
 	}
 
-	dx = destx - GET_SEL32V(segMan, client, SELECTOR(x));
-	dy = desty - GET_SEL32V(segMan, client, SELECTOR(y));
+	dx = destx - readSelectorValue(segMan, client, SELECTOR(x));
+	dy = desty - readSelectorValue(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, 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 oldx = readSelectorValue(segMan, client, SELECTOR(x));
+		int oldy = readSelectorValue(segMan, client, SELECTOR(y));
+		int xstep = readSelectorValue(segMan, client, SELECTOR(xStep));
+		int ystep = readSelectorValue(segMan, client, SELECTOR(yStep));
 		int moves;
 
 		debugC(2, kDebugLevelBresen, " avoider %04x:%04x", PRINT_REG(avoider));
@@ -434,23 +434,23 @@ 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, SELECTOR(x), oldx + move_x);
-			PUT_SEL32V(segMan, client, SELECTOR(y), oldy + move_y);
+			writeSelectorValue(segMan, client, SELECTOR(x), oldx + move_x);
+			writeSelectorValue(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);
 
-			if (invoke_selector(INV_SEL(s, client, canBeHere, kContinueOnInvalidSelector) , 0)) {
+			if (invokeSelector(INV_SEL(s, client, canBeHere, kContinueOnInvalidSelector) , 0)) {
 				error("Client %04x:%04x of avoider %04x:%04x doesn't"
 				         " have a canBeHere() funcselector", PRINT_REG(client), PRINT_REG(avoider));
 				return NULL_REG;
 			}
 
-			PUT_SEL32V(segMan, client, SELECTOR(x), oldx);
-			PUT_SEL32V(segMan, client, SELECTOR(y), oldy);
+			writeSelectorValue(segMan, client, SELECTOR(x), oldx);
+			writeSelectorValue(segMan, client, SELECTOR(y), oldy);
 
 			if (s->r_acc.offset) { // We can be here
 				debugC(2, kDebugLevelBresen, "Success");
-				PUT_SEL32V(segMan, client, SELECTOR(heading), angle);
+				writeSelectorValue(segMan, client, SELECTOR(heading), angle);
 
 				return make_reg(0, angle);
 			}
@@ -463,17 +463,17 @@ 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, SELECTOR(heading));
+		int heading = readSelectorValue(segMan, client, SELECTOR(heading));
 
 		if (heading == -1)
 			return s->r_acc; // No change
 
-		PUT_SEL32V(segMan, client, SELECTOR(heading), angle);
+		writeSelectorValue(segMan, client, SELECTOR(heading), angle);
 
 		s->r_acc = make_reg(0, angle);
 
 		if (looper.segment) {
-			if (invoke_selector(INV_SEL(s, looper, doit, kContinueOnInvalidSelector), 2, angle, client)) {
+			if (invokeSelector(INV_SEL(s, looper, doit, kContinueOnInvalidSelector), 2, angle, client)) {
 				error("Looper %04x:%04x of avoider %04x:%04x doesn't"
 				         " have a doit() funcselector", PRINT_REG(looper), PRINT_REG(avoider));
 			} else
diff --git a/engines/sci/engine/kparse.cpp b/engines/sci/engine/kparse.cpp
index 51ad6bb5c6..97a75dcb1c 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, SELECTOR(claimed)))) {
+	if (s->_voc->parser_event.isNull() || (readSelectorValue(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, SELECTOR(claimed), 1);
+			writeSelectorValue(s->_segMan, s->_voc->parser_event, SELECTOR(claimed), 1);
 
 	} else {
 		return NULL_REG;
@@ -115,16 +115,16 @@ reg_t kParse(EngineState *s, int argc, reg_t *argv) {
 
 		if (syntax_fail) {
 			s->r_acc = make_reg(0, 1);
-			PUT_SEL32V(segMan, event, SELECTOR(claimed), 1);
+			writeSelectorValue(segMan, event, SELECTOR(claimed), 1);
 
-			invoke_selector(INV_SEL(s, s->_gameObj, syntaxFail, kStopOnInvalidSelector), 2, s->_voc->parser_base, stringpos);
+			invokeSelector(INV_SEL(s, s->_gameObj, syntaxFail, kStopOnInvalidSelector), 2, s->_voc->parser_base, stringpos);
 			/* Issue warning */
 
 			debugC(2, kDebugLevelParser, "Tree building failed");
 
 		} else {
 			s->_voc->parserIsValid = true;
-			PUT_SEL32V(segMan, event, SELECTOR(claimed), 0);
+			writeSelectorValue(segMan, event, SELECTOR(claimed), 0);
 
 #ifdef DEBUG_PARSER
 			s->_voc->dumpParseTree();
@@ -134,13 +134,13 @@ reg_t kParse(EngineState *s, int argc, reg_t *argv) {
 	} else {
 
 		s->r_acc = make_reg(0, 0);
-		PUT_SEL32V(segMan, event, SELECTOR(claimed), 1);
+		writeSelectorValue(segMan, event, SELECTOR(claimed), 1);
 		if (error) {
 			s->_segMan->strcpy(s->_voc->parser_base, error);
 			debugC(2, kDebugLevelParser, "Word unknown: %s", error);
 			/* Issue warning: */
 
-			invoke_selector(INV_SEL(s, s->_gameObj, wordFail, kStopOnInvalidSelector), 2, s->_voc->parser_base, stringpos);
+			invokeSelector(INV_SEL(s, s->_gameObj, wordFail, kStopOnInvalidSelector), 2, s->_voc->parser_base, stringpos);
 			free(error);
 			return make_reg(0, 1); /* Tell them that it didn't work */
 		}
@@ -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, SELECTOR(elements)));
+	list = s->_segMan->lookupList(readSelector(segMan, object, SELECTOR(elements)));
 	node = s->_segMan->lookupNode(list->first);
 
 	while (node) {
 		reg_t objpos = node->value;
 		int seg;
 
-		script = GET_SEL32V(segMan, objpos, SELECTOR(number));
+		script = readSelectorValue(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 c36b7fbd28..857ccc2a08 100644
--- a/engines/sci/engine/kpathing.cpp
+++ b/engines/sci/engine/kpathing.cpp
@@ -337,15 +337,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, SELECTOR(points));
+	reg_t points = readSelector(segMan, polygon, SELECTOR(points));
 
 #ifdef ENABLE_SCI32
 	if (segMan->isHeapObject(points))
-		points = GET_SEL32(segMan, points, SELECTOR(data));
+		points = readSelector(segMan, points, SELECTOR(data));
 #endif
 
-	int size = GET_SEL32V(segMan, polygon, SELECTOR(size));
-	int type = GET_SEL32V(segMan, polygon, SELECTOR(type));
+	int size = readSelectorValue(segMan, polygon, SELECTOR(size));
+	int type = readSelectorValue(segMan, polygon, SELECTOR(type));
 	Common::Point first, prev;
 	int i;
 
@@ -386,15 +386,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, SELECTOR(points));
+	reg_t points = readSelector(segMan, polygon, SELECTOR(points));
 
 #ifdef ENABLE_SCI32
 	if (segMan->isHeapObject(points))
-		points = GET_SEL32(segMan, points, SELECTOR(data));
+		points = readSelector(segMan, points, SELECTOR(data));
 #endif
 
-	int size = GET_SEL32V(segMan, polygon, SELECTOR(size));
-	int type = GET_SEL32V(segMan, polygon, SELECTOR(type));
+	int size = readSelectorValue(segMan, polygon, SELECTOR(size));
+	int type = readSelectorValue(segMan, polygon, SELECTOR(type));
 	int i;
 	Common::Point point;
 
@@ -1036,13 +1036,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, SELECTOR(points));
-	int size = GET_SEL32V(segMan, polygon, SELECTOR(size));
+	reg_t points = readSelector(segMan, polygon, SELECTOR(points));
+	int size = readSelectorValue(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, SELECTOR(data));
+		points = readSelector(segMan, points, SELECTOR(data));
 #endif
 
 	if (size == 0) {
@@ -1050,7 +1050,7 @@ static Polygon *convert_polygon(EngineState *s, reg_t polygon) {
 		return NULL;
 	}
 
-	Polygon *poly = new Polygon(GET_SEL32V(segMan, polygon, SELECTOR(type)));
+	Polygon *poly = new Polygon(readSelectorValue(segMan, polygon, SELECTOR(type)));
 
 	int skip = 0;
 
@@ -1121,7 +1121,7 @@ static PathfindingState *convert_polygon_set(EngineState *s, reg_t poly_list, Co
 
 			if (polygon) {
 				pf_s->polygons.push_back(polygon);
-				count += GET_SEL32V(segMan, node->value, SELECTOR(size));
+				count += readSelectorValue(segMan, node->value, SELECTOR(size));
 			}
 
 			node = s->_segMan->lookupNode(node->succ);
@@ -1394,7 +1394,7 @@ reg_t kAvoidPath(EngineState *s, int argc, reg_t *argv) {
 			if (argc < 7)
 				error("[avoidpath] Not enough arguments");
 
-			poly_list = (!argv[4].isNull() ? GET_SEL32(s->_segMan, argv[4], SELECTOR(elements)) : NULL_REG);
+			poly_list = (!argv[4].isNull() ? readSelector(s->_segMan, argv[4], SELECTOR(elements)) : NULL_REG);
 			width = argv[5].toUint16();
 			height = argv[6].toUint16();
 			if (argc > 7)
@@ -1716,7 +1716,7 @@ reg_t kMergePoly(EngineState *s, int argc, reg_t *argv) {
 		polygon = convert_polygon(s, node->value);
 
 		if (polygon) {
-			count += GET_SEL32V(s->_segMan, node->value, SELECTOR(size));
+			count += readSelectorValue(s->_segMan, node->value, SELECTOR(size));
 		}
 
 		node = s->_segMan->lookupNode(node->succ);
diff --git a/engines/sci/engine/kscripts.cpp b/engines/sci/engine/kscripts.cpp
index 9b07648647..aec467bd54 100644
--- a/engines/sci/engine/kscripts.cpp
+++ b/engines/sci/engine/kscripts.cpp
@@ -161,7 +161,7 @@ reg_t kDisposeClone(EngineState *s, int argc, reg_t *argv) {
 	}
 
 	// QFG3 clears clones with underbits set
-	//if (GET_SEL32V(victim_addr, underBits))
+	//if (readSelectorValue(victim_addr, underBits))
 	//	warning("Clone %04x:%04x was cleared with underBits set", PRINT_REG(victim_addr));
 
 #if 0
@@ -250,7 +250,7 @@ reg_t kRespondsTo(EngineState *s, int argc, reg_t *argv) {
 	reg_t obj = argv[0];
 	int selector = argv[1].toUint16();
 
-	return make_reg(0, s->_segMan->isHeapObject(obj) && lookup_selector(s->_segMan, obj, selector, NULL, NULL) != kSelectorNone);
+	return make_reg(0, s->_segMan->isHeapObject(obj) && lookupSelector(s->_segMan, obj, selector, NULL, NULL) != kSelectorNone);
 }
 
 } // End of namespace Sci
diff --git a/engines/sci/engine/kstring.cpp b/engines/sci/engine/kstring.cpp
index d7fa23116b..13ec1bfc88 100644
--- a/engines/sci/engine/kstring.cpp
+++ b/engines/sci/engine/kstring.cpp
@@ -259,7 +259,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, SELECTOR(data));
+					reg = readSelector(s->_segMan, reg, SELECTOR(data));
 #endif
 
 				Common::String tempsource = (reg == NULL_REG) ? "" : g_sci->getKernel()->lookupText(reg,
diff --git a/engines/sci/engine/scriptdebug.cpp b/engines/sci/engine/scriptdebug.cpp
index da8e4ee211..4468d376ea 100644
--- a/engines/sci/engine/scriptdebug.cpp
+++ b/engines/sci/engine/scriptdebug.cpp
@@ -246,7 +246,7 @@ reg_t disassemble(EngineState *s, reg_t pos, int print_bw_tag, int print_bytecod
 
 				printf("  %s::%s[", name, (selector > kernel->getSelectorNamesSize()) ? "<invalid>" : selector_name(s, selector));
 
-				switch (lookup_selector(s->_segMan, called_obj_addr, selector, 0, &fun_ref)) {
+				switch (lookupSelector(s->_segMan, called_obj_addr, selector, 0, &fun_ref)) {
 				case kSelectorMethod:
 					printf("FUNCT");
 					argc += restmod;
diff --git a/engines/sci/engine/selector.cpp b/engines/sci/engine/selector.cpp
index cdbce5a6e4..92fed6e13e 100644
--- a/engines/sci/engine/selector.cpp
+++ b/engines/sci/engine/selector.cpp
@@ -176,32 +176,32 @@ void Kernel::mapSelectors() {
 #endif
 }
 
-reg_t read_selector(SegManager *segMan, reg_t object, Selector selector_id) {
+reg_t readSelector(SegManager *segMan, reg_t object, Selector selectorId) {
 	ObjVarRef address;
 
-	if (lookup_selector(segMan, object, selector_id, &address, NULL) != kSelectorVariable)
+	if (lookupSelector(segMan, object, selectorId, &address, NULL) != kSelectorVariable)
 		return NULL_REG;
 	else
 		return *address.getPointer(segMan);
 }
 
-void write_selector(SegManager *segMan, reg_t object, Selector selector_id, reg_t value) {
+void writeSelector(SegManager *segMan, reg_t object, Selector selectorId, reg_t value) {
 	ObjVarRef address;
 
-	if ((selector_id < 0) || (selector_id > (int)g_sci->getKernel()->getSelectorNamesSize())) {
+	if ((selectorId < 0) || (selectorId > (int)g_sci->getKernel()->getSelectorNamesSize())) {
 		warning("Attempt to write to invalid selector %d of"
-		         " object at %04x:%04x.", selector_id, PRINT_REG(object));
+		         " object at %04x:%04x.", selectorId, PRINT_REG(object));
 		return;
 	}
 
-	if (lookup_selector(segMan, object, selector_id, &address, NULL) != kSelectorVariable)
+	if (lookupSelector(segMan, object, selectorId, &address, NULL) != kSelectorVariable)
 		warning("Selector '%s' of object at %04x:%04x could not be"
-		         " written to", g_sci->getKernel()->getSelectorName(selector_id).c_str(), PRINT_REG(object));
+		         " written to", g_sci->getKernel()->getSelectorName(selectorId).c_str(), PRINT_REG(object));
 	else
 		*address.getPointer(segMan) = value;
 }
 
-int invoke_selector_argv(EngineState *s, reg_t object, int selector_id, SelectorInvocation noinvalid,
+int invokeSelectorArgv(EngineState *s, reg_t object, int selectorId, SelectorInvocation noinvalid,
 	int k_argc, StackPtr k_argp, int argc, const reg_t *argv) {
 	int i;
 	int framesize = 2 + 1 * argc;
@@ -209,21 +209,21 @@ int invoke_selector_argv(EngineState *s, reg_t object, int selector_id, Selector
 	int slc_type;
 	StackPtr stackframe = k_argp + k_argc;
 
-	stackframe[0] = make_reg(0, selector_id);  // The selector we want to call
+	stackframe[0] = make_reg(0, selectorId);  // The selector we want to call
 	stackframe[1] = make_reg(0, argc); // Argument count
 
-	slc_type = lookup_selector(s->_segMan, object, selector_id, NULL, &address);
+	slc_type = lookupSelector(s->_segMan, object, selectorId, NULL, &address);
 
 	if (slc_type == kSelectorNone) {
 		warning("Selector '%s' of object at %04x:%04x could not be invoked",
-		         g_sci->getKernel()->getSelectorName(selector_id).c_str(), PRINT_REG(object));
+		         g_sci->getKernel()->getSelectorName(selectorId).c_str(), PRINT_REG(object));
 		if (noinvalid == kStopOnInvalidSelector)
 			error("[Kernel] Not recoverable: VM was halted");
 		return 1;
 	}
 	if (slc_type == kSelectorVariable) {
 		warning("Attempting to invoke variable selector %s of object %04x:%04x",
-			g_sci->getKernel()->getSelectorName(selector_id).c_str(), PRINT_REG(object));
+			g_sci->getKernel()->getSelectorName(selectorId).c_str(), PRINT_REG(object));
 		return 0;
 	}
 
@@ -243,7 +243,7 @@ int invoke_selector_argv(EngineState *s, reg_t object, int selector_id, Selector
 	return 0;
 }
 
-int invoke_selector(EngineState *s, reg_t object, int selector_id, SelectorInvocation noinvalid,
+int invokeSelector(EngineState *s, reg_t object, int selectorId, SelectorInvocation noinvalid,
 	int k_argc, StackPtr k_argp, int argc, ...) {
 	va_list argp;
 	reg_t *args = new reg_t[argc];
@@ -253,13 +253,13 @@ int invoke_selector(EngineState *s, reg_t object, int selector_id, SelectorInvoc
 		args[i] = va_arg(argp, reg_t);
 	va_end(argp);
 
-	int retval = invoke_selector_argv(s, object, selector_id, noinvalid, k_argc, k_argp, argc, args);
+	int retval = invokeSelectorArgv(s, object, selectorId, noinvalid, k_argc, k_argp, argc, args);
 
 	delete[] args;
 	return retval;
 }
 
-SelectorType lookup_selector(SegManager *segMan, reg_t obj_location, Selector selector_id, ObjVarRef *varp, reg_t *fptr) {
+SelectorType lookupSelector(SegManager *segMan, reg_t obj_location, Selector selectorId, ObjVarRef *varp, reg_t *fptr) {
 	const Object *obj = segMan->getObject(obj_location);
 	int index;
 	bool oldScriptHeader = (getSciVersion() == SCI_VERSION_0_EARLY);
@@ -267,14 +267,14 @@ SelectorType lookup_selector(SegManager *segMan, reg_t obj_location, Selector se
 	// Early SCI versions used the LSB in the selector ID as a read/write
 	// toggle, meaning that we must remove it for selector lookup.
 	if (oldScriptHeader)
-		selector_id &= ~1;
+		selectorId &= ~1;
 
 	if (!obj) {
-		error("lookup_selector(): Attempt to send to non-object or invalid script. Address was %04x:%04x",
+		error("lookupSelector(): Attempt to send to non-object or invalid script. Address was %04x:%04x",
 				PRINT_REG(obj_location));
 	}
 
-	index = obj->locateVarSelector(segMan, selector_id);
+	index = obj->locateVarSelector(segMan, selectorId);
 
 	if (index >= 0) {
 		// Found it as a variable
@@ -286,7 +286,7 @@ SelectorType lookup_selector(SegManager *segMan, reg_t obj_location, Selector se
 	} else {
 		// Check if it's a method, with recursive lookup in superclasses
 		while (obj) {
-			index = obj->funcSelectorPosition(selector_id);
+			index = obj->funcSelectorPosition(selectorId);
 			if (index >= 0) {
 				if (fptr)
 					*fptr = obj->getFunction(index);
@@ -301,7 +301,7 @@ SelectorType lookup_selector(SegManager *segMan, reg_t obj_location, Selector se
 	}
 
 
-//	return _lookup_selector_function(segMan, obj, selector_id, fptr);
+//	return _lookupSelector_function(segMan, obj, selectorId, fptr);
 }
 
 } // End of namespace Sci
diff --git a/engines/sci/engine/selector.h b/engines/sci/engine/selector.h
index 70eeb34d93..f50b9ab1b3 100644
--- a/engines/sci/engine/selector.h
+++ b/engines/sci/engine/selector.h
@@ -34,20 +34,15 @@
 
 namespace Sci {
 
-
-/******************** Selector functionality ********************/
-
 enum SelectorInvocation {
 	kStopOnInvalidSelector = 0,
 	kContinueOnInvalidSelector = 1
 };
 
-
 /**
  * Map a selector name to a selector id. Shortcut for accessing the selector cache.
  */
 #define SELECTOR(_slc_)		(g_sci->getKernel()->_selectorCache._slc_)
-//#define SELECTOR(_slc_)		_slc_
 
 /**
  * Retrieves a selector from an object.
@@ -58,8 +53,8 @@ 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 GET_SEL32(segMan, _obj_, _slc_) read_selector(segMan, _obj_, _slc_)
-#define GET_SEL32V(segMan, _obj_, _slc_) (GET_SEL32(segMan, _obj_, _slc_).offset)
+reg_t readSelector(SegManager *segMan, reg_t object, Selector selectorId);
+#define readSelectorValue(segMan, _obj_, _slc_) (readSelector(segMan, _obj_, _slc_).offset)
 
 /**
  * Writes a selector value to an object.
@@ -70,27 +65,25 @@ 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_, _slc_, _val_)
-#define PUT_SEL32V(segMan, _obj_, _slc_, _val_) PUT_SEL32(segMan, _obj_, _slc_, make_reg(0, _val_))
+void writeSelector(SegManager *segMan, reg_t object, Selector selectorId, reg_t value);
+#define writeSelectorValue(segMan, _obj_, _slc_, _val_) writeSelector(segMan, _obj_, _slc_, make_reg(0, _val_))
 
+/**
+ * Invokes a selector from an object.
+ */
+int invokeSelector(EngineState *s, reg_t object, int selectorId, SelectorInvocation noinvalid,
+	int k_argc, StackPtr k_argp, int argc, ...);
+int invokeSelectorArgv(EngineState *s, reg_t object, int selectorId, SelectorInvocation noinvalid,
+	int k_argc, StackPtr k_argp, int argc, const reg_t *argv);
 
 /**
- * Kludge for use with invoke_selector(). Used for compatibility with compilers
+ * Kludge for use with invokeSelector(). Used for compatibility with compilers
  * that cannot handle vararg macros.
  */
 #define INV_SEL(s, _object_, _selector_, _noinvalid_) \
 	s, _object_,  g_sci->getKernel()->_selectorCache._selector_, _noinvalid_, argc, argv
 
 
-reg_t read_selector(SegManager *segMan, reg_t object, Selector selector_id);
-void write_selector(SegManager *segMan, reg_t object, Selector selector_id, reg_t value);
-int invoke_selector(EngineState *s, reg_t object, int selector_id, SelectorInvocation noinvalid,
-	int k_argc, StackPtr k_argp, int argc, ...);
-int invoke_selector_argv(EngineState *s, reg_t object, int selector_id, SelectorInvocation noinvalid,
-	int k_argc, StackPtr k_argp, int argc, const reg_t *argv);
-
-
-
 } // End of namespace Sci
 
 #endif // SCI_ENGINE_KERNEL_H
diff --git a/engines/sci/engine/state.cpp b/engines/sci/engine/state.cpp
index dfc4c39464..c9398d7ed5 100644
--- a/engines/sci/engine/state.cpp
+++ b/engines/sci/engine/state.cpp
@@ -227,7 +227,7 @@ kLanguage SciEngine::getSciLanguage() {
 	lang = K_LANG_ENGLISH;
 
 	if (_kernel->_selectorCache.printLang != -1) {
-		lang = (kLanguage)GET_SEL32V(_gamestate->_segMan, _gamestate->_gameObj, SELECTOR(printLang));
+		lang = (kLanguage)readSelectorValue(_gamestate->_segMan, _gamestate->_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.
@@ -262,7 +262,7 @@ kLanguage SciEngine::getSciLanguage() {
 			}
 
 			// Store language in printLang selector
-			PUT_SEL32V(_gamestate->_segMan, _gamestate->_gameObj, SELECTOR(printLang), lang);
+			writeSelectorValue(_gamestate->_segMan, _gamestate->_gameObj, SELECTOR(printLang), lang);
 		}
 	}
 
@@ -274,7 +274,7 @@ Common::String SciEngine::strSplit(const char *str, const char *sep) {
 	kLanguage subLang = K_LANG_NONE;
 
 	if (_kernel->_selectorCache.subtitleLang != -1) {
-		subLang = (kLanguage)GET_SEL32V(_gamestate->_segMan, _gamestate->_gameObj, SELECTOR(subtitleLang));
+		subLang = (kLanguage)readSelectorValue(_gamestate->_segMan, _gamestate->_gameObj, SELECTOR(subtitleLang));
 	}
 
 	kLanguage secondLang;
diff --git a/engines/sci/engine/vm.cpp b/engines/sci/engine/vm.cpp
index db45a087fa..1973693f1e 100644
--- a/engines/sci/engine/vm.cpp
+++ b/engines/sci/engine/vm.cpp
@@ -212,7 +212,7 @@ static void validate_write_var(reg_t *r, reg_t *stack_base, int type, int max, i
 			if (!stopGroopPos.isNull()) {	// does the game have a stopGroop object?
 				// Find the "client" member variable of the stopGroop object, and update it
 				ObjVarRef varp;
-				if (lookup_selector(segMan, stopGroopPos, kernel->_selectorCache.client, &varp, NULL) == kSelectorVariable) {
+				if (lookupSelector(segMan, stopGroopPos, kernel->_selectorCache.client, &varp, NULL) == kSelectorVariable) {
 					reg_t *clientVar = varp.getPointer(segMan);
 					*clientVar = value;
 				}
@@ -383,7 +383,7 @@ ExecStack *send_selector(EngineState *s, reg_t send_obj, reg_t work_obj, StackPt
 #endif // VM_DEBUG_SEND
 
 		ObjVarRef varp;
-		switch (lookup_selector(s->_segMan, send_obj, selector, &varp, &funcp)) {
+		switch (lookupSelector(s->_segMan, send_obj, selector, &varp, &funcp)) {
 		case kSelectorNone:
 			error("Send to invalid selector 0x%x of object at %04x:%04x", 0xffff & selector, PRINT_REG(send_obj));
 			break;
@@ -468,7 +468,7 @@ ExecStack *send_selector(EngineState *s, reg_t send_obj, reg_t work_obj, StackPt
 			}
 
 			break;
-		} // switch (lookup_selector())
+		} // switch (lookupSelector())
 
 		framesize -= (2 + argc);
 		argp += argc + 1;
diff --git a/engines/sci/engine/vm.h b/engines/sci/engine/vm.h
index f6151dfc9d..d6bb25c41d 100644
--- a/engines/sci/engine/vm.h
+++ b/engines/sci/engine/vm.h
@@ -95,7 +95,7 @@ class ResourceManager;
 /** Stack pointer value: Use predecessor's value */
 #define CALL_SP_CARRY NULL
 
-/** Types of selectors as returned by lookup_selector() below. */
+/** Types of selectors as returned by lookupSelector() below. */
 enum SelectorType {
 	kSelectorNone = 0,
 	kSelectorVariable,
@@ -379,7 +379,7 @@ int script_init_engine(EngineState *);
  * 							kSelectorMethod if the selector represents a
  * 							method
  */
-SelectorType lookup_selector(SegManager *segMan, reg_t obj, Selector selectorid,
+SelectorType lookupSelector(SegManager *segMan, reg_t obj, Selector selectorid,
 		ObjVarRef *varp, reg_t *fptr);
 
 /**