compiler_t Derived Type

type, public, extends(serializable_t) :: compiler_t

Definition of compiler object


Components

Type Visibility Attributes Name Initial
character(len=:), public, allocatable :: cc

Path to the C compiler
character(len=:), public, allocatable :: cxx

Path to the C++ compiler
logical, public :: echo = .true.

Print all commands
character(len=:), public, allocatable :: fc

Path to the Fortran compiler
integer(kind=compiler_enum), public :: id = id_unknown

Identifier of the compiler
logical, public :: verbose = .true.

Verbose output of command

Type-Bound Procedures

procedure, public :: check_c_flags_supported

  • public function check_c_flags_supported(self, compile_flags, link_flags)

    Check if the given C compile and/or link flags are accepted by the C compiler

    Arguments

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

    Return Value logical

procedure, public :: check_c_source_runs

C feature support

  • public function check_c_source_runs(self, input, compile_flags, link_flags) result(success)

    Check if the given C source code compiles, links, and runs successfully Create temporary source file Write contents Get flags Compile Link using C compiler for pure C programs Run Delete temporary files

    Arguments

    Type IntentOptional Attributes Name
    class(compiler_t), intent(in) :: self

    Instance of the compiler object
    character(len=*), intent(in) :: input

    C program source
    character(len=*), intent(in), optional :: compile_flags

    Optional build and link flags
    character(len=*), intent(in), optional :: link_flags

    Optional build and link flags

    Return Value logical

procedure, public :: check_cxx_flags_supported

  • public function check_cxx_flags_supported(self, compile_flags, link_flags)

    Check if the given C++ compile and/or link flags are accepted by the C++ compiler

    Arguments

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

    Return Value logical

procedure, public :: check_cxx_source_runs

C++ feature support

  • public function check_cxx_source_runs(self, input, compile_flags, link_flags) result(success)

    Check if the given C++ source code compiles, links, and runs successfully Create temporary source file Write contents Get flags Compile Link using C++ compiler for pure C++ programs Run Delete temporary files

    Arguments

    Type IntentOptional Attributes Name
    class(compiler_t), intent(in) :: self

    Instance of the compiler object
    character(len=*), intent(in) :: input

    C++ program source
    character(len=*), intent(in), optional :: compile_flags

    Optional build and link flags
    character(len=*), intent(in), optional :: link_flags

    Optional build and link flags

    Return Value logical

procedure, public :: check_flags_supported

  • public function check_flags_supported(self, compile_flags, link_flags)

    Check if the given compile and/or link flags are accepted by the compiler

    Arguments

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

    Return Value logical

procedure, public :: check_fortran_source_runs

Fortran feature support

  • public function check_fortran_source_runs(self, input, compile_flags, link_flags) result(success)

    Run a single-source Fortran program using the current compiler Compile a Fortran object Create temporary source file Write contents Get flags Intel: Needs -warn last for error on unknown command line arguments to work Compile and link program Run and retrieve exit code

    Read more…

    Arguments

    Type IntentOptional Attributes Name
    class(compiler_t), intent(in) :: self

    Instance of the compiler object
    character(len=*), intent(in) :: input

    Program Source
    character(len=*), intent(in), optional :: compile_flags

    Optional build and link flags
    character(len=*), intent(in), optional :: link_flags

    Optional build and link flags

    Return Value logical

procedure, public :: compile_c

Compile a C object

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

    Compile a C object

    Arguments

    Type IntentOptional Attributes Name
    class(compiler_t), intent(in) :: self

    Instance of the compiler object
    character(len=*), intent(in) :: input

    Source file input
    character(len=*), intent(in) :: output

    Output file of object
    character(len=*), intent(in) :: args

    Arguments for compiler
    character(len=*), intent(in) :: log_file

    Compiler output log file
    integer, intent(out) :: stat

    Status flag
    type(compile_command_table_t), intent(inout), optional :: table

    Optional compile_commands table
    logical, intent(in), optional :: dry_run

    Optional mocking

procedure, public :: compile_cpp

Compile a CPP object

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

    Compile a CPP object

    Arguments

    Type IntentOptional Attributes Name
    class(compiler_t), intent(in) :: self

    Instance of the compiler object
    character(len=*), intent(in) :: input

    Source file input
    character(len=*), intent(in) :: output

    Output file of object
    character(len=*), intent(in) :: args

    Arguments for compiler
    character(len=*), intent(in) :: log_file

    Compiler output log file
    integer, intent(out) :: stat

    Status flag
    type(compile_command_table_t), intent(inout), optional :: table

    Optional compile_commands table
    logical, intent(in), optional :: dry_run

    Optional mocking

