[m-rev.] diff: specialised MethodPtr interfaces

Peter Wang novalazy at gmail.com
Thu Sep 3 15:06:13 AEST 2009


Branches: main

On the Java backend, use specialised MethodPtr interfaces so that when calling
a method pointer input arguments do not have to be passed via a temporary
array, for arities up to 15.  For higher arities the temporary array is still
used.

java/runtime/MethodPtr.java:
java/runtime/MethodPtr1.java:
java/runtime/MethodPtr10.java:
java/runtime/MethodPtr11.java:
java/runtime/MethodPtr12.java:
java/runtime/MethodPtr13.java:
java/runtime/MethodPtr14.java:
java/runtime/MethodPtr15.java:
java/runtime/MethodPtr2.java:
java/runtime/MethodPtr3.java:
java/runtime/MethodPtr4.java:
java/runtime/MethodPtr5.java:
java/runtime/MethodPtr6.java:
java/runtime/MethodPtr7.java:
java/runtime/MethodPtr8.java:
java/runtime/MethodPtr9.java:
java/runtime/MethodPtrN.java:
        Add specialised MethodPtr interfaces and MethodPtrN for any higher
        arities.

compiler/mlds_to_java.m:
        Make the code generator use the specialised MethodPtr interfaces.

library/Mmakefile:
        Compile java/runtime/*.java files explicitly as some MethodPtr*.java
        files won't be compiled implicitly when compiling the standard library.

library/exception.m:
java/runtime/Exception.java:
library/rtti_implementation.m:
        Conform to changes.

diff --git a/compiler/mlds_to_java.m b/compiler/mlds_to_java.m
index 0316f67..b8a4640 100644
--- a/compiler/mlds_to_java.m
+++ b/compiler/mlds_to_java.m
@@ -234,6 +234,22 @@ rval_is_enum_object(Rval) :-
 interface_is_special("MercuryEnum").
 interface_is_special("MercuryType").
 interface_is_special("MethodPtr").
+interface_is_special("MethodPtr1").
+interface_is_special("MethodPtr2").
+interface_is_special("MethodPtr3").
+interface_is_special("MethodPtr4").
+interface_is_special("MethodPtr5").
+interface_is_special("MethodPtr6").
+interface_is_special("MethodPtr7").
+interface_is_special("MethodPtr8").
+interface_is_special("MethodPtr9").
+interface_is_special("MethodPtr10").
+interface_is_special("MethodPtr11").
+interface_is_special("MethodPtr12").
+interface_is_special("MethodPtr13").
+interface_is_special("MethodPtr14").
+interface_is_special("MethodPtr15").
+interface_is_special("MethodPtrN").
 
 %-----------------------------------------------------------------------------%
 %
@@ -335,7 +351,7 @@ output_java_src_file(ModuleInfo, Indent, MLDS, !IO) :-
     CodeAddrs = list.sort_and_remove_dups(CodeAddrs1),
 
     % Create wrappers in MLDS for all pointer addressed methods.
-    generate_code_addr_wrappers(Indent + 1, CodeAddrs, [], WrapperDefns),
+    list.map(generate_addr_wrapper_class, CodeAddrs, WrapperDefns),
     Defns1 = GlobalDefns ++ WrapperDefns ++ Defns0,
 
     % Rename classes with excessively long names.
@@ -791,30 +807,23 @@ method_ptrs_in_lval(ml_global_var_ref(_), !CodeAddrs).
 % module. This is due to the fact that the names of the generated wrapper
 % classes are based purely on the method name.
 
-    % Generates the MLDS to output the required wrapper classes
+    % Generate the MLDS wrapper class for a given code_addr.
     %
-:- pred generate_code_addr_wrappers(indent::in, list(mlds_code_addr)::in,
-    list(mlds_defn)::in, list(mlds_defn)::out) is det.
+:- pred generate_addr_wrapper_class(mlds_code_addr::in, mlds_defn::out) is det.
 
-generate_code_addr_wrappers(_, [], !Defns).
-generate_code_addr_wrappers(Indent, [CodeAddr | CodeAddrs], !Defns) :-
-    % XXX We should fill in the Context properly. This would probably involve
-    % also returning context information for each "code_addr" returned by the
-    % "method_ptrs_*" predicates above.
-    Context = mlds_make_context(term.context_init),
+generate_addr_wrapper_class(CodeAddr, ClassDefn) :-
+    % Create a method that calls the original predicate.
+    generate_call_method(CodeAddr, MethodDefn, Arity),
+
+    ( Arity =< max_specialised_method_ptr_arity ->
+        InterfaceName = "MethodPtr" ++ string.from_int(Arity)
+    ;
+        InterfaceName = "MethodPtrN"
+    ),
     InterfaceModuleName = mercury_module_name_to_mlds(
         mercury_runtime_package_name),
-    Interface = qual(InterfaceModuleName, module_qual, "MethodPtr"),
-    generate_addr_wrapper_class(Interface, Context, CodeAddr, ClassDefn),
-    !:Defns = [ ClassDefn | !.Defns ],
-    generate_code_addr_wrappers(Indent, CodeAddrs, !Defns).
+    Interface = qual(InterfaceModuleName, module_qual, InterfaceName),
 
-    % Generate the MLDS wrapper class for a given code_addr.
-    %
-:- pred generate_addr_wrapper_class(mlds_class::in,
-    mlds_context::in, mlds_code_addr::in, mlds_defn::out) is det.
-
-generate_addr_wrapper_class(Interface, Context, CodeAddr, ClassDefn) :-
     % Create class components.
     ClassImports = [],
     ClassExtends = [],
@@ -825,8 +834,10 @@ generate_addr_wrapper_class(Interface, Context, CodeAddr, ClassDefn) :-
     % (predicate) name.
     create_addr_wrapper_name(CodeAddr, MangledClassEntityName),
 
-    % Create a method that calls the original predicate.
-    generate_call_method(CodeAddr, MethodDefn),
+    % XXX We should fill in the Context properly. This would probably involve
+    % also returning context information for each "code_addr" returned by the
+    % "method_ptrs_*" predicates above.
+    Context = mlds_make_context(term.context_init),
 
     % Put it all together.
     ClassMembers  = [MethodDefn],
@@ -861,12 +872,19 @@ create_addr_wrapper_name(CodeAddr, MangledClassEntityName) :-
     ClassEntityName = "addrOf__" ++ ModuleNameStr ++ "__" ++ PredName,
     MangledClassEntityName = name_mangle_no_leading_digit(ClassEntityName).
 
+    % The highest arity for which there is a specialised MethodPtr<n> interface.
+    %
+:- func max_specialised_method_ptr_arity = int.
+
+max_specialised_method_ptr_arity = 15.
+
     % Generates a call methods which calls the original method we have
     % created the wrapper for.
     %
-:- pred generate_call_method(mlds_code_addr::in, mlds_defn::out) is det.
+:- pred generate_call_method(mlds_code_addr::in, mlds_defn::out, int::out)
+    is det.
 
-generate_call_method(CodeAddr, MethodDefn) :-
+generate_call_method(CodeAddr, MethodDefn, Arity) :-
     (
         CodeAddr = code_addr_proc(ProcLabel, OrigFuncSignature)
     ;
@@ -883,15 +901,28 @@ generate_call_method(CodeAddr, MethodDefn) :-
     Label = mlds_special_pred_label("call", no, "", 0),
     MethodName = entity_function(Label, ProcID, no, PredID),
 
-    % Create method argument and return type.
-    % It will have the argument type java.lang.Object[]
-    % It will have the return type java.lang.Object
-    MethodArgVariable = mlds_var_name("args", no),
-    MethodArgType = mlds_argument(
-        entity_data(mlds_data_var(MethodArgVariable)),
-        mlds_array_type(mlds_generic_type), gc_no_stmt),
+    list.length(OrigArgTypes, Arity),
+
+    % Create method arguments and call arguments.  For low arities we have
+    % specialised MethodPtr interfaces which contain a method which takes n
+    % arguments directly.  For higher arities the arguments are passed in as an
+    % array.
+    ( Arity =< max_specialised_method_ptr_arity ->
+        list.map2_foldl(generate_call_method_nth_arg(ModuleName),
+            OrigArgTypes, MethodArgs, CallArgs, 1, _Arity)
+    ;
+        MethodArgVariable = mlds_var_name("args", no),
+        MethodArgType = mlds_argument(
+            entity_data(mlds_data_var(MethodArgVariable)),
+            mlds_array_type(mlds_generic_type), gc_no_stmt),
+        MethodArgs = [MethodArgType],
+        CallArgLabel = qual(ModuleName, module_qual, MethodArgVariable),
+        generate_call_method_array_args(OrigArgTypes, CallArgLabel, 0, [],
+            CallArgs)
+    ),
+
+    % Create return type.
     MethodRetType = mlds_generic_type,
-    MethodArgs = [MethodArgType],
     MethodRets = [MethodRetType],
 
     % Create a temporary variable to store the result of the call to the
@@ -921,8 +952,6 @@ generate_call_method(CodeAddr, MethodDefn) :-
     MethodDefns = [ReturnVarDefn],
 
     % Create the call to the original method.
-    CallArgLabel = qual(ModuleName, module_qual, MethodArgVariable),
-    generate_call_method_args(OrigArgTypes, CallArgLabel, 0, [], CallArgs),
     CallRval = ml_const(mlconst_code_addr(CodeAddr)),
 
     % If the original method has a return type of void, then we obviously
@@ -959,17 +988,29 @@ generate_call_method(CodeAddr, MethodDefn) :-
     MethodFlags  = ml_gen_special_member_decl_flags,
     MethodDefn   = mlds_defn(MethodName, Context, MethodFlags, MethodBody).
 
-:- pred generate_call_method_args(list(mlds_type)::in, mlds_var::in, int::in,
-    list(mlds_rval)::in, list(mlds_rval)::out) is det.
+:- pred generate_call_method_nth_arg(mlds_module_name::in, mlds_type::in,
+    mlds_argument::out, mlds_rval::out, int::in, int::out) is det.
+
+generate_call_method_nth_arg(ModuleName, Type, MethodArg, CallArg, I, I + 1) :-
+    MethodArgVariable = mlds_var_name("arg" ++ string.from_int(I), no),
+    MethodArg = mlds_argument(entity_data(mlds_data_var(MethodArgVariable)),
+        mlds_generic_type, gc_no_stmt),
+    CallArgLabel = qual(ModuleName, module_qual, MethodArgVariable),
+    Rval = ml_lval(ml_var(CallArgLabel, mlds_generic_type)),
+    CallArg = ml_unop(unbox(Type), Rval).
 
-generate_call_method_args([], _, _, Args, Args).
-generate_call_method_args([Type | Types], Variable, Counter, Args0, Args) :-
-    ArrayRval = ml_lval(ml_var(Variable, mlds_native_int_type)),
+:- pred generate_call_method_array_args(list(mlds_type)::in, mlds_var::in,
+    int::in, list(mlds_rval)::in, list(mlds_rval)::out) is det.
+
+generate_call_method_array_args([], _, _, Args, Args).
+generate_call_method_array_args([Type | Types], ArrayVar, Counter,
+        Args0, Args) :-
+    ArrayRval = ml_lval(ml_var(ArrayVar, mlds_native_int_type)),
     IndexRval = ml_const(mlconst_int(Counter)),
     Rval = ml_binop(array_index(elem_type_generic), ArrayRval, IndexRval),
     UnBoxedRval = ml_unop(unbox(Type), Rval),
     Args1 = Args0 ++ [UnBoxedRval],
-    generate_call_method_args(Types, Variable, Counter + 1, Args1, Args).
+    generate_call_method_array_args(Types, ArrayVar, Counter + 1, Args1, Args).
 
 :- func make_pred_name_string(mlds_pred_label, proc_id,
     maybe(mlds_func_sequence_num)) = string.
@@ -3258,11 +3299,22 @@ output_stmt(Indent, ModuleInfo, CallerFuncInfo, Call, Context, ExitMethods,
         ;
             MaybeObject = no
         ),
-        output_bracketed_rval(ModuleInfo, FuncRval, ModuleName, !IO),
-        io.write_string(".call___0_0(", !IO),
 
-        % We need to pass the arguments as a single array of java.lang.Object.
-        output_args_as_array(ModuleInfo, CallArgs, ArgTypes, ModuleName, !IO),
+        list.length(CallArgs, Arity),
+        ( Arity =< max_specialised_method_ptr_arity ->
+            io.write_string("((jmercury.runtime.MethodPtr", !IO),
+            io.write_int(Arity, !IO),
+            io.write_string(") ", !IO),
+            output_bracketed_rval(ModuleInfo, FuncRval, ModuleName, !IO),
+            io.write_string(").call___0_0(", !IO),
+            output_boxed_args(ModuleInfo, CallArgs, ArgTypes, ModuleName, !IO)
+        ;
+            io.write_string("((jmercury.runtime.MethodPtrN) ", !IO),
+            output_bracketed_rval(ModuleInfo, FuncRval, ModuleName, !IO),
+            io.write_string(").call___0_0(", !IO),
+            output_args_as_array(ModuleInfo, CallArgs, ArgTypes, ModuleName,
+                !IO)
+        ),
 
         % Closes brackets, and calls unbox methods for downcasting.
         % XXX This is a hack, see the above comment.
diff --git a/java/runtime/Exception.java b/java/runtime/Exception.java
index 765db2b..6d8594f 100644
--- a/java/runtime/Exception.java
+++ b/java/runtime/Exception.java
@@ -9,7 +9,7 @@ package jmercury.runtime;
 public class Exception extends java.lang.Error {
     // This is to be set when the exception module is initialised, to avoid
     // having the runtime depend on the standard library.
-    public static MethodPtr getMessageHook = null;
+    public static MethodPtr1 getMessageHook = null;
 
     // Should be univ.Univ_0 but we don't want to depend on the standard
     // library.
@@ -21,8 +21,7 @@ public class Exception extends java.lang.Error {
 
     public String getMessage() {
         if (getMessageHook != null) {
-            Object[] args = new Object[] { exception };
-            return (String) getMessageHook.call___0_0(args);
+            return (String) getMessageHook.call___0_0(exception);
         } else {
             return null;
         }
diff --git a/java/runtime/MethodPtr.java b/java/runtime/MethodPtr.java
index c2e5e00..5a6dee0 100644
--- a/java/runtime/MethodPtr.java
+++ b/java/runtime/MethodPtr.java
@@ -10,6 +10,5 @@
 package jmercury.runtime;
 
 public interface MethodPtr {
-	public abstract java.lang.Object call___0_0(java.lang.Object[] args);
 }
 
diff --git a/java/runtime/MethodPtr1.java b/java/runtime/MethodPtr1.java
new file mode 100644
index 0000000..5d1a8d3
--- /dev/null
+++ b/java/runtime/MethodPtr1.java
@@ -0,0 +1,15 @@
+//
+// Copyright (C) 2009 The University of Melbourne.
+// This file may only be copied under the terms of the GNU Library General
+// Public License - see the file COPYING.LIB in the Mercury distribution.
+//
+// This interface is implemented by wrapper classes which are automatically
+// generated by the Java back-end to implement method pointers in Java.
+//
+
+package jmercury.runtime;
+
+public interface MethodPtr1 extends MethodPtr {
+    public abstract java.lang.Object call___0_0(
+        java.lang.Object arg1);
+}
diff --git a/java/runtime/MethodPtr10.java b/java/runtime/MethodPtr10.java
new file mode 100644
index 0000000..c07626e
--- /dev/null
+++ b/java/runtime/MethodPtr10.java
@@ -0,0 +1,24 @@
+//
+// Copyright (C) 2009 The University of Melbourne.
+// This file may only be copied under the terms of the GNU Library General
+// Public License - see the file COPYING.LIB in the Mercury distribution.
+//
+// This interface is implemented by wrapper classes which are automatically
+// generated by the Java back-end to implement method pointers in Java.
+//
+
+package jmercury.runtime;
+
+public interface MethodPtr10 extends MethodPtr {
+    public abstract java.lang.Object call___0_0(
+        java.lang.Object arg1,
+        java.lang.Object arg2,
+        java.lang.Object arg3,
+        java.lang.Object arg4,
+        java.lang.Object arg5,
+        java.lang.Object arg6,
+        java.lang.Object arg7,
+        java.lang.Object arg8,
+        java.lang.Object arg9,
+        java.lang.Object arg10);
+}
diff --git a/java/runtime/MethodPtr11.java b/java/runtime/MethodPtr11.java
new file mode 100644
index 0000000..302fcb4
--- /dev/null
+++ b/java/runtime/MethodPtr11.java
@@ -0,0 +1,25 @@
+//
+// Copyright (C) 2009 The University of Melbourne.
+// This file may only be copied under the terms of the GNU Library General
+// Public License - see the file COPYING.LIB in the Mercury distribution.
+//
+// This interface is implemented by wrapper classes which are automatically
+// generated by the Java back-end to implement method pointers in Java.
+//
+
+package jmercury.runtime;
+
+public interface MethodPtr11 extends MethodPtr {
+    public abstract java.lang.Object call___0_0(
+        java.lang.Object arg1,
+        java.lang.Object arg2,
+        java.lang.Object arg3,
+        java.lang.Object arg4,
+        java.lang.Object arg5,
+        java.lang.Object arg6,
+        java.lang.Object arg7,
+        java.lang.Object arg8,
+        java.lang.Object arg9,
+        java.lang.Object arg10,
+        java.lang.Object arg11);
+}
diff --git a/java/runtime/MethodPtr12.java b/java/runtime/MethodPtr12.java
new file mode 100644
index 0000000..5d3ab2d
--- /dev/null
+++ b/java/runtime/MethodPtr12.java
@@ -0,0 +1,26 @@
+//
+// Copyright (C) 2009 The University of Melbourne.
+// This file may only be copied under the terms of the GNU Library General
+// Public License - see the file COPYING.LIB in the Mercury distribution.
+//
+// This interface is implemented by wrapper classes which are automatically
+// generated by the Java back-end to implement method pointers in Java.
+//
+
+package jmercury.runtime;
+
+public interface MethodPtr12 extends MethodPtr {
+    public abstract java.lang.Object call___0_0(
+        java.lang.Object arg1,
+        java.lang.Object arg2,
+        java.lang.Object arg3,
+        java.lang.Object arg4,
+        java.lang.Object arg5,
+        java.lang.Object arg6,
+        java.lang.Object arg7,
+        java.lang.Object arg8,
+        java.lang.Object arg9,
+        java.lang.Object arg10,
+        java.lang.Object arg11,
+        java.lang.Object arg12);
+}
diff --git a/java/runtime/MethodPtr13.java b/java/runtime/MethodPtr13.java
new file mode 100644
index 0000000..f54fbaf
--- /dev/null
+++ b/java/runtime/MethodPtr13.java
@@ -0,0 +1,27 @@
+//
+// Copyright (C) 2009 The University of Melbourne.
+// This file may only be copied under the terms of the GNU Library General
+// Public License - see the file COPYING.LIB in the Mercury distribution.
+//
+// This interface is implemented by wrapper classes which are automatically
+// generated by the Java back-end to implement method pointers in Java.
+//
+
+package jmercury.runtime;
+
+public interface MethodPtr13 extends MethodPtr {
+    public abstract java.lang.Object call___0_0(
+        java.lang.Object arg1,
+        java.lang.Object arg2,
+        java.lang.Object arg3,
+        java.lang.Object arg4,
+        java.lang.Object arg5,
+        java.lang.Object arg6,
+        java.lang.Object arg7,
+        java.lang.Object arg8,
+        java.lang.Object arg9,
+        java.lang.Object arg10,
+        java.lang.Object arg11,
+        java.lang.Object arg12,
+        java.lang.Object arg13);
+}
diff --git a/java/runtime/MethodPtr14.java b/java/runtime/MethodPtr14.java
new file mode 100644
index 0000000..40884c2
--- /dev/null
+++ b/java/runtime/MethodPtr14.java
@@ -0,0 +1,28 @@
+//
+// Copyright (C) 2009 The University of Melbourne.
+// This file may only be copied under the terms of the GNU Library General
+// Public License - see the file COPYING.LIB in the Mercury distribution.
+//
+// This interface is implemented by wrapper classes which are automatically
+// generated by the Java back-end to implement method pointers in Java.
+//
+
+package jmercury.runtime;
+
+public interface MethodPtr14 extends MethodPtr {
+    public abstract java.lang.Object call___0_0(
+        java.lang.Object arg1,
+        java.lang.Object arg2,
+        java.lang.Object arg3,
+        java.lang.Object arg4,
+        java.lang.Object arg5,
+        java.lang.Object arg6,
+        java.lang.Object arg7,
+        java.lang.Object arg8,
+        java.lang.Object arg9,
+        java.lang.Object arg10,
+        java.lang.Object arg11,
+        java.lang.Object arg12,
+        java.lang.Object arg13,
+        java.lang.Object arg14);
+}
diff --git a/java/runtime/MethodPtr15.java b/java/runtime/MethodPtr15.java
new file mode 100644
index 0000000..bd5a643
--- /dev/null
+++ b/java/runtime/MethodPtr15.java
@@ -0,0 +1,29 @@
+//
+// Copyright (C) 2009 The University of Melbourne.
+// This file may only be copied under the terms of the GNU Library General
+// Public License - see the file COPYING.LIB in the Mercury distribution.
+//
+// This interface is implemented by wrapper classes which are automatically
+// generated by the Java back-end to implement method pointers in Java.
+//
+
+package jmercury.runtime;
+
+public interface MethodPtr15 extends MethodPtr {
+    public abstract java.lang.Object call___0_0(
+        java.lang.Object arg1,
+        java.lang.Object arg2,
+        java.lang.Object arg3,
+        java.lang.Object arg4,
+        java.lang.Object arg5,
+        java.lang.Object arg6,
+        java.lang.Object arg7,
+        java.lang.Object arg8,
+        java.lang.Object arg9,
+        java.lang.Object arg10,
+        java.lang.Object arg11,
+        java.lang.Object arg12,
+        java.lang.Object arg13,
+        java.lang.Object arg14,
+        java.lang.Object arg15);
+}
diff --git a/java/runtime/MethodPtr2.java b/java/runtime/MethodPtr2.java
new file mode 100644
index 0000000..cd10bf5
--- /dev/null
+++ b/java/runtime/MethodPtr2.java
@@ -0,0 +1,16 @@
+//
+// Copyright (C) 2009 The University of Melbourne.
+// This file may only be copied under the terms of the GNU Library General
+// Public License - see the file COPYING.LIB in the Mercury distribution.
+//
+// This interface is implemented by wrapper classes which are automatically
+// generated by the Java back-end to implement method pointers in Java.
+//
+
+package jmercury.runtime;
+
+public interface MethodPtr2 extends MethodPtr {
+    public abstract java.lang.Object call___0_0(
+        java.lang.Object arg1,
+        java.lang.Object arg2);
+}
diff --git a/java/runtime/MethodPtr3.java b/java/runtime/MethodPtr3.java
new file mode 100644
index 0000000..6603937
--- /dev/null
+++ b/java/runtime/MethodPtr3.java
@@ -0,0 +1,17 @@
+//
+// Copyright (C) 2009 The University of Melbourne.
+// This file may only be copied under the terms of the GNU Library General
+// Public License - see the file COPYING.LIB in the Mercury distribution.
+//
+// This interface is implemented by wrapper classes which are automatically
+// generated by the Java back-end to implement method pointers in Java.
+//
+
+package jmercury.runtime;
+
+public interface MethodPtr3 extends MethodPtr {
+    public abstract java.lang.Object call___0_0(
+        java.lang.Object arg1,
+        java.lang.Object arg2,
+        java.lang.Object arg3);
+}
diff --git a/java/runtime/MethodPtr4.java b/java/runtime/MethodPtr4.java
new file mode 100644
index 0000000..cd13bfc
--- /dev/null
+++ b/java/runtime/MethodPtr4.java
@@ -0,0 +1,18 @@
+//
+// Copyright (C) 2009 The University of Melbourne.
+// This file may only be copied under the terms of the GNU Library General
+// Public License - see the file COPYING.LIB in the Mercury distribution.
+//
+// This interface is implemented by wrapper classes which are automatically
+// generated by the Java back-end to implement method pointers in Java.
+//
+
+package jmercury.runtime;
+
+public interface MethodPtr4 extends MethodPtr {
+    public abstract java.lang.Object call___0_0(
+        java.lang.Object arg1,
+        java.lang.Object arg2,
+        java.lang.Object arg3,
+        java.lang.Object arg4);
+}
diff --git a/java/runtime/MethodPtr5.java b/java/runtime/MethodPtr5.java
new file mode 100644
index 0000000..0ab7d07
--- /dev/null
+++ b/java/runtime/MethodPtr5.java
@@ -0,0 +1,19 @@
+//
+// Copyright (C) 2009 The University of Melbourne.
+// This file may only be copied under the terms of the GNU Library General
+// Public License - see the file COPYING.LIB in the Mercury distribution.
+//
+// This interface is implemented by wrapper classes which are automatically
+// generated by the Java back-end to implement method pointers in Java.
+//
+
+package jmercury.runtime;
+
+public interface MethodPtr5 extends MethodPtr {
+    public abstract java.lang.Object call___0_0(
+        java.lang.Object arg1,
+        java.lang.Object arg2,
+        java.lang.Object arg3,
+        java.lang.Object arg4,
+        java.lang.Object arg5);
+}
diff --git a/java/runtime/MethodPtr6.java b/java/runtime/MethodPtr6.java
new file mode 100644
index 0000000..02002fe
--- /dev/null
+++ b/java/runtime/MethodPtr6.java
@@ -0,0 +1,20 @@
+//
+// Copyright (C) 2009 The University of Melbourne.
+// This file may only be copied under the terms of the GNU Library General
+// Public License - see the file COPYING.LIB in the Mercury distribution.
+//
+// This interface is implemented by wrapper classes which are automatically
+// generated by the Java back-end to implement method pointers in Java.
+//
+
+package jmercury.runtime;
+
+public interface MethodPtr6 extends MethodPtr {
+    public abstract java.lang.Object call___0_0(
+        java.lang.Object arg1,
+        java.lang.Object arg2,
+        java.lang.Object arg3,
+        java.lang.Object arg4,
+        java.lang.Object arg5,
+        java.lang.Object arg6);
+}
diff --git a/java/runtime/MethodPtr7.java b/java/runtime/MethodPtr7.java
new file mode 100644
index 0000000..cc1443f
--- /dev/null
+++ b/java/runtime/MethodPtr7.java
@@ -0,0 +1,21 @@
+//
+// Copyright (C) 2009 The University of Melbourne.
+// This file may only be copied under the terms of the GNU Library General
+// Public License - see the file COPYING.LIB in the Mercury distribution.
+//
+// This interface is implemented by wrapper classes which are automatically
+// generated by the Java back-end to implement method pointers in Java.
+//
+
+package jmercury.runtime;
+
+public interface MethodPtr7 extends MethodPtr {
+    public abstract java.lang.Object call___0_0(
+        java.lang.Object arg1,
+        java.lang.Object arg2,
+        java.lang.Object arg3,
+        java.lang.Object arg4,
+        java.lang.Object arg5,
+        java.lang.Object arg6,
+        java.lang.Object arg7);
+}
diff --git a/java/runtime/MethodPtr8.java b/java/runtime/MethodPtr8.java
new file mode 100644
index 0000000..61b6ce1
--- /dev/null
+++ b/java/runtime/MethodPtr8.java
@@ -0,0 +1,22 @@
+//
+// Copyright (C) 2009 The University of Melbourne.
+// This file may only be copied under the terms of the GNU Library General
+// Public License - see the file COPYING.LIB in the Mercury distribution.
+//
+// This interface is implemented by wrapper classes which are automatically
+// generated by the Java back-end to implement method pointers in Java.
+//
+
+package jmercury.runtime;
+
+public interface MethodPtr8 extends MethodPtr {
+    public abstract java.lang.Object call___0_0(
+        java.lang.Object arg1,
+        java.lang.Object arg2,
+        java.lang.Object arg3,
+        java.lang.Object arg4,
+        java.lang.Object arg5,
+        java.lang.Object arg6,
+        java.lang.Object arg7,
+        java.lang.Object arg8);
+}
diff --git a/java/runtime/MethodPtr9.java b/java/runtime/MethodPtr9.java
new file mode 100644
index 0000000..d0f8b73
--- /dev/null
+++ b/java/runtime/MethodPtr9.java
@@ -0,0 +1,23 @@
+//
+// Copyright (C) 2009 The University of Melbourne.
+// This file may only be copied under the terms of the GNU Library General
+// Public License - see the file COPYING.LIB in the Mercury distribution.
+//
+// This interface is implemented by wrapper classes which are automatically
+// generated by the Java back-end to implement method pointers in Java.
+//
+
+package jmercury.runtime;
+
+public interface MethodPtr9 extends MethodPtr {
+    public abstract java.lang.Object call___0_0(
+        java.lang.Object arg1,
+        java.lang.Object arg2,
+        java.lang.Object arg3,
+        java.lang.Object arg4,
+        java.lang.Object arg5,
+        java.lang.Object arg6,
+        java.lang.Object arg7,
+        java.lang.Object arg8,
+        java.lang.Object arg9);
+}
diff --git a/java/runtime/MethodPtrN.java b/java/runtime/MethodPtrN.java
new file mode 100644
index 0000000..8831934
--- /dev/null
+++ b/java/runtime/MethodPtrN.java
@@ -0,0 +1,15 @@
+//
+// Copyright (C) 2009 The University of Melbourne.
+// This file may only be copied under the terms of the GNU Library General
+// Public License - see the file COPYING.LIB in the Mercury distribution.
+//
+// This interface is implemented by wrapper classes which are automatically
+// generated by the Java back-end to implement method pointers in Java.
+//
+
+package jmercury.runtime;
+
+public interface MethodPtrN extends MethodPtr {
+    public abstract java.lang.Object call___0_0(java.lang.Object[] args);
+}
+
diff --git a/library/Mmakefile b/library/Mmakefile
index 293d08a..a4bd70f 100644
--- a/library/Mmakefile
+++ b/library/Mmakefile
@@ -246,6 +246,7 @@ endif
 # avoid keywords.  Instead of replicating that logic here we just use a
 # wildcard to find the file names.
 JAVAS = $(wildcard jmercury/*.java)
+RUNTIME_JAVAS = $(wildcard jmercury/runtime/*.java)
 
 # We need to invoke javac on all of the classes at the same time,
 # rather than compiling them separately.  This is needed because
@@ -253,6 +254,7 @@ JAVAS = $(wildcard jmercury/*.java)
 # modules.
 classes: javas java_symlinks
 	$(JAVAC) $(ALL_JAVACFLAGS) $(JAVAS)
+	$(JAVAC) $(ALL_JAVACFLAGS) $(RUNTIME_JAVAS)
 
 # javac expects to find the sources for symbols named mercury.runtime.* in
 # mercury/runtime/*, but in our sources those symbols actually come from
diff --git a/library/exception.m b/library/exception.m
index 7d65df4..47746bd 100644
--- a/library/exception.m
+++ b/library/exception.m
@@ -1718,13 +1718,14 @@ call_handler(Handler, Exception, Result) :- Handler(Exception, Result).
     Object[] Handler = (Object[]) Handler0;
 
     try {
-        jmercury.runtime.MethodPtr pred = (jmercury.runtime.MethodPtr) Pred[1];
-        pred.call___0_0(new java.lang.Object[] { Pred, cont, cont_env_ptr });
+        jmercury.runtime.MethodPtr3 pred =
+            (jmercury.runtime.MethodPtr3) Pred[1];
+        pred.call___0_0(Pred, cont, cont_env_ptr);
     }
     catch (jmercury.runtime.Exception ex) {
         Object T = exception.ML_call_handler_det(TypeInfo_for_T, Handler,
             (univ.Univ_0) ex.exception);
-        cont.call___0_0(new java.lang.Object[] { T, cont_env_ptr });
+        ((jmercury.runtime.MethodPtr2) cont).call___0_0(T, cont_env_ptr);
     }
 ").
 :- pragma foreign_proc("Java",
@@ -1735,13 +1736,14 @@ call_handler(Handler, Exception, Result) :- Handler(Exception, Result).
     Object[] Handler = (Object[]) Handler0;
 
     try {
-        jmercury.runtime.MethodPtr pred = (jmercury.runtime.MethodPtr) Pred[1];
-        pred.call___0_0(new java.lang.Object[] { Pred, cont, cont_env_ptr });
+        jmercury.runtime.MethodPtr3 pred =
+            (jmercury.runtime.MethodPtr3) Pred[1];
+        pred.call___0_0(Pred, cont, cont_env_ptr);
     }
     catch (jmercury.runtime.Exception ex) {
         Object T = exception.ML_call_handler_det(TypeInfo_for_T, Handler,
             (univ.Univ_0) ex.exception);
-        cont.call___0_0(new java.lang.Object[] { T, cont_env_ptr });
+        ((jmercury.runtime.MethodPtr2) cont).call___0_0(T, cont_env_ptr);
     }
 ").
 
@@ -2814,10 +2816,9 @@ set_get_message_hook(!IO).
         may_not_duplicate],
 "
     jmercury.runtime.Exception.getMessageHook =
-        new jmercury.runtime.MethodPtr() {
-            public java.lang.Object call___0_0(java.lang.Object[] args) {
-                univ.Univ_0 univ = (univ.Univ_0) args[0];
-                return ML_exception_to_string(univ);
+        new jmercury.runtime.MethodPtr1() {
+            public java.lang.Object call___0_0(java.lang.Object arg1) {
+                return ML_exception_to_string((univ.Univ_0) arg1);
             }
         };
     IO = IO0;
diff --git a/library/rtti_implementation.m b/library/rtti_implementation.m
index 437a59b..36a5b54 100644
--- a/library/rtti_implementation.m
+++ b/library/rtti_implementation.m
@@ -804,94 +804,88 @@ result_call_9(_::in, (=)::out, _::in, _::in, _::in, _::in, _::in,
     semidet_call_3(Pred::in, X::in, Y::in),
     [will_not_call_mercury, promise_pure, thread_safe],
 "
-    jmercury.runtime.MethodPtr P = (jmercury.runtime.MethodPtr) Pred;
-    succeeded = (Boolean) P.call___0_0(new Object[] { X, Y });
+    jmercury.runtime.MethodPtr2 P = (jmercury.runtime.MethodPtr2) Pred;
+    succeeded = (Boolean) P.call___0_0(X, Y);
 ").
 :- pragma foreign_proc("Java",
     semidet_call_4(Pred::in, A::in, X::in, Y::in),
     [will_not_call_mercury, promise_pure, thread_safe],
 "
-    jmercury.runtime.MethodPtr P = (jmercury.runtime.MethodPtr) Pred;
-    succeeded = (Boolean) P.call___0_0(new Object[] { A, X, Y });
+    jmercury.runtime.MethodPtr3 P = (jmercury.runtime.MethodPtr3) Pred;
+    succeeded = (Boolean) P.call___0_0(A, X, Y);
 ").
 :- pragma foreign_proc("Java",
     semidet_call_5(Pred::in, A::in, B::in, X::in, Y::in),
     [will_not_call_mercury, promise_pure, thread_safe],
 "
-    jmercury.runtime.MethodPtr P = (jmercury.runtime.MethodPtr) Pred;
-    succeeded = (Boolean) P.call___0_0(new Object[] { A, B, X, Y });
+    jmercury.runtime.MethodPtr4 P = (jmercury.runtime.MethodPtr4) Pred;
+    succeeded = (Boolean) P.call___0_0(A, B, X, Y);
 ").
 :- pragma foreign_proc("Java",
     semidet_call_6(Pred::in, A::in, B::in, C::in, X::in, Y::in),
     [will_not_call_mercury, promise_pure, thread_safe],
 "
-    jmercury.runtime.MethodPtr P = (jmercury.runtime.MethodPtr) Pred;
-    succeeded = (Boolean) P.call___0_0(new Object[] { A, B, C, X, Y });
+    jmercury.runtime.MethodPtr5 P = (jmercury.runtime.MethodPtr5) Pred;
+    succeeded = (Boolean) P.call___0_0(A, B, C, X, Y);
 ").
 :- pragma foreign_proc("Java",
     semidet_call_7(Pred::in, A::in, B::in, C::in, D::in, X::in, Y::in),
     [will_not_call_mercury, promise_pure, thread_safe],
 "
-    jmercury.runtime.MethodPtr P = (jmercury.runtime.MethodPtr) Pred;
-    succeeded = (Boolean) P.call___0_0(new Object[] { A, B, C, D, X, Y });
+    jmercury.runtime.MethodPtr6 P = (jmercury.runtime.MethodPtr6) Pred;
+    succeeded = (Boolean) P.call___0_0(A, B, C, D, X, Y);
 ").
 :- pragma foreign_proc("Java",
     semidet_call_8(Pred::in, A::in, B::in, C::in, D::in, E::in, X::in, Y::in),
     [will_not_call_mercury, promise_pure, thread_safe],
 "
-    jmercury.runtime.MethodPtr P = (jmercury.runtime.MethodPtr) Pred;
-    succeeded = (Boolean) P.call___0_0(new Object[] { A, B, C, D, E, X, Y });
+    jmercury.runtime.MethodPtr7 P = (jmercury.runtime.MethodPtr7) Pred;
+    succeeded = (Boolean) P.call___0_0(A, B, C, D, E, X, Y);
 ").
 
 :- pragma foreign_proc("Java",
     result_call_4(Pred::in, Res::out, X::in, Y::in),
     [will_not_call_mercury, promise_pure, thread_safe],
 "
-    jmercury.runtime.MethodPtr P = (jmercury.runtime.MethodPtr) Pred;
-    Res = (builtin.Comparison_result_0)
-        P.call___0_0(new Object[] { X, Y });
+    jmercury.runtime.MethodPtr2 P = (jmercury.runtime.MethodPtr2) Pred;
+    Res = (builtin.Comparison_result_0) P.call___0_0(X, Y);
 ").
 
 :- pragma foreign_proc("Java",
     result_call_5(Pred::in, Res::out, A::in, X::in, Y::in),
     [will_not_call_mercury, promise_pure, thread_safe],
 "
-    jmercury.runtime.MethodPtr P = (jmercury.runtime.MethodPtr) Pred;
-    Res = (builtin.Comparison_result_0)
-        P.call___0_0(new Object[] { A, X, Y });
+    jmercury.runtime.MethodPtr3 P = (jmercury.runtime.MethodPtr3) Pred;
+    Res = (builtin.Comparison_result_0) P.call___0_0(A, X, Y);
 ").
 :- pragma foreign_proc("Java",
     result_call_6(Pred::in, Res::out, A::in, B::in, X::in, Y::in),
     [will_not_call_mercury, promise_pure, thread_safe],
 "
-    jmercury.runtime.MethodPtr P = (jmercury.runtime.MethodPtr) Pred;
-    Res = (builtin.Comparison_result_0)
-        P.call___0_0(new Object[] { A, B, X, Y });
+    jmercury.runtime.MethodPtr4 P = (jmercury.runtime.MethodPtr4) Pred;
+    Res = (builtin.Comparison_result_0) P.call___0_0(A, B, X, Y);
 ").
 :- pragma foreign_proc("Java",
     result_call_7(Pred::in, Res::out, A::in, B::in, C::in, X::in, Y::in),
     [will_not_call_mercury, promise_pure, thread_safe],
 "
-    jmercury.runtime.MethodPtr P = (jmercury.runtime.MethodPtr) Pred;
-    Res = (builtin.Comparison_result_0)
-        P.call___0_0(new Object[] { A, B, C, X, Y });
+    jmercury.runtime.MethodPtr5 P = (jmercury.runtime.MethodPtr5) Pred;
+    Res = (builtin.Comparison_result_0) P.call___0_0(A, B, C, X, Y);
 ").
 :- pragma foreign_proc("Java",
     result_call_8(Pred::in, Res::out, A::in, B::in, C::in, D::in, X::in, Y::in),
     [will_not_call_mercury, promise_pure, thread_safe],
 "
-    jmercury.runtime.MethodPtr P = (jmercury.runtime.MethodPtr) Pred;
-    Res = (builtin.Comparison_result_0)
-        P.call___0_0(new Object[] { A, B, C, D, X, Y });
+    jmercury.runtime.MethodPtr6 P = (jmercury.runtime.MethodPtr6) Pred;
+    Res = (builtin.Comparison_result_0) P.call___0_0(A, B, C, D, X, Y);
 ").
 :- pragma foreign_proc("Java",
     result_call_9(Pred::in, Res::out, A::in, B::in, C::in, D::in, E::in,
         X::in, Y::in),
     [will_not_call_mercury, promise_pure, thread_safe],
 "
-    jmercury.runtime.MethodPtr P = (jmercury.runtime.MethodPtr) Pred;
-    Res = (builtin.Comparison_result_0)
-        P.call___0_0(new Object[] { A, B, C, D, E, X, Y });
+    jmercury.runtime.MethodPtr7 P = (jmercury.runtime.MethodPtr7) Pred;
+    Res = (builtin.Comparison_result_0) P.call___0_0(A, B, C, D, E, X, Y);
 ").
 
 %-----------------------------------------------------------------------------%

--------------------------------------------------------------------------
mercury-reviews mailing list
Post messages to:       mercury-reviews at csse.unimelb.edu.au
Administrative Queries: owner-mercury-reviews at csse.unimelb.edu.au
Subscriptions:          mercury-reviews-request at csse.unimelb.edu.au
--------------------------------------------------------------------------



More information about the reviews mailing list