r2corba 1.4.1

data/ext/libr2tao/exception.cpp

@@ -0,0 +1,202 @@
+/*--------------------------------------------------------------------
+# exception.cpp - R2TAO CORBA exception support
+#
+# Author: Martin Corino
+#
+# This program is free software; you can redistribute it and/or
+# modify it under the terms of the R2CORBA LICENSE which is
+# included with this program.
+#
+# Copyright (c) Remedy IT Expertise BV
+# Chamber of commerce Rotterdam nr.276339, The Netherlands
+#------------------------------------------------------------------*/
+
+#include "required.h"
+#include "exception.h"
+#include "typecode.h"
+#include "tao/corba.h"
+#include "tao/AnyTypeCode/Any.h"
+#include "tao/AnyTypeCode/Any_Unknown_IDL_Type.h"
+
+VALUE r2tao_cError = 0;
+R2TAO_EXPORT VALUE r2tao_cSystemException;
+R2TAO_EXPORT VALUE r2tao_cUserException;
+VALUE r2tao_cUNKNOWN;
+VALUE r2tao_cBAD_PARAM;
+VALUE r2tao_cNO_MEMORY;
+VALUE r2tao_cIMP_LIMIT;
+VALUE r2tao_cCOMM_FAILURE;
+VALUE r2tao_cINV_OBJREF;
+VALUE r2tao_cNO_PERMISSION;
+VALUE r2tao_cINTERNAL;
+VALUE r2tao_cMARSHAL;
+VALUE r2tao_cINITIALIZE;
+VALUE r2tao_cNO_IMPLEMENT;
+VALUE r2tao_cBAD_TYPECODE;
+VALUE r2tao_cBAD_OPERATION;
+VALUE r2tao_cNO_RESOURCES;
+VALUE r2tao_cNO_RESPONSE;
+VALUE r2tao_cPERSIST_STORE;
+VALUE r2tao_cBAD_INV_ORDER;
+VALUE r2tao_cTRANSIENT;
+VALUE r2tao_cFREE_MEM;
+VALUE r2tao_cINV_IDENT;
+VALUE r2tao_cINV_FLAG;
+VALUE r2tao_cINTF_REPOS;
+VALUE r2tao_cBAD_CONTEXT;
+VALUE r2tao_cOBJ_ADAPTER;
+VALUE r2tao_cDATA_CONVERSION;
+VALUE r2tao_cOBJECT_NOT_EXIST;
+VALUE r2tao_cTRANSACTION_UNAVAILABLE;
+VALUE r2tao_cTRANSACTION_MODE;
+VALUE r2tao_cTRANSACTION_REQUIRED;
+VALUE r2tao_cTRANSACTION_ROLLEDBACK;
+VALUE r2tao_cINVALID_TRANSACTION;
+VALUE r2tao_cINV_POLICY;
+VALUE r2tao_cCODESET_INCOMPATIBLE;
+VALUE r2tao_cREBIND;
+VALUE r2tao_cTIMEOUT;
+VALUE r2tao_cBAD_QOS;
+VALUE r2tao_cINVALID_ACTIVITY;
+VALUE r2tao_cACTIVITY_COMPLETED;
+VALUE r2tao_cACTIVITY_REQUIRED;
+VALUE r2tao_cTHREAD_CANCELLED;
+
+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 ());
+
+  rb_funcall (r2tao_cSystemException,
+              _raise_ID, 4, id, reason, minor, completed);
+}
+
+R2TAO_EXPORT void r2tao_sysex(const CORBA::SystemException& ex)
+{
+  sysexc_raise(ex);
+}
+
+R2TAO_EXPORT void r2tao_unknown_userex(const CORBA::UnknownUserException& ex)
+{
+  VALUE exc = r2tao_Any2Ruby (const_cast<CORBA::UnknownUserException&> (ex).exception (),
+                              ex._tao_type (), Qnil, Qnil);
+  rb_exc_raise(exc);
+}
+
+R2TAO_EXPORT void r2tao_userex(const CORBA::UserException& ex)
+{
+  try
+  {
+    // only way to convert these exceptions to Ruby
+    // is to marshal them, encapsulate in an any and
+    // from there demarshal them into a Ruby version of
+    // the exception
+    // NOTE: this does not work on UserExceptions from TAO
+    // core pseudo objects (like POA) since no marshaling
+    // code is generated for these.
+    TAO_OutputCDR outstrm;
+    ex._tao_encode (outstrm);
+    TAO_InputCDR instrm (outstrm);
+    TAO::Unknown_IDL_Type *any_impl = 0;
+    ACE_NEW_NORETURN (any_impl,
+                    TAO::Unknown_IDL_Type (ex._tao_type ()));
+    if (any_impl == 0)
+    {
+      X_CORBA (NO_MEMORY);
+    }
+    any_impl->_tao_decode (instrm);
+    CORBA::Any any_;
+    any_.replace (any_impl);
+
+    VALUE exc = r2tao_Any2Ruby(any_, ex._tao_type (), Qnil, Qnil);
+    rb_exc_raise(exc);
+  }
+  // marshaling/unmarshaling the exceptions might raise (system) exceptions
+  catch (const CORBA::SystemException& ex)
+  {
+    sysexc_raise(ex);
+  }
+  catch (const CORBA::Exception& ex)
+  {
+    r2tao_corbaex(ex);
+  }
+  catch (...)
+  {
+    r2tao_anyex();
+  }
+}
+
+R2TAO_EXPORT void r2tao_corbaex(const CORBA::Exception& ex)
+{
+  VALUE exc = rb_funcall(r2tao_cError, rb_intern("new"), 1,
+                         rb_str_new2 (ex._rep_id ()));
+  rb_exc_raise(exc);
+}
+
+R2TAO_EXPORT void r2tao_anyex()
+{
+  VALUE exc = rb_funcall(r2tao_cError, rb_intern("new"), 1,
+                         rb_str_new2 ("Unknown exception raised"));
+  rb_exc_raise(exc);
+}
+
+
+void r2tao_Init_Exception()
+{
+  if (r2tao_cError) return;
+
+  r2tao_cError = rb_const_get (r2tao_nsCORBA, rb_intern ("InternalError"));
+
+#define GET_EXCEPTION_CLASS(NAME)\
+  r2tao_c ## NAME = rb_const_get(r2tao_nsCORBA, rb_intern(#NAME));
+
+  GET_EXCEPTION_CLASS(SystemException);
+  GET_EXCEPTION_CLASS(UserException);
+  GET_EXCEPTION_CLASS(UNKNOWN);
+  GET_EXCEPTION_CLASS(BAD_PARAM);
+  GET_EXCEPTION_CLASS(NO_MEMORY);
+  GET_EXCEPTION_CLASS(IMP_LIMIT);
+  GET_EXCEPTION_CLASS(COMM_FAILURE);
+  GET_EXCEPTION_CLASS(INV_OBJREF);
+  GET_EXCEPTION_CLASS(NO_PERMISSION);
+  GET_EXCEPTION_CLASS(INTERNAL);
+  GET_EXCEPTION_CLASS(MARSHAL);
+  GET_EXCEPTION_CLASS(INITIALIZE);
+  GET_EXCEPTION_CLASS(NO_IMPLEMENT);
+  GET_EXCEPTION_CLASS(BAD_TYPECODE);
+  GET_EXCEPTION_CLASS(BAD_OPERATION);
+  GET_EXCEPTION_CLASS(NO_RESOURCES);
+  GET_EXCEPTION_CLASS(NO_RESPONSE);
+  GET_EXCEPTION_CLASS(PERSIST_STORE);
+  GET_EXCEPTION_CLASS(BAD_INV_ORDER);
+  GET_EXCEPTION_CLASS(TRANSIENT);
+  GET_EXCEPTION_CLASS(FREE_MEM);
+  GET_EXCEPTION_CLASS(INV_IDENT);
+  GET_EXCEPTION_CLASS(INV_FLAG);
+  GET_EXCEPTION_CLASS(INTF_REPOS);
+  GET_EXCEPTION_CLASS(BAD_CONTEXT);
+  GET_EXCEPTION_CLASS(OBJ_ADAPTER);
+  GET_EXCEPTION_CLASS(DATA_CONVERSION);
+  GET_EXCEPTION_CLASS(OBJECT_NOT_EXIST);
+  GET_EXCEPTION_CLASS(TRANSACTION_UNAVAILABLE);
+  GET_EXCEPTION_CLASS(TRANSACTION_MODE);
+  GET_EXCEPTION_CLASS(TRANSACTION_REQUIRED);
+  GET_EXCEPTION_CLASS(TRANSACTION_ROLLEDBACK);
+  GET_EXCEPTION_CLASS(INVALID_TRANSACTION);
+  GET_EXCEPTION_CLASS(INV_POLICY);
+  GET_EXCEPTION_CLASS(CODESET_INCOMPATIBLE);
+  GET_EXCEPTION_CLASS(REBIND);
+  GET_EXCEPTION_CLASS(TIMEOUT);
+  GET_EXCEPTION_CLASS(BAD_QOS);
+  GET_EXCEPTION_CLASS(INVALID_ACTIVITY);
+  GET_EXCEPTION_CLASS(ACTIVITY_COMPLETED);
+  GET_EXCEPTION_CLASS(ACTIVITY_REQUIRED);
+  GET_EXCEPTION_CLASS(THREAD_CANCELLED);
+#undef   GET_EXCEPTION_CLASS
+}

