From d825ed572f97d7d354c84106e508d52255f5e94b Mon Sep 17 00:00:00 2001 From: Perttu Ahola Date: Sat, 8 Jan 2011 03:10:20 +0200 Subject: CMake working on Linux (not on windows) --HG-- rename : Makefile => Makefile.bak --- CMakeLists.txt | 15 ++++ Makefile | 90 -------------------- Makefile.bak | 90 ++++++++++++++++++++ cmake/Modules/FindIrrlicht.cmake | 38 +++++++++ src/CMakeLists.txt | 73 ++++++++++++++++ src/jthread/CMakeLists.txt | 16 ++++ src/jthread/LICENSE.MIT | 20 +++++ src/jthread/jmutex.h | 70 +++++++++++++++ src/jthread/jmutexautolock.h | 43 ++++++++++ src/jthread/jthread.h | 77 +++++++++++++++++ src/jthread/pthread/jmutex.cpp | 67 +++++++++++++++ src/jthread/pthread/jthread.cpp | 180 +++++++++++++++++++++++++++++++++++++++ src/jthread/win32/jmutex.cpp | 83 ++++++++++++++++++ src/jthread/win32/jthread.cpp | 177 ++++++++++++++++++++++++++++++++++++++ 14 files changed, 949 insertions(+), 90 deletions(-) create mode 100644 CMakeLists.txt delete mode 100644 Makefile create mode 100644 Makefile.bak create mode 100644 cmake/Modules/FindIrrlicht.cmake create mode 100644 src/CMakeLists.txt create mode 100644 src/jthread/CMakeLists.txt create mode 100644 src/jthread/LICENSE.MIT create mode 100644 src/jthread/jmutex.h create mode 100644 src/jthread/jmutexautolock.h create mode 100644 src/jthread/jthread.h create mode 100644 src/jthread/pthread/jmutex.cpp create mode 100644 src/jthread/pthread/jthread.cpp create mode 100644 src/jthread/win32/jmutex.cpp create mode 100644 src/jthread/win32/jthread.cpp 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 deleted file mode 100644 index 8ba03f9bb..000000000 --- a/Makefile +++ /dev/null @@ -1,90 +0,0 @@ -# Makefile for Irrlicht Examples -# It's usually sufficient to change just the target name and source file list -# and be sure that CXX is set to a valid compiler -SOURCE_FILES = 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 - -DEBUG_TARGET = debugtest -DEBUG_SOURCES = $(addprefix src/, $(SOURCE_FILES)) -DEBUG_BUILD_DIR = debugbuild -DEBUG_OBJECTS = $(addprefix $(DEBUG_BUILD_DIR)/, $(SOURCE_FILES:.cpp=.o)) - -FAST_TARGET = fasttest -FAST_SOURCES = $(addprefix src/, $(SOURCE_FILES)) -FAST_BUILD_DIR = fastbuild -FAST_OBJECTS = $(addprefix $(FAST_BUILD_DIR)/, $(SOURCE_FILES:.cpp=.o)) - -SERVER_TARGET = server -SERVER_SOURCE_FILES = porting.cpp materials.cpp defaultsettings.cpp mapnode.cpp voxel.cpp mapblockobject.cpp inventory.cpp debug.cpp serialization.cpp light.cpp filesys.cpp connection.cpp environment.cpp server.cpp socket.cpp mapblock.cpp mapsector.cpp heightmap.cpp map.cpp player.cpp utility.cpp servermain.cpp test.cpp -SERVER_SOURCES = $(addprefix src/, $(SERVER_SOURCE_FILES)) -SERVER_BUILD_DIR = serverbuild -SERVER_OBJECTS = $(addprefix $(SERVER_BUILD_DIR)/, $(SERVER_SOURCE_FILES:.cpp=.o)) - -IRRLICHTPATH = ../irrlicht/irrlicht-1.7.1 -JTHREADPATH = ../jthread/jthread-1.2.1 - - -all: fast - -ifeq ($(HOSTTYPE), x86_64) -LIBSELECT=64 -endif - -debug: CXXFLAGS = -Wall -g -O1 -debug: CPPFLAGS = -I$(IRRLICHTPATH)/include -I/usr/X11R6/include -I$(JTHREADPATH)/src -DDEBUG -DRUN_IN_PLACE -debug: LDFLAGS = -L/usr/X11R6/lib$(LIBSELECT) -L$(IRRLICHTPATH)/lib/Linux -L$(JTHREADPATH)/src/.libs -lIrrlicht -lGL -lXxf86vm -lXext -lX11 -ljthread -lz - -fast: CXXFLAGS = -O3 -ffast-math -Wall -fomit-frame-pointer -pipe -funroll-loops -mtune=i686 -fast: CPPFLAGS = -I$(IRRLICHTPATH)/include -I/usr/X11R6/include -I$(JTHREADPATH)/src -DUNITTEST_DISABLE -DRUN_IN_PLACE -fast: LDFLAGS = -L/usr/X11R6/lib$(LIBSELECT) -L$(IRRLICHTPATH)/lib/Linux -L$(JTHREADPATH)/src/.libs -lIrrlicht -lGL -lXxf86vm -lXext -lX11 -ljthread -lz - -server: CXXFLAGS = -O3 -ffast-math -Wall -fomit-frame-pointer -pipe -funroll-loops -mtune=i686 -server: CPPFLAGS = -I$(IRRLICHTPATH)/include -I/usr/X11R6/include -I$(JTHREADPATH)/src -DSERVER -DUNITTEST_DISABLE -DRUN_IN_PLACE -server: LDFLAGS = -L$(JTHREADPATH)/src/.libs -ljthread -lz -lpthread - -DEBUG_DESTPATH = bin/$(DEBUG_TARGET) -FAST_DESTPATH = bin/$(FAST_TARGET) -SERVER_DESTPATH = bin/$(SERVER_TARGET) - -# Build commands - -debug: $(DEBUG_BUILD_DIR) $(DEBUG_DESTPATH) -fast: $(FAST_BUILD_DIR) $(FAST_DESTPATH) -server: $(SERVER_BUILD_DIR) $(SERVER_DESTPATH) - -$(DEBUG_BUILD_DIR): - mkdir -p $(DEBUG_BUILD_DIR) -$(FAST_BUILD_DIR): - mkdir -p $(FAST_BUILD_DIR) -$(SERVER_BUILD_DIR): - mkdir -p $(SERVER_BUILD_DIR) - -$(DEBUG_DESTPATH): $(DEBUG_OBJECTS) - $(CXX) -o $@ $(DEBUG_OBJECTS) $(LDFLAGS) - -$(FAST_DESTPATH): $(FAST_OBJECTS) - $(CXX) -o $@ $(FAST_OBJECTS) $(LDFLAGS) - -$(SERVER_DESTPATH): $(SERVER_OBJECTS) - $(CXX) -o $@ $(SERVER_OBJECTS) $(LDFLAGS) - -$(DEBUG_BUILD_DIR)/%.o: src/%.cpp - $(CXX) -c -o $@ $< $(CPPFLAGS) $(CXXFLAGS) - -$(FAST_BUILD_DIR)/%.o: src/%.cpp - $(CXX) -c -o $@ $< $(CPPFLAGS) $(CXXFLAGS) - -$(SERVER_BUILD_DIR)/%.o: src/%.cpp - $(CXX) -c -o $@ $< $(CPPFLAGS) $(CXXFLAGS) - -clean: clean_debug clean_fast clean_server - -clean_debug: - @$(RM) $(DEBUG_OBJECTS) $(DEBUG_DESTPATH) - -clean_fast: - @$(RM) $(FAST_OBJECTS) $(FAST_DESTPATH) - -clean_server: - @$(RM) $(SERVER_OBJECTS) $(SERVER_DESTPATH) - -.PHONY: all all_win32 clean clean_debug clean_win32 clean_fast clean_server diff --git a/Makefile.bak b/Makefile.bak new file mode 100644 index 000000000..8ba03f9bb --- /dev/null +++ b/Makefile.bak @@ -0,0 +1,90 @@ +# Makefile for Irrlicht Examples +# It's usually sufficient to change just the target name and source file list +# and be sure that CXX is set to a valid compiler +SOURCE_FILES = 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 + +DEBUG_TARGET = debugtest +DEBUG_SOURCES = $(addprefix src/, $(SOURCE_FILES)) +DEBUG_BUILD_DIR = debugbuild +DEBUG_OBJECTS = $(addprefix $(DEBUG_BUILD_DIR)/, $(SOURCE_FILES:.cpp=.o)) + +FAST_TARGET = fasttest +FAST_SOURCES = $(addprefix src/, $(SOURCE_FILES)) +FAST_BUILD_DIR = fastbuild +FAST_OBJECTS = $(addprefix $(FAST_BUILD_DIR)/, $(SOURCE_FILES:.cpp=.o)) + +SERVER_TARGET = server +SERVER_SOURCE_FILES = porting.cpp materials.cpp defaultsettings.cpp mapnode.cpp voxel.cpp mapblockobject.cpp inventory.cpp debug.cpp serialization.cpp light.cpp filesys.cpp connection.cpp environment.cpp server.cpp socket.cpp mapblock.cpp mapsector.cpp heightmap.cpp map.cpp player.cpp utility.cpp servermain.cpp test.cpp +SERVER_SOURCES = $(addprefix src/, $(SERVER_SOURCE_FILES)) +SERVER_BUILD_DIR = serverbuild +SERVER_OBJECTS = $(addprefix $(SERVER_BUILD_DIR)/, $(SERVER_SOURCE_FILES:.cpp=.o)) + +IRRLICHTPATH = ../irrlicht/irrlicht-1.7.1 +JTHREADPATH = ../jthread/jthread-1.2.1 + + +all: fast + +ifeq ($(HOSTTYPE), x86_64) +LIBSELECT=64 +endif + +debug: CXXFLAGS = -Wall -g -O1 +debug: CPPFLAGS = -I$(IRRLICHTPATH)/include -I/usr/X11R6/include -I$(JTHREADPATH)/src -DDEBUG -DRUN_IN_PLACE +debug: LDFLAGS = -L/usr/X11R6/lib$(LIBSELECT) -L$(IRRLICHTPATH)/lib/Linux -L$(JTHREADPATH)/src/.libs -lIrrlicht -lGL -lXxf86vm -lXext -lX11 -ljthread -lz + +fast: CXXFLAGS = -O3 -ffast-math -Wall -fomit-frame-pointer -pipe -funroll-loops -mtune=i686 +fast: CPPFLAGS = -I$(IRRLICHTPATH)/include -I/usr/X11R6/include -I$(JTHREADPATH)/src -DUNITTEST_DISABLE -DRUN_IN_PLACE +fast: LDFLAGS = -L/usr/X11R6/lib$(LIBSELECT) -L$(IRRLICHTPATH)/lib/Linux -L$(JTHREADPATH)/src/.libs -lIrrlicht -lGL -lXxf86vm -lXext -lX11 -ljthread -lz + +server: CXXFLAGS = -O3 -ffast-math -Wall -fomit-frame-pointer -pipe -funroll-loops -mtune=i686 +server: CPPFLAGS = -I$(IRRLICHTPATH)/include -I/usr/X11R6/include -I$(JTHREADPATH)/src -DSERVER -DUNITTEST_DISABLE -DRUN_IN_PLACE +server: LDFLAGS = -L$(JTHREADPATH)/src/.libs -ljthread -lz -lpthread + +DEBUG_DESTPATH = bin/$(DEBUG_TARGET) +FAST_DESTPATH = bin/$(FAST_TARGET) +SERVER_DESTPATH = bin/$(SERVER_TARGET) + +# Build commands + +debug: $(DEBUG_BUILD_DIR) $(DEBUG_DESTPATH) +fast: $(FAST_BUILD_DIR) $(FAST_DESTPATH) +server: $(SERVER_BUILD_DIR) $(SERVER_DESTPATH) + +$(DEBUG_BUILD_DIR): + mkdir -p $(DEBUG_BUILD_DIR) +$(FAST_BUILD_DIR): + mkdir -p $(FAST_BUILD_DIR) +$(SERVER_BUILD_DIR): + mkdir -p $(SERVER_BUILD_DIR) + +$(DEBUG_DESTPATH): $(DEBUG_OBJECTS) + $(CXX) -o $@ $(DEBUG_OBJECTS) $(LDFLAGS) + +$(FAST_DESTPATH): $(FAST_OBJECTS) + $(CXX) -o $@ $(FAST_OBJECTS) $(LDFLAGS) + +$(SERVER_DESTPATH): $(SERVER_OBJECTS) + $(CXX) -o $@ $(SERVER_OBJECTS) $(LDFLAGS) + +$(DEBUG_BUILD_DIR)/%.o: src/%.cpp + $(CXX) -c -o $@ $< $(CPPFLAGS) $(CXXFLAGS) + +$(FAST_BUILD_DIR)/%.o: src/%.cpp + $(CXX) -c -o $@ $< $(CPPFLAGS) $(CXXFLAGS) + +$(SERVER_BUILD_DIR)/%.o: src/%.cpp + $(CXX) -c -o $@ $< $(CPPFLAGS) $(CXXFLAGS) + +clean: clean_debug clean_fast clean_server + +clean_debug: + @$(RM) $(DEBUG_OBJECTS) $(DEBUG_DESTPATH) + +clean_fast: + @$(RM) $(FAST_OBJECTS) $(FAST_DESTPATH) + +clean_server: + @$(RM) $(SERVER_OBJECTS) $(SERVER_DESTPATH) + +.PHONY: all all_win32 clean clean_debug clean_win32 clean_fast clean_server 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 + #endif // _WIN32_WCE + #include + #include + + #define JMUTEX_CRITICALSECTION +#else // using pthread + #include +#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 +#include +#include + +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 +#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(); +} + -- cgit v1.2.3