procedure, public :: compile_fortran

Compile a Fortran object

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

    Compile a Fortran object

    Arguments

    Type IntentOptional Attributes Name
    class(compiler_t), intent(in) :: self

    Instance of the compiler object
    character(len=*), intent(in) :: input

    Source file input
    character(len=*), intent(in) :: output

    Output file of object
    character(len=*), intent(in) :: args

    Arguments for compiler
    character(len=*), intent(in) :: log_file

    Compiler output log file
    integer, intent(out) :: stat

    Status flag
    type(compile_command_table_t), intent(inout), optional :: table

    Optional compile_commands table
    logical, intent(in), optional :: dry_run

    Optional mocking

generic, public :: dump => dump_to_toml, dump_to_file, dump_to_unit

  • private subroutine srcfile_dump_to_toml(self, table, error)

    Dump dependency to toml table

    Arguments

    Type IntentOptional Attributes Name
    class(srcfile_t), intent(inout) :: self

    Instance of the serializable object
    type(toml_table), intent(inout) :: table

    Data structure
    type(error_t), intent(out), allocatable :: error

    Error handling

  • private subroutine dump_to_file(self, file, error, json)

    Write serializable object to file

    Arguments

    Type IntentOptional Attributes Name
    class(serializable_t), intent(inout) :: self

    Instance of the dependency tree
    character(len=*), intent(in) :: file

    File name
    type(error_t), intent(out), allocatable :: error

    Error handling
    logical, intent(in), optional :: json

    Optional JSON format

  • private subroutine dump_to_unit(self, unit, error, json)

    Write serializable object to a formatted Fortran unit

    Arguments

    Type IntentOptional Attributes Name
    class(serializable_t), intent(inout) :: self

    Instance of the dependency tree
    integer, intent(in) :: unit

    Formatted unit
    type(error_t), intent(out), allocatable :: error

    Error handling
    logical, intent(in), optional :: json

    Optional JSON format requested?

procedure, public :: dump_to_toml => compiler_dump

  • public subroutine compiler_dump(self, table, error)

    Dump dependency to toml table

    Arguments

    Type IntentOptional Attributes Name
    class(compiler_t), intent(inout) :: self

    Instance of the serializable object
    type(toml_table), intent(inout) :: table

    Data structure
    type(error_t), intent(out), allocatable :: error

    Error handling

procedure, public :: enumerate_libraries

Enumerate libraries, based on compiler and platform

  • public function enumerate_libraries(self, prefix, libs) result(r)

    Enumerate libraries, based on compiler and platform

    Arguments

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

    Return Value character(len=:), allocatable

procedure, public :: get_default_flags

Get default compiler flags

  • public function get_default_flags(self, release) result(flags)

    Arguments

    Type IntentOptional Attributes Name
    class(compiler_t), intent(in) :: self
    logical, intent(in) :: release

    Return Value character(len=:), allocatable

procedure, public :: get_export_flags

Get library export flags

  • public function get_export_flags(self, target_dir, target_name) result(export_flags)

    Generate library export flags for a shared library build

    Arguments

    Type IntentOptional Attributes Name
    class(compiler_t), intent(in) :: self

    Instance of the compiler
    character(len=*), intent(in) :: target_dir

    Path and package name
    character(len=*), intent(in) :: target_name

    Path and package name

    Return Value character(len=:), allocatable

procedure, public :: get_feature_flag

Get feature flag

  • public function get_feature_flag(self, feature) result(flags)

    Arguments

    Type IntentOptional Attributes Name
    class(compiler_t), intent(in) :: self
    character(len=*), intent(in) :: feature

    Return Value character(len=:), allocatable

procedure, public :: get_headerpad_flags

Generate header padding flags for macOS executables

  • public function get_headerpad_flags(self) result(flags)

    Generate header padding flags for install_name_tool compatibility on macOS

    Arguments

    Type IntentOptional Attributes Name
    class(compiler_t), intent(in) :: self

    Return Value character(len=:), allocatable

procedure, public :: get_include_flag

