zeroc-ice 3.7.2 → 3.7.3

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

@@ -144,7 +144,7 @@ IceUtil::Time::now(Clock clock)
         }
         return Time(tv.tv_sec * ICE_INT64(1000000) + tv.tv_usec);
 #elif defined(__APPLE__)
-       return Time(mach_absolute_time() * machMultiplier);
+        return Time(static_cast<IceUtil::Int64>(mach_absolute_time() * machMultiplier));
 #else
         struct timespec ts;
         if(clock_gettime(CLOCK_MONOTONIC, &ts) < 0)
@@ -197,8 +197,8 @@ IceUtil::Time::microSecondsDouble(double t)
 IceUtil::Time::operator timeval() const
 {
     timeval tv;
-    tv.tv_sec = static_cast<long>(_usec / 1000000);
-    tv.tv_usec = static_cast<long>(_usec % 1000000);
+    tv.tv_sec = static_cast<time_t>(_usec / 1000000);
+    tv.tv_usec = static_cast<suseconds_t>(_usec % 1000000);
     return tv;
 }
 #endif

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

@@ -47,7 +47,7 @@ public:
         int p = GetCurrentProcessId();
 #endif
         myPid[0] = (p >> 8) & 0x7F;
-        myPid[1] = p & 0xFF;
+        myPid[1] = static_cast<char>(p & 0xFF);
     }
 };
 
@@ -65,11 +65,11 @@ inline void halfByteToHex(unsigned char hb, char*& hexBuffer)
 {
     if(hb < 10)
     {
-        *hexBuffer++ = '0' + hb;
+        *hexBuffer++ = '0' + static_cast<char>(hb);
     }
     else
     {
-        *hexBuffer++ = 'A' + (hb - 10);
+        *hexBuffer++ = 'A' + static_cast<char>(hb - 10);
     }
 }
 
@@ -143,8 +143,8 @@ IceUtil::generateUUID()
     //
     // Replace the end of the node by myPid (15 bits)
     //
-    uuid.node[4] = (uuid.node[4] & 0x80) | myPid[0];
-    uuid.node[5] = myPid[1];
+    uuid.node[4] = (uuid.node[4] & 0x80) | static_cast<unsigned char>(myPid[0]);
+    uuid.node[5] = static_cast<unsigned char>(myPid[1]);
 
     //
     // Convert to a UUID string

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

@@ -43,7 +43,7 @@
 #       endif
 #   endif
 
-#   if !defined(__sun) && !defined(__FreeBSD__) && !defined(__MINGW32__) && !defined(ICE_STATIC_LIBS)
+#   if !defined(_AIX) && !defined(__sun) && !defined(__FreeBSD__) && !defined(__MINGW32__) && !defined(ICE_STATIC_LIBS)
 #       include <execinfo.h>
 #       include <cxxabi.h>
 #       include <stdint.h>
@@ -350,8 +350,8 @@ getStackFrames()
 #elif defined(ICE_BACKTRACE)
 
     stackFrames.resize(100);
