Fortran Package Manager (fpm)

Fortran Package Manager (fpm)#

Fortran Package Manager is a package manager and build system for Fortran.

All 56 modules from fpm v0.13.0 are auto-documented below via the FORD bridge.

module fpm#

Uses: fpm_strings, fpm_backend, fpm_command_line, fpm_dependency, fpm_filesystem, fpm_model, fpm_compiler, fpm_sources, fpm_targets, fpm_manifest, fpm_manifest_platform, fpm_meta, fpm_error, fpm_toml, iso_fortran_env, iso_c_binding, fpm_environment, fpm_settings

pure function assemble_flags(cli_flag, package_flag, fallback)#

Arguments:

character(len=*), intent(in), optional :: cli_flag
character(len=*), intent(in), optional :: package_flag
character(len=*), intent(in), optional :: fallback

Returns: character(len=:), allocatable

function should_be_run(settings, run_scope, exe_target)#

Arguments:

class (fpm_run_settings), intent(in) :: settings
integer, intent(in) :: run_scope
type (build_target_t), intent(in) :: exe_target

Returns: logical

function save_library_path()#: Returns: character(len=:), allocatable

subroutine build_model(model, settings, package_config, error)#

Arguments:

type (fpm_model_t), intent(out) :: model
class (fpm_build_settings), intent(inout) :: settings
type (package_config_t), intent(inout), target :: package_config
type (error_t), intent(out), allocatable :: error

subroutine new_compiler_flags(model, settings, package)#

Arguments:

type (fpm_model_t), intent(inout) :: model
type (fpm_build_settings), intent(in) :: settings
type (package_config_t), intent(in) :: package

subroutine check_modules_for_duplicates(model, duplicates_found)#

Arguments:

type (fpm_model_t), intent(in) :: model
logical :: duplicates_found

subroutine check_module_names(model, error)#

Arguments:

type (fpm_model_t), intent(in) :: model
type (error_t), intent(out), allocatable :: error

subroutine cmd_build(settings)#

Arguments:

type (fpm_build_settings), intent(inout) :: settings

subroutine cmd_run(settings, test)#

Arguments:

class (fpm_run_settings), intent(inout) :: settings
logical, intent(in) :: test

subroutine delete_skip(is_unix)#

Arguments:

logical, intent(in) :: is_unix

subroutine delete_targets_by_scope(targets, scope, scope_name, deleted_any)#

Arguments:

type (build_target_ptr), intent(in) :: targets
integer, intent(in) :: scope
character(len=*), intent(in) :: scope_name
logical, intent(inout) :: deleted_any

subroutine delete_targets(settings, error)#

Arguments:

class (fpm_clean_settings), intent(inout) :: settings
type (error_t), intent(out), allocatable :: error

subroutine cmd_clean(settings)#

Arguments:

class (fpm_clean_settings), intent(inout) :: settings

pure subroutine sort_executables(target_ID, executables)#

Arguments:

integer, intent(inout), allocatable :: target_ID
type (string_t), intent(inout), allocatable :: executables

subroutine set_library_path(model, targets, error)#

Arguments:

type (fpm_model_t), intent(in) :: model
type (build_target_ptr), intent(inout), target :: targets
type (error_t), intent(out), allocatable :: error

subroutine restore_library_path(saved_path, error)#

Arguments:

character(len=*), intent(in) :: saved_path
type (error_t), intent(out), allocatable :: error

module fpm_backend#

Uses: iso_fortran_env, fpm_error, fpm_filesystem, fpm_model, fpm_strings, fpm_targets, fpm_backend_output, fpm_compile_commands

interface c_isatty#

subroutine build_package(targets, model, verbose, dry_run)#

Arguments:

type (build_target_ptr), intent(inout) :: targets
type (fpm_model_t), intent(in) :: model
logical, intent(in) :: verbose
logical, intent(in) :: dry_run

recursive subroutine sort_target(target, mock)#

Arguments:

type (build_target_t), intent(inout), target :: target
logical, intent(in), optional :: mock

subroutine schedule_targets(queue, schedule_ptr, targets)#

Arguments:

type (build_target_ptr), intent(out), allocatable :: queue
integer, allocatable :: schedule_ptr
type (build_target_ptr), intent(in) :: targets

subroutine build_target(model, target, verbose, dry_run, table, stat)#

Arguments:

type (fpm_model_t), intent(in) :: model
type (build_target_t), intent(in), target :: target
logical, intent(in) :: verbose
logical, intent(in) :: dry_run
type (compile_command_table_t), intent(inout) :: table
integer, intent(out) :: stat

subroutine print_build_log(target)#

Arguments:

type (build_target_t), intent(in), target :: target

module fpm_backend_console#

Uses: iso_fortran_env

parameter ESC = char(27)#: Type: character(len=*)

parameter LINE_RESET = ESC//"[2K"//ESC//"[1G"#: Type: character(len=*)

parameter LINE_UP = ESC//"[1A"#: Type: character(len=*)

parameter LINE_DOWN = ESC//"[1B"#: Type: character(len=*)

parameter COLOR_RED = ESC//"[31m"#: Type: character(len=*)

parameter COLOR_GREEN = ESC//"[32m"#: Type: character(len=*)

parameter COLOR_YELLOW = ESC//"[93m"#: Type: character(len=*)

parameter COLOR_RESET = ESC//"[0m"#: Type: character(len=*)

type console_t#

member n_line = 1#: Type: integer

procedure write_line#: Binds to: console_write_line

procedure update_line#: Binds to: console_update_line

subroutine console_write_line(console, str, line, advance)#

Arguments:

class (console_t), intent(inout) :: console
character(len=*), intent(in) :: str
integer, intent(out), optional :: line
logical, intent(in), optional :: advance

subroutine console_update_line(console, line_no, str)#

Arguments:

class (console_t), intent(in) :: console
integer, intent(in) :: line_no
character(len=*), intent(in) :: str

module fpm_backend_output#

Uses: iso_fortran_env, fpm_error, fpm_filesystem, fpm_targets, fpm_backend_console, fpm_compile_commands

type build_progress_t#

member console#: Type: type (console_t)

member n_complete#: Type: integer

member n_target#: Type: integer

member plain_mode = .true.#: Type: logical

member output_lines#: Type: integer, allocatable

member build_dir#: Type: character(len=:), allocatable

member target_queue#: Type: type (build_target_ptr), pointer

member compile_commands#: Type: type (compile_command_table_t)

procedure compiling_status#: Binds to: output_status_compiling

procedure completed_status#: Binds to: output_status_complete

procedure success#: Binds to: output_progress_success

procedure dump_commands#: Binds to: output_write_compile_commands

Constructors:

function new_build_progress(target_queue, plain_mode, build_dir)#

Arguments:

type (build_target_ptr), intent(in), target :: target_queue
logical, intent(in), optional :: plain_mode
character(len=*), intent(in), optional :: build_dir

Returns: type (build_progress_t)

subroutine output_status_compiling(progress, queue_index)#

Arguments:

class (build_progress_t), intent(inout) :: progress
integer, intent(in) :: queue_index

subroutine output_status_complete(progress, queue_index, build_stat)#

Arguments:

class (build_progress_t), intent(inout) :: progress
integer, intent(in) :: queue_index
integer, intent(in) :: build_stat

subroutine output_progress_success(progress)#

Arguments:

class (build_progress_t), intent(inout) :: progress

subroutine output_write_compile_commands(progress, error)#

Arguments:

class (build_progress_t), intent(inout) :: progress
type (error_t), allocatable :: error

module fpm_cmd_export#

Uses: fpm_command_line, fpm_dependency, fpm_error, fpm_filesystem, fpm_manifest, fpm_toml, fpm_model, fpm

subroutine cmd_export(settings)#

Arguments:

type (fpm_export_settings), intent(inout) :: settings

subroutine handle_error(error)#

Arguments:

type (error_t), intent(in), optional :: error

module fpm_cmd_install#

Uses: iso_fortran_env, fpm, fpm_backend, fpm_command_line, fpm_error, fpm_filesystem, fpm_installer, fpm_manifest, fpm_model, fpm_targets, fpm_strings

subroutine cmd_install(settings)#

Arguments:

type (fpm_install_settings), intent(inout) :: settings

subroutine install_info(unit, verbose, targets, ntargets)#

Arguments:

integer, intent(in) :: unit
logical, intent(in) :: verbose
type (build_target_ptr), intent(in) :: targets
integer, intent(out) :: ntargets

subroutine install_module_files(installer, targets, error)#

Arguments:

type (installer_t), intent(inout) :: installer
type (build_target_ptr), intent(in) :: targets
type (error_t), intent(out), allocatable :: error

subroutine install_executables(installer, targets, error)#

Arguments:

type (installer_t), intent(inout) :: installer
type (build_target_ptr), intent(in) :: targets
type (error_t), intent(out), allocatable :: error

subroutine install_tests(installer, targets, error)#

Arguments:

type (installer_t), intent(inout) :: installer
type (build_target_ptr), intent(in) :: targets
type (error_t), intent(out), allocatable :: error

subroutine handle_error(error)#

Arguments:

type (error_t), intent(in), optional :: error

module fpm_cmd_new#

Uses: fpm_command_line, fpm_environment, fpm_filesystem, fpm_strings, fpm_error, iso_fortran_env

subroutine cmd_new(settings)#

Arguments:

type (fpm_new_settings), intent(in) :: settings

module fpm_cmd_publish#

Uses: fpm_command_line, fpm_manifest, fpm_model, fpm_error, fpm_versioning, fpm_filesystem, fpm_git, fpm_downloader, fpm_strings, fpm_settings, fpm

subroutine cmd_publish(settings)#

Arguments:

type (fpm_publish_settings), intent(inout) :: settings

subroutine print_upload_data(upload_data)#

Arguments:

type (string_t), intent(in) :: upload_data

module fpm_cmd_update#

Uses: fpm_command_line, fpm_dependency, fpm_error, fpm_filesystem, fpm_manifest, fpm_toml

subroutine cmd_update(settings)#

Arguments:

type (fpm_update_settings), intent(in) :: settings

subroutine handle_error(error)#

Arguments:

type (error_t), intent(in), optional :: error

module fpm_command_line#

Uses: fpm_environment, M_CLI2, fpm_strings, fpm_filesystem, fpm_error, fpm_os, fpm_release, iso_fortran_env

parameter ibug = 4096#: Type: integer

variable name#: Type: character(len=:), allocatable

variable os_type#: Type: character(len=:), allocatable

variable names#: Type: character(len=ibug), allocatable

variable tnames#: Type: character(len=:), allocatable

variable version_text#: Type: character(len=:), allocatable

variable help_new#: Type: character(len=:), allocatable

variable help_fpm#: Type: character(len=:), allocatable

variable help_run#: Type: character(len=:), allocatable

variable help_test#: Type: character(len=:), allocatable

variable help_build#: Type: character(len=:), allocatable

variable help_usage#: Type: character(len=:), allocatable

variable help_runner#: Type: character(len=:), allocatable

variable help_text#: Type: character(len=:), allocatable

variable help_install#: Type: character(len=:), allocatable

variable help_help#: Type: character(len=:), allocatable

variable help_update#: Type: character(len=:), allocatable

variable help_list#: Type: character(len=:), allocatable

variable help_list_dash#: Type: character(len=:), allocatable

variable help_list_nodash#: Type: character(len=:), allocatable

variable help_clean#: Type: character(len=:), allocatable

variable help_publish#: Type: character(len=:), allocatable

