rb/src/IceRuby/Util.cpp

   1 // **********************************************************************
   2 //
   3 // Copyright (c) 2003-2011 ZeroC, Inc. All rights reserved.
   4 //
   5 // This copy of Ice is licensed to you under the terms described in the
   6 // ICE_LICENSE file included in this distribution.
   7 //
   8 // **********************************************************************
   9
  10 #include <Util.h>
  11 #include <Ice/LocalException.h>
  12 #include <stdarg.h>
  13
  14 using namespace std;
  15 using namespace IceRuby;
  16
  17 extern "C"
  18 VALUE
  19 IceRuby_stringVersion(int /*argc*/, VALUE* /*argv*/, VALUE /*self*/)
  20 {
  21     ICE_RUBY_TRY
  22     {
  23         string s = ICE_STRING_VERSION;
  24         return createString(s);
  25     }
  26     ICE_RUBY_CATCH
  27     return Qnil;
  28 }
  29
  30 extern "C"
  31 VALUE
  32 IceRuby_intVersion(int /*argc*/, VALUE* /*argv*/, VALUE /*self*/)
  33 {
  34     ICE_RUBY_TRY
  35     {
  36         return INT2FIX(ICE_INT_VERSION);
  37     }
  38     ICE_RUBY_CATCH
  39     return Qnil;
  40 }
  41
  42 void
  43 IceRuby::initUtil(VALUE iceModule)
  44 {
  45     rb_define_module_function(iceModule, "stringVersion", CAST_METHOD(IceRuby_stringVersion), -1);
  46     rb_define_module_function(iceModule, "intVersion", CAST_METHOD(IceRuby_intVersion), -1);
  47 }
  48
  49 IceRuby::RubyException::RubyException()
  50 {
  51     ex = rb_gv_get("$!");
  52 }
  53
  54 IceRuby::RubyException::RubyException(VALUE exv) :
  55     ex(exv)
  56 {
  57 }
  58
  59 IceRuby::RubyException::RubyException(VALUE exClass, const char* fmt, ...)
  60 {
  61     va_list args;
  62     char buf[BUFSIZ];
  63
  64     va_start(args, fmt);
  65     vsnprintf(buf, BUFSIZ, fmt, args);
  66     buf[BUFSIZ - 1] = '\0';
  67     va_end(args);
  68
  69     ex = callRuby(rb_exc_new2, exClass, buf);
  70 }
  71
  72 ostream&
  73 IceRuby::RubyException::operator<<(ostream& ostr) const
  74 {
  75     volatile VALUE cls = rb_class_path(CLASS_OF(ex));
  76     volatile VALUE msg = rb_obj_as_string(ex);
  77     ostr << RSTRING_PTR(cls) << ": " << RSTRING_PTR(msg);
  78     return ostr;
  79 }
  80
  81 bool
  82 IceRuby::isString(VALUE val)
  83 {
  84     return TYPE(val) == T_STRING || callRuby(rb_respond_to, val, rb_intern("to_str")) != 0;
  85 }
  86
  87 bool
  88 IceRuby::isArray(VALUE val)
  89 {
  90     return TYPE(val) == T_ARRAY || callRuby(rb_respond_to, val, rb_intern("to_arr")) != 0;
  91 }
  92
  93 bool
  94 IceRuby::isHash(VALUE val)
  95 {
  96     return TYPE(val) == T_HASH || callRuby(rb_respond_to, val, rb_intern("to_hash")) != 0;
  97 }
  98
  99 string
 100 IceRuby::getString(VALUE val)
 101 {
 102     volatile VALUE result = callRuby(rb_string_value, &val);
 103     return string(RSTRING_PTR(result), RSTRING_LEN(result));
 104 }
 105
 106 VALUE
 107 IceRuby::createString(const string& str)
 108 {
 109     return callRuby(rb_str_new, str.c_str(), static_cast<long>(str.size()));
 110 }
 111
 112 long
 113 IceRuby::getInteger(VALUE val)
 114 {
 115     if(!FIXNUM_P(val) && TYPE(val) != T_BIGNUM)
 116     {
 117         val = callRuby(rb_Integer, val);
 118     }
 119     if(FIXNUM_P(val))
 120     {
 121         return FIX2LONG(val);
 122     }
 123     else if(TYPE(val) == T_BIGNUM)
 124     {
 125         Ice::Long l = getLong(val);
 126         if(l >= static_cast<Ice::Long>(INT_MIN) && l <= static_cast<Ice::Long>(INT_MAX))
 127         {
 128             return static_cast<long>(l);
 129         }
 130     }
 131     throw RubyException(rb_eTypeError, "unable to convert value to an integer");
 132 }
 133
 134 #define BITSPERDIG (SIZEOF_BDIGITS*CHAR_BIT)
 135 #define BIGUP(x) ((BDIGIT_DBL)(x) << BITSPERDIG)
 136
 137 Ice::Long
 138 IceRuby::getLong(VALUE val)
 139 {
 140     //
 141     // The rb_num2ll function raises exceptions, but we can't call it using callProtected
 142     // because its return type is long long and not VALUE.
 143     //
 144     volatile VALUE v = callRuby(rb_Integer, val);
 145     if(NIL_P(v))
 146     {
 147         throw RubyException(rb_eTypeError, "unable to convert value to a long");
 148     }
 149     if(FIXNUM_P(v))
 150     {
 151         return FIX2LONG(v);
 152     }
 153     else
 154     {
 155         assert(TYPE(v) == T_BIGNUM);
 156         long len = RBIGNUM_LEN(v);
 157         if(len > SIZEOF_LONG_LONG/SIZEOF_BDIGITS)
 158         {
 159             throw RubyException(rb_eRangeError, "bignum too big to convert into long");
 160         }
 161         BDIGIT *ds = RBIGNUM_DIGITS(v);
 162         BDIGIT_DBL num = 0;
 163         while(len--)
 164         {
 165             num = BIGUP(num);
 166             num += ds[len];
 167         }
 168         Ice::Long l = static_cast<Ice::Long>(num);
 169         if(l < 0 && (RBIGNUM_SIGN(v) || l != LLONG_MIN))
 170         {
 171             throw RubyException(rb_eRangeError, "bignum too big to convert into long");
 172         }
 173         if (!RBIGNUM_SIGN(v))
 174         {
 175             return -l;
 176         }
 177         return l;
 178     }
 179 }
 180
 181 bool
 182 IceRuby::arrayToStringSeq(VALUE val, vector<string>& seq)
 183 {
 184     volatile VALUE arr = callRuby(rb_check_array_type, val);
 185     if(NIL_P(arr))
 186     {
 187         return false;
 188     }
 189     for(long i = 0; i < RARRAY_LEN(arr); ++i)
 190     {
 191         string s = getString(RARRAY_PTR(arr)[i]);
 192         seq.push_back(getString(RARRAY_PTR(arr)[i]));
 193     }
 194     return true;
 195 }
 196
 197 VALUE
 198 IceRuby::stringSeqToArray(const vector<string>& seq)
 199 {
 200     volatile VALUE result = createArray(seq.size());
 201     long i = 0;
 202     if(seq.size() > 0)
 203     {
 204         for(vector<string>::const_iterator p = seq.begin(); p != seq.end(); ++p, ++i)
 205         {
 206             RARRAY_PTR(result)[i] = createString(*p);
 207         }
 208     }
 209     return result;
 210 }
 211
 212 namespace
 213 {
 214
 215 struct HashToContextIterator : public IceRuby::HashIterator
 216 {
 217     HashToContextIterator(Ice::Context& c) : ctx(c)
 218     {
 219     }
 220
 221     virtual void element(VALUE key, VALUE value)
 222     {
 223         string kstr = IceRuby::getString(key);
 224         string vstr = IceRuby::getString(value);
 225         ctx[kstr] = vstr;
 226     }
 227
 228     Ice::Context& ctx;
 229 };
 230
 231 }
 232
 233 bool
 234 IceRuby::hashToContext(VALUE val, Ice::Context& ctx)
 235 {
 236     if(TYPE(val) != T_HASH)
 237     {
 238         val = callRuby(rb_convert_type, val, T_HASH, "Hash", "to_hash");
 239         if(NIL_P(val))
 240         {
 241             return false;
 242         }
 243     }
 244     HashToContextIterator iter(ctx);
 245     hashIterate(val, iter);
 246     return true;
 247 }
 248
 249 VALUE
 250 IceRuby::contextToHash(const Ice::Context& ctx)
 251 {
 252     volatile VALUE result = callRuby(rb_hash_new);
 253     for(Ice::Context::const_iterator p = ctx.begin(); p != ctx.end(); ++p)
 254     {
 255         volatile VALUE key = callRuby(rb_str_new, p->first.c_str(), static_cast<long>(p->first.size()));
 256         volatile VALUE value = callRuby(rb_str_new, p->second.c_str(), static_cast<long>(p->second.size()));
 257         callRuby(rb_hash_aset, result, key, value);
 258     }
 259     return result;
 260 }
 261
 262 extern "C"
 263 VALUE
 264 IceRuby_Util_hash_foreach_callback(VALUE val, VALUE arg)
 265 {
 266     VALUE key = rb_ary_entry(val, 0);
 267     VALUE value = rb_ary_entry(val, 1);
 268
 269     //
 270     // We can't allow any C++ exceptions to propagate out of this function.
 271     //
 272     ICE_RUBY_TRY
 273     {
 274         IceRuby::HashIterator* iter = reinterpret_cast<IceRuby::HashIterator*>(arg);
 275         iter->element(key, value);
 276     }
 277     ICE_RUBY_CATCH
 278     return val;
 279 }
 280
 281 extern "C"
 282 {
 283 typedef VALUE (*ICE_RUBY_HASH_FOREACH_CALLBACK)(...);
 284 }
 285
 286 void
 287 IceRuby::hashIterate(VALUE h, HashIterator& iter)
 288 {
 289     assert(TYPE(h) == T_HASH);
 290     callRuby(rb_iterate, rb_each, h,
 291              reinterpret_cast<ICE_RUBY_HASH_FOREACH_CALLBACK>(IceRuby_Util_hash_foreach_callback),
 292              reinterpret_cast<VALUE>(&iter));
 293 }
 294
 295 Ice::Identity
 296 IceRuby::getIdentity(VALUE v)
 297 {
 298     volatile VALUE cls = callRuby(rb_path2class, "Ice::Identity");
 299     assert(!NIL_P(cls));
 300
 301     if(callRuby(rb_obj_is_kind_of, v, cls) == Qfalse)
 302     {
 303         throw RubyException(rb_eTypeError, "value is not an Ice::Identity");
 304     }
 305
 306     volatile VALUE name = callRuby(rb_iv_get, v, "@name");
 307     volatile VALUE category = callRuby(rb_iv_get, v, "@category");
 308
 309     if(!NIL_P(category) && !isString(category))
 310     {
 311         throw RubyException(rb_eTypeError, "identity category must be a string");
 312     }
 313
 314     if(NIL_P(name) || !isString(name))
 315     {
 316         throw RubyException(rb_eTypeError, "identity name must be a string");
 317     }
 318
 319     Ice::Identity result;
 320     result.name = getString(name);
 321     if(!NIL_P(category))
 322     {
 323         result.category = getString(category);
 324     }
 325     return result;
 326 }
 327
 328 VALUE
 329 IceRuby::createIdentity(const Ice::Identity& id)
 330 {
 331     volatile VALUE cls = callRuby(rb_path2class, "Ice::Identity");
 332     assert(!NIL_P(cls));
 333
 334     volatile VALUE result = callRuby(rb_class_new_instance, 0, reinterpret_cast<VALUE*>(0), cls);
 335     volatile VALUE name = callRuby(rb_str_new, id.name.c_str(), static_cast<long>(id.name.size()));
 336     volatile VALUE category = callRuby(rb_str_new, id.category.c_str(), static_cast<long>(id.category.size()));
 337     callRuby(rb_iv_set, result, "@name", name);
 338     callRuby(rb_iv_set, result, "@category", category);
 339     return result;
 340 }
 341
 342 VALUE
 343 IceRuby::callProtected(RubyFunction func, VALUE arg)
 344 {
 345     int error = 0;
 346     volatile VALUE result = rb_protect(func, arg, &error);
 347     if(error)
 348     {
 349         throw RubyException();
 350     }
 351     return result;
 352 }
 353
 354 static void
 355 setExceptionMembers(const Ice::LocalException& ex, VALUE p)
 356 {
 357     //
 358     // Transfer data members from Ice exception to Ruby exception.
 359     //
 360     try
 361     {
 362         ex.ice_throw();
 363     }
 364     catch(const Ice::InitializationException& e)
 365     {
 366         volatile VALUE v = createString(e.reason);
 367         callRuby(rb_iv_set, p, "@reason", v);
 368     }
 369     catch(const Ice::PluginInitializationException& e)
 370     {
 371         volatile VALUE v = createString(e.reason);
 372         callRuby(rb_iv_set, p, "@reason", v);
 373     }
 374     catch(const Ice::AlreadyRegisteredException& e)
 375     {
 376         volatile VALUE v;
 377         v = createString(e.kindOfObject);
 378         callRuby(rb_iv_set, p, "@kindOfObject", v);
 379         v = createString(e.id);
 380         callRuby(rb_iv_set, p, "@id", v);
 381     }
 382     catch(const Ice::NotRegisteredException& e)
 383     {
 384         volatile VALUE v;
 385         v = createString(e.kindOfObject);
 386         callRuby(rb_iv_set, p, "@kindOfObject", v);
 387         v = createString(e.id);
 388         callRuby(rb_iv_set, p, "@id", v);
 389     }
 390     catch(const Ice::TwowayOnlyException& e)
 391     {
 392         volatile VALUE v = createString(e.operation);
 393         callRuby(rb_iv_set, p, "@operation", v);
 394     }
 395     catch(const Ice::UnknownException& e)
 396     {
 397         volatile VALUE v = createString(e.unknown);
 398         callRuby(rb_iv_set, p, "@unknown", v);
 399     }
 400     catch(const Ice::ObjectAdapterDeactivatedException& e)
 401     {
 402         volatile VALUE v = createString(e.name);
 403         callRuby(rb_iv_set, p, "@name", v);
 404     }
 405     catch(const Ice::ObjectAdapterIdInUseException& e)
 406     {
 407         volatile VALUE v = createString(e.id);
 408         callRuby(rb_iv_set, p, "@id", v);
 409     }
 410     catch(const Ice::NoEndpointException& e)
 411     {
 412         volatile VALUE v = createString(e.proxy);
 413         callRuby(rb_iv_set, p, "@proxy", v);
 414     }
 415     catch(const Ice::EndpointParseException& e)
 416     {
 417         volatile VALUE v = createString(e.str);
 418         callRuby(rb_iv_set, p, "@str", v);
 419     }
 420     catch(const Ice::IdentityParseException& e)
 421     {
 422         volatile VALUE v = createString(e.str);
 423         callRuby(rb_iv_set, p, "@str", v);
 424     }
 425     catch(const Ice::ProxyParseException& e)
 426     {
 427         volatile VALUE v = createString(e.str);
 428         callRuby(rb_iv_set, p, "@str", v);
 429     }
 430     catch(const Ice::IllegalIdentityException& e)
 431     {
 432         volatile VALUE v = IceRuby::createIdentity(e.id);
 433         callRuby(rb_iv_set, p, "@id", v);
 434     }
 435     catch(const Ice::RequestFailedException& e)
 436     {
 437         volatile VALUE v;
 438         v = IceRuby::createIdentity(e.id);
 439         callRuby(rb_iv_set, p, "@id", v);
 440         v = createString(e.facet);
 441         callRuby(rb_iv_set, p, "@facet", v);
 442         v = createString(e.operation);
 443         callRuby(rb_iv_set, p, "@operation", v);
 444     }
 445     catch(const Ice::FileException& e)
 446     {
 447         volatile VALUE v = INT2FIX(e.error);
 448         callRuby(rb_iv_set, p, "@error", v);
 449         v = createString(e.path);
 450         callRuby(rb_iv_set, p, "@path", v);
 451     }
 452     catch(const Ice::SyscallException& e) // This must appear after all subclasses of SyscallException.
 453     {
 454         volatile VALUE v = INT2FIX(e.error);
 455         callRuby(rb_iv_set, p, "@error", v);
 456     }
 457     catch(const Ice::DNSException& e)
 458     {
 459         volatile VALUE v;
 460         v = INT2FIX(e.error);
 461         callRuby(rb_iv_set, p, "@error", v);
 462         v = createString(e.host);
 463         callRuby(rb_iv_set, p, "@host", v);
 464     }
 465     catch(const Ice::UnsupportedProtocolException& e)
 466     {
 467         callRuby(rb_iv_set, p, "@badMajor", INT2FIX(e.badMajor));
 468         callRuby(rb_iv_set, p, "@badMinor", INT2FIX(e.badMinor));
 469         callRuby(rb_iv_set, p, "@major", INT2FIX(e.major));
 470         callRuby(rb_iv_set, p, "@minor", INT2FIX(e.minor));
 471     }
 472     catch(const Ice::UnsupportedEncodingException& e)
 473     {
 474         callRuby(rb_iv_set, p, "@badMajor", INT2FIX(e.badMajor));
 475         callRuby(rb_iv_set, p, "@badMinor", INT2FIX(e.badMinor));
 476         callRuby(rb_iv_set, p, "@major", INT2FIX(e.major));
 477         callRuby(rb_iv_set, p, "@minor", INT2FIX(e.minor));
 478     }
 479     catch(const Ice::NoObjectFactoryException& e)
 480     {
 481         volatile VALUE v;
 482         v = createString(e.reason);
 483         callRuby(rb_iv_set, p, "@reason", v);
 484         v = createString(e.type);
 485         callRuby(rb_iv_set, p, "@type", v);
 486     }
 487     catch(const Ice::UnexpectedObjectException& e)
 488     {
 489         volatile VALUE v;
 490         v = createString(e.reason);
 491         callRuby(rb_iv_set, p, "@reason", v);
 492         v = createString(e.type);
 493         callRuby(rb_iv_set, p, "@type", v);
 494         v = createString(e.expectedType);
 495         callRuby(rb_iv_set, p, "@expectedType", v);
 496     }
 497     catch(const Ice::ProtocolException& e) // This must appear after all subclasses of ProtocolException.
 498     {
 499         volatile VALUE v = createString(e.reason);
 500         callRuby(rb_iv_set, p, "@reason", v);
 501     }
 502     catch(const Ice::FeatureNotSupportedException& e)
 503     {
 504         volatile VALUE v = createString(e.unsupportedFeature);
 505         callRuby(rb_iv_set, p, "@unsupportedFeature", v);
 506     }
 507     catch(const Ice::SecurityException& e)
 508     {
 509         volatile VALUE v = createString(e.reason);
 510         callRuby(rb_iv_set, p, "@reason", v);
 511     }
 512     catch(const Ice::LocalException&)
 513     {
 514         //
 515         // Nothing to do.
 516         //
 517     }
 518 }
 519
 520 VALUE
 521 IceRuby::createArrayHelper(long sz)
 522 {
 523     VALUE arr = callRuby(rb_ary_new2, sz);
 524     if(sz > 0)
 525     {
 526         callRubyVoid(rb_ary_store, arr, sz - 1, Qnil);
 527     }
 528     return arr;
 529 }
 530
 531 VALUE
 532 IceRuby::convertLocalException(const Ice::LocalException& ex)
 533 {
 534     //
 535     // We cannot throw a C++ exception or raise a Ruby exception. If an error
 536     // occurs while we are converting the exception, we do our best to return
 537     // an appropriate Ruby exception.
 538     //
 539     try
 540     {
 541         string name = ex.ice_name();
 542         volatile VALUE cls = callRuby(rb_path2class, name.c_str());
 543         if(NIL_P(cls))
 544         {
 545             throw RubyException(rb_eRuntimeError, "exception class `%s' not found", name.c_str());
 546         }
 547         volatile VALUE result = callRuby(rb_class_new_instance, 0, reinterpret_cast<VALUE*>(0), cls);
 548         setExceptionMembers(ex, result);
 549         return result;
 550     }
 551     catch(const RubyException& e)
 552     {
 553         return e.ex;
 554     }
 555     catch(...)
 556     {
 557         string msg = "failure occurred while converting exception " + ex.ice_name();
 558         return rb_exc_new2(rb_eRuntimeError, msg.c_str());
 559     }
 560 }