Move default flags fetching and build name generation to model

Author: awvwgk

src/fpm.f90

@@ -1,5 +1,5 @@
 module fpm
-use fpm_strings, only: string_t, operator(.in.), glob, join, string_cat
+use fpm_strings, only: string_t, operator(.in.), glob, join, string_cat, fnv_1a
 use fpm_backend, only: build_package
 use fpm_command_line, only: fpm_build_settings, fpm_new_settings, &
                       fpm_run_settings, fpm_install_settings, fpm_test_settings
@@ -9,8 +9,7 @@ module fpm
 use fpm_model, only: fpm_model_t, srcfile_t, show_model, &
                     FPM_SCOPE_UNKNOWN, FPM_SCOPE_LIB, FPM_SCOPE_DEP, &
                     FPM_SCOPE_APP, FPM_SCOPE_EXAMPLE, FPM_SCOPE_TEST
-use fpm_compiler, only: get_module_flags, is_unknown_compiler, get_default_c_compiler, &
-                        archiver_t
+use fpm_compiler, only: compiler_t, archiver_t
 
 
 use fpm_sources, only: add_executable_sources, add_sources_from_dir
@@ -43,10 +42,11 @@ subroutine build_model(model, settings, package, error)
 
     integer :: i, j
     type(package_config_t) :: dependency
-    character(len=:), allocatable :: manifest, lib_dir
+    character(len=:), allocatable :: manifest, lib_dir, flags
 
     logical :: duplicates_found = .false.
     type(string_t) :: include_dir
+    character(len=16) :: build_name
 
     model%package_name = package%name
 
@@ -58,27 +58,29 @@ subroutine build_model(model, settings, package, error)
     call model%deps%add(package, error)
     if (allocated(error)) return
 
-    if(settings%compiler.eq.'')then
-        model%compiler%fc = "gfortran"
+    model%compiler = compiler_t(settings%compiler)
+    model%archiver = archiver_t()
+
+    if (settings%flag == '') then
+        flags = model%compiler%get_default_flags(settings%profile == "release")
     else
-        model%compiler%fc = settings%compiler
-    endif
+        select case(settings%profile)
+        case("release", "debug")
+            flags = settings%flag // model%compiler%get_default_flags(settings%profile == "release")
+        end select
+    end if
 
-    model%archiver = archiver_t()
-    call get_default_c_compiler(model%compiler%fc, model%compiler%cc)
-    model%compiler%cc = get_env('FPM_C_COMPILER',model%compiler%cc)
+    write(build_name, '(z16.16)') fnv_1a(flags)
 
-    if (is_unknown_compiler(model%compiler%fc)) then
+    if (model%compiler%is_unknown()) then
         write(*, '(*(a:,1x))') &
             "<WARN>", "Unknown compiler", model%compiler%fc, "requested!", &
             "Defaults for this compiler might be incorrect"
     end if
