zeroc-ice 3.6b1

data/ext/ice/cpp/src/IceUtil/ConvertUTF.h

@@ -0,0 +1,144 @@
+/*
+ * Copyright 2001-2004 Unicode, Inc.
+ * 
+ * Disclaimer
+ * 
+ * This source code is provided as is by Unicode, Inc. No claims are
+ * made as to fitness for any particular purpose. No warranties of any
+ * kind are expressed or implied. The recipient agrees to determine
+ * applicability of information provided. If this file has been
+ * purchased on magnetic or optical media from Unicode, Inc., the
+ * sole remedy for any claim will be exchange of defective media
+ * within 90 days of receipt.
+ * 
+ * Limitations on Rights to Redistribute This Code
+ * 
+ * Unicode, Inc. hereby grants the right to freely use the information
+ * supplied in this file in the creation of products supporting the
+ * Unicode Standard, and to make copies of this file in any form
+ * for internal or external distribution as long as this notice
+ * remains attached.
+ */
+
+// **********************************************************************
+//
+// Copyright (c) 2003-2014 ZeroC, Inc. All rights reserved.
+//
+// This copy of Ice is licensed to you under the terms described in the
+// ICE_LICENSE file included in this distribution.
+//
+// **********************************************************************
+
+#ifndef ICE_UTIL_CONVERT_UTF_H
+#define ICE_UTIL_CONVERT_UTF_H
+
+#include <IceUtil/Unicode.h>
+
+
+/* ---------------------------------------------------------------------
+
+    Conversions between UTF32, UTF-16, and UTF-8.  Header file.
+
+    Several funtions are included here, forming a complete set of
+    conversions between the three formats.  UTF-7 is not included
+    here, but is handled in a separate source file.
+
+    Each of these routines takes pointers to input buffers and output
+    buffers.  The input buffers are const.
+
+    Each routine converts the text between *sourceStart and sourceEnd,
+    putting the result into the buffer between *targetStart and
+    targetEnd. Note: the end pointers are *after* the last item: e.g. 
+    *(sourceEnd - 1) is the last item.
+
+    The return result indicates whether the conversion was successful,
+    and if not, whether the problem was in the source or target buffers.
+    (Only the first encountered problem is indicated.)
+
+    After the conversion, *sourceStart and *targetStart are both
+    updated to point to the end of last text successfully converted in
+    the respective buffers.
+
+    Input parameters:
+        sourceStart - pointer to a pointer to the source buffer.
+                The contents of this are modified on return so that
+                it points at the next thing to be converted.
+        targetStart - similarly, pointer to pointer to the target buffer.
+        sourceEnd, targetEnd - respectively pointers to the ends of the
+                two buffers, for overflow checking only.
+
+    These conversion functions take a ConversionFlags argument. When this
+    flag is set to strict, both irregular sequences and isolated surrogates
+    will cause an error.  When the flag is set to lenient, both irregular
+    sequences and isolated surrogates are converted.
+
+    Whether the flag is strict or lenient, all illegal sequences will cause
+    an error return. This includes sequences such as: <F4 90 80 80>, <C0 80>,
+    or <A0> in UTF-8, and values above 0x10FFFF in UTF-32. Conformant code
+    must check for illegal sequences.
+
+    When the flag is set to lenient, characters over 0x10FFFF are converted
+    to the replacement character; otherwise (when the flag is set to strict)
+    they constitute an error.
+
+    Output parameters:
+        The value "sourceIllegal" is returned from some routines if the input
+        sequence is malformed.  When "sourceIllegal" is returned, the source
+        value will point to the illegal value that caused the problem. E.g.,
+        in UTF-8 when a sequence is malformed, it points to the start of the
+        malformed sequence.  
+
+    Author: Mark E. Davis, 1994.
+    Rev History: Rick McGowan, fixes & updates May 2001.
+                 Fixes & updates, Sept 2001.
+
+------------------------------------------------------------------------ */
+
+/* ---------------------------------------------------------------------
+    The following 4 definitions are compiler-specific.
+    The C standard does not guarantee that wchar_t has at least
+    16 bits, so wchar_t is no less portable than unsigned short!
+    All should be unsigned values to avoid sign extension during
+    bit mask & shift operations.
+------------------------------------------------------------------------ */
+
+namespace IceUtilInternal
+{
+
+typedef unsigned int    UTF32;  /* at least 32 bits */
+typedef unsigned short  UTF16;  /* at least 16 bits */
+typedef unsigned char   UTF8;   /* typically 8 bits */
+typedef bool            Boolean; /* 0 or 1 */
+
+/* Some fundamental constants */
+#define UNI_REPLACEMENT_CHAR static_cast<UTF32>(0x0000FFFD)
+#define UNI_MAX_BMP static_cast<UTF32>(0x0000FFFF)
+#define UNI_MAX_UTF16 static_cast<UTF32>(0x0010FFFF)
+#define UNI_MAX_UTF32 static_cast<UTF32>(0x7FFFFFFF)
+#define UNI_MAX_LEGAL_UTF32 static_cast<UTF32>(0x0010FFFF)
+
+
+ConversionResult ConvertUTF8toUTF16(
+    const UTF8** sourceStart, const UTF8* sourceEnd, 
+    UTF16** targetStart, UTF16* targetEnd, IceUtil::ConversionFlags flags);
+
+ConversionResult ConvertUTF16toUTF8 (
+    const UTF16** sourceStart, const UTF16* sourceEnd, 
+    UTF8** targetStart, UTF8* targetEnd, IceUtil::ConversionFlags flags);
+                
+ConversionResult ConvertUTF8toUTF32(
+    const UTF8** sourceStart, const UTF8* sourceEnd, 
+    UTF32** targetStart, UTF32* targetEnd, IceUtil::ConversionFlags flags);
+
+ConversionResult ConvertUTF32toUTF8(
+    const UTF32** sourceStart, const UTF32* sourceEnd, 
+    UTF8** targetStart, UTF8* targetEnd, IceUtil::ConversionFlags flags);
+
+//
+// isLegalUTFSequence is declared in IceUtil/StringConverter.h
+//
+
+/* --------------------------------------------------------------------- */
+
+}
+#endif

