zeroc-ice 3.6.5 → 3.7.0

data/ext/ice/cpp/{include → src}/Slice/JavaUtil.h

@@ -1,6 +1,6 @@
 // **********************************************************************
 //
-// Copyright (c) 2003-2018 ZeroC, Inc. All rights reserved.
+// Copyright (c) 2003-2017 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.
@@ -19,22 +19,22 @@ namespace Slice
 //
 // Compute Java serialVersionUID for a Slice class
 //
-SLICE_API long
+long
 computeSerialVersionUUID(const ClassDefPtr&);
 
 //
 // Compute Java serialVersionUID for a Slice class
 //
-SLICE_API long
+long
 computeSerialVersionUUID(const ExceptionPtr&);
 
 //
 // Compute Java serialVersionUID for a Slice struct
 //
-SLICE_API long
+long
 computeSerialVersionUUID(const StructPtr&);
 
-class SLICE_API JavaOutput : public ::IceUtilInternal::Output
+class JavaOutput : public ::IceUtilInternal::Output
 {
 public:
 
@@ -59,11 +59,11 @@ public:
     virtual void printHeader();
 };
 
-class SLICE_API JavaGenerator : private ::IceUtil::noncopyable
+class JavaCompatGenerator : private ::IceUtil::noncopyable
 {
 public:
 
-    virtual ~JavaGenerator();
+    virtual ~JavaCompatGenerator();
 
     //
     // Validate all metadata in the unit with a "java:" prefix.
@@ -74,7 +74,7 @@ public:
 
 protected:
 
-    JavaGenerator(const std::string&);
+    JavaCompatGenerator(const std::string&);
 
     //
     // Given the fully-scoped Java class name, create any intermediate
@@ -97,7 +97,6 @@ protected:
                                   const std::string& = std::string(),
                                   const std::string& = std::string()) const;
 
-
     //
     // Returns the package prefix for a give Slice file.
     //
@@ -145,7 +144,7 @@ protected:
         TypeModeReturn
     };
     std::string typeToString(const TypePtr&, TypeMode, const std::string& = std::string(),
-                             const StringList& = StringList(), bool = true, bool = false) const;
+                             const StringList& = StringList(), bool = true, bool = false, bool = false) const;
 
     //
     // Get the Java object name for a type. For primitive types, this returns the
