[Fortran fpm] Internal dependencies & build backend

ci/run_tests.bat

@@ -21,5 +21,24 @@ if errorlevel 1 exit 1
 ..\..\..\fpm\build\gfortran_debug\app\fpm build
 if errorlevel 1 exit 1
 
-.\hello_world
+.\build\gfortran_debug\app\hello_world
 if errorlevel 1 exit 1
+
+
+cd ..\hello_complex
+if errorlevel 1 exit 1
+
+..\..\..\fpm\build\gfortran_debug\app\fpm build
+if errorlevel 1 exit 1
+
+.\build\gfortran_debug\app\say_Hello
+if errorlevel 1 exit 1
+
+.\build\gfortran_debug\app\say_goodbye
+if errorlevel 1 exit 1
+
+.\build\gfortran_debug\test\greet_test
+if errorlevel 1 exit 1
+
+.\build\gfortran_debug\test\farewell_test
+if errorlevel 1 exit 1

ci/run_tests.sh

@@ -7,6 +7,14 @@ fpm build
 fpm run
 fpm test
 build/gfortran_debug/app/fpm
+
 cd ../test/example_packages/hello_world
 ../../../fpm/build/gfortran_debug/app/fpm build
-./hello_world
+./build/gfortran_debug/app/hello_world
+
+cd ../hello_complex
+../../../fpm/build/gfortran_debug/app/fpm build
+./build/gfortran_debug/app/say_Hello
+./build/gfortran_debug/app/say_goodbye
+./build/gfortran_debug/test/greet_test
+./build/gfortran_debug/test/farewell_test

fpm/app/main.f90

@@ -1,5 +1,5 @@
 program main
-use command_line, only: &
+use fpm_command_line, only: &
         fpm_cmd_settings, &
         fpm_new_settings, &
         fpm_build_settings, &
@@ -15,11 +15,11 @@ program main
 
 call get_command_line_settings(cmd_settings)
 
-select type(cmd_settings)
+select type(settings=>cmd_settings)
 type is (fpm_new_settings)
     call cmd_new()
 type is (fpm_build_settings)
-    call cmd_build()
+    call cmd_build(settings)
 type is (fpm_run_settings)
     call cmd_run()
 type is (fpm_test_settings)

fpm/src/fpm.f90

@@ -1,99 +1,61 @@
 module fpm
-use environment, only: get_os_type, OS_LINUX, OS_MACOS, OS_WINDOWS
-use fpm_manifest, only : get_package_data, default_executable, default_library, &
-    & package_t
+
+use fpm_strings, only: string_t, str_ends_with
+use fpm_backend, only: build_package
+use fpm_command_line, only: fpm_build_settings
+use fpm_environment, only: run, get_os_type, OS_LINUX, OS_MACOS, OS_WINDOWS
+use fpm_filesystem, only: join_path, number_of_rows, list_files, exists
+use fpm_model, only: srcfile_ptr, srcfile_t, fpm_model_t
+use fpm_sources, only: add_executable_sources, add_sources_from_dir, &
+                       resolve_module_dependencies
+use fpm_manifest, only : get_package_data, default_executable, &
+                         default_library, package_t
 use fpm_error, only : error_t
 implicit none
 private
 public :: cmd_build, cmd_install, cmd_new, cmd_run, cmd_test
 
-type string_t
-    character(len=:), allocatable :: s
-end type
 
 contains
 
