zeroc-ice 3.6.5 → 3.7.4

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

@@ -1,11 +1,6 @@
-// **********************************************************************
 //
-// Copyright (c) 2003-2018 ZeroC, Inc. All rights reserved.
+// Copyright (c) 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/InputUtil.h>
 #include <stdlib.h>

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

@@ -1,11 +1,6 @@
-// **********************************************************************
 //
-// Copyright (c) 2003-2018 ZeroC, Inc. All rights reserved.
+// Copyright (c) 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/MutexProtocol.h>
 

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

@@ -1,11 +1,6 @@
-// **********************************************************************
 //
-// Copyright (c) 2003-2018 ZeroC, Inc. All rights reserved.
+// Copyright (c) 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/Options.h>
 #include <IceUtil/StringUtil.h>
@@ -16,20 +11,20 @@ using namespace std;
 using namespace IceUtil;
 
 IceUtilInternal::APIException::APIException(const char* file, int line, const string& r)
-    : IceUtil::Exception(file, line), reason(r)
+    : IceUtil::ExceptionHelper<APIException>(file, line), reason(r)
 {
 }
 
+#ifndef ICE_CPP11_COMPILER
 IceUtilInternal::APIException::~APIException() throw()
 {
 }
-
-const char* IceUtilInternal::APIException::_name = "IceUtilInternal::APIException";
+#endif
 
 string
-IceUtilInternal::APIException::ice_name() const
+IceUtilInternal::APIException::ice_id() const
 {
-    return _name;
+    return "::IceUtilInternal::APIException";
 }
 
 void
@@ -42,17 +37,13 @@ IceUtilInternal::APIException::ice_print(ostream& out) const
     }
 }
 
+#ifndef ICE_CPP11_MAPPING
 IceUtilInternal::APIException*
 IceUtilInternal::APIException::ice_clone() const
 {
     return new APIException(*this);
 }
-
-void
-IceUtilInternal::APIException::ice_throw() const
-{
-    throw *this;
-}
+#endif
 
 ostream&
 IceUtilInternal::operator<<(ostream& out, const IceUtilInternal::APIException& ex)
@@ -62,20 +53,20 @@ IceUtilInternal::operator<<(ostream& out, const IceUtilInternal::APIException& e
 }
 
 IceUtilInternal::BadOptException::BadOptException(const char* file, int line, const string& r)
-    : IceUtil::Exception(file, line), reason(r)
+    : IceUtil::ExceptionHelper<BadOptException>(file, line), reason(r)
 {
 }
 
+#ifndef ICE_CPP11_COMPILER
 IceUtilInternal::BadOptException::~BadOptException() throw()
 {
 }
-
-const char* IceUtilInternal::BadOptException::_name = "IceUtilInternal::BadOptException";
+#endif
 
 string
-IceUtilInternal::BadOptException::ice_name() const
+IceUtilInternal::BadOptException::ice_id() const
 {
-    return _name;
+    return "::IceUtilInternal::BadOptException";
 }
 
 void
@@ -88,17 +79,13 @@ IceUtilInternal::BadOptException::ice_print(ostream& out) const
     }
 }
 
+#ifndef ICE_CPP11_MAPPING
 IceUtilInternal::BadOptException*
 IceUtilInternal::BadOptException::ice_clone() const
 {
     return new BadOptException(*this);
 }
-
-void
-IceUtilInternal::BadOptException::ice_throw() const
-{
-    throw *this;
-}
+#endif
 
 ostream&
 IceUtilInternal::operator<<(ostream& out, const IceUtilInternal::BadOptException& ex)
@@ -174,7 +161,7 @@ void
 IceUtilInternal::Options::addOpt(const string& shortOpt, const string& longOpt, ArgType at, string dflt, RepeatType rt)
 {
     RecMutex::Lock sync(_m);
-    
+
     if(parseCalled)
     {
         throw APIException(__FILE__, __LINE__, "cannot add options after parse() was called");
@@ -444,7 +431,7 @@ IceUtilInternal::Options::split(const string& line)
                                     j < i + 3 && j < l.size() && octalDigits.find_first_of(c = l[j]) != string::npos;
                                     ++j)
                                 {
-                                    us = us * 8 + c - '0';
+                                    us = us * 8 + static_cast<unsigned short>(c - '0');
                                 }
                                 i = j - 1;
                                 arg.push_back(static_cast<char>(us));
@@ -465,7 +452,7 @@ IceUtilInternal::Options::split(const string& line)
 
                                 Int64 ull = 0;
                                 string::size_type j;
-                                for(j = i + 1; j < i + 3 && j < l.size() && 
+                                for(j = i + 1; j < i + 3 && j < l.size() &&
                                     isxdigit(static_cast<unsigned char>(c = l[j])); ++j)
                                 {
                                     ull *= 16;
@@ -542,7 +529,7 @@ IceUtilInternal::Options::split(const string& line)
             }
             default:
             {
-                assert(!"Impossible parse state");
+                assert(false); // Impossible parse state
                 break;
             }
         }
@@ -572,7 +559,7 @@ IceUtilInternal::Options::split(const string& line)
         }
         default:
         {
-            assert(!"Impossible parse state");
+            assert(false); // Impossible parse state
             break;
         }
     }

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