data/ext/libr2tao/exception.h

@@ -0,0 +1,104 @@
+/*--------------------------------------------------------------------
+# exception.h - R2TAO CORBA exception support
+#
+# Author: Martin Corino
+#
+# This program is free software; you can redistribute it and/or
+# modify it under the terms of the R2CORBA LICENSE which is
+# included with this program.
+#
+# Copyright (c) Remedy IT Expertise BV
+# Chamber of commerce Rotterdam nr.276339, The Netherlands
+#------------------------------------------------------------------*/
+
+#ifndef __R2TAO_EXCEPTION_H
+#define __R2TAO_EXCEPTION_H
+
+#include "required.h"
+#include <tao/SystemException.h>
+#include <tao/UserException.h>
+#include "tao/DynamicInterface/Unknown_User_Exception.h"
+
+/*
+ * see 19.16 "Mapping for Exception Types" and 19.22 "Handling Exceptions".
+ *
+ */
+
+#define R2TAO_TRY   try
+#define R2TAO_CATCH \
+  catch (const CORBA::SystemException& sex) \
+  { \
+    r2tao_sysex(sex); \
+  } \
+  catch (CORBA::UnknownUserException& uex) \
+  { \
+    r2tao_unknown_userex (uex); \
+  } \
+  catch (const CORBA::UserException& uex) \
+  { \
+    r2tao_userex (uex); \
+  } \
+  catch (const CORBA::Exception& cex) \
+  { \
+    r2tao_corbaex (cex); \
+  } \
+  catch (...) \
+  { \
+    r2tao_anyex (); \
+  }
+
+/* check environment argument and raise if need.*/
+extern R2TAO_EXPORT void r2tao_sysex(const CORBA::SystemException& ex);
+extern R2TAO_EXPORT void r2tao_unknown_userex(const CORBA::UnknownUserException& ex);
+extern R2TAO_EXPORT void r2tao_userex(const CORBA::UserException& ex);
+extern R2TAO_EXPORT void r2tao_corbaex(const CORBA::Exception& ex);
+extern R2TAO_EXPORT void r2tao_anyex();
+
+extern VALUE r2tao_cError;
+extern R2TAO_EXPORT VALUE r2tao_cSystemException;
+extern R2TAO_EXPORT VALUE r2tao_cUserException;
+extern R2TAO_EXPORT VALUE r2tao_cUNKNOWN;
+extern R2TAO_EXPORT VALUE r2tao_cBAD_PARAM;
+extern R2TAO_EXPORT VALUE r2tao_cNO_MEMORY;
+extern R2TAO_EXPORT VALUE r2tao_cIMP_LIMIT;
+extern R2TAO_EXPORT VALUE r2tao_cCOMM_FAILURE;
+extern R2TAO_EXPORT VALUE r2tao_cINV_OBJREF;
+extern R2TAO_EXPORT VALUE r2tao_cNO_PERMISSION;
+extern R2TAO_EXPORT VALUE r2tao_cINTERNAL;
+extern R2TAO_EXPORT VALUE r2tao_cMARSHAL;
+extern R2TAO_EXPORT VALUE r2tao_cINITIALIZE;
+extern R2TAO_EXPORT VALUE r2tao_cNO_IMPLEMENT;
+extern R2TAO_EXPORT VALUE r2tao_cBAD_TYPECODE;
+extern R2TAO_EXPORT VALUE r2tao_cBAD_OPERATION;
+extern R2TAO_EXPORT VALUE r2tao_cNO_RESOURCES;
+extern R2TAO_EXPORT VALUE r2tao_cNO_RESPONSE;
+extern R2TAO_EXPORT VALUE r2tao_cPERSIST_STORE;
+extern R2TAO_EXPORT VALUE r2tao_cBAD_INV_ORDER;
+extern R2TAO_EXPORT VALUE r2tao_cTRANSIENT;
+extern R2TAO_EXPORT VALUE r2tao_cFREE_MEM;
+extern R2TAO_EXPORT VALUE r2tao_cINV_IDENT;
+extern R2TAO_EXPORT VALUE r2tao_cINV_FLAG;
+extern R2TAO_EXPORT VALUE r2tao_cINTF_REPOS;
+extern R2TAO_EXPORT VALUE r2tao_cBAD_CONTEXT;
+extern R2TAO_EXPORT VALUE r2tao_cOBJ_ADAPTER;
+extern R2TAO_EXPORT VALUE r2tao_cDATA_CONVERSION;
+extern R2TAO_EXPORT VALUE r2tao_cOBJECT_NOT_EXIST;
+extern R2TAO_EXPORT VALUE r2tao_cTRANSACTION_REQUIRED;
+extern R2TAO_EXPORT VALUE r2tao_cTRANSACTION_ROLLEDBACK;
+extern R2TAO_EXPORT VALUE r2tao_cINVALID_TRANSACTION;
+extern R2TAO_EXPORT VALUE r2tao_cINV_POLICY;
+extern R2TAO_EXPORT VALUE r2tao_cCODESET_INCOMPATIBLE;
+
+extern void r2tao_Init_Exception();
+
+#define X_CORBA(ex) \
+  rb_raise (r2tao_c ## ex, " ")
+
+#define X_CORBA_(ex,msg) \
+  rb_raise (r2tao_c ## ex, msg)
+
+#define CHECK_RTYPE(v,t)\
+  if (rb_type ((v)) != (t)) \
+  { throw CORBA::BAD_PARAM(0, CORBA::COMPLETED_NO); }
+
+#endif

data/ext/libr2tao/longdouble.cpp

@@ -0,0 +1,173 @@
+/*--------------------------------------------------------------------
+# longdouble.cpp - R2TAO CORBA LongDouble support
+#
+# Author: Martin Corino
+#
+# This program is free software; you can redistribute it and/or
+# modify it under the terms of the R2CORBA LICENSE which is
+# included with this program.
+#
+# Copyright (c) Remedy IT Expertise BV
+# Chamber of commerce Rotterdam nr.276339, The Netherlands
+#------------------------------------------------------------------*/
+
+#include "required.h"
+#include "exception.h"
+#include "longdouble.h"
+
+#include <ace/OS_NS_stdio.h>
+
+static VALUE r2tao_cLongDouble;
+
+static VALUE rb_cBigDecimal;
+
+// CORBA LongDouble methods
+static VALUE ld_alloc(VALUE klass);
+static void ld_free(void* ptr);
+
+static VALUE r2tao_LongDouble_initialize(int _argc, VALUE *_argv0, VALUE klass);
+static VALUE r2tao_LongDouble_to_s(int _argc, VALUE *_argv, VALUE self);
+static VALUE r2tao_LongDouble_to_f(VALUE self);
+static VALUE r2tao_LongDouble_to_i(VALUE self);
+static VALUE r2tao_LongDouble_size(VALUE self);
+
+void r2tao_init_LongDouble()
+{
+  VALUE k;
+
+  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_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);
+  rb_define_method(k, "to_i", RUBY_METHOD_FUNC(r2tao_LongDouble_to_i), 0);
+  rb_define_singleton_method(k, "size", RUBY_METHOD_FUNC(r2tao_LongDouble_size), 0);
+
+  rb_require ("bigdecimal");
+  rb_cBigDecimal = rb_eval_string ("::BigDecimal");
+}
+//-------------------------------------------------------------------
+//  CORBA LongDouble methods
+//
+//===================================================================
+
+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);
+  return obj;
+}
+
+static void ld_free(void* ptr)
+{
+  if (ptr)
+    delete static_cast<ACE_CDR::LongDouble*> (ptr);
+}
+
+VALUE r2tao_cld2rld(const NATIVE_LONGDOUBLE& _d)
+{
+  VALUE _rd = Data_Wrap_Struct(r2tao_cLongDouble, 0, ld_free, new ACE_CDR::LongDouble);
+  SETCLD2RLD (_rd, _d);
+  return _rd;
+}
+
+VALUE r2tao_LongDouble_initialize(int _argc, VALUE *_argv, VALUE self)
+{
+  VALUE v0, v1 = Qnil;
+  rb_scan_args(_argc, _argv, "11", &v0, &v1);
+
+  if (rb_obj_is_kind_of(v0, rb_cFloat) == Qtrue)
+  {
+    SETCLD2RLD(self, NUM2DBL(v0));
+    return self;
+  }
+  else if (rb_obj_is_kind_of(v0, rb_cBigDecimal) == Qtrue)
+  {
+    if (v1 != Qnil)
+    {
+      v0 = rb_funcall (v0, rb_intern ("round"), 1, v1);
+    }
+    v0 = rb_funcall (v0, rb_intern ("to_s"), 0);
+  }
+
+  if (rb_obj_is_kind_of(v0, rb_cString) == Qtrue)
+  {
+    char* endp = 0;
+#if defined (NONNATIVE_LONGDOUBLE) && defined (ACE_CDR_IMPLEMENT_WITH_NATIVE_DOUBLE)
+    NATIVE_LONGDOUBLE _ld = ::strtod (RSTRING_PTR (v0), &endp);
+#else
+    NATIVE_LONGDOUBLE _ld = ::strtold (RSTRING_PTR (v0), &endp);
+#endif
+
+    if (errno == ERANGE)
+      rb_raise (rb_eRangeError, "floating point '%s' out-of-range", RSTRING_PTR (v0));
+
+    if (RSTRING_PTR (v0) == endp)
+      rb_raise (rb_eArgError, "floating point string '%s' invalid", RSTRING_PTR (v0));
+
+    SETCLD2RLD(self, _ld);
+    return self;
+  }
+
+  rb_raise (rb_eTypeError, "wrong argument type %s (expected Float, String or BigDecimal)",
+            rb_class2name(CLASS_OF(v0)));
+
+  return Qnil;
+}
+
+// silence pesky warnings from MingW cocerning long double format specifier
+#pragma GCC diagnostic push
+#pragma GCC diagnostic ignored "-Wformat"
+#pragma GCC diagnostic ignored "-Wformat-extra-args"
+
+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));
+
+  R2TAO_TRY
+  {
+    unsigned long len = (lprec < 512) ? 1024 : 2*lprec;
+    CORBA::String_var buf = CORBA::string_alloc (len);
+#if defined (NONNATIVE_LONGDOUBLE) && defined (ACE_CDR_IMPLEMENT_WITH_NATIVE_DOUBLE)
+    if (prec == Qnil)
+      ACE_OS::snprintf ((char*)buf, len-1, "%f", RLD2CLD(self));
+    else
+      ACE_OS::snprintf ((char*)buf, len-1, "%.*f", lprec, RLD2CLD(self));
+#else
+    if (prec == Qnil)
+      ACE_OS::snprintf ((char*)buf, len-1, "%Lf", RLD2CLD(self));
+    else
+      ACE_OS::snprintf ((char*)buf, len-1, "%.*Lf", lprec, RLD2CLD(self));
+#endif
+    return rb_str_new2 ((char*)buf);
+  }
+  R2TAO_CATCH;
+
+  return Qnil;
+}
+
+#pragma GCC diagnostic pop
+
+VALUE r2tao_LongDouble_to_f(VALUE self)
+{
+  return rb_float_new (RLD2CLD(self));
+}
+
+VALUE r2tao_LongDouble_to_i(VALUE self)
+{
+  unsigned long long l =
+    static_cast<unsigned long long> (RLD2CLD(self));
+  return ULL2NUM (l);
+}
+
+VALUE r2tao_LongDouble_size(VALUE /*self*/)
+{
+  return INT2FIX (sizeof (NATIVE_LONGDOUBLE) * CHAR_BIT);
+}