-integer function number_of_rows(s) result(nrows)
-! determine number or rows
-integer,intent(in)::s
-integer :: ios
-character(len=100) :: r
-rewind(s)
-nrows = 0
-do
-    read(s, *, iostat=ios) r
-    if (ios /= 0) exit
-    nrows = nrows + 1
-end do
-rewind(s)
-end function
-
-
-subroutine list_files(dir, files)
-character(len=*), intent(in) :: dir
-type(string_t), allocatable, intent(out) :: files(:)
-character(len=100) :: filename
-integer :: stat, u, i
-! Using `inquire` / exists on directories works with gfortran, but not ifort
-if (.not. exists(dir)) then
-    allocate(files(0))
-    return
-end if
-select case (get_os_type())
-    case (OS_LINUX)
-        call execute_command_line("ls " // dir // " > fpm_ls.out", exitstat=stat)
-    case (OS_MACOS)
-        call execute_command_line("ls " // dir // " > fpm_ls.out", exitstat=stat)
-    case (OS_WINDOWS)
-        call execute_command_line("dir /b " // dir // " > fpm_ls.out", exitstat=stat)
-end select
-if (stat /= 0) then
-    print *, "execute_command_line() failed"
-    error stop
-end if
-open(newunit=u, file="fpm_ls.out", status="old")
-allocate(files(number_of_rows(u)))
-do i = 1, size(files)
-    read(u, *) filename
-    files(i)%s = trim(filename)
-end do
-close(u)
-end subroutine
-
-subroutine run(cmd)
-character(len=*), intent(in) :: cmd
-integer :: stat
-print *, "+ ", cmd
-call execute_command_line(cmd, exitstat=stat)
-if (stat /= 0) then
-    print *, "Command failed"
-    error stop
-end if
-end subroutine
-
-logical function exists(filename) result(r)
-character(len=*), intent(in) :: filename
-inquire(file=filename, exist=r)
-end function
-
-logical function str_ends_with(s, e) result(r)
-character(*), intent(in) :: s, e
-integer :: n1, n2
-n1 = len(s)-len(e)+1
-n2 = len(s)
-if (n1 < 1) then
-    r = .false.
-else
-    r = (s(n1:n2) == e)
-end if
-end function
-
-subroutine cmd_build()
+subroutine build_model(model, settings, package)
+    ! Constructs a valid fpm model from command line settings and toml manifest
+    !
+    type(fpm_model_t), intent(out) :: model
+    type(fpm_build_settings), intent(in) :: settings
+    type(package_t), intent(in) :: package
+
+    model%package_name = package%name
+
+    ! #TODO: Choose flags and output directory based on cli settings & manifest inputs
+    model%fortran_compiler = 'gfortran'
+    model%output_directory = 'build/gfortran_debug'
+    model%fortran_compile_flags = ' -Wall -Wextra -Wimplicit-interface  -fPIC -fmax-errors=1 -g '// &
+                                  '-fbounds-check -fcheck-array-temporaries -fbacktrace '// &
+                                  '-J'//join_path(model%output_directory,model%package_name)
+    model%link_flags = ''
+
+    ! Add sources from executable directories
+    if (allocated(package%executable)) then
+        call add_executable_sources(model%sources, package%executable,is_test=.false.)
+    end if
+    if (allocated(package%test)) then
+        call add_executable_sources(model%sources, package%test,is_test=.true.)
+    end if
+
+    if (allocated(package%library)) then
+        call add_sources_from_dir(model%sources,package%library%source_dir)
+    end if
+
+    call resolve_module_dependencies(model%sources)
+
+end subroutine build_model
+
+subroutine cmd_build(settings)
+type(fpm_build_settings), intent(in) :: settings
 type(package_t) :: package
+type(fpm_model_t) :: model
 type(error_t), allocatable :: error
-type(string_t), allocatable :: files(:)
-character(:), allocatable :: basename, linking
-integer :: i, n
 call get_package_data(package, "fpm.toml", error)
 if (allocated(error)) then
     print '(a)', error%message
@@ -102,6 +64,7 @@ subroutine cmd_build()
 
 ! Populate library in case we find the default src directory
 if (.not.allocated(package%library) .and. exists("src")) then
+    allocate(package%library)
     call default_library(package%library)
 end if
 
@@ -116,27 +79,10 @@ subroutine cmd_build()
     error stop 1
 end if
 
-linking = ""
-if (allocated(package%library)) then
-    call list_files(package%library%source_dir, files)
-    do i = 1, size(files)
-        if (str_ends_with(files(i)%s, ".f90")) then
-            n = len(files(i)%s)
-            basename = files(i)%s
-            call run("gfortran -c " // package%library%source_dir // "/" // &
-               & basename // " -o " // basename // ".o")
-            linking = linking // " " // basename // ".o"
-        end if
-    end do
-end if
+call build_model(model, settings, package)
+
+call build_package(model)
 
-do i = 1, size(package%executable)
-    basename = package%executable(i)%main
-    call run("gfortran -c " // package%executable(i)%source_dir // "/" // &
-       & basename // " -o " // basename // ".o")
-    call run("gfortran " // basename // ".o " // linking // " -o " // &
-       & package%executable(i)%name)
-end do
 end subroutine
 
 subroutine cmd_install()

fpm/src/fpm_backend.f90

@@ -0,0 +1,123 @@
+module fpm_backend
+
+! Implements the native fpm build backend
+
+use fpm_environment, only: run
+use fpm_filesystem, only: basename, join_path, exists, mkdir
+use fpm_model, only: fpm_model_t, srcfile_t, FPM_UNIT_MODULE, &
+                     FPM_UNIT_SUBMODULE, FPM_UNIT_SUBPROGRAM, &
+                     FPM_UNIT_CSOURCE, FPM_UNIT_PROGRAM
+use fpm_strings, only: split
+
+implicit none
+
+private
+public :: build_package
+
+contains
+
+
+subroutine build_package(model)
+    type(fpm_model_t), intent(inout) :: model
+
+    integer :: i
+    character(:), allocatable :: base, linking, subdir
+
+    if (.not.exists(model%output_directory)) then
+        call mkdir(model%output_directory)
+    end if
+    if (.not.exists(join_path(model%output_directory,model%package_name))) then
+        call mkdir(join_path(model%output_directory,model%package_name))
+    end if
+
+    linking = ""
+    do i=1,size(model%sources)
+
+        if (model%sources(i)%unit_type == FPM_UNIT_MODULE .or. &
+            model%sources(i)%unit_type == FPM_UNIT_SUBMODULE .or. &
+            model%sources(i)%unit_type == FPM_UNIT_SUBPROGRAM .or. &
+            model%sources(i)%unit_type == FPM_UNIT_CSOURCE) then
+
+            call build_source(model,model%sources(i),linking)
+
+        end if
+
+    end do
+
+    if (any([(model%sources(i)%unit_type == FPM_UNIT_PROGRAM,i=1,size(model%sources))])) then
+        if (.not.exists(join_path(model%output_directory,'test'))) then
+            call mkdir(join_path(model%output_directory,'test'))
+        end if
+        if (.not.exists(join_path(model%output_directory,'app'))) then
+            call mkdir(join_path(model%output_directory,'app'))
+        end if
+    end if
+
+    do i=1,size(model%sources)
+
+        if (model%sources(i)%unit_type == FPM_UNIT_PROGRAM) then
+
+            base = basename(model%sources(i)%file_name,suffix=.false.)
+
+            if (model%sources(i)%is_test) then
+                subdir = 'test'
+            else
+                subdir = 'app'
+            end if
+
+            call run("gfortran -c " // model%sources(i)%file_name // ' '//model%fortran_compile_flags &
+                      // " -o " // join_path(model%output_directory,subdir,base) // ".o")
+
+            call run("gfortran " // join_path(model%output_directory, subdir, base) // ".o "// &
+                     linking //" " //model%link_flags // " -o " // &
+                      join_path(model%output_directory,subdir,model%sources(i)%exe_name) )
+
+        end if
+
+    end do
+
+end subroutine build_package
+
+
+
+recursive subroutine build_source(model,source_file,linking)
+    ! Compile Fortran source, called recursively on it dependents
+    !  
+    type(fpm_model_t), intent(in) :: model
+    type(srcfile_t), intent(inout) :: source_file
+    character(:), allocatable, intent(inout) :: linking
+
+    integer :: i
+    character(:), allocatable :: object_file
+
+    if (source_file%built) then
+        return
+    end if
+
+    if (source_file%touched) then
+        write(*,*) '(!) Circular dependency found with: ',source_file%file_name
+        stop
+    else
+        source_file%touched = .true.
+    end if
+
+    do i=1,size(source_file%file_dependencies)
+
+        if (associated(source_file%file_dependencies(i)%ptr)) then
+            call build_source(model,source_file%file_dependencies(i)%ptr,linking)
+        end if
+
+    end do
+
+    object_file = join_path(model%output_directory, model%package_name, &
+                        basename(source_file%file_name,suffix=.false.)//'.o')
+
+    call run("gfortran -c " // source_file%file_name // model%fortran_compile_flags &
+              // " -o " // object_file)
+    linking = linking // " " // object_file
+
+    source_file%built = .true.
+
+end subroutine build_source
+
+end module fpm_backend