1 files changed, 168 insertions, 0 deletions

diff --git a/src/3rdParty/efsw/platform/posix/SystemImpl.cpp b/src/3rdParty/efsw/platform/posix/SystemImpl.cpp
new file mode 100755
index 0000000..37d4120
--- /dev/null
+++ b/src/3rdParty/efsw/platform/posix/SystemImpl.cpp
@@ -0,0 +1,168 @@
+#include <efsw/platform/posix/SystemImpl.hpp>
+
+#if defined( EFSW_PLATFORM_POSIX )
+
+#include <cstdio>
+#include <limits.h>
+#include <pthread.h>
+#include <sys/resource.h>
+#include <sys/time.h>
+
+#include <efsw/Debug.hpp>
+#include <efsw/FileSystem.hpp>
+
+#if EFSW_OS == EFSW_OS_MACOSX
+#include <CoreFoundation/CoreFoundation.h>
+#elif EFSW_OS == EFSW_OS_LINUX || EFSW_OS == EFSW_OS_ANDROID
+#include <libgen.h>
+#include <unistd.h>
+#elif EFSW_OS == EFSW_OS_HAIKU
+#include <kernel/OS.h>
+#include <kernel/image.h>
+#elif EFSW_OS == EFSW_OS_SOLARIS
+#include <stdlib.h>
+#elif EFSW_OS == EFSW_OS_BSD
+#include <sys/sysctl.h>
+#endif
+
+namespace efsw { namespace Platform {
+
+void System::sleep( const unsigned long& ms ) {
+        // usleep( static_cast<unsigned long>( ms * 1000 ) );
+
+        // usleep is not reliable enough (it might block the
+        // whole process instead of just the current thread)
+        // so we must use pthread_cond_timedwait instead
+
+        // this implementation is inspired from Qt
+        // and taken from SFML
+
+        unsigned long long usecs = ms * 1000;
+
+        // get the current time
+        timeval tv;
+        gettimeofday( &tv, NULL );
+
+        // construct the time limit (current time + time to wait)
+        timespec ti;
+        ti.tv_nsec = ( tv.tv_usec + ( usecs % 1000000 ) ) * 1000;
+        ti.tv_sec = tv.tv_sec + ( usecs / 1000000 ) + ( ti.tv_nsec / 1000000000 );
+        ti.tv_nsec %= 1000000000;
+
+        // create a mutex and thread condition
+        pthread_mutex_t mutex;
+        pthread_mutex_init( &mutex, 0 );
+        pthread_cond_t condition;
+        pthread_cond_init( &condition, 0 );
+
+        // wait...
+        pthread_mutex_lock( &mutex );
+        pthread_cond_timedwait( &condition, &mutex, &ti );
+        pthread_mutex_unlock( &mutex );
+
+        // destroy the mutex and condition
+        pthread_cond_destroy( &condition );
+}
+
+std::string System::getProcessPath() {
+#if EFSW_OS == EFSW_OS_MACOSX
+        char exe_file[FILENAME_MAX + 1];
+
+        CFBundleRef mainBundle = CFBundleGetMainBundle();
+
+        if ( mainBundle ) {
+                CFURLRef mainURL = CFBundleCopyBundleURL( mainBundle );
+
+                if ( mainURL ) {
+                        int ok = CFURLGetFileSystemRepresentation( mainURL, ( Boolean ) true, (UInt8*)exe_file,
+                                                                                                           FILENAME_MAX );
+
+                        if ( ok ) {
+                                return std::string( exe_file ) + "/";
+                        }
+                }
+        }
+
+        return "./";
+#elif EFSW_OS == EFSW_OS_LINUX
+        char exe_file[FILENAME_MAX + 1];
+
+        int size;
+
+        size = readlink( "/proc/self/exe", exe_file, FILENAME_MAX );
+
+        if ( size < 0 ) {
+                return std::string( "./" );
+        } else {
+                exe_file[size] = '\0';
+                return std::string( dirname( exe_file ) ) + "/";
+        }
+
+#elif EFSW_OS == EFSW_OS_BSD
+        int mib[4];
+        mib[0] = CTL_KERN;
+        mib[1] = KERN_PROC;
+        mib[2] = KERN_PROC_PATHNAME;
+        mib[3] = -1;
+        char buf[1024];
+        size_t cb = sizeof( buf );
+        sysctl( mib, 4, buf, &cb, NULL, 0 );
+
+        return FileSystem::pathRemoveFileName( std::string( buf ) );
+
+#elif EFSW_OS == EFSW_OS_SOLARIS
+        return FileSystem::pathRemoveFileName( std::string( getexecname() ) );
+
+#elif EFSW_OS == EFSW_OS_HAIKU
+        image_info info;
+        int32 cookie = 0;
+
+        while ( B_OK == get_next_image_info( 0, &cookie, &info ) ) {
+                if ( info.type == B_APP_IMAGE )
+                        break;
+        }
+
+        return FileSystem::pathRemoveFileName( std::string( info.name ) );
+
+#elif EFSW_OS == EFSW_OS_ANDROID
+        return "/sdcard/";
+
+#else
+#warning getProcessPath() not implemented on this platform. ( will return "./" )
+        return "./";
+
+#endif
+}
+
+void System::maxFD() {
+        static bool maxed = false;
+
+        if ( !maxed ) {
+                struct rlimit limit;
+                getrlimit( RLIMIT_NOFILE, &limit );
+                limit.rlim_cur = limit.rlim_max;
+                setrlimit( RLIMIT_NOFILE, &limit );
+
+                getrlimit( RLIMIT_NOFILE, &limit );
+
+                efDEBUG( "File descriptor limit %ld\n", limit.rlim_cur );
+
+                maxed = true;
+        }
+}
+
+Uint64 System::getMaxFD() {
+        static rlim_t max_fd = 0;
+
+        if ( max_fd == 0 ) {
+                struct rlimit limit;
+                getrlimit( RLIMIT_NOFILE, &limit );
+                max_fd = limit.rlim_cur;
+        }
+
+        return max_fd;
+}
+
+}} // namespace efsw::Platform
+
+#endif