Procedures

Add pointer to dependeny in target%dependencies

Add to sources using the executable and test entries in the manifest and applies any executable-specific overrides such as executable%name. Adds all sources (including modules) from each executable%source_dir Compare lowercase strings to allow auto-discovery of pre-processed extensions

Add to sources by looking for source files in directory

add_table: fpm interface

Allocate a new target and append to target list

Check that two archiver_t objects are equal All checks passed!

Check whether pkg-config is available on the local system

Extract filename from path with/without suffix

Constructs a valid fpm model from command line settings and the toml manifest. Add this dependency’s manifest macros

Top-level routine to build package described by model

Constructor for build_progress_t

Canonicalize path for comparison * Handles path string redundancies * Does not test existence of path

Run a single-source Fortran program using the current compiler Compile a Fortran object Create temporary source file Write contents Compile and link program Run and retrieve exit code

Check if table contains only keys that are part of the list. If a key is found that is not part of the list, an error is allocated.

Dump model to file

Delete the build directory including or excluding dependencies. Can be used to clear the registry cache.

Entry point for the export subcommand Read in manifest Export manifest Export dependency tree

Entry point for the fpm-install subcommand

TOP DIRECTORY NAME PROCESSING see if requested new directory already exists and process appropriately temporarily change to new directory as a test. NB: System dependent

The publish command first builds the root package to obtain all the relevant information such as the package version. It then creates a tarball of the package and uploads it to the registry. Checks before uploading the package.

Entry point for the update subcommand

Compile a C object

Compile a CPP object

Compile a Fortran object

Dump dependency to toml table

Check that two compiler_t objects are equal All checks passed!

Read dependency from toml table (no checks made at this stage)

Return a compiler name string

Converts a path to an absolute, canonical path.

Create debug printout

String representation of an archiver object

String representation of a compiler object

Populate test in case we find the default example/ directory

Populate executable in case we find the default app directory

Populate library in case we find the default src directory

Populate test in case we find the default test/ directory

Deletes an environment variable for the current environment using the C standard library Returns an error if the variable did not exist in the first place

delete a file by filename

Clean memory

Code git descriptor to a string

Destructor

Sample program:

Extract dirname from path

Dump dependency to toml table

Dump dependency to toml table

Enumerate libraries, based on compiler and platform

Execute command line and return output as a string.

test if pathname already exists

return Fortran character variable when given a C-like array of single characters terminated with a C_NULL_CHAR character

Generic fatal runtime error

Error created when a file is missing or not found

Error created when file parsing fails

Dump to toml table

Read from toml table (no checks made at this stage)

All checks passed!

simple close of a LUN. On error show message and stop (by default)

procedure to open filename as a sequential “text” file

procedure to write filedata to file filename

Look for profile with given configuration in array profiles

Return the character name of a scope flag

Target type name

Return the character name of a unit flag

Return the current fpm version from fpm_version_ID as a version type

Determine the canonical, absolute path for the given path. Expands home folder (~) on both Unix and Windows.

Alternative to get_absolute_path that uses chdir/_chdir to determine the absolute path.

! canon_path is not converting “.”, etc. & ‘ unknown help topic “’//trim(unnamed(i)).’not found in:’,manual]

Get C++ Compiler.

Construct an array of built-in profiles

Ensure a windows path is converted to an 8.3 DOS path if it contains spaces No need to convert if there are no spaces

get named environment variable value. It it is blank or not set return the optional default value !print , NAME, ” is not defined in the environment. Strange…” !print , “This processor doesn’t support environment variables. Boooh!”

Build an executable name with suffix. Safe routine that always returns an allocated string

Look for flags, c-flags, link-time-flags key-val pairs and files table in a given table and create new profiles

Get an environment variable for fpm, this routine ensures that every variable used by fpm is prefixed with FPM_.

Obtain global settings from the global config file.

Get the HOME directory on Unix and the %USERPROFILE% directory on Windows.

Determine the path prefix to the local folder. Used for installation, registry etc.

This function will parse and read the macros list and return them as defined flags. Set macro defintion symbol on the basis of compiler used Check if macros are not allocated. Split the macro name and value.

Get special flags for the main linker

Determine the OS type

Obtain package meta data from a configuation file

Read registry settings from the global config file.

Get a unused temporary filename Calls posix ‘tempnam’ - not recommended, but we have no security concerns for this application and use here is temporary. Works with MinGW

get_value: fpm interface

Save access to working directory in settings, in case setting have not been allocated

subroutine getline(unit,line,iostat,iomsg)

Archive a folder using git archive.

Check that two git targets are equal All checks passed!

Check that a cached dependency matches a manifest request

Target a branch in the git repository

Default target

Target a specific git revision

Target a git tag

glob(3f) compares given STRING for match to PATTERN which may contain wildcard characters.

Check if an instance of the TOML data structure contains a list

Check that a module name is prefixed with a custom prefix: 1) It must be a valid FORTRAN name subset (<=63 chars, begin with letter, only alphanumeric allowed) 2) It must begin with the prefix 3) If longer, package name must be followed by default separator (“_”) plus at least one char

