generator/generator_java.ml

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