Get flag for include directories

  • public function get_include_flag(self, path) result(flags)

    Arguments

    Type IntentOptional Attributes Name
    class(compiler_t), intent(in) :: self
    character(len=*), intent(in) :: path

    Return Value character(len=:), allocatable

procedure, public :: get_install_name_flags

Get library install name flags

  • public function get_install_name_flags(self, target_dir, target_name) result(flags)

    Generate install_name flag for a shared library build on macOS

    Arguments

    Type IntentOptional Attributes Name
    class(compiler_t), intent(in) :: self
    character(len=*), intent(in) :: target_dir
    character(len=*), intent(in) :: target_name

    Return Value character(len=:), allocatable

procedure, public :: get_main_flags

Get flags for the main linking command

  • public subroutine get_main_flags(self, language, flags)

    Get special flags for the main linker

    Arguments

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

procedure, public :: get_module_flag

Get flag for module output directories

  • public function get_module_flag(self, path) result(flags)

    Arguments

    Type IntentOptional Attributes Name
    class(compiler_t), intent(in) :: self
    character(len=*), intent(in) :: path

    Return Value character(len=:), allocatable

procedure, public :: is_gnu

Check whether this is a GNU compiler

  • public pure function is_gnu(self)

    Arguments

    Type IntentOptional Attributes Name
    class(compiler_t), intent(in) :: self

    Return Value logical

procedure, public :: is_intel

Check whether this is an Intel compiler

  • public pure function is_intel(self)

    Arguments

    Type IntentOptional Attributes Name
    class(compiler_t), intent(in) :: self

    Return Value logical

procedure, public :: is_unknown

Check whether compiler is recognized

  • public pure function is_unknown(self)

    Arguments

    Type IntentOptional Attributes Name
    class(compiler_t), intent(in) :: self

    Return Value logical

procedure, public :: link => link_executable

Link executable

  • public subroutine link_executable(self, output, args, log_file, stat, dry_run)

    Link an executable

    Arguments

    Type IntentOptional Attributes Name
    class(compiler_t), intent(in) :: self

    Instance of the compiler object
    character(len=*), intent(in) :: output

    Output file of object
    character(len=*), intent(in) :: args

    Arguments for compiler
    character(len=*), intent(in) :: log_file

    Compiler output log file
    integer, intent(out) :: stat

    Status flag
    logical, intent(in), optional :: dry_run

    Optional mocking

procedure, public :: link_shared

Link a shared library

  • public subroutine link_shared(self, output, args, log_file, stat, dry_run)

    Link a shared library

    Arguments

    Type IntentOptional Attributes Name
    class(compiler_t), intent(in) :: self

    Instance of the compiler object
    character(len=*), intent(in) :: output

    Output file of shared library object
    character(len=*), intent(in) :: args

    Arguments for the compiler
    character(len=*), intent(in) :: log_file

    Compiler output log file
    integer, intent(out) :: stat

    Status flag
    logical, intent(in), optional :: dry_run

    Optional mocking

generic, public :: load => load_from_toml, load_from_file, load_from_unit

  • private subroutine srcfile_load_from_toml(self, table, error)

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

    Arguments

    Type IntentOptional Attributes Name
    class(srcfile_t), intent(inout) :: self

    Instance of the serializable object
    type(toml_table), intent(inout) :: table

    Data structure
    type(error_t), intent(out), allocatable :: error

    Error handling

  • private subroutine load_from_file(self, file, error, json)

    Read dependency tree from file

    Arguments

    Type IntentOptional Attributes Name
    class(serializable_t), intent(inout) :: self

    Instance of the dependency tree
    character(len=*), intent(in) :: file

    File name
    type(error_t), intent(out), allocatable :: error

    Error handling
    logical, intent(in), optional :: json

    Optional JSON format

  • private subroutine load_from_unit(self, unit, error, json)

    Read dependency tree from file init JSON interpreter Read object from TOML table

    use default TOML parser

    Read object from TOML table

    Arguments

    Type IntentOptional Attributes Name
    class(serializable_t), intent(inout) :: self

    Instance of the dependency tree
    integer, intent(in) :: unit

    File name
    type(error_t), intent(out), allocatable :: error

    Error handling
    logical, intent(in), optional :: json

    Optional JSON format

