r2corba 1.5.5 → 1.6.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 3e920ffb5c3121f0f590343fd78737a1f18af807b6800812880e7d59a8d81586
-  data.tar.gz: 7b285e71aefed6353b2b28405e6a5b970705f27c2397fb5acea0e922dedbee48
+  metadata.gz: 968354f54041ad60d170c2089ff81467011b323f110813c6fdd7b80bc5f84466
+  data.tar.gz: b6c38a6b4e6262a5024743ce06272c0c067613943aedda71d722ba73ff619de5
 SHA512:
-  metadata.gz: 791e4da7b7477da1b3c63e75040b1d690816e669be8e9d9d7607daaec2612a80001413dbb3a30ce683d2e89573f6379068676fe91ee82157d74a437d78cc4239
-  data.tar.gz: d61caa1200c08e3e4f96f3fea2626fba209d16e47c7a91932177c700f00aff0d7937903051b4a269b30de79e62fb07c186d2f3aae6178619382e3936fd6b6307
+  metadata.gz: d19e36493ab582e6813d38922eb0228fefe784a9d5de16352215373034f8fc7874293acb29895d9fe4645cbf6fb12f6341c40ba8bcf7bbbead79e9a719c670b4
+  data.tar.gz: 97b53c6e3b5b1e22fbfc12b25b6d22144af2f83b7da88762aa1c8e3e85e3fd552244dabc08f7d9a9f36bbefa1e6282d016c02083678849f897a5d3bbd48932ef

data/ext/libr2tao/any.cpp

@@ -54,6 +54,7 @@
 #include "tao/Object_Loader.h"
 #include "tao/ORB_Core.h"
 #include "ace/Dynamic_Service.h"
+#include <cstring>
 
 #define RUBY_INVOKE_FUNC RUBY_ALLOC_FUNC
 
