[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