@@ -168,42 +167,191 @@ protected:
     };
 
     void writeMarshalUnmarshalCode(::IceUtilInternal::Output&, const std::string&, const TypePtr&, OptionalMode,
-                                   bool, int, const std::string&, bool, int&, bool = false,
-                                   const StringList& = StringList(), const std::string& patchParams = "");
+                                   bool, int, const std::string&, bool, int&, bool = false, const std::string& = "",
+                                   const StringList& = StringList(), const std::string& = "");
 
     //
     // Generate code to marshal or unmarshal a dictionary type.
     //
     void writeDictionaryMarshalUnmarshalCode(::IceUtilInternal::Output&, const std::string&, const DictionaryPtr&,
-                                           const std::string&, bool, int&, bool,
-                                           const StringList& = StringList());
+                                             const std::string&, bool, int&, bool,
+                                             const std::string& = "", const StringList& = StringList());
 
     //
     // Generate code to marshal or unmarshal a sequence type.
     //
     void writeSequenceMarshalUnmarshalCode(::IceUtilInternal::Output&, const std::string&, const SequencePtr&,
-                                           const std::string&, bool, int&, bool, const StringList& = StringList());
+                                           const std::string&, bool, int&, bool,
+                                           const std::string& = "", const StringList& = StringList());
+
+    //
+    // Search metadata for an entry with the given prefix and return the entire string.
+    //
+    static bool findMetaData(const std::string&, const StringList&, std::string&);
+
+    //
+    // Get custom type metadata. If metadata is found, the abstract and
+    // concrete types are extracted and the function returns true. If an
+    // abstract type is not specified, it is set to an empty string.
+    //
+    static bool getTypeMetaData(const StringList&, std::string&, std::string&);
+
+    //
+    // Determine whether a custom type is defined. The function checks the
+    // metadata of the type's original definition, as well as any optional
+    // metadata that typically represents a data member or parameter.
+    //
+    static bool hasTypeMetaData(const TypePtr&, const StringList& = StringList());
+
+    //
+    // Obtain the concrete and abstract types for a dictionary or sequence type.
+    // The functions return true if a custom type was defined and false to indicate
+    // the default mapping was used.
+    //
+    bool getDictionaryTypes(const DictionaryPtr&, const std::string&, const StringList&,
+                            std::string&, std::string&) const;
+    bool getSequenceTypes(const SequencePtr&, const std::string&, const StringList&, std::string&, std::string&) const;
+
+    bool sequenceHasHolder(const SequencePtr&) const;
+
+    virtual JavaOutput* createOutput();
+
+    static const std::string _getSetMetaData;
+
+private:
+
+    std::string _dir;
+    ::IceUtilInternal::Output* _out;
+    mutable std::map<std::string, std::string> _filePackagePrefix;
+};
+
+class JavaGenerator : private ::IceUtil::noncopyable
+{
+public:
+
+    virtual ~JavaGenerator();
 
     //
-    // Generate code to marshal or unmarshal a type using the public stream API.
+    // Validate all metadata in the unit with a "java:" prefix.
     //
-    void writeStreamMarshalUnmarshalCode(::IceUtilInternal::Output&, const std::string&, const TypePtr&, bool, int,
-                                          const std::string&, bool, int&, bool = false,
-                                         const StringList& = StringList(), const std::string& patchParams = "");
+    static void validateMetaData(const UnitPtr&);
+
+    void close();
+
+protected:
+
+    JavaGenerator(const std::string&);
 
     //
-    // Generate code to marshal or unmarshal a dictionary type using the public stream API.
+    // Given the fully-scoped Java class name, create any intermediate
+    // package directories and open the class file,
     //
-    void writeStreamDictionaryMarshalUnmarshalCode(::IceUtilInternal::Output&, const std::string&, const DictionaryPtr&,
-                                                   const std::string&, bool, int&, bool,
-                                                   const StringList& = StringList());
+    void open(const std::string&, const std::string&);
 
+    ::IceUtilInternal::Output& output() const;
+
+    //
+    // Check a symbol against any of the Java keywords. If a
+    // match is found, return the symbol with a leading underscore.
+    //
+    std::string fixKwd(const std::string&) const;
+
+    //
+    // Convert a Slice scoped name into a Java name.
     //
-    // Generate code to marshal or unmarshal a sequence type using the public stream API.
+    std::string convertScopedName(const std::string&,
+                                  const std::string& = std::string(),
+                                  const std::string& = std::string()) const;
+
+    //
+    // Returns the package prefix for a give Slice file.
     //
-    void writeStreamSequenceMarshalUnmarshalCode(::IceUtilInternal::Output&, const std::string&, const SequencePtr&,
-                                                 const std::string&, bool, int&, bool,
-                                                 const StringList& = StringList());
+    std::string getPackagePrefix(const ContainedPtr&) const;
+
+    //
+    // Returns the Java package of a Contained entity.
+    //
+    std::string getPackage(const ContainedPtr&) const;
+
+    //
+    // Returns the Java name for a Contained entity. If the optional
+    // package argument matches the entity's package name, then the
+    // package is removed from the result.
+    //
+    std::string getAbsolute(const ContainedPtr&,
+                            const std::string& = std::string(),
+                            const std::string& = std::string(),
+                            const std::string& = std::string()) const;
+
+    //
+    // Return the method call necessary to obtain the static type ID for an object type.
+    //
+    std::string getStaticId(const TypePtr&, const std::string&) const;
+
+    //
+    // Determines whether an operation should use the optional mapping.
+    //
+    bool useOptionalMapping(const OperationPtr&);
+
+    //
+    // Returns the optional type corresponding to the given Slice type.
+    //
+    std::string getOptionalFormat(const TypePtr&);
+
+    //
+    // Get the Java name for a type. If an optional scope is provided,
+    // the scope will be removed from the result if possible.
+    //
+    enum TypeMode
+    {
+        TypeModeIn,
+        TypeModeOut,
+        TypeModeMember,
+        TypeModeReturn
+    };
+    std::string typeToString(const TypePtr&, TypeMode, const std::string& = std::string(),
+                             const StringList& = StringList(), bool = true, bool = false, bool = false) const;
+
+    //
+    // Get the Java object name for a type. For primitive types, this returns the
+    // Java class type (e.g., Integer). For all other types, this function delegates
+    // to typeToString.
+    //
+    std::string typeToObjectString(const TypePtr&, TypeMode, const std::string& = std::string(),
+                                   const StringList& = StringList(), bool = true, bool = false) const;
+
+    //
+    // Generate code to marshal or unmarshal a type.
+    //
+    enum OptionalMode
+    {
+        OptionalNone,
+        OptionalInParam,
+        OptionalOutParam,
+        OptionalReturnParam,
+        OptionalMember
+    };
+
+    std::string getWriteFunction(const std::string&, const TypePtr&);
+    std::string getReadFunction(const std::string&, const TypePtr&);
+
+    void writeMarshalUnmarshalCode(::IceUtilInternal::Output&, const std::string&, const TypePtr&, OptionalMode,
+                                   bool, int, const std::string&, bool, int&, const std::string& = "",
+                                   const StringList& = StringList(), const std::string& = "");
+
+    //
+    // Generate code to marshal or unmarshal a dictionary type.
+    //
+    void writeDictionaryMarshalUnmarshalCode(::IceUtilInternal::Output&, const std::string&, const DictionaryPtr&,
+                                             const std::string&, bool, int&, bool,
+                                             const std::string& = "", const StringList& = StringList());
+
+    //
+    // Generate code to marshal or unmarshal a sequence type.
+    //
+    void writeSequenceMarshalUnmarshalCode(::IceUtilInternal::Output&, const std::string&, const SequencePtr&,
+                                           const std::string&, bool, int&, bool,
+                                           const std::string& = "", const StringList& = StringList());
 
     //
     // Search metadata for an entry with the given prefix and return the entire string.
@@ -230,10 +378,9 @@ protected:
     // the default mapping was used.
     //
     bool getDictionaryTypes(const DictionaryPtr&, const std::string&, const StringList&,
-                            std::string&, std::string&) const;
-    bool getSequenceTypes(const SequencePtr&, const std::string&, const StringList&, std::string&, std::string&) const;
-
-    bool sequenceHasHolder(const SequencePtr&) const;
+                            std::string&, std::string&, bool) const;
+    bool getSequenceTypes(const SequencePtr&, const std::string&, const StringList&, std::string&, std::string&,
+                          bool) const;
 
     virtual JavaOutput* createOutput();
 