@@ -658,7 +659,7 @@ R2TAO_EXPORT void r2tao_Ruby2Any(CORBA::Any& _any, CORBA::TypeCode_ptr _tc, VALU
       {
         if (rb_obj_is_kind_of (rval, r2corba_cObject) == Qtrue)
         {
-          R2TAO_AbstractObject_ptr abs_obj = 0;
+          R2TAO_AbstractObject_ptr abs_obj = nullptr;
           ACE_NEW_NORETURN (abs_obj,
                             R2TAO_AbstractObject (r2corba_Object_r2t (rval), _tc));
           _any <<= &abs_obj;
@@ -666,7 +667,7 @@ R2TAO_EXPORT void r2tao_Ruby2Any(CORBA::Any& _any, CORBA::TypeCode_ptr _tc, VALU
         else
         {
           // abstract wrapper for Values
-          R2TAO_AbstractValue_ptr abs_obj = 0;
+          R2TAO_AbstractValue_ptr abs_obj = nullptr;
           ACE_NEW_NORETURN (abs_obj,
                             R2TAO_AbstractValue (rval, _tc));
           _any <<= &abs_obj;
@@ -721,7 +722,7 @@ R2TAO_EXPORT void r2tao_Ruby2Any(CORBA::Any& _any, CORBA::TypeCode_ptr _tc, VALU
     {
       if (!NIL_P (rval))
       {
-        R2TAO_Value_ptr r2tval = 0;
+        R2TAO_Value_ptr r2tval = nullptr;
         ACE_NEW_NORETURN (r2tval,
                           R2TAO_Value (rval));
         _any <<= &r2tval;
@@ -792,7 +793,7 @@ TAO_END_VERSIONED_NAMESPACE_DECL
 VALUE r2tao_Struct2Ruby (const CORBA::Any& _any, CORBA::TypeCode_ptr _tc, VALUE rtc, VALUE roottc)
 {
   if (TAO_debug_level > 9)
-    ACE_DEBUG ((LM_INFO, "R2TAO (%P|%t) - Struct2Ruby:: tc=%@, id=%s\n", _tc, _tc->id ()));
+    ACE_DEBUG ((LM_INFO, "R2TAO (%P|%t) - Struct2Ruby:: tc=%@, id=%C\n", _tc, _tc->id ()));
 
   DynamicAny::DynAny_var da = r2tao_CreateDynAny (_any);
   DynamicAny::DynStruct_var das = DynamicAny::DynStruct::_narrow (da.in ());
@@ -809,7 +810,7 @@ VALUE r2tao_Struct2Ruby (const CORBA::Any& _any, CORBA::TypeCode_ptr _tc, VALUE
     VALUE mrtc = rb_funcall (rtc, member_type_ID, 1, ULONG2NUM(m));
     VALUE rmval = r2tao_Any2Ruby (nvps[m].value, mtc.in (), mrtc, mrtc);
     const char* name = _tc->member_name (m);
-    CORBA::String_var mname = CORBA::string_alloc (2 + ACE_OS::strlen (name));
+    CORBA::String_var mname = CORBA::string_alloc (2 + std::strlen (name));
     ACE_OS::sprintf ((char*)mname.in (), "@%s", name);
     rb_iv_set (new_rs, mname.in (), rmval);
   }
@@ -822,7 +823,7 @@ VALUE r2tao_Struct2Ruby (const CORBA::Any& _any, CORBA::TypeCode_ptr _tc, VALUE
 VALUE r2tao_Union2Ruby (const CORBA::Any& _any, CORBA::TypeCode_ptr _tc, VALUE rtc, VALUE roottc)
 {
   if (TAO_debug_level > 9)
-    ACE_DEBUG ((LM_INFO, "R2TAO (%P|%t) - Union2Ruby:: tc=%@, id=%s\n", _tc, _tc->id ()));
+    ACE_DEBUG ((LM_INFO, "R2TAO (%P|%t) - Union2Ruby:: tc=%@, id=%C\n", _tc, _tc->id ()));
 
   VALUE new_ru = R2TAO_NEW_TCOBJECT (roottc);
 
@@ -1408,7 +1409,7 @@ R2TAO_EXPORT VALUE r2tao_Any2Ruby(const CORBA::Any& _any, CORBA::TypeCode_ptr _t
     }
     case CORBA::tk_abstract_interface:
     {
-      CORBA::AbstractBase_ptr abs = 0;
+      CORBA::AbstractBase_ptr abs = nullptr;
       TAO::Any_Impl_T<CORBA::AbstractBase>::extract (
           _any,
           CORBA::AbstractBase::_tao_any_destructor,
@@ -1462,7 +1463,7 @@ R2TAO_EXPORT VALUE r2tao_Any2Ruby(const CORBA::Any& _any, CORBA::TypeCode_ptr _t
     case CORBA::tk_value:
     case CORBA::tk_event:
     {
-      R2TAO_Value_ptr r2tval = 0;
+      R2TAO_Value_ptr r2tval = nullptr;
       TAO::Any_Impl_T<R2TAO_Value>::extract (
           _any,
           R2TAO_Value::_tao_any_destructor,
@@ -1513,7 +1514,7 @@ R2TAO_EXPORT void r2tao_Any4Value(CORBA::Any& _any, CORBA::TypeCode_ptr _tc)
 {
   if (TAO_debug_level > 9)
     ACE_DEBUG ((LM_INFO, "R2TAO (%P|%t) - r2tao_Any4Value:: "
-                         "initialising any for value %s\n",
+                         "initialising any for value %C\n",
                          _tc->id ()));
 
   CORBA::ValueFactory factory =
@@ -1524,7 +1525,7 @@ R2TAO_EXPORT void r2tao_Any4Value(CORBA::Any& _any, CORBA::TypeCode_ptr _tc)
     CORBA::ValueBase * vb = factory->create_for_unmarshal ();
     R2TAO_Value_ptr r2tval = R2TAO_Value::_downcast (vb);
 
-    TAO::Any_Impl * vimpl = 0;
+    TAO::Any_Impl * vimpl = nullptr;
     ACE_NEW_THROW_EX (vimpl,
                    TAO::Any_Impl_T<R2TAO_Value> (R2TAO_Value::_tao_any_destructor,
                                                  _tc,

data/ext/libr2tao/exception.cpp

@@ -65,12 +65,10 @@ static void sysexc_raise(const CORBA::SystemException& sex, char *_reason = 0)
 {
   static ID _raise_ID = rb_intern ("_raise");
 
-  VALUE id, reason, minor, completed;
-
-  id = rb_str_new2 (sex._rep_id ());
-  minor = ULONG2NUM (sex.minor ());
-  completed = INT2NUM ((int)sex.completed ());
-  reason    = rb_str_new2 (_reason ? _reason : sex._info ().c_str ());
+  VALUE id = rb_str_new2 (sex._rep_id ());
+  VALUE minor = ULONG2NUM (sex.minor ());
+  VALUE completed = INT2NUM ((int)sex.completed ());
+  VALUE reason = rb_str_new2 (_reason ? _reason : sex._info ().c_str ());
 
   rb_funcall (r2tao_cSystemException,
               _raise_ID, 4, id, reason, minor, completed);
@@ -102,10 +100,10 @@ R2TAO_EXPORT void r2tao_userex(const CORBA::UserException& ex)
     TAO_OutputCDR outstrm;
     ex._tao_encode (outstrm);
     TAO_InputCDR instrm (outstrm);
-    TAO::Unknown_IDL_Type *any_impl = 0;
+    TAO::Unknown_IDL_Type *any_impl = nullptr;
     ACE_NEW_NORETURN (any_impl,
                     TAO::Unknown_IDL_Type (ex._tao_type ()));
-    if (any_impl == 0)
+    if (!any_impl)
     {
       X_CORBA (NO_MEMORY);
     }

data/ext/libr2tao/exception.h

@@ -28,7 +28,7 @@
   { \
     r2tao_sysex(sex); \
   } \
-  catch (CORBA::UnknownUserException& uex) \
+  catch (const CORBA::UnknownUserException& uex) \
   { \
     r2tao_unknown_userex (uex); \
   } \

data/ext/libr2tao/longdouble.cpp

@@ -32,11 +32,9 @@ static VALUE r2tao_LongDouble_size(VALUE self);
 
 void r2tao_init_LongDouble()
 {
-  VALUE k;
-
-  k = r2tao_cLongDouble =
+  VALUE k = r2tao_cLongDouble =
     rb_define_class_under (r2tao_nsCORBA, "LongDouble", rb_cObject);
-  rb_define_alloc_func (r2tao_cLongDouble, RUBY_ALLOC_FUNC (ld_alloc));
+  rb_define_alloc_func (r2tao_cLongDouble, ld_alloc);
   rb_define_method(k, "initialize", RUBY_METHOD_FUNC(r2tao_LongDouble_initialize), -1);
   rb_define_method(k, "to_s", RUBY_METHOD_FUNC(r2tao_LongDouble_to_s), -1);
   rb_define_method(k, "to_f", RUBY_METHOD_FUNC(r2tao_LongDouble_to_f), 0);
@@ -53,11 +51,9 @@ void r2tao_init_LongDouble()
 
 static VALUE ld_alloc(VALUE klass)
 {
-  VALUE obj;
-
   ACE_CDR::LongDouble* ld = new ACE_CDR::LongDouble;
   ACE_CDR_LONG_DOUBLE_ASSIGNMENT ((*ld), 0.0);
-  obj = Data_Wrap_Struct(klass, 0, ld_free, ld);
+  VALUE obj = Data_Wrap_Struct(klass, 0, ld_free, ld);
   return obj;
 }
 
@@ -95,7 +91,7 @@ VALUE r2tao_LongDouble_initialize(int _argc, VALUE *_argv, VALUE self)
 
   if (rb_obj_is_kind_of(v0, rb_cString) == Qtrue)
   {
-    char* endp = 0;
+    char* endp = nullptr;
 #if defined (NONNATIVE_LONGDOUBLE) && defined (ACE_CDR_IMPLEMENT_WITH_NATIVE_DOUBLE)
     NATIVE_LONGDOUBLE _ld = ::strtod (RSTRING_PTR (v0), &endp);
 #else
@@ -128,7 +124,7 @@ VALUE r2tao_LongDouble_to_s(int _argc, VALUE *_argv, VALUE self)
   VALUE prec = Qnil;
   rb_scan_args(_argc, _argv, "01", &prec);
 
-  int lprec = (prec == Qnil ? 0 : NUM2LONG (prec));
+  int const lprec = (prec == Qnil ? 0 : NUM2LONG (prec));
 
   R2TAO_TRY
   {

data/ext/libr2tao/object.cpp

@@ -20,6 +20,7 @@
 #include "exception.h"
 #include "orb.h"
 #include <memory>
+#include <cstring>
 
 R2TAO_EXPORT VALUE r2corba_cObject = 0;
 R2TAO_EXPORT VALUE r2tao_cObject = 0;
@@ -160,11 +161,8 @@ r2tao_Init_Object()
 VALUE
 r2tao_t2r(VALUE klass, CORBA::Object_ptr obj)
 {
-  VALUE ret;
-  CORBA::Object_ptr o;
-
-  o = CORBA::Object::_duplicate (obj);
-  ret = Data_Wrap_Struct(klass, 0, _object_free, o);
+  CORBA::Object_ptr o = CORBA::Object::_duplicate (obj);
+  VALUE ret = Data_Wrap_Struct(klass, 0, _object_free, o);
 
   return ret;
 }
@@ -205,7 +203,6 @@ _object_free(void *ptr)
   CORBA::release (static_cast<CORBA::Object_ptr> (ptr));
 }
 
-
 static void
 _request_free(void *ptr)
 {
@@ -215,11 +212,8 @@ _request_free(void *ptr)
 VALUE
 r2tao_Request_t2r(CORBA::Request_ptr req)
 {
-  VALUE ret;
-  CORBA::Request_ptr o;
-
-  o = CORBA::Request::_duplicate (req);
-  ret = Data_Wrap_Struct(r2tao_cRequest, 0, _request_free, o);
+  CORBA::Request_ptr o = CORBA::Request::_duplicate (req);
+  VALUE ret = Data_Wrap_Struct(r2tao_cRequest, 0, _request_free, o);
 
   return ret;
 }
@@ -238,7 +232,6 @@ r2tao_Request_r2t(VALUE obj)
 //  CORBA::Object methods
 //
 //===================================================================
-
 VALUE
 r2tao_Object_orb(VALUE self)
 {
@@ -371,11 +364,10 @@ rCORBA_Object_non_existent(VALUE self)
 VALUE
 rCORBA_Object_is_equivalent(VALUE self, VALUE _other)
 {
-  CORBA::Object_ptr other, obj;
   VALUE ret = Qnil;
 
-  obj = r2tao_Object_r2t (self);
-  other = r2tao_Object_r2t (_other);
+  CORBA::Object_ptr obj = r2tao_Object_r2t (self);
+  CORBA::Object_ptr other = r2tao_Object_r2t (_other);
 
   R2TAO_TRY
   {
@@ -389,10 +381,10 @@ rCORBA_Object_is_equivalent(VALUE self, VALUE _other)
 VALUE
 rCORBA_Object_hash(VALUE self, VALUE _max)
 {
-  CORBA::ULong ret=0, max;
+  CORBA::ULong ret = 0;
   CORBA::Object_ptr obj = r2tao_Object_r2t (self);
 
-  max = NUM2ULONG(_max);
+  CORBA::ULong max = NUM2ULONG(_max);
   R2TAO_TRY
   {
     ret = obj->_hash(max);
@@ -431,15 +423,14 @@ ri_CORBA_Object_hash(VALUE self)
 VALUE
 rCORBA_Object_is_a(VALUE self, VALUE type_id)
 {
-  CORBA::Object_ptr obj;
   VALUE ret = Qnil;
 
-  obj = r2tao_Object_r2t (self);
+  CORBA::Object_ptr obj = r2tao_Object_r2t (self);
   Check_Type(type_id, T_STRING);
 
   R2TAO_TRY
   {
-    int f = obj->_is_a (RSTRING_PTR (type_id));
+    int const f = obj->_is_a (RSTRING_PTR (type_id));
     //::printf ("rCORBA_Object_is_a: %s -> %d\n", RSTRING_PTR (type_id), f);
     ret = f ? Qtrue: Qfalse;
   }
@@ -451,10 +442,9 @@ rCORBA_Object_is_a(VALUE self, VALUE type_id)
 VALUE
 rCORBA_Object_request(VALUE self, VALUE op_name)
 {
-  CORBA::Object_ptr obj;
   CORBA::Request_var req;
 
-  obj = r2tao_Object_r2t (self);
+  CORBA::Object_ptr obj = r2tao_Object_r2t (self);
   Check_Type(op_name, T_STRING);
 
   R2TAO_TRY
@@ -506,7 +496,7 @@ static VALUE _r2tao_set_request_arguments(CORBA::Request_ptr _req, VALUE arg_lis
           ++ret_val;
 
         if (TAO_debug_level > 9)
-          ACE_DEBUG ((LM_INFO, "R2TAO (%P|%t) - set_request_arguments: IN_ARG/INOUT_ARG - arg_name=%s\n",
+          ACE_DEBUG ((LM_INFO, "R2TAO (%P|%t) - set_request_arguments: IN_ARG/INOUT_ARG - arg_name=%C\n",
                       _arg_name));
 
         // assign value to Any
@@ -520,7 +510,7 @@ static VALUE _r2tao_set_request_arguments(CORBA::Request_ptr _req, VALUE arg_lis
             _req->add_out_arg (_arg_name) : _req->add_out_arg ();
 
         if (TAO_debug_level > 9)
-          ACE_DEBUG ((LM_INFO, "R2TAO (%P|%t) - set_request_arguments: OUT_ARG - arg_name=%s\n",
+          ACE_DEBUG ((LM_INFO, "R2TAO (%P|%t) - set_request_arguments: OUT_ARG - arg_name=%C\n",
                       _arg_name));
 
         // assign type info to Any
@@ -559,9 +549,7 @@ class R2TAO_Request_BlockedRegionCaller
 {
 public:
   R2TAO_Request_BlockedRegionCaller (CORBA::Request_ptr req)
-    : req_ (req),
-      exception_ (false),
-      corba_ex_ (0) {}
+    : req_ (req) {}
   virtual ~R2TAO_Request_BlockedRegionCaller () noexcept(false);
 
   VALUE call ();
@@ -574,8 +562,8 @@ protected:
   virtual VALUE do_exec () = 0;
 
   CORBA::Request_ptr req_;
-  bool exception_;
-  CORBA::Exception* corba_ex_;
+  bool exception_ {false};
+  CORBA::Exception* corba_ex_ {};
 };
 
 R2TAO_Request_BlockedRegionCaller::~R2TAO_Request_BlockedRegionCaller() noexcept(false)
@@ -628,10 +616,10 @@ class R2TAO_Request_BlockedInvoke : public R2TAO_Request_BlockedRegionCaller
 public:
   R2TAO_Request_BlockedInvoke (CORBA::Request_ptr req)
     : R2TAO_Request_BlockedRegionCaller (req) {}
-  virtual ~R2TAO_Request_BlockedInvoke () {}
+  ~R2TAO_Request_BlockedInvoke () override = default;
 
 protected:
-  virtual VALUE do_exec ();
+  VALUE do_exec () override;
 };
 
 VALUE R2TAO_Request_BlockedInvoke::do_exec ()
@@ -645,10 +633,10 @@ class R2TAO_Request_BlockedSendOneway : public R2TAO_Request_BlockedRegionCaller
 public:
   R2TAO_Request_BlockedSendOneway (CORBA::Request_ptr req)
     : R2TAO_Request_BlockedRegionCaller (req) {}
-  virtual ~R2TAO_Request_BlockedSendOneway () {}
+  ~R2TAO_Request_BlockedSendOneway () override = default;
 
 protected:
-  virtual VALUE do_exec ();
+  VALUE do_exec () override;
 };
 
 VALUE R2TAO_Request_BlockedSendOneway::do_exec ()
@@ -662,10 +650,10 @@ class R2TAO_Request_BlockedSendDeferred : public R2TAO_Request_BlockedRegionCall
 public:
   R2TAO_Request_BlockedSendDeferred (CORBA::Request_ptr req)
     : R2TAO_Request_BlockedRegionCaller (req) {}
-  virtual ~R2TAO_Request_BlockedSendDeferred () {}
+  ~R2TAO_Request_BlockedSendDeferred () override = default;
 
 protected:
-  virtual VALUE do_exec ();
+  VALUE do_exec () override;
 };
 
 VALUE R2TAO_Request_BlockedSendDeferred::do_exec ()
@@ -679,10 +667,10 @@ class R2TAO_Request_BlockedGetResponse : public R2TAO_Request_BlockedRegionCalle
 public:
   R2TAO_Request_BlockedGetResponse (CORBA::Request_ptr req)
     : R2TAO_Request_BlockedRegionCaller (req) {}
-  virtual ~R2TAO_Request_BlockedGetResponse () {}
+  ~R2TAO_Request_BlockedGetResponse () override = default;
 
 protected:
-  virtual VALUE do_exec ();
+  VALUE do_exec () override;
 };
 
 VALUE R2TAO_Request_BlockedGetResponse::do_exec ()
@@ -696,10 +684,10 @@ class R2TAO_Request_BlockedPollResponse : public R2TAO_Request_BlockedRegionCall
 public:
   R2TAO_Request_BlockedPollResponse (CORBA::Request_ptr req)
     : R2TAO_Request_BlockedRegionCaller (req) {}
-  virtual ~R2TAO_Request_BlockedPollResponse () {}
+  ~R2TAO_Request_BlockedPollResponse () override = default;
 
 protected:
-  virtual VALUE do_exec ();
+  VALUE do_exec () override;
 };
 
 VALUE R2TAO_Request_BlockedPollResponse::do_exec ()
@@ -766,18 +754,14 @@ static VALUE _r2tao_invoke_request(CORBA::Request_ptr _req,
         ACE_DEBUG ((LM_INFO, "R2TAO (%P|%t) - invoke_request(%C): user exception from remote twoway\n", _req->operation ()));
 
       CORBA::Any& _excany = user_ex.exception ();
-
-      CORBA::ULong exc_len = _req->exceptions ()->count ();
-      for (CORBA::ULong x=0; x<exc_len ;++x)
+      CORBA::ULong const exc_len = _req->exceptions ()->count ();
+      for (CORBA::ULong x=0; x < exc_len ;++x)
       {
         CORBA::TypeCode_var _xtc = _req->exceptions ()->item (x);
-        if (ACE_OS::strcmp (_xtc->id (),
-                            _excany._tao_get_typecode ()->id ()) == 0)
+        if (std::strcmp (_xtc->id (), _excany._tao_get_typecode ()->id ()) == 0)
         {
           VALUE x_rtc = r2corba_TypeCode_t2r (_xtc.in ());
-          VALUE rexc = r2tao_Any2Ruby (_excany,
-                                       _xtc.in (),
-                                       x_rtc, x_rtc);
+          VALUE rexc = r2tao_Any2Ruby (_excany, _xtc.in (), x_rtc, x_rtc);
           _raise = true;
           return rexc;
         }
@@ -1098,10 +1082,10 @@ VALUE rCORBA_Request_arguments(VALUE self, VALUE arg_list)
   CORBA::Request_ptr _req =  r2tao_Request_r2t(self);
   if (arg_list != Qnil)
     Check_Type (arg_list, T_ARRAY);
-  CORBA::ULong rarg_len = (CORBA::ULong )RARRAY_LEN (arg_list);
+  CORBA::ULong const rarg_len = (CORBA::ULong )RARRAY_LEN (arg_list);
   R2TAO_TRY
   {
-    CORBA::ULong arg_len = _req->arguments ()->count ();
+    CORBA::ULong const arg_len = _req->arguments ()->count ();
     if (arg_len != rarg_len)
     {
       throw CORBA::BAD_PARAM();

data/ext/libr2tao/orb.cpp

@@ -61,8 +61,8 @@ public:
   virtual ~R2CSigGuard();
 
   virtual int handle_signal (int signum,
-                             siginfo_t * = 0,
-                             ucontext_t * = 0);
+                             siginfo_t * = nullptr,
+                             ucontext_t * = nullptr);
 
   bool has_caught_signal () { return this->m_signal_caught; }
 
@@ -71,9 +71,9 @@ private:
   {
   public:
     Signal(int signum) : m_signum (signum) {}
-    virtual ~Signal() {}
+    ~Signal() override = default;
 
-    virtual int handle_exception (ACE_HANDLE fd = ACE_INVALID_HANDLE);
+    int handle_exception (ACE_HANDLE fd = ACE_INVALID_HANDLE) override;
 
   private:
     int inner_handler ();
@@ -85,7 +85,7 @@ private:
 
   static VALUE c_signums;
   static int c_nsig;
-  static ACE_Auto_Ptr<ACE_SIGACTION>  c_sa;
+  static ACE_Auto_Ptr<ACE_SIGACTION> c_sa;
 
   static void init_ ();
 
@@ -103,7 +103,7 @@ public:
 };
 
 #if defined (WIN32)
-R2CSigGuard* R2CSigGuard::c_sig_guard = 0;
+R2CSigGuard* R2CSigGuard::c_sig_guard = nullptr;
 
 BOOL WINAPI CtrlHandlerRoutine (DWORD /*dwCtrlType*/)
 {
@@ -124,11 +124,8 @@ _orb_free(void *ptr)
 R2TAO_EXPORT VALUE
 r2tao_ORB_t2r(CORBA::ORB_ptr obj)
 {
-  VALUE ret;
-  CORBA::ORB_ptr _orb;
-
-  _orb = CORBA::ORB::_duplicate(obj);
-  ret = Data_Wrap_Struct(r2tao_cORB, 0, _orb_free, _orb);
+  CORBA::ORB_ptr _orb = CORBA::ORB::_duplicate(obj);
+  VALUE ret = Data_Wrap_Struct(r2tao_cORB, 0, _orb_free, _orb);
 
   return ret;
 }
@@ -222,11 +219,9 @@ VALUE r2tao_ORB_hash(VALUE self)
 static
 VALUE r2tao_ORB_eql(VALUE self, VALUE _other)
 {
-  CORBA::ORB_ptr other, obj;
-
-  obj = r2tao_ORB_r2t (self);
+  CORBA::ORB_ptr obj = r2tao_ORB_r2t (self);
   r2tao_check_type (_other, r2tao_cORB);
-  other = r2tao_ORB_r2t (_other);
+  CORBA::ORB_ptr other = r2tao_ORB_r2t (_other);
 
   if (obj == other)
     return Qtrue;
@@ -306,12 +301,10 @@ VALUE rCORBA_ORB_init(int _argc, VALUE *_argv, VALUE /*klass*/) {
 static
 VALUE rCORBA_ORB_object_to_string(VALUE self, VALUE _obj)
 {
-  CORBA::Object_ptr obj;
-  char *str=0;
-  CORBA::ORB_ptr orb;
+  char *str = nullptr;
 
-  orb = r2tao_ORB_r2t (self);
-  obj = r2tao_Object_r2t (_obj);
+  CORBA::ORB_ptr orb = r2tao_ORB_r2t (self);
+  CORBA::Object_ptr obj = r2tao_Object_r2t (_obj);
 
   if (obj->_is_local ())
   {
@@ -331,10 +324,9 @@ static
 VALUE rCORBA_ORB_string_to_object(VALUE self, VALUE _str)
 {
   CORBA::Object_var obj;
-  char *str=0;
-  CORBA::ORB_ptr orb;
+  char *str = nullptr;
 
-  orb = r2tao_ORB_r2t (self);
+  CORBA::ORB_ptr orb = r2tao_ORB_r2t (self);
   Check_Type(_str, T_STRING);
   str = RSTRING_PTR (_str);
 
@@ -364,12 +356,8 @@ VALUE rCORBA_ORB_get_current(VALUE /*self*/)
 static
 VALUE rCORBA_ORB_list_initial_services(VALUE self)
 {
-  CORBA::ULong i;
-  VALUE ary;
   CORBA::ORB::ObjectIdList_var list;
-  CORBA::ORB_ptr orb;
-
-  orb = r2tao_ORB_r2t (self);
+  CORBA::ORB_ptr orb = r2tao_ORB_r2t (self);
 
   R2TAO_TRY
   {
@@ -377,8 +365,8 @@ VALUE rCORBA_ORB_list_initial_services(VALUE self)
   }
   R2TAO_CATCH;
 
-  ary = rb_ary_new2(list->length ());
-  for (i=0; i<list->length (); i++)
+  VALUE ary = rb_ary_new2(list->length ());
+  for (CORBA::ULong i = 0; i < list->length (); i++)
   {
     char const * id = list[i];
     rb_ary_push (ary, rb_str_new2 (id));
@@ -391,13 +379,10 @@ static
 VALUE rCORBA_ORB_resolve_initial_references(VALUE self, VALUE _id)
 {
   CORBA::Object_var obj;
-  char *id;
-  CORBA::ORB_ptr orb;
-
-  orb = r2tao_ORB_r2t (self);
+  CORBA::ORB_ptr orb = r2tao_ORB_r2t (self);
 
   Check_Type(_id, T_STRING);
-  id = RSTRING_PTR (_id);
+  char *id = RSTRING_PTR (_id);
 
   R2TAO_TRY
   {
@@ -418,15 +403,11 @@ VALUE rCORBA_ORB_resolve_initial_references(VALUE self, VALUE _id)
 static
 VALUE rCORBA_ORB_register_initial_reference(VALUE self, VALUE _id, VALUE _obj)
 {
-  CORBA::Object_var obj;
-  char *id;
-  CORBA::ORB_ptr orb;
-
-  orb = r2tao_ORB_r2t (self);
+  CORBA::ORB_ptr orb = r2tao_ORB_r2t (self);
 
   Check_Type(_id, T_STRING);
-  id = RSTRING_PTR (_id);
-  obj = r2tao_Object_r2t(_obj);
+  char *id = RSTRING_PTR (_id);
+  CORBA::Object_var obj = r2tao_Object_r2t(_obj);
 
   R2TAO_TRY
   {
@@ -448,15 +429,10 @@ class R2TAO_ORB_BlockedRegionCaller
 {
 public:
   R2TAO_ORB_BlockedRegionCaller (CORBA::ORB_ptr orb)
-    : orb_ (orb),
-      timeout_ (0),
-      exception_ (false),
-      corba_ex_ (0) {}
+    : orb_ (orb) {}
   R2TAO_ORB_BlockedRegionCaller (CORBA::ORB_ptr orb, ACE_Time_Value& to)
     : orb_ (orb),
-      timeout_ (&to),
-      exception_ (false),
-      corba_ex_ (0) {}
+      timeout_ (std::addressof(to)) {}
   virtual ~R2TAO_ORB_BlockedRegionCaller () noexcept(false);
 
   VALUE call (bool with_unblock=true);
@@ -472,9 +448,9 @@ protected:
   virtual VALUE do_exec () = 0;
 
   CORBA::ORB_ptr orb_;
-  ACE_Time_Value* timeout_;
-  bool exception_;
-  CORBA::Exception* corba_ex_;
+  ACE_Time_Value* timeout_ {};
+  bool exception_ {};
+  CORBA::Exception* corba_ex_ {};
 };
 
 R2TAO_ORB_BlockedRegionCaller::~R2TAO_ORB_BlockedRegionCaller() noexcept(false)
@@ -546,10 +522,10 @@ public:
     : R2TAO_ORB_BlockedRegionCaller (orb) {}
   R2TAO_ORB_BlockedRun (CORBA::ORB_ptr orb, ACE_Time_Value& to)
     : R2TAO_ORB_BlockedRegionCaller (orb, to) {}
-  virtual ~R2TAO_ORB_BlockedRun () {}
+  ~R2TAO_ORB_BlockedRun () override = default;
 
 protected:
-  virtual VALUE do_exec ();
+  VALUE do_exec () override;
 };
 
 VALUE R2TAO_ORB_BlockedRun::do_exec ()
@@ -571,7 +547,7 @@ public:
   virtual ~R2TAO_ORB_BlockedWorkPending () noexcept(false);
 
 protected:
-  virtual VALUE do_exec ();
+  VALUE do_exec () override;
 
 private:
   R2CSigGuard& sg_;
@@ -623,10 +599,10 @@ public:
     : R2TAO_ORB_BlockedRegionCaller (orb) {}
   R2TAO_ORB_BlockedPerformWork (CORBA::ORB_ptr orb, ACE_Time_Value& to)
     : R2TAO_ORB_BlockedRegionCaller (orb, to) {}
-  virtual ~R2TAO_ORB_BlockedPerformWork () {}
+  ~R2TAO_ORB_BlockedPerformWork () override = default;
 
 protected:
-  virtual VALUE do_exec ();
+  VALUE do_exec () override;
 };
 
 VALUE R2TAO_ORB_BlockedPerformWork::do_exec ()
@@ -641,10 +617,10 @@ VALUE R2TAO_ORB_BlockedPerformWork::do_exec ()
 class R2TAO_ORB_BlockedShutdown : public R2TAO_ORB_BlockedRegionCaller
 {
 public:
-  R2TAO_ORB_BlockedShutdown (CORBA::ORB_ptr orb, bool wait=false)
+  R2TAO_ORB_BlockedShutdown (CORBA::ORB_ptr orb, bool wait = false)
     : R2TAO_ORB_BlockedRegionCaller (orb),
       wait_ (wait) {}
-  virtual ~R2TAO_ORB_BlockedShutdown () {}
+  ~R2TAO_ORB_BlockedShutdown () override = default;
 
 protected:
   virtual VALUE do_exec ();
@@ -662,7 +638,6 @@ VALUE R2TAO_ORB_BlockedShutdown::do_exec ()
 static
 VALUE rCORBA_ORB_run(int _argc, VALUE *_argv, VALUE self)
 {
-  CORBA::ORB_ptr orb;
   VALUE rtimeout = Qnil;
   ACE_Time_Value timeout;
   double tmleft=0.0;
@@ -682,7 +657,7 @@ VALUE rCORBA_ORB_run(int _argc, VALUE *_argv, VALUE self)
     // convert to ACE_Time_Value
   }
 
-  orb = r2tao_ORB_r2t (self);
+  CORBA::ORB_ptr orb = r2tao_ORB_r2t (self);
 
   R2TAO_TRY
   {
@@ -715,7 +690,6 @@ VALUE rCORBA_ORB_run(int _argc, VALUE *_argv, VALUE self)
 static
 VALUE rCORBA_ORB_work_pending(int _argc, VALUE *_argv, VALUE self)
 {
-  CORBA::ORB_ptr orb;
   VALUE rtimeout = Qnil;
   ACE_Time_Value timeout;
   double tmleft=0.0;
@@ -735,7 +709,7 @@ VALUE rCORBA_ORB_work_pending(int _argc, VALUE *_argv, VALUE self)
     // convert to ACE_Time_Value
   }
 
-  orb = r2tao_ORB_r2t (self);
+  CORBA::ORB_ptr orb = r2tao_ORB_r2t (self);
 
   VALUE _rc = Qfalse;
 
@@ -858,8 +832,7 @@ VALUE rCORBA_ORB_shutdown(int _argc, VALUE *_argv, VALUE self)
 static
 VALUE rCORBA_ORB_destroy(VALUE self)
 {
-  CORBA::ORB_ptr orb;
-  orb = r2tao_ORB_r2t (self);
+  CORBA::ORB_ptr orb = r2tao_ORB_r2t (self);
   R2TAO_TRY
   {
     orb->destroy ();