generator/generator_ruby.ml

   1 (* libguestfs
   2  * Copyright (C) 2009-2011 Red Hat Inc.
   3  *
   4  * This program is free software; you can redistribute it and/or modify
   5  * it under the terms of the GNU General Public License as published by
   6  * the Free Software Foundation; either version 2 of the License, or
   7  * (at your option) any later version.
   8  *
   9  * This program is distributed in the hope that it will be useful,
  10  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  11  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  12  * GNU General Public License for more details.
  13  *
  14  * You should have received a copy of the GNU General Public License
  15  * along with this program; if not, write to the Free Software
  16  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
  17  *)
  18
  19 (* Please read generator/README first. *)
  20
  21 open Printf
  22
  23 open Generator_types
  24 open Generator_utils
  25 open Generator_pr
  26 open Generator_docstrings
  27 open Generator_optgroups
  28 open Generator_actions
  29 open Generator_structs
  30 open Generator_c
  31 open Generator_events
  32
  33 (* Generate ruby bindings. *)
  34 let rec generate_ruby_c () =
  35   generate_header CStyle LGPLv2plus;
  36
  37   pr "\
  38 #include <stdio.h>
  39 #include <stdlib.h>
  40 #include <stdint.h>
  41
  42 #include <ruby.h>
  43
  44 #include \"guestfs.h\"
  45
  46 #include \"extconf.h\"
  47
  48 /* For Ruby < 1.9 */
  49 #ifndef RARRAY_LEN
  50 #define RARRAY_LEN(r) (RARRAY((r))->len)
  51 #endif
  52
  53 static VALUE m_guestfs;                 /* guestfs module */
  54 static VALUE c_guestfs;                 /* guestfs_h handle */
  55 static VALUE e_Error;                   /* used for all errors */
  56
  57 static void ruby_event_callback_wrapper (guestfs_h *g, void *data, uint64_t event, int event_handle, int flags, const char *buf, size_t buf_len, const uint64_t *array, size_t array_len);
  58 static VALUE ruby_event_callback_wrapper_wrapper (VALUE argv);
  59 static VALUE ruby_event_callback_handle_exception (VALUE not_used, VALUE exn);
  60 static VALUE **get_all_event_callbacks (guestfs_h *g, size_t *len_rtn);
  61
  62 static void
  63 ruby_guestfs_free (void *gvp)
  64 {
  65   guestfs_h *g = gvp;
  66
  67   if (g) {
  68     /* As in the OCaml binding, there is a nasty, difficult to
  69      * solve case here where the user deletes events in one of
  70      * the callbacks that we are about to invoke, resulting in
  71      * a double-free.  XXX
  72      */
  73     size_t len, i;
  74     VALUE **roots = get_all_event_callbacks (g, &len);
  75
  76     /* Close the handle: this could invoke callbacks from the list
  77      * above, which is why we don't want to delete them before
  78      * closing the handle.
  79      */
  80     guestfs_close (g);
  81
  82     /* Now unregister the global roots. */
  83     for (i = 0; i < len; ++i) {
  84       rb_gc_unregister_address (roots[i]);
  85       free (roots[i]);
  86     }
  87   }
  88 }
  89
  90 /*
  91  * call-seq:
  92  *   Guestfs::Guestfs.new() -> Guestfs::Guestfs
  93  *
  94  * Call
  95  * +guestfs_create+[http://libguestfs.org/guestfs.3.html#guestfs_create]
  96  * to create a new libguestfs handle.  The handle is represented in
  97  * Ruby as an instance of the Guestfs::Guestfs class.
  98  */
  99 static VALUE
 100 ruby_guestfs_create (VALUE m)
 101 {
 102   guestfs_h *g;
 103
 104   g = guestfs_create ();
 105   if (!g)
 106     rb_raise (e_Error, \"failed to create guestfs handle\");
 107
 108   /* Don't print error messages to stderr by default. */
 109   guestfs_set_error_handler (g, NULL, NULL);
 110
 111   /* Wrap it, and make sure the close function is called when the
 112    * handle goes away.
 113    */
 114   return Data_Wrap_Struct (c_guestfs, NULL, ruby_guestfs_free, g);
 115 }
 116
 117 /*
 118  * call-seq:
 119  *   g.close() -> nil
 120  *
 121  * Call
 122  * +guestfs_close+[http://libguestfs.org/guestfs.3.html#guestfs_close]
 123  * to close the libguestfs handle.
 124  */
 125 static VALUE
 126 ruby_guestfs_close (VALUE gv)
 127 {
 128   guestfs_h *g;
 129   Data_Get_Struct (gv, guestfs_h, g);
 130
 131   ruby_guestfs_free (g);
 132   DATA_PTR (gv) = NULL;
 133
 134   return Qnil;
 135 }
 136
 137 /*
 138  * call-seq:
 139  *   g.set_event_callback(cb, event_bitmask) -> event_handle
 140  *
 141  * Call
 142  * +guestfs_set_event_callback+[http://libguestfs.org/guestfs.3.html#guestfs_set_event_callback]
 143  * to register an event callback.  This returns an event handle.
 144  */
 145 static VALUE
 146 ruby_set_event_callback (VALUE gv, VALUE cbv, VALUE event_bitmaskv)
 147 {
 148   guestfs_h *g;
 149   uint64_t event_bitmask;
 150   int eh;
 151   VALUE *root;
 152   char key[64];
 153
 154   Data_Get_Struct (gv, guestfs_h, g);
 155
 156   event_bitmask = NUM2ULL (event_bitmaskv);
 157
 158   root = guestfs_safe_malloc (g, sizeof *root);
 159   *root = cbv;
 160
 161   eh = guestfs_set_event_callback (g, ruby_event_callback_wrapper,
 162                                    event_bitmask, 0, root);
 163   if (eh == -1) {
 164     free (root);
 165     rb_raise (e_Error, \"%%s\", guestfs_last_error (g));
 166   }
 167
 168   rb_gc_register_address (root);
 169
 170   snprintf (key, sizeof key, \"_ruby_event_%%d\", eh);
 171   guestfs_set_private (g, key, root);
 172
 173   return INT2NUM (eh);
 174 }
 175
 176 /*
 177  * call-seq:
 178  *   g.delete_event_callback(event_handle) -> nil
 179  *
 180  * Call
 181  * +guestfs_delete_event_callback+[http://libguestfs.org/guestfs.3.html#guestfs_delete_event_callback]
 182  * to delete an event callback.
 183  */
 184 static VALUE
 185 ruby_delete_event_callback (VALUE gv, VALUE event_handlev)
 186 {
 187   guestfs_h *g;
 188   char key[64];
 189   int eh = NUM2INT (event_handlev);
 190   VALUE *root;
 191
 192   Data_Get_Struct (gv, guestfs_h, g);
 193
 194   snprintf (key, sizeof key, \"_ruby_event_%%d\", eh);
 195
 196   root = guestfs_get_private (g, key);
 197   if (root) {
 198     rb_gc_unregister_address (root);
 199     free (root);
 200     guestfs_set_private (g, key, NULL);
 201     guestfs_delete_event_callback (g, eh);
 202   }
 203
 204   return Qnil;
 205 }
 206
 207 static void
 208 ruby_event_callback_wrapper (guestfs_h *g,
 209                              void *data,
 210                              uint64_t event,
 211                              int event_handle,
 212                              int flags,
 213                              const char *buf, size_t buf_len,
 214                              const uint64_t *array, size_t array_len)
 215 {
 216   size_t i;
 217   VALUE eventv, event_handlev, bufv, arrayv, argv;
 218
 219   eventv = ULL2NUM (event);
 220   event_handlev = INT2NUM (event_handle);
 221
 222   bufv = rb_str_new (buf, buf_len);
 223
 224   arrayv = rb_ary_new2 (array_len);
 225   for (i = 0; i < array_len; ++i)
 226     rb_ary_push (arrayv, ULL2NUM (array[i]));
 227
 228   /* Wrap up the arguments in an array which will be unpacked
 229    * and passed as multiple arguments.  This is a crap limitation
 230    * of rb_rescue.
 231    * http://blade.nagaokaut.ac.jp/cgi-bin/scat.rb/~poffice/mail/ruby-talk/65698
 232    */
 233   argv = rb_ary_new2 (5);
 234   rb_ary_store (argv, 0, * (VALUE *) data /* function */);
 235   rb_ary_store (argv, 1, eventv);
 236   rb_ary_store (argv, 2, event_handlev);
 237   rb_ary_store (argv, 3, bufv);
 238   rb_ary_store (argv, 4, arrayv);
 239
 240   rb_rescue (ruby_event_callback_wrapper_wrapper, argv,
 241              ruby_event_callback_handle_exception, Qnil);
 242 }
 243
 244 static VALUE
 245 ruby_event_callback_wrapper_wrapper (VALUE argv)
 246 {
 247   VALUE fn, eventv, event_handlev, bufv, arrayv;
 248
 249   fn = rb_ary_entry (argv, 0);
 250   eventv = rb_ary_entry (argv, 1);
 251   event_handlev = rb_ary_entry (argv, 2);
 252   bufv = rb_ary_entry (argv, 3);
 253   arrayv = rb_ary_entry (argv, 4);
 254
 255   rb_funcall (fn, rb_intern (\"call\"), 4,
 256               eventv, event_handlev, bufv, arrayv);
 257
 258   return Qnil;
 259 }
 260
 261 static VALUE
 262 ruby_event_callback_handle_exception (VALUE not_used, VALUE exn)
 263 {
 264   /* Callbacks aren't supposed to throw exceptions.  The best we
 265    * can do is to print the error.
 266    */
 267   fprintf (stderr, \"libguestfs: exception in callback: %%s\\n\",
 268            StringValueCStr (exn));
 269
 270   return Qnil;
 271 }
 272
 273 static VALUE **
 274 get_all_event_callbacks (guestfs_h *g, size_t *len_rtn)
 275 {
 276   VALUE **r;
 277   size_t i;
 278   const char *key;
 279   VALUE *root;
 280
 281   /* Count the length of the array that will be needed. */
 282   *len_rtn = 0;
 283   root = guestfs_first_private (g, &key);
 284   while (root != NULL) {
 285     if (strncmp (key, \"_ruby_event_\", strlen (\"_ruby_event_\")) == 0)
 286       (*len_rtn)++;
 287     root = guestfs_next_private (g, &key);
 288   }
 289
 290   /* Copy them into the return array. */
 291   r = guestfs_safe_malloc (g, sizeof (VALUE *) * (*len_rtn));
 292
 293   i = 0;
 294   root = guestfs_first_private (g, &key);
 295   while (root != NULL) {
 296     if (strncmp (key, \"_ruby_event_\", strlen (\"_ruby_event_\")) == 0) {
 297       r[i] = root;
 298       i++;
 299     }
 300     root = guestfs_next_private (g, &key);
 301   }
 302
 303   return r;
 304 }
 305
 306 /*
 307  * call-seq:
 308  *   g.user_cancel() -> nil
 309  *
 310  * Call
 311  * +guestfs_user_cancel+[http://libguestfs.org/guestfs.3.html#guestfs_user_cancel]
 312  * to cancel the current transfer.  This is safe to call from Ruby
 313  * signal handlers and threads.
 314  */
 315 static VALUE
 316 ruby_user_cancel (VALUE gv)
 317 {
 318   guestfs_h *g;
 319
 320   Data_Get_Struct (gv, guestfs_h, g);
 321   if (g)
 322     guestfs_user_cancel (g);
 323   return Qnil;
 324 }
 325
 326 ";
 327
 328   List.iter (
 329     fun (name, (ret, args, optargs as style), _, flags, _, shortdesc, longdesc) ->
 330       (* Generate rdoc. *)
 331       if not (List.mem NotInDocs flags); then (
 332         let doc = replace_str longdesc "C<guestfs_" "C<g." in
 333         let doc =
 334           if optargs <> [] then
 335             doc ^ "\n\nOptional arguments are supplied in the final hash parameter, which is a hash of the argument name to its value.  Pass an empty {} for no optional arguments."
 336           else doc in
 337         let doc =
 338           if List.mem ProtocolLimitWarning flags then
 339             doc ^ "\n\n" ^ protocol_limit_warning
 340           else doc in
 341         let doc =
 342           if List.mem DangerWillRobinson flags then
 343             doc ^ "\n\n" ^ danger_will_robinson
 344           else doc in
 345         let doc =
 346           match deprecation_notice flags with
 347           | None -> doc
 348           | Some txt -> doc ^ "\n\n" ^ txt in
 349         let doc = pod2text ~width:60 name doc in
 350         let doc = String.concat "\n * " doc in
 351         let doc = trim doc in
 352
 353         let args = List.map name_of_argt args in
 354         let args = if optargs <> [] then args @ ["{optargs...}"] else args in
 355         let args = String.concat ", " args in
 356
 357         let ret =
 358           match ret with
 359           | RErr -> "nil"
 360           | RBool _ -> "[True|False]"
 361           | RInt _ -> "fixnum"
 362           | RInt64 _ -> "fixnum"
 363           | RConstString _ -> "string"
 364           | RConstOptString _ -> "string"
 365           | RString _ -> "string"
 366           | RBufferOut _ -> "string"
 367           | RStruct _
 368           | RHashtable _ -> "hash"
 369           | RStringList _
 370           | RStructList _ -> "list" in
 371
 372         pr "\
 373 /*
 374  * call-seq:
 375  *   g.%s(%s) -> %s
 376  *
 377  * %s
 378  *
 379  * %s
 380  *
 381  * (For the C API documentation for this function, see
 382  * +guestfs_%s+[http://libguestfs.org/guestfs.3.html#guestfs_%s]).
 383  */
 384 " name args ret shortdesc doc name name
 385       );
 386
 387       (* Generate the function. *)
 388       pr "static VALUE\n";
 389       pr "ruby_guestfs_%s (VALUE gv" name;
 390       List.iter (fun arg -> pr ", VALUE %sv" (name_of_argt arg)) args;
 391       (* XXX This makes the hash mandatory, meaning that you have
 392        * to specify {} for no arguments.  We could make it so this
 393        * can be omitted.  However that is a load of hassle because
 394        * you have to completely change the way that arguments are
 395        * passed in.  See:
 396        * http://www.redhat.com/archives/libvir-list/2008-April/msg00004.html
 397        *)
 398       if optargs <> [] then
 399         pr ", VALUE optargsv";
 400       pr ")\n";
 401       pr "{\n";
 402       pr "  guestfs_h *g;\n";
 403       pr "  Data_Get_Struct (gv, guestfs_h, g);\n";
 404       pr "  if (!g)\n";
 405       pr "    rb_raise (rb_eArgError, \"%%s: used handle after closing it\", \"%s\");\n"
 406         name;
 407       pr "\n";
 408
 409       List.iter (
 410         function
 411         | Pathname n | Device n | Dev_or_Path n | String n | Key n
 412         | FileIn n | FileOut n ->
 413             pr "  const char *%s = StringValueCStr (%sv);\n" n n;
 414         | BufferIn n ->
 415             pr "  Check_Type (%sv, T_STRING);\n" n;
 416             pr "  const char *%s = RSTRING (%sv)->ptr;\n" n n;
 417             pr "  if (!%s)\n" n;
 418             pr "    rb_raise (rb_eTypeError, \"expected string for parameter %%s of %%s\",\n";
 419             pr "              \"%s\", \"%s\");\n" n name;
 420             pr "  size_t %s_size = RSTRING (%sv)->len;\n" n n
 421         | OptString n ->
 422             pr "  const char *%s = !NIL_P (%sv) ? StringValueCStr (%sv) : NULL;\n" n n n
 423         | StringList n | DeviceList n ->
 424             pr "  char **%s;\n" n;
 425             pr "  Check_Type (%sv, T_ARRAY);\n" n;
 426             pr "  {\n";
 427             pr "    size_t i, len;\n";
 428             pr "    len = RARRAY_LEN (%sv);\n" n;
 429             pr "    %s = ALLOC_N (char *, len+1);\n"
 430               n;
 431             pr "    for (i = 0; i < len; ++i) {\n";
 432             pr "      VALUE v = rb_ary_entry (%sv, i);\n" n;
 433             pr "      %s[i] = StringValueCStr (v);\n" n;
 434             pr "    }\n";
 435             pr "    %s[len] = NULL;\n" n;
 436             pr "  }\n";
 437         | Bool n ->
 438             pr "  int %s = RTEST (%sv);\n" n n
 439         | Int n ->
 440             pr "  int %s = NUM2INT (%sv);\n" n n
 441         | Int64 n ->
 442             pr "  long long %s = NUM2LL (%sv);\n" n n
 443         | Pointer (t, n) ->
 444             pr "  %s %s = (%s) (intptr_t) NUM2LL (%sv);\n" t n t n
 445       ) args;
 446       pr "\n";
 447
 448       (* Optional arguments are passed in a final hash parameter. *)
 449       if optargs <> [] then (
 450         let uc_name = String.uppercase name in
 451         pr "  Check_Type (optargsv, T_HASH);\n";
 452         pr "  struct guestfs_%s_argv optargs_s = { .bitmask = 0 };\n" name;
 453         pr "  struct guestfs_%s_argv *optargs = &optargs_s;\n" name;
 454         pr "  VALUE v;\n";
 455         List.iter (
 456           fun argt ->
 457             let n = name_of_argt argt in
 458             let uc_n = String.uppercase n in
 459             pr "  v = rb_hash_lookup (optargsv, ID2SYM (rb_intern (\"%s\")));\n" n;
 460             pr "  if (v != Qnil) {\n";
 461             (match argt with
 462              | Bool n ->
 463                  pr "    optargs_s.%s = RTEST (v);\n" n;
 464              | Int n ->
 465                  pr "    optargs_s.%s = NUM2INT (v);\n" n;
 466              | Int64 n ->
 467                  pr "    optargs_s.%s = NUM2LL (v);\n" n;
 468              | String _ ->
 469                  pr "    optargs_s.%s = StringValueCStr (v);\n" n
 470              | _ -> assert false
 471             );
 472             pr "    optargs_s.bitmask |= GUESTFS_%s_%s_BITMASK;\n" uc_name uc_n;
 473             pr "  }\n";
 474         ) optargs;
 475         pr "\n";
 476       );
 477
 478       (match ret with
 479        | RErr | RInt _ | RBool _ -> pr "  int r;\n"
 480        | RInt64 _ -> pr "  int64_t r;\n"
 481        | RConstString _ | RConstOptString _ ->
 482            pr "  const char *r;\n"
 483        | RString _ -> pr "  char *r;\n"
 484        | RStringList _ | RHashtable _ -> pr "  char **r;\n"
 485        | RStruct (_, typ) -> pr "  struct guestfs_%s *r;\n" typ
 486        | RStructList (_, typ) ->
 487            pr "  struct guestfs_%s_list *r;\n" typ
 488        | RBufferOut _ ->
 489            pr "  char *r;\n";
 490            pr "  size_t size;\n"
 491       );
 492       pr "\n";
 493
 494       if optargs = [] then
 495         pr "  r = guestfs_%s " name
 496       else
 497         pr "  r = guestfs_%s_argv " name;
 498       generate_c_call_args ~handle:"g" style;
 499       pr ";\n";
 500
 501       List.iter (
 502         function
 503         | Pathname _ | Device _ | Dev_or_Path _ | String _ | Key _
 504         | FileIn _ | FileOut _ | OptString _ | Bool _ | Int _ | Int64 _
 505         | BufferIn _ | Pointer _ -> ()
 506         | StringList n | DeviceList n ->
 507             pr "  free (%s);\n" n
 508       ) args;
 509
 510       (match errcode_of_ret ret with
 511        | `CannotReturnError -> ()
 512        | `ErrorIsMinusOne ->
 513            pr "  if (r == -1)\n";
 514            pr "    rb_raise (e_Error, \"%%s\", guestfs_last_error (g));\n"
 515        | `ErrorIsNULL ->
 516            pr "  if (r == NULL)\n";
 517            pr "    rb_raise (e_Error, \"%%s\", guestfs_last_error (g));\n"
 518       );
 519       pr "\n";
 520
 521       (match ret with
 522        | RErr ->
 523            pr "  return Qnil;\n"
 524        | RInt _ | RBool _ ->
 525            pr "  return INT2NUM (r);\n"
 526        | RInt64 _ ->
 527            pr "  return ULL2NUM (r);\n"
 528        | RConstString _ ->
 529            pr "  return rb_str_new2 (r);\n";
 530        | RConstOptString _ ->
 531            pr "  if (r)\n";
 532            pr "    return rb_str_new2 (r);\n";
 533            pr "  else\n";
 534            pr "    return Qnil;\n";
 535        | RString _ ->
 536            pr "  VALUE rv = rb_str_new2 (r);\n";
 537            pr "  free (r);\n";
 538            pr "  return rv;\n";
 539        | RStringList _ ->
 540            pr "  size_t i, len = 0;\n";
 541            pr "  for (i = 0; r[i] != NULL; ++i) len++;\n";
 542            pr "  VALUE rv = rb_ary_new2 (len);\n";
 543            pr "  for (i = 0; r[i] != NULL; ++i) {\n";
 544            pr "    rb_ary_push (rv, rb_str_new2 (r[i]));\n";
 545            pr "    free (r[i]);\n";
 546            pr "  }\n";
 547            pr "  free (r);\n";
 548            pr "  return rv;\n"
 549        | RStruct (_, typ) ->
 550            let cols = cols_of_struct typ in
 551            generate_ruby_struct_code typ cols
 552        | RStructList (_, typ) ->
 553            let cols = cols_of_struct typ in
 554            generate_ruby_struct_list_code typ cols
 555        | RHashtable _ ->
 556            pr "  VALUE rv = rb_hash_new ();\n";
 557            pr "  size_t i;\n";
 558            pr "  for (i = 0; r[i] != NULL; i+=2) {\n";
 559            pr "    rb_hash_aset (rv, rb_str_new2 (r[i]), rb_str_new2 (r[i+1]));\n";
 560            pr "    free (r[i]);\n";
 561            pr "    free (r[i+1]);\n";
 562            pr "  }\n";
 563            pr "  free (r);\n";
 564            pr "  return rv;\n"
 565        | RBufferOut _ ->
 566            pr "  VALUE rv = rb_str_new (r, size);\n";
 567            pr "  free (r);\n";
 568            pr "  return rv;\n";
 569       );
 570
 571       pr "}\n";
 572       pr "\n"
 573   ) all_functions;
 574
 575   pr "\
 576 /* Initialize the module. */
 577 void Init__guestfs ()
 578 {
 579   m_guestfs = rb_define_module (\"Guestfs\");
 580   c_guestfs = rb_define_class_under (m_guestfs, \"Guestfs\", rb_cObject);
 581   e_Error = rb_define_class_under (m_guestfs, \"Error\", rb_eStandardError);
 582
 583 #ifdef HAVE_RB_DEFINE_ALLOC_FUNC
 584   rb_define_alloc_func (c_guestfs, ruby_guestfs_create);
 585 #endif
 586
 587   rb_define_module_function (m_guestfs, \"create\", ruby_guestfs_create, 0);
 588   rb_define_method (c_guestfs, \"close\", ruby_guestfs_close, 0);
 589   rb_define_method (c_guestfs, \"set_event_callback\",
 590                     ruby_set_event_callback, 2);
 591   rb_define_method (c_guestfs, \"delete_event_callback\",
 592                     ruby_delete_event_callback, 1);
 593   rb_define_method (c_guestfs, \"user_cancel\",
 594                     ruby_user_cancel, 0);
 595
 596 ";
 597
 598   (* Constants. *)
 599   List.iter (
 600     fun (name, bitmask) ->
 601       pr "  rb_define_const (m_guestfs, \"EVENT_%s\",\n"
 602         (String.uppercase name);
 603       pr "                   ULL2NUM (UINT64_C (0x%x)));\n" bitmask;
 604   ) events;
 605   pr "\n";
 606
 607   (* Methods. *)
 608   List.iter (
 609     fun (name, (_, args, optargs), _, _, _, _, _) ->
 610       let nr_args = List.length args + if optargs <> [] then 1 else 0 in
 611       pr "  rb_define_method (c_guestfs, \"%s\",\n" name;
 612       pr "        ruby_guestfs_%s, %d);\n" name nr_args
 613   ) all_functions;
 614
 615   pr "}\n"
 616
 617 (* Ruby code to return a struct. *)
 618 and generate_ruby_struct_code typ cols =
 619   pr "  VALUE rv = rb_hash_new ();\n";
 620   List.iter (
 621     function
 622     | name, FString ->
 623         pr "  rb_hash_aset (rv, rb_str_new2 (\"%s\"), rb_str_new2 (r->%s));\n" name name
 624     | name, FBuffer ->
 625         pr "  rb_hash_aset (rv, rb_str_new2 (\"%s\"), rb_str_new (r->%s, r->%s_len));\n" name name name
 626     | name, FUUID ->
 627         pr "  rb_hash_aset (rv, rb_str_new2 (\"%s\"), rb_str_new (r->%s, 32));\n" name name
 628     | name, (FBytes|FUInt64) ->
 629         pr "  rb_hash_aset (rv, rb_str_new2 (\"%s\"), ULL2NUM (r->%s));\n" name name
 630     | name, FInt64 ->
 631         pr "  rb_hash_aset (rv, rb_str_new2 (\"%s\"), LL2NUM (r->%s));\n" name name
 632     | name, FUInt32 ->
 633         pr "  rb_hash_aset (rv, rb_str_new2 (\"%s\"), UINT2NUM (r->%s));\n" name name
 634     | name, FInt32 ->
 635         pr "  rb_hash_aset (rv, rb_str_new2 (\"%s\"), INT2NUM (r->%s));\n" name name
 636     | name, FOptPercent ->
 637         pr "  rb_hash_aset (rv, rb_str_new2 (\"%s\"), rb_dbl2big (r->%s));\n" name name
 638     | name, FChar -> (* XXX wrong? *)
 639         pr "  rb_hash_aset (rv, rb_str_new2 (\"%s\"), ULL2NUM (r->%s));\n" name name
 640   ) cols;
 641   pr "  guestfs_free_%s (r);\n" typ;
 642   pr "  return rv;\n"
 643
 644 (* Ruby code to return a struct list. *)
 645 and generate_ruby_struct_list_code typ cols =
 646   pr "  VALUE rv = rb_ary_new2 (r->len);\n";
 647   pr "  size_t i;\n";
 648   pr "  for (i = 0; i < r->len; ++i) {\n";
 649   pr "    VALUE hv = rb_hash_new ();\n";
 650   List.iter (
 651     function
 652     | name, FString ->
 653         pr "    rb_hash_aset (hv, rb_str_new2 (\"%s\"), rb_str_new2 (r->val[i].%s));\n" name name
 654     | name, FBuffer ->
 655         pr "    rb_hash_aset (hv, rb_str_new2 (\"%s\"), rb_str_new (r->val[i].%s, r->val[i].%s_len));\n" name name name
 656     | name, FUUID ->
 657         pr "    rb_hash_aset (hv, rb_str_new2 (\"%s\"), rb_str_new (r->val[i].%s, 32));\n" name name
 658     | name, (FBytes|FUInt64) ->
 659         pr "    rb_hash_aset (hv, rb_str_new2 (\"%s\"), ULL2NUM (r->val[i].%s));\n" name name
 660     | name, FInt64 ->
 661         pr "    rb_hash_aset (hv, rb_str_new2 (\"%s\"), LL2NUM (r->val[i].%s));\n" name name
 662     | name, FUInt32 ->
 663         pr "    rb_hash_aset (hv, rb_str_new2 (\"%s\"), UINT2NUM (r->val[i].%s));\n" name name
 664     | name, FInt32 ->
 665         pr "    rb_hash_aset (hv, rb_str_new2 (\"%s\"), INT2NUM (r->val[i].%s));\n" name name
 666     | name, FOptPercent ->
 667         pr "    rb_hash_aset (hv, rb_str_new2 (\"%s\"), rb_dbl2big (r->val[i].%s));\n" name name
 668     | name, FChar -> (* XXX wrong? *)
 669         pr "    rb_hash_aset (hv, rb_str_new2 (\"%s\"), ULL2NUM (r->val[i].%s));\n" name name
 670   ) cols;
 671   pr "    rb_ary_push (rv, hv);\n";
 672   pr "  }\n";
 673   pr "  guestfs_free_%s_list (r);\n" typ;
 674   pr "  return rv;\n"