Merge pull request #369 from LKedward/separate-targets

Separate build targets from model structure

Author: LKedward

fpm/fpm.toml

@@ -1,5 +1,5 @@
 name = "fpm"
-version = "0.1.3"
+version = "0.1.4"
 license = "MIT"
 author = "fpm maintainers"
 maintainer = ""

fpm/src/fpm.f90

@@ -6,16 +6,16 @@ module fpm
 use fpm_dependency, only : new_dependency_tree
 use fpm_environment, only: run
 use fpm_filesystem, only: is_dir, join_path, number_of_rows, list_files, exists, basename
-use fpm_model, only: fpm_model_t, srcfile_t, build_target_t, &
+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, &
-                    FPM_TARGET_EXECUTABLE, FPM_TARGET_ARCHIVE, show_model
+                    FPM_SCOPE_APP, FPM_SCOPE_EXAMPLE, FPM_SCOPE_TEST
 use fpm_compiler, only: add_compile_flag_defaults
 
 
 use fpm_sources, only: add_executable_sources, add_sources_from_dir
 use fpm_targets, only: targets_from_sources, resolve_module_dependencies, &
-                        resolve_target_linking
+                        resolve_target_linking, build_target_t, build_target_ptr, &
+                        FPM_TARGET_EXECUTABLE, FPM_TARGET_ARCHIVE
 use fpm_manifest, only : get_package_data, package_config_t
 use fpm_error, only : error_t, fatal_error
 use fpm_manifest_test, only : test_config_t
@@ -50,11 +50,7 @@ subroutine build_model(model, settings, package, error)
 
     model%package_name = package%name
 
-    if (allocated(package%build%link)) then
-        model%link_libraries = package%build%link
-    else
-        allocate(model%link_libraries(0))
-    end if
+    allocate(model%link_libraries(0))
 
     call new_dependency_tree(model%deps, cache=join_path("build", "cache.toml"))
     call model%deps%add(package, error)
@@ -73,8 +69,6 @@ subroutine build_model(model, settings, package, error)
        write(*,*)'<INFO>COMPILER OPTIONS:  ', model%fortran_compile_flags 
     endif
 
-    model%link_flags = ''
-
     allocate(model%packages(model%deps%ndep))
 
     ! Add sources from executable directories
@@ -160,27 +154,14 @@ subroutine build_model(model, settings, package, error)
     end do
     if (allocated(error)) return
 
-    call targets_from_sources(model)
-
-    do i = 1, size(model%link_libraries)
-        model%link_flags = model%link_flags // " -l" // model%link_libraries(i)%s
-    end do
-
-    if (model%targets(1)%ptr%target_type == FPM_TARGET_ARCHIVE) then
-        model%library_file = model%targets(1)%ptr%output_file
-    end if
-
-    call resolve_module_dependencies(model%targets,error)
-
-    call resolve_target_linking(model%targets)
-
 end subroutine build_model
 
 
 subroutine cmd_build(settings)
 type(fpm_build_settings), intent(in) :: settings
 type(package_config_t) :: package
 type(fpm_model_t) :: model
+type(build_target_ptr), allocatable :: targets(:)
 type(error_t), allocatable :: error
 
 integer :: i
@@ -197,14 +178,20 @@ subroutine cmd_build(settings)
     error stop 1
 end if
 
+call targets_from_sources(targets,model,error)
+if (allocated(error)) then
+    print '(a)', error%message
+    error stop 1
+end if
+
 if(settings%list)then
-    do i=1,size(model%targets)
-        write(stderr,*) model%targets(i)%ptr%output_file
+    do i=1,size(targets)
+        write(stderr,*) targets(i)%ptr%output_file
     enddo
 else if (settings%show_model) then
     call show_model(model)
 else
-    call build_package(model)
+    call build_package(targets,model)
 endif
 
 end subroutine
@@ -218,6 +205,7 @@ subroutine cmd_run(settings,test)
     type(error_t), allocatable :: error
     type(package_config_t) :: package
     type(fpm_model_t) :: model
+    type(build_target_ptr), allocatable :: targets(:)
     type(string_t) :: exe_cmd
     type(string_t), allocatable :: executables(:)
     type(build_target_t), pointer :: exe_target
@@ -238,6 +226,12 @@ subroutine cmd_run(settings,test)
         error stop 1
     end if
 
+    call targets_from_sources(targets,model,error)
+    if (allocated(error)) then
+        print '(a)', error%message
+        error stop 1
+    end if
+
     if (test) then
        run_scope = FPM_SCOPE_TEST
     else
