ubuntu: Add extra suppressions for libnl.1 leaks.
[libguestfs.git] / 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;
218   VALUE argv[5];
219
220   eventv = ULL2NUM (event);
221   event_handlev = INT2NUM (event_handle);
222
223   bufv = rb_str_new (buf, buf_len);
224
225   arrayv = rb_ary_new2 (array_len);
226   for (i = 0; i < array_len; ++i)
227     rb_ary_push (arrayv, ULL2NUM (array[i]));
228
229   /* This is a crap limitation of rb_rescue.
230    * http://blade.nagaokaut.ac.jp/cgi-bin/scat.rb/~poffice/mail/ruby-talk/65698
231    */
232   argv[0] = * (VALUE *) data; /* function */
233   argv[1] = eventv;
234   argv[2] = event_handlev;
235   argv[3] = bufv;
236   argv[4] = arrayv;
237
238   rb_rescue (ruby_event_callback_wrapper_wrapper, (VALUE) argv,
239              ruby_event_callback_handle_exception, Qnil);
240 }
241
242 static VALUE
243 ruby_event_callback_wrapper_wrapper (VALUE argvv)
244 {
245   VALUE *argv = (VALUE *) argvv;
246   VALUE fn, eventv, event_handlev, bufv, arrayv;
247
248   fn = argv[0];
249
250   /* Check the Ruby callback still exists.  For reasons which are not
251    * fully understood, even though we registered this as a global root,
252    * it is still possible for the callback to go away (fn value remains
253    * but its type changes from T_DATA to T_NONE).  (RHBZ#733297)
254    */
255   if (rb_type (fn) != T_NONE) {
256     eventv = argv[1];
257     event_handlev = argv[2];
258     bufv = argv[3];
259     arrayv = argv[4];
260
261     rb_funcall (fn, rb_intern (\"call\"), 4,
262                 eventv, event_handlev, bufv, arrayv);
263   }
264
265   return Qnil;
266 }
267
268 static VALUE
269 ruby_event_callback_handle_exception (VALUE not_used, VALUE exn)
270 {
271   /* Callbacks aren't supposed to throw exceptions.  The best we
272    * can do is to print the error.
273    */
274   fprintf (stderr, \"libguestfs: exception in callback: %%s\\n\",
275            StringValueCStr (exn));
276
277   return Qnil;
278 }
279
280 static VALUE **
281 get_all_event_callbacks (guestfs_h *g, size_t *len_rtn)
282 {
283   VALUE **r;
284   size_t i;
285   const char *key;
286   VALUE *root;
287
288   /* Count the length of the array that will be needed. */
289   *len_rtn = 0;
290   root = guestfs_first_private (g, &key);
291   while (root != NULL) {
292     if (strncmp (key, \"_ruby_event_\", strlen (\"_ruby_event_\")) == 0)
293       (*len_rtn)++;
294     root = guestfs_next_private (g, &key);
295   }
296
297   /* Copy them into the return array. */
298   r = guestfs_safe_malloc (g, sizeof (VALUE *) * (*len_rtn));
299
300   i = 0;
301   root = guestfs_first_private (g, &key);
302   while (root != NULL) {
303     if (strncmp (key, \"_ruby_event_\", strlen (\"_ruby_event_\")) == 0) {
304       r[i] = root;
305       i++;
306     }
307     root = guestfs_next_private (g, &key);
308   }
309
310   return r;
311 }
312
313 /*
314  * call-seq:
315  *   g.user_cancel() -> nil
316  *
317  * Call
318  * +guestfs_user_cancel+[http://libguestfs.org/guestfs.3.html#guestfs_user_cancel]
319  * to cancel the current transfer.  This is safe to call from Ruby
320  * signal handlers and threads.
321  */
322 static VALUE
323 ruby_user_cancel (VALUE gv)
324 {
325   guestfs_h *g;
326
327   Data_Get_Struct (gv, guestfs_h, g);
328   if (g)
329     guestfs_user_cancel (g);
330   return Qnil;
331 }
332
333 ";
334
335   List.iter (
336     fun (name, (ret, args, optargs as style), _, flags, _, shortdesc, longdesc) ->
337       (* Generate rdoc. *)
338       if not (List.mem NotInDocs flags); then (
339         let doc = replace_str longdesc "C<guestfs_" "C<g." in
340         let doc =
341           if optargs <> [] then
342             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."
343           else doc in
344         let doc =
345           if List.mem ProtocolLimitWarning flags then
346             doc ^ "\n\n" ^ protocol_limit_warning
347           else doc in
348         let doc =
349           match deprecation_notice flags with
350           | None -> doc
351           | Some txt -> doc ^ "\n\n" ^ txt in
352         let doc = pod2text ~width:60 name doc in
353         let doc = String.concat "\n * " doc in
354         let doc = trim doc in
355
356         let args = List.map name_of_argt args in
357         let args = if optargs <> [] then args @ ["{optargs...}"] else args in
358         let args = String.concat ", " args in
359
360         let ret =
361           match ret with
362           | RErr -> "nil"
363           | RBool _ -> "[True|False]"
364           | RInt _ -> "fixnum"
365           | RInt64 _ -> "fixnum"
366           | RConstString _ -> "string"
367           | RConstOptString _ -> "string"
368           | RString _ -> "string"
369           | RBufferOut _ -> "string"
370           | RStruct _
371           | RHashtable _ -> "hash"
372           | RStringList _
373           | RStructList _ -> "list" in
374
375         pr "\
376 /*
377  * call-seq:
378  *   g.%s(%s) -> %s
379  *
380  * %s
381  *
382  * %s
383  *
384  * (For the C API documentation for this function, see
385  * +guestfs_%s+[http://libguestfs.org/guestfs.3.html#guestfs_%s]).
386  */
387 " name args ret shortdesc doc name name
388       );
389
390       (* Generate the function. *)
391       pr "static VALUE\n";
392       pr "ruby_guestfs_%s (VALUE gv" name;
393       List.iter (fun arg -> pr ", VALUE %sv" (name_of_argt arg)) args;
394       (* XXX This makes the hash mandatory, meaning that you have
395        * to specify {} for no arguments.  We could make it so this
396        * can be omitted.  However that is a load of hassle because
397        * you have to completely change the way that arguments are
398        * passed in.  See:
399        * http://www.redhat.com/archives/libvir-list/2008-April/msg00004.html
400        *)
401       if optargs <> [] then
402         pr ", VALUE optargsv";
403       pr ")\n";
404       pr "{\n";
405       pr "  guestfs_h *g;\n";
406       pr "  Data_Get_Struct (gv, guestfs_h, g);\n";
407       pr "  if (!g)\n";
408       pr "    rb_raise (rb_eArgError, \"%%s: used handle after closing it\", \"%s\");\n"
409         name;
410       pr "\n";
411
412       List.iter (
413         function
414         | Pathname n | Device n | Dev_or_Path n | String n | Key n
415         | FileIn n | FileOut n ->
416             pr "  const char *%s = StringValueCStr (%sv);\n" n n;
417         | BufferIn n ->
418             pr "  Check_Type (%sv, T_STRING);\n" n;
419             pr "  const char *%s = RSTRING (%sv)->ptr;\n" n n;
420             pr "  if (!%s)\n" n;
421             pr "    rb_raise (rb_eTypeError, \"expected string for parameter %%s of %%s\",\n";
422             pr "              \"%s\", \"%s\");\n" n name;
423             pr "  size_t %s_size = RSTRING (%sv)->len;\n" n n
424         | OptString n ->
425             pr "  const char *%s = !NIL_P (%sv) ? StringValueCStr (%sv) : NULL;\n" n n n
426         | StringList n | DeviceList n ->
427             pr "  char **%s;\n" n;
428             pr "  Check_Type (%sv, T_ARRAY);\n" n;
429             pr "  {\n";
430             pr "    size_t i, len;\n";
431             pr "    len = RARRAY_LEN (%sv);\n" n;
432             pr "    %s = ALLOC_N (char *, len+1);\n"
433               n;
434             pr "    for (i = 0; i < len; ++i) {\n";
435             pr "      VALUE v = rb_ary_entry (%sv, i);\n" n;
436             pr "      %s[i] = StringValueCStr (v);\n" n;
437             pr "    }\n";
438             pr "    %s[len] = NULL;\n" n;
439             pr "  }\n";
440         | Bool n ->
441             pr "  int %s = RTEST (%sv);\n" n n
442         | Int n ->
443             pr "  int %s = NUM2INT (%sv);\n" n n
444         | Int64 n ->
445             pr "  long long %s = NUM2LL (%sv);\n" n n
446         | Pointer (t, n) ->
447             pr "  %s %s = (%s) (intptr_t) NUM2LL (%sv);\n" t n t n
448       ) args;
449       pr "\n";
450
451       (* Optional arguments are passed in a final hash parameter. *)
452       if optargs <> [] then (
453         let uc_name = String.uppercase name in
454         pr "  Check_Type (optargsv, T_HASH);\n";
455         pr "  struct guestfs_%s_argv optargs_s = { .bitmask = 0 };\n" name;
456         pr "  struct guestfs_%s_argv *optargs = &optargs_s;\n" name;
457         pr "  VALUE v;\n";
458         List.iter (
459           fun argt ->
460             let n = name_of_argt argt in
461             let uc_n = String.uppercase n in
462             pr "  v = rb_hash_lookup (optargsv, ID2SYM (rb_intern (\"%s\")));\n" n;
463             pr "  if (v != Qnil) {\n";
464             (match argt with
465              | Bool n ->
466                  pr "    optargs_s.%s = RTEST (v);\n" n;
467              | Int n ->
468                  pr "    optargs_s.%s = NUM2INT (v);\n" n;
469              | Int64 n ->
470                  pr "    optargs_s.%s = NUM2LL (v);\n" n;
471              | String _ ->
472                  pr "    optargs_s.%s = StringValueCStr (v);\n" n
473              | _ -> assert false
474             );
475             pr "    optargs_s.bitmask |= GUESTFS_%s_%s_BITMASK;\n" uc_name uc_n;
476             pr "  }\n";
477         ) optargs;
478         pr "\n";
479       );
480
481       (match ret with
482        | RErr | RInt _ | RBool _ -> pr "  int r;\n"
483        | RInt64 _ -> pr "  int64_t r;\n"
484        | RConstString _ | RConstOptString _ ->
485            pr "  const char *r;\n"
486        | RString _ -> pr "  char *r;\n"
487        | RStringList _ | RHashtable _ -> pr "  char **r;\n"
488        | RStruct (_, typ) -> pr "  struct guestfs_%s *r;\n" typ
489        | RStructList (_, typ) ->
490            pr "  struct guestfs_%s_list *r;\n" typ
491        | RBufferOut _ ->
492            pr "  char *r;\n";
493            pr "  size_t size;\n"
494       );
495       pr "\n";
496
497       if optargs = [] then
498         pr "  r = guestfs_%s " name
499       else
500         pr "  r = guestfs_%s_argv " name;
501       generate_c_call_args ~handle:"g" style;
502       pr ";\n";
503
504       List.iter (
505         function
506         | Pathname _ | Device _ | Dev_or_Path _ | String _ | Key _
507         | FileIn _ | FileOut _ | OptString _ | Bool _ | Int _ | Int64 _
508         | BufferIn _ | Pointer _ -> ()
509         | StringList n | DeviceList n ->
510             pr "  free (%s);\n" n
511       ) args;
512
513       (match errcode_of_ret ret with
514        | `CannotReturnError -> ()
515        | `ErrorIsMinusOne ->
516            pr "  if (r == -1)\n";
517            pr "    rb_raise (e_Error, \"%%s\", guestfs_last_error (g));\n"
518        | `ErrorIsNULL ->
519            pr "  if (r == NULL)\n";
520            pr "    rb_raise (e_Error, \"%%s\", guestfs_last_error (g));\n"
521       );
522       pr "\n";
523
524       (match ret with
525        | RErr ->
526            pr "  return Qnil;\n"
527        | RInt _ | RBool _ ->
528            pr "  return INT2NUM (r);\n"
529        | RInt64 _ ->
530            pr "  return ULL2NUM (r);\n"
531        | RConstString _ ->
532            pr "  return rb_str_new2 (r);\n";
533        | RConstOptString _ ->
534            pr "  if (r)\n";
535            pr "    return rb_str_new2 (r);\n";
536            pr "  else\n";
537            pr "    return Qnil;\n";
538        | RString _ ->
539            pr "  VALUE rv = rb_str_new2 (r);\n";
540            pr "  free (r);\n";
541            pr "  return rv;\n";
542        | RStringList _ ->
543            pr "  size_t i, len = 0;\n";
544            pr "  for (i = 0; r[i] != NULL; ++i) len++;\n";
545            pr "  VALUE rv = rb_ary_new2 (len);\n";
546            pr "  for (i = 0; r[i] != NULL; ++i) {\n";
547            pr "    rb_ary_push (rv, rb_str_new2 (r[i]));\n";
548            pr "    free (r[i]);\n";
549            pr "  }\n";
550            pr "  free (r);\n";
551            pr "  return rv;\n"
552        | RStruct (_, typ) ->
553            let cols = cols_of_struct typ in
554            generate_ruby_struct_code typ cols
555        | RStructList (_, typ) ->
556            let cols = cols_of_struct typ in
557            generate_ruby_struct_list_code typ cols
558        | RHashtable _ ->
559            pr "  VALUE rv = rb_hash_new ();\n";
560            pr "  size_t i;\n";
561            pr "  for (i = 0; r[i] != NULL; i+=2) {\n";
562            pr "    rb_hash_aset (rv, rb_str_new2 (r[i]), rb_str_new2 (r[i+1]));\n";
563            pr "    free (r[i]);\n";
564            pr "    free (r[i+1]);\n";
565            pr "  }\n";
566            pr "  free (r);\n";
567            pr "  return rv;\n"
568        | RBufferOut _ ->
569            pr "  VALUE rv = rb_str_new (r, size);\n";
570            pr "  free (r);\n";
571            pr "  return rv;\n";
572       );
573
574       pr "}\n";
575       pr "\n"
576   ) all_functions;
577
578   pr "\
579 /* Initialize the module. */
580 void Init__guestfs ()
581 {
582   m_guestfs = rb_define_module (\"Guestfs\");
583   c_guestfs = rb_define_class_under (m_guestfs, \"Guestfs\", rb_cObject);
584   e_Error = rb_define_class_under (m_guestfs, \"Error\", rb_eStandardError);
585
586 #ifdef HAVE_RB_DEFINE_ALLOC_FUNC
587   rb_define_alloc_func (c_guestfs, ruby_guestfs_create);
588 #endif
589
590   rb_define_module_function (m_guestfs, \"create\", ruby_guestfs_create, 0);
591   rb_define_method (c_guestfs, \"close\", ruby_guestfs_close, 0);
592   rb_define_method (c_guestfs, \"set_event_callback\",
593                     ruby_set_event_callback, 2);
594   rb_define_method (c_guestfs, \"delete_event_callback\",
595                     ruby_delete_event_callback, 1);
596   rb_define_method (c_guestfs, \"user_cancel\",
597                     ruby_user_cancel, 0);
598
599 ";
600
601   (* Constants. *)
602   List.iter (
603     fun (name, bitmask) ->
604       pr "  rb_define_const (m_guestfs, \"EVENT_%s\",\n"
605         (String.uppercase name);
606       pr "                   ULL2NUM (UINT64_C (0x%x)));\n" bitmask;
607   ) events;
608   pr "\n";
609
610   (* Methods. *)
611   List.iter (
612     fun (name, (_, args, optargs), _, _, _, _, _) ->
613       let nr_args = List.length args + if optargs <> [] then 1 else 0 in
614       pr "  rb_define_method (c_guestfs, \"%s\",\n" name;
615       pr "        ruby_guestfs_%s, %d);\n" name nr_args
616   ) all_functions;
617
618   pr "}\n"
619
620 (* Ruby code to return a struct. *)
621 and generate_ruby_struct_code typ cols =
622   pr "  VALUE rv = rb_hash_new ();\n";
623   List.iter (
624     function
625     | name, FString ->
626         pr "  rb_hash_aset (rv, rb_str_new2 (\"%s\"), rb_str_new2 (r->%s));\n" name name
627     | name, FBuffer ->
628         pr "  rb_hash_aset (rv, rb_str_new2 (\"%s\"), rb_str_new (r->%s, r->%s_len));\n" name name name
629     | name, FUUID ->
630         pr "  rb_hash_aset (rv, rb_str_new2 (\"%s\"), rb_str_new (r->%s, 32));\n" name name
631     | name, (FBytes|FUInt64) ->
632         pr "  rb_hash_aset (rv, rb_str_new2 (\"%s\"), ULL2NUM (r->%s));\n" name name
633     | name, FInt64 ->
634         pr "  rb_hash_aset (rv, rb_str_new2 (\"%s\"), LL2NUM (r->%s));\n" name name
635     | name, FUInt32 ->
636         pr "  rb_hash_aset (rv, rb_str_new2 (\"%s\"), UINT2NUM (r->%s));\n" name name
637     | name, FInt32 ->
638         pr "  rb_hash_aset (rv, rb_str_new2 (\"%s\"), INT2NUM (r->%s));\n" name name
639     | name, FOptPercent ->
640         pr "  rb_hash_aset (rv, rb_str_new2 (\"%s\"), rb_dbl2big (r->%s));\n" name name
641     | name, FChar -> (* XXX wrong? *)
642         pr "  rb_hash_aset (rv, rb_str_new2 (\"%s\"), ULL2NUM (r->%s));\n" name name
643   ) cols;
644   pr "  guestfs_free_%s (r);\n" typ;
645   pr "  return rv;\n"
646
647 (* Ruby code to return a struct list. *)
648 and generate_ruby_struct_list_code typ cols =
649   pr "  VALUE rv = rb_ary_new2 (r->len);\n";
650   pr "  size_t i;\n";
651   pr "  for (i = 0; i < r->len; ++i) {\n";
652   pr "    VALUE hv = rb_hash_new ();\n";
653   List.iter (
654     function
655     | name, FString ->
656         pr "    rb_hash_aset (hv, rb_str_new2 (\"%s\"), rb_str_new2 (r->val[i].%s));\n" name name
657     | name, FBuffer ->
658         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
659     | name, FUUID ->
660         pr "    rb_hash_aset (hv, rb_str_new2 (\"%s\"), rb_str_new (r->val[i].%s, 32));\n" name name
661     | name, (FBytes|FUInt64) ->
662         pr "    rb_hash_aset (hv, rb_str_new2 (\"%s\"), ULL2NUM (r->val[i].%s));\n" name name
663     | name, FInt64 ->
664         pr "    rb_hash_aset (hv, rb_str_new2 (\"%s\"), LL2NUM (r->val[i].%s));\n" name name
665     | name, FUInt32 ->
666         pr "    rb_hash_aset (hv, rb_str_new2 (\"%s\"), UINT2NUM (r->val[i].%s));\n" name name
667     | name, FInt32 ->
668         pr "    rb_hash_aset (hv, rb_str_new2 (\"%s\"), INT2NUM (r->val[i].%s));\n" name name
669     | name, FOptPercent ->
670         pr "    rb_hash_aset (hv, rb_str_new2 (\"%s\"), rb_dbl2big (r->val[i].%s));\n" name name
671     | name, FChar -> (* XXX wrong? *)
672         pr "    rb_hash_aset (hv, rb_str_new2 (\"%s\"), ULL2NUM (r->val[i].%s));\n" name name
673   ) cols;
674   pr "    rb_ary_push (rv, hv);\n";
675   pr "  }\n";
676   pr "  guestfs_free_%s_list (r);\n" typ;
677   pr "  return rv;\n"