generator: In non-C bindings, generate '*_opts' alias.

In C, a function called 'func' which has once_had_no_optargs=true will
(because of the previous commit) generate 'func_opts' and a
backwards-compatibility function called 'func'.

This commit changes some of the non-C bindings so that they also
generate 'func_opts' which is merely a wrapper that calls 'func'.

This avoids incompatibility when we rename 'mkfs_opts' etc back to
plain 'mkfs', and it also makes it easier to translate between other
language bindings and C code.

NB: Some bindings do not include aliases:

  PHP:     There's no way to easily alias methods in PHP < 5.3, and we
           can't assume everyone has this minimum version.

  GObject: Very complex to add aliases, but we should probably do this
           at some point.

  Haskell: No support for optargs in these bindings.  Unfortunately
           this means that we can no longer bind 'Guestfs.add_drive'
           (since it will be changed to add optional arguments) making
           the Haskell bindings even less useful than they were already.

1 files changed, 47 insertions, 1 deletions

diff --git a/generator/generator_java.ml b/generator/generator_java.ml
index 62a17751..d239e1f7 100644
--- a/generator/generator_java.ml
+++ b/generator/generator_java.ml
@@ -95,7 +95,7 @@ public class GuestFS {
   List.iter (
     fun ({ name = name; style = (ret, args, optargs as style);
            in_docs = in_docs; shortdesc = shortdesc;
-           longdesc = longdesc } as f) ->
+           longdesc = longdesc; non_c_aliases = non_c_aliases } as f) ->
       if in_docs then (
         let doc = replace_str longdesc "C<guestfs_" "C<g." in
         let doc =
@@ -200,6 +200,52 @@ public class GuestFS {
         pr "\n"
       );
 
+      (* Aliases. *)
+      List.iter (
+        fun alias ->
+          pr "  ";
+          generate_java_prototype ~public:true ~semicolon:false alias style;
+          pr "\n";
+          pr "  {\n";
+          (match ret with
+          | RErr -> pr "    "
+          | _ ->    pr "    return "
+          );
+          pr "%s (" name;
+          let needs_comma = ref false in
+          List.iter (
+            fun arg ->
+              if !needs_comma then pr ", ";
+              needs_comma := true;
+              pr "%s" (name_of_argt arg)
+          ) args;
+          if optargs <> [] then (
+            if !needs_comma then pr ", ";
+            needs_comma := true;
+            pr "optargs"
+          );
+          pr ");\n";
+          pr "  }\n";
+          pr "\n";
+
+          if optargs <> [] then (
+            pr "  ";
+            generate_java_prototype ~public:true ~semicolon:false
+              alias (ret, args, []);
+            pr "\n";
+            pr "  {\n";
+            (match ret with
+            | RErr -> pr "    "
+            | _ ->    pr "    return "
+            );
+            pr "%s (" name;
+            List.iter (fun arg -> pr "%s, " (name_of_argt arg)) args;
+            pr "null);\n";
+            pr "  }\n";
+            pr "\n"
+          )
+      ) non_c_aliases;
+
       (* Prototype for the native method. *)
       pr "  ";
       generate_java_prototype ~privat:true ~native:true name style;