%---------------------------------------------------------------------------% % vim: ft=mercury ts=4 sw=4 et %---------------------------------------------------------------------------% % Copyright (C) 2000-2012 The University of Melbourne. % Copyright (C) 2013-2018 The Mercury team. % This file may only be copied under the terms of the GNU General % Public License - see the file COPYING in the Mercury distribution. %---------------------------------------------------------------------------% % % Output MLDS function declarations and definitions in Java. % %---------------------------------------------------------------------------% :- module ml_backend.mlds_to_java_func. :- interface. :- import_module ml_backend.mlds. :- import_module ml_backend.mlds_to_java_util. :- import_module ml_backend.mlds_to_target_util. :- import_module io. :- import_module list. %---------------------------------------------------------------------------% :- pred output_func_decl_for_java(java_out_info::in, io.text_output_stream::in, indent::in, mlds_function_name::in, output_aux::in, mlds_func_params::in, io::di, io::uo) is det. :- pred output_params_for_java(java_out_info::in, io.text_output_stream::in, indent::in, list(mlds_argument)::in, io::di, io::uo) is det. %---------------------------------------------------------------------------% :- pred output_function_defn_for_java(java_out_info::in, io.text_output_stream::in, indent::in, output_aux::in, mlds_function_defn::in, io::di, io::uo) is det. %---------------------------------------------------------------------------% %---------------------------------------------------------------------------% :- implementation. :- import_module hlds. :- import_module hlds.hlds_module. :- import_module ml_backend.mlds_to_java_name. :- import_module ml_backend.mlds_to_java_stmt. :- import_module ml_backend.mlds_to_java_type. :- import_module parse_tree. :- import_module parse_tree.parse_tree_out_info. :- import_module parse_tree.prog_data. :- import_module bool. :- import_module char. :- import_module int. :- import_module maybe. :- import_module term. %---------------------------------------------------------------------------% output_func_decl_for_java(Info, Stream, Indent, FuncName, OutputAux, Signature, !IO) :- Signature = mlds_func_params(Parameters, RetTypes), ( if OutputAux = oa_cname(ClassName, ClassArity), FuncName = mlds_function_export("") then output_class_name_arity_for_java(Stream, ClassName, ClassArity, !IO) else output_return_types_for_java(Info, Stream, RetTypes, !IO), io.nl(Stream, !IO), output_n_indents(Stream, Indent, !IO), output_function_name_for_java(Stream, FuncName, !IO) ), output_params_for_java(Info, Stream, Indent, Parameters, !IO). :- pred output_return_types_for_java(java_out_info::in, io.text_output_stream::in, mlds_return_types::in, io::di, io::uo) is det. output_return_types_for_java(Info, Stream, RetTypes, !IO) :- ( RetTypes = [], io.write_string(Stream, "void", !IO) ; RetTypes = [RetType], output_type_for_java(Info, RetType, Stream, !IO) ; RetTypes = [_, _ | _], % For multiple outputs, we return an array of objects. io.write_string(Stream, "java.lang.Object []", !IO) ). output_params_for_java(Info, Stream, Indent, Parameters, !IO) :- io.write_char(Stream, '(', !IO), ( Parameters = [] ; Parameters = [_ | _], io.nl(Stream, !IO), write_out_list(output_param(Info, Indent + 1), ",\n", Parameters, Stream, !IO) ), io.write_char(Stream, ')', !IO). :- pred output_param(java_out_info::in, indent::in, mlds_argument::in, io.text_output_stream::in, io::di, io::uo) is det. output_param(Info, Indent, Arg, Stream, !IO) :- Arg = mlds_argument(VarName, Type, _GCStmt), output_n_indents(Stream, Indent, !IO), output_type_for_java(Info, Type, Stream, !IO), io.write_char(Stream, ' ', !IO), output_local_var_name_for_java(Stream, VarName, !IO). %---------------------------------------------------------------------------% output_function_defn_for_java(Info, Stream, Indent, OutputAux, FunctionDefn, !IO) :- % Put a blank line before each function definition. io.nl(Stream, !IO), FunctionDefn = mlds_function_defn(Name, Context, Flags, MaybePredProcId, Params, MaybeBody, _EnvVarNames, _MaybeRequireTailrecInfo), ( MaybeBody = body_external, % This is just a function declaration, with no body. % Java doesn't support separate declarations and definitions, % so just output the declaration as a comment. % (Note that the actual definition of an external procedure % must be given in `pragma java_code' in the same module.) % % XXX For now, we print only the name of the function. % We would like to print the whole declaration in a comment, % but that does not work. For some argument types in the function % declaration, we may print a comment before the Java type % (see type_to_string_for_java). This would yield nested comments, % which Java does not allow. indent_line_after_context(Stream, Info ^ joi_line_numbers, marker_comment, Context, Indent, !IO), io.write_string(Stream, "// external: ", !IO), output_function_name_for_java(Stream, Name, !IO), io.nl(Stream, !IO) ; MaybeBody = body_defined_here(_), indent_line_after_context(Stream, Info ^ joi_line_numbers, marker_comment, Context, Indent, !IO), output_function_decl_flags_for_java(Info, Stream, Flags, !IO), ( MaybePredProcId = no ; MaybePredProcId = yes(PredProcid), maybe_output_pred_proc_id_comment(Stream, Info ^ joi_auto_comments, PredProcid, !IO) ), output_func_for_java(Info, Stream, Indent, Name, OutputAux, Context, Params, MaybeBody, !IO) ). :- pred output_func_for_java(java_out_info::in, io.text_output_stream::in, indent::in, mlds_function_name::in, output_aux::in, prog_context::in, mlds_func_params::in, mlds_function_body::in, io::di, io::uo) is det. output_func_for_java(Info, Stream, Indent, FuncName, OutputAux, Context, Signature, MaybeBody, !IO) :- output_func_decl_for_java(Info, Stream, Indent, FuncName, OutputAux, Signature, !IO), io.write_string(Stream, "\n", !IO), ( MaybeBody = body_external % The signature above will be printed inside a comment. ; MaybeBody = body_defined_here(Body), FuncInfo = func_info_csj(Signature), % Do not place redundant brackets around a block. ( if Body = ml_stmt_block(_, _, _, _) then output_statement_for_java(Info, Stream, Indent, FuncInfo, Body, _ExitMethods, !IO) else io.write_string(Stream, "{\n", !IO), output_statement_for_java(Info, Stream, Indent + 1, FuncInfo, Body, _ExitMethods, !IO), indent_line_after_context(Stream, Info ^ joi_line_numbers, marker_comment, Context, Indent, !IO), io.write_string(Stream, "}\n", !IO) ) ). %---------------------------------------------------------------------------% :- pred output_function_decl_flags_for_java(java_out_info::in, io.text_output_stream::in, mlds_function_decl_flags::in, io::di, io::uo) is det. output_function_decl_flags_for_java(Info, Stream, Flags, !IO) :- Flags = mlds_function_decl_flags(Access, PerInstance), output_access_for_java(Info, Stream, Access, !IO), output_per_instance_for_java(Stream, PerInstance, !IO). :- pred output_access_for_java(java_out_info::in, io.text_output_stream::in, function_access::in, io::di, io::uo) is det. output_access_for_java(_Info, Stream, Access, !IO) :- ( Access = func_public, io.write_string(Stream, "public ", !IO) ; Access = func_private, io.write_string(Stream, "private ", !IO) ). :- pred output_per_instance_for_java(io.text_output_stream::in, per_instance::in, io::di, io::uo) is det. output_per_instance_for_java(Stream, PerInstance, !IO) :- ( PerInstance = per_instance ; PerInstance = one_copy, io.write_string(Stream, "static ", !IO) ). %---------------------------------------------------------------------------% :- end_module ml_backend.mlds_to_java_func. %---------------------------------------------------------------------------%