@@ -248,9 +242,9 @@ subroutine cmd_run(settings,test)
     col_width = -1
     found(:) = .false.
     allocate(executables(0))
-    do i=1,size(model%targets)
+    do i=1,size(targets)
 
-        exe_target => model%targets(i)%ptr
+        exe_target => targets(i)%ptr
 
         if (exe_target%target_type == FPM_TARGET_EXECUTABLE .and. &
              allocated(exe_target%dependencies)) then
@@ -331,7 +325,7 @@ subroutine cmd_run(settings,test)
 
     end if
 
-    call build_package(model)
+    call build_package(targets,model)
 
     if (settings%list) then
          call compact_list()
@@ -357,9 +351,9 @@ subroutine compact_list_all()
         j = 1
         nCol = LINE_WIDTH/col_width
         write(stderr,*) 'Available names:'
-        do i=1,size(model%targets)
+        do i=1,size(targets)
 
-            exe_target => model%targets(i)%ptr
+            exe_target => targets(i)%ptr
 
             if (exe_target%target_type == FPM_TARGET_EXECUTABLE .and. &
                 allocated(exe_target%dependencies)) then

fpm/src/fpm/cmd/install.f90

@@ -7,8 +7,9 @@ module fpm_cmd_install
   use fpm_filesystem, only : join_path, list_files
   use fpm_installer, only : installer_t, new_installer
   use fpm_manifest, only : package_config_t, get_package_data
-  use fpm_model, only : fpm_model_t, build_target_t, FPM_TARGET_EXECUTABLE, &
-    FPM_SCOPE_APP
+  use fpm_model, only : fpm_model_t, FPM_SCOPE_APP
+  use fpm_targets, only: targets_from_sources, build_target_t, &
+                         build_target_ptr, FPM_TARGET_EXECUTABLE
   use fpm_strings, only : string_t, resize
   implicit none
   private
@@ -24,6 +25,7 @@ subroutine cmd_install(settings)
     type(package_config_t) :: package
     type(error_t), allocatable :: error
     type(fpm_model_t) :: model
+    type(build_target_ptr), allocatable :: targets(:)
     type(installer_t) :: installer
     character(len=:), allocatable :: lib, exe, dir
     logical :: installable
@@ -34,6 +36,9 @@ subroutine cmd_install(settings)
     call build_model(model, settings%fpm_build_settings, package, error)
     call handle_error(error)
 
+    call targets_from_sources(targets,model,error)
+    call handle_error(error)
+
     installable = (allocated(package%library) .and. package%install%library) &
       .or. allocated(package%executable)
     if (.not.installable) then
@@ -42,12 +47,12 @@ subroutine cmd_install(settings)
     end if
 
     if (settings%list) then
-      call install_info(output_unit, package, model)
+      call install_info(output_unit, package, model, targets)
       return
     end if
 
     if (.not.settings%no_rebuild) then
