[meta] refactor: process command line args as arrays (#1123)

Author: perazz

src/fpm_compiler.F90

@@ -39,12 +39,15 @@ module fpm_compiler
         OS_UNKNOWN
 use fpm_filesystem, only: join_path, basename, get_temp_filename, delete_file, unix_path, &
     & getline, run
-use fpm_strings, only: split, string_cat, string_t, str_ends_with, str_begins_with_str
+use fpm_strings, only: split, string_cat, string_t, str_ends_with, str_begins_with_str, &
+    & string_array_contains
 use fpm_manifest, only : package_config_t
 use fpm_error, only: error_t, fatal_error
 use fpm_toml, only: serializable_t, toml_table, set_string, set_value, toml_stat, get_value
+use shlex_module, only: shlex_split => split
 implicit none
 public :: compiler_t, new_compiler, archiver_t, new_archiver, get_macros
+public :: append_clean_flags, append_clean_flags_array
 public :: debug
 
 enum, bind(C)
@@ -1071,17 +1074,17 @@ subroutine new_archiver(self, ar, echo, verbose)
         ! Attempt "ar"
         call execute_command_line("ar --version > "//get_temp_filename()//" 2>&1", &
           & exitstat=estat)
-          
-        if (estat == 0) then 
-            
+
+        if (estat == 0) then
+
             self%ar = "ar"//arflags
-            
+
         else
-            
+
             ! Then "gcc-ar"
             call execute_command_line("gcc-ar --version > "//get_temp_filename()//" 2>&1", &
-               & exitstat=estat)            
-            
+               & exitstat=estat)
+
             if (estat /= 0) then
               self%ar = "lib"//libflags
             else
@@ -1440,38 +1443,38 @@ end function compiler_name
 logical function check_fortran_source_runs(self, input) result(success)
     !> Instance of the compiler object
     class(compiler_t), intent(in) :: self
-    !> Program Source 
+    !> Program Source
     character(len=*), intent(in) :: input
-    
+
     integer :: stat,unit
     character(:), allocatable :: source,object,logf,exe
-    
+
     success = .false.
-   
+
     !> Create temporary source file
     exe    = get_temp_filename()
     source = exe//'.f90'
     object = exe//'.o'
     logf   = exe//'.log'
     open(newunit=unit, file=source, action='readwrite', iostat=stat)
     if (stat/=0) return
-   
+
     !> Write contents
     write(unit,*) input