-    size_t stackDepth = backtrace(&stackFrames.front(), stackFrames.size());
-    stackFrames.resize(stackDepth);
+    int stackDepth = backtrace(&stackFrames.front(), static_cast<int>(stackFrames.size()));
+    stackFrames.resize(static_cast<size_t>(stackDepth));
     if(!stackFrames.empty())
     {
         stackFrames.erase(stackFrames.begin()); // drop the first frame
@@ -468,7 +468,7 @@ getStackTrace(const vector<void*>& stackFrames)
     // Initialize backtraceStrings immediately
     if(p != stackFrames.end())
     {
-        backtraceStrings = backtrace_symbols(&*p, stackFrames.size());
+        backtraceStrings = backtrace_symbols(&*p, static_cast<int>(stackFrames.size()));
     }
 #   endif
 

data/ext/ice/cpp/src/Slice/CPlusPlusUtil.cpp

@@ -527,7 +527,7 @@ Slice::printVersionCheck(Output& out)
     out << "\n";
     out << "\n#ifndef ICE_IGNORE_VERSION";
     int iceVersion = ICE_INT_VERSION; // Use this to prevent warning with C++Builder
-    if(iceVersion % 100 > 50)
+    if(iceVersion % 100 >= 50)
     {
         //
         // Beta version: exact match required
@@ -545,7 +545,7 @@ Slice::printVersionCheck(Output& out)
         //
         // Generated code is release; reject beta header
         //
-        out << "\n#   if ICE_INT_VERSION % 100 > 50";
+        out << "\n#   if ICE_INT_VERSION % 100 >= 50";
         out << "\n#       error Beta header file detected";
         out << "\n#   endif";
 
@@ -752,13 +752,13 @@ Slice::typeToString(const TypePtr& type, const string& scope, const StringList&
             // Non local classes without operations map to the base
             // proxy class shared_ptr<Ice::ObjectPrx>
             //
-            if(def && !def->isInterface() && def->allOperations().empty())
+            if(!def || def->isAbstract())
             {
-                return getUnqualified(cpp11BuiltinTable[Builtin::KindObjectProxy], scope);
+                return "::std::shared_ptr<" + getUnqualified(fixKwd(proxy->_class()->scoped() + "Prx"), scope) + ">";
             }
             else
             {
-                return "::std::shared_ptr<" + getUnqualified(fixKwd(proxy->_class()->scoped() + "Prx"), scope) + ">";
+                return getUnqualified(cpp11BuiltinTable[Builtin::KindObjectProxy], scope);
             }
         }
         else
@@ -1496,7 +1496,7 @@ Slice::writeStreamHelpers(Output& out,
                           bool cpp11)
 {
     // If c is a C++11 class/exception whose base class contains data members (recursively), then we need to generate
-    // an StreamWriter even if its implementation is empty. This is becuase our default marsaling uses ice_tuple() which
+    // a StreamWriter even if its implementation is empty. This is because our default marshaling uses ice_tuple() which
     // contains all of our class/exception's data members as well the base data members, which breaks marshaling. This
     // is not an issue for structs.
     if(dataMembers.empty() && !(cpp11 && hasBaseDataMembers))
@@ -1580,7 +1580,7 @@ Slice::writeStreamHelpers(Output& out,
     }
 
     //
-    // Generate StreamWriter
+    // Generate StreamReader
     //
     out << nl << "template<typename S>";
     out << nl << "struct StreamReader" << (cpp11 ? "<" : "< ") << fullName << ", S>";
@@ -1619,9 +1619,13 @@ Slice::writeStreamHelpers(Output& out,
 }
 
 void
-Slice::writeIceTuple(::IceUtilInternal::Output& out, const string& scope, DataMemberList dataMembers, int typeCtx)
+Slice::writeIceTuple(::IceUtilInternal::Output& out, DataMemberList dataMembers, int typeCtx)
 {
-    out << sp << nl << "std::tuple<";
+    //
+    // Use an empty scope to get full qualified names from calls to typeToString.
+    //
+    const string scope = "";
+    out << nl << "std::tuple<";
     for(DataMemberList::const_iterator q = dataMembers.begin(); q != dataMembers.end(); ++q)
     {
         if(q != dataMembers.begin())

data/ext/ice/cpp/src/Slice/CPlusPlusUtil.h

@@ -59,7 +59,7 @@ void writeEndCode(::IceUtilInternal::Output&, const ParamDeclList&, const Operat
 void writeMarshalUnmarshalDataMemberInHolder(IceUtilInternal::Output&, const std::string&, const DataMemberPtr&, bool);
 void writeMarshalUnmarshalAllInHolder(IceUtilInternal::Output&, const std::string&, const DataMemberList&, bool, bool);
 void writeStreamHelpers(::IceUtilInternal::Output&, const ContainedPtr&, DataMemberList, bool, bool, bool);
-void writeIceTuple(::IceUtilInternal::Output&, const std::string&, DataMemberList, int);
+void writeIceTuple(::IceUtilInternal::Output&, DataMemberList, int);
 
 bool findMetaData(const std::string&, const ClassDeclPtr&, std::string&);
 bool findMetaData(const std::string&, const StringList&, std::string&);

data/ext/ice/cpp/src/Slice/Grammar.cpp

@@ -98,6 +98,14 @@
 #  pragma GCC diagnostic ignored "-Wold-style-cast"
 #endif
 
+//
+// Avoid clang conversion warnings
+//
+#if defined(__clang__)
+#   pragma clang diagnostic ignored "-Wconversion"
+#   pragma clang diagnostic ignored "-Wsign-conversion"
+#endif
+
 using namespace std;
 using namespace Slice;
 

data/ext/ice/cpp/src/Slice/JavaUtil.cpp

@@ -3764,8 +3764,7 @@ Slice::JavaGenerator::typeToString(const TypePtr& type,
     if(proxy)
     {
         ClassDefPtr def = proxy->_class()->definition();
-        assert(def);
-        if(def->isAbstract())
+        if(!def || def->isAbstract())
         {
             return getUnqualified(proxy->_class(), package, "", "Prx");
         }

data/ext/ice/cpp/src/Slice/MD5I.cpp

@@ -58,6 +58,14 @@
 #  pragma GCC diagnostic ignored "-Wold-style-cast"
 #endif
 
+//
+// Avoid clang conversion warnings
+//
+#if defined(__clang__)
+#   pragma clang diagnostic ignored "-Wconversion"
+#   pragma clang diagnostic ignored "-Wsign-conversion"
+#endif
+
 #undef BYTE_ORDER       /* 1 = big-endian, -1 = little-endian, 0 = unknown */
 #ifdef ARCH_IS_BIG_ENDIAN
 #  define BYTE_ORDER (ARCH_IS_BIG_ENDIAN ? 1 : -1)

data/ext/ice/cpp/src/Slice/Parser.cpp

@@ -19,6 +19,51 @@
 using namespace std;
 using namespace Slice;
 
+Slice::CompilerException::CompilerException(const char* file, int line, const string& r) :
+    IceUtil::Exception(file, line),
+    _reason(r)
+{
+}
+
+#ifndef ICE_CPP11_COMPILER
+Slice::CompilerException::~CompilerException() throw()
+{
+}
+#endif
+
+string
+Slice::CompilerException::ice_id() const
+{
+    return "::Slice::CompilerException";
+}
+
+void
+Slice::CompilerException::ice_print(ostream& out) const
+{
+    IceUtil::Exception::ice_print(out);
+    out << ": " << _reason;
+}
+
+#ifndef ICE_CPP11_MAPPING
+Slice::CompilerException*
+Slice::CompilerException::ice_clone() const
+{
+    return new CompilerException(*this);
+}
+#endif
+
+void
+Slice::CompilerException::ice_throw() const
+{
+    throw *this;
+}
+
+string
+Slice::CompilerException::reason() const
+{
+    return _reason;
+}
+
 extern FILE* slice_in;
 extern int slice_debug;
 
@@ -227,6 +272,20 @@ Slice::DefinitionContext::warning(WarningCategory category, const string& file,
     }
 }
 
+void
+Slice::DefinitionContext::error(const string& file, int line, const string& msg) const
+{
+    emitError(file, line, msg);
+    throw CompilerException(__FILE__, __LINE__, msg);
+}
+
+void
+Slice::DefinitionContext::error(const string& file, const string& line, const string& msg) const
+{
+    emitError(file, line, msg);
+    throw CompilerException(__FILE__, __LINE__, msg);
+}
+
 bool
 Slice::DefinitionContext::suppressWarning(WarningCategory category) const
 {
@@ -4298,6 +4357,7 @@ Slice::ClassDef::isDelegate() const
 {
     return isLocal() && isInterface() && hasMetaData("delegate") && allOperations().size() == 1;
 }
+
 Slice::ClassDef::ClassDef(const ContainerPtr& container, const string& name, int id, bool intf, const ClassList& bases,
                           bool local) :
     SyntaxTreeBase(container->unit()),
@@ -6835,11 +6895,6 @@ Slice::Unit::parse(const string& filename, FILE* file, bool debug)
         popContainer();
         assert(_definitionContextStack.size() == 1);
         popDefinitionContext();
-
-        if(!checkUndefinedTypes())
-        {
-            status = EXIT_FAILURE;
-        }
     }
 
     Slice::unit = 0;
@@ -6938,113 +6993,6 @@ Slice::Unit::eraseWhiteSpace(string& s)
     }
 }
 
-bool
-Slice::Unit::checkUndefinedTypes()
-{
-    class Visitor : public ParserVisitor
-    {
-    public:
-
-        Visitor(int& errors) :
-            _errors(errors),
-            _local(false)
-        {
-        }
-
-        virtual bool visitClassDefStart(const ClassDefPtr& p)
-        {
-            _local = p->isLocal();
-            return true;
-        }
-
-        virtual bool visitExceptionStart(const ExceptionPtr& p)
-        {
-            _local = p->isLocal();
-            return true;
-        }
-
-        virtual bool visitStructStart(const StructPtr& p)
-        {
-            _local = p->isLocal();
-            return true;
-        }
-
-        virtual void visitOperation(const OperationPtr& p)
-        {
-            if(p->returnType())
-            {
-                checkUndefined(p->returnType(), "return type", p->file(), p->line());
-            }
-            ParamDeclList params = p->parameters();
-            for(ParamDeclList::const_iterator q = params.begin(); q != params.end(); ++q)
-            {
-                checkUndefined((*q)->type(), "parameter " + (*q)->name(), (*q)->file(), (*q)->line());
-            }
-        }
-
-        virtual void visitParamDecl(const ParamDeclPtr& p)
-        {
-            checkUndefined(p->type(), "parameter " + p->name(), p->file(), p->line());
-        }
-
-        virtual void visitDataMember(const DataMemberPtr& p)
-        {
-            checkUndefined(p->type(), "member " + p->name(), p->file(), p->line());
-        }
-
-        virtual void visitSequence(const SequencePtr& p)
-        {
-            _local = p->isLocal();
-            checkUndefined(p->type(), "element type", p->file(), p->line());
-        }
-
-        virtual void visitDictionary(const DictionaryPtr& p)
-        {
-            _local = p->isLocal();
-            checkUndefined(p->keyType(), "key type", p->file(), p->line());
-            checkUndefined(p->valueType(), "value type", p->file(), p->line());
-        }
-
-    private:
-
-        void checkUndefined(const TypePtr& type, const string& desc, const string& file, const string& line)
-        {
-            //
-            // See ICE-6867. Any use of a proxy requires the full type definition, as does any
-            // use of a class in a non-local context.
-            //
-            ProxyPtr p = ProxyPtr::dynamicCast(type);
-            if(p)
-            {
-                const ClassDeclPtr cl = p->_class();
-                if(!cl->definition())
-                {
-                    ostringstream ostr;
-                    ostr << desc << " uses a proxy for undefined type `" << cl->scoped() << "'";
-                    emitError(file, line, ostr.str());
-                    _errors++;
-                }
-            }
-
-            ClassDeclPtr cl = ClassDeclPtr::dynamicCast(type);
-            if(cl && !cl->definition() && !_local)
-            {
-                ostringstream ostr;
-                ostr << desc << " refers to undefined type `" << cl->scoped() << "'";
-                emitError(file, line, ostr.str());
-                _errors++;
-            }
-        }
-
-        int& _errors;
-        bool _local;
-    };
-
-    Visitor v(_errors);
-    visit(&v, true);
-    return _errors == 0;
-}
-
 // ----------------------------------------------------------------------
 // CICompare
 // ----------------------------------------------------------------------

data/ext/ice/cpp/src/Slice/Parser.h

@@ -7,6 +7,7 @@
 
 #include <IceUtil/Shared.h>
 #include <IceUtil/Handle.h>
+#include <IceUtil/Exception.h>
 #include <string>
 #include <vector>
 #include <list>
@@ -18,6 +19,29 @@
 namespace Slice
 {
 
+class CompilerException : public ::IceUtil::Exception
+{
+public:
+
+    CompilerException(const char*, int, const std::string&);
+#ifndef ICE_CPP11_COMPILER
+    ~CompilerException() throw();
+#endif
+    virtual std::string ice_id() const;
+    virtual void ice_print(std::ostream&) const;
+#ifndef ICE_CPP11_MAPPING
+    virtual CompilerException* ice_clone() const;
+#endif
+    virtual void ice_throw() const;
+
+    std::string reason() const;
+
+private:
+
+    static const char* _name;
+    const std::string _reason;
+};
+
 #if defined(_WIN32) && !defined(__MINGW32__)
 
 const IceUtil::Int64 Int32Max =  0x7fffffffi64;
@@ -241,6 +265,9 @@ public:
     void warning(WarningCategory, const std::string&, int, const std::string&) const;
     void warning(WarningCategory, const std::string&, const std::string&, const std::string&) const;
 
+    void error(const std::string&, int, const std::string&) const;
+    void error(const std::string&, const std::string&, const std::string&) const;
+
 private:
 
     bool suppressWarning(WarningCategory) const;
@@ -1118,7 +1145,6 @@ private:
 
     Unit(bool, bool, bool, bool, const StringList&);
     static void eraseWhiteSpace(::std::string&);
-    bool checkUndefinedTypes();
 
     bool _ignRedefs;
     bool _all;