%-----------------------------------------------------------------------------% % Copyright (C) 2002-2004 The University of Melbourne. % This file may only be copied under the terms of the GNU General % Public License - see the file COPYING in the Mercury distribution. %-----------------------------------------------------------------------------% % File: make.module_target.m % Main author: stayl % % Build targets which relate to a single module (e.g. C code, object code, % interface files). %-----------------------------------------------------------------------------% :- module make__module_target. :- interface. % make_module_target(Target, Success, Info0, Info). % % Make a target corresponding to a single module. :- pred make_module_target(dependency_file::in, bool::out, make_info::in, make_info::out, io::di, io::uo) is det. % record_made_target(Target, Task, MakeSucceeded) % % Record whether building a target succeeded or not. % Makes sure any timestamps for files which may have changed % in building the target are recomputed next time they are needed. % Exported for use by make__module_dep_file__write_module_dep_file. :- pred record_made_target(target_file::in, compilation_task_type::in, bool::in, make_info::in, make_info::out, io::di, io::uo) is det. :- type foreign_code_file ---> foreign_code_file( foreign_language :: foreign_language, % Name of the file produced by the Mercury % compiler, e.g. module_c_code.c. target_file :: file_name, % Name of the file produced by the foreign % language compiler, e.g. module_c_code.o. object_file :: file_name ). % Find the foreign code files generated when a module is processed. % The `pic' field is only used for C foreign code. :- pred external_foreign_code_files(pic::in, module_imports::in, list(foreign_code_file)::out, io::di, io::uo) is det. %-----------------------------------------------------------------------------% :- implementation. :- import_module hlds__passes_aux. :- pred make_module_target(dependency_file::in, bool::in, bool::out, make_info::in, make_info::out, io::di, io::uo) is det. make_module_target(TargetFile, Succeeded1, Succeeded1 `and` Succeeded2, Info0, Info) --> make_module_target(TargetFile, Succeeded2, Info0, Info). make_module_target(file(_, _) @ Dep, Succeeded, Info0, Info) --> dependency_status(Dep, Status, Info0, Info), { Succeeded = ( Status = error -> no ; yes ) }. make_module_target(target(TargetFile) @ Dep, Succeeded, Info0, Info) --> dependency_status(Dep, Status, Info0, Info1), ( { Status = not_considered }, { TargetFile = ModuleName - FileType }, get_module_dependencies(ModuleName, MaybeImports, Info1, Info2), ( { MaybeImports = no }, { Succeeded = no }, { Info = Info2 ^ dependency_status ^ elem(Dep) := error } ; { MaybeImports = yes(Imports) }, globals__io_get_globals(Globals), { CompilationTask = compilation_task(Globals, FileType) }, ( % For a target built by processing a Mercury source file, % the target for a nested sub-module is produced as a side % effect of making the target for the top-level module in % the file. { CompilationTask = process_module(_) - _ }, { Imports ^ source_file_module_name \= ModuleName } -> make_module_target( target(Imports ^ source_file_module_name - FileType), Succeeded, Info2, Info) ; { CompilationTask = CompilationTaskType - _ }, touched_files(TargetFile, CompilationTaskType, TouchedTargetFiles, TouchedFiles, Info2, Info3), { list__foldl(update_target_status(being_built), TouchedTargetFiles, Info3, Info4) }, debug_file_msg(TargetFile, "checking dependencies"), { CompilationTask = process_module(_) - _ -> ModulesToCheck = [ModuleName | Imports ^ nested_children] ; ModulesToCheck = [ModuleName] }, foldl3_maybe_stop_at_error(Info4 ^ keep_going, union_deps(target_dependencies(Globals, FileType)), ModulesToCheck, DepsSuccess, set__init, DepFiles0, Info4, Info5), { TargetFile = _ - private_interface -> % Avoid circular dependencies (the `.int0' files % for the nested sub-modules depend on this module's % `.int0' file). DepFilesToMake = set__to_sorted_list( set__delete_list(DepFiles0, make_dependency_list(ModulesToCheck, private_interface))) ; DepFilesToMake = set__to_sorted_list(DepFiles0) }, { DepFiles = set__to_sorted_list(DepFiles0) }, debug_msg( (pred(di, uo) is det --> write_target_file(TargetFile), io__write_string(": dependencies:\n"), io__write_list(DepFiles, ", ", write_dependency_file), io__nl )), globals__io_lookup_bool_option(keep_going, KeepGoing), ( { DepsSuccess = no, KeepGoing = no } -> { Info6 = Info5 }, { DepsResult = error } ; make_dependency_files(TargetFile, DepFilesToMake, TouchedTargetFiles, TouchedFiles, DepsResult0, Info5, Info6), { DepsResult = ( DepsSuccess = yes -> DepsResult0 ; error ) } ), ( { DepsResult = error }, { Succeeded = no }, { list__foldl(update_target_status(error), TouchedTargetFiles, Info6, Info) } ; { DepsResult = out_of_date }, { Info7 = Info6 ^ command_line_targets := set__delete(Info6 ^ command_line_targets, ModuleName - module_target(FileType)) }, build_target(CompilationTask, TargetFile, Imports, TouchedTargetFiles, TouchedFiles, Succeeded, Info7, Info) ; { DepsResult = up_to_date }, maybe_warn_up_to_date_target( ModuleName - module_target(FileType), Info6, Info7), debug_file_msg(TargetFile, "up to date"), { Succeeded = yes }, { list__foldl(update_target_status(up_to_date), [TargetFile | TouchedTargetFiles], Info7, Info) } ) ) ) ; { Status = up_to_date }, { Succeeded = yes }, { Info = Info1 } ; { Status = being_built }, ( { TargetFile = _FileName - foreign_il_asm(_Lang) } -> io__write_string( "Error: circular dependency detected while building\n"), io__write_string(" `"), write_dependency_file(Dep), io__write_string("'.\n"), io__write_string( " This is due to a forbidden foreign_import_module cycle.\n"), io__set_exit_status(1) ; { error( "make_module_target: target being built, circular dependencies?" ) } ), { Succeeded = no }, { Info = Info1 } ; { Status = error }, { Succeeded = no }, { Info = Info1 } ). :- pred make_dependency_files(target_file::in, list(dependency_file)::in, list(target_file)::in, list(file_name)::in, dependencies_result::out, make_info::in, make_info::out, io::di, io::uo) is det. make_dependency_files(TargetFile, DepFilesToMake, TouchedTargetFiles, TouchedFiles, DepsResult, Info0, Info) --> % % Build the dependencies. % globals__io_lookup_bool_option(keep_going, KeepGoing), foldl2_maybe_stop_at_error(KeepGoing, make_module_target, DepFilesToMake, MakeDepsSuccess, Info0, Info1), % % Check that the target files exist. % list__map_foldl2(get_target_timestamp(no), TouchedTargetFiles, TargetTimestamps, Info1, Info2), ( { MakeDepsSuccess = no } -> debug_file_msg(TargetFile, "error making dependencies"), { DepsResult = error }, { Info = Info2 } ; { list__member(error(_), TargetTimestamps) } -> debug_file_msg(TargetFile, "target file does not exist"), { DepsResult = out_of_date }, { Info = Info2 } ; % % Compare the oldest of the timestamps of the touched % files with the timestamps of the dependencies. % list__map_foldl2(get_timestamp_file_timestamp, TouchedTargetFiles, TouchedTargetFileTimestamps, Info2, Info3), list__map_foldl2(get_file_timestamp([dir__this_directory]), TouchedFiles, TouchedFileTimestamps, Info3, Info4), { MaybeOldestTimestamp0 = list__foldl(find_oldest_timestamp, TouchedTargetFileTimestamps, ok(newest_timestamp)) }, { MaybeOldestTimestamp = list__foldl(find_oldest_timestamp, TouchedFileTimestamps, MaybeOldestTimestamp0) }, get_file_name(no, TargetFile, TargetFileName, Info4, Info5), check_dependencies(TargetFileName, MaybeOldestTimestamp, MakeDepsSuccess, DepFilesToMake, DepsResult, Info5, Info) ). %-----------------------------------------------------------------------------% :- pred build_target(compilation_task_result::in, target_file::in, module_imports::in, list(target_file)::in, list(file_name)::in, bool::out, make_info::in, make_info::out, io::di, io::uo) is det. build_target(CompilationTask, TargetFile, Imports, TouchedTargetFiles, TouchedFiles, Succeeded, Info0, Info) --> maybe_make_target_message(TargetFile), { TargetFile = ModuleName - _FileType }, { CompilationTask = Task - TaskOptions }, ( { CompilationTask = process_module(compile_to_target_code) - _ }, \+ { can_fork } -> % We need a temporary file to pass the arguments to % the mmc process which will do the compilation. % It's created here (not in invoke_mmc) so it can be % cleaned up by build_with_check_for_interrupt. io__make_temp(ArgFileName), { MaybeArgFileName = yes(ArgFileName) } ; { MaybeArgFileName = no } ), { Cleanup = (pred(MakeInfo0::in, MakeInfo::out, di, uo) is det --> % XXX Remove `.int.tmp' files. list__foldl2(remove_target_file, TouchedTargetFiles, MakeInfo0, MakeInfo1), list__foldl2(remove_file, TouchedFiles, MakeInfo1, MakeInfo), ( { MaybeArgFileName = yes(ArgFileName2) }, io__remove_file(ArgFileName2, _) ; { MaybeArgFileName = no } ) ) }, build_with_check_for_interrupt( build_with_module_options_and_output_redirect(ModuleName, TaskOptions, build_target_2(ModuleName, Task, MaybeArgFileName, Imports)), Cleanup, Succeeded, Info0, Info1), record_made_target_2(Succeeded, TargetFile, TouchedTargetFiles, TouchedFiles, Info1, Info). :- pred build_target_2(module_name::in, compilation_task_type::in, maybe(file_name)::in, module_imports::in, list(string)::in, io__output_stream::in, bool::out, make_info::in, make_info::out, io::di, io::uo) is det. build_target_2(ModuleName, process_module(ModuleTask), ArgFileName, _Imports, AllOptionArgs, ErrorStream, Succeeded, Info, Info) --> { prog_out__sym_name_to_string(ModuleName, ".", ModuleArg) }, globals__io_lookup_bool_option(verbose_commands, Verbose), ( { Verbose = yes } -> { AllArgs = list__append(AllOptionArgs, [ModuleArg]) }, io__write_string("Invoking command `mmc "), % XXX Don't write the default options. io__write_list(list__map(quote_arg, AllArgs), " ", io__write_string), io__write_string("'"), io__nl ; [] ), % % Run compilations to target code in a separate process. % This is necessary for `--target asm' because the GCC % backend can only be invoked once per process. It's a good % idea for other the backends because it avoids problems with % the Boehm GC retaining memory by scanning too much of the % Mercury stacks. If the compilation is run in a separate % process, it is also easier to kill if an interrupt arrives. % io__set_output_stream(ErrorStream, OldOutputStream), ( { ModuleTask = compile_to_target_code } -> call_in_forked_process(call_mercury_compile_main([ModuleArg]), invoke_mmc(ErrorStream, ArgFileName, AllOptionArgs ++ [ModuleArg]), Succeeded) ; call_mercury_compile_main([ModuleArg], Succeeded) ), io__set_output_stream(OldOutputStream, _), ( { ModuleTask = compile_to_target_code ; ModuleTask = errorcheck } -> % The `.err_date' file is needed because the `.err' % file is touched by all phases of compilation, including % writing interfaces. touch_interface_datestamp(ModuleName, ".err_date") ; [] ). build_target_2(ModuleName, target_code_to_object_code(PIC), _, Imports, _, ErrorStream, Succeeded, Info, Info) --> globals__io_get_target(CompilationTarget), % Run the compilation in a child process so it can % be killed if an interrupt arrives. call_in_forked_process( build_object_code(ModuleName, CompilationTarget, PIC, ErrorStream, Imports), Succeeded). build_target_2(ModuleName, foreign_code_to_object_code(PIC, Lang), _, Imports, _, ErrorStream, Succeeded, Info, Info) --> foreign_code_file(ModuleName, PIC, Lang, ForeignCodeFile), % Run the compilation in a child process so it can % be killed if an interrupt arrives. call_in_forked_process( compile_foreign_code_file(ErrorStream, PIC, Imports, ForeignCodeFile), Succeeded). build_target_2(ModuleName, fact_table_code_to_object_code(PIC, FactTableFile), _, Imports, _, ErrorStream, Succeeded, Info, Info) --> fact_table_foreign_code_file(ModuleName, PIC, FactTableFile, FactTableForeignCode), % Run the compilation in a child process so it can % be killed if an interrupt arrives. call_in_forked_process( compile_foreign_code_file(ErrorStream, PIC, Imports, FactTableForeignCode), Succeeded). :- pred build_object_code(module_name::in, compilation_target::in, pic::in, io__output_stream::in, module_imports::in, bool::out, io::di, io::uo) is det. build_object_code(ModuleName, c, PIC, ErrorStream, _Imports, Succeeded) --> compile_target_code__compile_c_file(ErrorStream, PIC, ModuleName, Succeeded). build_object_code(ModuleName, asm, PIC, ErrorStream, _Imports, Succeeded) --> compile_target_code__assemble(ErrorStream, PIC, ModuleName, Succeeded). build_object_code(ModuleName, java, _, ErrorStream, _Imports, Succeeded) --> module_name_to_file_name(ModuleName, ".java", yes, JavaFile), compile_target_code__compile_java_file(ErrorStream, JavaFile, Succeeded). build_object_code(ModuleName, il, _, ErrorStream, Imports, Succeeded) --> compile_target_code__il_assemble(ErrorStream, ModuleName, Imports ^ has_main, Succeeded). :- pred compile_foreign_code_file(io__output_stream::in, pic::in, module_imports::in, foreign_code_file::in, bool::out, io::di, io::uo) is det. compile_foreign_code_file(ErrorStream, PIC, _Imports, foreign_code_file(c, CFile, ObjFile), Succeeded) --> compile_target_code__compile_c_file(ErrorStream, PIC, CFile, ObjFile, Succeeded). compile_foreign_code_file(ErrorStream, _, _Imports, foreign_code_file(il, ILFile, DLLFile), Succeeded) --> compile_target_code__il_assemble(ErrorStream, ILFile, DLLFile, no_main, Succeeded). compile_foreign_code_file(ErrorStream, _, _Imports, foreign_code_file(java, JavaFile, _ClassFile), Succeeded) --> compile_target_code__compile_java_file(ErrorStream, JavaFile, Succeeded). compile_foreign_code_file(ErrorStream, _, _Imports, foreign_code_file(managed_cplusplus, MCPPFile, DLLFile), Succeeded) --> compile_target_code__compile_managed_cplusplus_file(ErrorStream, MCPPFile, DLLFile, Succeeded). compile_foreign_code_file(ErrorStream, _, Imports, foreign_code_file(csharp, CSharpFile, DLLFile), Succeeded) --> compile_target_code__compile_csharp_file(ErrorStream, Imports, CSharpFile, DLLFile, Succeeded). %-----------------------------------------------------------------------------% :- pred foreign_code_file(module_name::in, pic::in, foreign_language::in, foreign_code_file::out, io::di, io::uo) is det. foreign_code_file(ModuleName, PIC, Lang, ForeignCodeFile) --> globals__io_get_globals(Globals), { ForeignModName0 = foreign_language_module_name( ModuleName, Lang), SrcExt0 = foreign_language_file_extension(Lang) -> ForeignModName = ForeignModName0, SrcExt = SrcExt0 ; unexpected(this_file, "unsupported foreign language") }, { ObjExt = get_object_extension(Globals, PIC) }, module_name_to_file_name(ForeignModName, SrcExt, yes, SrcFileName), module_name_to_file_name(ForeignModName, ObjExt, yes, ObjFileName), { ForeignCodeFile = foreign_code_file(Lang, SrcFileName, ObjFileName) }. :- pred fact_table_foreign_code_file(module_name::in, pic::in, string::in, foreign_code_file::out, io::di, io::uo) is det. fact_table_foreign_code_file(ModuleName, PIC, FactTableName, ForeignCodeFile) --> globals__io_get_globals(Globals), { ObjExt = get_object_extension(Globals, PIC) }, fact_table_file_name(ModuleName, FactTableName, ".c", yes, CFile), fact_table_file_name(ModuleName, FactTableName, ObjExt, yes, ObjFile), { ForeignCodeFile = foreign_code_file(c, CFile, ObjFile) }. :- func get_object_extension(globals, pic) = string. get_object_extension(Globals, PIC) = Ext :- globals__get_target(Globals, CompilationTarget), ( CompilationTarget = c, maybe_pic_object_file_extension(Globals, PIC, Ext) ; CompilationTarget = asm, maybe_pic_object_file_extension(Globals, PIC, Ext) ; CompilationTarget = il, Ext = ".dll" ; CompilationTarget = java, sorry(this_file, "object extension for java") ). %-----------------------------------------------------------------------------% :- pred call_mercury_compile_main(list(string)::in, bool::out, io::di, io::uo) is det. call_mercury_compile_main(Args, Succeeded) --> io__get_exit_status(Status0), io__set_exit_status(0), mercury_compile__main(Args), io__get_exit_status(Status), { Succeeded = ( Status = 0 -> yes ; no ) }, io__set_exit_status(Status0). :- pred invoke_mmc(io__output_stream::in, maybe(file_name)::in, list(string)::in, bool::out, io::di, io::uo) is det. invoke_mmc(ErrorStream, MaybeArgFileName, Args, Succeeded) --> io__progname("", ProgName), ( { ProgName = "" } -> io__get_environment_var("MERCURY_COMPILER", MaybeMercuryCompiler), { MaybeMercuryCompiler = yes(MercuryCompiler) ; MaybeMercuryCompiler = no, MercuryCompiler = "mmc" } ; { MercuryCompiler = ProgName } ), { QuotedArgs = list__map(quote_arg, Args) }, % Some operating systems (e.g. Windows) have shells with % ludicrously short limits on the length of command lines, % so we need to write the arguments to a file which will % be read by the child mmc process. % This code is only called if fork() doesn't work, so there's % no point checking whether the shell actually has this % limitation. % The temporary file is created by the caller so that it will be % removed by build_with_check_for_interrupt if an interrupt occurs. { MaybeArgFileName = yes(ArgFileName) ; MaybeArgFileName = no, error( "make.module_target.invoke_mmc: argument file not created") }, io__open_output(ArgFileName, ArgFileOpenRes), ( { ArgFileOpenRes = ok(ArgFileStream) }, io__write_string(ArgFileStream, "MCFLAGS = "), io__write_list(ArgFileStream, QuotedArgs, " ", io__write_string), io__nl(ArgFileStream), io__close_output(ArgFileStream), { Command = string__join_list(" ", [quote_arg(MercuryCompiler), "--arg-file", quote_arg(ArgFileName)]) }, % We've already written the command. { CommandVerbosity = verbose }, invoke_system_command(ErrorStream, CommandVerbosity, Command, Succeeded) ; { ArgFileOpenRes = error(Error) }, { Succeeded = no }, io__write_string("Error opening `"), io__write_string(ArgFileName), io__write_string("' for output: "), io__write_string(io__error_message(Error)), io__nl ), io__remove_file(ArgFileName, _). %-----------------------------------------------------------------------------% record_made_target(TargetFile, CompilationTask, Succeeded, Info0, Info) --> touched_files(TargetFile, CompilationTask, TouchedTargetFiles, TouchedFiles, Info0, Info1), record_made_target_2(Succeeded, TargetFile, TouchedTargetFiles, TouchedFiles, Info1, Info). :- pred record_made_target_2(bool::in, target_file::in, list(target_file)::in, list(file_name)::in, make_info::in, make_info::out, io::di, io::uo) is det. record_made_target_2(Succeeded, TargetFile, TouchedTargetFiles, OtherTouchedFiles, Info0, Info) --> ( { Succeeded = yes } -> { TargetStatus = up_to_date }, { Info1 = Info0 } ; { TargetStatus = error }, { Info1 = Info0 }, target_file_error(TargetFile) ), { list__foldl(update_target_status(TargetStatus), TouchedTargetFiles, Info1, Info2) }, { DeleteTimestamp = (pred(TouchedFile::in, MakeInfo0::in, MakeInfo::out) is det :- MakeInfo = MakeInfo0 ^ file_timestamps := map__delete(MakeInfo0 ^ file_timestamps, TouchedFile) ) }, list__map_foldl2(get_file_name(no), TouchedTargetFiles, TouchedTargetFileNames, Info2, Info3), { list__foldl(DeleteTimestamp, TouchedTargetFileNames, Info3, Info4) }, { list__foldl(DeleteTimestamp, OtherTouchedFiles, Info4, Info) }. :- pred update_target_status(dependency_status::in, target_file::in, make_info::in, make_info::out) is det. update_target_status(TargetStatus, TargetFile, Info, Info ^ dependency_status ^ elem(target(TargetFile)) := TargetStatus). %-----------------------------------------------------------------------------% :- type compilation_task_result == pair(compilation_task_type, list(string)). :- func compilation_task(globals, module_target_type) = compilation_task_result. compilation_task(_, source) = _ :- error("compilation_task"). compilation_task(_, errors) = process_module(errorcheck) - ["--errorcheck-only"]. compilation_task(_, unqualified_short_interface) = process_module(make_short_interface) - ["--make-short-interface"]. compilation_task(Globals, short_interface) = compilation_task(Globals, long_interface). compilation_task(_, long_interface) = process_module(make_interface) - ["--make-interface"]. compilation_task(_, private_interface) = process_module(make_private_interface) - ["--make-private-interface"]. compilation_task(_, intermodule_interface) = process_module(make_optimization_interface) - ["--make-optimization-interface"]. compilation_task(_, aditi_code) = process_module(compile_to_target_code) - ["--aditi-only"]. compilation_task(Globals, c_header(_)) = compilation_task(Globals, c_code). compilation_task(_, c_code) = process_module(compile_to_target_code) - ["--compile-to-c"]. compilation_task(_, il_code) = process_module(compile_to_target_code) - ["--il-only"]. compilation_task(_, il_asm) = target_code_to_object_code(non_pic) - []. compilation_task(_, java_code) = process_module(compile_to_target_code) - ["--java-only"]. compilation_task(_, asm_code(PIC)) = process_module(compile_to_target_code) - ( PIC = pic -> ["--pic"] ; [] ). compilation_task(_, object_code(PIC)) = target_code_to_object_code(PIC) - get_pic_flags(PIC). compilation_task(_, foreign_il_asm(Lang)) = foreign_code_to_object_code(non_pic, Lang) - []. compilation_task(_, foreign_object(PIC, Lang)) = foreign_code_to_object_code(PIC, Lang) - get_pic_flags(PIC). compilation_task(_, fact_table_object(PIC, FactTable)) = fact_table_code_to_object_code(PIC, FactTable) - get_pic_flags(PIC). :- func get_pic_flags(pic) = list(string). % `--pic-reg' is harmless for architectures and grades where % it is not needed (it's only needed for grades using % GCC global register variables on x86). get_pic_flags(pic) = ["--pic", "--pic-reg"]. get_pic_flags(link_with_pic) = ["--pic-reg"]. get_pic_flags(non_pic) = []. % Find the files which could be touched by a compilation task. :- pred touched_files(target_file::in, compilation_task_type::in, list(target_file)::out, list(file_name)::out, make_info::in, make_info::out, io::di, io::uo) is det. touched_files(TargetFile, process_module(Task), TouchedTargetFiles, TouchedFileNames, Info0, Info) --> { TargetFile = ModuleName - FileType }, get_module_dependencies(ModuleName, MaybeImports, Info0, Info1), { MaybeImports = yes(Imports0) -> Imports = Imports0 ; % This error should have been caught earlier. % We shouldn't be attempting to build a target % if we couldn't find the dependencies for the % module. error("touched_files: no module dependencies") }, { NestedChildren = Imports ^ nested_children }, { SourceFileModuleNames = [ModuleName | NestedChildren] }, list__map_foldl2(get_module_dependencies, NestedChildren, MaybeNestedImportsList, Info1, Info), { list__map( (pred(yes(NestedModuleImports)::in, NestedModuleImports::out) is semidet), MaybeNestedImportsList, NestedImportsList) -> ModuleImportsList = [Imports | NestedImportsList] ; % This error should have been caught earlier. % We shouldn't be attempting to build a target % if we couldn't find the dependencies for the % module or its nested sub-modules. error("touched_files: no nested module dependencies") }, globals__io_get_target(CompilationTarget), { Task = compile_to_target_code, CompilationTarget = asm -> % For `--target asm' the code for the nested children % is placed in the `.s' file for the top-level module % in the source file. TargetModuleNames = [ModuleName] ; TargetModuleNames = SourceFileModuleNames }, % % Find out what header files are generated. % ( { Task = compile_to_target_code } -> list__map_foldl( external_foreign_code_files(target_type_to_pic(FileType)), ModuleImportsList, ForeignCodeFileList), { ForeignCodeFiles = list__map( (func(ForeignFile) = ForeignFile ^ target_file), list__condense(ForeignCodeFileList)) }, ( { CompilationTarget = c }, globals__io_lookup_bool_option(highlevel_code, HighLevelCode), ( { HighLevelCode = yes } -> % % When compiling to high-level C, we always generate % a header file. % { HeaderModuleNames = SourceFileModuleNames }, { HeaderTargets0 = make_target_list(HeaderModuleNames, c_header(mih)) } ; { HeaderTargets0 = [] } ) ; { CompilationTarget = asm }, % % When compiling to assembler, we only generate % a header file if the module contains foreign code. % { HeaderModuleNames = list__filter_map( (func(MImports) = MImports ^ module_name is semidet :- contains_foreign_code(_) = MImports ^ foreign_code ), ModuleImportsList) }, { HeaderTargets0 = make_target_list(HeaderModuleNames, c_header(mih)) } ; { CompilationTarget = il }, { HeaderTargets0 = [] } ; { CompilationTarget = java }, { HeaderTargets0 = [] } ), { ( CompilationTarget = c ; CompilationTarget = asm ) -> Names = SourceFileModuleNames, HeaderTargets = make_target_list(Names, c_header(mh)) ++ HeaderTargets0 ; HeaderTargets = HeaderTargets0 }, { TouchedTargetFiles0 = make_target_list(TargetModuleNames, FileType) }, { TouchedTargetFiles = TouchedTargetFiles0 ++ HeaderTargets } ; { Task = make_interface } -> % Both long and short interface files are produced % when making the interface. { ForeignCodeFiles = [] }, { TouchedTargetFiles = make_target_list(TargetModuleNames, long_interface) ++ make_target_list(TargetModuleNames, short_interface) } ; { ForeignCodeFiles = [] }, { TouchedTargetFiles = make_target_list(TargetModuleNames, FileType) } ), globals__io_get_globals(Globals), list__foldl2( (pred((TargetModuleName - TargetFileType)::in, TimestampFiles0::in, TimestampFiles1::out, di, uo) is det --> ( { TimestampExt = timestamp_extension(Globals, TargetFileType) } -> module_name_to_file_name(TargetModuleName, TimestampExt, no, TimestampFile), { TimestampFiles1 = [TimestampFile | TimestampFiles0] } ; { TimestampFiles1 = TimestampFiles0 } ) ), TouchedTargetFiles, [], TimestampFileNames), { TouchedFileNames = list__condense([ForeignCodeFiles, TimestampFileNames]) }. touched_files(TargetFile, target_code_to_object_code(_), [TargetFile], [], Info, Info) --> []. touched_files(TargetFile, foreign_code_to_object_code(PIC, Lang), [TargetFile], [ForeignObjectFile], Info, Info) --> { TargetFile = ModuleName - _ }, foreign_code_file(ModuleName, PIC, Lang, ForeignCodeFile), { ForeignObjectFile = ForeignCodeFile ^ object_file }. touched_files(TargetFile, fact_table_code_to_object_code(PIC, FactTableName), [TargetFile], [FactTableObjectFile], Info, Info) --> { TargetFile = ModuleName - _ }, globals__io_get_globals(Globals), { ObjExt = get_object_extension(Globals, PIC) }, fact_table_file_name(ModuleName, FactTableName, ObjExt, yes, FactTableObjectFile). external_foreign_code_files(PIC, Imports, ForeignFiles) --> % % Find externally compiled foreign code files for % `:- pragma foreign_proc' declarations. % maybe_pic_object_file_extension(PIC, ObjExt), globals__io_get_target(CompilationTarget), { ModuleName = Imports ^ module_name }, ( { CompilationTarget = asm }, { Imports ^ foreign_code = contains_foreign_code(Langs) }, { set__member(c, Langs) } -> module_name_to_file_name( foreign_language_module_name(ModuleName, c), ".c", no, CCodeFileName), module_name_to_file_name( foreign_language_module_name(ModuleName, c), ObjExt, no, ObjFileName), { ForeignFiles0 = [foreign_code_file(c, CCodeFileName, ObjFileName) ] } ; { CompilationTarget = il }, { Imports ^ foreign_code = contains_foreign_code(Langs) } -> list__map_foldl(external_foreign_code_files_for_il(ModuleName), set__to_sorted_list(Langs), ForeignFilesList), { list__condense(ForeignFilesList, ForeignFiles0) } ; { ForeignFiles0 = [] } ), % % Find externally compiled foreign code files for fact tables. % ( { CompilationTarget = c ; CompilationTarget = asm } -> list__map_foldl( (pred(FactTableFile::in, FactTableForeignFile::out, di, uo) is det --> fact_table_file_name(ModuleName, FactTableFile, ".c", no, FactTableCFile), fact_table_file_name(ModuleName, FactTableFile, ObjExt, no, FactTableObjFile), { FactTableForeignFile = foreign_code_file(c, FactTableCFile, FactTableObjFile) } ), Imports ^ fact_table_deps, FactTableForeignFiles), { ForeignFiles = ForeignFiles0 ++ FactTableForeignFiles } ; { ForeignFiles = ForeignFiles0 } ). :- pred external_foreign_code_files_for_il(module_name::in, foreign_language::in, list(foreign_code_file)::out, io::di, io::uo) is det. external_foreign_code_files_for_il(ModuleName, Language, ForeignFiles, !IO) :- ( ForeignModuleName = foreign_language_module_name(ModuleName, Language), ForeignExt = foreign_language_file_extension(Language) -> module_name_to_file_name(ForeignModuleName, ForeignExt, yes, ForeignFileName, !IO), module_name_to_file_name(ForeignModuleName, ".dll", yes, ForeignDLLFileName, !IO), ForeignFiles = [foreign_code_file(Language, ForeignFileName, ForeignDLLFileName)] ; % No external file is generated for this foreign language. ForeignFiles = [] ). :- func target_type_to_pic(module_target_type) = pic. target_type_to_pic(TargetType) = Result :- ( TargetType = asm_code(PIC) -> Result = PIC ; TargetType = object_code(PIC) -> Result = PIC ; Result = non_pic ). %-----------------------------------------------------------------------------% :- func this_file = string. this_file = "make.module_target.m". %-----------------------------------------------------------------------------%