-    model%output_directory = join_path('build',basename(model%compiler%fc)//'_'//settings%build_name)
+    model%output_directory = join_path('build',basename(model%compiler%fc)//'_'//build_name)
 
-    call get_module_flags(model%compiler%fc, &
-        & join_path(model%output_directory,model%package_name), &
-        & model%fortran_compile_flags)
-    model%fortran_compile_flags = settings%flag // model%fortran_compile_flags
+    model%fortran_compile_flags = flags // " " // &
+        & model%compiler%get_module_flag(join_path(model%output_directory, model%package_name))
 
     allocate(model%packages(model%deps%ndep))
 
@@ -186,7 +188,7 @@ subroutine build_model(model, settings, package, error)
     if (allocated(error)) return
 
     if (settings%verbose) then
-        write(*,*)'<INFO> BUILD_NAME: ',settings%build_name
+        write(*,*)'<INFO> BUILD_NAME: ',build_name
         write(*,*)'<INFO> COMPILER:  ',model%compiler%fc
         write(*,*)'<INFO> C COMPILER:  ',model%compiler%cc
         write(*,*)'<INFO> COMPILER OPTIONS:  ', model%fortran_compile_flags

src/fpm_command_line.f90

@@ -31,7 +31,6 @@ module fpm_command_line
 use fpm_strings,      only : lower, split, fnv_1a, to_fortran_name, is_fortran_name
 use fpm_filesystem,   only : basename, canon_path, which
 use fpm_environment,  only : run, get_command_arguments_quoted
-use fpm_compiler,     only : get_default_compile_flags
 use fpm_error,        only : fpm_stop
 use,intrinsic :: iso_fortran_env, only : stdin=>input_unit, &
                                        & stdout=>output_unit, &
@@ -70,7 +69,6 @@ module fpm_command_line
     logical                      :: show_model=.false.
     character(len=:),allocatable :: compiler
     character(len=:),allocatable :: profile
-    character(len=:),allocatable :: build_name
     character(len=:),allocatable :: flag
 end type
 
@@ -113,7 +111,7 @@ module fpm_command_line
 &  ' ',     'fpm',     'new',   'build',  'run',     &
 &  'test',  'runner', 'install', 'update', 'list',   'help',   'version'  ]
 
-character(len=:), allocatable :: val_runner, val_build, val_compiler, val_flag, val_profile
+character(len=:), allocatable :: val_runner, val_compiler, val_flag, val_profile
 
 contains
     subroutine get_command_line_settings(cmd_settings)
@@ -199,7 +197,6 @@ subroutine get_command_line_settings(cmd_settings)
             if(specified('runner') .and. val_runner.eq.'')val_runner='echo'
             cmd_settings=fpm_run_settings(&
             & args=remaining,&
-            & build_name=val_build,&
             & profile=val_profile,&
             & compiler=val_compiler, &
             & flag=val_flag, &
@@ -223,7 +220,6 @@ subroutine get_command_line_settings(cmd_settings)
 
             allocate( fpm_build_settings :: cmd_settings )
             cmd_settings=fpm_build_settings(  &
-            & build_name=val_build,&
             & profile=val_profile,&
             & compiler=val_compiler, &
             & flag=val_flag, &
@@ -361,7 +357,6 @@ subroutine get_command_line_settings(cmd_settings)
             allocate(install_settings)
             install_settings = fpm_install_settings(&
                 list=lget('list'), &
-                build_name=val_build, &
                 profile=val_profile,&
                 compiler=val_compiler, &
                 flag=val_flag, &
@@ -417,7 +412,6 @@ subroutine get_command_line_settings(cmd_settings)
             if(specified('runner') .and. val_runner.eq.'')val_runner='echo'
             cmd_settings=fpm_test_settings(&
             & args=remaining, &
-            & build_name=val_build, &
             & profile=val_profile, &
             & compiler=val_compiler, &
             & flag=val_flag, &
@@ -487,17 +481,6 @@ subroutine check_build_vals()
 
         val_flag = " " // sget('flag')
         val_profile = sget('profile')
-        if (val_flag == '') then
-            call get_default_compile_flags(val_compiler, val_profile == "release", val_flag)
-        else
-            select case(val_profile)
-            case("release", "debug")
-               call get_default_compile_flags(val_compiler, val_profile == "release", flags)
-               val_flag = flags // val_flag
-            end select
-        end if
-        allocate(character(len=16) :: val_build)
-        write(val_build, '(z16.16)') fnv_1a(val_flag)
 
     end subroutine check_build_vals
 

src/fpm_compiler.f90

@@ -28,6 +28,7 @@
 module fpm_compiler
 use fpm_environment, only: &
         run, &
+        get_env, &
         get_os_type, &
         OS_LINUX, &
         OS_MACOS, &
@@ -40,12 +41,6 @@ module fpm_compiler
 use fpm_filesystem, only: join_path, basename, get_temp_filename, delete_file, unix_path
 use fpm_strings, only: string_cat, string_t
 implicit none
-public :: is_unknown_compiler
-public :: get_module_flags
-public :: get_default_compile_flags
-public :: get_debug_compile_flags
-public :: get_release_compile_flags
-
 public :: compiler_t, archiver_t
 public :: debug
 
@@ -76,22 +71,37 @@ module fpm_compiler
 
 !> Definition of compiler object
 type :: 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
     !> Print all commands
     logical :: echo = .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
     !> Compile a Fortran object
     procedure :: compile_fortran
     !> Compile a C object
     procedure :: compile_c
     !> Link executable
     procedure :: link
+    !> Check whether compiler is recognized
+    procedure :: is_unknown
 end type compiler_t
 
 
+interface compiler_t
+    module procedure :: new_compiler
+end interface compiler_t
+
+
 !> Definition of archiver object
 type :: archiver_t
     !> Path to archiver
@@ -121,20 +131,19 @@ module fpm_compiler
 
 contains
 
-subroutine get_default_compile_flags(compiler, release, flags)
-    character(len=*), intent(in) :: compiler
+
+function get_default_flags(self, release) result(flags)
+    class(compiler_t), intent(in) :: self
     logical, intent(in) :: release
-    character(len=:), allocatable, intent(out) :: flags
-    integer :: id
+    character(len=:), allocatable :: flags
 
-    id = get_compiler_id(compiler)
     if (release) then
-        call get_release_compile_flags(id, flags)
+        call get_release_compile_flags(self%id, flags)
     else
-        call get_debug_compile_flags(id, flags)
+        call get_debug_compile_flags(self%id, flags)
     end if
 
-end subroutine get_default_compile_flags
+end function get_default_flags
 
 subroutine get_release_compile_flags(id, flags)
     integer(compiler_enum), intent(in) :: id
@@ -343,42 +352,63 @@ subroutine get_debug_compile_flags(id, flags)
     end select
 end subroutine get_debug_compile_flags
 
-subroutine get_module_flags(compiler, modpath, flags)
-    character(len=*), intent(in) :: compiler
-    character(len=*), intent(in) :: modpath
-    character(len=:), allocatable, intent(out) :: flags
-    integer(compiler_enum) :: id
+function get_include_flag(self, path) result(flags)
+    class(compiler_t), intent(in) :: self
+    character(len=*), intent(in) :: path
+    character(len=:), allocatable :: flags
 
-    id = get_compiler_id(compiler)
+    select case(self%id)
+    case default
+        flags = "-I "//path
 
-    select case(id)
+    case(id_caf, id_gcc, id_f95, id_cray, id_nvhpc, id_pgi, id_flang, &
+        & id_intel_classic_nix, id_intel_classic_mac, id_intel_classic_unknown, &
+        & id_intel_llvm_nix, id_intel_llvm_unknown, id_lahey, id_nag, &
+        & id_ibmxl)
+        flags = "-I "//path
+
+    case(id_intel_classic_windows, id_intel_llvm_windows)
+        flags = "/I"//path
+
+    end select
+end function get_include_flag
+
+function get_module_flag(self, path) result(flags)
+    class(compiler_t), intent(in) :: self
+    character(len=*), intent(in) :: path
+    character(len=:), allocatable :: flags
+
+    select case(self%id)
     case default
-        flags=' -module '//modpath//' -I '//modpath
+        flags = "-module "//path
 
     case(id_caf, id_gcc, id_f95, id_cray)
-        flags=' -J '//modpath//' -I '//modpath
+        flags = "-J "//path
 
     case(id_nvhpc, id_pgi, id_flang)
-        flags=' -module '//modpath//' -I '//modpath
+        flags = "-module "//path
 
-    case(id_intel_classic_nix, id_intel_classic_mac, id_intel_classic_unknown, id_intel_llvm_nix, id_intel_llvm_unknown)
-        flags=' -module '//modpath//' -I'//modpath
+    case(id_intel_classic_nix, id_intel_classic_mac, id_intel_classic_unknown, &
+        & id_intel_llvm_nix, id_intel_llvm_unknown)
+        flags = "-module "//path
 
     case(id_intel_classic_windows, id_intel_llvm_windows)
-        flags=' /module:'//modpath//' /I'//modpath
+        flags = "/module:"//path
 
     case(id_lahey)
-        flags=' -M '//modpath//' -I '//modpath
+        flags = "-M "//path
 
     case(id_nag)
-        flags=' -mdir '//modpath//' -I '//modpath !
+        flags = "-mdir "//path
 
     case(id_ibmxl)
-        flags=' -qmoddir '//modpath//' -I '//modpath
+        flags = "-qmoddir "//path
 
     end select
+    flags = flags//" "//self%get_include_flag(path)
+
+end function get_module_flag
 
-end subroutine get_module_flags
 
 subroutine get_default_c_compiler(f_compiler, c_compiler)
     character(len=*), intent(in) :: f_compiler
@@ -408,10 +438,13 @@ subroutine get_default_c_compiler(f_compiler, c_compiler)
 
 end subroutine get_default_c_compiler
 
+
 function get_compiler_id(compiler) result(id)
     character(len=*), intent(in) :: compiler
     integer(kind=compiler_enum) :: id
 
+    integer :: stat
+
     if (check_compiler(compiler, "gfortran")) then
         id = id_gcc
         return
@@ -510,14 +543,31 @@ function check_compiler(compiler, expected) result(match)
 end function check_compiler
 
 
-function is_unknown_compiler(compiler) result(is_unknown)
-    character(len=*), intent(in) :: compiler
+pure function is_unknown(self)
+    class(compiler_t), intent(in) :: self
     logical :: is_unknown
-    is_unknown = get_compiler_id(compiler) == id_unknown
-end function is_unknown_compiler
+    is_unknown = self%id == id_unknown
+end function is_unknown
+
+
+!> Create new compiler instance
+function new_compiler(fc) result(self)
+    !> Fortran compiler name or path
+    character(len=*), intent(in) :: fc
+    !> New instance of the compiler
+    type(compiler_t) :: self
+
+    character(len=*), parameter :: cc_env = "FPM_C_COMPILER"
+
+    self%id = get_compiler_id(fc)
+
+    self%fc = fc
+    call get_default_c_compiler(self%fc, self%cc)
+    self%cc = get_env(cc_env, self%cc)
+end function new_compiler
 
 
-!> Create new archiver
+!> Create new archiver instance
 function new_archiver() result(self)
     !> New instance of the archiver
     type(archiver_t) :: self