zeroc-ice 3.7.11 → 3.8.1

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

@@ -1,147 +0,0 @@
-/*
- * 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) ZeroC, Inc. All rights reserved.
-//
-
-#ifndef ICE_UTIL_CONVERT_UTF_H
-#define ICE_UTIL_CONVERT_UTF_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.
-
------------------------------------------------------------------------- */
-
-namespace IceUtilInternal
-{
-
-enum ConversionFlags
-{
-    strictConversion = 0,
-    lenientConversion
-};
-
-enum ConversionResult
-{
-        conversionOK,           /* conversion successful */
-        sourceExhausted,        /* partial character in source, but hit end */
-        targetExhausted,        /* insuff. room in target for conversion */
-        sourceIllegal           /* source sequence is illegal/malformed */
-};
-
-/* ---------------------------------------------------------------------
-    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.
------------------------------------------------------------------------- */
-
-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, ConversionFlags flags);
-
-ConversionResult ConvertUTF16toUTF8 (
-    const UTF16** sourceStart, const UTF16* sourceEnd,
-    UTF8** targetStart, UTF8* targetEnd, ConversionFlags flags);
-
-ConversionResult ConvertUTF8toUTF32(
-    const UTF8** sourceStart, const UTF8* sourceEnd,
-    UTF32** targetStart, UTF32* targetEnd, ConversionFlags flags);
-
-ConversionResult ConvertUTF32toUTF8(
-    const UTF32** sourceStart, const UTF32* sourceEnd,
-    UTF8** targetStart, UTF8* targetEnd, ConversionFlags flags);
-
-bool isLegalUTF8Sequence(const UTF8* source, const UTF8* end);
-
-/* --------------------------------------------------------------------- */
-
-}
-#endif

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

@@ -1,259 +0,0 @@
-//
-// Copyright (c) ZeroC, Inc. All rights reserved.
-//
-
-#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 = ICE_NULLPTR;
-
-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) :
-    ExceptionHelper<CtrlCHandlerException>(file, line)
-{
-}
-
-string
-CtrlCHandlerException::ice_id() const
-{
-    return "::IceUtil::CtrlCHandlerException";
-}
-
-#ifndef ICE_CPP11_MAPPING
-CtrlCHandlerException*
-CtrlCHandlerException::ice_clone() const
-{
-    return new CtrlCHandlerException(*this);
-}
-#endif
-
-CtrlCHandlerCallback
-CtrlCHandler::setCallback(CtrlCHandlerCallback callback)
-{
-    IceUtilInternal::MutexPtrLock<IceUtil::Mutex> lock(globalMutex);
-    CtrlCHandlerCallback oldCallback = _callback;
-    _callback = callback;
-    return oldCallback;
-}
-
-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)
-    {
-        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;
-        _callback = ICE_NULLPTR;
-    }
-}
-
-#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)
-        {
-            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 null
-    //
-    {
-        IceUtilInternal::MutexPtrLock<IceUtil::Mutex> lock(globalMutex);
-        _handler = 0;
-        _callback = ICE_NULLPTR;
-    }
-
-    //
-    // 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