fix(code): resolve #12 the quick way

Author: gynt

CodeFunctions.cpp

@@ -252,32 +252,32 @@ DWORD __stdcall executeLuaHook(unsigned long* args) {
 		return 0;
 	}
 
-	lua_rawgeti(L, LUA_REGISTRYINDEX, luaHookedFunctionReference);
+	lua_rawgeti(LC, LUA_REGISTRYINDEX, luaHookedFunctionReference);
 
-	if (lua_isfunction(L, -1)) {
+	if (lua_isfunction(LC, -1)) {
 		int totalArgCount = luaHookedFunctionArgCount;
 		if (luaCallingConvention == CallingConvention::THISCALL) {
-			lua_pushnumber(L, currentECXValue);
+			lua_pushnumber(LC, currentECXValue);
 			totalArgCount += 1;
 		}
 		for (int i = 0; i < luaHookedFunctionArgCount; i++) {
-			lua_pushnumber(L, args[i]);
+			lua_pushnumber(LC, args[i]);
 		}
-		if (lua_pcall(L, totalArgCount, 1, 0) == LUA_OK) {
+		if (lua_pcall(LC, totalArgCount, 1, 0) == LUA_OK) {
 			luaErrorLevel = 0;
 			luaErrorMsg = "";
-			int ret = (DWORD)lua_tonumber(L, -1);
-			lua_pop(L, 1); // pop off the return value;
+			int ret = (DWORD)lua_tonumber(LC, -1);
+			lua_pop(LC, 1); // pop off the return value;
 			return ret;
 		}
 		else {
 			luaErrorLevel = 1;
-			luaErrorMsg = lua_tostring(L, -1);
-			lua_pop(L, 1); // pop off the error message;
+			luaErrorMsg = lua_tostring(LC, -1);
+			lua_pop(LC, 1); // pop off the error message;
 		}
 	}
 	else {
-		lua_pop(L, 1); // we need this pop, because the getglobal does a push that would otherwise be popped by pcall.
+		lua_pop(LC, 1); // we need this pop, because the getglobal does a push that would otherwise be popped by pcall.
 		luaErrorLevel = 2;
 		luaErrorMsg = std::string(luaHookedFunctionName) + " is not a function";
 	}
@@ -737,54 +737,54 @@ void __stdcall GetDetourLuaTargetAndCallTheLuaFunction(DWORD address, DWORD* reg
 		return;
 	}
 
-	int before = lua_gettop(L);
+	int before = lua_gettop(LC);
 
-	lua_rawgeti(L, LUA_REGISTRYINDEX, entry->luaFunctionRef);
+	lua_rawgeti(LC, LUA_REGISTRYINDEX, entry->luaFunctionRef);
 
-	if (lua_isfunction(L, -1)) {
-		lua_createtable(L, 0, 8);
+	if (lua_isfunction(LC, -1)) {
+		lua_createtable(LC, 0, 8);
 
 		for (int i = 0; i < order.size(); i++) {
-			lua_pushstring(L, order[i].c_str());
+			lua_pushstring(LC, order[i].c_str());
 			if (order[i] == "ESP") {
-				lua_pushinteger(L, registers[i]+8);
+				lua_pushinteger(LC, registers[i]+8);
 			}
 			else {
-				lua_pushinteger(L, registers[i]);
+				lua_pushinteger(LC, registers[i]);
 			}
-			lua_settable(L, -3);  /* 3rd element from the stack top */
+			lua_settable(LC, -3);  /* 3rd element from the stack top */
 		}
 
 		// We call the function and pass 1 argument and expect 1 argument in return.
-		if (lua_pcall(L, 1, 1, 0) == LUA_OK) {
+		if (lua_pcall(LC, 1, 1, 0) == LUA_OK) {
 			luaErrorLevel = 0;
 			luaErrorMsg = "";
-			if (lua_istable(L, -1)) {
+			if (lua_istable(LC, -1)) {
 				/* table is in the stack at index 't' */
-				lua_pushnil(L);  /* first key */
-				while (lua_next(L, -2) != 0) {
+				lua_pushnil(LC);  /* first key */
+				while (lua_next(LC, -2) != 0) {
 					/* uses 'key' (at index -2) and 'value' (at index -1) */
-					if (!lua_isstring(L, -2)) {
+					if (!lua_isstring(LC, -2)) {
 						luaErrorLevel = 6;
 						luaErrorMsg = "The return value table must have string keys";
 						std::cout << "[RPS]: " << std::string(luaErrorMsg) << std::endl;
 						currentDetourReturn = retLoc;
 
-						lua_settop(L, before);
+						lua_settop(LC, before);
 						return;
 					}
-					if (!lua_isinteger(L, -1)) {
+					if (!lua_isinteger(LC, -1)) {
 						luaErrorLevel = 5;
 						luaErrorMsg = "The return value table must have integer values";
 						std::cout << "[RPS]: " << std::string(luaErrorMsg) << std::endl;
 						currentDetourReturn = retLoc;
 
-						lua_settop(L, before);
+						lua_settop(LC, before);
 						return;
 					}
 
-					std::string key = lua_tostring(L, -2);
-					DWORD value = lua_tointeger(L, -1);
+					std::string key = lua_tostring(LC, -2);
+					DWORD value = lua_tointeger(LC, -1);
 
 					std::vector<std::string>::const_iterator it = find(order.begin(), order.end(), key);
 					if (it == order.end()) {
@@ -793,7 +793,7 @@ void __stdcall GetDetourLuaTargetAndCallTheLuaFunction(DWORD address, DWORD* reg
 						std::cout << "[RPS]: " << std::string(luaErrorMsg) << std::endl;
 						currentDetourReturn = retLoc;
 
-						lua_settop(L, before);
+						lua_settop(LC, before);
 						return;
 					}
 
@@ -808,39 +808,39 @@ void __stdcall GetDetourLuaTargetAndCallTheLuaFunction(DWORD address, DWORD* reg
 
 
 					/* removes 'value'; keeps 'key' for next iteration */
-					lua_pop(L, 1);
+					lua_pop(LC, 1);
 				}
-				lua_pop(L, 1); // pop off the return value;
+				lua_pop(LC, 1); // pop off the return value;
 				currentDetourReturn = retLoc;
 
-				lua_settop(L, before);
+				lua_settop(LC, before);
 				return;
 			}
 			else {
 				luaErrorLevel = 3;
 				luaErrorMsg = "Detour did not return a table";
 			}
-			lua_pop(L, 1); // pop off the return value;
+			lua_pop(LC, 1); // pop off the return value;
 			currentDetourReturn = retLoc;
 
-			lua_settop(L, before);
+			lua_settop(LC, before);
 			return;
 		}
 		else {
 			luaErrorLevel = 1;
-			luaErrorMsg = lua_tostring(L, -1);
-			lua_pop(L, 1); // pop off the error message;
+			luaErrorMsg = lua_tostring(LC, -1);
+			lua_pop(LC, 1); // pop off the error message;
 		}
 	}
 	else {
-		lua_pop(L, 1); // I think we need this pop, because the getglobal does a push that would otherwise be popped by pcall.
+		lua_pop(LC, 1); // I think we need this pop, because the getglobal does a push that would otherwise be popped by pcall.
 		luaErrorLevel = 2;
 		luaErrorMsg = std::string(entry->luaDetourFunctionName.c_str()) + " is not a function";
 	}
 
 	std::cout << "[RPS]: " << std::string(luaErrorMsg) << std::endl;
 
-	lua_settop(L, before);
+	lua_settop(LC, before);
 	currentDetourReturn = retLoc;
 }
 

RuntimePatchingSystem.cpp

@@ -80,7 +80,7 @@ RUNTIMEPATCHINGSYSTEM_API void RPS_initializePrintRedirect(lua_State* L) {
 }
 
 RUNTIMEPATCHINGSYSTEM_API void RPS_initializePrintRedirect() {
-	return RPS_initializePrintRedirect(L);
+	return RPS_initializePrintRedirect(LC);
 }
 
 RUNTIMEPATCHINGSYSTEM_API void RPS_initializeLuaAPI(lua_State* L, std::string apiNamespace) {
@@ -101,15 +101,15 @@ RUNTIMEPATCHINGSYSTEM_API void RPS_initializeLuaAPI(lua_State* L, std::string ap
 }
 
 RUNTIMEPATCHINGSYSTEM_API void RPS_initializeLuaAPI(std::string apiNamespace) {
-	return RPS_initializeLuaAPI(L, apiNamespace);
+	return RPS_initializeLuaAPI(LC, apiNamespace);
 }
 
 RUNTIMEPATCHINGSYSTEM_API void RPS_initializeLuaAPI(lua_State* L) {
 	return RPS_initializeLuaAPI(L, "global");
 }
 
 RUNTIMEPATCHINGSYSTEM_API void RPS_initializeLuaAPI() {
-	return RPS_initializeLuaAPI(L);
+	return RPS_initializeLuaAPI(LC);
 }
 
 RUNTIMEPATCHINGSYSTEM_API void RPS_setupPackagePath(lua_State* L, std::string packagePath) {
@@ -121,7 +121,7 @@ RUNTIMEPATCHINGSYSTEM_API void RPS_setupPackagePath(lua_State* L, std::string pa
 }
 
 RUNTIMEPATCHINGSYSTEM_API void RPS_setupPackagePath(std::string packagePath) {
-	return RPS_setupPackagePath(L, packagePath);
+	return RPS_setupPackagePath(LC, packagePath);
 }
 
 RUNTIMEPATCHINGSYSTEM_API void RPS_setupPackageCPath(lua_State* L, std::string packageCPath) {
@@ -133,7 +133,7 @@ RUNTIMEPATCHINGSYSTEM_API void RPS_setupPackageCPath(lua_State* L, std::string p
 }
 
 RUNTIMEPATCHINGSYSTEM_API void RPS_setupPackageCPath(std::string packageCPath) {
-	return RPS_setupPackageCPath(L, packageCPath);
+	return RPS_setupPackageCPath(LC, packageCPath);
 }
 
 RUNTIMEPATCHINGSYSTEM_API void RPS_runBootstrapFile(lua_State* L, std::string bootstrapFilePath) {
@@ -161,81 +161,81 @@ RUNTIMEPATCHINGSYSTEM_API void RPS_runBootstrapFile(lua_State* L, std::string bo
 }
 
 RUNTIMEPATCHINGSYSTEM_API void RPS_runBootstrapFile(std::string bootstrapFilePath) {
-	return RPS_runBootstrapFile(L, bootstrapFilePath);
+	return RPS_runBootstrapFile(LC, bootstrapFilePath);
 }
 
 RUNTIMEPATCHINGSYSTEM_API void RPS_initializeLua() {
-	L = luaL_newstate();
+	LC = luaL_newstate();
 }
 
 RUNTIMEPATCHINGSYSTEM_API void RPS_initializeLuaOpenLibs() {
-	luaL_openlibs(L);
+	luaL_openlibs(LC);
 }
 
 RUNTIMEPATCHINGSYSTEM_API void RPS_initializeLuaOpenBase() {
-	luaL_requiref(L, "base", luaopen_base, true);
+	luaL_requiref(LC, "base", luaopen_base, true);
 }
 
 RUNTIMEPATCHINGSYSTEM_API void RPS_initialize(std::string bootstrapFilePath, bool initializePrintRedirect) {
 	RPS_initializeLua();
 
 	RPS_initializeLuaOpenLibs();
 
-	if (initializePrintRedirect) RPS_initializePrintRedirect(L);
+	if (initializePrintRedirect) RPS_initializePrintRedirect(LC);
 
-	RPS_initializeLuaAPI(L, "global");
+	RPS_initializeLuaAPI(LC, "global");
 
 
-	RPS_runBootstrapFile(L, bootstrapFilePath);
+	RPS_runBootstrapFile(LC, bootstrapFilePath);
 }
 
 RUNTIMEPATCHINGSYSTEM_API void RPS_initialize(std::string bootstrapFilePath) {
 	return RPS_initialize(bootstrapFilePath, true);
 }
 
 RUNTIMEPATCHINGSYSTEM_API void RPS_deinitialize() {
-	lua_close(L);
+	lua_close(LC);
 }
 
 RUNTIMEPATCHINGSYSTEM_API void RPS_executeSnippet(std::string code) {
-	int before = lua_gettop(L);
-	int r = luaL_dostring(L, code.c_str());
+	int before = lua_gettop(LC);
+	int r = luaL_dostring(LC, code.c_str());
 	if (r == LUA_OK) {
-		int after = lua_gettop(L);
+		int after = lua_gettop(LC);
 		if (after - before > 0) {
 			for (int i = before; i < after; i++) {  /* for each argument */
 				size_t l;
-				const char* s = luaL_tolstring(L, i, &l);  /* convert it to string */
+				const char* s = luaL_tolstring(LC, i, &l);  /* convert it to string */
 				if (i > 1)  /* not the first element? */
 					lua_writestring("\t", 1);  /* add a tab before it */
 				lua_writestring(s, l);  /* print it */
-				lua_pop(L, 1);  /* pop result */
+				lua_pop(LC, 1);  /* pop result */
 			}
 			lua_writeline();
 		}
-		lua_pop(L, after - before);
+		lua_pop(LC, after - before);
 	}
 	else {
-		std::string errormsg = lua_tostring(L, -1);
+		std::string errormsg = lua_tostring(LC, -1);
 		std::cout << "[RPS]: error in lua snippet: " << errormsg << std::endl;
-		lua_pop(L, 1); // pop off the error message;
+		lua_pop(LC, 1); // pop off the error message;
 	}
 }
 
 RUNTIMEPATCHINGSYSTEM_API int RPS_getCurrentStackSize() {
-	return lua_gettop(L);
+	return lua_gettop(LC);
 }
 
 RUNTIMEPATCHINGSYSTEM_API lua_State* RPS_getLuaState() {
-	return L;
+	return LC;
 }
 
 RUNTIMEPATCHINGSYSTEM_API void RPS_setLuaState(lua_State* value) {
-	L = value;
+	LC = value;
 }
 
 extern "C" RUNTIMEPATCHINGSYSTEM_API int luaopen_RPS(lua_State * L) {
-
+	RPS_setLuaState(L);
 	luaL_newlib(L, RPS_LIB);
 
 	return 1;

UtilityFunctions.cpp

@@ -1,6 +1,6 @@
 #include "UtilityFunctions.h"
 
-lua_State* L = 0;
+lua_State* LC = 0;
 
 #ifdef _DEBUG
 

UtilityFunctions.h

@@ -4,7 +4,7 @@
 #include <iostream>
 #include "lua.hpp"
 
-extern lua_State* L;
+extern lua_State* LC;
 
 #ifdef _DEBUG