zeroc-ice 3.6b1

data/ext/ice/cpp/include/IceUtil/SHA1.h

@@ -0,0 +1,65 @@
+// **********************************************************************
+//
+// 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_SHA1_H
+#define ICE_UTIL_SHA1_H
+
+#include <IceUtil/Config.h>
+
+#include <vector>
+
+#ifndef ICE_OS_WINRT
+#   if defined(_WIN32)
+#      include <Wincrypt.h>
+#   elif defined(__APPLE__)
+#      include <CommonCrypto/CommonDigest.h>
+#   else
+#      include <openssl/sha.h>
+#   endif
+#endif
+
+namespace IceUtil
+{
+
+ICE_UTIL_API void 
+sha1(const unsigned char*, std::size_t, std::vector<unsigned char>&);
+    
+#ifndef ICE_OS_WINRT
+class ICE_UTIL_API SHA1
+{
+public:
+    SHA1();
+    
+#   ifdef _WIN32
+    ~SHA1();
+#   endif
+    
+    void update(const unsigned char*, std::size_t);
+    
+    void finalize(std::vector<unsigned char>&);
+
+private:
+
+    // noncopyable
+    SHA1(const SHA1&);
+    SHA1 operator=(const SHA1&);
+    
+#   if defined (_WIN32)
+    HCRYPTPROV _ctx;
+    HCRYPTHASH _hash;
+#   elif defined(__APPLE__)
+    CC_SHA1_CTX _ctx;
+#   else
+    SHA_CTX _ctx;
+#   endif
+};
+#endif
+
+}
+#endif

data/ext/ice/cpp/include/IceUtil/ScannerConfig.h

@@ -0,0 +1,44 @@
+// **********************************************************************
+//
+// 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_SCANNER_CONFIG_H
+#define ICE_UTIL_SCANNER_CONFIG_H
+
+#include <IceUtil/Config.h> // Required by generated Scanners.
+
+//
+// COMPILERFIX: VC compilers does not provide stdint.h header until VC100
+// the header must be included before that macros for integral types
+// in flex generated Scanners are defined.
+//
+// in C99 conformant compilers we don't need to include it because the
+// header is included by inttypes.h, that is included by the gernated 
+// Scanners.
+//
+#if defined(_MSC_VER) && (_MSC_VER >= 1600)
+#   include <stdint.h>
+#endif
+
+//
+// Apple clang++ >= 5.1  deprecate 'register' storage class specifier
+// used by lex generated Scanners.
+//
+#if defined(__clang__) && defined(__apple_build_version__) && __apple_build_version__ >= 5030038
+#   pragma clang diagnostic ignored "-Wdeprecated-register"
+#endif
+
+
+//
+// Avoid old style cast warnings in generated scanners
+// 
+#ifdef __GNUC__
+#  pragma GCC diagnostic ignored "-Wold-style-cast"
+#endif
+
+#endif

data/ext/ice/cpp/include/IceUtil/ScopedArray.h

@@ -0,0 +1,97 @@
+// **********************************************************************
+//
+// 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_SCOPED_ARRAY_H
+#define ICE_UTIL_SCOPED_ARRAY_H
+
+#include <IceUtil/Config.h>
+
+namespace IceUtil
+{
+
+template<typename T>
+class ScopedArray
+{
+public:
+
+    explicit ScopedArray(T* ptr = 0) :
+        _ptr(ptr)
+    {
+    }
+
+    ScopedArray(const ScopedArray& other)
+    {
+        _ptr = other._ptr;
+        const_cast<ScopedArray&>(other)._ptr = 0;
+    }
+
+    ~ScopedArray()
+    {
+        if(_ptr != 0)
+        {
+            delete[] _ptr;
+        }
+    }
+
+    void reset(T* ptr = 0)
+    {
+        assert(ptr == 0 || ptr != _ptr);
+        if(_ptr != 0)
+        {
+            delete[] _ptr;
+        }
+        _ptr = ptr;
+    }
+
+    ScopedArray& operator=(const ScopedArray& other)
+    {
+        if(_ptr != 0)
+        {
+            delete[] _ptr;
+        }
+        _ptr = other._ptr;
+        const_cast<ScopedArray&>(other)._ptr = 0;
+        return *this;
+    }
+
+
+    T& operator[](size_t i) const
+    {
+        assert(_ptr != 0);
+        assert(i >= 0);
+        return _ptr[i];
+    }
+
+    T* get() const
+    {
+        return _ptr;
+    }
+
+    void swap(ScopedArray& a)
+    {
+        T* tmp = a._ptr;
+        a._ptr = _ptr;
+        _ptr = tmp;
+    }
+
+    T* release()
+    {
+        T* tmp = _ptr;
+        _ptr = 0;
+        return tmp;
+    }
+
+private:
+
+    T* _ptr;
+};
+
+} // End of namespace IceUtil
+
+#endif