@@ -1,11 +1,6 @@
-// **********************************************************************
 //
-// Copyright (c) 2003-2018 ZeroC, Inc. All rights reserved.
+// Copyright (c) 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/OutputUtil.h>
 #include <IceUtil/FileUtil.h>
@@ -23,6 +18,8 @@ StartBlock sb;
 EndBlock eb;
 StartPar spar;
 EndPar epar;
+StartAbrk sabrk;
+EndAbrk eabrk;
 Separator sp;
 EndElement ee;
 StartEscapes startEscapes;
@@ -69,7 +66,6 @@ IceUtilInternal::OutputBase::OutputBase(ostream& os) :
 {
 }
 
-
 IceUtilInternal::OutputBase::OutputBase(const string& s) :
     _out(_fout),
     _pos(0),
@@ -239,33 +235,43 @@ IceUtilInternal::OutputBase::operator!() const
 // Output
 // ----------------------------------------------------------------------
 
-IceUtilInternal::Output::Output() :
+IceUtilInternal::Output::Output(bool breakBeforeBlock, bool shortEmptyBlock) :
     OutputBase(),
     _blockStart("{"),
     _blockEnd("}"),
-    _par(-1)
+    _par(-1),
+    _breakBeforeBlock(breakBeforeBlock),
+    _shortEmptyBlock(shortEmptyBlock),
+    _emptyBlock(false)
 {
 }
 
-IceUtilInternal::Output::Output(ostream& os) :
+IceUtilInternal::Output::Output(ostream& os, bool breakBeforeBlock, bool shortEmptyBlock) :
     OutputBase(os),
     _blockStart("{"),
     _blockEnd("}"),
-    _par(-1)
+    _par(-1),
+    _breakBeforeBlock(breakBeforeBlock),
+    _shortEmptyBlock(shortEmptyBlock),
+    _emptyBlock(false)
 {
 }
 
-IceUtilInternal::Output::Output(const char* s) :
+IceUtilInternal::Output::Output(const char* s, bool breakBeforeBlock, bool shortEmptyBlock) :
     OutputBase(s),
     _blockStart("{"),
     _blockEnd("}"),
-    _par(-1)
+    _par(-1),
+    _breakBeforeBlock(breakBeforeBlock),
+    _shortEmptyBlock(shortEmptyBlock),
+    _emptyBlock(false)
 {
 }
 
 void
 IceUtilInternal::Output::print(const string& s)
 {
+    _emptyBlock = false;
     if(_par >= 0)
     {
         if(++_par > 1) // No comma for the first parameter.
@@ -281,38 +287,58 @@ IceUtilInternal::Output::sb()
 {
     if(_blockStart.length())
     {
-        newline();
+        if(_breakBeforeBlock)
+        {
+            newline();
+        }
+        else
+        {
+            _out << ' ';
+        }
         _out << _blockStart;
     }
     ++_pos;
     inc();
     _separator = false;
+    _emptyBlock = true;
 }
 
 void
 IceUtilInternal::Output::eb()
 {
     dec();
-    if(_blockEnd.length())
+    if(_emptyBlock && _shortEmptyBlock)
     {
-        newline();
-        _out << _blockEnd;
+        if(_blockEnd.length())
+        {
+            _separator = true;
+            _out << _blockEnd;
+        }
+    }
+    else
+    {
+        if(_blockEnd.length())
+        {
+            newline();
+            _out << _blockEnd;
+        }
     }
     --_pos;
 }
 
 void
-IceUtilInternal::Output::spar()
+IceUtilInternal::Output::spar(char c)
 {
-    _out << '(';
+    _emptyBlock = false;
+    _out << c;
     _par = 0;
 }
 
 void
-IceUtilInternal::Output::epar()
+IceUtilInternal::Output::epar(char c)
 {
     _par = -1;
-    _out << ')';
+    _out << c;
 }
 
 Output&

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

@@ -1,11 +1,6 @@
-// **********************************************************************
 //
-// Copyright (c) 2003-2018 ZeroC, Inc. All rights reserved.
+// Copyright (c) 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 _WIN32
 #  define _CRT_RAND_S
@@ -38,13 +33,13 @@ namespace
 // platforms is usually a port from Linux, this problem could be
 // widespread. Therefore, we serialize access to /dev/urandom using a
 // static mutex.
-// 
+//
 Mutex* staticMutex = 0;
 int fd = -1;
 
 //
-// Callback to use with pthread_atfork to reset the "/dev/urandom"  
-// fd state. We don't need to close the fd here as that is done 
+// Callback to use with pthread_atfork to reset the "/dev/urandom"
+// fd state. We don't need to close the fd here as that is done
 // during static destruction.
 //
 extern "C"
@@ -69,12 +64,12 @@ public:
         staticMutex = new IceUtil::Mutex;
 
         //
-        // Register a callback to reset the "/dev/urandom" fd 
+        // Register a callback to reset the "/dev/urandom" fd
         // state after fork.
         //
         pthread_atfork(0, 0, &childAtFork);
     }
-    
+
     ~Init()
     {
         if(fd != -1)
@@ -98,7 +93,7 @@ IceUtilInternal::generateRandom(char* buffer, size_t size)
 #ifdef _WIN32
     int i = 0;
     const size_t randSize = sizeof(unsigned int);
-    
+
     while(size - i >= randSize)
     {
         unsigned int r = 0;
@@ -107,7 +102,7 @@ IceUtilInternal::generateRandom(char* buffer, size_t size)
         {
             throw SyscallException(__FILE__, __LINE__, errno);
         }
-        memcpy(buffer + i, &r, randSize);   
+        memcpy(buffer + i, &r, randSize);
         i += randSize;
     }
 
@@ -120,7 +115,7 @@ IceUtilInternal::generateRandom(char* buffer, size_t size)
         {
             throw SyscallException(__FILE__, __LINE__, errno);
         }
-        memcpy(buffer + i, &r, size - i);   
+        memcpy(buffer + i, &r, size - i);
     }
 #else
     //
@@ -135,28 +130,28 @@ IceUtilInternal::generateRandom(char* buffer, size_t size)
             throw SyscallException(__FILE__, __LINE__, errno);
         }
     }