@@ -241,34 +388,6 @@ protected:
 
 private:
 
-    class MetaDataVisitor : public ParserVisitor
-    {
-    public:
-
-        virtual bool visitUnitStart(const UnitPtr&);
-        virtual bool visitModuleStart(const ModulePtr&);
-        virtual void visitClassDecl(const ClassDeclPtr&);
-        virtual bool visitClassDefStart(const ClassDefPtr&);
-        virtual bool visitExceptionStart(const ExceptionPtr&);
-        virtual bool visitStructStart(const StructPtr&);
-        virtual void visitOperation(const OperationPtr&);
-        virtual void visitDataMember(const DataMemberPtr&);
-        virtual void visitSequence(const SequencePtr&);
-        virtual void visitDictionary(const DictionaryPtr&);
-        virtual void visitEnum(const EnumPtr&);
-        virtual void visitConst(const ConstPtr&);
-
-    private:
-
-        StringList getMetaData(const ContainedPtr&);
-        void validateType(const SyntaxTreeBasePtr&, const StringList&, const std::string&, const std::string&);
-        void validateGetSet(const SyntaxTreeBasePtr&, const StringList&, const std::string&, const std::string&);
-
-        StringSet _history;
-    };
-
-    friend class JavaGenerator::MetaDataVisitor;
-
     std::string _dir;
     ::IceUtilInternal::Output* _out;
     mutable std::map<std::string, std::string> _filePackagePrefix;

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

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

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

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

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

@@ -131,7 +131,6 @@
 #define T63    0x2ad7d2bb
 #define T64 /* 0xeb86d391 */ (T_MASK ^ 0x14792c6e)
 