-      call build_package(model)
+      call build_package(targets,model)
     end if
 
     call new_installer(installer, prefix=settings%prefix, &
@@ -66,16 +71,17 @@ subroutine cmd_install(settings)
     end if
 
     if (allocated(package%executable)) then
-      call install_executables(installer, model, error)
+      call install_executables(installer, targets, error)
       call handle_error(error)
     end if
 
   end subroutine cmd_install
 
-  subroutine install_info(unit, package, model)
+  subroutine install_info(unit, package, model, targets)
     integer, intent(in) :: unit
     type(package_config_t), intent(in) :: package
     type(fpm_model_t), intent(in) :: model
+    type(build_target_ptr), intent(in) :: targets(:)
 
     integer :: ii, ntargets
     character(len=:), allocatable :: lib
@@ -90,11 +96,11 @@ subroutine install_info(unit, package, model)
         "lib"//model%package_name//".a")
       install_target(ntargets)%s = lib
     end if
-    do ii = 1, size(model%targets)
-      if (is_executable_target(model%targets(ii)%ptr)) then
+    do ii = 1, size(targets)
+      if (is_executable_target(targets(ii)%ptr)) then
         if (ntargets >= size(install_target)) call resize(install_target)
         ntargets = ntargets + 1
-        install_target(ntargets)%s = model%targets(ii)%ptr%output_file
+        install_target(ntargets)%s = targets(ii)%ptr%output_file
       end if
     end do
 
@@ -125,15 +131,15 @@ subroutine install_module_files(installer, dir, error)
 
   end subroutine install_module_files
 
-  subroutine install_executables(installer, model, error)
+  subroutine install_executables(installer, targets, error)
     type(installer_t), intent(inout) :: installer
-    type(fpm_model_t), intent(in) :: model
+    type(build_target_ptr), intent(in) :: targets(:)
     type(error_t), allocatable, intent(out) :: error
     integer :: ii
 
-    do ii = 1, size(model%targets)
-      if (is_executable_target(model%targets(ii)%ptr)) then
-        call installer%install_executable(model%targets(ii)%ptr%output_file, error)
+    do ii = 1, size(targets)
+      if (is_executable_target(targets(ii)%ptr)) then
+        call installer%install_executable(targets(ii)%ptr%output_file, error)
         if (allocated(error)) exit
       end if
     end do

fpm/src/fpm_backend.f90

@@ -1,6 +1,6 @@
 !># Build backend
-!> Uses a valid `[[fpm_model]]` instance to schedule and execute the
-!> compilation and linking of package targets.
+!> Uses a list of `[[build_target_ptr]]` and a valid `[[fpm_model]]` instance 
+!> to schedule and execute the compilation and linking of package targets.
 !> 
 !> The package build process (`[[build_package]]`) comprises three steps:
 !>
@@ -29,7 +29,8 @@ module fpm_backend
 
 use fpm_environment, only: run
 use fpm_filesystem, only: dirname, join_path, exists, mkdir
-use fpm_model, only: fpm_model_t, build_target_t, build_target_ptr, &
+use fpm_model, only: fpm_model_t
+use fpm_targets, only: build_target_t, build_target_ptr, &
                      FPM_TARGET_OBJECT, FPM_TARGET_ARCHIVE, FPM_TARGET_EXECUTABLE
 
 use fpm_strings, only: string_cat
@@ -42,8 +43,9 @@ module fpm_backend
 contains
 
 !> Top-level routine to build package described by `model`
-subroutine build_package(model)
-    type(fpm_model_t), intent(inout) :: model
+subroutine build_package(targets,model)
+    type(build_target_ptr), intent(inout) :: targets(:)
+    type(fpm_model_t), intent(in) :: model
 
     integer :: i, j
     type(build_target_ptr), allocatable :: queue(:)
@@ -55,14 +57,14 @@ subroutine build_package(model)
     end if
 
     ! Perform depth-first topological sort of targets
-    do i=1,size(model%targets)
+    do i=1,size(targets)
 
-        call sort_target(model%targets(i)%ptr)
+        call sort_target(targets(i)%ptr)
 
     end do
 
     ! Construct build schedule queue
-    call schedule_targets(queue, schedule_ptr, model%targets)
+    call schedule_targets(queue, schedule_ptr, targets)
 
     ! Loop over parallel schedule regions
     do i=1,size(schedule_ptr)-1
@@ -236,27 +238,13 @@ subroutine build_target(model,target)
     select case(target%target_type)
 
     case (FPM_TARGET_OBJECT)
-        call run(model%fortran_compiler//" -c " // target%source%file_name // model%fortran_compile_flags &
+        call run(model%fortran_compiler//" -c " // target%source%file_name // target%compile_flags &
               // " -o " // target%output_file)
 
     case (FPM_TARGET_EXECUTABLE)
-
-        link_flags = string_cat(target%link_objects," ") 
-
-        if (allocated(model%library_file)) then
-            link_flags = link_flags//" "//model%library_file//" "//model%link_flags
-        else
-            link_flags = link_flags//" "//model%link_flags
-        end if
-        
-        if (allocated(target%link_libraries)) then
-            if (size(target%link_libraries) > 0) then
-                link_flags = link_flags // " -l" // string_cat(target%link_libraries," -l")
-            end if
-        end if
 
-        call run(model%fortran_compiler// " " // model%fortran_compile_flags &
-              //" "//link_flags// " -o " // target%output_file)
+        call run(model%fortran_compiler// " " // target%compile_flags &
+              //" "//target%link_flags// " -o " // target%output_file)
 
     case (FPM_TARGET_ARCHIVE)
         call run("ar -rs " // target%output_file // " " // string_cat(target%link_objects," "))

fpm/src/fpm_command_line.f90

@@ -130,7 +130,7 @@ subroutine get_command_line_settings(cmd_settings)
             case default     ; os_type =  "OS Type:     UNKNOWN"
         end select
         version_text = [character(len=80) :: &
-         &  'Version:     0.1.3, alpha',                           &
+         &  'Version:     0.1.4, alpha',                           &
          &  'Program:     fpm(1)',                                     &
          &  'Description: A Fortran package manager and build system', &
          &  'Home Page:   https://github.com/fortran-lang/fpm',        &