data/ext/ice/cpp/src/IceUtil/CountDownLatch.cpp

@@ -0,0 +1,184 @@
+// **********************************************************************
+//
+// Copyright (c) 2003-2014 ZeroC, Inc. All rights reserved.
+//
+// This copy of Ice is licensed to you under the terms described in the
+// ICE_LICENSE file included in this distribution.
+//
+// **********************************************************************
+
+#include <IceUtil/CountDownLatch.h>
+#include <IceUtil/ThreadException.h>
+
+IceUtilInternal::CountDownLatch::CountDownLatch(int count) :
+    _count(count)
+{
+    if(count < 0)
+    {
+        throw IceUtil::Exception(__FILE__, __LINE__);
+    }
+
+#ifdef _WIN32
+#   ifndef ICE_OS_WINRT
+    _event = CreateEvent(0, TRUE, FALSE, 0);
+#   else
+    _event = CreateEventExW(0, 0,  CREATE_EVENT_MANUAL_RESET, SEMAPHORE_ALL_ACCESS);
+#   endif
+    if(_event == 0)
+    {
+        throw  IceUtil::ThreadSyscallException(__FILE__, __LINE__, GetLastError());
+    }
+#else
+    int rc = pthread_mutex_init(&_mutex, 0);
+    if(rc != 0)
+    {
+        throw IceUtil::ThreadSyscallException(__FILE__, __LINE__, rc);
+    }
+    
+    rc = pthread_cond_init(&_cond, 0);
+    if(rc != 0)
+    {
+        throw IceUtil::ThreadSyscallException(__FILE__, __LINE__, rc);
+    }   
+#endif
+}
+
+IceUtilInternal::CountDownLatch::~CountDownLatch()
+{
+#ifdef _WIN32
+    CloseHandle(_event);
+#else
+#  ifndef NDEBUG
+    int rc = pthread_mutex_destroy(&_mutex);
+    assert(rc == 0);
+    rc = pthread_cond_destroy(&_cond);
+    assert(rc == 0);
+#  else
+    pthread_mutex_destroy(&_mutex);
+    pthread_cond_destroy(&_cond);
+#  endif
+#endif
+}
+
+void 
+IceUtilInternal::CountDownLatch::await() const
+{
+#ifdef _WIN32
+    while(InterlockedExchangeAdd(&_count, 0) > 0)
+    {
+#   ifndef ICE_OS_WINRT
+        DWORD rc = WaitForSingleObject(_event, INFINITE);
+#   else
+        DWORD rc = WaitForSingleObjectEx(_event, INFINITE, false);
+#   endif
+        assert(rc == WAIT_OBJECT_0 || rc == WAIT_FAILED);
+        
+        if(rc == WAIT_FAILED)
+        {
+            throw IceUtil::ThreadSyscallException(__FILE__, __LINE__, GetLastError());
+        }
+    }
+#else
+    lock();
+    while(_count > 0)
+    {
+        int rc = pthread_cond_wait(&_cond, &_mutex);
+        if(rc != 0)
+        {
+            pthread_mutex_unlock(&_mutex);
+            throw IceUtil::ThreadSyscallException(__FILE__, __LINE__, rc);
+        }
+    }
+    unlock();
+    
+#endif
+}
+
+void 
+IceUtilInternal::CountDownLatch::countDown()
+{
+#ifdef _WIN32
+    if(InterlockedDecrement(&_count) == 0)
+    {
+        if(SetEvent(_event) == 0)
+        {
+            throw IceUtil::ThreadSyscallException(__FILE__, __LINE__, GetLastError());
+        }
+    }
+#else
+    bool broadcast = false;
+
+    lock();
+    if(_count > 0 && --_count == 0)
+    {
+        broadcast = true;
+    }
+#if defined(__APPLE__)
+    //
+    // On OS X we do the broadcast with the mutex held. This seems to
+    // be necessary to prevent the broadcast call to hang (spinning in
+    // an infinite loop).
+    //
+    if(broadcast)
+    {
+        int rc = pthread_cond_broadcast(&_cond);
+        if(rc != 0)
+        {
+            pthread_mutex_unlock(&_mutex);
+            throw IceUtil::ThreadSyscallException(__FILE__, __LINE__, rc);
+        }
+    }
+    unlock();
+    
+#else
+    unlock();
+    
+    if(broadcast)
+    {
+        int rc = pthread_cond_broadcast(&_cond);
+        if(rc != 0)
+        {
+            throw IceUtil::ThreadSyscallException(__FILE__, __LINE__, rc);
+        }
+    }
+#endif
+
+#endif
+}
+
+int 
+IceUtilInternal::CountDownLatch::getCount() const
+{
+#ifdef _WIN32
+    int count = InterlockedExchangeAdd(&_count, 0);
+    return count > 0 ? count : 0;
+#else
+    lock();
+    int result = _count;
+    unlock();
+    return result;
+#endif
+}
+
+#ifndef _WIN32
+void
+IceUtilInternal::CountDownLatch::lock() const
+{
+    int rc = pthread_mutex_lock(&_mutex);
+    if(rc != 0)
+    {
+        throw IceUtil::ThreadSyscallException(__FILE__, __LINE__, rc);
+    }
+}
+
+void
+IceUtilInternal::CountDownLatch::unlock() const
+{
+    int rc = pthread_mutex_unlock(&_mutex);
+    if(rc != 0)
+    {
+        throw IceUtil::ThreadSyscallException(__FILE__, __LINE__, rc);
+    }
+}
+
+#endif