data/ext/ice/cpp/include/IceUtil/Shared.h

@@ -0,0 +1,168 @@
+// **********************************************************************
+//
+// 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_SHARED_H
+#define ICE_UTIL_SHARED_H
+
+#include <IceUtil/Config.h>
+
+#if defined(ICE_USE_MUTEX_SHARED)
+
+#   include <IceUtil/Mutex.h>
+
+// Using the gcc builtins requires gcc 4.1 or better. For Linux, i386
+// doesn't work. Apple is supported for all architectures. Sun only
+// supports sparc (32 and 64 bit).
+
+#elif ((defined(__GNUC__) && (((__GNUC__* 100) + __GNUC_MINOR__) >= 401)) || __clang__)  &&                         \
+        ((defined(__sun) && (defined(__sparc) || defined(__sparcv9))) || \
+         defined(__APPLE__) || \
+        (defined(__linux) && \
+                (defined(__i486) || defined(__i586) || \
+                 defined(__i686) || defined(__x86_64))))
+
+#   define ICE_HAS_GCC_BUILTINS
+
+#elif (defined(__APPLE__) || defined(__linux) || defined(__FreeBSD__)) && (defined(__i386) || defined(__x86_64)) && !defined(__ICC)
+
+#   define ICE_HAS_ATOMIC_FUNCTIONS
+
+#elif defined(_WIN32)
+// Nothing to include
+#else
+// Use a simple mutex
+#   include <IceUtil/Mutex.h>
+#endif
+
+//
+// Base classes for reference counted types. The IceUtil::Handle
+// template can be used for smart pointers to types derived from these
+// bases.
+//
+// IceUtil::SimpleShared
+// =====================
+//
+// A non thread-safe base class for reference-counted types.
+//
+// IceUtil::Shared
+// ===============
+//
+// A thread-safe base class for reference-counted types.
+//
+namespace IceUtil
+{
+
+class ICE_UTIL_API SimpleShared
+{
+public:
+
+    SimpleShared();
+    SimpleShared(const SimpleShared&);
+
+    virtual ~SimpleShared()
+    {
+    }
+
+    SimpleShared& operator=(const SimpleShared&)
+    {
+        return *this;
+    }
+
+    void __incRef()
+    {
+        assert(_ref >= 0);
+        ++_ref;
+    }
+
+    void __decRef()
+    {
+        assert(_ref > 0);
+        if(--_ref == 0)
+        {
+            if(!_noDelete)
+            {
+                delete this;
+            }
+        }
+    }
+
+    int __getRef() const
+    {
+        return _ref;
+    }
+
+    void __setNoDelete(bool b)
+    {
+        _noDelete = b;
+    }
+
+private:
+
+    int _ref;
+    bool _noDelete;
+};
+
+class ICE_UTIL_API Shared
+{
+public:
+
+    //
+    // Flag constant used by the Shared class. Derived classes
+    // such as GCObject define more flag constants.
+    //
+    static const unsigned char NoDelete;
+
+    Shared();
+    Shared(const Shared&);
+
+    virtual ~Shared()
+    {
+    }
+
+    Shared& operator=(const Shared&)
+    {
+        return *this;
+    }
+
+    virtual void __incRef();
+    virtual void __decRef();
+    virtual int __getRef() const;
+    virtual void __setNoDelete(bool);
+
+    void __setFlag(unsigned char flag)
+    {
+        _flags |= flag;
+    }
+
+    void __clearFlag(unsigned char flag)
+    {
+        _flags &= ~flag;
+    }
+
+    bool __hasFlag(unsigned char flag)
+    {
+        return (_flags & flag) > 0;
+    }
+    
+protected:
+
+#if defined(_WIN32)
+    LONG _ref;
+#elif defined(ICE_HAS_ATOMIC_FUNCTIONS) || defined(ICE_HAS_GCC_BUILTINS)
+    volatile int _ref;
+#else
+    int _ref;
+    Mutex _mutex;
+#endif
+    unsigned char _flags;
+};
+
+}
+
+#endif

data/ext/ice/cpp/include/IceUtil/StringConverter.h

