libretro/scummvm
1
0
Fork 0
mirror of https://github.com/libretro/scummvm.git synced 2025-03-07 02:39:56 +00:00
Code Issues Actions Packages Projects Releases Wiki Activity

SWORD25: Fix for void * conversion errors

Browse Source 
It turns out that strict C++ doesn't allow function pointers to be converted to void pointers and vice versa. Since there are two callback function pointer types - one with a KEY_COMMANDS enum parameter, and the other with an unsigned char type, I changed all void * occurances to a function pointer type with an 'int' parameter, and changed all implementation methods to take in an int parameter.

svn-id: r53208
This commit is contained in:
Paul Gilbert 2010-08-05 10:16:21 +00:00 committed by Eugene Sandulenko
parent 1e3b3af5c0
commit 49ea23c532
5 changed files with 36 additions and 36 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

11
engines/sword25/input/inputengine.h
View File

@ -49,6 +49,7 @@
#include "sword25/kernel/common.h"
#include "sword25/kernel/service.h"
#include "sword25/kernel/persistable.h"
#include "sword25/kernel/callbackregistry.h"
namespace Sword25 {
@ -254,7 +255,7 @@ public:
*/
virtual bool WasKeyDown(unsigned int KeyCode) = 0;
typedef void (*CharacterCallback)(unsigned char Character);
typedef CallbackPtr CharacterCallback;
/**
* Registers a callback function for keyboard input.
@ -268,15 +269,15 @@ public:
* The input of strings by the user through use of callbacks should be implemented.
* @return Returns true if the function was registered, otherwise false.
*/
virtual bool RegisterCharacterCallback(CharacterCallback Callback) = 0;
virtual bool RegisterCharacterCallback(CallbackPtr Callback) = 0;
/**
* De-registeres a previously registered callback function.
* @return Returns true if the function could be de-registered, otherwise false.
*/
virtual bool UnregisterCharacterCallback(CharacterCallback Callback) = 0;
virtual bool UnregisterCharacterCallback(CallbackPtr Callback) = 0;
typedef void (*CommandCallback)(KEY_COMMANDS Command);
typedef CallbackPtr CommandCallback;
/**
* Registers a callback function for the input of commands that can have influence on the string input
@ -287,7 +288,7 @@ public:
* The input of strings by the user through the use of callbacks should be implemented.
* @return Returns true if the function was registered, otherwise false.
*/
virtual bool RegisterCommandCallback(CommandCallback Callback) = 0;
virtual bool RegisterCommandCallback(CallbackPtr Callback) = 0;
/**
* Un-register a callback function for the input of commands that can have an influence on the string input.

21
engines/sword25/input/inputengine_script.cpp
View File

@ -57,8 +57,8 @@ using namespace Lua;
// Callback-Objekte
// -----------------------------------------------------------------------------
static void TheCharacterCallback(unsigned char Character);
static void TheCommandCallback(BS_InputEngine::KEY_COMMANDS Command);
static void TheCharacterCallback(int Character);
static void TheCommandCallback(int Command);
namespace {
class CharacterCallbackClass : public BS_LuaCallback {
@ -68,8 +68,7 @@ namespace {
Common::String Character;
protected:
int PreFunctionInvokation(lua_State *L)
{
int PreFunctionInvokation(lua_State *L) {
lua_pushstring(L, Character.c_str());
return 1;
}
@ -242,8 +241,8 @@ static int SetMouseY(lua_State *L) {
// -----------------------------------------------------------------------------
static void TheCharacterCallback(unsigned char Character) {
CharacterCallbackPtr->Character = Character;
static void TheCharacterCallback(int Character) {
CharacterCallbackPtr->Character = static_cast<unsigned char>(Character);
lua_State *L = static_cast<lua_State *>(BS_Kernel::GetInstance()->GetScript()->GetScriptObject());
CharacterCallbackPtr->InvokeCallbackFunctions(L, 1);
}
@ -268,8 +267,8 @@ static int UnregisterCharacterCallback(lua_State *L) {
// -----------------------------------------------------------------------------
static void TheCommandCallback(BS_InputEngine::KEY_COMMANDS Command) {
CommandCallbackPtr->Command = Command;
static void TheCommandCallback(int Command) {
CommandCallbackPtr->Command = static_cast<BS_InputEngine::KEY_COMMANDS>(Command);
lua_State *L = static_cast<lua_State *>(BS_Kernel::GetInstance()->GetScript()->GetScriptObject());
CommandCallbackPtr->InvokeCallbackFunctions(L, 1);
}
@ -345,10 +344,8 @@ bool BS_InputEngine::_RegisterScriptBindings() {
if (!BS_LuaBindhelper::AddFunctionsToLib(L, PACKAGE_LIBRARY_NAME, PACKAGE_FUNCTIONS)) return false;
if (!BS_LuaBindhelper::AddConstantsToLib(L, PACKAGE_LIBRARY_NAME, PACKAGE_CONSTANTS)) return false;
Common::SharedPtr<CharacterCallbackClass> p1(new CharacterCallbackClass(L));
CharacterCallbackPtr = p1;
Common::SharedPtr<CharacterCallbackClass> p2(new CommandCallbackClass(L));
CommandCallbackPtr = p2;
CharacterCallbackPtr = Common::SharedPtr<CharacterCallbackClass>(new CharacterCallbackClass(L));
CommandCallbackPtr = Common::SharedPtr<CommandCallbackClass>(new CommandCallbackClass(L));
return true;
}

8
engines/sword25/input/scummvminput.h
View File

@ -65,10 +65,10 @@ public:
virtual bool WasKeyDown(unsigned int KeyCode);
virtual void SetMouseX(int PosX);
virtual void SetMouseY(int PosY);
virtual bool RegisterCharacterCallback(CharacterCallback Callback);
virtual bool UnregisterCharacterCallback(CharacterCallback Callback);
virtual bool RegisterCommandCallback(CommandCallback Callback);
virtual bool UnregisterCommandCallback(CommandCallback Callback);
virtual bool RegisterCharacterCallback(CallbackPtr Callback);
virtual bool UnregisterCharacterCallback(CallbackPtr Callback);
virtual bool RegisterCommandCallback(CallbackPtr Callback);
virtual bool UnregisterCommandCallback(CallbackPtr Callback);
virtual void ReportCharacter(unsigned char Character);
virtual void ReportCommand(KEY_COMMANDS Command);

14
engines/sword25/kernel/callbackregistry.cpp
View File

@ -60,7 +60,7 @@ namespace Sword25 {
// -----------------------------------------------------------------------------
bool BS_CallbackRegistry::RegisterCallbackFunction(const Common::String &Name, void *Ptr) {
bool BS_CallbackRegistry::RegisterCallbackFunction(const Common::String &Name, CallbackPtr Ptr) {
if (Name == "") {
BS_LOG_ERRORLN("The empty string is not allowed as a callback function name.");
return false;
@ -82,8 +82,8 @@ bool BS_CallbackRegistry::RegisterCallbackFunction(const Common::String &Name, v
// -----------------------------------------------------------------------------
void * BS_CallbackRegistry::ResolveCallbackFunction(const Common::String & Name) const {
void * Result = FindPtrByName(Name);
CallbackPtr BS_CallbackRegistry::ResolveCallbackFunction(const Common::String &Name) const {
CallbackPtr Result = FindPtrByName(Name);
if (!Result) {
BS_LOG_ERRORLN("There is no callback function with the name \"%s\".", Name.c_str());
@ -94,7 +94,7 @@ void * BS_CallbackRegistry::ResolveCallbackFunction(const Common::String & Name)
// -----------------------------------------------------------------------------
Common::String BS_CallbackRegistry::ResolveCallbackPointer(void *Ptr) const {
Common::String BS_CallbackRegistry::ResolveCallbackPointer(CallbackPtr Ptr) const {
const Common::String &Result = FindNameByPtr(Ptr);
if (Result == "") {
@ -106,7 +106,7 @@ Common::String BS_CallbackRegistry::ResolveCallbackPointer(void *Ptr) const {
// -----------------------------------------------------------------------------
void * BS_CallbackRegistry::FindPtrByName(const Common::String &Name) const {
CallbackPtr BS_CallbackRegistry::FindPtrByName(const Common::String &Name) const {
// Eintrag in der Map finden und den Pointer zurückgeben.
NameToPtrMap::const_iterator It = m_NameToPtrMap.find(Name);
return It == m_NameToPtrMap.end() ? 0 : It->_value;
@ -114,7 +114,7 @@ void * BS_CallbackRegistry::FindPtrByName(const Common::String &Name) const {
// -----------------------------------------------------------------------------
Common::String BS_CallbackRegistry::FindNameByPtr(void *Ptr) const {
Common::String BS_CallbackRegistry::FindNameByPtr(CallbackPtr Ptr) const {
// Eintrag in der Map finden und den Namen zurückgeben.
PtrToNameMap::const_iterator It = m_PtrToNameMap.find(Ptr);
return It == m_PtrToNameMap.end() ? "" : It->second;
@ -122,7 +122,7 @@ Common::String BS_CallbackRegistry::FindNameByPtr(void *Ptr) const {
// -----------------------------------------------------------------------------
void BS_CallbackRegistry::StoreCallbackFunction(const Common::String &Name, void *Ptr) {
void BS_CallbackRegistry::StoreCallbackFunction(const Common::String &Name, CallbackPtr Ptr) {
// Callback-Funktion in beide Maps eintragen.
m_NameToPtrMap[Name] = Ptr;
m_PtrToNameMap[Ptr] = Name;

18
engines/sword25/kernel/callbackregistry.h
View File

@ -51,6 +51,8 @@ namespace Sword25 {
// Klassendeklaration
// -----------------------------------------------------------------------------
typedef void (*CallbackPtr)(int Command);
class BS_CallbackRegistry {
public:
static BS_CallbackRegistry & GetInstance() {
@ -58,19 +60,19 @@ public:
return Instance;
}
bool RegisterCallbackFunction(const Common::String &Name, void * Ptr);
void * ResolveCallbackFunction(const Common::String &Name) const;
Common::String ResolveCallbackPointer(void *Ptr) const;
bool RegisterCallbackFunction(const Common::String &Name, CallbackPtr Ptr);
CallbackPtr ResolveCallbackFunction(const Common::String &Name) const;
Common::String ResolveCallbackPointer(CallbackPtr Ptr) const;
private:
typedef Common::HashMap<Common::String, void *, Common::CaseSensitiveString_Hash, Common::CaseSensitiveString_EqualTo> NameToPtrMap;
typedef Common::HashMap<Common::String, CallbackPtr, Common::CaseSensitiveString_Hash, Common::CaseSensitiveString_EqualTo> NameToPtrMap;
NameToPtrMap m_NameToPtrMap;
typedef Common::HashMap<void *, Common::String, Common::CaseSensitiveString_Hash, Common::CaseSensitiveString_EqualTo> PtrToNameMap;
typedef Common::HashMap<CallbackPtr, Common::String, Common::CaseSensitiveString_Hash, Common::CaseSensitiveString_EqualTo> PtrToNameMap;
PtrToNameMap m_PtrToNameMap;
void * FindPtrByName(const Common::String &Name) const;
Common::String FindNameByPtr(void * Ptr) const;
void StoreCallbackFunction(const Common::String & Name, void * Ptr);
CallbackPtr FindPtrByName(const Common::String &Name) const;
Common::String FindNameByPtr(CallbackPtr Ptr) const;
void StoreCallbackFunction(const Common::String &Name, CallbackPtr Ptr);
};
} // End of namespace Sword25