data/ext/ice/cpp/src/IceUtil/CtrlCHandler.cpp

@@ -0,0 +1,273 @@
+// **********************************************************************
+//
+// Copyright (c) 2003-2014 ZeroC, Inc. All rights reserved.
+//
+// This copy of Ice is licensed to you under the terms described in the
+// ICE_LICENSE file included in this distribution.
+//
+// **********************************************************************
+
+#ifdef __sun
+#    define _POSIX_PTHREAD_SEMANTICS
+#endif
+
+#include <IceUtil/CtrlCHandler.h>
+#include <IceUtil/MutexPtrLock.h>
+#include <IceUtil/Mutex.h>
+
+#ifndef _WIN32
+#   include <signal.h>
+#endif
+
+using namespace std;
+using namespace IceUtil;
+
+namespace
+{
+
+CtrlCHandlerCallback _callback = 0;
+const CtrlCHandler* _handler = 0;
+
+IceUtil::Mutex* globalMutex = 0;
+
+class Init
+{
+public:
+
+    Init()
+    {
+        globalMutex = new IceUtil::Mutex;
+    }
+
+    ~Init()
+    {
+        delete globalMutex;
+        globalMutex = 0;
+    }
+};
+
+Init init;
+
+}
+
+CtrlCHandlerException::CtrlCHandlerException(const char* file, int line) :
+    Exception(file, line)
+{
+}
+
+namespace
+{
+
+const char* ctrlCHandlerName = "IceUtil::CtrlCHandlerException";
+
+}
+
+string
+CtrlCHandlerException::ice_name() const
+{
+    return ctrlCHandlerName;
+}
+
+CtrlCHandlerException*
+CtrlCHandlerException::ice_clone() const
+{
+    return new CtrlCHandlerException(*this);
+}
+
+void
+CtrlCHandlerException::ice_throw() const
+{
+    throw *this;
+}
+
+void 
+CtrlCHandler::setCallback(CtrlCHandlerCallback callback)
+{
+    IceUtilInternal::MutexPtrLock<IceUtil::Mutex> lock(globalMutex);
+    _callback = callback;
+}
+
+CtrlCHandlerCallback 
+CtrlCHandler::getCallback() const
+{
+    IceUtilInternal::MutexPtrLock<IceUtil::Mutex> lock(globalMutex);
+    return _callback;
+}
+
+#ifdef _WIN32
+
+static BOOL WINAPI handlerRoutine(DWORD dwCtrlType)
+{
+    CtrlCHandlerCallback callback;
+    {
+        IceUtilInternal::MutexPtrLock<IceUtil::Mutex> lock(globalMutex);
+        if(!_handler) // The handler is destroyed.
+        {
+            return FALSE;
+        }
+        callback = _callback;
+    }
+    if(callback != 0)
+    {
+        callback(dwCtrlType);
+    }
+    return TRUE;
+}
+
+
+CtrlCHandler::CtrlCHandler(CtrlCHandlerCallback callback)
+{
+    IceUtilInternal::MutexPtrLock<IceUtil::Mutex> lock(globalMutex);
+    bool handler = _handler != 0;
+
+    if(handler)
+    {
+        throw CtrlCHandlerException(__FILE__, __LINE__);
+    }
+    else
+    {
+        _callback = callback;
+        _handler = this;
+        lock.release();
+
+        SetConsoleCtrlHandler(handlerRoutine, TRUE);
+    }
+}
+
+CtrlCHandler::~CtrlCHandler()
+{
+    SetConsoleCtrlHandler(handlerRoutine, FALSE);
+    {
+        IceUtilInternal::MutexPtrLock<IceUtil::Mutex> lock(globalMutex);
+        _handler = 0;
+    }
+}
+
+#else
+
+extern "C" 
+{
+
+static void* 
+sigwaitThread(void*)
+{
+    sigset_t ctrlCLikeSignals;
+    sigemptyset(&ctrlCLikeSignals);
+    sigaddset(&ctrlCLikeSignals, SIGHUP);
+    sigaddset(&ctrlCLikeSignals, SIGINT);
+    sigaddset(&ctrlCLikeSignals, SIGTERM);
+
+    //
+    // Run until the handler is destroyed (_handler == 0)
+    //
+    for(;;)
+    {
+        int signal = 0;
+        int rc = sigwait(&ctrlCLikeSignals, &signal);
+        if(rc == EINTR)
+        {
+            //
+            // Some sigwait() implementations incorrectly return EINTR
+            // when interrupted by an unblocked caught signal
+            //
+            continue;
+        }
+        assert(rc == 0);
+        
+        CtrlCHandlerCallback callback;
+        {
+            IceUtilInternal::MutexPtrLock<IceUtil::Mutex> lock(globalMutex);
+            if(!_handler) // The handler is destroyed.
+            {
+                return 0;
+            }
+            callback = _callback;
+        }
+
+        if(callback != 0)
+        {
+            callback(signal);
+        }
+    }
+    return 0;
+}
+
+}
+
+namespace
+{
+
+pthread_t _tid;
+
+}
+
+CtrlCHandler::CtrlCHandler(CtrlCHandlerCallback callback)
+{
+    IceUtilInternal::MutexPtrLock<IceUtil::Mutex> lock(globalMutex);
+    bool handler = _handler != 0;
+
+    if(handler)
+    {
+        throw CtrlCHandlerException(__FILE__, __LINE__);
+    }
+    else
+    {
+        _callback = callback;
+        _handler = this;
+
+        lock.release();
+        
+        // We block these CTRL+C like signals in the main thread,
+        // and by default all other threads will inherit this signal
+        // mask.
+        
+        sigset_t ctrlCLikeSignals;
+        sigemptyset(&ctrlCLikeSignals);
+        sigaddset(&ctrlCLikeSignals, SIGHUP);
+        sigaddset(&ctrlCLikeSignals, SIGINT);
+        sigaddset(&ctrlCLikeSignals, SIGTERM);
+
+#ifndef NDEBUG
+        int rc = pthread_sigmask(SIG_BLOCK, &ctrlCLikeSignals, 0);
+        assert(rc == 0);
+
+        // Joinable thread
+        rc = pthread_create(&_tid, 0, sigwaitThread, 0);
+        assert(rc == 0);
+#else
+        pthread_sigmask(SIG_BLOCK, &ctrlCLikeSignals, 0);
+
+        // Joinable thread
+        pthread_create(&_tid, 0, sigwaitThread, 0);
+#endif
+    }
+}
+
+CtrlCHandler::~CtrlCHandler()
+{
+    //
+    // Clear the handler, the sigwaitThread will exit if _handler is
+    // nil.
+    //
+    {
+        IceUtilInternal::MutexPtrLock<IceUtil::Mutex> lock(globalMutex);
+        _handler = 0;
+    }
+
+    //
+    // Signal the sigwaitThread and join it.
+    //
+    void* status = 0;
+#ifndef NDEBUG
+    int rc = pthread_kill(_tid, SIGTERM);
+    assert(rc == 0);
+    rc = pthread_join(_tid, &status);
+    assert(rc == 0);
+#else
+    pthread_kill(_tid, SIGTERM);
+    pthread_join(_tid, &status);
+#endif
+}
+
+#endif
+