parameter manual = [character(len=20)::' ', 'fpm', 'new', 'build', 'run', 'clea...#: Type: character(len=20)

variable val_runner#: Type: character(len=:), allocatable

variable val_runner_args#: Type: character(len=:), allocatable

variable val_dump#: Type: character(len=:), allocatable

parameter help_text_build_common = [character(len=80)::' --profile PROF Selects either a com...#: Type: character(len=80)

parameter help_text_compiler = [character(len=80)::' --compiler NAME Specify a compiler...#: Type: character(len=80)

parameter help_text_flag = [character(len=80)::' --flag FFLAGS selects compile argu...#: Type: character(len=80)

parameter help_text_environment = [character(len=80)::'ENVIRONMENT VARIABLES', ' FPM_FC...#: Type: character(len=80)

type fpm_cmd_settings#

member working_dir#: Type: character(len=:), allocatable

member path_to_config#: Type: character(len=:), allocatable

member verbose = .true.#: Type: logical

type fpm_new_settings, extends(fpm_cmd_settings)#

member name#: Type: character(len=:), allocatable

member with_executable = .false.#: Type: logical

member with_test = .false.#: Type: logical

member with_lib = .true.#: Type: logical

member with_example = .false.#: Type: logical

member with_full = .false.#: Type: logical

member with_bare = .false.#: Type: logical

member backfill = .true.#: Type: logical

type fpm_build_settings, extends(fpm_cmd_settings)#

member list = .false.#: Type: logical

member show_model = .false.#: Type: logical

member build_tests = .false.#: Type: logical

member prune = .true.#: Type: logical

member dump#: Type: character(len=:), allocatable

member compiler#: Type: character(len=:), allocatable

member c_compiler#: Type: character(len=:), allocatable

member cxx_compiler#: Type: character(len=:), allocatable

member archiver#: Type: character(len=:), allocatable

member profile#: Type: character(len=:), allocatable

member features#: Type: type (string_t), allocatable

member flag#: Type: character(len=:), allocatable

member cflag#: Type: character(len=:), allocatable

member cxxflag#: Type: character(len=:), allocatable

member ldflag#: Type: character(len=:), allocatable

member build_dir#: Type: character(len=:), allocatable

type fpm_run_settings, extends(fpm_build_settings)#

member name#: Type: character(len=ibug), allocatable

member args#: Type: character(len=:), allocatable

member runner#: Type: character(len=:), allocatable

member runner_args#: Type: character(len=:), allocatable

member example#: Type: logical

procedure runner_command#: Binds to: runner_command

procedure name_ID#: Binds to: name_ID

type fpm_test_settings, extends(fpm_run_settings)#

type fpm_install_settings, extends(fpm_build_settings)#

member prefix#: Type: character(len=:), allocatable

member bindir#: Type: character(len=:), allocatable

member libdir#: Type: character(len=:), allocatable

member testdir#: Type: character(len=:), allocatable

member includedir#: Type: character(len=:), allocatable

member no_rebuild#: Type: logical

type fpm_update_settings, extends(fpm_cmd_settings)#

member name#: Type: character(len=ibug), allocatable

member dump#: Type: character(len=:), allocatable

member fetch_only#: Type: logical

member clean#: Type: logical

type fpm_export_settings, extends(fpm_build_settings)#

member dump_manifest#: Type: character(len=:), allocatable

member dump_dependencies#: Type: character(len=:), allocatable

member dump_model#: Type: character(len=:), allocatable

type fpm_clean_settings, extends(fpm_build_settings)#

member clean_skip = .false.#: Type: logical

member clean_all = .false.#: Type: logical

member clean_test = .false.#: Type: logical

member clean_apps = .false.#: Type: logical

member clean_examples = .false.#: Type: logical

member registry_cache = .false.#: Type: logical

type fpm_publish_settings, extends(fpm_build_settings)#

member show_package_version = .false.#: Type: logical

member show_upload_data = .false.#: Type: logical

member is_dry_run = .false.#: Type: logical

member token#: Type: character(len=:), allocatable

function get_fpm_env(env, default)#

Arguments:

character(len=*), intent(in) :: env
character(len=*), intent(in) :: default

Returns: character(len=:), allocatable

function runner_command(cmd)#

Arguments:

class (fpm_run_settings), intent(in) :: cmd

Returns: character(len=:), allocatable

function name_ID(cmd, name)#

Arguments:

class (fpm_run_settings), intent(in) :: cmd
character(len=*), intent(in) :: name

Returns: integer

subroutine get_command_line_settings(cmd_settings)#

Arguments:

class (fpm_cmd_settings), intent(out), allocatable :: cmd_settings

subroutine validate_build_dir(build_dir)#

Arguments:

character(len=*), intent(in) :: build_dir

subroutine printhelp(lines)#

Arguments:

character(len=:), intent(in), allocatable :: lines

subroutine set_help()#

subroutine get_char_arg(var, arg)#

Arguments:

character(len=:), intent(out), allocatable :: var
character(len=*), intent(in) :: arg

subroutine build_settings(self, list, show_model, build_tests, config_file)#

Arguments:

class (fpm_build_settings), intent(inout) :: self
logical, intent(in), optional :: list
logical, intent(in), optional :: show_model
logical, intent(in), optional :: build_tests
character(len=*), intent(in), optional :: config_file

subroutine parse_features(features_str, features_array)#

Arguments:

character(len=*), intent(in) :: features_str
type (string_t), intent(out), allocatable :: features_array

module fpm_compile_commands#

Uses: fpm_toml, tomlf, jonquil, fpm_strings, fpm_error, fpm_os, fpm_environment, shlex_module

type compile_command_t, extends(serializable_t)#

member directory#: Type: type (string_t)

member arguments#: Type: type (string_t), allocatable

member file#: Type: type (string_t)

procedure destroy#: Binds to: compile_command_destroy

procedure serializable_is_same#: Binds to: compile_command_is_same

procedure dump_to_toml#: Binds to: compile_command_dump_toml

procedure load_from_toml#: Binds to: compile_command_load_toml

Constructors:

function cct_new(directory, arguments, file)#

Arguments:

character(len=*), intent(in) :: directory
character(len=*), intent(in), optional :: arguments
character(len=*), intent(in) :: file

Returns: type (compile_command_t)

type compile_command_table_t, extends(serializable_t)#

member command#: Type: type (compile_command_t), allocatable

procedure destroy#: Binds to: cct_destroy

procedure write#: Binds to: cct_write

procedure cct_register#: Binds to: cct_register

procedure cct_register_object#: Binds to: cct_register_object

procedure register#: Binds to: cct_register, cct_register_object

procedure serializable_is_same#: Binds to: cct_is_same

procedure dump_to_toml#: Binds to: cct_dump_toml

procedure load_from_toml#: Binds to: cct_load_toml

interface add_compile_command#

pure subroutine add_compile_command_one(list, new)#

Arguments:

type (compile_command_t), intent(inout), allocatable :: list
type (compile_command_t), intent(in) :: new

pure subroutine add_compile_command_many(list, new)#

Arguments:

type (compile_command_t), intent(inout), allocatable :: list
type (compile_command_t), intent(in) :: new

function compile_command_is_same(this, that)#

Arguments:

class (compile_command_t), intent(in) :: this
class (serializable_t), intent(in) :: that

Returns: logical

function cct_is_same(this, that)#

Arguments:

class (compile_command_table_t), intent(in) :: this
class (serializable_t), intent(in) :: that

Returns: logical

elemental subroutine compile_command_destroy(self)#

Arguments:

class (compile_command_t), intent(inout) :: self

subroutine compile_command_dump_toml(self, table, error)#

Arguments:

class (compile_command_t), intent(inout) :: self
type (toml_table), intent(inout) :: table
type (error_t), intent(out), allocatable :: error

subroutine compile_command_load_toml(self, table, error)#

Arguments:

class (compile_command_t), intent(inout) :: self
type (toml_table), intent(inout) :: table
type (error_t), intent(out), allocatable :: error

subroutine cct_dump_array(self, array, error)#

Arguments:

class (compile_command_table_t), intent(inout) :: self
type (toml_array), intent(inout) :: array
type (error_t), intent(out), allocatable :: error

subroutine cct_write(self, filename, error)#

Arguments:

class (compile_command_table_t), intent(inout) :: self
character(len=*), intent(in) :: filename
type (error_t), intent(out), allocatable :: error

elemental subroutine cct_destroy(self)#

Arguments:

class (compile_command_table_t), intent(inout) :: self

subroutine cct_register(self, command, target_os, error)#

Arguments:

class (compile_command_table_t), intent(inout) :: self
character(len=*), intent(in) :: command
integer, intent(in) :: target_os
type (error_t), intent(out), allocatable :: error

pure subroutine cct_register_object(self, command, error)#

Arguments:

class (compile_command_table_t), intent(inout) :: self
type (compile_command_t), intent(in) :: command
type (error_t), intent(out), allocatable :: error

subroutine cct_dump_toml(self, table, error)#

Arguments:

class (compile_command_table_t), intent(inout) :: self
type (toml_table), intent(inout) :: table
type (error_t), intent(out), allocatable :: error

subroutine cct_load_toml(self, table, error)#

Arguments:

class (compile_command_table_t), intent(inout) :: self
type (toml_table), intent(inout) :: table
type (error_t), intent(out), allocatable :: error

module fpm_compiler#

Uses: iso_fortran_env, fpm_environment, fpm_filesystem, fpm_strings, fpm_error, tomlf, fpm_toml, fpm_compile_commands, fpm_versioning, shlex_module

parameter compiler_enum = kind(id_unknown)#: Type: integer

parameter flag_gnu_coarray = " -fcoarray=single"#: Type: character(len=*)

parameter flag_gnu_backtrace = " -fbacktrace"#: Type: character(len=*)

parameter flag_gnu_opt = " -O3 -funroll-loops"#: Type: character(len=*)

parameter flag_gnu_debug = " -g"#: Type: character(len=*)

parameter flag_gnu_pic = " -fPIC"#: Type: character(len=*)

parameter flag_gnu_warn = " -Wall -Wextra -Wno-external-argument-mismatch"#: Type: character(len=*)

parameter flag_gnu_check = " -fcheck=bounds -fcheck=array-temps"#: Type: character(len=*)

parameter flag_gnu_limit = " -fmax-errors=1"#: Type: character(len=*)

parameter flag_gnu_external = " -Wimplicit-interface"#: Type: character(len=*)

parameter flag_gnu_openmp = " -fopenmp"#: Type: character(len=*)

parameter flag_gnu_no_implicit_typing = " -fimplicit-none"#: Type: character(len=*)

parameter flag_gnu_no_implicit_external = " -Werror=implicit-interface"#: Type: character(len=*)

parameter flag_gnu_free_form = " -ffree-form"#: Type: character(len=*)

parameter flag_gnu_fixed_form = " -ffixed-form"#: Type: character(len=*)

parameter flag_pgi_backslash = " -Mbackslash"#: Type: character(len=*)

parameter flag_pgi_traceback = " -traceback"#: Type: character(len=*)

parameter flag_pgi_debug = " -g"#: Type: character(len=*)

parameter flag_pgi_check = " -Mbounds -Mchkptr -Mchkstk"#: Type: character(len=*)

parameter flag_pgi_warn = " -Minform=inform"#: Type: character(len=*)

parameter flag_pgi_openmp = " -mp"#: Type: character(len=*)

parameter flag_pgi_free_form = " -Mfree"#: Type: character(len=*)

parameter flag_pgi_fixed_form = " -Mfixed"#: Type: character(len=*)

parameter flag_ibmxl_backslash = " -qnoescape"#: Type: character(len=*)

parameter flag_intel_backtrace = " -traceback"#: Type: character(len=*)

parameter flag_intel_warn = " -warn all"#: Type: character(len=*)

parameter flag_intel_check = " -check all"#: Type: character(len=*)

parameter flag_intel_debug = " -O0 -g"#: Type: character(len=*)

parameter flag_intel_opt = " -O3"#: Type: character(len=*)

parameter flag_intel_fp = " -fp-model precise -pc64"#: Type: character(len=*)

parameter flag_intel_align = " -align all"#: Type: character(len=*)

parameter flag_intel_limit = " -error-limit 1"#: Type: character(len=*)

parameter flag_intel_pthread = " -reentrancy threaded"#: Type: character(len=*)

parameter flag_intel_nogen = " -nogen-interfaces"#: Type: character(len=*)

parameter flag_intel_byterecl = " -assume byterecl"#: Type: character(len=*)

parameter flag_intel_openmp = " -qopenmp"#: Type: character(len=*)

parameter flag_intel_free_form = " -free"#: Type: character(len=*)

parameter flag_intel_fixed_form = " -fixed"#: Type: character(len=*)

parameter flag_intel_standard_compliance = " -standard-semantics"#: Type: character(len=*)

parameter flag_intel_unknown_cmd_err = " -diag-error 10006"#: Type: character(len=*)

parameter flag_intel_llvm_check = " -check all,nouninit"#: Type: character(len=*)

parameter flag_intel_backtrace_win = " /traceback"#: Type: character(len=*)

parameter flag_intel_warn_win = " /warn:all"#: Type: character(len=*)

parameter flag_intel_check_win = " /check:all"#: Type: character(len=*)

parameter flag_intel_debug_win = " /Od /Z7"#: Type: character(len=*)

parameter flag_intel_opt_win = " /O3"#: Type: character(len=*)

parameter flag_intel_fp_win = " /fp:precise"#: Type: character(len=*)

parameter flag_intel_align_win = " /align:all"#: Type: character(len=*)

parameter flag_intel_limit_win = " /error-limit:1"#: Type: character(len=*)

parameter flag_intel_pthread_win = " /reentrancy:threaded"#: Type: character(len=*)

parameter flag_intel_nogen_win = " /nogen-interfaces"#: Type: character(len=*)

parameter flag_intel_byterecl_win = " /assume:byterecl"#: Type: character(len=*)

parameter flag_intel_openmp_win = " /Qopenmp"#: Type: character(len=*)

parameter flag_intel_free_form_win = " /free"#: Type: character(len=*)

parameter flag_intel_fixed_form_win = " /fixed"#: Type: character(len=*)

parameter flag_intel_standard_compliance_win = " /standard-semantics"#: Type: character(len=*)

parameter flag_intel_unknown_cmd_err_win = " /Qdiag-error:10006"#: Type: character(len=*)

parameter flag_nag_coarray = " -coarray=single"#: Type: character(len=*)

parameter flag_nag_pic = " -PIC"#: Type: character(len=*)

parameter flag_nag_check = " -C"#: Type: character(len=*)

parameter flag_nag_debug = " -g -O0"#: Type: character(len=*)

parameter flag_nag_opt = " -O4"#: Type: character(len=*)

parameter flag_nag_backtrace = " -gline"#: Type: character(len=*)

parameter flag_nag_openmp = " -openmp"#: Type: character(len=*)

parameter flag_nag_free_form = " -free"#: Type: character(len=*)

parameter flag_nag_fixed_form = " -fixed"#: Type: character(len=*)

parameter flag_nag_no_implicit_typing = " -u"#: Type: character(len=*)

parameter flag_lfortran_opt = " --fast"#: Type: character(len=*)

parameter flag_lfortran_openmp = " --openmp"#: Type: character(len=*)

parameter flag_lfortran_implicit_typing = " --implicit-typing"#: Type: character(len=*)

parameter flag_lfortran_implicit_external = " --implicit-interface"#: Type: character(len=*)

parameter flag_lfortran_fixed_form = " --fixed-form"#: Type: character(len=*)

parameter flag_cray_no_implicit_typing = " -dl"#: Type: character(len=*)

parameter flag_cray_implicit_typing = " -el"#: Type: character(len=*)

parameter flag_cray_fixed_form = " -ffixed"#: Type: character(len=*)

parameter flag_cray_free_form = " -ffree"#: Type: character(len=*)

parameter flag_flang_openmp = " -fopenmp"#: Type: character(len=*)

parameter flag_flang_debug = " -g"#: Type: character(len=*)

parameter flag_flang_opt = " -O3"#: Type: character(len=*)

parameter flag_flang_pic = " -fPIC"#: Type: character(len=*)

parameter flag_flang_free_form = " -ffree-form"#: Type: character(len=*)

parameter flag_flang_fixed_form = " -ffixed-form"#: Type: character(len=*)

parameter flag_flang_no_implicit_typing = " -fimplicit-none"#: Type: character(len=*)

type compiler_t, extends(serializable_t)#

member id = id_unknown#: Type: integer (compiler_enum)

member fc#: Type: character(len=:), allocatable

member cc#: Type: character(len=:), allocatable

member cxx#: Type: character(len=:), allocatable

member echo = .true.#: Type: logical

member verbose = .true.#: Type: logical

procedure get_default_flags#: Binds to: get_default_flags

procedure get_module_flag#: Binds to: get_module_flag

procedure get_include_flag#: Binds to: get_include_flag

procedure get_feature_flag#: Binds to: get_feature_flag

procedure get_main_flags#: Binds to: get_main_flags

procedure get_export_flags#: Binds to: get_export_flags

procedure get_install_name_flags#: Binds to: get_install_name_flags

procedure get_headerpad_flags#: Binds to: get_headerpad_flags

procedure compile_fortran#: Binds to: compile_fortran

procedure compile_c#: Binds to: compile_c

procedure compile_cpp#: Binds to: compile_cpp

procedure link_shared#: Binds to: link_shared

procedure link#: Binds to: link_executable

procedure is_unknown#: Binds to: is_unknown

procedure is_intel#: Binds to: is_intel

procedure is_gnu#: Binds to: is_gnu

procedure enumerate_libraries#: Binds to: enumerate_libraries

procedure serializable_is_same#: Binds to: compiler_is_same

procedure dump_to_toml#: Binds to: compiler_dump

procedure load_from_toml#: Binds to: compiler_load

procedure check_fortran_source_runs#: Binds to: check_fortran_source_runs

procedure check_flags_supported#: Binds to: check_flags_supported

procedure with_xdp#: Binds to: with_xdp

procedure with_qp#: Binds to: with_qp

procedure check_c_source_runs#: Binds to: check_c_source_runs

procedure check_c_flags_supported#: Binds to: check_c_flags_supported

procedure check_cxx_source_runs#: Binds to: check_cxx_source_runs

procedure check_cxx_flags_supported#: Binds to: check_cxx_flags_supported

procedure name#: Binds to: compiler_name

type archiver_t, extends(serializable_t)#

member ar#: Type: character(len=:), allocatable

member use_response_file = .false.#: Type: logical

member echo = .true.#: Type: logical

member verbose = .true.#: Type: logical

procedure make_archive#: Binds to: make_archive

procedure serializable_is_same#: Binds to: ar_is_same

procedure dump_to_toml#: Binds to: dump_to_toml

procedure load_from_toml#: Binds to: load_from_toml

interface debug#

pure function debug_compiler(self)#

Arguments:

type (compiler_t), intent(in) :: self

Returns: character(len=:), allocatable

pure function debug_archiver(self)#

Arguments:

type (archiver_t), intent(in) :: self

Returns: character(len=:), allocatable

function get_default_flags(self, release)#

Arguments:

class (compiler_t), intent(in) :: self
logical, intent(in) :: release

Returns: character(len=:), allocatable

function get_macros(id, macros_list, version)#

Arguments:

integer (compiler_enum), intent(in) :: id
type (string_t), intent(in), allocatable :: macros_list
type (version_t), intent(in), optional :: version

Returns: character(len=:), allocatable

function get_include_flag(self, path)#

Arguments:

class (compiler_t), intent(in) :: self
character(len=*), intent(in) :: path

Returns: character(len=:), allocatable

function get_module_flag(self, path)#

Arguments:

class (compiler_t), intent(in) :: self
character(len=*), intent(in) :: path

Returns: character(len=:), allocatable

function get_shared_flag(self)#

Arguments:

class (compiler_t), intent(in) :: self

Returns: character(len=:), allocatable

function get_feature_flag(self, feature)#

Arguments:

class (compiler_t), intent(in) :: self
character(len=*), intent(in) :: feature

Returns: character(len=:), allocatable

function is_cxx_gnu_based(self)#

Arguments:

class (compiler_t), intent(in) :: self

Returns: logical

function get_compiler_id(compiler)#

Arguments:

character(len=*), intent(in) :: compiler

Returns: integer (compiler_enum)

function match_compiler_type(compiler)#

Arguments:

character(len=*), intent(in) :: compiler

Returns: integer (compiler_enum)

function check_compiler(compiler, expected)#

Arguments:

character(len=*), intent(in) :: compiler
character(len=*), intent(in) :: expected

Returns: logical

pure function is_unknown(self)#

Arguments:

class (compiler_t), intent(in) :: self

Returns: logical

pure function is_intel(self)#

Arguments:

class (compiler_t), intent(in) :: self

Returns: logical

pure function is_gnu(self)#

Arguments:

class (compiler_t), intent(in) :: self

Returns: logical

function enumerate_libraries(self, prefix, libs)#

Arguments:

class (compiler_t), intent(in) :: self
character(len=*), intent(in) :: prefix
type (string_t), intent(in) :: libs

Returns: character(len=:), allocatable

function get_export_flags(self, target_dir, target_name)#

Arguments:

class (compiler_t), intent(in) :: self
character(len=*), intent(in) :: target_dir
character(len=*), intent(in) :: target_name

Returns: character(len=:), allocatable

function get_install_name_flags(self, target_dir, target_name)#

Arguments:

class (compiler_t), intent(in) :: self
character(len=*), intent(in) :: target_dir
character(len=*), intent(in) :: target_name

Returns: character(len=:), allocatable

function get_headerpad_flags(self)#

Arguments:

class (compiler_t), intent(in) :: self

Returns: character(len=:), allocatable

function ar_is_same(this, that)#

Arguments:

class (archiver_t), intent(in) :: this
class (serializable_t), intent(in) :: that

Returns: logical

function compiler_is_same(this, that)#

Arguments:

class (compiler_t), intent(in) :: this
class (serializable_t), intent(in) :: that

Returns: logical

pure function compiler_name(self)#

Arguments:

class (compiler_t), intent(in) :: self

Returns: character(len=:), allocatable

pure function compiler_id_name(id)#

Arguments:

integer (compiler_enum), intent(in) :: id

Returns: character(len=:), allocatable

function check_fortran_source_runs(self, input, compile_flags, link_flags)#

Arguments:

class (compiler_t), intent(in) :: self
character(len=*), intent(in) :: input
character(len=*), intent(in), optional :: compile_flags
character(len=*), intent(in), optional :: link_flags

Returns: logical

function check_c_source_runs(self, input, compile_flags, link_flags)#

Arguments:

class (compiler_t), intent(in) :: self
character(len=*), intent(in) :: input
character(len=*), intent(in), optional :: compile_flags
character(len=*), intent(in), optional :: link_flags

Returns: logical

function check_cxx_source_runs(self, input, compile_flags, link_flags)#

Arguments:

class (compiler_t), intent(in) :: self
character(len=*), intent(in) :: input
character(len=*), intent(in), optional :: compile_flags
character(len=*), intent(in), optional :: link_flags

Returns: logical

function check_c_flags_supported(self, compile_flags, link_flags)#

Arguments:

class (compiler_t), intent(in) :: self
character(len=*), intent(in), optional :: compile_flags
character(len=*), intent(in), optional :: link_flags

Returns: logical

function check_cxx_flags_supported(self, compile_flags, link_flags)#

Arguments:

class (compiler_t), intent(in) :: self
character(len=*), intent(in), optional :: compile_flags
character(len=*), intent(in), optional :: link_flags

Returns: logical

function check_flags_supported(self, compile_flags, link_flags)#

Arguments:

class (compiler_t), intent(in) :: self
character(len=*), intent(in), optional :: compile_flags
character(len=*), intent(in), optional :: link_flags

Returns: logical

function with_qp(self)#

Arguments:

class (compiler_t), intent(in) :: self

Returns: logical

function with_xdp(self)#

Arguments:

class (compiler_t), intent(in) :: self

Returns: logical

subroutine get_release_compile_flags(id, flags)#

Arguments:

integer (compiler_enum), intent(in) :: id
character(len=:), intent(out), allocatable :: flags

subroutine get_debug_compile_flags(id, flags)#

Arguments:

integer (compiler_enum), intent(in) :: id
character(len=:), intent(out), allocatable :: flags

pure subroutine set_cpp_preprocessor_flags(id, flags)#

Arguments:

integer (compiler_enum), intent(in) :: id
character(len=:), intent(inout), allocatable :: flags

subroutine get_main_flags(self, language, flags)#

Arguments:

class (compiler_t), intent(in) :: self
character(len=*), intent(in) :: language
character(len=:), intent(out), allocatable :: flags

subroutine get_default_c_compiler(f_compiler, c_compiler)#

Arguments:

character(len=*), intent(in) :: f_compiler
character(len=:), intent(out), allocatable :: c_compiler

subroutine get_default_cxx_compiler(f_compiler, cxx_compiler)#

Arguments:

character(len=*), intent(in) :: f_compiler
character(len=:), intent(out), allocatable :: cxx_compiler

pure elemental subroutine validate_compiler_name(compiler_name, is_valid)#

Arguments:

character(len=*), intent(in) :: compiler_name
logical, intent(out) :: is_valid

subroutine new_compiler(self, fc, cc, cxx, echo, verbose)#

Arguments:

type (compiler_t), intent(out) :: self
character(len=*), intent(in) :: fc
character(len=*), intent(in) :: cc
character(len=*), intent(in) :: cxx
logical, intent(in) :: echo
logical, intent(in) :: verbose

subroutine new_archiver(self, ar, echo, verbose)#

Arguments:

type (archiver_t), intent(out) :: self
character(len=*), intent(in) :: ar
logical, intent(in) :: echo
logical, intent(in) :: verbose

subroutine compile_fortran(self, input, output, args, log_file, stat, table, dry_run)#

Arguments:

class (compiler_t), intent(in) :: self
character(len=*), intent(in) :: input
character(len=*), intent(in) :: output
character(len=*), intent(in) :: args
character(len=*), intent(in) :: log_file
integer, intent(out) :: stat
type (compile_command_table_t), intent(inout), optional :: table
logical, intent(in), optional :: dry_run

subroutine compile_c(self, input, output, args, log_file, stat, table, dry_run)#

Arguments:

class (compiler_t), intent(in) :: self
character(len=*), intent(in) :: input
character(len=*), intent(in) :: output
character(len=*), intent(in) :: args
character(len=*), intent(in) :: log_file
integer, intent(out) :: stat
type (compile_command_table_t), intent(inout), optional :: table
logical, intent(in), optional :: dry_run

subroutine compile_cpp(self, input, output, args, log_file, stat, table, dry_run)#

Arguments:

class (compiler_t), intent(in) :: self
character(len=*), intent(in) :: input
character(len=*), intent(in) :: output
character(len=*), intent(in) :: args
character(len=*), intent(in) :: log_file
integer, intent(out) :: stat
type (compile_command_table_t), intent(inout), optional :: table
logical, intent(in), optional :: dry_run

subroutine link_executable(self, output, args, log_file, stat, dry_run)#

Arguments:

class (compiler_t), intent(in) :: self
character(len=*), intent(in) :: output
character(len=*), intent(in) :: args
character(len=*), intent(in) :: log_file
integer, intent(out) :: stat
logical, intent(in), optional :: dry_run

subroutine link_shared(self, output, args, log_file, stat, dry_run)#

Arguments:

class (compiler_t), intent(in) :: self
character(len=*), intent(in) :: output
character(len=*), intent(in) :: args
character(len=*), intent(in) :: log_file
integer, intent(out) :: stat
logical, intent(in), optional :: dry_run

subroutine make_archive(self, output, args, log_file, stat, dry_run)#

Arguments:

class (archiver_t), intent(in) :: self
character(len=*), intent(in) :: output
type (string_t), intent(in) :: args
character(len=*), intent(in) :: log_file
integer, intent(out) :: stat
logical, intent(in), optional :: dry_run

subroutine write_response_file(name, argv)#

Arguments:

character(len=*), intent(in) :: name
type (string_t), intent(in) :: argv

subroutine dump_to_toml(self, table, error)#

Arguments:

class (archiver_t), intent(inout) :: self
type (toml_table), intent(inout) :: table
type (error_t), intent(out), allocatable :: error

subroutine load_from_toml(self, table, error)#

Arguments:

class (archiver_t), intent(inout) :: self
type (toml_table), intent(inout) :: table
type (error_t), intent(out), allocatable :: error

subroutine compiler_dump(self, table, error)#

Arguments:

class (compiler_t), intent(inout) :: self
type (toml_table), intent(inout) :: table
type (error_t), intent(out), allocatable :: error

subroutine compiler_load(self, table, error)#

Arguments:

class (compiler_t), intent(inout) :: self
type (toml_table), intent(inout) :: table
type (error_t), intent(out), allocatable :: error

subroutine append_clean_flags(flags, new_flags)#

Arguments:

character(len=:), intent(inout), allocatable :: flags
character(len=*), intent(in) :: new_flags

subroutine append_clean_flags_array(flags_array, new_flags_array)#

Arguments:

type (string_t), intent(inout), allocatable :: flags_array
type (string_t), intent(in) :: new_flags_array

subroutine tokenize_flags(flags, flags_array)#

Arguments:

character(len=*), intent(in) :: flags
type (string_t), intent(out), allocatable :: flags_array

module fpm_dependency#

Uses: iso_fortran_env, fpm_environment, fpm_error, fpm_filesystem, fpm_git, fpm_manifest, fpm_manifest_dependency, fpm_manifest_preprocess, fpm_strings, tomlf, fpm_toml, fpm_versioning, fpm_settings, fpm_downloader, jonquil

parameter out_fmt = '("#", *(1x, g0))'#: Type: character(len=*)

type dependency_node_t, extends(dependency_config_t)#

member version#: Type: type (version_t), allocatable

member proj_dir#: Type: character(len=:), allocatable

member revision#: Type: character(len=:), allocatable

member done = .false.#: Type: logical

member update = .false.#: Type: logical

member cached = .false.#: Type: logical

member package_dep#: Type: type (string_t), allocatable

procedure register#: Binds to: register

procedure get_from_registry#: Binds to: get_from_registry

procedure get_from_local_registry#: Binds to: get_from_local_registry

procedure info#: Binds to: info

procedure serializable_is_same#: Binds to: dependency_node_is_same

procedure dump_to_toml#: Binds to: node_dump_to_toml

procedure load_from_toml#: Binds to: node_load_from_toml

type dependency_tree_t, extends(serializable_t)#

member unit = output_unit#: Type: integer

member verbosity = 1#: Type: integer

member dep_dir#: Type: character(len=:), allocatable

member ndep = 0#: Type: integer

member dep#: Type: type (dependency_node_t), allocatable

member cache#: Type: character(len=:), allocatable

member path_to_config#: Type: character(len=:), allocatable

procedure add#: Binds to: add_project, add_project_dependencies, add_dependencies, add_dependency, add_dependency_node

procedure add_project#: Binds to: add_project

procedure add_project_dependencies#: Binds to: add_project_dependencies

procedure add_dependencies#: Binds to: add_dependencies

procedure add_dependency#: Binds to: add_dependency

procedure add_dependency_node#: Binds to: add_dependency_node

procedure resolve#: Binds to: resolve_dependencies, resolve_dependency

procedure resolve_dependencies#: Binds to: resolve_dependencies

procedure resolve_dependency#: Binds to: resolve_dependency

procedure has#: Binds to: has_dependency

procedure has_dependency#: Binds to: has_dependency

procedure find#: Binds to: find_name

procedure find_name#: Binds to: find_name

procedure local_link_order#: Binds to: local_link_order

procedure finished#: Binds to: finished

procedure load_cache#: Binds to: load_cache_from_file, load_cache_from_unit, load_cache_from_toml

procedure load_cache_from_file#: Binds to: load_cache_from_file

procedure load_cache_from_unit#: Binds to: load_cache_from_unit

procedure load_cache_from_toml#: Binds to: load_cache_from_toml

procedure dump_cache#: Binds to: dump_cache_to_file, dump_cache_to_unit, dump_cache_to_toml

procedure dump_cache_to_file#: Binds to: dump_cache_to_file

procedure dump_cache_to_unit#: Binds to: dump_cache_to_unit

procedure dump_cache_to_toml#: Binds to: dump_cache_to_toml

procedure update#: Binds to: update_dependency, update_tree

procedure update_dependency#: Binds to: update_dependency

procedure update_tree#: Binds to: update_tree

procedure serializable_is_same#: Binds to: dependency_tree_is_same

procedure dump_to_toml#: Binds to: tree_dump_to_toml

procedure load_from_toml#: Binds to: tree_load_from_toml

interface resize#

pure subroutine resize_dependency_node(var, n)#

Arguments:

type (dependency_node_t), intent(inout), allocatable :: var
integer, intent(in), optional :: n

pure function has_dependency(self, dependency)#

Arguments:

class (dependency_tree_t), intent(in) :: self
class (dependency_node_t), intent(in) :: dependency

Returns: logical

pure function find_name(self, name)#

Arguments:

class (dependency_tree_t), intent(in) :: self
character(len=*), intent(in) :: name

Returns: integer

pure function finished(self)#

Arguments:

class (dependency_tree_t), intent(in) :: self

Returns: logical

function dependency_has_changed(cached, manifest, verbosity, iunit)#

Arguments:

type (dependency_node_t), intent(in) :: cached
type (dependency_node_t), intent(in) :: manifest
integer, intent(in) :: verbosity
integer, intent(in) :: iunit

Returns: logical

function dependency_node_is_same(this, that)#

Arguments:

class (dependency_node_t), intent(in) :: this
class (serializable_t), intent(in) :: that

Returns: logical

function dependency_tree_is_same(this, that)#

Arguments:

class (dependency_tree_t), intent(in) :: this
class (serializable_t), intent(in) :: that

Returns: logical

subroutine new_dependency_tree(self, verbosity, cache, path_to_config, build_dir)#

Arguments:

type (dependency_tree_t), intent(out) :: self
integer, intent(in), optional :: verbosity
character(len=*), intent(in), optional :: cache
character(len=*), intent(in), optional :: path_to_config
character(len=*), intent(in), optional :: build_dir

subroutine new_dependency_node(self, dependency, version, proj_dir, update)#

Arguments:

type (dependency_node_t), intent(out) :: self
type (dependency_config_t), intent(in) :: dependency
type (version_t), intent(in), optional :: version
character(len=*), intent(in), optional :: proj_dir
logical, intent(in), optional :: update

subroutine info(self, unit, verbosity)#

Arguments:

class (dependency_node_t), intent(in) :: self
integer, intent(in) :: unit
integer, intent(in), optional :: verbosity

subroutine add_project(self, package, error)#

Arguments:

class (dependency_tree_t), intent(inout) :: self
type (package_config_t), intent(in) :: package
type (error_t), intent(out), allocatable :: error

subroutine resolve_dependency_graph(self, main, error)#

Arguments:

class (dependency_tree_t), intent(inout) :: self
type (package_config_t), intent(in) :: main
type (error_t), intent(out), allocatable :: error

recursive subroutine add_project_dependencies(self, package, root, main, error)#

Arguments:

class (dependency_tree_t), intent(inout) :: self
type (package_config_t), intent(in) :: package
character(len=*), intent(in) :: root
logical, intent(in) :: main
type (error_t), intent(out), allocatable :: error

subroutine add_dependencies(self, dependency, error)#

Arguments:

class (dependency_tree_t), intent(inout) :: self
type (dependency_config_t), intent(in) :: dependency
type (error_t), intent(out), allocatable :: error

subroutine add_dependency_node(self, dependency, error)#

Arguments:

class (dependency_tree_t), intent(inout) :: self
type (dependency_node_t), intent(in) :: dependency
type (error_t), intent(out), allocatable :: error

subroutine add_dependency(self, dependency, error)#

Arguments:

class (dependency_tree_t), intent(inout) :: self
type (dependency_config_t), intent(in) :: dependency
type (error_t), intent(out), allocatable :: error

subroutine update_dependency(self, name, error)#

Arguments:

class (dependency_tree_t), intent(inout) :: self
character(len=*), intent(in) :: name
type (error_t), intent(out), allocatable :: error

subroutine update_tree(self, error)#

Arguments:

class (dependency_tree_t), intent(inout) :: self
type (error_t), intent(out), allocatable :: error

subroutine resolve_dependencies(self, root, error)#

Arguments:

class (dependency_tree_t), intent(inout) :: self
character(len=*), intent(in) :: root
type (error_t), intent(out), allocatable :: error

subroutine resolve_dependency(self, dependency, global_settings, root, error)#

Arguments:

class (dependency_tree_t), intent(inout) :: self
type (dependency_node_t), intent(inout) :: dependency
type (fpm_global_settings), intent(in) :: global_settings
character(len=*), intent(in) :: root
type (error_t), intent(out), allocatable :: error

subroutine get_from_registry(self, target_dir, global_settings, error, downloader_)#

Arguments:

class (dependency_node_t), intent(in) :: self
character(len=:), intent(out), allocatable :: target_dir
type (fpm_global_settings), intent(in) :: global_settings
type (error_t), intent(out), allocatable :: error
class (downloader_t), intent(in), optional :: downloader_

subroutine check_and_read_pkg_data(json, node, download_url, version, error)#

Arguments:

type (json_object), intent(inout) :: json
class (dependency_node_t), intent(in) :: node
character(len=:), intent(out), allocatable :: download_url
type (version_t), intent(out) :: version
type (error_t), intent(out), allocatable :: error

subroutine get_from_local_registry(self, target_dir, registry_path, error)#

Arguments:

class (dependency_node_t), intent(in) :: self
character(len=:), intent(out), allocatable :: target_dir
character(len=*), intent(in) :: registry_path
type (error_t), intent(out), allocatable :: error

subroutine register(node, package, root, fetch, revision, error)#

Arguments:

class (dependency_node_t), intent(inout) :: node
type (package_config_t), intent(in) :: package
character(len=*), intent(in) :: root
logical, intent(in) :: fetch
character(len=*), intent(in), optional :: revision
type (error_t), intent(out), allocatable :: error

subroutine get_required_packages(tree, node_ID, error)#

Arguments:

class (dependency_tree_t), intent(inout) :: tree
integer, intent(in) :: node_ID
type (error_t), intent(out), allocatable :: error

subroutine local_link_order(tree, root_id, order, error)#

Arguments:

class (dependency_tree_t), intent(in) :: tree
integer, intent(in) :: root_id
integer, intent(out), allocatable :: order
type (error_t), intent(out), allocatable :: error

subroutine load_cache_from_file(self, file, error)#

Arguments:

class (dependency_tree_t), intent(inout) :: self
character(len=*), intent(in) :: file
type (error_t), intent(out), allocatable :: error

subroutine load_cache_from_unit(self, unit, error)#

Arguments:

class (dependency_tree_t), intent(inout) :: self
integer, intent(in) :: unit
type (error_t), intent(out), allocatable :: error

subroutine load_cache_from_toml(self, table, error)#

Arguments:

class (dependency_tree_t), intent(inout) :: self
type (toml_table), intent(inout) :: table
type (error_t), intent(out), allocatable :: error

subroutine dump_cache_to_file(self, file, error)#

Arguments:

class (dependency_tree_t), intent(inout) :: self
character(len=*), intent(in) :: file
type (error_t), intent(out), allocatable :: error

subroutine dump_cache_to_unit(self, unit, error)#

Arguments:

class (dependency_tree_t), intent(inout) :: self
integer, intent(in) :: unit
type (error_t), intent(out), allocatable :: error

subroutine dump_cache_to_toml(self, table, error)#

Arguments:

class (dependency_tree_t), intent(inout) :: self
type (toml_table), intent(inout) :: table
type (error_t), intent(out), allocatable :: error

subroutine node_dump_to_toml(self, table, error)#

Arguments:

class (dependency_node_t), intent(inout) :: self
type (toml_table), intent(inout) :: table
type (error_t), intent(out), allocatable :: error

subroutine node_load_from_toml(self, table, error)#

Arguments:

class (dependency_node_t), intent(inout) :: self
type (toml_table), intent(inout) :: table
type (error_t), intent(out), allocatable :: error

elemental subroutine destroy_dependency_node(self)#

Arguments:

class (dependency_node_t), intent(inout) :: self

subroutine tree_dump_to_toml(self, table, error)#

Arguments:

class (dependency_tree_t), intent(inout) :: self
type (toml_table), intent(inout) :: table
type (error_t), intent(out), allocatable :: error

subroutine tree_load_from_toml(self, table, error)#

Arguments:

class (dependency_tree_t), intent(inout) :: self
type (toml_table), intent(inout) :: table
type (error_t), intent(out), allocatable :: error

module fpm_downloader#

Uses: fpm_error, fpm_filesystem, fpm_versioning, jonquil, fpm_strings

type downloader_t#

procedure unpack#: Binds to: unpack

procedure upload_form#: Binds to: upload_form

procedure get_file#: Binds to: get_file

procedure get_pkg_data#: Binds to: get_pkg_data

subroutine get_pkg_data(url, version, tmp_pkg_file, json, error)#

Arguments:

character(len=*), intent(in) :: url
type (version_t), intent(in), allocatable :: version
character(len=*), intent(in) :: tmp_pkg_file
type (json_object), intent(out) :: json
type (error_t), intent(out), allocatable :: error

subroutine get_file(url, tmp_pkg_file, error)#

Arguments:

character(len=*), intent(in) :: url
character(len=*), intent(in) :: tmp_pkg_file
type (error_t), intent(out), allocatable :: error

subroutine upload_form(endpoint, form_data, verbose, error)#

Arguments:

character(len=*), intent(in) :: endpoint
type (string_t), intent(in) :: form_data
logical, intent(in) :: verbose
type (error_t), intent(out), allocatable :: error

subroutine unpack(tmp_pkg_file, destination, error)#

Arguments:

character(len=*), intent(in) :: tmp_pkg_file
character(len=*), intent(in) :: destination
type (error_t), intent(out), allocatable :: error

module fpm_environment#

Uses: iso_fortran_env, iso_c_binding, fpm_error, fpm_strings

parameter OS_ALL = -1#: Type: integer

parameter OS_UNKNOWN = 0#: Type: integer

parameter OS_LINUX = 1#: Type: integer

parameter OS_MACOS = 2#: Type: integer

parameter OS_WINDOWS = 3#: Type: integer

parameter OS_CYGWIN = 4#: Type: integer

parameter OS_SOLARIS = 5#: Type: integer

parameter OS_FREEBSD = 6#: Type: integer

parameter OS_OPENBSD = 7#: Type: integer

pure function library_filename(package_name, shared, import, target_os)#

Arguments:

character(len=*), intent(in) :: package_name
logical, intent(in) :: shared
logical, intent(in) :: import
integer, intent(in) :: target_os

Returns: character(len=:), allocatable

pure function OS_NAME(os)#

Arguments:

integer, intent(in) :: os

Returns: character(len=:), allocatable

function match_os_type(os_name)#

Arguments:

character(len=*), intent(in) :: os_name

Returns: integer

function get_os_type()#: Returns: integer

function os_is_unix(os)#

Arguments:

integer, intent(in), optional :: os

Returns: logical

function get_env(NAME, DEFAULT)#

Arguments:

character(len=*), intent(in) :: NAME
character(len=*), intent(in), optional :: DEFAULT

Returns: character(len=:), allocatable

function get_command_arguments_quoted()#: Returns: character(len=:), allocatable

function separator()#: Returns: character(len=1)

function set_env(name, value, overwrite)#

Arguments:

character(len=*), intent(in) :: name
character(len=*), intent(in) :: value
logical, intent(in), optional :: overwrite

Returns: logical

function delete_env(name)#

Arguments:

character(len=*), intent(in) :: name

Returns: logical

pure elemental subroutine validate_os_name(os_name, is_valid)#

Arguments:

character(len=*), intent(in) :: os_name
logical, intent(out) :: is_valid

pure subroutine f2cs(f, c)#

Arguments:

character(len=*), intent(in) :: f
character (c_char), intent(out), allocatable :: c

module fpm_error#

Uses: iso_fortran_env, fpm_strings

type error_t#

member message#: Type: character(len=:), allocatable

function bad_name_error(error, label, name)#

Arguments:

type (error_t), intent(out), allocatable :: error
character(len=*), intent(in) :: label
character(len=*), intent(in) :: name

Returns: logical

subroutine fatal_error(error, message)#

Arguments:

type (error_t), intent(out), allocatable :: error
character(len=*), intent(in) :: message

subroutine syntax_error(error, message)#

Arguments:

type (error_t), intent(out), allocatable :: error
character(len=*), intent(in) :: message

subroutine file_not_found_error(error, file_name)#

Arguments:

type (error_t), intent(out), allocatable :: error
character(len=*), intent(in) :: file_name

subroutine file_parse_error(error, file_name, message, line_num, line_string, line_col)#

Arguments:

type (error_t), intent(out), allocatable :: error
character(len=*), intent(in) :: file_name
character(len=*), intent(in) :: message
integer, intent(in), optional :: line_num
character(len=*), intent(in), optional :: line_string
integer, intent(in), optional :: line_col

subroutine fpm_stop(value, message)#

Arguments:

integer, intent(in) :: value
character(len=*), intent(in) :: message

module fpm_filesystem#

Uses: iso_fortran_env, iso_c_binding, fpm_environment, fpm_strings, fpm_error

interface c_opendir#

interface c_readdir#

interface c_closedir#

interface c_get_d_name#

interface c_is_dir#

function basename(path, suffix)#

Arguments:

character(len=*), intent(in) :: path
logical, intent(in), optional :: suffix

Returns: character(len=:), allocatable

function canon_path(path)#

Arguments:

character(len=*), intent(in) :: path

Returns: character(len=:), allocatable

function dirname(path)#

Arguments:

character(len=*), intent(in) :: path

Returns: character(len=:), allocatable

function parent_dir(path)#

Arguments:

character(len=*), intent(in) :: path

Returns: character(len=:), allocatable

function is_dir(dir)#

Arguments:

character(len=*), intent(in) :: dir

Returns: logical

function is_hidden_file(file_basename)#

Arguments:

character(len=*), intent(in) :: file_basename

Returns: logical

function join_path(a1, a2, a3, a4, a5)#

Arguments:

character(len=*), intent(in) :: a1
character(len=*), intent(in) :: a2
character(len=*), intent(in), optional :: a3
character(len=*), intent(in), optional :: a4
character(len=*), intent(in), optional :: a5

Returns: character(len=:), allocatable

function number_of_rows(s)#

Arguments:

integer, intent(in) :: s

Returns: integer

function read_lines_expanded(filename)#

Arguments:

character(len=*), intent(in) :: filename

Returns: type (string_t), allocatable

function read_lines(filename)#

Arguments:

character(len=*), intent(in) :: filename

Returns: type (string_t), allocatable

function read_text_file(filename)#

Arguments:

character(len=*), intent(in) :: filename

Returns: character(len=:), allocatable

function exists(filename)#

Arguments:

character(len=*), intent(in) :: filename

Returns: logical

function get_temp_filename()#: Returns: character(len=:), allocatable

function windows_path(path)#

Arguments:

character(len=*), intent(in) :: path

Returns: character(len=:), allocatable

function unix_path(path)#

Arguments:

character(len=*), intent(in) :: path

Returns: character(len=:), allocatable

function which(command)#

Arguments:

character(len=*), intent(in) :: command

Returns: character(len=:), allocatable

function get_local_prefix(os)#

Arguments:

integer, intent(in), optional :: os

Returns: character(len=:), allocatable

function is_absolute_path(path, is_unix)#

Arguments:

character(len=*), intent(in) :: path
logical, intent(in), optional :: is_unix

Returns: logical

function get_dos_path(path, error)#

Arguments:

character(len=*), intent(in) :: path
type (error_t), intent(out), allocatable :: error

Returns: character(len=:), allocatable

subroutine mkdir(dir, echo)#

Arguments:

character(len=*), intent(in) :: dir
logical, intent(in), optional :: echo

recursive subroutine list_files(dir, files, recurse)#

Arguments:

character(len=*), intent(in) :: dir
type (string_t), intent(out), allocatable :: files
logical, intent(in), optional :: recurse

subroutine getline(unit, line, iostat, iomsg)#

Arguments:

integer, intent(in) :: unit
character(len=:), intent(out), allocatable :: line
integer, intent(out) :: iostat
character(len=:), optional, allocatable :: iomsg

subroutine delete_file(file)#

Arguments:

character(len=*), intent(in) :: file

subroutine warnwrite(fname, data)#

Arguments:

character(len=*), intent(in) :: fname
character(len=*), intent(in) :: data

subroutine fileopen(filename, lun, ier)#

Arguments:

character(len=*), intent(in) :: filename
integer, intent(out) :: lun
integer, intent(out), optional :: ier

subroutine fileclose(lun, ier)#

Arguments:

integer, intent(in) :: lun
integer, intent(out), optional :: ier

subroutine filewrite(filename, filedata)#

Arguments:

character(len=*), intent(in) :: filename
character(len=*), intent(in) :: filedata

subroutine run(cmd, echo, exitstat, verbose, redirect)#

Arguments:

character(len=*), intent(in) :: cmd
logical, intent(in), optional :: echo
integer, intent(out), optional :: exitstat
logical, intent(in), optional :: verbose
character(len=*), intent(in), optional :: redirect

subroutine os_delete_dir(is_unix, dir, echo)#

Arguments:

logical, intent(in) :: is_unix
character(len=*), intent(in) :: dir
logical, intent(in), optional :: echo

subroutine get_home(home, error)#

Arguments:

character(len=:), intent(out), allocatable :: home
type (error_t), intent(out), allocatable :: error

subroutine execute_and_read_output(cmd, output, error, verbose)#

Arguments:

character(len=*), intent(in) :: cmd
character(len=:), intent(out), allocatable :: output
type (error_t), intent(out), allocatable :: error
logical, intent(in), optional :: verbose

module fpm_git#

Uses: fpm_error, fpm_filesystem, tomlf, fpm_toml

parameter compressed_package_name = 'compressed_package'#: Type: character(len=*)

parameter git_descriptor = enum_descriptor()#: Type: type (enum_descriptor)

parameter out_fmt = '("#", *(1x, g0))'#: Type: character(len=*)

type enum_descriptor#

member default = 200#: Type: integer

member branch = 201#: Type: integer

member tag = 202#: Type: integer

member revision = 203#: Type: integer

member error = -999#: Type: integer

type git_target_t, extends(serializable_t)#

member descriptor = git_descriptor%default#: Type: integer

member url#: Type: character(len=:), allocatable

member object#: Type: character(len=:), allocatable

procedure checkout#: Binds to: checkout

procedure info#: Binds to: info

procedure serializable_is_same#: Binds to: git_is_same

procedure dump_to_toml#: Binds to: dump_to_toml

procedure load_from_toml#: Binds to: load_from_toml

function git_target_default(url)#

Arguments:

character(len=*), intent(in) :: url

Returns: type (git_target_t)

function git_target_branch(url, branch)#

Arguments:

character(len=*), intent(in) :: url
character(len=*), intent(in) :: branch

Returns: type (git_target_t)

function git_target_revision(url, sha1)#

Arguments:

character(len=*), intent(in) :: url
character(len=*), intent(in) :: sha1

Returns: type (git_target_t)

function git_target_tag(url, tag)#

Arguments:

character(len=*), intent(in) :: url
character(len=*), intent(in) :: tag

Returns: type (git_target_t)

function git_is_same(this, that)#

Arguments:

class (git_target_t), intent(in) :: this
class (serializable_t), intent(in) :: that

Returns: logical

function git_matches_manifest(cached, manifest, verbosity, iunit)#

Arguments:

type (git_target_t), intent(in) :: cached
type (git_target_t), intent(in) :: manifest
integer, intent(in) :: verbosity
integer, intent(in) :: iunit

Returns: logical

pure function parse_descriptor(name)#

Arguments:

character(len=*), intent(in) :: name

Returns: integer

pure function descriptor_name(descriptor)#

Arguments:

integer, intent(in) :: descriptor

Returns: character(len=:), allocatable

subroutine checkout(self, local_path, error)#

Arguments:

class (git_target_t), intent(in) :: self
character(len=*), intent(in) :: local_path
type (error_t), intent(out), allocatable :: error

subroutine git_revision(local_path, object, error)#

Arguments:

character(len=*), intent(in) :: local_path
character(len=:), intent(out), allocatable :: object
type (error_t), intent(out), allocatable :: error

subroutine info(self, unit, verbosity)#

Arguments:

class (git_target_t), intent(in) :: self
integer, intent(in) :: unit
integer, intent(in), optional :: verbosity

subroutine dump_to_toml(self, table, error)#

Arguments:

class (git_target_t), intent(inout) :: self
type (toml_table), intent(inout) :: table
type (error_t), intent(out), allocatable :: error

subroutine load_from_toml(self, table, error)#

Arguments:

class (git_target_t), intent(inout) :: self
type (toml_table), intent(inout) :: table
type (error_t), intent(out), allocatable :: error

subroutine git_archive(source, destination, ref, additional_files, verbose, error)#

Arguments:

character(len=*), intent(in) :: source
character(len=*), intent(in) :: destination
character(len=*), intent(in) :: ref
character(len=*), intent(in), optional :: additional_files
logical, intent(in) :: verbose
type (error_t), intent(out), allocatable :: error

module fpm_installer#

Uses: iso_fortran_env, fpm_environment, fpm_error, fpm_targets, fpm_filesystem

parameter default_bindir = "bin"#: Type: character(len=*)

parameter default_libdir = "lib"#: Type: character(len=*)

parameter default_testdir = "test"#: Type: character(len=*)

parameter default_includedir = "include"#: Type: character(len=*)

parameter default_moduledir = "include"#: Type: character(len=*)

parameter default_copy_unix = "cp"#: Type: character(len=*)

parameter default_copy_win = "copy"#: Type: character(len=*)

parameter default_force_copy_unix = "cp -f"#: Type: character(len=*)

parameter default_force_copy_win = "copy /Y"#: Type: character(len=*)

parameter default_move_unix = "mv"#: Type: character(len=*)

parameter default_move_win = "move"#: Type: character(len=*)

type installer_t#

member prefix#: Type: character(len=:), allocatable

member bindir#: Type: character(len=:), allocatable

member libdir#: Type: character(len=:), allocatable

member testdir#: Type: character(len=:), allocatable

member includedir#: Type: character(len=:), allocatable

member moduledir#: Type: character(len=:), allocatable

member unit = output_unit#: Type: integer

member verbosity = 1#: Type: integer

member copy#: Type: character(len=:), allocatable

member move#: Type: character(len=:), allocatable

member os#: Type: integer

procedure install_destination#: Binds to: install_destination

procedure install_executable#: Binds to: install_executable

procedure install_library#: Binds to: install_library

procedure install_header#: Binds to: install_header

procedure install_module#: Binds to: install_module

procedure install_test#: Binds to: install_test

procedure install#: Binds to: install

procedure run#: Binds to: run

procedure make_dir#: Binds to: make_dir

function install_destination(self, destination)#

Arguments:

class (installer_t), intent(inout) :: self
character(len=*), intent(in) :: destination

Returns: character(len=:), allocatable

subroutine new_installer(self, prefix, bindir, libdir, includedir, moduledir, testdir, verbosity, copy, move)#

Arguments:

type (installer_t), intent(out) :: self
character(len=*), intent(in), optional :: prefix
character(len=*), intent(in), optional :: bindir
character(len=*), intent(in), optional :: libdir
character(len=*), intent(in), optional :: includedir
character(len=*), intent(in), optional :: moduledir
character(len=*), intent(in), optional :: testdir
integer, intent(in), optional :: verbosity
character(len=*), intent(in), optional :: copy
character(len=*), intent(in), optional :: move

subroutine install_executable(self, executable, error)#

Arguments:

class (installer_t), intent(inout) :: self
character(len=*), intent(in) :: executable
type (error_t), intent(out), allocatable :: error

subroutine install_library(self, library, error)#

Arguments:

class (installer_t), intent(inout) :: self
type (build_target_t), intent(in) :: library
type (error_t), intent(out), allocatable :: error

subroutine install_test(self, test, error)#

Arguments:

class (installer_t), intent(inout) :: self
character(len=*), intent(in) :: test
type (error_t), intent(out), allocatable :: error

subroutine install_header(self, header, error)#

Arguments:

class (installer_t), intent(inout) :: self
character(len=*), intent(in) :: header
type (error_t), intent(out), allocatable :: error

subroutine install_module(self, module, error)#

Arguments:

class (installer_t), intent(inout) :: self
character(len=*), intent(in) :: module
type (error_t), intent(out), allocatable :: error

subroutine install(self, source, destination, error)#

Arguments:

class (installer_t), intent(inout) :: self
character(len=*), intent(in) :: source
character(len=*), intent(in) :: destination
type (error_t), intent(out), allocatable :: error

subroutine make_dir(self, dir, error)#

Arguments:

class (installer_t), intent(inout) :: self
character(len=*), intent(in) :: dir
type (error_t), intent(out), allocatable :: error

subroutine run(self, command, error)#

Arguments:

class (installer_t), intent(inout) :: self
character(len=*), intent(in) :: command
type (error_t), intent(out), allocatable :: error

module fpm_manifest#

Uses: fpm_manifest_example, fpm_manifest_executable, fpm_manifest_dependency, fpm_manifest_library, fpm_manifest_preprocess, fpm_manifest_package, fpm_error, tomlf, fpm_toml, fpm_manifest_test, fpm_filesystem, fpm_environment, fpm_strings

subroutine default_library(self)#

Arguments:

type (library_config_t), intent(out) :: self

subroutine default_executable(self, name)#

Arguments:

type (executable_config_t), intent(out) :: self
character(len=*), intent(in) :: name

subroutine default_example(self, name)#

Arguments:

type (example_config_t), intent(out) :: self
character(len=*), intent(in) :: name

subroutine default_test(self, name)#

Arguments:

type (test_config_t), intent(out) :: self
character(len=*), intent(in) :: name

subroutine get_package_data(package, file, error, apply_defaults)#

Arguments:

type (package_config_t), intent(out) :: package
character(len=*), intent(in) :: file
type (error_t), intent(out), allocatable :: error
logical, intent(in), optional :: apply_defaults

subroutine package_defaults(package, root, error)#

Arguments:

type (package_config_t), intent(inout) :: package
character(len=*), intent(in) :: root
type (error_t), intent(out), allocatable :: error

subroutine get_package_dependencies(package, main, deps)#

Arguments:

type (package_config_t), intent(in) :: package
logical, intent(in) :: main
type (dependency_config_t), intent(out), allocatable :: deps

module fpm_manifest_build#

Uses: fpm_error, fpm_strings, tomlf, fpm_toml

parameter class_name = 'build_config_t'#: Type: character(len=*)

type build_config_t, extends(serializable_t)#

member auto_executables = .true.#: Type: logical

member auto_examples = .true.#: Type: logical

member auto_tests = .true.#: Type: logical

member module_naming = .false.#: Type: logical

member module_prefix#: Type: type (string_t)

member link#: Type: type (string_t), allocatable

member external_modules#: Type: type (string_t), allocatable

procedure info#: Binds to: info

procedure serializable_is_same#: Binds to: build_conf_is_same

procedure dump_to_toml#: Binds to: dump_to_toml

procedure load_from_toml#: Binds to: load_from_toml

function build_conf_is_same(this, that)#

Arguments:

class (build_config_t), intent(in) :: this
class (serializable_t), intent(in) :: that

Returns: logical

subroutine new_build_config(self, table, package_name, error)#

Arguments:

type (build_config_t), intent(out) :: self
type (toml_table), intent(inout) :: table
character(len=*), intent(in) :: package_name
type (error_t), intent(out), allocatable :: error

subroutine check(table, package_name, error)#

Arguments:

type (toml_table), intent(inout) :: table
character(len=*), intent(in) :: package_name
type (error_t), intent(out), allocatable :: error

subroutine info(self, unit, verbosity)#

Arguments:

class (build_config_t), intent(in) :: self
integer, intent(in) :: unit
integer, intent(in), optional :: verbosity

subroutine dump_to_toml(self, table, error)#

Arguments:

class (build_config_t), intent(inout) :: self
type (toml_table), intent(inout) :: table
type (error_t), intent(out), allocatable :: error

subroutine load_from_toml(self, table, error)#

Arguments:

class (build_config_t), intent(inout) :: self
type (toml_table), intent(inout) :: table
type (error_t), intent(out), allocatable :: error

module fpm_manifest_dependency#

Uses: fpm_error, fpm_git, tomlf, fpm_toml, fpm_filesystem, fpm_environment, fpm_manifest_metapackages, fpm_versioning, fpm_strings, fpm_manifest_preprocess

parameter out_fmt = '("#", *(1x, g0))'#: Type: character(len=*)

type dependency_config_t, extends(serializable_t)#

member name#: Type: character(len=:), allocatable

member path#: Type: character(len=:), allocatable

member namespace#: Type: character(len=:), allocatable

member requested_version#: Type: type (version_t), allocatable

member preprocess#: Type: type (preprocess_config_t), allocatable

member features#: Type: type (string_t), allocatable

member profile#: Type: character(len=:), allocatable

member git#: Type: type (git_target_t), allocatable

procedure info#: Binds to: info

procedure add_preprocess#: Binds to: add_preprocess

procedure serializable_is_same#: Binds to: dependency_is_same

procedure dump_to_toml#: Binds to: dump_to_toml

procedure load_from_toml#: Binds to: load_from_toml

interface resize#

pure subroutine resize_dependency_config(var, n)#

Arguments:

type (dependency_config_t), intent(inout), allocatable :: var
integer, intent(in), optional :: n

function manifest_has_changed(cached, manifest, verbosity, iunit)#

Arguments:

class (dependency_config_t), intent(in) :: cached
class (dependency_config_t), intent(in) :: manifest
integer, intent(in) :: verbosity
integer, intent(in) :: iunit

Returns: logical

function dependency_is_same(this, that)#

Arguments:

class (dependency_config_t), intent(in) :: this
class (serializable_t), intent(in) :: that

Returns: logical

subroutine new_dependency(self, table, root, error)#

Arguments:

type (dependency_config_t), intent(out) :: self
type (toml_table), intent(inout) :: table
character(len=*), intent(in), optional :: root
type (error_t), intent(out), allocatable :: error

subroutine check(table, error)#

Arguments:

type (toml_table), intent(inout) :: table
type (error_t), intent(out), allocatable :: error

subroutine new_dependencies(deps, table, root, meta, error)#

Arguments:

type (dependency_config_t), intent(out), allocatable :: deps
type (toml_table), intent(inout) :: table
character(len=*), intent(in), optional :: root
type (metapackage_config_t), intent(out), optional :: meta
type (error_t), intent(out), allocatable :: error

subroutine info(self, unit, verbosity)#

Arguments:

class (dependency_config_t), intent(in) :: self
integer, intent(in) :: unit
integer, intent(in), optional :: verbosity

elemental subroutine dependency_destroy(self)#

Arguments:

class (dependency_config_t), intent(inout) :: self

subroutine dump_to_toml(self, table, error)#

Arguments:

class (dependency_config_t), intent(inout) :: self
type (toml_table), intent(inout) :: table
type (error_t), intent(out), allocatable :: error

subroutine load_from_toml(self, table, error)#

Arguments:

class (dependency_config_t), intent(inout) :: self
type (toml_table), intent(inout) :: table
type (error_t), intent(out), allocatable :: error

subroutine add_preprocess(dep, preprocess)#

Arguments:

class (dependency_config_t), intent(inout) :: dep
type (preprocess_config_t), intent(in) :: preprocess

module fpm_manifest_example#

Uses: fpm_manifest_dependency, fpm_manifest_executable, fpm_error, tomlf, fpm_toml

type example_config_t, extends(executable_config_t)#

procedure info#: Binds to: info

subroutine new_example(self, table, error)#

Arguments:

type (example_config_t), intent(out) :: self
type (toml_table), intent(inout) :: table
type (error_t), intent(out), allocatable :: error

subroutine check(table, error)#

Arguments:

type (toml_table), intent(inout) :: table
type (error_t), intent(out), allocatable :: error

subroutine info(self, unit, verbosity)#

Arguments:

class (example_config_t), intent(in) :: self
integer, intent(in) :: unit
integer, intent(in), optional :: verbosity

module fpm_manifest_executable#

Uses: fpm_manifest_dependency, fpm_error, fpm_strings, tomlf, fpm_toml

parameter class_name = 'executable_config_t'#: Type: character(len=*)

type executable_config_t, extends(serializable_t)#

member name#: Type: character(len=:), allocatable

member source_dir#: Type: character(len=:), allocatable

member main#: Type: character(len=:), allocatable

member dependency#: Type: type (dependency_config_t), allocatable

member link#: Type: type (string_t), allocatable

procedure info#: Binds to: info

procedure serializable_is_same#: Binds to: exe_is_same

procedure dump_to_toml#: Binds to: dump_to_toml

procedure load_from_toml#: Binds to: load_from_toml

function exe_is_same(this, that)#

Arguments:

class (executable_config_t), intent(in) :: this
class (serializable_t), intent(in) :: that

Returns: logical

subroutine new_executable(self, table, error)#

Arguments:

type (executable_config_t), intent(out) :: self
type (toml_table), intent(inout) :: table
type (error_t), intent(out), allocatable :: error

subroutine check(table, error)#

Arguments:

type (toml_table), intent(inout) :: table
type (error_t), intent(out), allocatable :: error

subroutine info(self, unit, verbosity)#

Arguments:

class (executable_config_t), intent(in) :: self
integer, intent(in) :: unit
integer, intent(in), optional :: verbosity

subroutine dump_to_toml(self, table, error)#

Arguments:

class (executable_config_t), intent(inout) :: self
type (toml_table), intent(inout) :: table
type (error_t), intent(out), allocatable :: error

subroutine load_from_toml(self, table, error)#

Arguments:

class (executable_config_t), intent(inout) :: self
type (toml_table), intent(inout) :: table
type (error_t), intent(out), allocatable :: error

module fpm_manifest_feature#

Uses: fpm_manifest_build, fpm_manifest_dependency, fpm_manifest_example, fpm_manifest_executable, fpm_manifest_fortran, fpm_manifest_library, fpm_manifest_install, fpm_manifest_test, fpm_manifest_preprocess, fpm_manifest_metapackages, fpm_manifest_platform, fpm_error, fpm_environment, fpm_compiler, fpm_strings, tomlf, fpm_toml

parameter class_name = 'feature_config_t'#: Type: character(len=*)

type feature_config_t, extends(serializable_t)#

member name#: Type: character(len=:), allocatable

member description#: Type: character(len=:), allocatable

member platform#: Type: type (platform_config_t)

member build#: Type: type (build_config_t), allocatable

member install#: Type: type (install_config_t), allocatable

member fortran#: Type: type (fortran_config_t), allocatable

member library#: Type: type (library_config_t), allocatable

member executable#: Type: type (executable_config_t), allocatable

member dependency#: Type: type (dependency_config_t), allocatable

member dev_dependency#: Type: type (dependency_config_t), allocatable

member example#: Type: type (example_config_t), allocatable

member test#: Type: type (test_config_t), allocatable

member preprocess#: Type: type (preprocess_config_t), allocatable

member meta#: Type: type (metapackage_config_t)

member flags#: Type: character(len=:), allocatable

member c_flags#: Type: character(len=:), allocatable

member cxx_flags#: Type: character(len=:), allocatable

member link_time_flags#: Type: character(len=:), allocatable

member requires_features#: Type: type (string_t), allocatable

procedure info#: Binds to: info

procedure check#: Binds to: check

procedure manifest_name#: Binds to: manifest_name

procedure has_cpp#: Binds to: has_cpp

procedure serializable_is_same#: Binds to: feature_is_same

procedure dump_to_toml#: Binds to: dump_to_toml

procedure load_from_toml#: Binds to: load_from_toml

interface unique_programs#

subroutine unique_programs1(executable, error)#

Arguments:

class (executable_config_t), intent(in) :: executable
type (error_t), intent(out), allocatable :: error

subroutine unique_programs2(executable_i, executable_j, error)#

Arguments:

class (executable_config_t), intent(in) :: executable_i
class (executable_config_t), intent(in) :: executable_j
type (error_t), intent(out), allocatable :: error

function feature_is_same(this, that)#

Arguments:

class (feature_config_t), intent(in) :: this
class (serializable_t), intent(in) :: that

Returns: logical

function manifest_name(self)#

Arguments:

class (feature_config_t), intent(in) :: self

Returns: character(len=:), allocatable

elemental function has_cpp(self)#

Arguments:

class (feature_config_t), intent(in) :: self

Returns: logical

subroutine new_feature(self, table, root, error, name)#

Arguments:

type (feature_config_t), intent(out) :: self
type (toml_table), intent(inout) :: table
character(len=*), intent(in), optional :: root
type (error_t), intent(out), allocatable :: error
character(len=*), intent(in), optional :: name

subroutine check(table, error)#

Arguments:

type (toml_table), intent(inout) :: table
type (error_t), intent(out), allocatable :: error

subroutine new_features(features, table, root, error)#

Arguments:

type (feature_config_t), intent(out), allocatable :: features
type (toml_table), intent(inout) :: table
character(len=*), intent(in), optional :: root
type (error_t), intent(out), allocatable :: error

subroutine find_feature(features, feature_name, current_platform, found, chosen_feature)#

Arguments:

type (feature_config_t), intent(in), allocatable :: features
character(len=*), intent(in) :: feature_name
type (platform_config_t), intent(in) :: current_platform
logical, intent(out) :: found
type (feature_config_t), intent(out) :: chosen_feature

subroutine info(self, unit, verbosity)#

Arguments:

class (feature_config_t), intent(in) :: self
integer, intent(in) :: unit
integer, intent(in), optional :: verbosity

subroutine dump_to_toml(self, table, error)#

Arguments:

class (feature_config_t), intent(inout) :: self
type (toml_table), intent(inout) :: table
type (error_t), intent(out), allocatable :: error

subroutine load_from_toml(self, table, error)#

Arguments:

class (feature_config_t), intent(inout) :: self
type (toml_table), intent(inout) :: table
type (error_t), intent(out), allocatable :: error

subroutine init_feature_components(self, table, platform, root, error)#

Arguments:

type (feature_config_t), intent(inout) :: self
type (toml_table), intent(inout) :: table
type (platform_config_t), intent(in), optional :: platform
character(len=*), intent(in), optional :: root
type (error_t), intent(out), allocatable :: error

module fpm_manifest_feature_collection#

Uses: fpm_manifest_feature, fpm_manifest_platform, fpm_manifest_dependency, fpm_manifest_example, fpm_manifest_executable, fpm_manifest_metapackages, fpm_manifest_test, fpm_manifest_preprocess, fpm_error, fpm_environment, fpm_compiler, fpm_strings, tomlf, fpm_toml

type feature_collection_t, extends(serializable_t)#

member base#: Type: type (feature_config_t)

member variants#: Type: type (feature_config_t), allocatable

procedure serializable_is_same#: Binds to: feature_collection_same

procedure dump_to_toml#: Binds to: feature_collection_dump

procedure load_from_toml#: Binds to: feature_collection_load

procedure push_variant#: Binds to: push_variant

procedure extract_for_target#: Binds to: extract_for_target

procedure check#: Binds to: check_collection

procedure merge_into_package#: Binds to: merge_into_package

procedure has_cpp#: Binds to: has_cpp

Constructors:

function collection_from_feature(self)#

Arguments:

class (feature_config_t), intent(in) :: self

Returns: type (feature_collection_t)

function feature_collection_same(this, that)#

Arguments:

class (feature_collection_t), intent(in) :: this
class (serializable_t), intent(in) :: that

Returns: logical

function is_compiler_key(s)#

Arguments:

character(len=*), intent(in) :: s

Returns: logical

function is_os_key(s)#

Arguments:

character(len=*), intent(in) :: s

Returns: logical

function default_debug_feature()#: Returns: type (feature_collection_t)

function default_release_feature()#: Returns: type (feature_collection_t)

function default_variant(name, compiler_id, os_type, flags, c_flags, cxx_flags)#

Arguments:

character(len=*), intent(in) :: name
integer (compiler_enum), intent(in) :: compiler_id
integer, intent(in) :: os_type
character(len=*), intent(in), optional :: flags
character(len=*), intent(in), optional :: c_flags
character(len=*), intent(in), optional :: cxx_flags

Returns: type (feature_config_t)

function variant_applies_to_target(variant, target_compiler, target_os)#

Arguments:

type (feature_config_t), intent(in) :: variant
integer, intent(in) :: target_compiler
integer, intent(in) :: target_os

Returns: logical

function extract_for_target(self, target, error)#

Arguments:

class (feature_collection_t), intent(in) :: self
type (platform_config_t), intent(in) :: target
type (error_t), intent(out), allocatable :: error

Returns: type (feature_config_t)

elemental function has_cpp(self)#

Arguments:

class (feature_collection_t), intent(in) :: self

Returns: logical

subroutine feature_collection_dump(self, table, error)#

Arguments:

class (feature_collection_t), intent(inout) :: self
type (toml_table), intent(inout) :: table
type (error_t), intent(out), allocatable :: error

subroutine feature_collection_load(self, table, error)#

Arguments:

class (feature_collection_t), intent(inout) :: self
type (toml_table), intent(inout) :: table
type (error_t), intent(out), allocatable :: error

elemental subroutine push_variant(self, variant)#

Arguments:

class (feature_collection_t), intent(inout) :: self
type (feature_config_t), intent(in) :: variant

subroutine new_collections(collections, table, error)#

Arguments:

type (feature_collection_t), intent(out), allocatable :: collections
type (toml_table), intent(inout) :: table
type (error_t), intent(out), allocatable :: error

subroutine new_collection_from_subtable(self, table, name, error)#

Arguments:

type (feature_collection_t), intent(out) :: self
type (toml_table), intent(inout) :: table
character(len=*), intent(in) :: name
type (error_t), intent(out), allocatable :: error

recursive subroutine traverse_feature_table(collection, table, feature_name, constraint, error)#

Arguments:

type (feature_collection_t), intent(inout) :: collection
type (toml_table), intent(inout) :: table
character(len=*), intent(in) :: feature_name
type (platform_config_t), intent(in) :: constraint
type (error_t), intent(out), allocatable :: error

subroutine merge_feature_configs(target, source, error)#

Arguments:

type (feature_config_t), intent(inout) :: target
type (feature_config_t), intent(in) :: source
type (error_t), intent(out), allocatable :: error

subroutine merge_executable_arrays(target, source, error)#

Arguments:

type (executable_config_t), intent(inout), allocatable :: target
type (executable_config_t), intent(in), allocatable :: source
type (error_t), intent(out), allocatable :: error

subroutine merge_dependency_arrays(target, source, error)#

Arguments:

type (dependency_config_t), intent(inout), allocatable :: target
type (dependency_config_t), intent(in), allocatable :: source
type (error_t), intent(out), allocatable :: error

subroutine merge_string_additive(target, source)#

Arguments:

character(len=:), intent(inout), allocatable :: target
character(len=:), intent(in), allocatable :: source

subroutine merge_example_arrays(target, source, error)#

Arguments:

type (example_config_t), intent(inout), allocatable :: target
type (example_config_t), intent(in), allocatable :: source
type (error_t), intent(out), allocatable :: error

subroutine merge_test_arrays(target, source, error)#

Arguments:

type (test_config_t), intent(inout), allocatable :: target
type (test_config_t), intent(in), allocatable :: source
type (error_t), intent(out), allocatable :: error

subroutine merge_preprocess_arrays(target, source)#

Arguments:

type (preprocess_config_t), intent(inout), allocatable :: target
type (preprocess_config_t), intent(in), allocatable :: source

subroutine merge_preprocessor_config(target, source)#

Arguments:

type (preprocess_config_t), intent(inout) :: target
type (preprocess_config_t), intent(in) :: source

subroutine merge_string_arrays(target, source)#

Arguments:

type (string_t), intent(inout), allocatable :: target
type (string_t), intent(in), allocatable :: source

subroutine merge_metapackages_additive(target, source)#

Arguments:

type (metapackage_request_t), intent(inout) :: target
type (metapackage_request_t), intent(in) :: source

subroutine merge_metapackages(target, source)#

Arguments:

type (metapackage_config_t), intent(inout) :: target
type (metapackage_config_t), intent(in) :: source

subroutine get_default_features(collections, error)#

Arguments:

type (feature_collection_t), intent(out), allocatable :: collections
type (error_t), intent(out), allocatable :: error

subroutine check_collection(self, error)#

Arguments:

class (feature_collection_t), intent(in) :: self
type (error_t), intent(out), allocatable :: error

subroutine validate_variant_hierarchy(variant, index, error)#

Arguments:

type (feature_config_t), intent(in) :: variant
integer, intent(in) :: index
type (error_t), intent(out), allocatable :: error

subroutine check_merge_conflicts(collection, error)#

Arguments:

class (feature_collection_t), intent(in) :: collection
type (error_t), intent(out), allocatable :: error

subroutine check_single_merge_conflict(target, source, compiler_id, os_id, error)#

Arguments:

type (feature_config_t), intent(in) :: target
type (feature_config_t), intent(in) :: source
integer, intent(in) :: compiler_id
integer, intent(in) :: os_id
type (error_t), intent(out), allocatable :: error

subroutine simulate_merge(target, source)#

Arguments:

type (feature_config_t), intent(inout) :: target
type (feature_config_t), intent(in) :: source

subroutine merge_into_package(self, package, target, error)#

Arguments:

class (feature_collection_t), intent(in) :: self
class (feature_config_t), intent(inout) :: package
type (platform_config_t), intent(in) :: target
type (error_t), intent(out), allocatable :: error

subroutine add_default_features(features, error)#

Arguments:

type (feature_collection_t), intent(inout), allocatable :: features
type (error_t), intent(out), allocatable :: error

module fpm_manifest_fortran#

Uses: fpm_error, tomlf, fpm_toml

parameter class_name = 'fortran_config_t'#: Type: character(len=*)

type fortran_config_t, extends(serializable_t)#

member implicit_typing = .false.#: Type: logical

member implicit_external = .false.#: Type: logical

member source_form#: Type: character(len=:), allocatable

procedure serializable_is_same#: Binds to: fortran_is_same

procedure dump_to_toml#: Binds to: dump_to_toml

procedure load_from_toml#: Binds to: load_from_toml

function fortran_is_same(this, that)#

Arguments:

class (fortran_config_t), intent(in) :: this
class (serializable_t), intent(in) :: that

Returns: logical

subroutine default_fortran_config(self)#

Arguments:

type (fortran_config_t), intent(inout) :: self

subroutine new_fortran_config(self, table, error)#

Arguments:

type (fortran_config_t), intent(out) :: self
type (toml_table), intent(inout) :: table
type (error_t), intent(out), allocatable :: error

subroutine check(table, error)#

Arguments:

type (toml_table), intent(inout) :: table
type (error_t), intent(out), allocatable :: error

subroutine dump_to_toml(self, table, error)#

Arguments:

class (fortran_config_t), intent(inout) :: self
type (toml_table), intent(inout) :: table
type (error_t), intent(out), allocatable :: error

subroutine load_from_toml(self, table, error)#

Arguments:

class (fortran_config_t), intent(inout) :: self
type (toml_table), intent(inout) :: table
type (error_t), intent(out), allocatable :: error

module fpm_manifest_install#

Uses: fpm_error, tomlf, fpm_toml

parameter class_name = 'install_config_t'#: Type: character(len=*)

type install_config_t, extends(serializable_t)#

member library = .false.#: Type: logical

member test = .false.#: Type: logical

member module_dir#: Type: character(len=:), allocatable

procedure info#: Binds to: info

procedure serializable_is_same#: Binds to: install_conf_same

procedure dump_to_toml#: Binds to: dump_to_toml

procedure load_from_toml#: Binds to: load_from_toml

function install_conf_same(this, that)#

Arguments:

class (install_config_t), intent(in) :: this
class (serializable_t), intent(in) :: that

Returns: logical

subroutine new_install_config(self, table, error)#

Arguments:

type (install_config_t), intent(out) :: self
type (toml_table), intent(inout) :: table
type (error_t), intent(out), allocatable :: error

subroutine check(table, error)#

Arguments:

type (toml_table), intent(inout) :: table
type (error_t), intent(out), allocatable :: error

subroutine info(self, unit, verbosity)#

Arguments:

class (install_config_t), intent(in) :: self
integer, intent(in) :: unit
integer, intent(in), optional :: verbosity

subroutine dump_to_toml(self, table, error)#

Arguments:

class (install_config_t), intent(inout) :: self
type (toml_table), intent(inout) :: table
type (error_t), intent(out), allocatable :: error

subroutine load_from_toml(self, table, error)#

Arguments:

class (install_config_t), intent(inout) :: self
type (toml_table), intent(inout) :: table
type (error_t), intent(out), allocatable :: error

module fpm_manifest_library#

Uses: fpm_error, fpm_strings, tomlf, fpm_toml

parameter class_name = 'library_config_t'#: Type: character(len=*)

type library_config_t, extends(serializable_t)#

member source_dir#: Type: character(len=:), allocatable

member include_dir#: Type: type (string_t), allocatable

member build_script#: Type: character(len=:), allocatable

member lib_type#: Type: type (string_t), allocatable

procedure info#: Binds to: info

procedure serializable_is_same#: Binds to: library_is_same

procedure dump_to_toml#: Binds to: dump_to_toml

procedure load_from_toml#: Binds to: load_from_toml

procedure monolithic#: Binds to: monolithic

procedure shared#: Binds to: shared

procedure static#: Binds to: static

elemental function shared(self)#

Arguments:

class (library_config_t), intent(in) :: self

Returns: logical

elemental function static(self)#

Arguments:

class (library_config_t), intent(in) :: self

Returns: logical

elemental function monolithic(self)#

Arguments:

class (library_config_t), intent(in) :: self

Returns: logical

function library_is_same(this, that)#

Arguments:

class (library_config_t), intent(in) :: this
class (serializable_t), intent(in) :: that

Returns: logical

subroutine new_library(self, table, error)#

Arguments:

type (library_config_t), intent(out) :: self
type (toml_table), intent(inout) :: table
type (error_t), intent(out), allocatable :: error

subroutine check(table, error)#

Arguments:

type (toml_table), intent(inout) :: table
type (error_t), intent(out), allocatable :: error

subroutine info(self, unit, verbosity)#

Arguments:

class (library_config_t), intent(in) :: self
integer, intent(in) :: unit
integer, intent(in), optional :: verbosity

subroutine dump_to_toml(self, table, error)#

Arguments:

class (library_config_t), intent(inout) :: self
type (toml_table), intent(inout) :: table
type (error_t), intent(out), allocatable :: error

subroutine load_from_toml(self, table, error)#

Arguments:

class (library_config_t), intent(inout) :: self
type (toml_table), intent(inout) :: table
type (error_t), intent(out), allocatable :: error

module fpm_manifest_metapackages#

Uses: fpm_error, tomlf, fpm_toml, fpm_environment

type metapackage_request_t, extends(serializable_t)#

member on = .false.#: Type: logical

member name#: Type: character(len=:), allocatable

member version#: Type: character(len=:), allocatable

procedure serializable_is_same#: Binds to: meta_request_same

procedure dump_to_toml#: Binds to: meta_request_dump

procedure load_from_toml#: Binds to: meta_request_load

type metapackage_config_t, extends(serializable_t)#

member mpi#: Type: type (metapackage_request_t)

member openmp#: Type: type (metapackage_request_t)

member stdlib#: Type: type (metapackage_request_t)

member minpack#: Type: type (metapackage_request_t)

member hdf5#: Type: type (metapackage_request_t)

member netcdf#: Type: type (metapackage_request_t)

member blas#: Type: type (metapackage_request_t)

procedure get_requests#: Binds to: get_requests

procedure merge#: Binds to: meta_config_merge

procedure reset#: Binds to: meta_config_reset

procedure serializable_is_same#: Binds to: meta_config_same

procedure dump_to_toml#: Binds to: meta_config_dump

procedure load_from_toml#: Binds to: meta_config_load

function is_meta_package(key)#

Arguments:

character(len=*), intent(in) :: key

Returns: logical

function get_requests(meta)#

Arguments:

class (metapackage_config_t), intent(in) :: meta

Returns: type (metapackage_request_t), allocatable

function meta_request_same(this, that)#

Arguments:

class (metapackage_request_t), intent(in) :: this
class (serializable_t), intent(in) :: that

Returns: logical

function meta_config_same(this, that)#

Arguments:

class (metapackage_config_t), intent(in) :: this
class (serializable_t), intent(in) :: that

Returns: logical

elemental subroutine request_destroy(self)#

Arguments:

class (metapackage_request_t), intent(inout) :: self

subroutine request_parse(self, version_request, error)#

Arguments:

type (metapackage_request_t), intent(inout) :: self
character(len=*), intent(in) :: version_request
type (error_t), intent(out), allocatable :: error

subroutine new_meta_request(self, key, table, meta_allowed, error)#

Arguments:

type (metapackage_request_t), intent(out) :: self
character(len=*), intent(in) :: key
type (toml_table), intent(inout) :: table
logical, intent(in), optional :: meta_allowed
type (error_t), intent(out), allocatable :: error

subroutine new_meta_config(self, table, meta_allowed, error)#

Arguments:

type (metapackage_config_t), intent(out) :: self
type (toml_table), intent(inout) :: table
logical, intent(in) :: meta_allowed
type (error_t), intent(out), allocatable :: error

subroutine meta_config_merge(self, other)#

Arguments:

class (metapackage_config_t), intent(inout) :: self
type (metapackage_config_t), intent(in) :: other

subroutine meta_request_dump(self, table, error)#

Arguments:

class (metapackage_request_t), intent(inout) :: self
type (toml_table), intent(inout) :: table
type (error_t), intent(out), allocatable :: error

subroutine meta_request_load(self, table, error)#

Arguments:

class (metapackage_request_t), intent(inout) :: self
type (toml_table), intent(inout) :: table
type (error_t), intent(out), allocatable :: error

subroutine meta_config_dump(self, table, error)#

Arguments:

class (metapackage_config_t), intent(inout) :: self
type (toml_table), intent(inout) :: table
type (error_t), intent(out), allocatable :: error

subroutine meta_config_final(self)#

Arguments:

type (metapackage_config_t), intent(inout) :: self

subroutine meta_config_reset(self)#

Arguments:

class (metapackage_config_t), intent(inout) :: self

subroutine meta_config_load(self, table, error)#

Arguments:

class (metapackage_config_t), intent(inout) :: self
type (toml_table), intent(inout) :: table
type (error_t), intent(out), allocatable :: error

module fpm_manifest_package#

Uses: fpm_manifest_build, fpm_manifest_dependency, fpm_manifest_profile, fpm_manifest_example, fpm_manifest_executable, fpm_manifest_fortran, fpm_manifest_library, fpm_manifest_install, fpm_manifest_test, fpm_manifest_preprocess, fpm_manifest_feature, fpm_manifest_feature_collection, fpm_manifest_platform, fpm_strings, fpm_filesystem, fpm_error, tomlf, fpm_toml, fpm_versioning

parameter class_name = 'package_config_t'#: Type: character(len=*)

type package_config_t, extends(feature_config_t)#

member version#: Type: type (version_t)

member license#: Type: character(len=:), allocatable

member author#: Type: character(len=:), allocatable

member maintainer#: Type: character(len=:), allocatable

member copyright#: Type: character(len=:), allocatable

member features#: Type: type (feature_collection_t), allocatable

member profiles#: Type: type (profile_config_t), allocatable

procedure info#: Binds to: info

procedure serializable_is_same#: Binds to: manifest_is_same

procedure dump_to_toml#: Binds to: dump_to_toml

procedure load_from_toml#: Binds to: load_from_toml

procedure has_cpp#: Binds to: has_cpp

procedure export_config#: Binds to: export_config

procedure find_feature#: Binds to: find_feature

procedure find_profile#: Binds to: find_profile

function manifest_is_same(this, that)#

Arguments:

class (package_config_t), intent(in) :: this
class (serializable_t), intent(in) :: that

Returns: logical

function export_config(self, platform, features, profile, verbose, error)#

Arguments:

class (package_config_t), intent(in), target :: self
type (platform_config_t), intent(in) :: platform
type (string_t), intent(in), optional, target :: features
character(len=*), intent(in), optional :: profile
logical, intent(in), optional :: verbose
type (error_t), intent(out), allocatable :: error

Returns: type (package_config_t)

function find_profile(self, profile_name)#

Arguments:

class (package_config_t), intent(in) :: self
character(len=*), intent(in) :: profile_name

Returns: integer

function find_feature(self, feature_name)#

Arguments:

class (package_config_t), intent(in) :: self
character(len=*), intent(in) :: feature_name

Returns: integer

elemental function has_cpp(self)#

Arguments:

class (package_config_t), intent(in) :: self

Returns: logical

subroutine new_package(self, table, root, error)#

Arguments:

type (package_config_t), intent(out) :: self
type (toml_table), intent(inout) :: table
character(len=*), intent(in), optional :: root
type (error_t), intent(out), allocatable :: error

subroutine check(table, error)#

Arguments:

type (toml_table), intent(inout) :: table
type (error_t), intent(out), allocatable :: error

subroutine info(self, unit, verbosity)#

Arguments:

class (package_config_t), intent(in) :: self
integer, intent(in) :: unit
integer, intent(in), optional :: verbosity

subroutine dump_to_toml(self, table, error)#

Arguments:

class (package_config_t), intent(inout) :: self
type (toml_table), intent(inout) :: table
type (error_t), intent(out), allocatable :: error

subroutine load_from_toml(self, table, error)#

Arguments:

class (package_config_t), intent(inout) :: self
type (toml_table), intent(inout) :: table
type (error_t), intent(out), allocatable :: error

subroutine apply_default_features(self, prof, cfg, platform, verbose, error)#

Arguments:

class (package_config_t), intent(in) :: self
type (profile_config_t), intent(in) :: prof
type (package_config_t), intent(inout) :: cfg
type (platform_config_t), intent(in) :: platform
logical, intent(in), optional :: verbose
type (error_t), intent(out), allocatable :: error

subroutine validate_profiles(self, error)#

Arguments:

class (package_config_t), intent(in) :: self
type (error_t), intent(out), allocatable :: error

subroutine print_feature_collection(collection, platform)#

Arguments:

type (feature_collection_t), intent(in) :: collection
type (platform_config_t), intent(in) :: platform

module fpm_manifest_platform#

Uses: fpm_error, tomlf, fpm_toml, fpm_environment, fpm_compiler, fpm_strings

parameter id_intel_classic = [id_intel_classic_mac, id_intel_classic_nix, id_intel_classi...#: Type: integer (compiler_enum)

parameter id_intel_llvm = [id_intel_llvm_nix, id_intel_llvm_windows, id_intel_llvm_unk...#: Type: integer (compiler_enum)

parameter class_name = 'platform_config_t'#: Type: character(len=*)

type platform_config_t, extends(serializable_t)#

member compiler = id_all#: Type: integer (compiler_enum)

member os_type = OS_ALL#: Type: integer

procedure serializable_is_same#: Binds to: platform_is_same

procedure dump_to_toml#: Binds to: dump_to_toml

procedure load_from_toml#: Binds to: load_from_toml

procedure info#: Binds to: info

procedure matches#: Binds to: platform_is_suitable

procedure compiler_name#: Binds to: platform_compiler_name

procedure os_name#: Binds to: platform_os_name

procedure name#: Binds to: platform_config_name

procedure is_valid#: Binds to: platform_is_valid

procedure any_compiler#: Binds to: any_compiler

procedure any_os#: Binds to: any_os

procedure any_platform#: Binds to: any_platform

Constructors:

function new_platform(compiler, os_type)#

Arguments:

character(len=*), intent(in) :: compiler
integer, intent(in) :: os_type

Returns: type (platform_config_t)

function new_platform_id(compiler_id, os_type)#

Arguments:

integer (compiler_enum), intent(in) :: compiler_id
integer, intent(in) :: os_type

Returns: type (platform_config_t)

function correct_compiler_for_os(compiler_id, os_type)#

Arguments:

integer (compiler_enum), intent(in) :: compiler_id
integer, intent(in) :: os_type

Returns: integer (compiler_enum)

function compiler_is_suitable(compiler_id, target)#

Arguments:

integer (compiler_enum), intent(in) :: compiler_id
type (platform_config_t), intent(in) :: target

Returns: logical

function platform_is_same(this, that)#

Arguments:

class (platform_config_t), intent(in) :: this
class (serializable_t), intent(in) :: that

Returns: logical

function platform_is_suitable(self, target)#

Arguments:

class (platform_config_t), intent(in) :: self
type (platform_config_t), intent(in) :: target

Returns: logical

function platform_is_valid(self)#

Arguments:

class (platform_config_t), intent(in) :: self

Returns: logical

elemental function compiler_os_compatible(compiler_id, os_type)#

Arguments:

integer (compiler_enum), intent(in) :: compiler_id
integer, intent(in) :: os_type

Returns: logical

elemental function is_platform_key(key)#

Arguments:

character(len=*), intent(in) :: key

Returns: logical

function platform_compiler_name(self)#

Arguments:

class (platform_config_t), intent(in) :: self

Returns: character(len=:), allocatable

function platform_os_name(self)#

Arguments:

class (platform_config_t), intent(in) :: self

Returns: character(len=:), allocatable

function platform_config_name(self)#

Arguments:

class (platform_config_t), intent(in) :: self

Returns: character(len=:), allocatable

elemental function any_compiler(self)#

Arguments:

class (platform_config_t), intent(in) :: self

Returns: logical

elemental function any_os(self)#

Arguments:

class (platform_config_t), intent(in) :: self

Returns: logical

elemental function any_platform(self)#

Arguments:

class (platform_config_t), intent(in) :: self

Returns: logical

subroutine dump_to_toml(self, table, error)#

Arguments:

class (platform_config_t), intent(inout) :: self
type (toml_table), intent(inout) :: table
type (error_t), intent(out), allocatable :: error

subroutine load_from_toml(self, table, error)#

Arguments:

class (platform_config_t), intent(inout) :: self
type (toml_table), intent(inout) :: table
type (error_t), intent(out), allocatable :: error

subroutine info(self, unit, verbosity)#

Arguments:

class (platform_config_t), intent(in) :: self
integer, intent(in) :: unit
integer, intent(in), optional :: verbosity

module fpm_manifest_preprocess#

Uses: fpm_error, fpm_strings, tomlf, fpm_toml, iso_fortran_env

parameter class_name = 'preprocess_config_t'#: Type: character(len=*)

type preprocess_config_t, extends(serializable_t)#

member name#: Type: character(len=:), allocatable

member suffixes#: Type: type (string_t), allocatable

member directories#: Type: type (string_t), allocatable

member macros#: Type: type (string_t), allocatable

procedure info#: Binds to: info

procedure new_cpp_config_with_macros#: Binds to: new_cpp_config_with_macros

procedure new_preprocess_config#: Binds to: new_preprocess_config

procedure new#: Binds to: new_cpp_config_with_macros, new_preprocess_config

procedure serializable_is_same#: Binds to: preprocess_is_same

procedure dump_to_toml#: Binds to: dump_to_toml

procedure load_from_toml#: Binds to: load_from_toml

procedure destroy#: Binds to: destroy

procedure add_config#: Binds to: add_config

procedure is_cpp#: Binds to: is_cpp

procedure is_fypp#: Binds to: is_fypp

function preprocess_is_same(this, that)#

Arguments:

class (preprocess_config_t), intent(in) :: this
class (serializable_t), intent(in) :: that

Returns: logical

elemental function is_cpp(this)#

Arguments:

class (preprocess_config_t), intent(in) :: this

Returns: logical

function is_fypp(this)#

Arguments:

class (preprocess_config_t), intent(in) :: this

Returns: logical

subroutine new_cpp_config_with_macros(self, macros)#

Arguments:

class (preprocess_config_t), intent(out) :: self
type (string_t), intent(in) :: macros

subroutine new_preprocess_config(self, table, error)#

Arguments:

class (preprocess_config_t), intent(out) :: self
type (toml_table), intent(inout) :: table
type (error_t), intent(out), allocatable :: error

subroutine check(table, error)#

Arguments:

type (toml_table), intent(inout) :: table
type (error_t), intent(inout), allocatable :: error

subroutine new_preprocessors(preprocessors, table, error)#

Arguments:

type (preprocess_config_t), intent(out), allocatable :: preprocessors
type (toml_table), intent(inout) :: table
type (error_t), intent(out), allocatable :: error

subroutine info(self, unit, verbosity)#

Arguments:

class (preprocess_config_t), intent(in) :: self
integer, intent(in) :: unit
integer, intent(in), optional :: verbosity

subroutine dump_to_toml(self, table, error)#

Arguments:

class (preprocess_config_t), intent(inout) :: self
type (toml_table), intent(inout) :: table
type (error_t), intent(out), allocatable :: error

subroutine load_from_toml(self, table, error)#

Arguments:

class (preprocess_config_t), intent(inout) :: self
type (toml_table), intent(inout) :: table
type (error_t), intent(out), allocatable :: error

elemental subroutine destroy(this)#

Arguments:

class (preprocess_config_t), intent(inout) :: this

subroutine add_config(this, that)#

Arguments:

class (preprocess_config_t), intent(inout) :: this
type (preprocess_config_t), intent(in) :: that

module fpm_manifest_profile#

Uses: fpm_error, fpm_strings, tomlf, fpm_toml

parameter class_name = 'profile_config_t'#: Type: character(len=*)

type profile_config_t, extends(serializable_t)#

member name#: Type: character(len=:), allocatable

member features#: Type: type (string_t), allocatable

procedure info#: Binds to: info

procedure serializable_is_same#: Binds to: profile_is_same

procedure dump_to_toml#: Binds to: dump_to_toml

procedure load_from_toml#: Binds to: load_from_toml

function profile_is_same(this, that)#

Arguments:

class (profile_config_t), intent(in) :: this
class (serializable_t), intent(in) :: that

Returns: logical

subroutine new_profile(self, features_array, profile_name, error)#

Arguments:

type (profile_config_t), intent(out) :: self
type (toml_array), intent(inout) :: features_array
character(len=*), intent(in) :: profile_name
type (error_t), intent(out), allocatable :: error

subroutine new_profiles(profiles, table, error)#

Arguments:

type (profile_config_t), intent(out), allocatable :: profiles
type (toml_table), intent(inout) :: table
type (error_t), intent(out), allocatable :: error

subroutine info(self, unit, verbosity)#

Arguments:

class (profile_config_t), intent(in) :: self
integer, intent(in) :: unit
integer, intent(in), optional :: verbosity

subroutine dump_to_toml(self, table, error)#

Arguments:

class (profile_config_t), intent(inout) :: self
type (toml_table), intent(inout) :: table
type (error_t), intent(out), allocatable :: error

subroutine load_from_toml(self, table, error)#

Arguments:

class (profile_config_t), intent(inout) :: self
type (toml_table), intent(inout) :: table
type (error_t), intent(out), allocatable :: error

subroutine get_default_profiles(profiles, error)#

Arguments:

type (profile_config_t), intent(out), allocatable :: profiles
type (error_t), intent(out), allocatable :: error

subroutine add_default_profiles(profiles, error)#

Arguments:

type (profile_config_t), intent(inout), allocatable :: profiles
type (error_t), intent(out), allocatable :: error

module fpm_manifest_test#

Uses: fpm_manifest_dependency, fpm_manifest_executable, fpm_error, tomlf, fpm_toml

type test_config_t, extends(executable_config_t)#

procedure info#: Binds to: info

subroutine new_test(self, table, error)#

Arguments:

type (test_config_t), intent(out) :: self
type (toml_table), intent(inout) :: table
type (error_t), intent(out), allocatable :: error

subroutine check(table, error)#

Arguments:

type (toml_table), intent(inout) :: table
type (error_t), intent(out), allocatable :: error

subroutine info(self, unit, verbosity)#

Arguments:

class (test_config_t), intent(in) :: self
integer, intent(in) :: unit
integer, intent(in), optional :: verbosity

module fpm_meta#

Uses: fpm_compiler, fpm_manifest, fpm_model, fpm_command_line, fpm_error, fpm_filesystem, fpm_meta_base, fpm_meta_openmp, fpm_meta_stdlib, fpm_meta_minpack, fpm_meta_mpi, fpm_meta_hdf5, fpm_meta_netcdf, fpm_meta_blas, fpm_manifest_metapackages, shlex_module, regex_module, iso_fortran_env

interface resolve_metapackages#

subroutine resolve_metapackage_model(model, package, settings, error)#

Arguments:

type (fpm_model_t), intent(inout) :: model
type (package_config_t), intent(inout) :: package
class (fpm_build_settings), intent(inout) :: settings
type (error_t), intent(out), allocatable :: error

subroutine init_from_request(this, request, compiler, all_meta, error)#

Arguments:

class (metapackage_t), intent(inout) :: this
type (metapackage_request_t), intent(in) :: request
type (compiler_t), intent(in) :: compiler
type (metapackage_request_t), intent(in) :: all_meta
type (error_t), intent(out), allocatable :: error

subroutine add_metapackage_model(model, package, settings, meta, error)#

Arguments:

type (fpm_model_t), intent(inout) :: model
type (package_config_t), intent(inout) :: package
class (fpm_cmd_settings), intent(inout) :: settings
type (metapackage_t), intent(inout) :: meta
type (error_t), intent(out), allocatable :: error

module fpm_meta_base#

Uses: fpm_error, fpm_versioning, fpm_model, fpm_command_line, fpm_manifest_dependency, fpm_manifest_preprocess, fpm_manifest, fpm_strings, fpm_compiler

type metapackage_t#

member name#: Type: character(len=:), allocatable

member version#: Type: type (version_t), allocatable

member has_link_libraries = .false.#: Type: logical

member has_link_flags = .false.#: Type: logical

member has_build_flags = .false.#: Type: logical

member has_fortran_flags = .false.#: Type: logical

member has_c_flags = .false.#: Type: logical

member has_cxx_flags = .false.#: Type: logical

member has_include_dirs = .false.#: Type: logical

member has_dependencies = .false.#: Type: logical

member has_run_command = .false.#: Type: logical

member has_external_modules = .false.#: Type: logical

member flags#: Type: type (string_t)

member fflags#: Type: type (string_t)

member cflags#: Type: type (string_t)

member cxxflags#: Type: type (string_t)

member link_flags#: Type: type (string_t)

member run_command#: Type: type (string_t)

member incl_dirs#: Type: type (string_t), allocatable

member link_libs#: Type: type (string_t), allocatable

member external_modules#: Type: type (string_t), allocatable

member fortran#: Type: type (fortran_config_t), allocatable

member preprocess#: Type: type (preprocess_config_t), allocatable

member dependency#: Type: type (dependency_config_t), allocatable

procedure destroy#: Binds to: destroy

procedure resolve_cmd#: Binds to: resolve_cmd

procedure resolve_model#: Binds to: resolve_model

procedure resolve_package_config#: Binds to: resolve_package_config

procedure resolve#: Binds to: resolve_cmd, resolve_model, resolve_package_config

interface add_dependency_config#

pure subroutine add_dependency_config_one(list, new)#

Arguments:

type (dependency_config_t), intent(inout), allocatable :: list
type (dependency_config_t), intent(in) :: new

pure subroutine add_dependency_config_many(list, new)#

Arguments:

type (dependency_config_t), intent(inout), allocatable :: list
type (dependency_config_t), intent(in) :: new

elemental subroutine destroy(this)#

Arguments:

class (metapackage_t), intent(inout) :: this

subroutine resolve_cmd(self, settings, error)#

Arguments:

class (metapackage_t), intent(in) :: self
class (fpm_cmd_settings), intent(inout) :: settings
type (error_t), intent(out), allocatable :: error

subroutine resolve_model(self, model, error)#

Arguments:

class (metapackage_t), intent(in) :: self
type (fpm_model_t), intent(inout) :: model
type (error_t), intent(out), allocatable :: error

subroutine resolve_package_config(self, package, error)#

Arguments:

class (metapackage_t), intent(in) :: self
type (package_config_t), intent(inout) :: package
type (error_t), intent(out), allocatable :: error

module fpm_meta_blas#

Uses: fpm_compiler, fpm_environment, fpm_meta_base, fpm_meta_util, fpm_pkg_config, fpm_manifest_metapackages, fpm_strings, fpm_error

function compile_and_link_flags_supported(compiler, flags)#

Arguments:

type (compiler_t), intent(in) :: compiler
character(len=*), intent(in) :: flags

Returns: logical

subroutine init_blas(this, compiler, all_meta, error)#

Arguments:

class (metapackage_t), intent(inout) :: this
type (compiler_t), intent(in) :: compiler
type (metapackage_request_t), intent(in) :: all_meta
type (error_t), intent(out), allocatable :: error

subroutine set_compile_and_link_flags(this, compiler, flags)#

Arguments:

class (metapackage_t), intent(inout) :: this
type (compiler_t), intent(in) :: compiler
character(len=*), intent(in) :: flags

module fpm_meta_hdf5#

Uses: fpm_compiler, fpm_strings, fpm_filesystem, fpm_pkg_config, fpm_meta_base, fpm_meta_util, fpm_manifest_metapackages, fpm_error

subroutine init_hdf5(this, compiler, all_meta, error)#

Arguments:

class (metapackage_t), intent(inout) :: this
type (compiler_t), intent(in) :: compiler
type (metapackage_request_t), intent(in) :: all_meta
type (error_t), intent(out), allocatable :: error

module fpm_meta_minpack#

Uses: fpm_compiler, fpm_meta_base, fpm_error, fpm_git, fpm_manifest_metapackages

subroutine init_minpack(this, compiler, all_meta, error)#

Arguments:

class (metapackage_t), intent(inout) :: this
type (compiler_t), intent(in) :: compiler
type (metapackage_request_t), intent(in) :: all_meta
type (error_t), intent(out), allocatable :: error

module fpm_meta_mpi#

Uses: fpm_compiler, fpm_filesystem, fpm_os, fpm_error, fpm_versioning, fpm_strings, fpm_environment, fpm_meta_base, fpm_meta_util, fpm_manifest_metapackages, fpm_pkg_config, shlex_module

parameter MPI_TYPE_NONE = 0#: Type: integer

parameter MPI_TYPE_OPENMPI = 1#: Type: integer

parameter MPI_TYPE_MPICH = 2#: Type: integer

parameter MPI_TYPE_INTEL = 3#: Type: integer

parameter MPI_TYPE_MSMPI = 4#: Type: integer

parameter verbose = .false.#: Type: logical

parameter LANG_FORTRAN = 1#: Type: integer

parameter LANG_C = 2#: Type: integer

parameter LANG_CXX = 3#: Type: integer

parameter LANG_NAME = [character(7)::'Fortran', 'C', 'C++']#: Type: character(len=*)

function is_64bit_environment()#: Returns: logical

pure function MPI_TYPE_NAME(mpilib)#

Arguments:

integer, intent(in) :: mpilib

Returns: character(len=:), allocatable

function msmpi_init(this, compiler, error)#

Arguments:

class (metapackage_t), intent(inout) :: this
type (compiler_t), intent(in) :: compiler
type (error_t), intent(out), allocatable :: error

Returns: logical

function wsl_shell()#: Returns: logical

function is_intel_classic_option(language, same_vendor_ID, screen_out, compiler, mpi_compiler)#

Arguments:

integer, intent(in) :: language
integer, intent(in) :: same_vendor_ID
type (string_t), intent(in) :: screen_out
type (compiler_t), intent(in) :: compiler
type (compiler_t), intent(in) :: mpi_compiler

Returns: logical

function mpi_version_get(mpilib, wrapper, error)#

Arguments:

integer, intent(in) :: mpilib
type (string_t), intent(in) :: wrapper
type (error_t), intent(out), allocatable :: error

Returns: type (version_t)

function which_mpi_library(wrapper, compiler, verbose)#

Arguments:

type (string_t), intent(in) :: wrapper
type (compiler_t), intent(in) :: compiler
logical, intent(in), optional :: verbose

Returns: integer

function mpi_wrapper_query(mpilib, wrapper, command, verbose, error)#

Arguments:

integer, intent(in) :: mpilib
type (string_t), intent(in) :: wrapper
character(len=*), intent(in) :: command
logical, intent(in), optional :: verbose
type (error_t), intent(out), allocatable :: error

Returns: type (string_t)

function is_link_argument(compiler, string)#

Arguments:

type (compiler_t), intent(in) :: compiler
character(len=*), intent(in) :: string

Returns: logical

subroutine init_mpi(this, compiler, all_meta, error)#

Arguments:

class (metapackage_t), intent(inout) :: this
type (compiler_t), intent(in) :: compiler
type (metapackage_request_t), intent(in) :: all_meta
type (error_t), intent(out), allocatable :: error

subroutine wrapper_compiler_fit(fort_wrappers, c_wrappers, cpp_wrappers, compiler, wrap, mpi, error)#

Arguments:

type (string_t), intent(in), allocatable :: fort_wrappers
type (string_t), intent(in), allocatable :: c_wrappers
type (string_t), intent(in), allocatable :: cpp_wrappers
type (compiler_t), intent(in) :: compiler
integer, intent(out), dimension(3) :: wrap
integer, intent(out), dimension(3) :: mpi
type (error_t), intent(out), allocatable :: error

subroutine find_command_location(command, path, echo, verbose, error)#

Arguments:

character(len=*), intent(in) :: command
character(len=:), intent(out), allocatable :: path
logical, intent(in), optional :: echo
logical, intent(in), optional :: verbose
type (error_t), intent(out), allocatable :: error

subroutine get_mpi_runner(command, verbose, error)#

Arguments:

type (string_t), intent(out) :: command
logical, intent(in) :: verbose
type (error_t), intent(out), allocatable :: error

subroutine compiler_get_path(self, path, error)#

Arguments:

type (compiler_t), intent(in) :: self
type (string_t), intent(out) :: path
type (error_t), intent(out), allocatable :: error

subroutine compiler_get_version(self, version, is_msys2, error)#

Arguments:

type (compiler_t), intent(in) :: self
type (version_t), intent(out) :: version
logical, intent(out) :: is_msys2
type (error_t), intent(out), allocatable :: error

subroutine init_mpi_from_wrappers(this, compiler, mpilib, fort_wrapper, c_wrapper, cxx_wrapper, error)#

Arguments:

class (metapackage_t), intent(inout) :: this
type (compiler_t), intent(in) :: compiler
integer, intent(in) :: mpilib
type (string_t), intent(in) :: fort_wrapper
type (string_t), intent(in) :: c_wrapper
type (string_t), intent(in) :: cxx_wrapper
type (error_t), intent(out), allocatable :: error

subroutine mpi_compiler_match(language, wrappers, compiler, which_one, mpilib, error)#

Arguments:

integer, intent(in) :: language
type (string_t), intent(in) :: wrappers
type (compiler_t), intent(in) :: compiler
integer, intent(out) :: which_one
integer, intent(out) :: mpilib
type (error_t), intent(out), allocatable :: error

subroutine mpi_wrappers(compiler, fort_wrappers, c_wrappers, cpp_wrappers)#

Arguments:

type (compiler_t), intent(in) :: compiler
type (string_t), intent(out), allocatable :: fort_wrappers
type (string_t), intent(out), allocatable :: c_wrappers
type (string_t), intent(out), allocatable :: cpp_wrappers

subroutine assert_mpi_wrappers(language, wrappers, compiler, verbose)#

Arguments:

character(len=*), intent(in) :: language
type (string_t), intent(inout), allocatable :: wrappers
type (compiler_t), intent(in) :: compiler
logical, intent(in), optional :: verbose

subroutine filter_build_arguments(compiler, command)#

Arguments:

type (compiler_t), intent(in) :: compiler
type (string_t), intent(inout) :: command

subroutine filter_link_arguments(compiler, command)#

Arguments:

type (compiler_t), intent(in) :: compiler
type (string_t), intent(inout) :: command

module fpm_meta_netcdf#

Uses: fpm_compiler, fpm_meta_base, fpm_meta_util, fpm_pkg_config, fpm_strings, fpm_error, fpm_manifest_metapackages

subroutine init_netcdf(this, compiler, all_meta, error)#

Arguments:

class (metapackage_t), intent(inout) :: this
type (compiler_t), intent(in) :: compiler
type (metapackage_request_t), intent(in) :: all_meta
type (error_t), intent(out), allocatable :: error

module fpm_meta_openmp#

Uses: fpm_compiler, fpm_strings, fpm_meta_base, fpm_error, fpm_manifest_metapackages

subroutine init_openmp(this, compiler, all_meta, error)#

Arguments:

class (metapackage_t), intent(inout) :: this
type (compiler_t), intent(in) :: compiler
type (metapackage_request_t), intent(in) :: all_meta
type (error_t), intent(out), allocatable :: error

module fpm_meta_stdlib#

Uses: fpm_compiler, fpm_error, fpm_meta_base, fpm_git, fpm_manifest_metapackages, fpm_strings, iso_fortran_env

function external_blas(all_meta)#

Arguments:

type (metapackage_request_t), intent(in) :: all_meta

Returns: logical

subroutine init_stdlib(this, compiler, all_meta, error)#

Arguments:

class (metapackage_t), intent(inout) :: this
type (compiler_t), intent(in) :: compiler
type (metapackage_request_t), intent(in) :: all_meta
type (error_t), intent(out), allocatable :: error

module fpm_meta_util#

Uses: fpm_meta_base, fpm_filesystem, fpm_strings, fpm_error, fpm_versioning, fpm_pkg_config

subroutine add_pkg_config_compile_options(this, name, include_flag, libdir, error)#

Arguments:

class (metapackage_t), intent(inout) :: this
character(len=*), intent(in) :: name
character(len=*), intent(in) :: include_flag
character(len=:), allocatable :: libdir
type (error_t), intent(out), allocatable :: error

subroutine lib_get_trailing(lib_name, lib_dir, prefix, suffix, found)#

Arguments:

character(len=*), intent(in) :: lib_name
character(len=*), intent(in) :: lib_dir
character(len=:), intent(out), allocatable :: prefix
character(len=:), intent(out), allocatable :: suffix
logical, intent(out) :: found

module fpm_model#

Uses: iso_fortran_env, fpm_compiler, fpm_dependency, fpm_versioning, fpm_strings, tomlf, fpm_toml, fpm_error, fpm_environment, fpm_manifest_preprocess, fpm_manifest_fortran, fpm_manifest_platform

parameter FPM_UNIT_UNKNOWN = -1#: Type: integer

parameter FPM_UNIT_PROGRAM = 1#: Type: integer

parameter FPM_UNIT_MODULE = 2#: Type: integer

parameter FPM_UNIT_SUBMODULE = 3#: Type: integer

parameter FPM_UNIT_SUBPROGRAM = 4#: Type: integer

parameter FPM_UNIT_CSOURCE = 5#: Type: integer

parameter FPM_UNIT_CHEADER = 6#: Type: integer

parameter FPM_UNIT_CPPSOURCE = 7#: Type: integer

parameter FPM_SCOPE_UNKNOWN = -1#: Type: integer

parameter FPM_SCOPE_LIB = 1#: Type: integer

parameter FPM_SCOPE_DEP = 2#: Type: integer

parameter FPM_SCOPE_APP = 3#: Type: integer

parameter FPM_SCOPE_TEST = 4#: Type: integer

parameter FPM_SCOPE_EXAMPLE = 5#: Type: integer

type srcfile_t, extends(serializable_t)#

member file_name#: Type: character(len=:), allocatable

member exe_name#: Type: character(len=:), allocatable

member unit_scope = FPM_SCOPE_UNKNOWN#: Type: integer

member modules_provided#: Type: type (string_t), allocatable

member unit_type = FPM_UNIT_UNKNOWN#: Type: integer

member parent_modules#: Type: type (string_t), allocatable

member modules_used#: Type: type (string_t), allocatable

member include_dependencies#: Type: type (string_t), allocatable

member link_libraries#: Type: type (string_t), allocatable

member digest#: Type: integer (int64)

procedure serializable_is_same#: Binds to: srcfile_is_same

procedure dump_to_toml#: Binds to: srcfile_dump_to_toml

procedure load_from_toml#: Binds to: srcfile_load_from_toml

type package_t, extends(serializable_t)#

member name#: Type: character(len=:), allocatable

member sources#: Type: type (srcfile_t), allocatable

member preprocess#: Type: type (preprocess_config_t)

member version#: Type: type (version_t), allocatable

member enforce_module_names = .false.#: Type: logical

member module_prefix#: Type: type (string_t)

member features#: Type: type (fortran_config_t)

procedure has_library#: Binds to: package_has_library

procedure serializable_is_same#: Binds to: package_is_same

procedure dump_to_toml#: Binds to: package_dump_to_toml

procedure load_from_toml#: Binds to: package_load_from_toml

type fpm_model_t, extends(serializable_t)#

member package_name#: Type: character(len=:), allocatable

member packages#: Type: type (package_t), allocatable

member compiler#: Type: type (compiler_t)

member archiver#: Type: type (archiver_t)

member fortran_compile_flags#: Type: character(len=:), allocatable

member c_compile_flags#: Type: character(len=:), allocatable

member cxx_compile_flags#: Type: character(len=:), allocatable

member link_flags#: Type: character(len=:), allocatable

member build_prefix#: Type: character(len=:), allocatable

member build_dir#: Type: character(len=:), allocatable

member include_dirs#: Type: type (string_t), allocatable

member link_libraries#: Type: type (string_t), allocatable

member external_modules#: Type: type (string_t), allocatable

member deps#: Type: type (dependency_tree_t)

member include_tests = .true.#: Type: logical

member enforce_module_names = .false.#: Type: logical

member module_prefix#: Type: type (string_t)

member target_os = OS_ALL#: Type: integer

procedure get_package_libraries_link#: Binds to: get_package_libraries_link

procedure target_platform#: Binds to: target_platform

procedure serializable_is_same#: Binds to: model_is_same

procedure dump_to_toml#: Binds to: model_dump_to_toml

procedure load_from_toml#: Binds to: model_load_from_toml

function info_package(p)#

Arguments:

type (package_t), intent(in) :: p

Returns: character(len=:), allocatable

function info_srcfile(source)#

Arguments:

type (srcfile_t), intent(in) :: source

Returns: character(len=:), allocatable

function info_srcfile_short(source)#

Arguments:

type (srcfile_t), intent(in) :: source

Returns: character(len=:), allocatable

function info_model(model)#

Arguments:

type (fpm_model_t), intent(in) :: model

Returns: character(len=:), allocatable

function FPM_SCOPE_NAME(flag)#

Arguments:

integer, intent(in) :: flag

Returns: character(len=:), allocatable

function parse_scope(name)#

Arguments:

character(len=*), intent(in) :: name

Returns: integer

function FPM_UNIT_NAME(flag)#

Arguments:

integer, intent(in) :: flag

Returns: character(len=:), allocatable

function parse_unit(name)#

Arguments:

character(len=*), intent(in) :: name

Returns: integer

function srcfile_is_same(this, that)#

Arguments:

class (srcfile_t), intent(in) :: this
class (serializable_t), intent(in) :: that

Returns: logical

function package_is_same(this, that)#

Arguments:

class (package_t), intent(in) :: this
class (serializable_t), intent(in) :: that

Returns: logical

function model_is_same(this, that)#

Arguments:

class (fpm_model_t), intent(in) :: this
class (serializable_t), intent(in) :: that

Returns: logical

function target_platform(self)#

Arguments:

class (fpm_model_t), intent(in) :: self

Returns: type (platform_config_t)

function get_package_libraries_link(model, package_name, prefix, exclude_self, dep_IDs, error)#

Arguments:

class (fpm_model_t), intent(in) :: model
character(len=*), intent(in) :: package_name
character(len=*), intent(in) :: prefix
logical, intent(in), optional :: exclude_self
integer, intent(out), optional, allocatable :: dep_IDs
type (error_t), intent(out), allocatable :: error

Returns: character(len=:), allocatable

elemental function package_has_library(self)#

Arguments:

class (package_t), intent(in) :: self

Returns: logical

subroutine show_model(model)#

Arguments:

type (fpm_model_t), intent(in) :: model

subroutine srcfile_dump_to_toml(self, table, error)#

Arguments:

class (srcfile_t), intent(inout) :: self
type (toml_table), intent(inout) :: table
type (error_t), intent(out), allocatable :: error

subroutine srcfile_load_from_toml(self, table, error)#

Arguments:

class (srcfile_t), intent(inout) :: self
type (toml_table), intent(inout) :: table
type (error_t), intent(out), allocatable :: error

subroutine package_dump_to_toml(self, table, error)#

Arguments:

class (package_t), intent(inout) :: self
type (toml_table), intent(inout) :: table
type (error_t), intent(out), allocatable :: error

subroutine package_load_from_toml(self, table, error)#

Arguments:

class (package_t), intent(inout) :: self
type (toml_table), intent(inout) :: table
type (error_t), intent(out), allocatable :: error

subroutine model_dump_to_toml(self, table, error)#

Arguments:

class (fpm_model_t), intent(inout) :: self
type (toml_table), intent(inout) :: table
type (error_t), intent(out), allocatable :: error

subroutine model_load_from_toml(self, table, error)#

Arguments:

class (fpm_model_t), intent(inout) :: self
type (toml_table), intent(inout) :: table
type (error_t), intent(out), allocatable :: error

module fpm_os#

Uses: iso_c_binding, fpm_filesystem, fpm_environment, fpm_error

parameter buffersize = 1000_c_int#: Type: integer (c_int)

parameter pwd_env = "PWD"#: Type: character(len=*)

interface chdir_#

interface getcwd_#

interface realpath#

interface fullpath#

interface c_realpath#

subroutine change_directory(path, error)#

Arguments:

character(len=*), intent(in) :: path
type (error_t), intent(out), allocatable :: error

subroutine get_current_directory(path, error)#

Arguments:

character(len=:), intent(out), allocatable :: path
type (error_t), intent(out), allocatable :: error

subroutine f_c_character(rhs, lhs, len)#

Arguments:

character(len=*), intent(in) :: rhs
character (c_char), intent(out) :: lhs
integer, intent(in) :: len

subroutine c_f_character(rhs, lhs)#

Arguments:

character (c_char), intent(in) :: rhs
character(len=:), intent(out), allocatable :: lhs

subroutine get_realpath(path, real_path, error)#

Arguments:

character(len=*), intent(in) :: path
character(len=:), intent(out), allocatable :: real_path
type (error_t), intent(out), allocatable :: error

subroutine get_absolute_path(path, absolute_path, error)#

Arguments:

character(len=*), intent(in) :: path
character(len=:), intent(out), allocatable :: absolute_path
type (error_t), intent(out), allocatable :: error

subroutine get_absolute_path_by_cd(path, absolute_path, error)#

Arguments:

character(len=*), intent(in) :: path
character(len=:), intent(out), allocatable :: absolute_path
type (error_t), intent(out), allocatable :: error

subroutine convert_to_absolute_path(path, error)#

Arguments:

character(len=:), intent(inout), allocatable :: path
type (error_t), intent(out), allocatable :: error

module fpm_pkg_config#

Uses: fpm_strings, fpm_error, fpm_filesystem, fpm_environment, shlex_module

function assert_pkg_config()#: Returns: logical

function pkgcfg_get_version(package, error)#

Arguments:

character(len=*), intent(in) :: package
type (error_t), intent(out), allocatable :: error

Returns: type (string_t)

function pkgcfg_has_package(name)#

Arguments:

character(len=*), intent(in) :: name

Returns: logical

function pkgcfg_get_libs(package, error)#

Arguments:

character(len=*), intent(in) :: package
type (error_t), intent(out), allocatable :: error

Returns: type (string_t), allocatable

function pkgcfg_list_all(error, descriptions)#

Arguments:

type (error_t), intent(out), allocatable :: error
type (string_t), intent(out), optional, allocatable :: descriptions

Returns: type (string_t), allocatable

function pkgcfg_get_build_flags(name, allow_system, error)#

Arguments:

character(len=*), intent(in) :: name
logical, intent(in) :: allow_system
type (error_t), intent(out), allocatable :: error

Returns: type (string_t), allocatable

subroutine run_wrapper(wrapper, args, verbose, exitcode, cmd_success, screen_output)#

Arguments:

type (string_t), intent(in) :: wrapper
type (string_t), intent(in), optional :: args
logical, intent(in), optional :: verbose
integer, intent(out), optional :: exitcode
logical, intent(out), optional :: cmd_success
type (string_t), intent(out), optional :: screen_output

module fpm_release#

Uses: fpm_versioning, fpm_error

function fpm_version()#: Returns: type (version_t)

module fpm_settings#

Uses: fpm_filesystem, fpm_environment, fpm_error, tomlf, fpm_toml, fpm_os

parameter official_registry_base_url = 'https://fpm-registry.vercel.app'#: Type: character(len=*)

parameter default_config_file_name = 'config.toml'#: Type: character(len=*)

type fpm_global_settings#

member path_to_config_folder#: Type: character(len=:), allocatable

member config_file_name#: Type: character(len=:), allocatable

member registry_settings#: Type: type (fpm_registry_settings), allocatable

procedure path_to_config_folder_or_empty#: Binds to: path_to_config_folder_or_empty

procedure full_path#: Binds to: full_path

procedure has_custom_location#: Binds to: has_custom_location

type fpm_registry_settings#

member path#: Type: character(len=:), allocatable

member url#: Type: character(len=:), allocatable

member cache_path#: Type: character(len=:), allocatable

elemental function has_custom_location(self)#

Arguments:

class (fpm_global_settings), intent(in) :: self

Returns: logical

function full_path(self)#

Arguments:

class (fpm_global_settings), intent(in) :: self

Returns: character(len=:), allocatable

pure function path_to_config_folder_or_empty(self)#

Arguments:

class (fpm_global_settings), intent(in) :: self

Returns: character(len=:), allocatable

subroutine get_global_settings(global_settings, error)#

Arguments:

type (fpm_global_settings), intent(inout) :: global_settings
type (error_t), intent(out), allocatable :: error

subroutine use_default_registry_settings(global_settings)#

Arguments:

type (fpm_global_settings), intent(inout) :: global_settings

subroutine get_registry_settings(table, global_settings, error)#

Arguments:

type (toml_table), intent(inout), target :: table
type (fpm_global_settings), intent(inout) :: global_settings
type (error_t), intent(out), allocatable :: error

module fpm_source_parsing#

Uses: fpm_error, fpm_strings, fpm_model, fpm_manifest_preprocess, fpm_filesystem

type cpp_block#

member depth = 0#: Type: integer

member inside_inactive_block = .false.#: Type: logical

member inactive_depth = 0#: Type: integer

member name#: Type: character(len=:), allocatable

function macro_in_list(macro_name, macros)#

Arguments:

character(len=*), intent(in) :: macro_name
type (string_t), intent(in), optional :: macros

Returns: logical

function find_include_file(name, src_dir, pkg_dir)#

Arguments:

character(len=*), intent(in) :: name
character(len=*), intent(in) :: src_dir
character(len=*), intent(in) :: pkg_dir

Returns: character(len=:), allocatable

function get_macro_value(macro_name, macros, found)#

Arguments:

character(len=*), intent(in) :: macro_name
type (string_t), intent(in), optional :: macros
logical, intent(out), optional :: found

Returns: character(len=:), allocatable

function has_comparison_operator(condition)#

Arguments:

character(len=*), intent(in) :: condition

Returns: logical

function macro_is_truthy(macro_name, macros, locally_defined)#

Arguments:

character(len=*), intent(in) :: macro_name
type (string_t), intent(in), optional :: macros
logical, intent(in) :: locally_defined

Returns: logical

function read_lines_with_includes(filename)#

Arguments:

character(len=*), intent(in) :: filename

Returns: type (string_t), allocatable

function parse_define_directive(line)#

Arguments:

character(len=*), intent(in) :: line

Returns: character(len=:), allocatable

function parse_f_source(f_filename, error, preprocess)#

Arguments:

character(len=*), intent(in) :: f_filename
type (error_t), intent(out), allocatable :: error
type (preprocess_config_t), intent(in), optional :: preprocess

Returns: type (srcfile_t)

function parse_c_source(c_filename, error)#

Arguments:

character(len=*), intent(in) :: c_filename
type (error_t), intent(out), allocatable :: error

Returns: type (srcfile_t)

function split_n(string, delims, n, stat)#

Arguments:

character(len=*), intent(in) :: string
character(len=*), intent(in) :: delims
integer, intent(in) :: n
integer, intent(out) :: stat

Returns: character(len=:), allocatable

function parse_subsequence(string, t1, t2, t3, t4)#

Arguments:

character(len=*), intent(in) :: string
character(len=*), intent(in) :: t1
character(len=*), intent(in), optional :: t2
character(len=*), intent(in), optional :: t3
character(len=*), intent(in), optional :: t4

Returns: logical

function parse_sequence(string, t1, t2, t3, t4)#

Arguments:

character(len=*), intent(in) :: string
character(len=*), intent(in) :: t1
character(len=*), intent(in), optional :: t2
character(len=*), intent(in), optional :: t3
character(len=*), intent(in), optional :: t4

Returns: logical

subroutine is_include_line(line, is_include, include_name)#

Arguments:

character(len=*), intent(in) :: line
logical, intent(out) :: is_include
character(len=:), intent(out), allocatable :: include_name

subroutine parse_macro_comparison(condition, preprocess_macros, defined_macros, is_active, macro_name)#

Arguments:

character(len=*), intent(in) :: condition
type (string_t), intent(in), optional :: preprocess_macros
type (string_t), intent(in), optional :: defined_macros
logical, intent(out) :: is_active
character(len=:), intent(out), allocatable :: macro_name

subroutine parse_if_condition(lower_line, line, offset, heading_blanks, preprocess_macros, defined_macros, is_active, macro_name)#

Arguments:

character(len=*), intent(in) :: lower_line
character(len=*), intent(in) :: line
integer, intent(in) :: offset
integer, intent(in) :: heading_blanks
type (string_t), intent(in), optional :: preprocess_macros
type (string_t), intent(in), optional :: defined_macros
logical, intent(out) :: is_active
character(len=:), intent(out), allocatable :: macro_name

pure subroutine insert_lines(array, chunk, at_line)#

Arguments:

type (string_t), intent(inout), allocatable :: array
type (string_t), intent(in) :: chunk
integer, intent(in) :: at_line

subroutine add_macro(macros, macro)#

Arguments:

type (string_t), intent(inout), allocatable :: macros
character(len=*), intent(in) :: macro

subroutine start_cpp_block(blk, lower_line, line, preprocess, defined_macros)#

Arguments:

type (cpp_block), intent(inout) :: blk
character(len=*), intent(in) :: lower_line
character(len=*), intent(in) :: line
type (preprocess_config_t), intent(in), optional :: preprocess
type (string_t), intent(in), optional :: defined_macros

subroutine end_cpp_block(blk)#

Arguments:

type (cpp_block), intent(inout) :: blk

subroutine handle_else_block(blk)#

Arguments:

type (cpp_block), intent(inout) :: blk

subroutine parse_cpp_condition(lower_line, line, preprocess, is_active, macro_name, defined_macros)#

Arguments:

character(len=*), intent(in) :: lower_line
character(len=*), intent(in) :: line
type (preprocess_config_t), intent(in), optional :: preprocess
logical, intent(out) :: is_active
character(len=:), intent(out), allocatable :: macro_name
type (string_t), intent(in), optional :: defined_macros

subroutine parse_use_statement(f_filename, i, line, use_stmt, is_intrinsic, module_name, error)#

Arguments:

character(len=*), intent(in) :: f_filename
integer, intent(in) :: i
character(len=*), intent(in) :: line
logical, intent(out) :: use_stmt
logical, intent(out) :: is_intrinsic
character(len=:), intent(out), allocatable :: module_name
type (error_t), intent(out), allocatable :: error

module fpm_sources#

Uses: fpm_error, fpm_model, fpm_filesystem, fpm_environment, fpm_strings, fpm_source_parsing, fpm_manifest_executable, fpm_manifest_preprocess

parameter fortran_suffixes = [".f90", ".f "]#: Type: character(len=4)

parameter c_suffixes = [".c ", ".h ", ".cpp", ".hpp"]#: Type: character(len=4)

interface add_srcfile#

pure subroutine add_srcfile_one(list, new)#

Arguments:

type (srcfile_t), intent(inout), allocatable :: list
type (srcfile_t), intent(in) :: new

pure subroutine add_srcfile_many(list, new)#

Arguments:

type (srcfile_t), intent(inout), allocatable :: list
type (srcfile_t), intent(in) :: new

function parse_source(source_file_path, custom_f_ext, error, preprocess)#

Arguments:

character(len=*), intent(in) :: source_file_path
type (string_t), intent(in), optional :: custom_f_ext
type (error_t), intent(out), allocatable :: error
type (preprocess_config_t), intent(in), optional :: preprocess

Returns: type (srcfile_t)

function get_exe_name_with_suffix(source)#

Arguments:

type (srcfile_t), intent(in) :: source

Returns: character(len=:), allocatable

subroutine list_fortran_suffixes(suffixes, with_f_ext)#

Arguments:

type (string_t), intent(out), allocatable :: suffixes
type (string_t), intent(in), optional :: with_f_ext

subroutine add_sources_from_dir(sources, directory, scope, with_executables, with_f_ext, recurse, error, preprocess)#

Arguments:

type (srcfile_t), intent(inout), allocatable, target :: sources
character(len=*), intent(in) :: directory
integer, intent(in) :: scope
logical, intent(in), optional :: with_executables
type (string_t), intent(in), optional :: with_f_ext
logical, intent(in), optional :: recurse
type (error_t), intent(out), allocatable :: error
type (preprocess_config_t), intent(in), optional :: preprocess

subroutine add_executable_sources(sources, executables, scope, auto_discover, with_f_ext, error, preprocess)#

Arguments:

type (srcfile_t), intent(inout), allocatable, target :: sources
class (executable_config_t), intent(in) :: executables
integer, intent(in) :: scope
logical, intent(in) :: auto_discover
type (string_t), intent(in), optional :: with_f_ext
type (error_t), intent(out), allocatable :: error
type (preprocess_config_t), intent(in), optional :: preprocess

subroutine get_executable_source_dirs(exe_dirs, executables)#

Arguments:

type (string_t), intent(inout), allocatable :: exe_dirs
class (executable_config_t), intent(in) :: executables

module fpm_strings#

Uses: iso_fortran_env, iso_c_binding

type string_t#

member s#: Type: character(len=:), allocatable

Constructors:

function new_string_t(s)#

Arguments:

character(len=*), intent(in) :: s

Returns: type (string_t)

interface len_trim#

elemental function string_len_trim(string)#

Arguments:

type (string_t), intent(in) :: string

Returns: integer

pure function strings_len_trim(strings)#

Arguments:

type (string_t), intent(in) :: strings

Returns: integer

interface resize#

subroutine resize_string(list, n)#

Arguments:

type (string_t), intent(inout), allocatable :: list
integer, intent(in), optional :: n

interface operator(.in.)#

function string_array_contains(search_string, array)#

Arguments:

character(len=*), intent(in) :: search_string
type (string_t), intent(in) :: array

Returns: logical

interface fnv_1a#

pure function fnv_1a_char(input, seed)#

Arguments:

character(len=*), intent(in) :: input
integer (int64), intent(in), optional :: seed

Returns: integer (int64)

pure function fnv_1a_string_t(input, seed)#

Arguments:

type (string_t), intent(in) :: input
integer (int64), intent(in), optional :: seed

Returns: integer (int64)

interface str_ends_with#

pure function str_ends_with_str(s, e)#

Arguments:

character(len=*), intent(in) :: s
character(len=*), intent(in) :: e

Returns: logical

pure function str_ends_with_any(s, e)#

Arguments:

character(len=*), intent(in) :: s
character(len=*), intent(in) :: e

Returns: logical

pure function str_ends_with_any_string(s, e)#

Arguments:

character(len=*), intent(in) :: s
type (string_t), intent(in) :: e

Returns: logical

interface str#

pure function str_int(i)#

Arguments:

integer, intent(in) :: i

Returns: character(len=str_int_len)

pure function str_int64(i)#

Arguments:

integer (int64), intent(in) :: i

Returns: character(len=str_int64_len)

pure function str_logical(l)#

Arguments:

logical, intent(in) :: l

Returns: character(len=str_logical_len)

interface f_string#

function f_string(c_string)#

Arguments:

character(len=1), intent(in) :: c_string

Returns: character(len=:), allocatable

function f_string_cptr(cptr)#

Arguments:

type (c_ptr), intent(in), value :: cptr

Returns: character (c_char), allocatable

function f_string_cptr_n(cptr, n)#

Arguments:

type (c_ptr), intent(in), value :: cptr
integer (c_size_t), intent(in) :: n

Returns: character (c_char)

interface operator(==)#

pure function string_is_same(this, that)#

Arguments:

type (string_t), intent(in) :: this
type (string_t), intent(in) :: that

Returns: logical

pure function string_arrays_same(this, that)#

Arguments:

type (string_t), intent(in), allocatable :: this
type (string_t), intent(in), allocatable :: that

Returns: logical

interface add_strings#

pure subroutine add_strings_one(list, new)#

Arguments:

type (string_t), intent(inout), allocatable :: list
type (string_t), intent(in) :: new

pure subroutine add_strings_many(list, new)#

Arguments:

type (string_t), intent(inout), allocatable :: list
type (string_t), intent(in) :: new

pure function str_begins_with_str(s, e, case_sensitive)#

Arguments:

character(len=*), intent(in) :: s
character(len=*), intent(in) :: e
logical, intent(in), optional :: case_sensitive

Returns: logical

pure elemental function lower(str, begin, end)#

Arguments:

character(len=*), intent(in) :: str
integer, intent(in), optional :: begin
integer, intent(in), optional :: end

Returns: character(len=len(str))

pure elemental function upper(str, begin, end)#

Arguments:

character(len=*), intent(in) :: str
integer, intent(in), optional :: begin
integer, intent(in), optional :: end

Returns: character(len=len(str))

function string_cat(strings, delim)#

Arguments:

type (string_t), intent(in) :: strings
character(len=*), intent(in), optional :: delim

Returns: character(len=:), allocatable

pure function replace(string, charset, target_char)#

Arguments:

character(len=*), intent(in) :: string
character(len=1), intent(in) :: charset
character(len=1), intent(in) :: target_char

Returns: character(len=len(string))

pure function join(str, sep, trm, left, right, start, end)#

Arguments:

character(len=*), intent(in) :: str
character(len=*), intent(in), optional :: sep
logical, intent(in), optional :: trm
character(len=*), intent(in), optional :: left
character(len=*), intent(in), optional :: right
character(len=*), intent(in), optional :: start
character(len=*), intent(in), optional :: end

Returns: character(len=:), allocatable

function glob(tame, wild)#

Arguments:

character(len=*) :: tame
character(len=*) :: wild

Returns: logical

pure function str_int_len(i)#

Arguments:

integer, intent(in) :: i

Returns: integer

pure function str_int64_len(i)#

Arguments:

integer (int64), intent(in) :: i

Returns: integer

pure function str_logical_len(l)#

Arguments:

logical, intent(in) :: l

Returns: integer

pure function to_fortran_name(string)#

Arguments:

character(len=*), intent(in) :: string

Returns: character(len=len(string))

elemental function is_fortran_name(line)#

Arguments:

character(len=*), intent(in) :: line

Returns: logical

function is_valid_module_name(module_name, package_name, custom_prefix, enforce_module_names)#

Arguments:

type (string_t), intent(in) :: module_name
type (string_t), intent(in) :: package_name
type (string_t), intent(in) :: custom_prefix
logical, intent(in) :: enforce_module_names

Returns: logical

function is_valid_module_prefix(module_prefix)#

Arguments:

type (string_t), intent(in) :: module_prefix

Returns: logical

function module_prefix_template(project_name, custom_prefix)#

Arguments:

type (string_t), intent(in) :: project_name
type (string_t), intent(in) :: custom_prefix

Returns: type (string_t)

function module_prefix_type(project_name, custom_prefix)#

Arguments:

type (string_t), intent(in) :: project_name
type (string_t), intent(in) :: custom_prefix

Returns: type (string_t)

function has_valid_custom_prefix(module_name, custom_prefix)#

Arguments:

type (string_t), intent(in) :: module_name
type (string_t), intent(in) :: custom_prefix

Returns: logical

function has_valid_standard_prefix(module_name, package_name)#

Arguments:

type (string_t), intent(in) :: module_name
type (string_t), intent(in) :: package_name

Returns: logical

function dilate(instr)#

Arguments:

character(len=*), intent(in) :: instr

Returns: character(len=:), allocatable

function is_valid_feature_name(name)#

Arguments:

character(len=*), intent(in) :: name

Returns: logical

subroutine split(input_line, array, delimiters, order, nulls)#

Arguments:

character(len=*), intent(in) :: input_line
character(len=:), intent(out), allocatable :: array
character(len=*), intent(in), optional :: delimiters
character(len=*), intent(in), optional :: order
character(len=*), intent(in), optional :: nulls

pure subroutine split_first_last(string, set, first, last)#

Arguments:

character(len=*), intent(in) :: string
character(len=*), intent(in) :: set
integer, intent(out), allocatable :: first
integer, intent(out), allocatable :: last

pure subroutine split_lines_first_last(string, first, last)#

Arguments:

character(len=*), intent(in) :: string
integer, intent(out), allocatable :: first
integer, intent(out), allocatable :: last

pure subroutine split_pos(string, set, pos, back)#

Arguments:

character(len=*), intent(in) :: string
character(len=*), intent(in) :: set
integer, intent(inout) :: pos
logical, intent(in), optional :: back

subroutine remove_characters_in_set(string, set, replace_with)#

Arguments:

character(len=:), intent(inout), allocatable :: string
character(len=*), intent(in) :: set
character(len=1), intent(in), optional :: replace_with

subroutine remove_newline_characters(string)#

Arguments:

type (string_t), intent(inout) :: string

impure elemental subroutine notabs(instr, outstr, ilen)#

Arguments:

character(len=*), intent(in) :: instr
character(len=*), intent(out) :: outstr
integer, intent(out) :: ilen

module fpm_targets#

Uses: iso_fortran_env, fpm_error, fpm_model, fpm_compiler, fpm_environment, fpm_filesystem, fpm_strings, fpm_sources, fpm_manifest_library, fpm_manifest_preprocess, fpm_versioning

parameter FPM_TARGET_UNKNOWN = -1#: Type: integer

parameter FPM_TARGET_EXECUTABLE = 1#: Type: integer

parameter FPM_TARGET_ARCHIVE = 2#: Type: integer

parameter FPM_TARGET_OBJECT = 3#: Type: integer

parameter FPM_TARGET_C_OBJECT = 4#: Type: integer

parameter FPM_TARGET_CPP_OBJECT = 5#: Type: integer

parameter FPM_TARGET_SHARED = 6#: Type: integer

type build_target_ptr#

member ptr = null()#: Type: type (build_target_t), pointer

type build_target_t#

member output_file#: Type: character(len=:), allocatable

member output_name#: Type: character(len=:), allocatable

member output_dir#: Type: character(len=:), allocatable

member output_log_file#: Type: character(len=:), allocatable

member package_name#: Type: character(len=:), allocatable

member source#: Type: type (srcfile_t), allocatable

member dependencies#: Type: type (build_target_ptr), allocatable

member target_type = FPM_TARGET_UNKNOWN#: Type: integer

member link_libraries#: Type: type (string_t), allocatable

member link_objects#: Type: type (string_t), allocatable

member link_flags#: Type: character(len=:), allocatable

member compile_flags#: Type: character(len=:), allocatable

member touched = .false.#: Type: logical

member sorted = .false.#: Type: logical

member skip = .false.#: Type: logical

member features#: Type: type (fortran_config_t)

member schedule = -1#: Type: integer

member digest_cached#: Type: integer (int64), allocatable

member macros#: Type: type (string_t), allocatable

member version#: Type: type (version_t), allocatable

procedure info#: Binds to: info

procedure set_output_dir#: Binds to: set_output_dir

procedure is_executable_target#: Binds to: is_executable_target

interface add_target#

subroutine add_new_target(targets, package, type, output_name, source, link_libraries, features, preprocess, version, output_dir)#

Arguments:

type (build_target_ptr), intent(inout), allocatable :: targets
character(len=*), intent(in) :: package
integer, intent(in) :: type
character(len=*), intent(in) :: output_name
type (srcfile_t), intent(in), optional :: source
type (string_t), intent(in), optional :: link_libraries
type (fortran_config_t), intent(in), optional :: features
type (preprocess_config_t), intent(in), optional :: preprocess
type (version_t), intent(in), optional :: version
character(len=*), intent(in), optional :: output_dir

subroutine add_old_target(targets, add_target)#

Arguments:

type (build_target_ptr), intent(inout), allocatable :: targets
type (build_target_ptr), intent(in) :: add_target

subroutine add_old_targets(targets, add_targets)#

Arguments:

type (build_target_ptr), intent(inout), allocatable :: targets
type (build_target_ptr), intent(in) :: add_targets

interface add_target_ptr#

subroutine add_target_ptr_one(list, new)#

Arguments:

type (build_target_ptr), intent(inout), allocatable :: list
type (build_target_ptr), intent(in) :: new

subroutine add_target_ptr_many(list, new)#

Arguments:

type (build_target_ptr), intent(inout), allocatable :: list
type (build_target_ptr), intent(in) :: new

pure function FPM_TARGET_NAME(type)#

Arguments:

integer, intent(in) :: type

Returns: character(len=:), allocatable

function new_target(package, type, output_name, source, link_libraries, features, preprocess, version, output_dir)#

Arguments:

character(len=*), intent(in) :: package
integer, intent(in) :: type
character(len=*), intent(in) :: output_name
type (srcfile_t), intent(in), optional :: source
type (string_t), intent(in), optional :: link_libraries
type (fortran_config_t), intent(in), optional :: features
type (preprocess_config_t), intent(in), optional :: preprocess
type (version_t), intent(in), optional :: version
character(len=*), intent(in), optional :: output_dir

Returns: type (build_target_ptr)

function find_module_dependency(targets, module_name, include_dir)#

Arguments:

type (build_target_ptr), intent(in), target :: targets
character(len=*), intent(in) :: module_name
character(len=*), intent(in), optional :: include_dir

Returns: type (build_target_t), pointer

function get_output_dir(build_prefix, args)#

Arguments:

character(len=*), intent(in) :: build_prefix
character(len=*), intent(in) :: args

Returns: character(len=:), allocatable

elemental function is_executable_target(target_ptr, scope)#

Arguments:

class (build_target_t), intent(in) :: target_ptr
integer, intent(in) :: scope

Returns: logical

function get_feature_flags(compiler, features)#

Arguments:

type (compiler_t), intent(in) :: compiler
type (fortran_config_t), intent(in) :: features

Returns: character(len=:), allocatable

subroutine info(self, unit, verbosity)#

Arguments:

class (build_target_t), intent(in) :: self
integer, intent(in) :: unit
integer, intent(in), optional :: verbosity

subroutine targets_from_sources(targets, model, prune, library, error)#

Arguments:

type (build_target_ptr), intent(out), allocatable :: targets
type (fpm_model_t), intent(inout), target :: model
logical, intent(in) :: prune
type (library_config_t), intent(in), optional :: library
type (error_t), intent(out), allocatable :: error

subroutine build_target_list(targets, model, library)#

Arguments:

type (build_target_ptr), intent(out), allocatable :: targets
type (fpm_model_t), intent(inout), target :: model
type (library_config_t), intent(in), optional :: library

subroutine collect_exe_link_dependencies(targets)#

Arguments:

type (build_target_ptr), intent(inout) :: targets

subroutine add_dependency(target, dependency)#

Arguments:

type (build_target_t), intent(inout) :: target
type (build_target_t), intent(in), target :: dependency

subroutine resolve_module_dependencies(targets, external_modules, error)#

Arguments:

type (build_target_ptr), intent(inout), target :: targets
type (string_t), intent(in) :: external_modules
type (error_t), intent(out), allocatable :: error

subroutine prune_build_targets(targets, root_package, prune_unused_objects)#

Arguments:

type (build_target_ptr), intent(inout), allocatable :: targets
type (package_t), intent(in) :: root_package
logical, intent(in) :: prune_unused_objects

subroutine resolve_target_linking(targets, model, library, error)#

Arguments:

type (build_target_ptr), intent(inout), target :: targets
type (fpm_model_t), intent(in) :: model
type (library_config_t), intent(in), optional :: library
type (error_t), intent(out), allocatable :: error

subroutine add_include_build_dirs(model, targets)#

Arguments:

type (fpm_model_t), intent(in) :: model
type (build_target_ptr), intent(inout), target :: targets

subroutine get_library_dirs(model, targets, shared_lib_dirs)#

Arguments:

type (fpm_model_t), intent(in) :: model
type (build_target_ptr), intent(inout), target :: targets
type (string_t), intent(out), allocatable :: shared_lib_dirs

subroutine add_library_link_dirs(model, targets, shared_lib_path)#

Arguments:

type (fpm_model_t), intent(in) :: model
type (build_target_ptr), intent(inout), target :: targets
character(len=:), intent(out), allocatable :: shared_lib_path

subroutine filter_library_targets(targets, list)#

Arguments:

type (build_target_ptr), intent(in) :: targets
type (build_target_ptr), intent(out), allocatable :: list

subroutine filter_executable_targets(targets, scope, list)#

Arguments:

type (build_target_ptr), intent(in) :: targets
integer, intent(in) :: scope
type (string_t), intent(out), allocatable :: list

subroutine filter_modules(targets, list)#

Arguments:

type (build_target_ptr), intent(in) :: targets
type (string_t), intent(out), allocatable :: list

subroutine set_output_dir(self, output_dir)#

Arguments:

class (build_target_t), intent(inout) :: self
character(len=*), intent(in), optional :: output_dir

subroutine library_targets_to_deps(model, targets, target_ID)#

Arguments:

class (fpm_model_t), intent(in) :: model
type (build_target_ptr), intent(in) :: targets
integer, intent(out), allocatable :: target_ID

module fpm_toml#

Uses: fpm_error, fpm_strings, tomlf, tomlf_de_parser, jonquil, iso_fortran_env

type serializable_t#

procedure dump_to_toml#

procedure dump_to_file#: Binds to: dump_to_file

procedure dump_to_unit#: Binds to: dump_to_unit

procedure dump#: Binds to: dump_to_file, dump_to_unit

procedure load_from_toml#

procedure load_from_file#: Binds to: load_from_file

procedure load_from_unit#: Binds to: load_from_unit

procedure load#: Binds to: load_from_file, load_from_unit

procedure serializable_is_same#

procedure operator(==)#

procedure test_serialization#: Binds to: test_serialization

interface add_table#

subroutine add_table_fpm(table, key, ptr, error, whereAt)#

Arguments:

type (toml_table), intent(inout) :: table
character(len=*), intent(in) :: key
type (toml_table), intent(out), pointer :: ptr
type (error_t), intent(out), allocatable :: error
character(len=*), intent(in), optional :: whereAt

interface set_value#

subroutine set_logical(table, key, var, error, whereAt)#

Arguments:

type (toml_table), intent(inout) :: table
character(len=*), intent(in) :: key
logical, intent(in) :: var
type (error_t), intent(out), allocatable :: error
character(len=*), intent(in), optional :: whereAt

subroutine set_integer(table, key, var, error, whereAt)#

Arguments:

type (toml_table), intent(inout) :: table
character(len=*), intent(in) :: key
integer, intent(in) :: var
type (error_t), intent(out), allocatable :: error
character(len=*), intent(in), optional :: whereAt

subroutine set_integer_64(table, key, var, error, whereAt)#

Arguments:

type (toml_table), intent(inout) :: table
character(len=*), intent(in) :: key
integer (int64), intent(in) :: var
type (error_t), intent(out), allocatable :: error
character(len=*), intent(in), optional :: whereAt

interface set_string#

subroutine set_character(table, key, var, error, whereAt)#

Arguments:

type (toml_table), intent(inout) :: table
character(len=*), intent(in) :: key
character(len=*), intent(in), optional :: var
type (error_t), intent(out), allocatable :: error
character(len=*), intent(in), optional :: whereAt

subroutine set_string_type(table, key, var, error, whereAt)#

Arguments:

type (toml_table), intent(inout) :: table
character(len=*), intent(in) :: key
type (string_t), intent(in) :: var
type (error_t), intent(out), allocatable :: error
character(len=*), intent(in), optional :: whereAt

interface get_value#

subroutine get_logical(table, key, var, error, whereAt)#

Arguments:

type (toml_table), intent(inout) :: table
character(len=*), intent(in) :: key
logical, intent(inout) :: var
type (error_t), intent(out), allocatable :: error
character(len=*), intent(in), optional :: whereAt

subroutine get_integer(table, key, var, error, whereAt)#

Arguments:

type (toml_table), intent(inout) :: table
character(len=*), intent(in) :: key
integer, intent(inout) :: var
type (error_t), intent(out), allocatable :: error
character(len=*), intent(in), optional :: whereAt

subroutine get_integer_64(table, key, var, error, whereAt)#

Arguments:

type (toml_table), intent(inout) :: table
character(len=*), intent(in) :: key
integer (int64), intent(inout) :: var
type (error_t), intent(out), allocatable :: error
character(len=*), intent(in), optional :: whereAt

subroutine get_char(table, key, var, error, whereAt)#

Arguments:

type (toml_table), intent(inout) :: table
character(len=*), intent(in) :: key
character(len=:), intent(inout), allocatable :: var
type (error_t), intent(out), allocatable :: error
character(len=*), intent(in), optional :: whereAt

subroutine get_string(table, key, var, error, whereAt)#

Arguments:

type (toml_table), intent(inout) :: table
character(len=*), intent(in) :: key
type (string_t), intent(inout) :: var
type (error_t), intent(out), allocatable :: error
character(len=*), intent(in), optional :: whereAt

function has_list(table, key)#

Arguments:

type (toml_table), intent(inout) :: table
character(len=*), intent(in) :: key

Returns: logical

function name_is_json(filename)#

Arguments:

character(len=*), intent(in) :: filename

Returns: logical

subroutine test_serialization(self, message, error)#

Arguments:

class (serializable_t), intent(inout) :: self
character(len=*), intent(in) :: message
type (error_t), intent(out), allocatable :: error

subroutine dump_to_unit(self, unit, error, json)#

Arguments:

class (serializable_t), intent(inout) :: self
integer, intent(in) :: unit
type (error_t), intent(out), allocatable :: error
logical, intent(in), optional :: json

subroutine dump_to_file(self, file, error, json)#

Arguments:

class (serializable_t), intent(inout) :: self
character(len=*), intent(in) :: file
type (error_t), intent(out), allocatable :: error
logical, intent(in), optional :: json

subroutine load_from_file(self, file, error, json)#

Arguments:

class (serializable_t), intent(inout) :: self
character(len=*), intent(in) :: file
type (error_t), intent(out), allocatable :: error
logical, intent(in), optional :: json

subroutine load_from_unit(self, unit, error, json)#

Arguments:

class (serializable_t), intent(inout) :: self
integer, intent(in) :: unit
type (error_t), intent(out), allocatable :: error
logical, intent(in), optional :: json

subroutine read_package_file(table, manifest, error)#

Arguments:

type (toml_table), intent(out), allocatable :: table
character(len=*), intent(in) :: manifest
type (error_t), intent(out), allocatable :: error

subroutine get_list(table, key, list, error)#

Arguments:

type (toml_table), intent(inout) :: table
character(len=*), intent(in) :: key
type (string_t), intent(out), allocatable :: list
type (error_t), intent(out), allocatable :: error

subroutine set_list(table, key, list, error)#

Arguments:

type (toml_table), intent(inout) :: table
character(len=*), intent(in) :: key
type (string_t), intent(in), allocatable :: list
type (error_t), intent(out), allocatable :: error

subroutine check_keys(table, valid_keys, error)#

Arguments:

type (toml_table), intent(inout) :: table
character(len=*), intent(in) :: valid_keys
type (error_t), intent(out), allocatable :: error

module fpm_versioning#

Uses: fpm_error, fpm_strings, regex_module

parameter max_limit = 3#: Type: integer

type version_t#

member num#: Type: integer, allocatable

procedure operator(==)#: Binds to: equals

procedure equals#: Binds to: equals

procedure operator(/=)#: Binds to: not_equals

procedure not_equals#: Binds to: not_equals

procedure operator(>)#: Binds to: greater

procedure greater#: Binds to: greater

procedure operator(<)#: Binds to: less

procedure less#: Binds to: less

procedure operator(>=)#: Binds to: greater_equals

procedure greater_equals#: Binds to: greater_equals

procedure operator(<=)#: Binds to: less_equals

procedure less_equals#: Binds to: less_equals

procedure operator(.match.)#: Binds to: match

procedure match#: Binds to: match

procedure s#: Binds to: s

interface new_version#

subroutine new_version_from_string(self, string, error)#

Arguments:

type (version_t), intent(out) :: self
character(len=*), intent(in) :: string
type (error_t), intent(out), allocatable :: error

subroutine new_version_from_int(self, num)#

Arguments:

type (version_t), intent(out) :: self
integer, intent(in) :: num

pure function s(self)#

Arguments:

class (version_t), intent(in) :: self

Returns: character(len=:), allocatable

elemental function equals(lhs, rhs)#

Arguments:

class (version_t), intent(in) :: lhs
class (version_t), intent(in) :: rhs

Returns: logical

elemental function not_equals(lhs, rhs)#

Arguments:

class (version_t), intent(in) :: lhs
class (version_t), intent(in) :: rhs

Returns: logical

elemental function greater(lhs, rhs)#

Arguments:

class (version_t), intent(in) :: lhs
class (version_t), intent(in) :: rhs

Returns: logical

elemental function less(lhs, rhs)#

Arguments:

class (version_t), intent(in) :: lhs
class (version_t), intent(in) :: rhs

Returns: logical

elemental function greater_equals(lhs, rhs)#

Arguments:

class (version_t), intent(in) :: lhs
class (version_t), intent(in) :: rhs

Returns: logical

elemental function less_equals(lhs, rhs)#

Arguments:

class (version_t), intent(in) :: lhs
class (version_t), intent(in) :: rhs

Returns: logical

elemental function match(lhs, rhs)#

Arguments:

class (version_t), intent(in) :: lhs
class (version_t), intent(in) :: rhs

Returns: logical

elemental function ndigits(self)#

Arguments:

class (version_t), intent(in) :: self

Returns: integer

function regex_version_from_text(text, what, error)#

Arguments:

character(len=*), intent(in) :: text
character(len=*), intent(in) :: what
type (error_t), intent(out), allocatable :: error

Returns: type (string_t)

subroutine next(string, istart, iend, is_number, error)#

Arguments:

character(len=*), intent(in) :: string
integer, intent(inout) :: istart
integer, intent(inout) :: iend
logical, intent(inout) :: is_number
type (error_t), intent(out), allocatable :: error

subroutine token_error(error, string, istart, iend, message)#

Arguments:

type (error_t), intent(out), allocatable :: error
character(len=*), intent(in) :: string
integer, intent(in) :: istart
integer, intent(in) :: iend
character(len=*), intent(in) :: message

Fortran Package Manager (fpm)

Contents

Fortran Package Manager (fpm)#