diff options
| -rw-r--r-- | CMakeLists.txt | 15 | ||||
| -rw-r--r-- | Makefile.bak (renamed from Makefile) | 0 | ||||
| -rw-r--r-- | cmake/Modules/FindIrrlicht.cmake | 38 | ||||
| -rw-r--r-- | src/CMakeLists.txt | 73 | ||||
| -rw-r--r-- | src/jthread/CMakeLists.txt | 16 | ||||
| -rw-r--r-- | src/jthread/LICENSE.MIT | 20 | ||||
| -rw-r--r-- | src/jthread/jmutex.h | 70 | ||||
| -rw-r--r-- | src/jthread/jmutexautolock.h | 43 | ||||
| -rw-r--r-- | src/jthread/jthread.h | 77 | ||||
| -rw-r--r-- | src/jthread/pthread/jmutex.cpp | 67 | ||||
| -rw-r--r-- | src/jthread/pthread/jthread.cpp | 180 | ||||
| -rw-r--r-- | src/jthread/win32/jmutex.cpp | 83 | ||||
| -rw-r--r-- | src/jthread/win32/jthread.cpp | 177 |
13 files changed, 859 insertions, 0 deletions
diff --git a/CMakeLists.txt b/CMakeLists.txt new file mode 100644 index 000000000..53999e022 --- /dev/null +++ b/CMakeLists.txt @@ -0,0 +1,15 @@ +cmake_minimum_required(VERSION 2.6) +if(${CMAKE_VERSION} STREQUAL "2.8.2") + # bug http://vtk.org/Bug/view.php?id=11020 + message( WARNING "CMake/CPack version 2.8.2 will not create working .deb packages!") +endif(${CMAKE_VERSION} STREQUAL "2.8.2") + +set(CMAKE_BUILD_TYPE Debug) +set(CMAKE_MODULE_PATH ${CMAKE_MODULE_PATH} "${CMAKE_SOURCE_DIR}/cmake/Modules/") + +# This is done here so that IRRDIR is relative to the typical cmake call directory +find_package(Irrlicht) + +# This way the CMakeLists.txt file in src/ is processed +add_subdirectory(src) + diff --git a/Makefile b/Makefile.bak index 8ba03f9bb..8ba03f9bb 100644 --- a/Makefile +++ b/Makefile.bak diff --git a/cmake/Modules/FindIrrlicht.cmake b/cmake/Modules/FindIrrlicht.cmake new file mode 100644 index 000000000..c39a8cbfb --- /dev/null +++ b/cmake/Modules/FindIrrlicht.cmake @@ -0,0 +1,38 @@ +MESSAGE(STATUS "IRRDIR = $ENV{IRRDIR}") + +FIND_PATH(IRRLICHT_INCLUDE_DIR NAMES irrlicht.h + PATHS + $ENV{IRRDIR}/include + /usr/local/include/irrlicht + /usr/include/irrlicht +) + +MESSAGE(STATUS "IRRLICHT_INCLUDE_DIR = ${IRRLICHT_INCLUDE_DIR}") + +FIND_LIBRARY(IRRLICHT_LIBRARY NAMES libIrrlicht.a Irrlicht + PATHS + $ENV{IRRDIR}/lib + $ENV{IRRDIR}/lib/Linux + $ENV{IRRDIR}/lib/MacOSX + $ENV{IRRDIR}/lib/Win32-gcc + $ENV{IRRDIR}/lib/Win32-visualstudio + $ENV{IRRDIR}/lib/Win64-visualstudio + /usr/local/lib + /usr/lib +) + +MESSAGE(STATUS "IRRLICHT_LIBRARY = ${IRRLICHT_LIBRARY}") + +# handle the QUIETLY and REQUIRED arguments and set IRRLICHT_FOUND to TRUE if +# all listed variables are TRUE +INCLUDE(FindPackageHandleStandardArgs) +FIND_PACKAGE_HANDLE_STANDARD_ARGS(IRRLICHT DEFAULT_MSG IRRLICHT_LIBRARY IRRLICHT_INCLUDE_DIR) + +IF(IRRLICHT_FOUND) + SET(IRRLICHT_LIBRARIES ${IRRLICHT_LIBRARY}) +ELSE(IRRLICHT_FOUND) + SET(IRRLICHT_LIBRARIES) +ENDIF(IRRLICHT_FOUND) + +MARK_AS_ADVANCED(IRRLICHT_LIBRARY IRRLICHT_INCLUDE_DIR) + diff --git a/src/CMakeLists.txt b/src/CMakeLists.txt new file mode 100644 index 000000000..72a159f16 --- /dev/null +++ b/src/CMakeLists.txt @@ -0,0 +1,73 @@ +project(minetest) +cmake_minimum_required( VERSION 2.6 ) +set ( CMAKE_BUILD_TYPE Debug ) +add_definitions ( -Wall -DRUN_IN_PLACE -O2) +find_package(ZLIB REQUIRED) +find_package(X11 REQUIRED) +find_package(OpenGL REQUIRED) +find_package(JPEG REQUIRED) +find_package(BZip2 REQUIRED) + +if( UNIX ) + #set( platform_SRCS some_necessary_linux_file.cpp ) +else( UNIX ) + #windows + #set( platform_SRCS dllmain.cpp stdafx.cpp ) +endif( UNIX ) + +set(minetest_SRCS + porting.cpp + guiMessageMenu.cpp + materials.cpp + guiTextInputMenu.cpp + guiInventoryMenu.cpp + irrlichtwrapper.cpp + guiPauseMenu.cpp + defaultsettings.cpp + mapnode.cpp + tile.cpp + voxel.cpp + mapblockobject.cpp + inventory.cpp + debug.cpp + serialization.cpp + light.cpp + filesys.cpp + connection.cpp + environment.cpp + client.cpp + server.cpp + socket.cpp + mapblock.cpp + mapsector.cpp + heightmap.cpp + map.cpp + player.cpp + utility.cpp + main.cpp + test.cpp +) + +include_directories( + ${ZLIB_INCLUDE_DIR} + ${IRRLICHT_INCLUDE_DIR} + "${PROJECT_SOURCE_DIR}/jthread" +) + +set(EXECUTABLE_OUTPUT_PATH ../bin) + +add_executable(minetest ${minetest_SRCS}) + +target_link_libraries( + minetest + ${ZLIB_LIBRARIES} + ${IRRLICHT_LIBRARY} + ${OPENGL_LIBRARIES} + ${JPEG_LIBRARIES} + ${BZIP2_LIBRARIES} + jthread +) + +add_subdirectory(jthread) + +#END diff --git a/src/jthread/CMakeLists.txt b/src/jthread/CMakeLists.txt new file mode 100644 index 000000000..be38f87f3 --- /dev/null +++ b/src/jthread/CMakeLists.txt @@ -0,0 +1,16 @@ +if( UNIX ) + set(jthread_SRCS pthread/jmutex.cpp pthread/jthread.cpp) + set(jthread_platform_LIBS "") +else( UNIX ) + set(jthread_SRCS win32/jmutex.cpp win32/jthread.cpp) + set(jthread_platform_LIBS "") +endif( UNIX ) + +add_library(jthread ${jthread_SRCS}) + +target_link_libraries( + jthread + ${jthread_platform_LIBS} +) + + diff --git a/src/jthread/LICENSE.MIT b/src/jthread/LICENSE.MIT new file mode 100644 index 000000000..2aa4fd57b --- /dev/null +++ b/src/jthread/LICENSE.MIT @@ -0,0 +1,20 @@ +The license of JThread: + +Permission is hereby granted, free of charge, to any person obtaining a +copy of this software and associated documentation files (the "Software"), +to deal in the Software without restriction, including without limitation +the rights to use, copy, modify, merge, publish, distribute, sublicense, +and/or sell copies of the Software, and to permit persons to whom the +Software is furnished to do so, subject to the following conditions: + +The above copyright notice and this permission notice shall be included +in all copies or substantial portions of the Software. + +THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS +OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL +THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER +LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING +FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS +IN THE SOFTWARE. + diff --git a/src/jthread/jmutex.h b/src/jthread/jmutex.h new file mode 100644 index 000000000..39bd95f02 --- /dev/null +++ b/src/jthread/jmutex.h @@ -0,0 +1,70 @@ +/* + + This file is a part of the JThread package, which contains some object- + oriented thread wrappers for different thread implementations. + + Copyright (c) 2000-2006 Jori Liesenborgs (jori.liesenborgs@gmail.com) + + Permission is hereby granted, free of charge, to any person obtaining a + copy of this software and associated documentation files (the "Software"), + to deal in the Software without restriction, including without limitation + the rights to use, copy, modify, merge, publish, distribute, sublicense, + and/or sell copies of the Software, and to permit persons to whom the + Software is furnished to do so, subject to the following conditions: + + The above copyright notice and this permission notice shall be included in + all copies or substantial portions of the Software. + + THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR + IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, + FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL + THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER + LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING + FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER + DEALINGS IN THE SOFTWARE. + +*/ + +#ifndef JMUTEX_H + +#define JMUTEX_H + +#if (defined(WIN32) || defined(_WIN32_WCE)) + #ifndef _WIN32_WCE + #include <process.h> + #endif // _WIN32_WCE + #include <winsock2.h> + #include <windows.h> + + #define JMUTEX_CRITICALSECTION +#else // using pthread + #include <pthread.h> +#endif // WIN32 + +#define ERR_JMUTEX_ALREADYINIT -1 +#define ERR_JMUTEX_NOTINIT -2 +#define ERR_JMUTEX_CANTCREATEMUTEX -3 + +class JMutex +{ +public: + JMutex(); + ~JMutex(); + int Init(); + int Lock(); + int Unlock(); + bool IsInitialized() { return initialized; } +private: +#if (defined(WIN32) || defined(_WIN32_WCE)) +#ifdef JMUTEX_CRITICALSECTION + CRITICAL_SECTION mutex; +#else // Use standard mutex + HANDLE mutex; +#endif // JMUTEX_CRITICALSECTION +#else // pthread mutex + pthread_mutex_t mutex; +#endif // WIN32 + bool initialized; +}; + +#endif // JMUTEX_H diff --git a/src/jthread/jmutexautolock.h b/src/jthread/jmutexautolock.h new file mode 100644 index 000000000..6020a5c33 --- /dev/null +++ b/src/jthread/jmutexautolock.h @@ -0,0 +1,43 @@ +/* + + This file is a part of the JThread package, which contains some object- + oriented thread wrappers for different thread implementations. + + Copyright (c) 2000-2006 Jori Liesenborgs (jori.liesenborgs@gmail.com) + + Permission is hereby granted, free of charge, to any person obtaining a + copy of this software and associated documentation files (the "Software"), + to deal in the Software without restriction, including without limitation + the rights to use, copy, modify, merge, publish, distribute, sublicense, + and/or sell copies of the Software, and to permit persons to whom the + Software is furnished to do so, subject to the following conditions: + + The above copyright notice and this permission notice shall be included in + all copies or substantial portions of the Software. + + THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR + IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, + FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL + THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER + LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING + FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER + DEALINGS IN THE SOFTWARE. + +*/ + +#ifndef JMUTEXAUTOLOCK_H + +#define JMUTEXAUTOLOCK_H + +#include "jmutex.h" + +class JMutexAutoLock +{ +public: + JMutexAutoLock(JMutex &m) : mutex(m) { mutex.Lock(); } + ~JMutexAutoLock() { mutex.Unlock(); } +private: + JMutex &mutex; +}; + +#endif // JMUTEXAUTOLOCK_H diff --git a/src/jthread/jthread.h b/src/jthread/jthread.h new file mode 100644 index 000000000..9440a158d --- /dev/null +++ b/src/jthread/jthread.h @@ -0,0 +1,77 @@ +/* + + This file is a part of the JThread package, which contains some object- + oriented thread wrappers for different thread implementations. + + Copyright (c) 2000-2006 Jori Liesenborgs (jori.liesenborgs@gmail.com) + + Permission is hereby granted, free of charge, to any person obtaining a + copy of this software and associated documentation files (the "Software"), + to deal in the Software without restriction, including without limitation + the rights to use, copy, modify, merge, publish, distribute, sublicense, + and/or sell copies of the Software, and to permit persons to whom the + Software is furnished to do so, subject to the following conditions: + + The above copyright notice and this permission notice shall be included in + all copies or substantial portions of the Software. + + THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR + IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, + FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL + THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER + LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING + FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER + DEALINGS IN THE SOFTWARE. + +*/ + +#ifndef JTHREAD_H + +#define JTHREAD_H + +#include "jmutex.h" + +#define ERR_JTHREAD_CANTINITMUTEX -1 +#define ERR_JTHREAD_CANTSTARTTHREAD -2 +#define ERR_JTHREAD_THREADFUNCNOTSET -3 +#define ERR_JTHREAD_NOTRUNNING -4 +#define ERR_JTHREAD_ALREADYRUNNING -5 + +class JThread +{ +public: + JThread(); + virtual ~JThread(); + int Start(); + int Kill(); + virtual void *Thread() = 0; + bool IsRunning(); + void *GetReturnValue(); +protected: + void ThreadStarted(); +private: + +#if (defined(WIN32) || defined(_WIN32_WCE)) +#ifdef _WIN32_WCE + DWORD threadid; + static DWORD WINAPI TheThread(void *param); +#else + static UINT __stdcall TheThread(void *param); + UINT threadid; +#endif // _WIN32_WCE + HANDLE threadhandle; +#else // pthread type threads + static void *TheThread(void *param); + + pthread_t threadid; +#endif // WIN32 + void *retval; + bool running; + + JMutex runningmutex; + JMutex continuemutex,continuemutex2; + bool mutexinit; +}; + +#endif // JTHREAD_H + diff --git a/src/jthread/pthread/jmutex.cpp b/src/jthread/pthread/jmutex.cpp new file mode 100644 index 000000000..6bc3ae5e2 --- /dev/null +++ b/src/jthread/pthread/jmutex.cpp @@ -0,0 +1,67 @@ +/* + + This file is a part of the JThread package, which contains some object- + oriented thread wrappers for different thread implementations. + + Copyright (c) 2000-2006 Jori Liesenborgs (jori.liesenborgs@gmail.com) + + Permission is hereby granted, free of charge, to any person obtaining a + copy of this software and associated documentation files (the "Software"), + to deal in the Software without restriction, including without limitation + the rights to use, copy, modify, merge, publish, distribute, sublicense, + and/or sell copies of the Software, and to permit persons to whom the + Software is furnished to do so, subject to the following conditions: + + The above copyright notice and this permission notice shall be included in + all copies or substantial portions of the Software. + + THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR + IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, + FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL + THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER + LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING + FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER + DEALINGS IN THE SOFTWARE. + +*/ + +#include "jmutex.h" + +JMutex::JMutex() +{ + initialized = false; +} + +JMutex::~JMutex() +{ + if (initialized) + pthread_mutex_destroy(&mutex); +} + +int JMutex::Init() +{ + if (initialized) + return ERR_JMUTEX_ALREADYINIT; + + pthread_mutex_init(&mutex,NULL); + initialized = true; + return 0; +} + +int JMutex::Lock() +{ + if (!initialized) + return ERR_JMUTEX_NOTINIT; + + pthread_mutex_lock(&mutex); + return 0; +} + +int JMutex::Unlock() +{ + if (!initialized) + return ERR_JMUTEX_NOTINIT; + + pthread_mutex_unlock(&mutex); + return 0; +} diff --git a/src/jthread/pthread/jthread.cpp b/src/jthread/pthread/jthread.cpp new file mode 100644 index 000000000..978cac20a --- /dev/null +++ b/src/jthread/pthread/jthread.cpp @@ -0,0 +1,180 @@ +/* + + This file is a part of the JThread package, which contains some object- + oriented thread wrappers for different thread implementations. + + Copyright (c) 2000-2006 Jori Liesenborgs (jori.liesenborgs@gmail.com) + + Permission is hereby granted, free of charge, to any person obtaining a + copy of this software and associated documentation files (the "Software"), + to deal in the Software without restriction, including without limitation + the rights to use, copy, modify, merge, publish, distribute, sublicense, + and/or sell copies of the Software, and to permit persons to whom the + Software is furnished to do so, subject to the following conditions: + + The above copyright notice and this permission notice shall be included in + all copies or substantial portions of the Software. + + THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR + IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, + FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL + THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER + LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING + FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER + DEALINGS IN THE SOFTWARE. + +*/ + +#include "jthread.h" +#include <sys/time.h> +#include <time.h> +#include <stdlib.h> + +JThread::JThread() +{ + retval = NULL; + mutexinit = false; + running = false; +} + +JThread::~JThread() +{ + Kill(); +} + +int JThread::Start() +{ + int status; + + if (!mutexinit) + { + if (!runningmutex.IsInitialized()) + { + if (runningmutex.Init() < 0) + return ERR_JTHREAD_CANTINITMUTEX; + } + if (!continuemutex.IsInitialized()) + { + if (continuemutex.Init() < 0) + return ERR_JTHREAD_CANTINITMUTEX; + } + if (!continuemutex2.IsInitialized()) + { + if (continuemutex2.Init() < 0) + return ERR_JTHREAD_CANTINITMUTEX; + } + mutexinit = true; + } + + runningmutex.Lock(); + if (running) + { + runningmutex.Unlock(); + return ERR_JTHREAD_ALREADYRUNNING; + } + runningmutex.Unlock(); + + pthread_attr_t attr; + pthread_attr_init(&attr); + pthread_attr_setdetachstate(&attr,PTHREAD_CREATE_DETACHED); + + continuemutex.Lock(); + status = pthread_create(&threadid,&attr,TheThread,this); + pthread_attr_destroy(&attr); + if (status != 0) + { + continuemutex.Unlock(); + return ERR_JTHREAD_CANTSTARTTHREAD; + } + + /* Wait until 'running' is set */ + + runningmutex.Lock(); + while (!running) + { + runningmutex.Unlock(); + + struct timespec req,rem; + + req.tv_sec = 0; + req.tv_nsec = 1000000; + nanosleep(&req,&rem); + + runningmutex.Lock(); + } + runningmutex.Unlock(); + + continuemutex.Unlock(); + + continuemutex2.Lock(); + continuemutex2.Unlock(); + return 0; +} + +int JThread::Kill() +{ + runningmutex.Lock(); + if (!running) + { + runningmutex.Unlock(); + return ERR_JTHREAD_NOTRUNNING; + } + pthread_cancel(threadid); + running = false; + runningmutex.Unlock(); + return 0; +} + +bool JThread::IsRunning() +{ + bool r; + + runningmutex.Lock(); + r = running; + runningmutex.Unlock(); + return r; +} + +void *JThread::GetReturnValue() +{ + void *val; + + runningmutex.Lock(); + if (running) + val = NULL; + else + val = retval; + runningmutex.Unlock(); + return val; +} + +void *JThread::TheThread(void *param) +{ + JThread *jthread; + void *ret; + + jthread = (JThread *)param; + + jthread->continuemutex2.Lock(); + jthread->runningmutex.Lock(); + jthread->running = true; + jthread->runningmutex.Unlock(); + + jthread->continuemutex.Lock(); + jthread->continuemutex.Unlock(); + + ret = jthread->Thread(); + + jthread->runningmutex.Lock(); + jthread->running = false; + jthread->retval = ret; + jthread->runningmutex.Unlock(); + + return NULL; +} + +void JThread::ThreadStarted() +{ + continuemutex2.Unlock(); +} + diff --git a/src/jthread/win32/jmutex.cpp b/src/jthread/win32/jmutex.cpp new file mode 100644 index 000000000..000461e3b --- /dev/null +++ b/src/jthread/win32/jmutex.cpp @@ -0,0 +1,83 @@ +/* + + This file is a part of the JThread package, which contains some object- + oriented thread wrappers for different thread implementations. + + Copyright (c) 2000-2006 Jori Liesenborgs (jori.liesenborgs@gmail.com) + + Permission is hereby granted, free of charge, to any person obtaining a + copy of this software and associated documentation files (the "Software"), + to deal in the Software without restriction, including without limitation + the rights to use, copy, modify, merge, publish, distribute, sublicense, + and/or sell copies of the Software, and to permit persons to whom the + Software is furnished to do so, subject to the following conditions: + + The above copyright notice and this permission notice shall be included in + all copies or substantial portions of the Software. + + THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR + IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, + FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL + THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER + LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING + FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER + DEALINGS IN THE SOFTWARE. + +*/ + +#include "jmutex.h" + +JMutex::JMutex() +{ + initialized = false; +} + +JMutex::~JMutex() +{ + if (initialized) +#ifdef JMUTEX_CRITICALSECTION + DeleteCriticalSection(&mutex); +#else + CloseHandle(mutex); +#endif // JMUTEX_CRITICALSECTION +} + +int JMutex::Init() +{ + if (initialized) + return ERR_JMUTEX_ALREADYINIT; +#ifdef JMUTEX_CRITICALSECTION + InitializeCriticalSection(&mutex); +#else + mutex = CreateMutex(NULL,FALSE,NULL); + if (mutex == NULL) + return ERR_JMUTEX_CANTCREATEMUTEX; +#endif // JMUTEX_CRITICALSECTION + initialized = true; + return 0; +} + +int JMutex::Lock() +{ + if (!initialized) + return ERR_JMUTEX_NOTINIT; +#ifdef JMUTEX_CRITICALSECTION + EnterCriticalSection(&mutex); +#else + WaitForSingleObject(mutex,INFINITE); +#endif // JMUTEX_CRITICALSECTION + return 0; +} + +int JMutex::Unlock() +{ + if (!initialized) + return ERR_JMUTEX_NOTINIT; +#ifdef JMUTEX_CRITICALSECTION + LeaveCriticalSection(&mutex); +#else + ReleaseMutex(mutex); +#endif // JMUTEX_CRITICALSECTION + return 0; +} + diff --git a/src/jthread/win32/jthread.cpp b/src/jthread/win32/jthread.cpp new file mode 100644 index 000000000..54b110bfd --- /dev/null +++ b/src/jthread/win32/jthread.cpp @@ -0,0 +1,177 @@ +/* + + This file is a part of the JThread package, which contains some object- + oriented thread wrappers for different thread implementations. + + Copyright (c) 2000-2006 Jori Liesenborgs (jori.liesenborgs@gmail.com) + + Permission is hereby granted, free of charge, to any person obtaining a + copy of this software and associated documentation files (the "Software"), + to deal in the Software without restriction, including without limitation + the rights to use, copy, modify, merge, publish, distribute, sublicense, + and/or sell copies of the Software, and to permit persons to whom the + Software is furnished to do so, subject to the following conditions: + + The above copyright notice and this permission notice shall be included in + all copies or substantial portions of the Software. + + THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR + IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, + FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL + THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER + LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING + FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER + DEALINGS IN THE SOFTWARE. + +*/ + +#include "jthread.h" + +#ifndef _WIN32_WCE + #include <process.h> +#endif // _WIN32_WCE + +JThread::JThread() +{ + retval = NULL; + mutexinit = false; + running = false; +} + +JThread::~JThread() +{ + Kill(); +} + +int JThread::Start() +{ + if (!mutexinit) + { + if (!runningmutex.IsInitialized()) + { + if (runningmutex.Init() < 0) + return ERR_JTHREAD_CANTINITMUTEX; + } + if (!continuemutex.IsInitialized()) + { + if (continuemutex.Init() < 0) + return ERR_JTHREAD_CANTINITMUTEX; + } + if (!continuemutex2.IsInitialized()) + { + if (continuemutex2.Init() < 0) + return ERR_JTHREAD_CANTINITMUTEX; + } mutexinit = true; + } + + runningmutex.Lock(); + if (running) + { + runningmutex.Unlock(); + return ERR_JTHREAD_ALREADYRUNNING; + } + runningmutex.Unlock(); + + continuemutex.Lock(); +#ifndef _WIN32_WCE + threadhandle = (HANDLE)_beginthreadex(NULL,0,TheThread,this,0,&threadid); +#else + threadhandle = CreateThread(NULL,0,TheThread,this,0,&threadid); +#endif // _WIN32_WCE + if (threadhandle == NULL) + { + continuemutex.Unlock(); + return ERR_JTHREAD_CANTSTARTTHREAD; + } + + /* Wait until 'running' is set */ + + runningmutex.Lock(); + while (!running) + { + runningmutex.Unlock(); + Sleep(1); + runningmutex.Lock(); + } + runningmutex.Unlock(); + + continuemutex.Unlock(); + + continuemutex2.Lock(); + continuemutex2.Unlock(); + + return 0; +} + +int JThread::Kill() +{ + runningmutex.Lock(); + if (!running) + { + runningmutex.Unlock(); + return ERR_JTHREAD_NOTRUNNING; + } + TerminateThread(threadhandle,0); + CloseHandle(threadhandle); + running = false; + runningmutex.Unlock(); + return 0; +} + +bool JThread::IsRunning() +{ + bool r; + + runningmutex.Lock(); + r = running; + runningmutex.Unlock(); + return r; +} + +void *JThread::GetReturnValue() +{ + void *val; + + runningmutex.Lock(); + if (running) + val = NULL; + else + val = retval; + runningmutex.Unlock(); + return val; +} + +#ifndef _WIN32_WCE +UINT __stdcall JThread::TheThread(void *param) +#else +DWORD WINAPI JThread::TheThread(void *param) +#endif // _WIN32_WCE +{ + JThread *jthread; + void *ret; + + jthread = (JThread *)param; + + jthread->continuemutex2.Lock(); + jthread->runningmutex.Lock(); + jthread->running = true; + jthread->runningmutex.Unlock(); + + jthread->continuemutex.Lock(); + jthread->continuemutex.Unlock(); + + ret = jthread->Thread(); + + jthread->runningmutex.Lock(); + jthread->running = false; + jthread->retval = ret; + CloseHandle(jthread->threadhandle); + jthread->runningmutex.Unlock(); + return 0; +} + +void JThread::ThreadStarted() +{ + continuemutex2.Unlock(); +} + |