-
 static void
 md5_process(md5_state_t *pms, const md5_byte_t *data /*[64]*/)
 {

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

@@ -71,7 +71,7 @@ typedef struct md5_state_s {
 } md5_state_t;
 
 #ifdef __cplusplus
-extern "C" 
+extern "C"
 {
 #endif
 

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

@@ -1,6 +1,6 @@
 // **********************************************************************
 //
-// Copyright (c) 2003-2018 ZeroC, Inc. All rights reserved.
+// Copyright (c) 2003-2017 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.
@@ -9,6 +9,8 @@
 
 #include <Slice/PHPUtil.h>
 #include <functional>
+#include <algorithm>
+#include <vector>
 
 using namespace std;
 using namespace Slice;
@@ -29,14 +31,15 @@ lookupKwd(const string& name)
     //
     // Keyword list. *Must* be kept in alphabetical order.
     //
-    static const string keywordList[] = 
-    {       
-        "abstract", "and", "array", "as", "break", "case", "catch", "class", "clone", "const", "continue", "declare",
-        "default", "die", "do", "echo", "else", "elseif", "empty", "enddeclare", "endfor", "endforeach", "endif",
-        "endswitch", "endwhile", "eval", "exit", "extends", "final", "for", "foreach", "function", "global", "if",
-        "implements", "include", "include_once", "interface", "isset", "list", "new", "or", "print", "private",
-        "protected", "public", "require", "require_once", "return", "static", "switch", "this", "throw", "try",
-        "unset", "use", "var", "while", "xor"
+    static const string keywordList[] =
+    {
+        "_halt_compiler", "abstract", "and", "array", "as", "break", "callable", "case", "catch", "class", "clone",
+        "const", "continue", "declare", "default", "die", "do", "echo", "else", "elseif", "empty", "enddeclare",
+        "endfor", "endforeach", "endif", "endswitch", "endwhile", "eval", "exit", "extends", "final", "finally",
+        "for", "foreach", "function", "global", "goto", "if", "implements", "include", "include_once", "instanceof",
+        "insteadof", "interface", "isset", "list", "namespace", "new", "or", "print", "private", "protected", "public",
+        "require", "require_once", "return", "static", "switch", "this", "throw", "trait", "try", "unset", "use", "var",
+        "while", "xor", "yield"
     };
     bool found =  binary_search(&keywordList[0],
                                 &keywordList[sizeof(keywordList) / sizeof(*keywordList)],
@@ -134,12 +137,6 @@ Slice::PHP::fixIdent(const string& ident)
     return result.str();
 }
 
-string
-Slice::PHP::getAbsolute(const ContainedPtr& cont, bool ns, const string& prefix, const string& suffix)
-{
-    return scopedToName(cont->scope() + prefix + cont->name() + suffix, ns);
-}
-
 string
 Slice::PHP::escapeName(const string& name)
 {

data/ext/ice/cpp/{include → src}/Slice/PHPUtil.h

@@ -1,6 +1,6 @@
 // **********************************************************************
 //
-// Copyright (c) 2003-2018 ZeroC, Inc. All rights reserved.
+// Copyright (c) 2003-2017 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.
@@ -10,7 +10,8 @@
 #ifndef SLICE_PHP_UTIL_H
 #define SLICE_PHP_UTIL_H
 
-#include <Slice/Parser.h>
+#include <IceUtil/Config.h>
+#include <string>
 
 namespace Slice
 {
@@ -20,29 +21,19 @@ namespace PHP
 //
 // Convert a scoped name into a PHP name.
 //
-SLICE_API std::string scopedToName(const std::string&, bool);
+std::string scopedToName(const std::string&, bool);
 
 //
 // Check the given identifier against PHP's list of reserved words. If it matches
 // a reserved word, then an escaped version is returned with a leading underscore.
 //
-SLICE_API std::string fixIdent(const std::string&);
-
-//
-// Get the fully-qualified name of the given definition. If a suffix is provided,
-// it is prepended to the definition's unqualified name. If the nameSuffix
-// is provided, it is appended to the container's name.
-//
-// COMPILERFIX: MSVC 6 seems to have a problem with const std::string
-// = std::string(), const std::string = std::string().
-//
-SLICE_API std::string getAbsolute(const Slice::ContainedPtr&, bool, const std::string& = "", const std::string& = "");
+std::string fixIdent(const std::string&);
 
 //
 // Since PHP uses the backslash character as the namespace separator, we have
 // to escape backslash characters when they appear in a string literal.
 //
-SLICE_API std::string escapeName(const std::string&);
+std::string escapeName(const std::string&);
 
 }
 }