-    close(unit)  
-    
-    !> Compile and link program 
+    close(unit)
+
+    !> Compile and link program
     call self%compile_fortran(source, object, self%get_default_flags(release=.false.), logf, stat)
     if (stat==0) &
     call self%link(exe, self%get_default_flags(release=.false.)//" "//object, logf, stat)
-        
-    !> Run and retrieve exit code 
+
+    !> Run and retrieve exit code
     if (stat==0) &
     call run(exe,echo=.false., exitstat=stat, verbose=.false., redirect=logf)
-    
+
     !> Successful exit on 0 exit code
     success = stat==0
-    
+
     !> Delete files
     open(newunit=unit, file=source, action='readwrite', iostat=stat)
     close(unit,status='delete')
@@ -1481,23 +1484,81 @@ logical function check_fortran_source_runs(self, input) result(success)
     close(unit,status='delete')
     open(newunit=unit, file=exe, action='readwrite', iostat=stat)
     close(unit,status='delete')
-            
+
 end function check_fortran_source_runs
 
-!> Check if the current compiler supports 128-bit real precision 
+!> Check if the current compiler supports 128-bit real precision
 logical function with_qp(self)
     !> Instance of the compiler object
     class(compiler_t), intent(in) :: self
     with_qp = self%check_fortran_source_runs &
               ('if (selected_real_kind(33) == -1) stop 1; end')
 end function with_qp
 
-!> Check if the current compiler supports 80-bit "extended" real precision 
+!> Check if the current compiler supports 80-bit "extended" real precision
 logical function with_xdp(self)
     !> Instance of the compiler object
     class(compiler_t), intent(in) :: self
     with_xdp = self%check_fortran_source_runs &
                ('if (any(selected_real_kind(18) == [-1, selected_real_kind(33)])) stop 1; end')
 end function with_xdp
 
+!> Append new flags to existing flags, removing duplicates and empty flags (string version)
+subroutine append_clean_flags(flags, new_flags)
+    character(:), intent(inout), allocatable :: flags
+    character(*), intent(in) :: new_flags
+
+    type(string_t), allocatable :: flags_array(:), new_flags_array(:)
+    integer :: i
+
+    call tokenize_flags(flags, flags_array)
+    call tokenize_flags(new_flags, new_flags_array)
+
+    call append_clean_flags_array(flags_array, new_flags_array)
+
+    do i = 1, size(flags_array)
+        flags = flags // " " // flags_array(i)%s
+    end do
+end subroutine append_clean_flags
+
+!> Append new flags to existing flags, removing duplicates and empty flags (array version)
+subroutine append_clean_flags_array(flags_array, new_flags_array)
+    type(string_t), allocatable, intent(inout) :: flags_array(:)
+    type(string_t), intent(in) :: new_flags_array(:)
+
+    integer :: i
+
+    do i = 1, size(new_flags_array)
+        if (string_array_contains(new_flags_array(i)%s, flags_array)) cycle
+        ! Filter out empty flags and arguments
+        if (new_flags_array(i)%s == "") cycle
+        if (trim(new_flags_array(i)%s) == "-l") cycle
+        if (trim(new_flags_array(i)%s) == "-L") cycle
+        if (trim(new_flags_array(i)%s) == "-I") cycle
+        if (trim(new_flags_array(i)%s) == "-J") cycle
+        if (trim(new_flags_array(i)%s) == "-M") cycle
+        flags_array = [flags_array, new_flags_array(i)]
+    end do
+end subroutine append_clean_flags_array
+
+!> Tokenize a string into an array of compiler flags
+subroutine tokenize_flags(flags, flags_array)
+    character(*), intent(in) :: flags
+    type(string_t), allocatable, intent(out) :: flags_array(:)
+    character(len=:), allocatable :: flags_char_array(:)
+
+    integer :: i
+    logical :: success
+
+    flags_char_array = shlex_split(flags, join_spaced=.true., keep_quotes=.true., success=success)
+    if (.not. success) then
+        allocate(flags_array(0))
+        return
+    end if
+    allocate(flags_array(size(flags_char_array)))
+    do i = 1, size(flags_char_array)
+        flags_array(i)%s = trim(adjustl(flags_char_array(i)))
+    end do
+end subroutine tokenize_flags
+
 end module fpm_compiler

src/metapackage/fpm_meta_base.f90

@@ -5,7 +5,8 @@ module fpm_meta_base
     use fpm_command_line, only: fpm_cmd_settings, fpm_run_settings
     use fpm_manifest_dependency, only: dependency_config_t
     use fpm_manifest, only: package_config_t
-    use fpm_strings, only: string_t, len_trim
+    use fpm_strings, only: string_t, len_trim, split, join
+    use fpm_compiler, only: append_clean_flags, append_clean_flags_array
 
     implicit none
 
@@ -111,30 +112,30 @@ subroutine resolve_model(self,model,error)
 
         ! Add global build flags, to apply to all sources
         if (self%has_build_flags) then
-            model%fortran_compile_flags = model%fortran_compile_flags//self%flags%s
-            model%c_compile_flags       = model%c_compile_flags//self%flags%s
-            model%cxx_compile_flags     = model%cxx_compile_flags//self%flags%s
+            call append_clean_flags(model%fortran_compile_flags, self%flags%s)
+            call append_clean_flags(model%c_compile_flags, self%flags%s)
+            call append_clean_flags(model%cxx_compile_flags, self%flags%s)
         endif
 
         ! Add language-specific flags
-        if (self%has_fortran_flags) model%fortran_compile_flags = model%fortran_compile_flags//self%fflags%s
-        if (self%has_c_flags)       model%c_compile_flags       = model%c_compile_flags//self%cflags%s
-        if (self%has_cxx_flags)     model%cxx_compile_flags     = model%cxx_compile_flags//self%cxxflags%s
+        if (self%has_fortran_flags) call append_clean_flags(model%fortran_compile_flags, self%fflags%s)
+        if (self%has_c_flags)       call append_clean_flags(model%c_compile_flags, self%cflags%s)
+        if (self%has_cxx_flags)     call append_clean_flags(model%cxx_compile_flags, self%cxxflags%s)
 
         if (self%has_link_flags) then
-            model%link_flags            = model%link_flags//' '//self%link_flags%s
+            call append_clean_flags(model%link_flags, self%link_flags%s)
         end if
 
         if (self%has_link_libraries) then
-            model%link_libraries        = [model%link_libraries,self%link_libs]
+            call append_clean_flags_array(model%link_libraries, self%link_libs)
         end if
 
         if (self%has_include_dirs) then
-            model%include_dirs          = [model%include_dirs,self%incl_dirs]
+            call append_clean_flags_array(model%include_dirs, self%incl_dirs)
         end if
 
         if (self%has_external_modules) then
-            model%external_modules      = [model%external_modules,self%external_modules]
+            call append_clean_flags_array(model%external_modules, self%external_modules)
         end if
 
     end subroutine resolve_model
@@ -185,6 +186,6 @@ pure function dn(bool)
            end if
         end function dn
 
-
     end subroutine resolve_package_config
+
 end module fpm_meta_base

src/metapackage/fpm_meta_util.f90

@@ -21,8 +21,8 @@ subroutine add_pkg_config_compile_options(this, name, include_flag, libdir, erro
         character(len=*), intent(in) :: include_flag
         type(error_t), allocatable, intent(out) :: error
 
-        character(len=:), allocatable :: libdir, ext, pref
-        type(string_t) :: log, this_lib
+        character(len=:), allocatable :: libdir
+        type(string_t) :: log, current_include_dir, current_lib
         type(string_t), allocatable :: libs(:), flags(:)
         integer :: i
 
@@ -42,8 +42,10 @@ subroutine add_pkg_config_compile_options(this, name, include_flag, libdir, erro
         libdir = ""
         do i = 1, size(libs)
             if (str_begins_with_str(libs(i)%s, '-l')) then
+                current_lib = string_t(libs(i)%s(3:))
+                if (len_trim(current_lib%s) == 0) cycle
                 this%has_link_libraries = .true.
-                this%link_libs = [this%link_libs, string_t(libs(i)%s(3:))]
+                this%link_libs = [this%link_libs, current_lib]
             else ! -L and others: concatenate
                 this%has_link_flags = .true.
                 this%link_flags = string_t(trim(this%link_flags%s)//' '//libs(i)%s)
@@ -63,8 +65,10 @@ subroutine add_pkg_config_compile_options(this, name, include_flag, libdir, erro
 
         do i = 1, size(flags)
             if (str_begins_with_str(flags(i)%s, include_flag)) then
+                current_include_dir = string_t(flags(i)%s(len(include_flag)+1:))
+                if (len_trim(current_include_dir%s) == 0) cycle
                 this%has_include_dirs = .true.
-                this%incl_dirs = [this%incl_dirs, string_t(flags(i)%s(len(include_flag)+1:))]
+                this%incl_dirs = [this%incl_dirs, current_include_dir]
             else
                 this%has_build_flags = .true.
                 this%flags = string_t(trim(this%flags%s)//' '//flags(i)%s)

test/fpm_test/test_compiler.f90

@@ -3,7 +3,8 @@ module test_compiler
     use testsuite, only : new_unittest, unittest_t, error_t, test_failed, &
         & check_string
     use fpm_environment, only : OS_WINDOWS, OS_LINUX
-    use fpm_compiler   , only : compiler_t, new_compiler
+    use fpm_compiler   , only : compiler_t, new_compiler, tokenize_flags
+    use fpm_strings    , only : string_t
     use fpm_command_line, only: get_fpm_env
     implicit none
     private
@@ -19,38 +20,73 @@ subroutine collect_compiler(testsuite)
         type(unittest_t), allocatable, intent(out) :: testsuite(:)
 
         testsuite = [ &
-            & new_unittest("check-fortran-source-runs", test_check_fortran_source_runs)]
+            & new_unittest("check-fortran-source-runs", test_check_fortran_source_runs), &
+            & new_unittest("tokenize-flags", test_tokenize_flags)]
 
     end subroutine collect_compiler
-    
+
     subroutine test_check_fortran_source_runs(error)
         !> Error handling
         type(error_t), allocatable, intent(out) :: error
-        
+
         character(:), allocatable :: fc,cc,cxx
-        
-        
+
+
         type(compiler_t) :: compiler
 
         !> Get default compiler
         fc  = get_fpm_env("FC", default="gfortran")
         cc  = get_fpm_env("CC", default=" ")
         cxx = get_fpm_env("CXX", default=" ")
-        
+
         call new_compiler(compiler, fc, cc, cxx, echo=.false., verbose=.false.)
 
         if (compiler%is_unknown()) then
             call test_failed(error, "Cannot initialize Fortran compiler")
             return
         end if
-        
+
         !> Test fortran-source runs
-        if (.not.compiler%check_fortran_source_runs("print *, 'Hello world!'; end")) then 
+        if (.not.compiler%check_fortran_source_runs("print *, 'Hello world!'; end")) then
             call test_failed(error, "Cannot run Fortran hello world")
             return
-        end if        
+        end if
+
+    end subroutine test_check_fortran_source_runs
+
+    subroutine test_tokenize_flags(error)
+        type(error_t), allocatable, intent(out) :: error
+
+        character(:), allocatable :: flags
+        type(string_t), allocatable :: tokens(:)
+        integer :: i
+
+        flags = '-I/path/to/include -I /test -I"/path/to/include with spaces" ' // &
+            '-I "spaces here too" -L/path/to/lib -lmylib -O2 -g -Wall'
+        call tokenize_flags(flags, tokens)
+
+        do i = 1, size(tokens)
+            print *, "Tokens ", i, ": ", tokens(i)%s
+        end do
+
+        if (tokens(1)%s /= '-I/path/to/include') then
+            call test_failed(error, "Tokenization of flags failed: expected '-I/path/to/include'")
+            return
+        end if
+        if (tokens(2)%s /= '-I/test') then
+            call test_failed(error, "Tokenization of flags failed: expected '-I/test'")
+            return
+        end if
+        if (tokens(3)%s /= '-I"/path/to/include with spaces"') then
+            call test_failed(error, 'Tokenization of flags failed: expected -I"/path/to/include with spaces"')
+            return
+        end if
 
-    end subroutine test_check_fortran_source_runs    
+        if (size(tokens) /= 9) then
+            call test_failed(error, "Tokenization of flags failed: expected 9 tokens")
+            return
+        end if
 
+    end subroutine test_tokenize_flags
 
 end module test_compiler