@@ -0,0 +1,175 @@
+//
+// This copy of Ice is licensed to you under the terms described in the
+// ICE_LICENSE file included in this distribution.
+//
+// **********************************************************************
+
+#ifndef ICE_UTIL_STRING_CONVERTER_H
+#define ICE_UTIL_STRING_CONVERTER_H
+
+#include <IceUtil/Config.h>
+#include <IceUtil/Exception.h>
+#include <IceUtil/Shared.h>
+#include <IceUtil/Handle.h>
+
+#include <string>
+
+namespace IceUtil
+{
+
+enum ConversionFlags
+{
+    strictConversion = 0,
+    lenientConversion
+};
+
+typedef unsigned char Byte;
+
+ICE_UTIL_API bool
+isLegalUTF8Sequence(const Byte* source, const Byte* end);
+
+//
+// Provides bytes to toUTF8. Can raise std::bad_alloc or Ice::MemoryLimitException 
+// when too many bytes are requested.
+//
+class ICE_UTIL_API UTF8Buffer
+{
+public:
+    virtual Byte* getMoreBytes(size_t howMany, Byte* firstUnused) = 0;
+    
+    virtual ~UTF8Buffer() {}
+};
+
+//
+// A StringConverter converts narrow or wide-strings to and from UTF-8 byte sequences.
+// It's used by the communicator during marshaling (toUTF8) and unmarshaling (fromUTF8).
+// It report errors by raising IllegalConversionException or an exception raised
+// by UTF8Buffer
+//
+template<typename charT>
+class BasicStringConverter : public IceUtil::Shared
+{
+public:
+    //
+    // Returns a pointer to byte after the last written byte (which may be
+    // past the last byte returned by getMoreBytes).
+    //
+    virtual Byte* toUTF8(const charT* sourceStart, const charT* sourceEnd,
+                         UTF8Buffer&) const = 0;
+
+    //
+    // Unmarshals a UTF-8 sequence into a basic_string
+    //
+    virtual void fromUTF8(const Byte* sourceStart, const Byte* sourceEnd,
+                          std::basic_string<charT>& target) const = 0;
+};
+
+typedef BasicStringConverter<char> StringConverter;
+typedef IceUtil::Handle<StringConverter> StringConverterPtr;
+
+typedef BasicStringConverter<wchar_t> WstringConverter;
+typedef IceUtil::Handle<WstringConverter> WstringConverterPtr;
+
+//
+// Converts to and from UTF-16 or UTF-32 depending on sizeof(wchar_t)
+//
+class ICE_UTIL_API UnicodeWstringConverter : public WstringConverter
+{
+public:
+
+    UnicodeWstringConverter(ConversionFlags = lenientConversion);
+
+    virtual Byte* toUTF8(const wchar_t*, const wchar_t*, UTF8Buffer&) const;
+
+    virtual void fromUTF8(const Byte*, const Byte*, std::wstring&) const;
+
+private:
+    const ConversionFlags _conversionFlags;
+};
+
+#ifdef _WIN32
+
+//
+// Converts to/from UTF-8 using MultiByteToWideChar and WideCharToMultiByte
+//
+class ICE_UTIL_API WindowsStringConverter : public StringConverter
+{
+public:
+
+    explicit WindowsStringConverter(unsigned int);
+
+    virtual Byte* toUTF8(const char*, const char*, UTF8Buffer&) const;
+
+    virtual void fromUTF8(const Byte*, const Byte*, std::string& target) const;
+
+private:
+    unsigned int _cp;
+    UnicodeWstringConverter _unicodeWstringConverter;
+};
+#endif
+
+//
+// Retrieve the per process narrow string converter.
+//
+ICE_UTIL_API StringConverterPtr getProcessStringConverter();
+
+//
+// Set the per process narrow string converter.
+//
+ICE_UTIL_API void setProcessStringConverter(const StringConverterPtr&);
+
+//
+// Retrieve the per process wide string converter.
+//
+ICE_UTIL_API WstringConverterPtr getProcessWstringConverter();
+
+//
+// Set the per process wide string converter.
+//
+ICE_UTIL_API void setProcessWstringConverter(const WstringConverterPtr&);
+
+
+//
+// Converts the given wide string to a narrow string
+//
+// If the StringConverter parameter is null, the result's narrow 
+// string encoding is UTF-8.  
+// If the WstringConverter parameter is null, the input's wstring 
+// encoding is UTF-16 or UTF-32 depending on the size of wchar_t.
+//
+ICE_UTIL_API std::string
+wstringToString(const std::wstring&, const StringConverterPtr& = 0, 
+                const WstringConverterPtr& = 0, ConversionFlags = lenientConversion);
+
+//
+// Converts the given narrow string to a wide string
+//
+// If the StringConverter parameter is null, the input's narrow string 
+// encoding is UTF-8.  
+// If the WstringConverter parameter is null, the result's wstring 
+// encoding is UTF-16 or UTF-32 depending on the size of wchar_t.
+//
+ICE_UTIL_API std::wstring
+stringToWstring(const std::string&, const StringConverterPtr& = 0, 
+                const WstringConverterPtr& = 0, ConversionFlags = lenientConversion);
+
+
+//
+// Converts the given string from the native narrow string encoding to
+// UTF-8 using the given converter. If the converter is null, returns
+// the given string.
+//
+ICE_UTIL_API std::string
+nativeToUTF8(const std::string&, const StringConverterPtr&);
+
+//
+// Converts the given string from UTF-8 to the native narrow string
+// encoding using the given converter. If the converter is null,
+// returns the given string.
+//
+ICE_UTIL_API std::string
+UTF8ToNative(const std::string&, const StringConverterPtr&);
+
+}
+
+#endif