Check that a module name is prefixed with the default package prefix: 1) It must be a valid FORTRAN name (<=63 chars, begin with letter, “_” is only allowed non-alphanumeric) 2) It must begin with the package name 3) If longer, package name must be followed by default separator plus at least one char

Show information on git target

Write information on instance

Print a representation of profile_config_t

Returns .true. if provided path is absolute.

test if a name matches an existing directory path

test if a file is hidden

Check local schema for allowed entries

Check that a module name fits the current naming rules: 1) It must be a valid FORTRAN name (<=63 chars, begin with letter, “_” is only allowed non-alphanumeric) 2) It must begin with the package name 3) If longer, package name must be followed by default separator plus at least one char

Check that a custom module prefix fits the current naming rules: 1) Only alphanumeric characters (no spaces, dashes, underscores or other characters) 2) Does not begin with a number (Fortran-compatible syntax)

JOIN(3f) appends the elements of a CHARACTER array into a single CHARACTER variable, with elements 1 to N joined from left to right. By default each element is trimmed of trailing spaces and the default separator is a null string.

Construct path by joining strings with os file separator

Link an executable

Get file & directory names in directory dir using iso_c_binding.

Read dependency from toml table (no checks made at this stage)

Read dependency from toml table (no checks made at this stage)

Changes a string to lowercase over optional specified column range

Create an archive

Check if two dependency configurations are different

Match os_type enum to a lowercase string with name of OS

Create a directory. Create subdirectories as needed

Return a name for the MPI library

Choose between JSON or TOML based on a file name

Create new archiver instance

Construct a new build configuration from a TOML data structure

Create new compiler instance

Construct new dependency array from a TOML data structure

Construct a new dependency configuration from a TOML data structure

Create a new dependency node from a configuration

Create a new dependency tree

Construct a new example configuration from a TOML data structure

Construct a new executable configuration from a TOML data structure

Construct a new build configuration from a TOML data structure

Create a new installation configuration from a TOML data structure

Create a new instance of an installer

Construct a new library configuration from a TOML data structure

Construct a new build configuration from a TOML data structure

Construct a new metapackage request from the dependencies table

Construct a new package configuration from a TOML data structure

Construct a new preprocess configuration from TOML data structure

Construct new preprocess array from a TOML data structure.

Construct a new profile configuration from a TOML data structure

Construct new profiles array from a TOML data structure

Construct a new test configuration from a TOML data structure

notabs(3f) - [fpm_strings:NONALPHA] expand tab characters (LICENSE:PD)

Determine number or rows in a file given a LUN

Delete directory using system OS remove directory commands

Compare the output of get_os_type or the optional passed INTEGER value to the value for OS_WINDOWS and return .TRUE. if they match and .FALSE. otherwise

Return string describing the OS type flag

Match lowercase string with name of OS to os_type enum

Extract dirname from path

Parsing of c, cpp source files

Parse git descriptor identifier from a string

Parsing of free-form fortran source files

Get build flags (option to include flags from system directories, that gfortran does not look into by default)

Get package libraries from pkg-config

Get package version from pkg-config

Check if pkgcfg has package

Return whole list of available pkg-cfg packages

Dump to toml table

Read from toml table (no checks made at this stage)

All checks passed!

read lines into an array of TYPE(STRING_T) variables

read lines into an array of TYPE(STRING_T) variables expanding tabs

Process the configuration file to a TOML data structure

Returns string with characters in charset replaced with target_char.

Overloaded reallocation interface

Add dependencies to source-based targets (FPM_TARGET_OBJECT) based on any modules used by the corresponding source file.

Execute the specified system command. Optionally

Simple call to execute_command_line involving one mpi* wrapper

Construct a build schedule from the sorted targets.

sample usage

Modify the flag_cpp_preprocessor on the basis of the compiler.

Set an environment variable for the current environment using the C standard library

Set no key if array is not present

set_value: fpm interface

Topologically sort a target for scheduling by recursing over its dependencies.

parse string on delimiter characters and store tokens into an allocatable array given a line of structure ” par1 par2 par3 … parn ” store each par(n) into a separate variable in array.

test if a CHARACTER string begins with a specified prefix

Check if array of TYPE(STRING_T) matches a particular CHARACTER string

Concatenate an array of type(string_t) into a single CHARACTER variable

High-level wrapper to generate build target information

Returns string with special characters replaced with an underscore. For now, only a hyphen is treated as a special character, but this can be expanded to other characters if needed.

Traverse compiler tables

Traverse operating system tables to obtain profiles

Traverse operating system tables to obtain number of profiles

Replace file system separators for unix

Check if compiler name is a valid compiler name

Check if os_name is a valid name of a supported OS

write trimmed character data to a file if it does not exist

function which(command) result(pathname)

Replace file system separators for windows

Check if the current compiler supports 128-bit real precision

Check if the current compiler supports 80-bit “extended” real precision

Response files allow to read command line options from files. Whitespace is used to separate the arguments, we will use newlines as separator to create readable response files which can be inspected in case of errors.