extract target platform from package and dependencies

Author: perazz

src/fpm.f90

@@ -19,6 +19,7 @@ module fpm
 use fpm_targets, only: targets_from_sources, build_target_t, build_target_ptr, &
                         FPM_TARGET_EXECUTABLE, get_library_dirs, filter_executable_targets
 use fpm_manifest, only : get_package_data, package_config_t
+use fpm_manifest_platform, only: platform_config_t
 use fpm_meta, only : resolve_metapackages
 use fpm_error, only : error_t, fatal_error, fpm_stop
 use fpm_toml, only: name_is_json
@@ -37,21 +38,25 @@ module fpm
 contains
 
 !> Constructs a valid fpm model from command line settings and the toml manifest.
-subroutine build_model(model, settings, package, error)
+subroutine build_model(model, settings, package_config, error)
     type(fpm_model_t), intent(out) :: model
     class(fpm_build_settings), intent(inout) :: settings
-    type(package_config_t), intent(inout), target :: package
+    type(package_config_t), intent(inout), target :: package_config
     type(error_t), allocatable, intent(out) :: error
 
     integer :: i, j
-    type(package_config_t), target  :: dependency
+    type(package_config_t), target  :: package, dependency_config, dependency
     type(package_config_t), pointer :: manifest
+    type(platform_config_t) :: target_platform
     character(len=:), allocatable :: file_name, lib_dir
     logical :: has_cpp
     logical :: duplicates_found, auto_exe, auto_example, auto_test
     type(string_t) :: include_dir
 
-    model%package_name = package%name
+    model%package_name = package_config%name
+
+    ! Set target OS to current OS (may be extended for cross-compilation in the future)
+    model%target_os = get_os_type()
 
     allocate(model%include_dirs(0))
     allocate(model%link_libraries(0))
@@ -68,19 +73,26 @@ subroutine build_model(model, settings, package, error)
             "Defaults for this compiler might be incorrect"
     end if
 
+    ! Extract the target platform for this build
+    target_platform = model%target_platform()
+    
     call new_compiler_flags(model,settings)
     model%build_dir            = settings%build_dir
     model%build_prefix         = join_path(settings%build_dir, basename(model%compiler%fc))
     model%include_tests        = settings%build_tests    
-    if (allocated(package%build)) then 
-        model%enforce_module_names = package%build%module_naming
-        model%module_prefix        = package%build%module_prefix
-    endif
-
+    
+    ! Extract the current package configuration request
+    package = package_config%export_config(target_platform)    
+    
     ! Resolve meta-dependencies into the package and the model
     call resolve_metapackages(model,package,settings,error)
     if (allocated(error)) return
 
+    if (allocated(package%build)) then 
+        model%enforce_module_names = package%build%module_naming
+        model%module_prefix        = package%build%module_prefix
+    endif      
+    
     ! Create dependencies
     call new_dependency_tree(model%deps, cache=join_path(settings%build_dir, "cache.toml"), &
     & path_to_config=settings%path_to_config, build_dir=settings%build_dir)
@@ -111,8 +123,12 @@ subroutine build_model(model, settings, package, error)
                 manifest => package
             else
 
-                call get_package_data(dependency, file_name, error, apply_defaults=.true.)
-                if (allocated(error)) exit                
+                ! Extract this dependency config
+                call get_package_data(dependency_config, file_name, error, apply_defaults=.true.)
+                if (allocated(error)) exit          
+                
+                ! Adapt it to the current profile/platform
+                dependency = dependency_config%export_config(target_platform)
 
                 manifest => dependency
             end if            

src/fpm/manifest/package.f90

@@ -46,6 +46,8 @@ module fpm_manifest_package
     use fpm_manifest_preprocess, only : preprocess_config_t, new_preprocessors
     use fpm_manifest_feature, only: feature_config_t, init_feature_components
     use fpm_manifest_feature_collection, only: feature_collection_t, get_default_features, new_collections
+    use fpm_manifest_platform, only: platform_config_t
+    use fpm_strings, only: string_t
     use fpm_filesystem, only : exists, getline, join_path
     use fpm_error, only : error_t, fatal_error, syntax_error, bad_name_error
     use tomlf, only : toml_table, toml_array, toml_key, toml_stat
@@ -94,6 +96,9 @@ module fpm_manifest_package
         procedure :: dump_to_toml
         procedure :: load_from_toml
 
+        !> Export package configuration with features applied
+        procedure :: export_config
+
     end type package_config_t
 
     character(len=*), parameter, private :: class_name = 'package_config_t'
@@ -535,5 +540,47 @@ subroutine load_from_toml(self, table, error)
 
      end subroutine load_from_toml
 