procedure, public :: load_from_toml => compiler_load

  • public subroutine compiler_load(self, table, error)

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

    Arguments

    Type IntentOptional Attributes Name
    class(compiler_t), intent(inout) :: self

    Instance of the serializable object
    type(toml_table), intent(inout) :: table

    Data structure
    type(error_t), intent(out), allocatable :: error

    Error handling

procedure, public :: name => compiler_name

Return compiler name

  • public pure function compiler_name(self) result(name)

    Return a compiler name string

    Arguments

    Type IntentOptional Attributes Name
    class(compiler_t), intent(in) :: self

    Instance of the compiler object

    Return Value character(len=:), allocatable

    Representation as string

generic, public :: operator(==) => serializable_is_same

  • private function srcfile_is_same(this, that)

    Check that two source files are equal All checks passed!

    Arguments

    Type IntentOptional Attributes Name
    class(srcfile_t), intent(in) :: this
    class(serializable_t), intent(in) :: that

    Return Value logical

procedure, public :: serializable_is_same => compiler_is_same

Serialization interface

  • public function compiler_is_same(this, that)

    Check that two compiler_t objects are equal All checks passed!

    Arguments

    Type IntentOptional Attributes Name
    class(compiler_t), intent(in) :: this
    class(serializable_t), intent(in) :: that

    Return Value logical

procedure, public, non_overridable :: test_serialization

Test load/write roundtrip

  • private subroutine test_serialization(self, message, error)

    Test serialization of a serializable object Dump to scratch file Load from scratch file Check same

    Arguments

    Type IntentOptional Attributes Name
    class(serializable_t), intent(inout) :: self
    character(len=*), intent(in) :: message
    type(error_t), intent(out), allocatable :: error

procedure, public :: with_qp

  • public function with_qp(self)

    Check if the current compiler supports 128-bit real precision

    Arguments

    Type IntentOptional Attributes Name
    class(compiler_t), intent(in) :: self

    Instance of the compiler object

    Return Value logical

procedure, public :: with_xdp

  • public function with_xdp(self)

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

    Arguments

    Type IntentOptional Attributes Name
    class(compiler_t), intent(in) :: self

    Instance of the compiler object

    Return Value logical

Source Code

type, extends(serializable_t) :: compiler_t
    !> Identifier of the compiler
    integer(compiler_enum) :: id = id_unknown
    !> Path to the Fortran compiler
    character(len=:), allocatable :: fc
    !> Path to the C compiler
    character(len=:), allocatable :: cc
    !> Path to the C++ compiler
    character(len=:), allocatable :: cxx
    !> Print all commands
    logical :: echo = .true.
    !> Verbose output of command
    logical :: verbose = .true.
contains
    !> Get default compiler flags
    procedure :: get_default_flags
    !> Get flag for module output directories
    procedure :: get_module_flag
    !> Get flag for include directories
    procedure :: get_include_flag
    !> Get feature flag
    procedure :: get_feature_flag
    !> Get flags for the main linking command
    procedure :: get_main_flags
    !> Get library export flags
    procedure :: get_export_flags    
    !> Get library install name flags
    procedure :: get_install_name_flags
    !> Generate header padding flags for macOS executables
    procedure :: get_headerpad_flags
    !> Compile a Fortran object
    procedure :: compile_fortran
    !> Compile a C object
    procedure :: compile_c
    !> Compile a CPP object
    procedure :: compile_cpp
    !> Link a shared library
    procedure :: link_shared
    !> Link executable
    procedure :: link => link_executable
    !> Check whether compiler is recognized
    procedure :: is_unknown
    !> Check whether this is an Intel compiler
    procedure :: is_intel
    !> Check whether this is a GNU compiler
    procedure :: is_gnu
    !> Enumerate libraries, based on compiler and platform
    procedure :: enumerate_libraries


    !> Serialization interface
    procedure :: serializable_is_same => compiler_is_same
    procedure :: dump_to_toml => compiler_dump
    procedure :: load_from_toml => compiler_load
    !> Fortran feature support
    procedure :: check_fortran_source_runs
    procedure :: check_flags_supported
    procedure :: with_xdp
    procedure :: with_qp
    !> C feature support
    procedure :: check_c_source_runs
    procedure :: check_c_flags_supported
    !> C++ feature support
    procedure :: check_cxx_source_runs
    procedure :: check_cxx_flags_supported
    !> Return compiler name
    procedure :: name => compiler_name

end type compiler_t