generator/generator_java.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
  32 (* Generate Java bindings GuestFS.java file. *)
  33 let rec generate_java_java () =
  34   generate_header CStyle LGPLv2plus;
  35
  36   pr "\
  37 package com.redhat.et.libguestfs;
  38
  39 import java.util.HashMap;
  40 import java.util.Map;
  41 import com.redhat.et.libguestfs.LibGuestFSException;
  42 import com.redhat.et.libguestfs.PV;
  43 import com.redhat.et.libguestfs.VG;
  44 import com.redhat.et.libguestfs.LV;
  45 import com.redhat.et.libguestfs.Stat;
  46 import com.redhat.et.libguestfs.StatVFS;
  47 import com.redhat.et.libguestfs.IntBool;
  48 import com.redhat.et.libguestfs.Dirent;
  49
  50 /**
  51  * The GuestFS object is a libguestfs handle.
  52  *
  53  * @author rjones
  54  */
  55 public class GuestFS {
  56   // Load the native code.
  57   static {
  58     System.loadLibrary (\"guestfs_jni\");
  59   }
  60
  61   /**
  62    * The native guestfs_h pointer.
  63    */
  64   long g;
  65
  66   /**
  67    * Create a libguestfs handle.
  68    *
  69    * @throws LibGuestFSException
  70    */
  71   public GuestFS () throws LibGuestFSException
  72   {
  73     g = _create ();
  74   }
  75   private native long _create () throws LibGuestFSException;
  76
  77   /**
  78    * Close a libguestfs handle.
  79    *
  80    * You can also leave handles to be collected by the garbage
  81    * collector, but this method ensures that the resources used
  82    * by the handle are freed up immediately.  If you call any
  83    * other methods after closing the handle, you will get an
  84    * exception.
  85    *
  86    * @throws LibGuestFSException
  87    */
  88   public void close () throws LibGuestFSException
  89   {
  90     if (g != 0)
  91       _close (g);
  92     g = 0;
  93   }
  94   private native void _close (long g) throws LibGuestFSException;
  95
  96   public void finalize () throws LibGuestFSException
  97   {
  98     close ();
  99   }
 100
 101 ";
 102
 103   List.iter (
 104     fun (name, (ret, args, optargs as style), _, flags, _, shortdesc, longdesc) ->
 105       if not (List.mem NotInDocs flags); then (
 106         let doc = replace_str longdesc "C<guestfs_" "C<g." in
 107         let doc =
 108           if optargs <> [] then
 109             doc ^ "\n\nOptional arguments are supplied in the final Map<String,Object> parameter, which is a hash of the argument name to its value (cast to Object).  Pass an empty Map or null for no optional arguments."
 110           else doc in
 111         let doc =
 112           if List.mem ProtocolLimitWarning flags then
 113             doc ^ "\n\n" ^ protocol_limit_warning
 114           else doc in
 115         let doc =
 116           if List.mem DangerWillRobinson flags then
 117             doc ^ "\n\n" ^ danger_will_robinson
 118           else doc in
 119         let doc =
 120           match deprecation_notice flags with
 121           | None -> doc
 122           | Some txt -> doc ^ "\n\n" ^ txt in
 123         let doc = pod2text ~width:60 name doc in
 124         let doc = List.map (            (* RHBZ#501883 *)
 125           function
 126           | "" -> "<p>"
 127           | nonempty -> nonempty
 128         ) doc in
 129         let doc = String.concat "\n   * " doc in
 130
 131         pr "  /**\n";
 132         pr "   * %s\n" shortdesc;
 133         pr "   * <p>\n";
 134         pr "   * %s\n" doc;
 135         pr "   * @throws LibGuestFSException\n";
 136         pr "   */\n";
 137       );
 138       pr "  ";
 139       generate_java_prototype ~public:true ~semicolon:false name style;
 140       pr "\n";
 141       pr "  {\n";
 142       pr "    if (g == 0)\n";
 143       pr "      throw new LibGuestFSException (\"%s: handle is closed\");\n"
 144         name;
 145       if optargs <> [] then (
 146         pr "\n";
 147         pr "    /* Unpack optional args. */\n";
 148         pr "    Object _optobj;\n";
 149         pr "    long _optargs_bitmask = 0;\n";
 150         iteri (
 151           fun i argt ->
 152             let t, boxed_t, convert, n, default =
 153               match argt with
 154               | Bool n -> "boolean", "Boolean", ".booleanValue()", n, "false"
 155               | Int n -> "int", "Integer", ".intValue()", n, "0"
 156               | Int64 n -> "long", "Long", ".longValue()", n, "0"
 157               | String n -> "String", "String", "", n, "\"\""
 158               | _ -> assert false in
 159             pr "    %s %s = %s;\n" t n default;
 160             pr "    _optobj = null;\n";
 161             pr "    if (optargs != null)\n";
 162             pr "      _optobj = optargs.get (\"%s\");\n" n;
 163             pr "    if (_optobj != null) {\n";
 164             pr "      %s = ((%s) _optobj)%s;\n" n boxed_t convert;
 165             pr "      _optargs_bitmask |= %Ld;\n"
 166               (Int64.shift_left Int64.one i);
 167             pr "    }\n";
 168         ) optargs
 169       );
 170       pr "\n";
 171       (match ret with
 172        | RErr ->
 173            pr "    _%s " name;
 174            generate_java_call_args ~handle:"g" style;
 175            pr ";\n"
 176        | RHashtable _ ->
 177            pr "    String[] r = _%s " name;
 178            generate_java_call_args ~handle:"g" style;
 179            pr ";\n";
 180            pr "\n";
 181            pr "    HashMap rhash = new HashMap ();\n";
 182            pr "    for (int i = 0; i < r.length; i += 2)\n";
 183            pr "      rhash.put (r[i], r[i+1]);\n";
 184            pr "    return rhash;\n"
 185        | _ ->
 186            pr "    return _%s " name;
 187            generate_java_call_args ~handle:"g" style;
 188            pr ";\n"
 189       );
 190       pr "  }\n";
 191       pr "\n";
 192       pr "  ";
 193       generate_java_prototype ~privat:true ~native:true name style;
 194       pr "\n";
 195       pr "\n";
 196   ) all_functions;
 197
 198   pr "}\n"
 199
 200 (* Generate Java call arguments, eg "(handle, foo, bar)" *)
 201 and generate_java_call_args ~handle (_, args, optargs) =
 202   pr "(%s" handle;
 203   List.iter (fun arg -> pr ", %s" (name_of_argt arg)) args;
 204   if optargs <> [] then (
 205     pr ", _optargs_bitmask";
 206     List.iter (fun arg -> pr ", %s" (name_of_argt arg)) optargs
 207   );
 208   pr ")"
 209
 210 and generate_java_prototype ?(public=false) ?(privat=false) ?(native=false)
 211     ?(semicolon=true) name (ret, args, optargs) =
 212   if privat then pr "private ";
 213   if public then pr "public ";
 214   if native then pr "native ";
 215
 216   (* return type *)
 217   (match ret with
 218    | RErr -> pr "void ";
 219    | RInt _ -> pr "int ";
 220    | RInt64 _ -> pr "long ";
 221    | RBool _ -> pr "boolean ";
 222    | RConstString _ | RConstOptString _ | RString _
 223    | RBufferOut _ -> pr "String ";
 224    | RStringList _ -> pr "String[] ";
 225    | RStruct (_, typ) ->
 226        let name = java_name_of_struct typ in
 227        pr "%s " name;
 228    | RStructList (_, typ) ->
 229        let name = java_name_of_struct typ in
 230        pr "%s[] " name;
 231    | RHashtable _ ->
 232        if not native then
 233          pr "Map<String,String> "
 234        else
 235          pr "String[] ";
 236   );
 237
 238   if native then pr "_%s " name else pr "%s " name;
 239   pr "(";
 240   let needs_comma = ref false in
 241   if native then (
 242     pr "long g";
 243     needs_comma := true
 244   );
 245
 246   (* args *)
 247   List.iter (
 248     fun arg ->
 249       if !needs_comma then pr ", ";
 250       needs_comma := true;
 251
 252       match arg with
 253       | Pathname n
 254       | Device n | Dev_or_Path n
 255       | String n
 256       | OptString n
 257       | FileIn n
 258       | FileOut n
 259       | Key n ->
 260           pr "String %s" n
 261       | BufferIn n ->
 262           pr "byte[] %s" n
 263       | StringList n | DeviceList n ->
 264           pr "String[] %s" n
 265       | Bool n ->
 266           pr "boolean %s" n
 267       | Int n ->
 268           pr "int %s" n
 269       | Int64 n | Pointer (_, n) ->
 270           pr "long %s" n
 271   ) args;
 272
 273   if optargs <> [] then (
 274     if !needs_comma then pr ", ";
 275     needs_comma := true;
 276
 277     if not native then
 278       pr "Map<String, Object> optargs"
 279     else (
 280       pr "long _optargs_bitmask";
 281       List.iter (
 282         fun argt ->
 283           match argt with
 284           | Bool n -> pr ", boolean %s" n
 285           | Int n -> pr ", int %s" n
 286           | Int64 n -> pr ", long %s" n
 287           | String n -> pr ", String %s" n
 288           | _ -> assert false
 289       ) optargs
 290     )
 291   );
 292
 293   pr ")\n";
 294   pr "    throws LibGuestFSException";
 295   if semicolon then pr ";"
 296
 297 and generate_java_struct jtyp cols () =
 298   generate_header CStyle LGPLv2plus;
 299
 300   pr "\
 301 package com.redhat.et.libguestfs;
 302
 303 /**
 304  * Libguestfs %s structure.
 305  *
 306  * @author rjones
 307  * @see GuestFS
 308  */
 309 public class %s {
 310 " jtyp jtyp;
 311
 312   List.iter (
 313     function
 314     | name, FString
 315     | name, FUUID
 316     | name, FBuffer -> pr "  public String %s;\n" name
 317     | name, (FBytes|FUInt64|FInt64) -> pr "  public long %s;\n" name
 318     | name, (FUInt32|FInt32) -> pr "  public int %s;\n" name
 319     | name, FChar -> pr "  public char %s;\n" name
 320     | name, FOptPercent ->
 321         pr "  /* The next field is [0..100] or -1 meaning 'not present': */\n";
 322         pr "  public float %s;\n" name
 323   ) cols;
 324
 325   pr "}\n"
 326
 327 and generate_java_c () =
 328   generate_header CStyle LGPLv2plus;
 329
 330   pr "\
 331 #include <stdio.h>
 332 #include <stdlib.h>
 333 #include <string.h>
 334
 335 #include \"com_redhat_et_libguestfs_GuestFS.h\"
 336 #include \"guestfs.h\"
 337
 338 /* Note that this function returns.  The exception is not thrown
 339  * until after the wrapper function returns.
 340  */
 341 static void
 342 throw_exception (JNIEnv *env, const char *msg)
 343 {
 344   jclass cl;
 345   cl = (*env)->FindClass (env,
 346                           \"com/redhat/et/libguestfs/LibGuestFSException\");
 347   (*env)->ThrowNew (env, cl, msg);
 348 }
 349
 350 JNIEXPORT jlong JNICALL
 351 Java_com_redhat_et_libguestfs_GuestFS__1create
 352   (JNIEnv *env, jobject obj)
 353 {
 354   guestfs_h *g;
 355
 356   g = guestfs_create ();
 357   if (g == NULL) {
 358     throw_exception (env, \"GuestFS.create: failed to allocate handle\");
 359     return 0;
 360   }
 361   guestfs_set_error_handler (g, NULL, NULL);
 362   return (jlong) (long) g;
 363 }
 364
 365 JNIEXPORT void JNICALL
 366 Java_com_redhat_et_libguestfs_GuestFS__1close
 367   (JNIEnv *env, jobject obj, jlong jg)
 368 {
 369   guestfs_h *g = (guestfs_h *) (long) jg;
 370   guestfs_close (g);
 371 }
 372
 373 ";
 374
 375   List.iter (
 376     fun (name, (ret, args, optargs as style), _, _, _, _, _) ->
 377       pr "JNIEXPORT ";
 378       (match ret with
 379        | RErr -> pr "void ";
 380        | RInt _ -> pr "jint ";
 381        | RInt64 _ -> pr "jlong ";
 382        | RBool _ -> pr "jboolean ";
 383        | RConstString _ | RConstOptString _ | RString _
 384        | RBufferOut _ -> pr "jstring ";
 385        | RStruct _ | RHashtable _ ->
 386            pr "jobject ";
 387        | RStringList _ | RStructList _ ->
 388            pr "jobjectArray ";
 389       );
 390       pr "JNICALL\n";
 391       pr "Java_com_redhat_et_libguestfs_GuestFS_";
 392       pr "%s" (replace_str ("_" ^ name) "_" "_1");
 393       pr "  (JNIEnv *env, jobject obj, jlong jg";
 394       List.iter (
 395         function
 396         | Pathname n
 397         | Device n | Dev_or_Path n
 398         | String n
 399         | OptString n
 400         | FileIn n
 401         | FileOut n
 402         | Key n ->
 403             pr ", jstring j%s" n
 404         | BufferIn n ->
 405             pr ", jbyteArray j%s" n
 406         | StringList n | DeviceList n ->
 407             pr ", jobjectArray j%s" n
 408         | Bool n ->
 409             pr ", jboolean j%s" n
 410         | Int n ->
 411             pr ", jint j%s" n
 412         | Int64 n | Pointer (_, n) ->
 413             pr ", jlong j%s" n
 414       ) args;
 415       if optargs <> [] then (
 416         pr ", jlong joptargs_bitmask";
 417         List.iter (
 418           function
 419           | Bool n -> pr ", jboolean j%s" n
 420           | Int n -> pr ", jint j%s" n
 421           | Int64 n -> pr ", jlong j%s" n
 422           | String n -> pr ", jstring j%s" n
 423           | _ -> assert false
 424         ) optargs
 425       );
 426       pr ")\n";
 427       pr "{\n";
 428       pr "  guestfs_h *g = (guestfs_h *) (long) jg;\n";
 429       (match ret with
 430        | RErr -> pr "  int r;\n"
 431        | RBool _
 432        | RInt _ -> pr "  int r;\n"
 433        | RInt64 _ -> pr "  int64_t r;\n"
 434        | RConstString _ -> pr "  const char *r;\n"
 435        | RConstOptString _ -> pr "  const char *r;\n"
 436        | RString _ ->
 437            pr "  jstring jr;\n";
 438            pr "  char *r;\n"
 439        | RStringList _
 440        | RHashtable _ ->
 441            pr "  jobjectArray jr;\n";
 442            pr "  size_t r_len;\n";
 443            pr "  jclass cl;\n";
 444            pr "  jstring jstr;\n";
 445            pr "  char **r;\n"
 446        | RStruct (_, typ) ->
 447            pr "  jobject jr;\n";
 448            pr "  jclass cl;\n";
 449            pr "  jfieldID fl;\n";
 450            pr "  struct guestfs_%s *r;\n" typ
 451        | RStructList (_, typ) ->
 452            pr "  jobjectArray jr;\n";
 453            pr "  jclass cl;\n";
 454            pr "  jfieldID fl;\n";
 455            pr "  jobject jfl;\n";
 456            pr "  struct guestfs_%s_list *r;\n" typ
 457        | RBufferOut _ ->
 458            pr "  jstring jr;\n";
 459            pr "  char *r;\n";
 460            pr "  size_t size;\n"
 461       );
 462
 463       List.iter (
 464         function
 465         | Pathname n
 466         | Device n | Dev_or_Path n
 467         | String n
 468         | OptString n
 469         | FileIn n
 470         | FileOut n
 471         | Key n ->
 472             pr "  const char *%s;\n" n
 473         | BufferIn n ->
 474             pr "  char *%s;\n" n;
 475             pr "  size_t %s_size;\n" n
 476         | StringList n | DeviceList n ->
 477             pr "  size_t %s_len;\n" n;
 478             pr "  char **%s;\n" n
 479         | Bool n
 480         | Int n ->
 481             pr "  int %s;\n" n
 482         | Int64 n ->
 483             pr "  int64_t %s;\n" n
 484         | Pointer (t, n) ->
 485             pr "  %s %s;\n" t n
 486       ) args;
 487
 488       if optargs <> [] then (
 489         pr "  struct guestfs_%s_argv optargs_s;\n" name;
 490         pr "  const struct guestfs_%s_argv *optargs = &optargs_s;\n" name
 491       );
 492
 493       let needs_i =
 494         (match ret with
 495          | RStringList _ | RStructList _ | RHashtable _ -> true
 496          | RErr | RBool _ | RInt _ | RInt64 _ | RConstString _
 497          | RConstOptString _
 498          | RString _ | RBufferOut _ | RStruct _ -> false) ||
 499           List.exists (function
 500                        | StringList _ -> true
 501                        | DeviceList _ -> true
 502                        | _ -> false) args in
 503       if needs_i then
 504         pr "  size_t i;\n";
 505
 506       pr "\n";
 507
 508       (* Get the parameters. *)
 509       List.iter (
 510         function
 511         | Pathname n
 512         | Device n | Dev_or_Path n
 513         | String n
 514         | FileIn n
 515         | FileOut n
 516         | Key n ->
 517             pr "  %s = (*env)->GetStringUTFChars (env, j%s, NULL);\n" n n
 518         | OptString n ->
 519             (* This is completely undocumented, but Java null becomes
 520              * a NULL parameter.
 521              *)
 522             pr "  %s = j%s ? (*env)->GetStringUTFChars (env, j%s, NULL) : NULL;\n" n n n
 523         | BufferIn n ->
 524             pr "  %s = (char *) (*env)->GetByteArrayElements (env, j%s, NULL);\n" n n;
 525             pr "  %s_size = (*env)->GetArrayLength (env, j%s);\n" n n
 526         | StringList n | DeviceList n ->
 527             pr "  %s_len = (*env)->GetArrayLength (env, j%s);\n" n n;
 528             pr "  %s = guestfs_safe_malloc (g, sizeof (char *) * (%s_len+1));\n" n n;
 529             pr "  for (i = 0; i < %s_len; ++i) {\n" n;
 530             pr "    jobject o = (*env)->GetObjectArrayElement (env, j%s, i);\n"
 531               n;
 532             pr "    %s[i] = (char *) (*env)->GetStringUTFChars (env, o, NULL);\n" n;
 533             pr "  }\n";
 534             pr "  %s[%s_len] = NULL;\n" n n;
 535         | Bool n
 536         | Int n
 537         | Int64 n ->
 538             pr "  %s = j%s;\n" n n
 539         | Pointer (t, n) ->
 540             pr "  %s = (%s) j%s;\n" n t n
 541       ) args;
 542
 543       if optargs <> [] then (
 544         pr "  optargs_s.bitmask = joptargs_bitmask;\n";
 545         List.iter (
 546           function
 547           | Bool n
 548           | Int n
 549           | Int64 n ->
 550               pr "  optargs_s.%s = j%s;\n" n n
 551           | String n ->
 552               pr "  optargs_s.%s = (*env)->GetStringUTFChars (env, j%s, NULL);\n"
 553                 n n
 554           | _ -> assert false
 555         ) optargs;
 556       );
 557
 558       pr "\n";
 559
 560       (* Make the call. *)
 561       if optargs = [] then
 562         pr "  r = guestfs_%s " name
 563       else
 564         pr "  r = guestfs_%s_argv " name;
 565       generate_c_call_args ~handle:"g" style;
 566       pr ";\n";
 567
 568       pr "\n";
 569
 570       (* Release the parameters. *)
 571       List.iter (
 572         function
 573         | Pathname n
 574         | Device n | Dev_or_Path n
 575         | String n
 576         | FileIn n
 577         | FileOut n
 578         | Key n ->
 579             pr "  (*env)->ReleaseStringUTFChars (env, j%s, %s);\n" n n
 580         | OptString n ->
 581             pr "  if (j%s)\n" n;
 582             pr "    (*env)->ReleaseStringUTFChars (env, j%s, %s);\n" n n
 583         | BufferIn n ->
 584             pr "  (*env)->ReleaseByteArrayElements (env, j%s, (jbyte *) %s, 0);\n" n n
 585         | StringList n | DeviceList n ->
 586             pr "  for (i = 0; i < %s_len; ++i) {\n" n;
 587             pr "    jobject o = (*env)->GetObjectArrayElement (env, j%s, i);\n"
 588               n;
 589             pr "    (*env)->ReleaseStringUTFChars (env, o, %s[i]);\n" n;
 590             pr "  }\n";
 591             pr "  free (%s);\n" n
 592         | Bool _
 593         | Int _
 594         | Int64 _
 595         | Pointer _ -> ()
 596       ) args;
 597
 598       List.iter (
 599         function
 600         | Bool n
 601         | Int n
 602         | Int64 n -> ()
 603         | String n ->
 604             pr "  (*env)->ReleaseStringUTFChars (env, j%s, optargs_s.%s);\n" n n
 605         | _ -> assert false
 606       ) optargs;
 607
 608       pr "\n";
 609
 610       (* Check for errors. *)
 611       (match errcode_of_ret ret with
 612        | `CannotReturnError -> ()
 613        | (`ErrorIsMinusOne|`ErrorIsNULL) as errcode ->
 614            (match errcode with
 615             | `ErrorIsMinusOne ->
 616                 pr "  if (r == -1) {\n";
 617             | `ErrorIsNULL ->
 618                 pr "  if (r == NULL) {\n";
 619            );
 620            pr "    throw_exception (env, guestfs_last_error (g));\n";
 621            (match ret with
 622             | RErr ->
 623                 pr "    return;\n"
 624             | RInt _
 625             | RInt64 _
 626             | RBool _ ->
 627                 pr "    return -1;\n"
 628             | RConstString _ | RConstOptString _ | RString _
 629             | RBufferOut _
 630             | RStruct _ | RHashtable _
 631             | RStringList _ | RStructList _ ->
 632                 pr "    return NULL;\n"
 633            );
 634            pr "  }\n"
 635       );
 636
 637       (* Return value. *)
 638       (match ret with
 639        | RErr -> ()
 640        | RInt _ -> pr "  return (jint) r;\n"
 641        | RBool _ -> pr "  return (jboolean) r;\n"
 642        | RInt64 _ -> pr "  return (jlong) r;\n"
 643        | RConstString _ -> pr "  return (*env)->NewStringUTF (env, r);\n"
 644        | RConstOptString _ ->
 645            pr "  return (*env)->NewStringUTF (env, r); /* XXX r NULL? */\n"
 646        | RString _ ->
 647            pr "  jr = (*env)->NewStringUTF (env, r);\n";
 648            pr "  free (r);\n";
 649            pr "  return jr;\n"
 650        | RStringList _
 651        | RHashtable _ ->
 652            pr "  for (r_len = 0; r[r_len] != NULL; ++r_len) ;\n";
 653            pr "  cl = (*env)->FindClass (env, \"java/lang/String\");\n";
 654            pr "  jstr = (*env)->NewStringUTF (env, \"\");\n";
 655            pr "  jr = (*env)->NewObjectArray (env, r_len, cl, jstr);\n";
 656            pr "  for (i = 0; i < r_len; ++i) {\n";
 657            pr "    jstr = (*env)->NewStringUTF (env, r[i]);\n";
 658            pr "    (*env)->SetObjectArrayElement (env, jr, i, jstr);\n";
 659            pr "    free (r[i]);\n";
 660            pr "  }\n";
 661            pr "  free (r);\n";
 662            pr "  return jr;\n"
 663        | RStruct (_, typ) ->
 664            let jtyp = java_name_of_struct typ in
 665            let cols = cols_of_struct typ in
 666            generate_java_struct_return typ jtyp cols
 667        | RStructList (_, typ) ->
 668            let jtyp = java_name_of_struct typ in
 669            let cols = cols_of_struct typ in
 670            generate_java_struct_list_return typ jtyp cols
 671        | RBufferOut _ ->
 672            pr "  jr = (*env)->NewStringUTF (env, r); // XXX size\n";
 673            pr "  free (r);\n";
 674            pr "  return jr;\n"
 675       );
 676
 677       pr "}\n";
 678       pr "\n"
 679   ) all_functions
 680
 681 and generate_java_struct_return typ jtyp cols =
 682   pr "  cl = (*env)->FindClass (env, \"com/redhat/et/libguestfs/%s\");\n" jtyp;
 683   pr "  jr = (*env)->AllocObject (env, cl);\n";
 684   List.iter (
 685     function
 686     | name, FString ->
 687         pr "  fl = (*env)->GetFieldID (env, cl, \"%s\", \"Ljava/lang/String;\");\n" name;
 688         pr "  (*env)->SetObjectField (env, jr, fl, (*env)->NewStringUTF (env, r->%s));\n" name;
 689     | name, FUUID ->
 690         pr "  {\n";
 691         pr "    char s[33];\n";
 692         pr "    memcpy (s, r->%s, 32);\n" name;
 693         pr "    s[32] = 0;\n";
 694         pr "    fl = (*env)->GetFieldID (env, cl, \"%s\", \"Ljava/lang/String;\");\n" name;
 695         pr "    (*env)->SetObjectField (env, jr, fl, (*env)->NewStringUTF (env, s));\n";
 696         pr "  }\n";
 697     | name, FBuffer ->
 698         pr "  {\n";
 699         pr "    int len = r->%s_len;\n" name;
 700         pr "    char s[len+1];\n";
 701         pr "    memcpy (s, r->%s, len);\n" name;
 702         pr "    s[len] = 0;\n";
 703         pr "    fl = (*env)->GetFieldID (env, cl, \"%s\", \"Ljava/lang/String;\");\n" name;
 704         pr "    (*env)->SetObjectField (env, jr, fl, (*env)->NewStringUTF (env, s));\n";
 705         pr "  }\n";
 706     | name, (FBytes|FUInt64|FInt64) ->
 707         pr "  fl = (*env)->GetFieldID (env, cl, \"%s\", \"J\");\n" name;
 708         pr "  (*env)->SetLongField (env, jr, fl, r->%s);\n" name;
 709     | name, (FUInt32|FInt32) ->
 710         pr "  fl = (*env)->GetFieldID (env, cl, \"%s\", \"I\");\n" name;
 711         pr "  (*env)->SetLongField (env, jr, fl, r->%s);\n" name;
 712     | name, FOptPercent ->
 713         pr "  fl = (*env)->GetFieldID (env, cl, \"%s\", \"F\");\n" name;
 714         pr "  (*env)->SetFloatField (env, jr, fl, r->%s);\n" name;
 715     | name, FChar ->
 716         pr "  fl = (*env)->GetFieldID (env, cl, \"%s\", \"C\");\n" name;
 717         pr "  (*env)->SetLongField (env, jr, fl, r->%s);\n" name;
 718   ) cols;
 719   pr "  free (r);\n";
 720   pr "  return jr;\n"
 721
 722 and generate_java_struct_list_return typ jtyp cols =
 723   pr "  cl = (*env)->FindClass (env, \"com/redhat/et/libguestfs/%s\");\n" jtyp;
 724   pr "  jr = (*env)->NewObjectArray (env, r->len, cl, NULL);\n";
 725   pr "  for (i = 0; i < r->len; ++i) {\n";
 726   pr "    jfl = (*env)->AllocObject (env, cl);\n";
 727   List.iter (
 728     function
 729     | name, FString ->
 730         pr "    fl = (*env)->GetFieldID (env, cl, \"%s\", \"Ljava/lang/String;\");\n" name;
 731         pr "    (*env)->SetObjectField (env, jfl, fl, (*env)->NewStringUTF (env, r->val[i].%s));\n" name;
 732     | name, FUUID ->
 733         pr "    {\n";
 734         pr "      char s[33];\n";
 735         pr "      memcpy (s, r->val[i].%s, 32);\n" name;
 736         pr "      s[32] = 0;\n";
 737         pr "      fl = (*env)->GetFieldID (env, cl, \"%s\", \"Ljava/lang/String;\");\n" name;
 738         pr "      (*env)->SetObjectField (env, jfl, fl, (*env)->NewStringUTF (env, s));\n";
 739         pr "    }\n";
 740     | name, FBuffer ->
 741         pr "    {\n";
 742         pr "      int len = r->val[i].%s_len;\n" name;
 743         pr "      char s[len+1];\n";
 744         pr "      memcpy (s, r->val[i].%s, len);\n" name;
 745         pr "      s[len] = 0;\n";
 746         pr "      fl = (*env)->GetFieldID (env, cl, \"%s\", \"Ljava/lang/String;\");\n" name;
 747         pr "      (*env)->SetObjectField (env, jfl, fl, (*env)->NewStringUTF (env, s));\n";
 748         pr "    }\n";
 749     | name, (FBytes|FUInt64|FInt64) ->
 750         pr "    fl = (*env)->GetFieldID (env, cl, \"%s\", \"J\");\n" name;
 751         pr "    (*env)->SetLongField (env, jfl, fl, r->val[i].%s);\n" name;
 752     | name, (FUInt32|FInt32) ->
 753         pr "    fl = (*env)->GetFieldID (env, cl, \"%s\", \"I\");\n" name;
 754         pr "    (*env)->SetLongField (env, jfl, fl, r->val[i].%s);\n" name;
 755     | name, FOptPercent ->
 756         pr "    fl = (*env)->GetFieldID (env, cl, \"%s\", \"F\");\n" name;
 757         pr "    (*env)->SetFloatField (env, jfl, fl, r->val[i].%s);\n" name;
 758     | name, FChar ->
 759         pr "    fl = (*env)->GetFieldID (env, cl, \"%s\", \"C\");\n" name;
 760         pr "    (*env)->SetLongField (env, jfl, fl, r->val[i].%s);\n" name;
 761   ) cols;
 762   pr "    (*env)->SetObjectArrayElement (env, jfl, i, jfl);\n";
 763   pr "  }\n";
 764   pr "  guestfs_free_%s_list (r);\n" typ;
 765   pr "  return jr;\n"
 766
 767 and generate_java_makefile_inc () =
 768   generate_header HashStyle GPLv2plus;
 769
 770   pr "java_built_sources = \\\n";
 771   List.iter (
 772     fun (typ, jtyp) ->
 773         pr "\tcom/redhat/et/libguestfs/%s.java \\\n" jtyp;
 774   ) java_structs;
 775   pr "\tcom/redhat/et/libguestfs/GuestFS.java\n"