+    !> Export package configuration for a given (OS+compiler) platform
+    type(package_config_t) function export_config(self, platform, features) result(cfg)
+        
+        !> Instance of the package configuration  
+        class(package_config_t), intent(in) :: self
+        
+        !> Target platform
+        type(platform_config_t), intent(in) :: platform
+        
+        !> Optional list of features to apply (currently idle)
+        type(string_t), optional, intent(in) :: features(:)
+        
+        ! Copy the entire package configuration
+        cfg = self
+        
+        ! Ensure allocatable fields are always allocated with default values if not already set
+        if (.not. allocated(cfg%build)) then
+            allocate(cfg%build)
+            cfg%build%auto_executables = .true.
+            cfg%build%auto_examples = .true.
+            cfg%build%auto_tests = .true.
+            cfg%build%module_naming = .false.
+        end if
+        
+        if (.not. allocated(cfg%install)) then
+            allocate(cfg%install)
+            cfg%install%library = .false.
+            cfg%install%test = .false.
+        end if
+        
+        if (.not. allocated(cfg%fortran)) then
+            allocate(cfg%fortran)
+            cfg%fortran%implicit_typing = .false.
+            cfg%fortran%implicit_external = .false.
+            cfg%fortran%source_form = 'free'
+        end if
+        
+        ! TODO: Feature processing will be implemented here
+        ! For now, features parameter is ignored as requested
+        
+    end function export_config
+
 
 end module fpm_manifest_package

src/fpm_model.f90

@@ -44,9 +44,12 @@ module fpm_model
 use fpm_toml, only: serializable_t, set_value, set_list, get_value, &
                     & get_list, add_table, toml_key, add_array, set_string
 use fpm_error, only: error_t, fatal_error
-use fpm_environment, only: OS_WINDOWS,OS_MACOS
+use fpm_environment, only: OS_WINDOWS,OS_MACOS, get_os_type, OS_UNKNOWN, OS_LINUX, OS_CYGWIN, &
+                              OS_SOLARIS, OS_FREEBSD, OS_OPENBSD, OS_ALL, validate_os_name, OS_NAME, &
+                              match_os_type
 use fpm_manifest_preprocess, only: preprocess_config_t
 use fpm_manifest_fortran, only: fortran_config_t
+use fpm_manifest_platform, only: platform_config_t
 implicit none
 
 private
@@ -221,10 +224,16 @@ module fpm_model
     !> Prefix for all module names
     type(string_t) :: module_prefix
 
+    !> Target operating system
+    integer :: target_os = OS_UNKNOWN
+
     contains
 
         !> Get target link flags
         procedure :: get_package_libraries_link
+
+        !> Get target platform configuration
+        procedure :: target_platform
 
         !> Serialization interface
         procedure :: serializable_is_same => model_is_same
@@ -864,6 +873,7 @@ logical function model_is_same(this,that)
            if (.not.(this%include_tests.eqv.other%include_tests)) return
            if (.not.(this%enforce_module_names.eqv.other%enforce_module_names)) return
            if (.not.(this%module_prefix==other%module_prefix)) return
+           if (.not.(this%target_os==other%target_os)) return
 
        class default
           ! Not the same type
@@ -929,6 +939,10 @@ subroutine model_dump_to_toml(self, table, error)
     if (allocated(error)) return
     call set_string(table, "module-prefix", self%module_prefix, error, 'fpm_model_t')
     if (allocated(error)) return
+    
+    ! Serialize target OS as string
+    call set_string(table, "target-os", OS_NAME(self%target_os), error, 'fpm_model_t')
+    if (allocated(error)) return
 
     call add_table(table, "deps", ptr, error, 'fpm_model_t')
     if (allocated(error)) return
@@ -985,7 +999,9 @@ subroutine model_load_from_toml(self, table, error)
     type(toml_key), allocatable :: keys(:),pkg_keys(:)
     integer :: ierr, ii, jj
     type(toml_table), pointer :: ptr,ptr_pkg
-
+    character(:), allocatable :: os_string
+    logical :: is_valid
+        
     call table%get_keys(keys)
 
     call get_value(table, "package-name", self%package_name)
@@ -1072,8 +1088,35 @@ subroutine model_load_from_toml(self, table, error)
     if (allocated(error)) return
     call get_value(table, "module-prefix", self%module_prefix%s)
 
+    ! Load target OS from string and validate
+    call get_value(table, "target-os", os_string)
+    if (allocated(os_string)) then
+        ! Validate and convert OS string to integer
+        call validate_os_name(os_string, is_valid)
+        if (.not. is_valid) then
+            call fatal_error(error, "Invalid target OS: " // os_string)
+            return
+        end if
+        
+        self%target_os = match_os_type(os_string) 
+
+    else
+        ! Default to current OS if not specified
+        self%target_os = get_os_type()
+    end if
+
 end subroutine model_load_from_toml
 
+!> Get target platform configuration for the current model
+function target_platform(self) result(target)
+    class(fpm_model_t), intent(in) :: self
+    type(platform_config_t) :: target
+    
+    ! Initialize platform with compiler and target OS
+    target = platform_config_t(self%compiler%id, self%target_os)
+    
+end function target_platform
+
 function get_package_libraries_link(model, package_name, prefix, exclude_self, dep_IDs, error) result(r)
     class(fpm_model_t), intent(in) :: model
     character(*), intent(in) :: package_name