-    
+
     //
     // Limit the number of attempts to 20 reads to avoid
     // a potential "for ever" loop
     //
     int reads = 0;
-    size_t index = 0;    
+    size_t index = 0;
     while(reads <= 20 && index != size)
     {
         ssize_t bytesRead = read(fd, buffer + index, size - index);
-        
+
         if(bytesRead == -1 && errno != EINTR)
         {
             throw SyscallException(__FILE__, __LINE__, errno);
         }
         else
         {
-            index += bytesRead;
+            index += static_cast<size_t>(bytesRead);
             reads++;
         }
     }
-        
+
     if(index != size)
     {
         throw SyscallException(__FILE__, __LINE__, 0);
@@ -179,7 +174,7 @@ IceUtilInternal::random(int limit)
 #endif
     if(limit > 0)
     {
-        r = r % limit;
+        r = r % static_cast<unsigned int>(limit);
     }
     return r;
 }

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

@@ -1,21 +1,10 @@
-// **********************************************************************
 //
-// Copyright (c) 2003-2018 ZeroC, Inc. All rights reserved.
+// Copyright (c) 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/RecMutex.h>
 #include <IceUtil/Exception.h>
 
-//
-// AbstractMutex isn't used anywhere in IceUtil, we include it here
-// to give the compiler a chance to export the class symbols.
-//
-#include <IceUtil/AbstractMutex.h>
-
 using namespace std;
 
 IceUtil::RecMutex::RecMutex() :
@@ -39,7 +28,7 @@ IceUtil::RecMutex::RecMutex(const IceUtil::MutexProtocol protocol) :
 void
 IceUtil::RecMutex::init(const MutexProtocol)
 {
-#   ifdef ICE_OS_WINRT
+#   ifdef ICE_OS_UWP
     InitializeCriticalSectionEx(&_mutex, 0, 0);
 #   else
     InitializeCriticalSection(&_mutex);
@@ -119,7 +108,7 @@ IceUtil::RecMutex::lock(LockState& state) const
 #else
 
 void
-IceUtil::RecMutex::init(const MutexProtocol protocol)
+IceUtil::RecMutex::init(ICE_MAYBE_UNUSED const MutexProtocol protocol)
 {
     int rc;
     pthread_mutexattr_t attr;
@@ -131,11 +120,7 @@ IceUtil::RecMutex::init(const MutexProtocol protocol)
         throw ThreadSyscallException(__FILE__, __LINE__, rc);
     }
 
-#if defined(__linux) && !defined(__USE_UNIX98)
-    rc = pthread_mutexattr_settype(&attr, PTHREAD_MUTEX_RECURSIVE_NP);
-#else
     rc = pthread_mutexattr_settype(&attr, PTHREAD_MUTEX_RECURSIVE);
-#endif
     assert(rc == 0);
     if(rc != 0)
     {
@@ -208,7 +193,7 @@ IceUtil::RecMutex::tryLock() const
         {
             throw ThreadSyscallException(__FILE__, __LINE__, rc);
         }
-    } 
+    }
     else if(++_count > 1)
     {
         rc = pthread_mutex_unlock(&_mutex);