data/ext/libr2tao/longdouble.h

@@ -0,0 +1,31 @@
+/*--------------------------------------------------------------------
+# longdouble.h - R2TAO CORBA LongDouble support
+#
+# Author: Martin Corino
+#
+# This program is free software; you can redistribute it and/or
+# modify it under the terms of the R2CORBA LICENSE which is
+# included with this program.
+#
+# Copyright (c) Remedy IT Expertise BV
+# Chamber of commerce Rotterdam nr.276339, The Netherlands
+#------------------------------------------------------------------*/
+
+#if defined (NONNATIVE_LONGDOUBLE)
+#define NATIVE_LONGDOUBLE ACE_CDR::LongDouble::NativeImpl
+#else
+#define NATIVE_LONGDOUBLE long double
+#endif
+
+VALUE r2tao_cld2rld(const NATIVE_LONGDOUBLE& _d);
+
+#define RLD2CLD(_x) \
+  ((NATIVE_LONGDOUBLE)*static_cast<ACE_CDR::LongDouble*> (DATA_PTR (_x)))
+
+#define SETCLD2RLD(_x, _d) \
+  ACE_CDR_LONG_DOUBLE_ASSIGNMENT ((*static_cast<ACE_CDR::LongDouble*> (DATA_PTR (_x))), _d)
+
+#define CLD2RLD(_d) \
+  r2tao_cld2rld(_d)
+
+