zeroc-ice 3.7.11 → 3.8.1

data/dist/IceRuby/Proxy.h

@@ -1,22 +1,21 @@
-//
-// Copyright (c) ZeroC, Inc. All rights reserved.
-//
+// Copyright (c) ZeroC, Inc.
 
 #ifndef ICE_RUBY_PROXY_H
 #define ICE_RUBY_PROXY_H
 
-#include <Config.h>
-#include <Ice/ProxyF.h>
-#include <Ice/CommunicatorF.h>
+#include "Config.h"
 
-namespace IceRuby
-{
+#include "Ice/CommunicatorF.h"
+#include "Ice/ProxyF.h"
 
-void initProxy(VALUE);
-VALUE createProxy(const Ice::ObjectPrx&, VALUE = Qnil);
-Ice::ObjectPrx getProxy(VALUE);
-bool checkProxy(VALUE);
+#include <memory>
 
+namespace IceRuby
+{
+    void initProxy(VALUE);
+    VALUE createProxy(Ice::ObjectPrx, VALUE = Qnil);
+    Ice::ObjectPrx getProxy(VALUE);
+    bool checkProxy(VALUE);
 }
 
 #endif

data/dist/IceRuby/RubySliceLoader.cpp

@@ -0,0 +1,39 @@
+// Copyright (c) ZeroC, Inc.
+
+#include "RubySliceLoader.h"
+#include "Types.h"
+
+#include <cassert>
+
+using namespace std;
+
+IceRuby::RubySliceLoader::RubySliceLoader(VALUE sliceLoader) : _sliceLoader{sliceLoader}
+{
+    // Mark the object as in use for the lifetime of this wrapper.
+    rb_gc_register_address(&sliceLoader);
+}
+
+IceRuby::RubySliceLoader::~RubySliceLoader() { rb_gc_unregister_address(&_sliceLoader); }
+
+Ice::ValuePtr
+IceRuby::RubySliceLoader::newClassInstance(string_view typeId) const
+{
+    volatile VALUE str = createString(typeId);
+    volatile VALUE obj = callRuby(rb_funcall, _sliceLoader, rb_intern("newInstance"), 1, str);
+    if (NIL_P(obj))
+    {
+        return nullptr;
+    }
+
+    // When the type ID is ::Ice::Object, it indicates that the stream has not found a factory and is providing us an
+    // opportunity to preserve the object.
+    ClassInfoPtr info =
+        typeId == Ice::Value::ice_staticId() ? lookupClassInfo("::Ice::UnknownSlicedValue") : lookupClassInfo(typeId);
+
+    if (!info)
+    {
+        return nullptr;
+    }
+
+    return make_shared<ValueReader>(obj, info);
+}

data/dist/IceRuby/RubySliceLoader.h

@@ -0,0 +1,27 @@
+// Copyright (c) ZeroC, Inc.
+
+#ifndef ICE_RUBY_RUBY_SLICE_LOADER_H
+#define ICE_RUBY_RUBY_SLICE_LOADER_H
+
+#include "Config.h"
+#include "Ice/Ice.h"
+
+namespace IceRuby
+{
+    /// Implements SliceLoader using a Ruby SliceLoader.
+    class RubySliceLoader final : public Ice::SliceLoader
+    {
+    public:
+        explicit RubySliceLoader(VALUE sliceLoader);
+        ~RubySliceLoader() final;
+
+        [[nodiscard]] Ice::ValuePtr newClassInstance(std::string_view typeId) const final;
+
+        // TODO: we currently don't support loading of custom Slice exceptions from Ruby.
+
+    private:
+        VALUE _sliceLoader;
+    };
+}
+
+#endif

data/dist/IceRuby/Slice.cpp

@@ -1,61 +1,39 @@
-//
-// Copyright (c) ZeroC, Inc. All rights reserved.
-//
+// Copyright (c) ZeroC, Inc.
 
-#include <Slice.h>
-#include <Util.h>
-#include <Slice/Preprocessor.h>
-#include <Slice/RubyUtil.h>
-#include <Slice/Util.h>
-#include <IceUtil/Options.h>
+#include "Slice.h"
+#include "Ice/Options.h"
+#include "Slice/Preprocessor.h"
+#include "Slice/Util.h"
+#include "Util.h"
+#include "slice2rb/RubyUtil.h"
+
+#include <iostream>
 
 using namespace std;
 using namespace IceRuby;
 using namespace Slice;
-using namespace Slice::Ruby;
 
-extern "C"
-VALUE
+extern "C" VALUE
 IceRuby_loadSlice(int argc, VALUE* argv, VALUE /*self*/)
 {
     ICE_RUBY_TRY
     {
-        if(argc < 1 || argc > 2)
+        if (argc != 1)
         {
             throw RubyException(rb_eArgError, "wrong number of arguments");
         }
 
-        string cmd = getString(argv[0]);
         vector<string> argSeq;
-        try
-        {
-            argSeq = IceUtilInternal::Options::split(cmd);
-        }
-        catch(const IceUtilInternal::BadOptException& ex)
-        {
-            throw RubyException(rb_eArgError, "error in Slice options: %s", ex.reason.c_str());
-        }
-        catch(const IceUtilInternal::APIException& ex)
-        {
-            throw RubyException(rb_eArgError, "error in Slice options: %s", ex.reason.c_str());
-        }
-
-        if(argc > 1)
+        if (!arrayToStringSeq(argv[0], argSeq))
         {
-            if(!arrayToStringSeq(argv[1], argSeq))
-            {
-                throw RubyException(rb_eTypeError, "argument 2 is not an array");
-            }
+            throw RubyException(rb_eTypeError, "argument 1 is not an array");
         }
 
-        IceUtilInternal::Options opts;
-        opts.addOpt("D", "", IceUtilInternal::Options::NeedArg, "", IceUtilInternal::Options::Repeat);
-        opts.addOpt("U", "", IceUtilInternal::Options::NeedArg, "", IceUtilInternal::Options::Repeat);
-        opts.addOpt("I", "", IceUtilInternal::Options::NeedArg, "", IceUtilInternal::Options::Repeat);
+        IceInternal::Options opts;
+        opts.addOpt("D", "", IceInternal::Options::NeedArg, "", IceInternal::Options::Repeat);
+        opts.addOpt("U", "", IceInternal::Options::NeedArg, "", IceInternal::Options::Repeat);
+        opts.addOpt("I", "", IceInternal::Options::NeedArg, "", IceInternal::Options::Repeat);
         opts.addOpt("d", "debug");
-        opts.addOpt("", "ice");
-        opts.addOpt("", "underscore");
-        opts.addOpt("", "checksum");
         opts.addOpt("", "all");
 
         vector<string> files;
@@ -63,92 +41,109 @@ IceRuby_loadSlice(int argc, VALUE* argv, VALUE /*self*/)
         {
             argSeq.insert(argSeq.begin(), ""); // dummy argv[0]
             files = opts.parse(argSeq);
-            if(files.empty())
+            if (files.empty())
             {
-                throw RubyException(rb_eArgError, "no Slice files specified in `%s'", cmd.c_str());
+                throw RubyException(rb_eArgError, "no Slice files specified");
             }
         }
-        catch(const IceUtilInternal::BadOptException& ex)
+        catch (const IceInternal::BadOptException& ex)
         {
-            throw RubyException(rb_eArgError, "error in Slice options: %s", ex.reason.c_str());
+            throw RubyException(rb_eArgError, "error in Slice options: %s", ex.what());
         }
-        catch(const IceUtilInternal::APIException& ex)
+        catch (const IceInternal::APIException& ex)
         {
-            throw RubyException(rb_eArgError, "error in Slice options: %s", ex.reason.c_str());
+            throw RubyException(rb_eArgError, "error in Slice options: %s", ex.what());
         }
 
         vector<string> cppArgs;
         vector<string> includePaths;
         bool debug = false;
-        bool ice = true; // This must be true so that we can create Ice::Identity when necessary.
-        bool underscore = opts.isSet("underscore");
         bool all = false;
-        bool checksum = false;
-        if(opts.isSet("D"))
+        if (opts.isSet("D"))
         {
             vector<string> optargs = opts.argVec("D");
-            for(vector<string>::const_iterator i = optargs.begin(); i != optargs.end(); ++i)
+            for (vector<string>::const_iterator i = optargs.begin(); i != optargs.end(); ++i)
             {
                 cppArgs.push_back("-D" + *i);
             }
         }
-        if(opts.isSet("U"))
+        if (opts.isSet("U"))
         {
             vector<string> optargs = opts.argVec("U");
-            for(vector<string>::const_iterator i = optargs.begin(); i != optargs.end(); ++i)
+            for (vector<string>::const_iterator i = optargs.begin(); i != optargs.end(); ++i)
             {
                 cppArgs.push_back("-U" + *i);
             }
         }
-        if(opts.isSet("I"))
+        if (opts.isSet("I"))
         {
             includePaths = opts.argVec("I");
-            for(vector<string>::const_iterator i = includePaths.begin(); i != includePaths.end(); ++i)
+            for (vector<string>::const_iterator i = includePaths.begin(); i != includePaths.end(); ++i)
             {
                 cppArgs.push_back("-I" + *i);
             }
         }
         debug = opts.isSet("d") || opts.isSet("debug");
         all = opts.isSet("all");
-        checksum = opts.isSet("checksum");
-
-        bool ignoreRedefs = false;
 
-        for(vector<string>::const_iterator p = files.begin(); p != files.end(); ++p)
+        for (vector<string>::const_iterator p = files.begin(); p != files.end(); ++p)
         {
-            string file = *p;
-            Slice::PreprocessorPtr icecpp = Slice::Preprocessor::create("icecpp", file, cppArgs);
-            FILE* cppHandle = icecpp->preprocess(false, "-D__SLICE2RB__");
-
-            if(cppHandle == 0)
+            PreprocessorPtr preprocessor;
+            UnitPtr unit;
+            try
             {
-                throw RubyException(rb_eArgError, "Slice preprocessing failed for `%s'", cmd.c_str());
+                string file = *p;
+                preprocessor = Preprocessor::create("preprocessor", file, cppArgs);
+                FILE* preprocessedHandle = preprocessor->preprocess("-D__SLICE2RB__");
+                if (preprocessedHandle == nullptr)
+                {
+                    throw RubyException(rb_eArgError, "Slice preprocessing failed");
+                }
+
+                unit = Unit::createUnit("ruby", {.all = all});
+                int parseStatus = unit->parse(file, preprocessedHandle, debug);
+
+                preprocessor->close();
+
+                if (parseStatus == EXIT_FAILURE)
+                {
+                    unit->destroy();
+                    throw RubyException(rb_eArgError, "Slice parsing failed");
+                }
+
+                //
+                // Generate the Ruby code into a string stream.
+                //
+                ostringstream codeStream;
+                IceInternal::Output out(codeStream);
+                out.setUseTab(false);
+                //
+                // Ruby magic comment to set the file encoding, it must be first or second line
+                //
+                out << "# encoding: utf-8\n";
+                Slice::Ruby::generate(unit, all, includePaths, out);
+                if (unit->getStatus() == EXIT_FAILURE)
+                {
+                    throw RubyException(rb_eArgError, "Slice validation failed");
+                }
+                unit->destroy();
+
+                string code = codeStream.str();
+                callRuby(rb_eval_string, code.c_str());
             }
-
-            UnitPtr u = Slice::Unit::createUnit(ignoreRedefs, all, ice, underscore);
-            int parseStatus = u->parse(file, cppHandle, debug);
-
-            if(!icecpp->close() || parseStatus == EXIT_FAILURE)
+            catch (...)
             {
-                u->destroy();
-                throw RubyException(rb_eArgError, "Slice parsing failed for `%s'", cmd.c_str());
+                if (preprocessor)
+                {
+                    preprocessor->close();
+                }
+
+                if (unit)
+                {
+                    unit->destroy();
+                }
+                throw;
             }
-
-            //
-            // Generate the Ruby code into a string stream.
-            //
-            ostringstream codeStream;
-            IceUtilInternal::Output out(codeStream);
-            out.setUseTab(false);
-            //
-            // Ruby magic comment to set the file encoding, it must be first or second line
-            //
-            out << "# encoding: utf-8\n";
-            generate(u, all, checksum, includePaths, out);
-            u->destroy();
-
-            string code = codeStream.str();
-            callRuby(rb_eval_string, code.c_str());
         }
     }
     ICE_RUBY_CATCH
@@ -156,19 +151,18 @@ IceRuby_loadSlice(int argc, VALUE* argv, VALUE /*self*/)
     return Qnil;
 }
 
-extern "C"
-VALUE
+extern "C" VALUE
 IceRuby_compile(int argc, VALUE* argv, VALUE /*self*/)
 {
     ICE_RUBY_TRY
     {
-        if(argc != 1)
+        if (argc != 1)
         {
             throw RubyException(rb_eArgError, "wrong number of arguments");
         }
 
         vector<string> argSeq;
-        if(!arrayToStringSeq(argv[0], argSeq))
+        if (!arrayToStringSeq(argv[0], argSeq))
         {
             throw RubyException(rb_eTypeError, "argument is not an array");
         }
@@ -180,14 +174,14 @@ IceRuby_compile(int argc, VALUE* argv, VALUE /*self*/)
         {
             rc = Slice::Ruby::compile(argSeq);
         }
-        catch(const std::exception& ex)
+        catch (const std::exception& ex)
         {
             cerr << argSeq[0] << ": error:" << ex.what() << endl;
             rc = EXIT_FAILURE;
         }
-        catch(...)
+        catch (...)
         {
-            cerr << argSeq[0] << ": error:" << "unknown exception" << endl;
+            cerr << argSeq[0] << ": error:unknown exception" << endl;
             rc = EXIT_FAILURE;
         }
         return INT2FIX(rc);

data/dist/IceRuby/Slice.h

@@ -1,17 +1,13 @@
-//
-// Copyright (c) ZeroC, Inc. All rights reserved.
-//
+// Copyright (c) ZeroC, Inc.
 
 #ifndef ICE_RUBY_SLICE_H
 #define ICE_RUBY_SLICE_H
 
-#include <Config.h>
+#include "Config.h"
 
 namespace IceRuby
 {
-
-void initSlice(VALUE);
-
+    void initSlice(VALUE);
 }
 
 #endif