pax_global_header00006660000000000000000000000064136565341610014524gustar00rootroot0000000000000052 comment=67f1338ec62a889f0c57238e10e8bc902a56b88e gFTL-shared-1.0.7/000077500000000000000000000000001365653416100135715ustar00rootroot00000000000000gFTL-shared-1.0.7/.gitignore000066400000000000000000000000231365653416100155540ustar00rootroot00000000000000# Prerequisites *~ gFTL-shared-1.0.7/.gitmodules000066400000000000000000000001441365653416100157450ustar00rootroot00000000000000[submodule "gFTL"] path = extern/gFTL url = https://github.com/Goddard-Fortran-Ecosystem/gFTL.git gFTL-shared-1.0.7/CMakeLists.txt000066400000000000000000000045341365653416100163370ustar00rootroot00000000000000cmake_minimum_required(VERSION 3.0) # Note: the CMake project name is spelled slightly different than the # git project. This is to allow superprojects to use an environment # variable to find gFTL-shared with find_package(). Env variables # cannot have hyphens, whereas both git and cmake do allow hyphens in # names. Unfortunately, I learned the intricacies of find_package() a # bit late in the game, and am trying to avoid relocating the git repo. # # Names/paths that are derived from the CMake project will all have # "GFTL_SHARED" as their base name (and all caps). Targets such as # the library gftl-shared retain the hyphen (and lower case) project (GFTL_SHARED VERSION 1.0.7 LANGUAGES Fortran) # Most users of this software do not (should not?) have permissions to # install in the cmake default of /usr/local (or equiv on other os's). # Below, the default is changed to a directory within the build tree # unless the user explicitly sets CMAKE_INSTALL_PREFIX in the cache. if (CMAKE_INSTALL_PREFIX_INITIALIZED_TO_DEFAULT) set (CMAKE_INSTALL_PREFIX "${CMAKE_BINARY_DIR}/installed" CACHE PATH "default install path" FORCE ) endif() if (POLICY CMP0076) cmake_policy(SET CMP0076 NEW) endif() set(CMAKE_POSITION_INDEPENDENT_CODE ON) set(CMAKE_MODULE_PATH "${GFTL_SHARED_SOURCE_DIR}/cmake" ${CMAKE_MODULE_PATH}) include(${CMAKE_Fortran_COMPILER_ID} RESULT_VARIABLE found) include(check_intrinsic_kinds RESULT_VARIABLE found) add_subdirectory (extern) add_subdirectory (src) configure_file (GFTL_SHAREDConfig-version.cmake.in ${CMAKE_CURRENT_BINARY_DIR}/GFTL_SHAREDConfig-version.cmake @ONLY) configure_file (GFTL_SHAREDConfig.cmake.in ${CMAKE_CURRENT_BINARY_DIR}/GFTL_SHAREDConfig.cmake @ONLY) set (top_dir GFTL_SHARED-${GFTL_SHARED_VERSION_MAJOR}.${GFTL_SHARED_VERSION_MINOR}) install ( FILES ${CMAKE_CURRENT_BINARY_DIR}/GFTL_SHAREDConfig.cmake ${CMAKE_CURRENT_BINARY_DIR}/GFTL_SHAREDConfig-version.cmake DESTINATION "${top_dir}/cmake") # The following is needed for external projects using *nix make when # parent project builds gFTL-shared as a subproject. set (GFTL_SHARED_TOP_DIR "${CMAKE_INSTALL_PREFIX}/${top_dir}" CACHE PATH "") configure_file (GFTL_SHARED.mk.in ${CMAKE_CURRENT_BINARY_DIR}/GFTL_SHARED.mk @ONLY) install ( FILES ${CMAKE_CURRENT_BINARY_DIR}/GFTL_SHARED.mk ${CMAKE_CURRENT_BINARY_DIR}/GFTL_SHARED.mk DESTINATION "${top_dir}/include") gFTL-shared-1.0.7/ChangeLog.md000066400000000000000000000012671365653416100157500ustar00rootroot00000000000000# ChangeLog The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.0.0/), and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html). ## [Unreleased] ## [1.0.7] - 2020-05-12 - Trivial upate of submodule ## [1.0.6] - 2020-05-05 ### Changed - overrode the default name for Pair types in generated Maps Was tripping an XLF bug, but this change is also potentially useful to users. ## [1.0.5] - 2020-04-08 ### Changed - Enabled CMAKE_POSITION_INDEPENDENT_CODE ## [1.0.4] - 2020-04-06 ### Changed - updated gFTL to v1.2.5 ## [1.0.3] - 2019-11-07 ### Changed - updated gFTL to include memory leak workaround for Intel 18 gFTL-shared-1.0.7/GFTL_SHARED.mk.in000066400000000000000000000011621365653416100163110ustar00rootroot00000000000000# Include file for external projects using Unix Make instead of cmake. # Usage: # FFLAGS += -I$(GFTL_INCLUDE_DIR) -I$(GFTL_SHARED_INCLUDE_DIR) # LFLAGS += $(GFTL_SHARED_LIBRARIES) # gFTL GFTL_TOP_DIR := @GFTL_TOP_DIR@ include ${GFTL_TOP_DIR}/include/GFTL.mk # gFTL-shared GFTL_SHARED_INSTALL_PREFIX := @CMAKE_INSTALL_PREFIX@ GFTL_SHARED_VERSION := @GFTL_SHARED_VERSION_MAJOR@.@GFTL_SHARED_VERSION_MINOR@ GFTL_SHARED_TOP_DIR := $(GFTL_SHARED_INSTALL_PREFIX)/GFTL_SHARED-$(GFTL_SHARED_VERSION) GFTL_SHARED_INCLUDE_DIR := $(GFTL_SHARED_TOP_DIR)/include GFTL_SHARED_LIBRARIES := -L$(GFTL_SHARED_TOP_DIR)/lib -lgftl-shared gFTL-shared-1.0.7/GFTL_SHAREDConfig-version.cmake.in000066400000000000000000000012531365653416100215740ustar00rootroot00000000000000# my_library-config-version.cmake - checks version: major must match, minor must be less than or equal set(PACKAGE_VERSION @GFTL_SHARED_VERSION@) if (PACKAGE_FIND_VERSION_MAJOR EQUAL 0) set(PACKAGE_VERSION_COMPATIBLE TRUE) else() if("${PACKAGE_FIND_VERSION_MAJOR}" EQUAL "@GFTL_SHARED_VERSION_MAJOR@") if ("${PACKAGE_FIND_VERSION_MINOR}" EQUAL "@GFTL_SHARED_VERSION_MINOR@") set(PACKAGE_VERSION_EXACT TRUE) elseif("${PACKAGE_FIND_VERSION_MINOR}" LESS "@GFTL_SHARED_VERSION_MINOR@") set(PACKAGE_VERSION_COMPATIBLE TRUE) else() set(PACKAGE_VERSION_UNSUITABLE TRUE) endif() else() set(PACKAGE_VERSION_UNSUITABLE TRUE) endif() endif() gFTL-shared-1.0.7/GFTL_SHAREDConfig.cmake.in000066400000000000000000000004631365653416100201130ustar00rootroot00000000000000# Package configuration file get_filename_component (SELF_DIR "${CMAKE_CURRENT_LIST_FILE}" PATH) set (PREFIX ${SELF_DIR}/../..) set (GFTL_SHARED_TOP_DIR ${PREFIX}/GFTL_SHARED-@GFTL_SHARED_VERSION_MAJOR@.@GFTL_SHARED_VERSION_MINOR@ CACHE PATH "") include ("${GFTL_SHARED_TOP_DIR}/cmake/GFTL_SHARED.cmake") gFTL-shared-1.0.7/LICENSE000066400000000000000000000261351365653416100146050ustar00rootroot00000000000000 Apache License Version 2.0, January 2004 http://www.apache.org/licenses/ TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION 1. Definitions. "License" shall mean the terms and conditions for use, reproduction, and distribution as defined by Sections 1 through 9 of this document. "Licensor" shall mean the copyright owner or entity authorized by the copyright owner that is granting the License. "Legal Entity" shall mean the union of the acting entity and all other entities that control, are controlled by, or are under common control with that entity. For the purposes of this definition, "control" means (i) the power, direct or indirect, to cause the direction or management of such entity, whether by contract or otherwise, or (ii) ownership of fifty percent (50%) or more of the outstanding shares, or (iii) beneficial ownership of such entity. "You" (or "Your") shall mean an individual or Legal Entity exercising permissions granted by this License. "Source" form shall mean the preferred form for making modifications, including but not limited to software source code, documentation source, and configuration files. "Object" form shall mean any form resulting from mechanical transformation or translation of a Source form, including but not limited to compiled object code, generated documentation, and conversions to other media types. "Work" shall mean the work of authorship, whether in Source or Object form, made available under the License, as indicated by a copyright notice that is included in or attached to the work (an example is provided in the Appendix below). "Derivative Works" shall mean any work, whether in Source or Object form, that is based on (or derived from) the Work and for which the editorial revisions, annotations, elaborations, or other modifications represent, as a whole, an original work of authorship. For the purposes of this License, Derivative Works shall not include works that remain separable from, or merely link (or bind by name) to the interfaces of, the Work and Derivative Works thereof. "Contribution" shall mean any work of authorship, including the original version of the Work and any modifications or additions to that Work or Derivative Works thereof, that is intentionally submitted to Licensor for inclusion in the Work by the copyright owner or by an individual or Legal Entity authorized to submit on behalf of the copyright owner. For the purposes of this definition, "submitted" means any form of electronic, verbal, or written communication sent to the Licensor or its representatives, including but not limited to communication on electronic mailing lists, source code control systems, and issue tracking systems that are managed by, or on behalf of, the Licensor for the purpose of discussing and improving the Work, but excluding communication that is conspicuously marked or otherwise designated in writing by the copyright owner as "Not a Contribution." "Contributor" shall mean Licensor and any individual or Legal Entity on behalf of whom a Contribution has been received by Licensor and subsequently incorporated within the Work. 2. Grant of Copyright License. Subject to the terms and conditions of this License, each Contributor hereby grants to You a perpetual, worldwide, non-exclusive, no-charge, royalty-free, irrevocable copyright license to reproduce, prepare Derivative Works of, publicly display, publicly perform, sublicense, and distribute the Work and such Derivative Works in Source or Object form. 3. Grant of Patent License. Subject to the terms and conditions of this License, each Contributor hereby grants to You a perpetual, worldwide, non-exclusive, no-charge, royalty-free, irrevocable (except as stated in this section) patent license to make, have made, use, offer to sell, sell, import, and otherwise transfer the Work, where such license applies only to those patent claims licensable by such Contributor that are necessarily infringed by their Contribution(s) alone or by combination of their Contribution(s) with the Work to which such Contribution(s) was submitted. If You institute patent litigation against any entity (including a cross-claim or counterclaim in a lawsuit) alleging that the Work or a Contribution incorporated within the Work constitutes direct or contributory patent infringement, then any patent licenses granted to You under this License for that Work shall terminate as of the date such litigation is filed. 4. Redistribution. You may reproduce and distribute copies of the Work or Derivative Works thereof in any medium, with or without modifications, and in Source or Object form, provided that You meet the following conditions: (a) You must give any other recipients of the Work or Derivative Works a copy of this License; and (b) You must cause any modified files to carry prominent notices stating that You changed the files; and (c) You must retain, in the Source form of any Derivative Works that You distribute, all copyright, patent, trademark, and attribution notices from the Source form of the Work, excluding those notices that do not pertain to any part of the Derivative Works; and (d) If the Work includes a "NOTICE" text file as part of its distribution, then any Derivative Works that You distribute must include a readable copy of the attribution notices contained within such NOTICE file, excluding those notices that do not pertain to any part of the Derivative Works, in at least one of the following places: within a NOTICE text file distributed as part of the Derivative Works; within the Source form or documentation, if provided along with the Derivative Works; or, within a display generated by the Derivative Works, if and wherever such third-party notices normally appear. The contents of the NOTICE file are for informational purposes only and do not modify the License. You may add Your own attribution notices within Derivative Works that You distribute, alongside or as an addendum to the NOTICE text from the Work, provided that such additional attribution notices cannot be construed as modifying the License. You may add Your own copyright statement to Your modifications and may provide additional or different license terms and conditions for use, reproduction, or distribution of Your modifications, or for any such Derivative Works as a whole, provided Your use, reproduction, and distribution of the Work otherwise complies with the conditions stated in this License. 5. Submission of Contributions. Unless You explicitly state otherwise, any Contribution intentionally submitted for inclusion in the Work by You to the Licensor shall be under the terms and conditions of this License, without any additional terms or conditions. Notwithstanding the above, nothing herein shall supersede or modify the terms of any separate license agreement you may have executed with Licensor regarding such Contributions. 6. Trademarks. This License does not grant permission to use the trade names, trademarks, service marks, or product names of the Licensor, except as required for reasonable and customary use in describing the origin of the Work and reproducing the content of the NOTICE file. 7. Disclaimer of Warranty. Unless required by applicable law or agreed to in writing, Licensor provides the Work (and each Contributor provides its Contributions) on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied, including, without limitation, any warranties or conditions of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A PARTICULAR PURPOSE. You are solely responsible for determining the appropriateness of using or redistributing the Work and assume any risks associated with Your exercise of permissions under this License. 8. Limitation of Liability. In no event and under no legal theory, whether in tort (including negligence), contract, or otherwise, unless required by applicable law (such as deliberate and grossly negligent acts) or agreed to in writing, shall any Contributor be liable to You for damages, including any direct, indirect, special, incidental, or consequential damages of any character arising as a result of this License or out of the use or inability to use the Work (including but not limited to damages for loss of goodwill, work stoppage, computer failure or malfunction, or any and all other commercial damages or losses), even if such Contributor has been advised of the possibility of such damages. 9. Accepting Warranty or Additional Liability. While redistributing the Work or Derivative Works thereof, You may choose to offer, and charge a fee for, acceptance of support, warranty, indemnity, or other liability obligations and/or rights consistent with this License. However, in accepting such obligations, You may act only on Your own behalf and on Your sole responsibility, not on behalf of any other Contributor, and only if You agree to indemnify, defend, and hold each Contributor harmless for any liability incurred by, or claims asserted against, such Contributor by reason of your accepting any such warranty or additional liability. END OF TERMS AND CONDITIONS APPENDIX: How to apply the Apache License to your work. To apply the Apache License to your work, attach the following boilerplate notice, with the fields enclosed by brackets "[]" replaced with your own identifying information. (Don't include the brackets!) The text should be enclosed in the appropriate comment syntax for the file format. We also recommend that a file or class name and description of purpose be included on the same "printed page" as the copyright notice for easier identification within third-party archives. Copyright [yyyy] [name of copyright owner] Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with the License. You may obtain a copy of the License at http://www.apache.org/licenses/LICENSE-2.0 Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the specific language governing permissions and limitations under the License. gFTL-shared-1.0.7/README.md000066400000000000000000000001521365653416100150460ustar00rootroot00000000000000# gFTL-shared Provides common gFTL containers of Fortran intrinsic types that are encountered frequently. gFTL-shared-1.0.7/cmake/000077500000000000000000000000001365653416100146515ustar00rootroot00000000000000gFTL-shared-1.0.7/cmake/CMakeInstallation.cmake000066400000000000000000000016621365653416100212220ustar00rootroot00000000000000#----------------------------------------------------------------------------- # Add Target(s) to CMake Install for import into other projects #----------------------------------------------------------------------------- if (NOT gFTL_EXTERNALLY_CONFIGURED) if (gFTL_EXPORTED_TARGETS) install ( EXPORT ${gFTL-shared_EXPORTED_TARGETS} DESTINATION ${gFTL_INSTALL_CMAKE_DIR}/hdf5 # why here? FILE ${gFTL-shared_PACKAGE}-targets.cmake NAMESPACE ${gFTL-shared_PACKAGE} COMPONENT configinstall ) endif () #----------------------------------------------------------------------------- # Export all exported targets to the build tree for use by parent project #----------------------------------------------------------------------------- export ( TARGETS ${gFTL-shared_LIBRARIES_TO_EXPORT} FILE ${gFTL-shared_PACKAGE}-targets.cmake NAMESPACE ${gFTL-shared_PACKAGE}:: ) endif () gFTL-shared-1.0.7/cmake/GNU.cmake000066400000000000000000000004761365653416100163130ustar00rootroot00000000000000# Compiler specific flags for GNU Fortran compiler set(traceback "-fbacktrace") set(check_all "-fbounds-check") set(cpp "-cpp") set(CMAKE_Fortran_FLAGS_DEBUG "-O0 ${check_all}") set(CMAKE_Fortran_FLAGS_RELEASE "-O3") set(CMAKE_Fortran_FLAGS "-g ${cpp} ${traceback} -ffree-line-length-512") add_definitions(-D_GNU) gFTL-shared-1.0.7/cmake/Intel.cmake000066400000000000000000000011731365653416100167300ustar00rootroot00000000000000# Compiler specific flags for Intel Fortran compiler if(WIN32) set(no_optimize "-Od") set(check_all "-check:all") else() set(no_optimize "-O0") set(check_all "-check all") endif() set(disable_warning_for_long_names "-diag-disable 5462") set(traceback "-traceback") set(cpp "-cpp") set(save-temps "-save-temps") set(CMAKE_Fortran_Flags_ALL "${cpp} ${disable_warning_for_long_names}") set(CMAKE_Fortran_FLAGS_DEBUG "${no_optimize} ${check_all} ${save-temps} ${CMAKE_Fortran_Flags_ALL} -save-temps") set(CMAKE_Fortran_FLAGS_RELEASE "-O3 ${CMAKE_Fortran_Flags_ALL}") add_definitions(-D_INTEL) add_definitions(-D__ifort_18) gFTL-shared-1.0.7/cmake/NAG.cmake000066400000000000000000000005651365653416100162660ustar00rootroot00000000000000if (CMAKE_Fortran_COMPILER_VERSION VERSION_LESS 6.0) message(FATAL_ERROR "${CMAKE_Fortran_COMPILER_ID} version must be at least 6.0!") endif() set (DISABLE_FIELD_WIDTH_WARNING) set (CRAY_POINTER "") set (EXTENDED_SOURCE "-132") set (check_kinds "-kind=unique") set (CMAKE_Fortran_FLAGS_DEBUG "-O0 -g -C=all") # -C=undefined") set (CMAKE_Fortran_FLAGS_RELEASE "-O3 -g") gFTL-shared-1.0.7/cmake/build_submodule.cmake000066400000000000000000000021051365653416100210270ustar00rootroot00000000000000# Build subprojects in a standardized way. macro (build_submodule submodule) set(options) set(oneValueArgs TARGET PROJECT) set(multiValueArgs) cmake_parse_arguments(build_submodule "${options}" "${oneValueArgs}" "${multiValueArgs}" ${ARGN}) find_package(${build_submodule_PROJECT} QUIET) if (NOT ${project}_FOUND) if (NOT TARGET ${build_submodule_TARGET}) # from https://cliutils.gitlab.io/modern-cmake/chapters/projects/submodule.html find_package(Git QUIET) if (GIT_FOUND AND EXISTS "${PROJECT_SOURCE_DIR}/.git") option (GIT_SUBMODULE "Check submodules during build" ON) if (GIT_SUBMODULE) execute_process ( COMMAND ${GIT_EXECUTABLE} submodule update --init --recursive WORKING_DIRECTORY ${CMAKE_CURRENT_SOURCE_DIR} RESULT_VARIABLE GIT_SUBMODULE_RESULT ) if (NOT GIT_SUBMODULE_RESULT EQUAL "0") message(FATAL_ERROR "git submodule update --init failed with ${GIT_SUBMODULE_RESULT}, please checkout submodules") endif () endif () endif () add_subdirectory(${submodule}) endif () endif() endmacro() gFTL-shared-1.0.7/cmake/check_intrinsic_kinds.cmake000066400000000000000000000026151365653416100222060ustar00rootroot00000000000000include (fortran_try) CHECK_Fortran_SOURCE_RUN ( ${CMAKE_CURRENT_LIST_DIR}/trial_sources/LOGICAL_DEFAULT_KIND.F90 _LOGICAL_DEFAULT_KIND ) CHECK_Fortran_SOURCE_RUN ( ${CMAKE_CURRENT_LIST_DIR}/trial_sources/INT_DEFAULT_KIND.F90 _INT_DEFAULT_KIND ) foreach (kind 8 16 32 64) set(CMAKE_REQUIRED_FLAGS = -fpp) set(CMAKE_REQUIRED_DEFINITIONS -D_KIND=INT${kind}) CHECK_Fortran_SOURCE_RUN ( ${CMAKE_CURRENT_LIST_DIR}/trial_sources/INT_KIND.F90 _ISO_INT${kind} ) endforeach() CHECK_Fortran_SOURCE_RUN ( ${CMAKE_CURRENT_LIST_DIR}/trial_sources/REAL_DEFAULT_KIND.F90 _REAL_DEFAULT_KIND ) CHECK_Fortran_SOURCE_RUN ( ${CMAKE_CURRENT_LIST_DIR}/trial_sources/DOUBLE_DEFAULT_KIND.F90 _DOUBLE_DEFAULT_KIND ) foreach (kind 32 64 128) set(CMAKE_REQUIRED_FLAGS = -fpp) set(CMAKE_REQUIRED_DEFINITIONS -D_KIND=REAL${kind}) try_compile ( code_compiles ${GFTL_SHARED_BINARY_DIR} ${CMAKE_CURRENT_LIST_DIR}/trial_sources/REAL_KIND.F90 CMAKE_FLAGS "-DCOMPILE_DEFINITIONS=${CMAKE_REQUIRED_DEFINITIONS}") if (code_compiles) CHECK_Fortran_SOURCE_RUN ( ${CMAKE_CURRENT_LIST_DIR}/trial_sources/REAL_KIND.F90 _ISO_REAL${kind} ) endif () try_compile ( code_compiles ${GFTL_SHARED_BINARY_DIR} ${CMAKE_CURRENT_LIST_DIR}/trial_sources/REAL_KIND.F90 CMAKE_FLAGS "-DCOMPILE_DEFINITIONS=${CMAKE_REQUIRED_DEFINITIONS}") endforeach() gFTL-shared-1.0.7/cmake/fortran_try.cmake000066400000000000000000000023421365653416100202250ustar00rootroot00000000000000macro (CHECK_FORTRAN_SOURCE_RUN file var) try_run ( run compile ${CMAKE_CURRENT_BINARY_DIR} ${file} CMAKE_FLAGS "-DCOMPILE_DEFINITIONS=${CMAKE_REQUIRED_DEFINITIONS}" RUN_OUTPUT_VARIABLE ${var} ) # Successful runs return "0", which is opposite of CMake sense of "if": if (NOT run) string(STRIP ${${var}} ${var}) if (NOT CMAKE_REQUIRED_QUIET) message(STATUS "Performing Test ${var}: SUCCESS (value=${${var}})") endif () add_definitions(-D${var}=${${var}}) else () if (NOT CMAKE_REQUIRED_QUIET) message(STATUS "Performing Test ${var}: FAILURE") endif () endif () endmacro (CHECK_FORTRAN_SOURCE_RUN) macro (CHECK_FORTRAN_SOURCE_COMPILE file var) try_compile ( code_compiles ${CMAKE_CURRENT_BINARY_DIR} ${file} CMAKE_FLAGS "-DCOMPILE_DEFINITIONS=${CMAKE_REQUIRED_DEFINITIONS}" ) if (${code_compiles}) set(${var} SUCCESS) if (NOT CMAKE_REQUIRED_QUIET) message (STATUS "Performing Test ${var}: SUCCESS") endif () add_definitions(-D${var}) else () if (NOT CMAKE_REQUIRED_QUIET) message (STATUS "Performing Test ${var}: BUILD FAILURE") endif () endif() endmacro (CHECK_FORTRAN_SOURCE_COMPILE) gFTL-shared-1.0.7/cmake/trial_sources/000077500000000000000000000000001365653416100175275ustar00rootroot00000000000000gFTL-shared-1.0.7/cmake/trial_sources/DOUBLE_DEFAULT_KIND.F90000066400000000000000000000000631365653416100227310ustar00rootroot00000000000000program main print*,kind(1.d0) end program main gFTL-shared-1.0.7/cmake/trial_sources/INT_DEFAULT_KIND.F90000066400000000000000000000000601365653416100224060ustar00rootroot00000000000000program main print*,kind(1) end program main gFTL-shared-1.0.7/cmake/trial_sources/INT_KIND.F90000066400000000000000000000001751365653416100212510ustar00rootroot00000000000000program main use, intrinsic :: iso_fortran_env, only: _KIND integer(kind=_KIND) :: i print*, _KIND end program main gFTL-shared-1.0.7/cmake/trial_sources/LOGICAL_DEFAULT_KIND.F90000066400000000000000000000000651365653416100230330ustar00rootroot00000000000000program main print*,kind(.true.) end program main gFTL-shared-1.0.7/cmake/trial_sources/REAL_DEFAULT_KIND.F90000066400000000000000000000000611365653416100225000ustar00rootroot00000000000000program main print*,kind(1.) end program main gFTL-shared-1.0.7/cmake/trial_sources/REAL_KIND.F90000066400000000000000000000001721365653416100213370ustar00rootroot00000000000000program main use, intrinsic :: iso_fortran_env, only: _KIND real(kind=_KIND) :: x print*, _KIND end program main gFTL-shared-1.0.7/extern/000077500000000000000000000000001365653416100150765ustar00rootroot00000000000000gFTL-shared-1.0.7/extern/CMakeLists.txt000066400000000000000000000007511365653416100176410ustar00rootroot00000000000000# We attempt to use find_package() first for each dependency. But all # dependencies are also available as submodules. include(build_submodule) build_submodule(gFTL PROJECT GFTL TARGET gftl) add_library (extern-gftl-shared INTERFACE) target_link_libraries (extern-gftl-shared INTERFACE gftl gftl-shared) set (library_dest "lib/GFTL_SHARED-${GFTL_SHARED_VERSION_MAJOR}.${GFTL_SHARED_VERSION_MINOR}") install (TARGETS extern-gftl-shared EXPORT GFTL_SHARED DESTINATION "${library_dest}") gFTL-shared-1.0.7/extern/gFTL/000077500000000000000000000000001365653416100156725ustar00rootroot00000000000000gFTL-shared-1.0.7/src/000077500000000000000000000000001365653416100143605ustar00rootroot00000000000000gFTL-shared-1.0.7/src/CMakeLists.txt000066400000000000000000000075131365653416100171260ustar00rootroot00000000000000set(CMAKE_Fortran_MODULE_DIRECTORY ${GFTL_SHARED_BINARY_DIR}/mod) add_library(gftl-shared # Vector containers Integer32Vector.F90 Integer64Vector.F90 IntegerVector.F90 Real32Vector.F90 Real64Vector.F90 RealVector.F90 DoubleVector.F90 Complex32Vector.F90 Complex64Vector.F90 ComplexVector.F90 DoubleComplexVector.F90 LogicalVector.F90 StringVector.F90 UnlimitedVector.F90 # MapContainers StringInteger32Map.F90 StringInteger64Map.F90 StringIntegerMap.F90 StringReal32Map.F90 StringReal64Map.F90 StringRealMap.F90 StringDoubleMap.F90 StringComplex32Map.F90 StringComplex64Map.F90 StringComplexMap.F90 StringDoubleComplexMap.F90 StringLogicalMap.F90 StringStringMap.F90 StringUnlimitedMap.F90 Integer32Integer32Map.F90 Integer32Integer64Map.F90 Integer32IntegerMap.F90 Integer32Real32Map.F90 Integer32Real64Map.F90 Integer32RealMap.F90 Integer32DoubleMap.F90 Integer32Complex32Map.F90 Integer32Complex64Map.F90 Integer32ComplexMap.F90 Integer32DoubleComplexMap.F90 Integer32LogicalMap.F90 Integer32StringMap.F90 Integer32UnlimitedMap.F90 Integer64Integer32Map.F90 Integer64Integer64Map.F90 Integer64IntegerMap.F90 Integer64Real32Map.F90 Integer64Real64Map.F90 Integer64RealMap.F90 Integer64DoubleMap.F90 Integer64Complex32Map.F90 Integer64Complex64Map.F90 Integer64ComplexMap.F90 Integer64DoubleComplexMap.F90 Integer64LogicalMap.F90 Integer64StringMap.F90 Integer64UnlimitedMap.F90 IntegerInteger32Map.F90 IntegerInteger64Map.F90 IntegerIntegerMap.F90 IntegerReal32Map.F90 IntegerReal64Map.F90 IntegerRealMap.F90 IntegerDoubleMap.F90 IntegerComplex32Map.F90 IntegerComplex64Map.F90 IntegerComplexMap.F90 IntegerDoubleComplexMap.F90 IntegerLogicalMap.F90 IntegerStringMap.F90 IntegerUnlimitedMap.F90 ) if(_ISO_REAL128) target_sources(gftl-shared PRIVATE Real128Vector.F90) target_sources(gftl-shared PRIVATE Complex128Vector.F90) target_sources(gftl-shared PRIVATE StringReal128Map.F90) target_sources(gftl-shared PRIVATE StringComplex128Map.F90) target_sources(gftl-shared PRIVATE Integer32Real128Map.F90) target_sources(gftl-shared PRIVATE Integer32Complex128Map.F90) target_sources(gftl-shared PRIVATE Integer64Real128Map.F90) target_sources(gftl-shared PRIVATE Integer64Complex128Map.F90) target_sources(gftl-shared PRIVATE IntegerReal128Map.F90) target_sources(gftl-shared PRIVATE IntegerComplex128Map.F90) endif() if (_ISO_INT32 EQUAL _INT_DEFAULT_KIND) target_compile_definitions(gftl-shared PRIVATE _INT_DEFAULT_KIND_IS_INT32) endif () if (_ISO_INT64 EQUAL _INT_DEFAULT_KIND) target_compile_definitions(gftl-shared PRIVATE _INT_DEFAULT_KIND_IS_INT64) endif () if (_ISO_REAL32 EQUAL _REAL_DEFAULT_KIND) target_compile_definitions(gftl-shared PRIVATE _REAL_DEFAULT_KIND_IS_REAL32) endif () if (_ISO_REAL64 EQUAL _REAL_DEFAULT_KIND) target_compile_definitions(gftl-shared PRIVATE _REAL_DEFAULT_KIND_IS_REAL64) endif () if (_ISO_REAL64 EQUAL _DOUBLE_DEFAULT_KIND) target_compile_definitions(gftl-shared PRIVATE _DOUBLE_DEFAULT_KIND_IS_REAL64) endif () if (_ISO_REAL128) if (_ISO_REAL128 EQUAL _DOUBLE_DEFAULT_KIND) target_compile_definitions(gftl-shared PRIVATE _DOUBLE_DEFAULT_KIND_IS_REAL128) endif () endif() set (dest "GFTL_SHARED-${GFTL_SHARED_VERSION_MAJOR}.${GFTL_SHARED_VERSION_MINOR}") target_include_directories (gftl-shared PUBLIC $ $ ) target_link_libraries (gftl-shared extern-gftl-shared) add_executable (demo.x demo.F90) target_link_libraries (demo.x gftl-shared) install (DIRECTORY ${GFTL_SHARED_BINARY_DIR}/mod/ DESTINATION ${dest}/include) install (TARGETS gftl-shared EXPORT GFTL_SHARED DESTINATION "${dest}/lib") install (EXPORT GFTL_SHARED DESTINATION "${dest}/cmake") gFTL-shared-1.0.7/src/Complex128Vector.F90000066400000000000000000000005041365653416100176640ustar00rootroot00000000000000module gFTL_Complex128Vector use, intrinsic :: iso_fortran_env, only: REAL128 #define _type type(complex(kind=REAL128)) #define _vector Complex128Vector #define _vectoriterator Complex128VectorIterator #include "templates/vector.inc" #undef _vectoriterator #undef _vector #undef _type end module gFTL_Complex128Vector gFTL-shared-1.0.7/src/Complex32Vector.F90000066400000000000000000000004761365653416100176060ustar00rootroot00000000000000module gFTL_Complex32Vector use, intrinsic :: iso_fortran_env, only: REAL32 #define _type type(complex(kind=REAL32)) #define _vector Complex32Vector #define _vectoriterator Complex32VectorIterator #include "templates/vector.inc" #undef _vectoriterator #undef _vector #undef _type end module gFTL_Complex32Vector gFTL-shared-1.0.7/src/Complex64Vector.F90000066400000000000000000000004761365653416100176130ustar00rootroot00000000000000module gFTL_Complex64Vector use, intrinsic :: iso_fortran_env, only: REAL64 #define _type type(complex(kind=REAL64)) #define _vector Complex64Vector #define _vectoriterator Complex64VectorIterator #include "templates/vector.inc" #undef _vectoriterator #undef _vector #undef _type end module gFTL_Complex64Vector gFTL-shared-1.0.7/src/ComplexVector.F90000066400000000000000000000012321365653416100174300ustar00rootroot00000000000000module gFTL_ComplexVector #if defined(_REAL_DEFAULT_KIND_IS_REAL32) use gFTL_Complex32Vector, only: ComplexVector => Complex32Vector use gFTL_Complex32Vector, only: ComplexVectorIterator => Complex32VectorIterator #elif defined(_REAL_DEFAULT_KIND_IS_REAL64) use gFTL_Complex64Vector, only: ComplexVector => Complex64Vector use gFTL_Complex64Vector, only: ComplexVectorIterator => Complex64VectorIterator #else # define _type type(complex) # define _vector ComplexVector # define _vectoriterator ComplexVectorIterator # include "templates/vector.inc" # undef _vectoriterator # undef _vector # undef _type #endif end module gFTL_ComplexVector gFTL-shared-1.0.7/src/DoubleComplexVector.F90000066400000000000000000000013421365653416100205650ustar00rootroot00000000000000module gFTL_DoubleComplexVector #if defined(_DOUBLE_DEFAULT_KIND_IS_REAL64) use gFTL_Complex64Vector, only: DoubleComplexVector => Complex64Vector use gFTL_Complex64Vector, only: DoubleComplexVectorIterator => Complex64VectorIterator #elif defined(_DOUBLE_DEFAULT_KIND_IS_REAL128) use gFTL_Complex64Vector, only: DoubleComplexVector => Complex128Vector use gFTL_Complex64Vector, only: DoubleComplexVectorIterator => Complex128VectorIterator #else # define _type type(complex(kind=kind(0.d0))) # define _vector DoubleComplexVector # define _vectoriterator DoubleComplexVectorIterator # include "templates/vector.inc" # undef _vectoriterator # undef _vector # undef _type #endif end module gFTL_DoubleComplexVector gFTL-shared-1.0.7/src/DoubleVector.F90000066400000000000000000000012151365653416100172340ustar00rootroot00000000000000module gFTL_DoubleVector #if defined(_DOUBLE_DEFAULT_KIND_IS_REAL64) use gFTL_Real64Vector, only: DoubleVector => Real64Vector use gFTL_Real64Vector, only: DoubleVectorIterator => Real64VectorIterator #elif defined (_DOUBLE_DEFAULT_KIND_IS_REAL128) use gFTL_Real128Vector, only: DoubleVector => Real128Vector use gFTL_Real128Vector, only: DoubleVectorIterator => Real128VectorIterator #else # define _type type(double precision) # define _vector DoubleVector # define _vectoriterator DoubleVectorIterator # include "templates/vector.inc" # undef _vectoriterator # undef _vector # undef _type #endif end module gFTL_DoubleVector gFTL-shared-1.0.7/src/Integer32Complex128Map.F90000066400000000000000000000007031365653416100206230ustar00rootroot00000000000000module gFTL_Integer32Complex128Map use, intrinsic:: iso_fortran_env, only: INT32, REAL128 #define _key type(integer(kind=INT32)) #define _value type(complex(kind=REAL128)) #define _map Integer32Complex128Map #define _iterator Integer32Complex128MapIterator #define _pair Integer32Complex128Pair #define _alt #include "templates/map.inc" #undef _alt #undef _iterator #undef _map #undef _value #undef _key end module gFTL_Integer32Complex128Map gFTL-shared-1.0.7/src/Integer32Complex32Map.F90000066400000000000000000000006741365653416100205440ustar00rootroot00000000000000module gFTL_Integer32Complex32Map use, intrinsic:: iso_fortran_env, only: INT32, REAL32 #define _key type(integer(kind=INT32)) #define _value type(complex(kind=REAL32)) #define _map Integer32Complex32Map #define _iterator Integer32Complex32MapIterator #define _pair Integer32Complex32Pair #define _alt #include "templates/map.inc" #undef _alt #undef _iterator #undef _map #undef _value #undef _key end module gFTL_Integer32Complex32Map gFTL-shared-1.0.7/src/Integer32Complex64Map.F90000066400000000000000000000006741365653416100205510ustar00rootroot00000000000000module gFTL_Integer32Complex64Map use, intrinsic:: iso_fortran_env, only: INT32, REAL64 #define _key type(integer(kind=INT32)) #define _value type(complex(kind=REAL64)) #define _map Integer32Complex64Map #define _iterator Integer32Complex64MapIterator #define _pair Integer32Complex64Pair #define _alt #include "templates/map.inc" #undef _alt #undef _iterator #undef _map #undef _value #undef _key end module gFTL_Integer32Complex64Map gFTL-shared-1.0.7/src/Integer32ComplexMap.F90000066400000000000000000000016231365653416100203720ustar00rootroot00000000000000module gFTL_Integer32ComplexMap #if defined(_REAL_DEFAULT_KIND_IS_REAL32) use gFTL_Integer32Complex32Map, only: Integer32ComplexMap => Integer32Complex32Map use gFTL_Integer32Complex32Map, only: Integer32ComplexMapIterator => Integer32Complex32MapIterator #elif defined(_REAL_DEFAULT_KIND_IS_REAL64) use gFTL_Integer32Complex64Map, only: Integer32ComplexMap => Integer32Complex64Map use gFTL_Integer32Complex64Map, only: Integer32ComplexMapIterator => Integer32Complex64MapIterator #else use, intrinsic :: iso_fortran_env, only: INT32 # define _key type(integer(kind=INT32)) # define _value type(complex) # define _map Integer32ComplexMap # define _iterator Integer32ComplexMapIterator # define _pair Integer32ComplexPair # define _alt # include "templates/map.inc" # undef _alt # undef _iterator # undef _map # undef _value # undef _key #endif end module gFTL_Integer32ComplexMap gFTL-shared-1.0.7/src/Integer32DoubleComplexMap.F90000066400000000000000000000017441365653416100215310ustar00rootroot00000000000000module gFTL_Integer32DoubleComplexMap #if defined(_DOUBLE_DEFAULT_KIND_IS_REAL64) use gFTL_Integer32Complex64Map, only: Integer32DoubleComplexMap => Integer32Complex64Map use gFTL_Integer32Complex64Map, only: Integer32DoubleComplexMapIterator => Integer32Complex64MapIterator #elif defined(_DOUBLE_DEFAULT_KIND_IS_REAL128) use gFTL_Integer32Complex128Map, only: Integer32DoubleComplexMap => Integer32Complex128Map use gFTL_Integer32Complex128Map, only: Integer32DoubleComplexMapIterator => Integer32Complex128MapIterator #else use, intrinsic :: iso_fortran_env, only: INT32 # define _key type(integer(kind=INT32)) # define _value type(complex(kind=kind(0.0d0))) # define _map Integer32DoubleComplexMap # define _iterator Integer32DoubleComplexMapIterator # define _pair Integer32DoubleComplexPair # define _alt # include "templates/map.inc" # undef _alt # undef _iterator # undef _map # undef _value # undef _key #endif end module gFTL_Integer32DoubleComplexMap gFTL-shared-1.0.7/src/Integer32DoubleMap.F90000066400000000000000000000016041365653416100201740ustar00rootroot00000000000000module gFTL_Integer32DoubleMap #if defined(_DOUBLE_DEFAULT_KIND_IS_REAL64) use gFTL_Integer32Real64Map, only: Integer32DoubleMap => Integer32Real64Map use gFTL_Integer32Real64Map, only: Integer32DoubleMapIterator => Integer32Real64MapIterator #elif defined(_DOUBLE_DEFAULT_KIND_IS_REAL128) use gFTL_Integer32Real128Map, only: Integer32DoubleMap => Integer32Real128Map use gFTL_Integer32Real128Map, only: Integer32DoubleMapIterator => Integer32Real128MapIterator #else use, intrinsic :: iso_fortran_env, only: INT32 # define _key type(integer(kind=INT32)) # define _value type(double precision) # define _map Integer32DoubleMap # define _iterator Integer32DoubleMapIterator # define _pair Integer32DoublePair # define _alt # include "templates/map.inc" # undef _alt # undef _iterator # undef _map # undef _value # undef _key #endif end module gFTL_Integer32DoubleMap gFTL-shared-1.0.7/src/Integer32Integer32Map.F90000066400000000000000000000006631365653416100205300ustar00rootroot00000000000000module gFTL_Integer32Integer32Map use, intrinsic:: iso_fortran_env, only: INT32 #define _key type(integer(kind=INT32)) #define _value type(integer(kind=INT32)) #define _map Integer32Integer32Map #define _iterator Integer32Integer32MapIterator #define _pair Integer32Integer32Pair #define _alt #include "templates/map.inc" #undef _alt #undef _iterator #undef _map #undef _value #undef _key end module gFTL_Integer32Integer32Map gFTL-shared-1.0.7/src/Integer32Integer64Map.F90000066400000000000000000000006721365653416100205350ustar00rootroot00000000000000module gFTL_Integer32Integer64Map use, intrinsic:: iso_fortran_env, only: INT32, INT64 #define _key type(integer(kind=INT32)) #define _value type(integer(kind=INT64)) #define _map Integer32Integer64Map #define _iterator Integer32Integer64MapIterator #define _pair Integer32Integer64Pair #define _alt #include "templates/map.inc" #undef _alt #undef _iterator #undef _map #undef _value #undef _key end module gFTL_Integer32Integer64Map gFTL-shared-1.0.7/src/Integer32IntegerMap.F90000066400000000000000000000016171365653416100203630ustar00rootroot00000000000000module gFTL_Integer32IntegerMap #if defined(_INT_DEFAULT_KIND_IS_INT32) use gFTL_Integer32Integer32Map, only: Integer32IntegerMap => Integer32Integer32Map use gFTL_Integer32Integer32Map, only: Integer32IntegerMapIterator => Integer32Integer32MapIterator #elif defined(_INT_DEFAULT_KIND_IS_INT64) use gFTL_Integer32Integer64Map, only: Integer32IntegerMap => Integer32Integer64Map use gFTL_Integer32Integer64Map, only: Integer32IntegerMapIterator => Integer32Integer64MapIterator #else use, intrinsic :: iso_fortran_env, only: INT32 # define _key type(integer(kind=INT32)) # define _value type(integer) # define _map Integer32IntegerMap # define _iterator Integer32IntegerMapIterator # define _pair Integer32IntegerPair # define _alt # include "templates/map.inc" # undef _alt # undef _iterator # undef _map # undef _value # undef _key #endif end module gFTL_Integer32IntegerMap gFTL-shared-1.0.7/src/Integer32LogicalMap.F90000066400000000000000000000006351365653416100203370ustar00rootroot00000000000000module gFTL_Integer32LogicalMap use, intrinsic:: iso_fortran_env, only: INT32 #define _key type(integer(kind=INT32)) #define _value type(logical) #define _map Integer32LogicalMap #define _iterator Integer32LogicalMapIterator #define _pair Integer32LogicalPair #define _alt #include "templates/map.inc" #undef _alt #undef _iterator #undef _map #undef _value #undef _key end module gFTL_Integer32LogicalMap gFTL-shared-1.0.7/src/Integer32Real128Map.F90000066400000000000000000000006611365653416100201020ustar00rootroot00000000000000module gFTL_Integer32Real128Map use, intrinsic:: iso_fortran_env, only: INT32, REAL128 #define _key type(integer(kind=INT32)) #define _value type(real(kind=REAL128)) #define _map Integer32Real128Map #define _iterator Integer32Real128MapIterator #define _pair Integer32Real128Pair #define _alt #include "templates/map.inc" #undef _alt #undef _iterator #undef _map #undef _value #undef _key end module gFTL_Integer32Real128Map gFTL-shared-1.0.7/src/Integer32Real32Map.F90000066400000000000000000000006521365653416100200140ustar00rootroot00000000000000module gFTL_Integer32Real32Map use, intrinsic:: iso_fortran_env, only: INT32, REAL32 #define _key type(integer(kind=INT32)) #define _value type(real(kind=REAL32)) #define _map Integer32Real32Map #define _iterator Integer32Real32MapIterator #define _pair Integer32Real32Pair #define _alt #include "templates/map.inc" #undef _alt #undef _iterator #undef _map #undef _value #undef _key end module gFTL_Integer32Real32Map gFTL-shared-1.0.7/src/Integer32Real64Map.F90000066400000000000000000000006521365653416100200210ustar00rootroot00000000000000module gFTL_Integer32Real64Map use, intrinsic:: iso_fortran_env, only: INT32, REAL64 #define _key type(integer(kind=INT32)) #define _value type(real(kind=REAL64)) #define _map Integer32Real64Map #define _iterator Integer32Real64MapIterator #define _pair Integer32Real64Pair #define _alt #include "templates/map.inc" #undef _alt #undef _iterator #undef _map #undef _value #undef _key end module gFTL_Integer32Real64Map gFTL-shared-1.0.7/src/Integer32RealMap.F90000066400000000000000000000015351365653416100176500ustar00rootroot00000000000000module gFTL_Integer32RealMap #if defined(_REAL_DEFAULT_KIND_IS_REAL32) use gFTL_Integer32Real32Map, only: Integer32RealMap => Integer32Real32Map use gFTL_Integer32Real32Map, only: Integer32RealMapIterator => Integer32Real32MapIterator #elif defined(_REAL_DEFAULT_KIND_IS_REAL64) use gFTL_Integer32Real64Map, only: Integer32RealMap => Integer32Real64Map use gFTL_Integer32Real64Map, only: Integer32RealMapIterator => Integer32Real64MapIterator #else use, intrinsic :: iso_fortran_env, only: INT32 # define _key type(integer(kind=INT32)) # define _value type(real) # define _map Integer32RealMap # define _iterator Integer32RealMapIterator # define _pair Integer32RealPair # define _alt # include "templates/map.inc" # undef _alt # undef _iterator # undef _map # undef _value # undef _key #endif end module gFTL_Integer32RealMap gFTL-shared-1.0.7/src/Integer32StringMap.F90000066400000000000000000000006531365653416100202330ustar00rootroot00000000000000module gFTL_Integer32StringMap use, intrinsic:: iso_fortran_env, only: INT32 #define _key type(integer(kind=INT32)) #include "types/value_deferredLengthString.inc" #define _map Integer32StringMap #define _iterator Integer32StringMapIterator #define _pair Integer32StringPair #define _alt #include "templates/map.inc" #undef _alt #undef _iterator #undef _map #undef _value #undef _key end module gFTL_Integer32StringMap gFTL-shared-1.0.7/src/Integer32UnlimitedMap.F90000066400000000000000000000006631365653416100207200ustar00rootroot00000000000000module gFTL_Integer32UnlimitedMap use, intrinsic:: iso_fortran_env, only: INT32 #define _key type(integer(kind=INT32)) #include "types/value_unlimitedPoly.inc" #define _map Integer32UnlimitedMap #define _iterator Integer32UnlimitedMapIterator #define _pair Integer32UnlimitedPair #define _alt #include "templates/map.inc" #undef _alt #undef _iterator #undef _map #undef _value #undef _key end module gFTL_Integer32UnlimitedMap gFTL-shared-1.0.7/src/Integer32Vector.F90000066400000000000000000000004741365653416100175720ustar00rootroot00000000000000module gFTL_Integer32Vector use, intrinsic :: iso_fortran_env, only: INT32 #define _type type(integer(kind=INT32)) #define _vector Integer32Vector #define _vectoriterator Integer32VectorIterator #include "templates/vector.inc" #undef _vectoriterator #undef _vector #undef _type end module gFTL_Integer32Vector gFTL-shared-1.0.7/src/Integer64Complex128Map.F90000066400000000000000000000007031365653416100206300ustar00rootroot00000000000000module gFTL_Integer64Complex128Map use, intrinsic:: iso_fortran_env, only: INT64, REAL128 #define _key type(integer(kind=INT64)) #define _value type(complex(kind=REAL128)) #define _map Integer64Complex128Map #define _iterator Integer64Complex128MapIterator #define _pair Integer64Complex128Pair #define _alt #include "templates/map.inc" #undef _alt #undef _iterator #undef _map #undef _value #undef _key end module gFTL_Integer64Complex128Map gFTL-shared-1.0.7/src/Integer64Complex32Map.F90000066400000000000000000000006741365653416100205510ustar00rootroot00000000000000module gFTL_Integer64Complex32Map use, intrinsic:: iso_fortran_env, only: INT64, REAL32 #define _key type(integer(kind=INT64)) #define _value type(complex(kind=REAL32)) #define _map Integer64Complex32Map #define _iterator Integer64Complex32MapIterator #define _pair Integer64Complex32Pair #define _alt #include "templates/map.inc" #undef _alt #undef _iterator #undef _map #undef _value #undef _key end module gFTL_Integer64Complex32Map gFTL-shared-1.0.7/src/Integer64Complex64Map.F90000066400000000000000000000006741365653416100205560ustar00rootroot00000000000000module gFTL_Integer64Complex64Map use, intrinsic:: iso_fortran_env, only: INT64, REAL64 #define _key type(integer(kind=INT64)) #define _value type(complex(kind=REAL64)) #define _map Integer64Complex64Map #define _iterator Integer64Complex64MapIterator #define _pair Integer64Complex64Pair #define _alt #include "templates/map.inc" #undef _alt #undef _iterator #undef _map #undef _value #undef _key end module gFTL_Integer64Complex64Map gFTL-shared-1.0.7/src/Integer64ComplexMap.F90000066400000000000000000000016231365653416100203770ustar00rootroot00000000000000module gFTL_Integer64ComplexMap #if defined(_REAL_DEFAULT_KIND_IS_REAL32) use gFTL_Integer64Complex32Map, only: Integer64ComplexMap => Integer64Complex32Map use gFTL_Integer64Complex32Map, only: Integer64ComplexMapIterator => Integer64Complex32MapIterator #elif defined(_REAL_DEFAULT_KIND_IS_REAL64) use gFTL_Integer64Complex64Map, only: Integer64ComplexMap => Integer64Complex64Map use gFTL_Integer64Complex64Map, only: Integer64ComplexMapIterator => Integer64Complex64MapIterator #else use, intrinsic :: iso_fortran_env, only: INT64 # define _key type(integer(kind=INT64)) # define _value type(complex) # define _map Integer64ComplexMap # define _iterator Integer64ComplexMapIterator # define _pair Integer64ComplexPair # define _alt # include "templates/map.inc" # undef _alt # undef _iterator # undef _map # undef _value # undef _key #endif end module gFTL_Integer64ComplexMap gFTL-shared-1.0.7/src/Integer64DoubleComplexMap.F90000066400000000000000000000017441365653416100215360ustar00rootroot00000000000000module gFTL_Integer64DoubleComplexMap #if defined(_DOUBLE_DEFAULT_KIND_IS_REAL64) use gFTL_Integer64Complex64Map, only: Integer64DoubleComplexMap => Integer64Complex64Map use gFTL_Integer64Complex64Map, only: Integer64DoubleComplexMapIterator => Integer64Complex64MapIterator #elif defined(_DOUBLE_DEFAULT_KIND_IS_REAL128) use gFTL_Integer64Complex128Map, only: Integer64DoubleComplexMap => Integer64Complex128Map use gFTL_Integer64Complex128Map, only: Integer64DoubleComplexMapIterator => Integer64Complex128MapIterator #else use, intrinsic :: iso_fortran_env, only: INT64 # define _key type(integer(kind=INT64)) # define _value type(complex(kind=kind(0.0d0))) # define _map Integer64DoubleComplexMap # define _iterator Integer64DoubleComplexMapIterator # define _pair Integer64DoubleComplexPair # define _alt # include "templates/map.inc" # undef _alt # undef _iterator # undef _map # undef _value # undef _key #endif end module gFTL_Integer64DoubleComplexMap gFTL-shared-1.0.7/src/Integer64DoubleMap.F90000066400000000000000000000016041365653416100202010ustar00rootroot00000000000000module gFTL_Integer64DoubleMap #if defined(_DOUBLE_DEFAULT_KIND_IS_REAL64) use gFTL_Integer64Real64Map, only: Integer64DoubleMap => Integer64Real64Map use gFTL_Integer64Real64Map, only: Integer64DoubleMapIterator => Integer64Real64MapIterator #elif defined(_DOUBLE_DEFAULT_KIND_IS_REAL128) use gFTL_Integer64Real128Map, only: Integer64DoubleMap => Integer64Real128Map use gFTL_Integer64Real128Map, only: Integer64DoubleMapIterator => Integer64Real128MapIterator #else use, intrinsic :: iso_fortran_env, only: INT64 # define _key type(integer(kind=INT64)) # define _value type(double precision) # define _map Integer64DoubleMap # define _iterator Integer64DoubleMapIterator # define _pair Integer64DoublePair # define _alt # include "templates/map.inc" # undef _alt # undef _iterator # undef _map # undef _value # undef _key #endif end module gFTL_Integer64DoubleMap gFTL-shared-1.0.7/src/Integer64Integer32Map.F90000066400000000000000000000006721365653416100205350ustar00rootroot00000000000000module gFTL_Integer64Integer32Map use, intrinsic:: iso_fortran_env, only: INT32, INT64 #define _key type(integer(kind=INT64)) #define _value type(integer(kind=INT32)) #define _map Integer64Integer32Map #define _iterator Integer64Integer32MapIterator #define _pair Integer64Integer32Pair #define _alt #include "templates/map.inc" #undef _alt #undef _iterator #undef _map #undef _value #undef _key end module gFTL_Integer64Integer32Map gFTL-shared-1.0.7/src/Integer64Integer64Map.F90000066400000000000000000000006631365653416100205420ustar00rootroot00000000000000module gFTL_Integer64Integer64Map use, intrinsic:: iso_fortran_env, only: INT64 #define _key type(integer(kind=INT64)) #define _value type(integer(kind=INT64)) #define _map Integer64Integer64Map #define _iterator Integer64Integer64MapIterator #define _pair Integer64Integer64Pair #define _alt #include "templates/map.inc" #undef _alt #undef _iterator #undef _map #undef _value #undef _key end module gFTL_Integer64Integer64Map gFTL-shared-1.0.7/src/Integer64IntegerMap.F90000066400000000000000000000016171365653416100203700ustar00rootroot00000000000000module gFTL_Integer64IntegerMap #if defined(_INT_DEFAULT_KIND_IS_INT32) use gFTL_Integer64Integer32Map, only: Integer64IntegerMap => Integer64Integer32Map use gFTL_Integer64Integer32Map, only: Integer64IntegerMapIterator => Integer64Integer32MapIterator #elif defined(_INT_DEFAULT_KIND_IS_INT64) use gFTL_Integer64Integer64Map, only: Integer64IntegerMap => Integer64Integer64Map use gFTL_Integer64Integer64Map, only: Integer64IntegerMapIterator => Integer64Integer64MapIterator #else use, intrinsic :: iso_fortran_env, only: INT64 # define _key type(integer(kind=INT64)) # define _value type(integer) # define _map Integer64IntegerMap # define _iterator Integer64IntegerMapIterator # define _pair Integer64IntegerPair # define _alt # include "templates/map.inc" # undef _alt # undef _iterator # undef _map # undef _value # undef _key #endif end module gFTL_Integer64IntegerMap gFTL-shared-1.0.7/src/Integer64LogicalMap.F90000066400000000000000000000006351365653416100203440ustar00rootroot00000000000000module gFTL_Integer64LogicalMap use, intrinsic:: iso_fortran_env, only: INT64 #define _key type(integer(kind=INT64)) #define _value type(logical) #define _map Integer64LogicalMap #define _iterator Integer64LogicalMapIterator #define _pair Integer64LogicalPair #define _alt #include "templates/map.inc" #undef _alt #undef _iterator #undef _map #undef _value #undef _key end module gFTL_Integer64LogicalMap gFTL-shared-1.0.7/src/Integer64Real128Map.F90000066400000000000000000000006611365653416100201070ustar00rootroot00000000000000module gFTL_Integer64Real128Map use, intrinsic:: iso_fortran_env, only: INT64, REAL128 #define _key type(integer(kind=INT64)) #define _value type(real(kind=REAL128)) #define _map Integer64Real128Map #define _iterator Integer64Real128MapIterator #define _pair Integer64Real128Pair #define _alt #include "templates/map.inc" #undef _alt #undef _iterator #undef _map #undef _value #undef _key end module gFTL_Integer64Real128Map gFTL-shared-1.0.7/src/Integer64Real32Map.F90000066400000000000000000000006521365653416100200210ustar00rootroot00000000000000module gFTL_Integer64Real32Map use, intrinsic:: iso_fortran_env, only: INT64, REAL32 #define _key type(integer(kind=INT64)) #define _value type(real(kind=REAL32)) #define _map Integer64Real32Map #define _iterator Integer64Real32MapIterator #define _pair Integer64Real32Pair #define _alt #include "templates/map.inc" #undef _alt #undef _iterator #undef _map #undef _value #undef _key end module gFTL_Integer64Real32Map gFTL-shared-1.0.7/src/Integer64Real64Map.F90000066400000000000000000000006521365653416100200260ustar00rootroot00000000000000module gFTL_Integer64Real64Map use, intrinsic:: iso_fortran_env, only: INT64, REAL64 #define _key type(integer(kind=INT64)) #define _value type(real(kind=REAL64)) #define _map Integer64Real64Map #define _iterator Integer64Real64MapIterator #define _pair Integer64Real64Pair #define _alt #include "templates/map.inc" #undef _alt #undef _iterator #undef _map #undef _value #undef _key end module gFTL_Integer64Real64Map gFTL-shared-1.0.7/src/Integer64RealMap.F90000066400000000000000000000015351365653416100176550ustar00rootroot00000000000000module gFTL_Integer64RealMap #if defined(_REAL_DEFAULT_KIND_IS_REAL32) use gFTL_Integer64Real32Map, only: Integer64RealMap => Integer64Real32Map use gFTL_Integer64Real32Map, only: Integer64RealMapIterator => Integer64Real32MapIterator #elif defined(_REAL_DEFAULT_KIND_IS_REAL64) use gFTL_Integer64Real64Map, only: Integer64RealMap => Integer64Real64Map use gFTL_Integer64Real64Map, only: Integer64RealMapIterator => Integer64Real64MapIterator #else use, intrinsic :: iso_fortran_env, only: INT64 # define _key type(integer(kind=INT64)) # define _value type(real) # define _map Integer64RealMap # define _iterator Integer64RealMapIterator # define _pair Integer64RealPair # define _alt # include "templates/map.inc" # undef _alt # undef _iterator # undef _map # undef _value # undef _key #endif end module gFTL_Integer64RealMap gFTL-shared-1.0.7/src/Integer64StringMap.F90000066400000000000000000000006531365653416100202400ustar00rootroot00000000000000module gFTL_Integer64StringMap use, intrinsic:: iso_fortran_env, only: INT64 #define _key type(integer(kind=INT64)) #include "types/value_deferredLengthString.inc" #define _map Integer64StringMap #define _iterator Integer64StringMapIterator #define _pair Integer64StringPair #define _alt #include "templates/map.inc" #undef _alt #undef _iterator #undef _map #undef _value #undef _key end module gFTL_Integer64StringMap gFTL-shared-1.0.7/src/Integer64UnlimitedMap.F90000066400000000000000000000006631365653416100207250ustar00rootroot00000000000000module gFTL_Integer64UnlimitedMap use, intrinsic:: iso_fortran_env, only: INT64 #define _key type(integer(kind=INT64)) #include "types/value_unlimitedPoly.inc" #define _map Integer64UnlimitedMap #define _iterator Integer64UnlimitedMapIterator #define _pair Integer64UnlimitedPair #define _alt #include "templates/map.inc" #undef _alt #undef _iterator #undef _map #undef _value #undef _key end module gFTL_Integer64UnlimitedMap gFTL-shared-1.0.7/src/Integer64Vector.F90000066400000000000000000000004741365653416100175770ustar00rootroot00000000000000module gFTL_Integer64Vector use, intrinsic :: iso_fortran_env, only: INT64 #define _type type(integer(kind=INT64)) #define _vector Integer64Vector #define _vectoriterator Integer64VectorIterator #include "templates/vector.inc" #undef _vectoriterator #undef _vector #undef _type end module gFTL_Integer64Vector gFTL-shared-1.0.7/src/IntegerComplex128Map.F90000066400000000000000000000016541365653416100204640ustar00rootroot00000000000000module gFTL_IntegerComplex128Map #if defined(_INT_DEFAULT_KIND_IS_INT32) use gFTL_Integer32Complex128Map, only: IntegerComplex128Map => Integer32Complex128Map use gFTL_Integer32Complex128Map, only: IntegerComplex128MapIterator => Integer32Complex128MapIterator #elif defined(_INT_DEFAULT_KIND_IS_INT64) use gFTL_Integer64Complex128Map, only: IntegerComplex128Map => Integer64Complex128Map use gFTL_Integer64Complex128Map, only: IntegerComplex128MapIterator => Integer64Complex128MapIterator #else use, intrinsic :: iso_fortran_env, only: REAL128 # define _key type(integer) # define _value type(complex(kind=REAL128)) # define _map IntegerComplex128Map # define _iterator IntegerComplex128MapIterator # define _pair IntegerComplex128Pair # define _alt # include "templates/map.inc" # undef _alt # undef _iterator # undef _map # undef _value # undef _key #endif end module gFTL_IntegerComplex128Map gFTL-shared-1.0.7/src/IntegerComplex32Map.F90000066400000000000000000000016311365653416100203710ustar00rootroot00000000000000module gFTL_IntegerComplex32Map #if defined(_INT_DEFAULT_KIND_IS_INT32) use gFTL_Integer32Complex32Map, only: IntegerComplex32Map => Integer32Complex32Map use gFTL_Integer32Complex32Map, only: IntegerComplex32MapIterator => Integer32Complex32MapIterator #elif defined(_INT_DEFAULT_KIND_IS_INT64) use gFTL_Integer64Complex32Map, only: IntegerComplex32Map => Integer64Complex32Map use gFTL_Integer64Complex32Map, only: IntegerComplex32MapIterator => Integer64Complex32MapIterator #else use, intrinsic :: iso_fortran_env, only: REAL32 # define _key type(integer) # define _value type(complex(kind=REAL32)) # define _map IntegerComplex32Map # define _iterator IntegerComplex32MapIterator # define _pair IntegerComplex32Pair # define _alt # include "templates/map.inc" # undef _alt # undef _iterator # undef _map # undef _value # undef _key #endif end module gFTL_IntegerComplex32Map gFTL-shared-1.0.7/src/IntegerComplex64Map.F90000066400000000000000000000016311365653416100203760ustar00rootroot00000000000000module gFTL_IntegerComplex64Map #if defined(_INT_DEFAULT_KIND_IS_INT32) use gFTL_Integer32Complex64Map, only: IntegerComplex64Map => Integer32Complex64Map use gFTL_Integer32Complex64Map, only: IntegerComplex64MapIterator => Integer32Complex64MapIterator #elif defined(_INT_DEFAULT_KIND_IS_INT64) use gFTL_Integer64Complex64Map, only: IntegerComplex64Map => Integer64Complex64Map use gFTL_Integer64Complex64Map, only: IntegerComplex64MapIterator => Integer64Complex64MapIterator #else use, intrinsic :: iso_fortran_env, only: REAL64 # define _key type(integer) # define _value type(complex(kind=REAL64)) # define _map IntegerComplex64Map # define _iterator IntegerComplex64MapIterator # define _pair IntegerComplex64Pair # define _alt # include "templates/map.inc" # undef _alt # undef _iterator # undef _map # undef _value # undef _key #endif end module gFTL_IntegerComplex64Map gFTL-shared-1.0.7/src/IntegerComplexMap.F90000066400000000000000000000014661365653416100202320ustar00rootroot00000000000000module gFTL_IntegerComplexMap #if defined(_INT_DEFAULT_KIND_IS_INT32) use gFTL_Integer32ComplexMap, only: IntegerComplexMap => Integer32ComplexMap use gFTL_Integer32ComplexMap, only: IntegerComplexMapIterator => Integer32ComplexMapIterator #elif defined(_INT_DEFAULT_KIND_IS_INT64) use gFTL_Integer64ComplexMap, only: IntegerComplexMap => Integer64ComplexMap use gFTL_Integer64ComplexMap, only: IntegerComplexMapIterator => Integer64ComplexMapIterator #else # define _key type(integer) # define _value type(complex) # define _map IntegerComplexMap # define _iterator IntegerComplexMapIterator # define _pair IntegerComplexPair # define _alt # include "templates/map.inc" # undef _alt # undef _iterator # undef _map # undef _value # undef _key #endif end module gFTL_IntegerComplexMap gFTL-shared-1.0.7/src/IntegerDoubleComplexMap.F90000066400000000000000000000016551365653416100213650ustar00rootroot00000000000000module gFTL_IntegerDoubleComplexMap #if defined(_INT_DEFAULT_KIND_IS_INT32) use gFTL_Integer32DoubleComplexMap, only: IntegerDoubleComplexMap => Integer32DoubleComplexMap use gFTL_Integer32DoubleComplexMap, only: IntegerDoubleComplexMapIterator => Integer32DoubleComplexMapIterator #elif defined(_INT_DEFAULT_KIND_IS_INT64) use gFTL_Integer64DoubleComplexMap, only: IntegerDoubleComplexMap => Integer64DoubleComplexMap use gFTL_Integer64DoubleComplexMap, only: IntegerDoubleComplexMapIterator => Integer64DoubleComplexMapIterator #else # define _key type(integer) # define _value type(complex(kind=kind(0.d0))) # define _map IntegerDoubleComplexMap # define _iterator IntegerDoubleComplexMapIterator # define _pair IntegerDoubleComplexPair # define _alt # include "templates/map.inc" # undef _alt # undef _iterator # undef _map # undef _value # undef _key #endif end module gFTL_IntegerDoubleComplexMap gFTL-shared-1.0.7/src/IntegerDoubleMap.F90000066400000000000000000000014561365653416100200340ustar00rootroot00000000000000module gFTL_IntegerDoubleMap #if defined(_INT_DEFAULT_KIND_IS_INT32) use gFTL_Integer32DoubleMap, only: IntegerDoubleMap => Integer32DoubleMap use gFTL_Integer32DoubleMap, only: IntegerDoubleMapIterator => Integer32DoubleMapIterator #elif defined(_INT_DEFAULT_KIND_IS_INT64) use gFTL_Integer64DoubleMap, only: IntegerDoubleMap => Integer64DoubleMap use gFTL_Integer64DoubleMap, only: IntegerDoubleMapIterator => Integer64DoubleMapIterator #else # define _key type(integer) # define _value type(double precision) # define _map IntegerDoubleMap # define _iterator IntegerDoubleMapIterator # define _pair IntegerDoublePair # define _alt # include "templates/map.inc" # undef _alt # undef _iterator # undef _map # undef _value # undef _key #endif end module gFTL_IntegerDoubleMap gFTL-shared-1.0.7/src/IntegerInteger32Map.F90000066400000000000000000000016171365653416100203630ustar00rootroot00000000000000module gFTL_IntegerInteger32Map #if defined(_INT_DEFAULT_KIND_IS_INT32) use gFTL_Integer32Integer32Map, only: IntegerInteger32Map => Integer32Integer32Map use gFTL_Integer32Integer32Map, only: IntegerInteger32MapIterator => Integer32Integer32MapIterator #elif defined(_INT_DEFAULT_KIND_IS_INT64) use gFTL_Integer64Integer32Map, only: IntegerInteger32Map => Integer64Integer32Map use gFTL_Integer64Integer32Map, only: IntegerInteger32MapIterator => Integer64Integer32MapIterator #else use, intrinsic :: iso_fortran_env, only: INT32 # define _key type(integer) # define _value type(integer(kind=INT32)) # define _map IntegerInteger32Map # define _iterator IntegerInteger32MapIterator # define _pair IntegerInteger32Pair # define _alt # include "templates/map.inc" # undef _alt # undef _iterator # undef _map # undef _value # undef _key #endif end module gFTL_IntegerInteger32Map gFTL-shared-1.0.7/src/IntegerInteger64Map.F90000066400000000000000000000016171365653416100203700ustar00rootroot00000000000000module gFTL_IntegerInteger64Map #if defined(_INT_DEFAULT_KIND_IS_INT32) use gFTL_Integer32Integer64Map, only: IntegerInteger64Map => Integer32Integer64Map use gFTL_Integer32Integer64Map, only: IntegerInteger64MapIterator => Integer32Integer64MapIterator #elif defined(_INT_DEFAULT_KIND_IS_INT64) use gFTL_Integer64Integer64Map, only: IntegerInteger64Map => Integer64Integer64Map use gFTL_Integer64Integer64Map, only: IntegerInteger64MapIterator => Integer64Integer64MapIterator #else use, intrinsic :: iso_fortran_env, only: INT64 # define _key type(integer) # define _value type(integer(kind=INT64)) # define _map IntegerInteger64Map # define _iterator IntegerInteger64MapIterator # define _pair IntegerInteger64Pair # define _alt # include "templates/map.inc" # undef _alt # undef _iterator # undef _map # undef _value # undef _key #endif end module gFTL_IntegerInteger64Map gFTL-shared-1.0.7/src/IntegerIntegerMap.F90000066400000000000000000000014761365653416100202210ustar00rootroot00000000000000module gFTL_IntegerIntegerMap #if defined(_INT_DEFAULT_KIND_IS_INT32) use gFTL_Integer32Integer32Map, only: IntegerIntegerMap => Integer32Integer32Map use gFTL_Integer32Integer32Map, only: IntegerIntegerMapIterator => Integer32Integer32MapIterator #elif defined(_INT_DEFAULT_KIND_IS_INT64) use gFTL_Integer64Integer64Map, only: IntegerIntegerMap => Integer64Integer64Map use gFTL_Integer64Integer64Map, only: IntegerIntegerMapIterator => Integer64Integer64MapIterator #else # define _key type(integer) # define _value type(integer) # define _map IntegerIntegerMap # define _iterator IntegerIntegerMapIterator # define _pair IntegerIntegerPair # define _alt # include "templates/map.inc" # undef _alt # undef _iterator # undef _map # undef _value # undef _key #endif end module gFTL_IntegerIntegerMap gFTL-shared-1.0.7/src/IntegerLogicalMap.F90000066400000000000000000000014561365653416100201740ustar00rootroot00000000000000module gFTL_IntegerLogicalMap #if defined(_INT_DEFAULT_KIND_IS_INT32) use gFTL_Integer32LogicalMap, only: IntegerLogicalMap => Integer32LogicalMap use gFTL_Integer32LogicalMap, only: IntegerLogicalMapIterator => Integer32LogicalMapIterator #elif defined(_INT_DEFAULT_KIND_IS_INT64) use gFTL_Integer64LogicalMap, only: IntegerLogicalMap => Integer64LogicalMap use gFTL_Integer64LogicalMap, only: IntegerLogicalMapIterator => Integer64LogicalMapIterator #else # define _key type(integer) # define _value type(logical) # define _map IntegerLogicalMap # define _iterator IntegerLogicalMapIterator # define _pair IntegerLogicalPair # define _alt # include "templates/map.inc" # undef _alt # undef _iterator # undef _map # undef _value # undef _key #endif end module gFTL_IntegerLogicalMap gFTL-shared-1.0.7/src/IntegerReal128Map.F90000066400000000000000000000015661365653416100177420ustar00rootroot00000000000000module gFTL_IntegerReal128Map #if defined(_INT_DEFAULT_KIND_IS_INT32) use gFTL_Integer32Real128Map, only: IntegerReal128Map => Integer32Real128Map use gFTL_Integer32Real128Map, only: IntegerReal128MapIterator => Integer32Real128MapIterator #elif defined(_INT_DEFAULT_KIND_IS_INT64) use gFTL_Integer64Real128Map, only: IntegerReal128Map => Integer64Real128Map use gFTL_Integer64Real128Map, only: IntegerReal128MapIterator => Integer64Real128MapIterator #else use, intrinsic :: iso_fortran_env, only: REAL128 # define _key type(integer) # define _value type(real(kind=REAL128)) # define _map IntegerReal128Map # define _iterator IntegerReal128MapIterator # define _pair IntegerReal128Pair # define _alt # include "templates/map.inc" # undef _alt # undef _iterator # undef _map # undef _value # undef _key #endif end module gFTL_IntegerReal128Map gFTL-shared-1.0.7/src/IntegerReal32Map.F90000066400000000000000000000015431365653416100176470ustar00rootroot00000000000000module gFTL_IntegerReal32Map #if defined(_INT_DEFAULT_KIND_IS_INT32) use gFTL_Integer32Real32Map, only: IntegerReal32Map => Integer32Real32Map use gFTL_Integer32Real32Map, only: IntegerReal32MapIterator => Integer32Real32MapIterator #elif defined(_INT_DEFAULT_KIND_IS_INT64) use gFTL_Integer64Real32Map, only: IntegerReal32Map => Integer64Real32Map use gFTL_Integer64Real32Map, only: IntegerReal32MapIterator => Integer64Real32MapIterator #else use, intrinsic :: iso_fortran_env, only: REAL32 # define _key type(integer) # define _value type(real(kind=REAL32)) # define _map IntegerReal32Map # define _iterator IntegerReal32MapIterator # define _pair IntegerReal32Pair # define _alt # include "templates/map.inc" # undef _alt # undef _iterator # undef _map # undef _value # undef _key #endif end module gFTL_IntegerReal32Map gFTL-shared-1.0.7/src/IntegerReal64Map.F90000066400000000000000000000015431365653416100176540ustar00rootroot00000000000000module gFTL_IntegerReal64Map #if defined(_INT_DEFAULT_KIND_IS_INT32) use gFTL_Integer32Real64Map, only: IntegerReal64Map => Integer32Real64Map use gFTL_Integer32Real64Map, only: IntegerReal64MapIterator => Integer32Real64MapIterator #elif defined(_INT_DEFAULT_KIND_IS_INT64) use gFTL_Integer64Real64Map, only: IntegerReal64Map => Integer64Real64Map use gFTL_Integer64Real64Map, only: IntegerReal64MapIterator => Integer64Real64MapIterator #else use, intrinsic :: iso_fortran_env, only: REAL64 # define _key type(integer) # define _value type(real(kind=REAL64)) # define _map IntegerReal64Map # define _iterator IntegerReal64MapIterator # define _pair IntegerReal64Pair # define _alt # include "templates/map.inc" # undef _alt # undef _iterator # undef _map # undef _value # undef _key #endif end module gFTL_IntegerReal64Map gFTL-shared-1.0.7/src/IntegerRealMap.F90000066400000000000000000000014001365653416100174720ustar00rootroot00000000000000module gFTL_IntegerRealMap #if defined(_INT_DEFAULT_KIND_IS_INT32) use gFTL_Integer32RealMap, only: IntegerRealMap => Integer32RealMap use gFTL_Integer32RealMap, only: IntegerRealMapIterator => Integer32RealMapIterator #elif defined(_INT_DEFAULT_KIND_IS_INT64) use gFTL_Integer64RealMap, only: IntegerRealMap => Integer64RealMap use gFTL_Integer64RealMap, only: IntegerRealMapIterator => Integer64RealMapIterator #else # define _key type(integer) # define _value type(real) # define _map IntegerRealMap # define _iterator IntegerRealMapIterator # define _pair IntegerRealPair # define _alt # include "templates/map.inc" # undef _alt # undef _iterator # undef _map # undef _value # undef _key #endif end module gFTL_IntegerRealMap gFTL-shared-1.0.7/src/IntegerStringMap.F90000066400000000000000000000014621365653416100200650ustar00rootroot00000000000000module gFTL_IntegerStringMap #if defined(_INT_DEFAULT_KIND_IS_INT32) use gFTL_Integer32StringMap, only: IntegerStringMap => Integer32StringMap use gFTL_Integer32StringMap, only: IntegerStringMapIterator => Integer32StringMapIterator #elif defined(_INT_DEFAULT_KIND_IS_INT64) use gFTL_Integer64StringMap, only: IntegerStringMap => Integer64StringMap use gFTL_Integer64StringMap, only: IntegerStringMapIterator => Integer64StringMapIterator #else # define _key type(integer) # include "types/value_deferredLengthString.inc" # define _map IntegerStringMap # define _iterator IntegerStringMapIterator # define _pair IntegerStringPair # define _alt # include "templates/map.inc" # undef _alt # undef _iterator # undef _map # undef _value # undef _key #endif end module gFTL_IntegerStringMap gFTL-shared-1.0.7/src/IntegerUnlimitedMap.F90000066400000000000000000000015361365653416100205530ustar00rootroot00000000000000module gFTL_IntegerUnlimitedMap #if defined(_INT_DEFAULT_KIND_IS_INT32) use gFTL_Integer32UnlimitedMap, only: IntegerUnlimitedMap => Integer32UnlimitedMap use gFTL_Integer32UnlimitedMap, only: IntegerUnlimitedMapIterator => Integer32UnlimitedMapIterator #elif defined(_INT_DEFAULT_KIND_IS_INT64) use gFTL_Integer64UnlimitedMap, only: IntegerUnlimitedMap => Integer64UnlimitedMap use gFTL_Integer64UnlimitedMap, only: IntegerUnlimitedMapIterator => Integer64UnlimitedMapIterator #else # define _key type(integer) # include "types/value_unlimitedPoly.inc" # define _map IntegerUnlimitedMap # define _iterator IntegerUnlimitedMapIterator # define _pair IntegerUnlimitedPair # define _alt # include "templates/map.inc" # undef _alt # undef _iterator # undef _map # undef _value # undef _key #endif end module gFTL_IntegerUnlimitedMap gFTL-shared-1.0.7/src/IntegerVector.F90000066400000000000000000000012241365653416100174170ustar00rootroot00000000000000module gFTL_IntegerVector #if defined(_INT_DEFAULT_KIND_IS_INT32) use gFTL_Integer32Vector, only: IntegerVector => Integer32Vector use gFTL_Integer32Vector, only: IntegerVectorIterator => Integer32VectorIterator #elif defined(_INT_DEFAULT_KIND_IS_INT64) use gFTL_Integer64Vector, only: IntegerVector => Integer64Vector use gFTL_Integer64Vector, only: IntegerVectorIterator => Integer64VectorIterator #else # define _type type(integer) # define _vector IntegerVector # define _vectoriterator IntegerVectorIterator # include "templates/vector.inc" # undef _vectoriterator # undef _vector # undef _type #endif end module gFTL_IntegerVector gFTL-shared-1.0.7/src/LogicalVector.F90000066400000000000000000000003651365653416100174010ustar00rootroot00000000000000module gFTL_LogicalVector #define _type type(logical) #define _vector LogicalVector #define _vectoriterator LogicalVectorIterator #include "templates/vector.inc" #undef _vectoriterator #undef _vector #undef _type end module gFTL_LogicalVector gFTL-shared-1.0.7/src/Real128Vector.F90000066400000000000000000000004651365653416100171460ustar00rootroot00000000000000module gFTL_Real128Vector use, intrinsic :: iso_fortran_env, only: REAL128 #define _type type(real(kind=REAL128)) #define _vector Real128Vector #define _vectoriterator Real128VectorIterator #include "templates/vector.inc" #undef _vectoriterator #undef _vector #undef _type end module gFTL_Real128Vector gFTL-shared-1.0.7/src/Real32Vector.F90000066400000000000000000000004571365653416100170610ustar00rootroot00000000000000module gFTL_Real32Vector use, intrinsic :: iso_fortran_env, only: REAL32 #define _type type(real(kind=REAL32)) #define _vector Real32Vector #define _vectoriterator Real32VectorIterator #include "templates/vector.inc" #undef _vectoriterator #undef _vector #undef _type end module gFTL_Real32Vector gFTL-shared-1.0.7/src/Real64Vector.F90000066400000000000000000000004571365653416100170660ustar00rootroot00000000000000module gFTL_Real64Vector use, intrinsic :: iso_fortran_env, only: REAL64 #define _type type(real(kind=REAL64)) #define _vector Real64Vector #define _vectoriterator Real64VectorIterator #include "templates/vector.inc" #undef _vectoriterator #undef _vector #undef _type end module gFTL_Real64Vector gFTL-shared-1.0.7/src/RealVector.F90000066400000000000000000000011471365653416100167110ustar00rootroot00000000000000module gFTL_RealVector #if defined(_REAL_DEFAULT_KIND_IS_REAL32) use gFTL_Real32Vector, only: RealVector => Real32Vector use gFTL_Real32Vector, only: RealVectorIterator => Real32VectorIterator #elif defined(_REAL_DEFAULT_KIND_IS_REAL64) use gFTL_Real64Vector, only: RealVector => Real64Vector use gFTL_Real64Vector, only: RealVectorIterator => Real64VectorIterator #else # define _type type(real) # define _vector RealVector # define _vectoriterator RealVectorIterator # include "templates/vector.inc" # undef _vectoriterator # undef _vector # undef _type #endif end module gFTL_RealVector gFTL-shared-1.0.7/src/StringComplex128Map.F90000066400000000000000000000006641365653416100203350ustar00rootroot00000000000000module gFTL_StringComplex128Map use, intrinsic:: iso_fortran_env, only: REAL128 #include "types/key_deferredLengthString.inc" #define _value type(complex(kind=REAL128)) #define _map StringComplex128Map #define _iterator StringComplex128MapIterator #define _pair StringComplex128Pair #define _alt #include "templates/map.inc" #undef _alt #undef _iterator #undef _map #undef _value #undef _key end module gFTL_StringComplex128Map gFTL-shared-1.0.7/src/StringComplex32Map.F90000066400000000000000000000006551365653416100202470ustar00rootroot00000000000000module gFTL_StringComplex32Map use, intrinsic:: iso_fortran_env, only: REAL32 #include "types/key_deferredLengthString.inc" #define _value type(complex(kind=REAL32)) #define _map StringComplex32Map #define _iterator StringComplex32MapIterator #define _pair StringComplex32Pair #define _alt #include "templates/map.inc" #undef _alt #undef _iterator #undef _map #undef _value #undef _key end module gFTL_StringComplex32Map gFTL-shared-1.0.7/src/StringComplex64Map.F90000066400000000000000000000006551365653416100202540ustar00rootroot00000000000000module gFTL_StringComplex64Map use, intrinsic:: iso_fortran_env, only: REAL64 #include "types/key_deferredLengthString.inc" #define _value type(complex(kind=REAL64)) #define _map StringComplex64Map #define _iterator StringComplex64MapIterator #define _pair StringComplex64Pair #define _alt #include "templates/map.inc" #undef _alt #undef _iterator #undef _map #undef _value #undef _key end module gFTL_StringComplex64Map gFTL-shared-1.0.7/src/StringComplexMap.F90000066400000000000000000000014701365653416100200760ustar00rootroot00000000000000module gFTL_StringComplexMap #if defined(_REAL_DEFAULT_KIND_IS_REAL32) use gFTL_StringComplex32Map, only: StringComplexMap => StringComplex32Map use gFTL_StringComplex32Map, only: StringComplexMapIterator => StringComplex32MapIterator #elif defined(_REAL_DEFAULT_KIND_IS_REAL64) use gFTL_StringComplex64Map, only: StringComplexMap => StringComplex64Map use gFTL_StringComplex64Map, only: StringComplexMapIterator => StringComplex64MapIterator #else # include "types/key_deferredLengthString.inc" # define _value type(complex) # define _map StringComplexMap # define _iterator StringComplexMapIterator # define _pair StringComplexPair # define _alt # include "templates/map.inc" # undef _alt # undef _iterator # undef _map # undef _value # undef _key #endif end module gFTL_StringComplexMap gFTL-shared-1.0.7/src/StringDoubleComplexMap.F90000066400000000000000000000016111365653416100212260ustar00rootroot00000000000000module gFTL_StringDoubleComplexMap #if defined(_DOUBLE_DEFAULT_KIND_IS_REAL64) use gFTL_StringComplex64Map, only: StringDoubleComplexMap => StringComplex64Map use gFTL_StringComplex64Map, only: StringDoubleComplexMapIterator => StringComplex64MapIterator #elif defined(_DOUBLE_DEFAULT_KIND_IS_REAL128) use gFTL_StringComplex128Map, only: StringDoubleComplexMap => StringComplex128Map use gFTL_StringComplex128Map, only: StringDoubleComplexMapIterator => StringComplex128MapIterator #else # include "types/key_deferredLengthString.inc" # define _value type(complex(kind=kind(0.0d0))) # define _map StringDoubleComplexMap # define _iterator StringDoubleComplexMapIterator # define _pair StringDoubleComplexPair # define _alt # include "templates/map.inc" # undef _alt # undef _iterator # undef _map # undef _value # undef _key #endif end module gFTL_StringDoubleComplexMap gFTL-shared-1.0.7/src/StringDoubleMap.F90000066400000000000000000000014511365653416100177000ustar00rootroot00000000000000module gFTL_StringDoubleMap #if defined(_DOUBLE_DEFAULT_KIND_IS_REAL64) use gFTL_StringReal64Map, only: StringDoubleMap => StringReal64Map use gFTL_StringReal64Map, only: StringDoubleMapIterator => StringReal64MapIterator #elif defined(_DOUBLE_DEFAULT_KIND_IS_REAL128) use gFTL_StringReal128Map, only: StringDoubleMap => StringReal128Map use gFTL_StringReal128Map, only: StringDoubleMapIterator => StringReal128MapIterator #else # include "types/key_deferredLengthString.inc" # define _value type(double precision) # define _map StringDoubleMap # define _iterator StringDoubleMapIterator # define _pair StringDoublePair # define _alt # include "templates/map.inc" # undef _alt # undef _iterator # undef _map # undef _value # undef _key #endif end module gFTL_StringDoubleMap gFTL-shared-1.0.7/src/StringInteger32Map.F90000066400000000000000000000006531365653416100202330ustar00rootroot00000000000000module gFTL_StringInteger32Map use, intrinsic:: iso_fortran_env, only: INT32 #include "types/key_deferredLengthString.inc" #define _value type(integer(kind=INT32)) #define _map StringInteger32Map #define _iterator StringInteger32MapIterator #define _pair StringInteger32Pair #define _alt #include "templates/map.inc" #undef _alt #undef _iterator #undef _map #undef _value #undef _key end module gFTL_StringInteger32Map gFTL-shared-1.0.7/src/StringInteger64Map.F90000066400000000000000000000006531365653416100202400ustar00rootroot00000000000000module gFTL_StringInteger64Map use, intrinsic:: iso_fortran_env, only: INT64 #include "types/key_deferredLengthString.inc" #define _value type(integer(kind=INT64)) #define _map StringInteger64Map #define _iterator StringInteger64MapIterator #define _pair StringInteger64Pair #define _alt #include "templates/map.inc" #undef _alt #undef _iterator #undef _map #undef _value #undef _key end module gFTL_StringInteger64Map gFTL-shared-1.0.7/src/StringIntegerMap.F90000066400000000000000000000014641365653416100200670ustar00rootroot00000000000000module gFTL_StringIntegerMap #if defined(_INT_DEFAULT_KIND_IS_INT32) use gFTL_StringInteger32Map, only: StringIntegerMap => StringInteger32Map use gFTL_StringInteger32Map, only: StringIntegerMapIterator => StringInteger32MapIterator #elif defined(_INT_DEFAULT_KIND_IS_INT64) use gFTL_StringInteger64Map, only: StringIntegerMap => StringInteger64Map use gFTL_StringInteger64Map, only: StringIntegerMapIterator => StringInteger64MapIterator #else # include "types/key_deferredLengthString.inc" # define _value type(integer) # define _map StringIntegerMap # define _iterator StringIntegerMapIterator # define _pair StringIntegerPair # define _alt # include "templates/map.inc" # undef _alt # undef _iterator # undef _map # undef _value # undef _key #endif end module gFTL_StringIntegerMap gFTL-shared-1.0.7/src/StringLogicalMap.F90000066400000000000000000000005451365653416100200430ustar00rootroot00000000000000module gFTL_StringLogicalMap #include "types/key_deferredLengthString.inc" #define _value type(logical) #define _map StringLogicalMap #define _iterator StringLogicalMapIterator #define _pair StringLogicalPair #define _alt #include "templates/map.inc" #undef _alt #undef _iterator #undef _map #undef _value #undef _key end module gFTL_StringLogicalMap gFTL-shared-1.0.7/src/StringReal128Map.F90000066400000000000000000000006421365653416100176050ustar00rootroot00000000000000module gFTL_StringReal128Map use, intrinsic:: iso_fortran_env, only: REAL128 #include "types/key_deferredLengthString.inc" #define _value type(real(kind=REAL128)) #define _map StringReal128Map #define _iterator StringReal128MapIterator #define _pair StringReal128Pair #define _alt #include "templates/map.inc" #undef _alt #undef _iterator #undef _map #undef _value #undef _key end module gFTL_StringReal128Map gFTL-shared-1.0.7/src/StringReal32Map.F90000066400000000000000000000006331365653416100175170ustar00rootroot00000000000000module gFTL_StringReal32Map use, intrinsic:: iso_fortran_env, only: REAL32 #include "types/key_deferredLengthString.inc" #define _value type(real(kind=REAL32)) #define _map StringReal32Map #define _iterator StringReal32MapIterator #define _pair StringReal32Pair #define _alt #include "templates/map.inc" #undef _alt #undef _iterator #undef _map #undef _value #undef _key end module gFTL_StringReal32Map gFTL-shared-1.0.7/src/StringReal64Map.F90000066400000000000000000000006331365653416100175240ustar00rootroot00000000000000module gFTL_StringReal64Map use, intrinsic:: iso_fortran_env, only: REAL64 #include "types/key_deferredLengthString.inc" #define _value type(real(kind=REAL64)) #define _map StringReal64Map #define _iterator StringReal64MapIterator #define _pair StringReal64Pair #define _alt #include "templates/map.inc" #undef _alt #undef _iterator #undef _map #undef _value #undef _key end module gFTL_StringReal64Map gFTL-shared-1.0.7/src/StringRealMap.F90000066400000000000000000000014011365653416100173440ustar00rootroot00000000000000module gFTL_StringRealMap #if defined(_REAL_DEFAULT_KIND_IS_REAL32) use gFTL_StringReal32Map, only: StringRealMap => StringReal32Map use gFTL_StringReal32Map, only: StringRealMapIterator => StringReal32MapIterator #elif defined(_REAL_DEFAULT_KIND_IS_REAL64) use gFTL_StringReal64Map, only: StringRealMap => StringReal64Map use gFTL_StringReal64Map, only: StringRealMapIterator => StringReal64MapIterator #else # include "types/key_deferredLengthString.inc" # define _value type(real) # define _map StringRealMap # define _iterator StringRealMapIterator # define _pair StringRealPair # define _alt # include "templates/map.inc" # undef _alt # undef _iterator # undef _map # undef _value # undef _key #endif end module gFTL_StringRealMap gFTL-shared-1.0.7/src/StringStringMap.F90000066400000000000000000000005631365653416100177370ustar00rootroot00000000000000module gFTL_StringStringMap #include "types/key_deferredLengthString.inc" #include "types/value_deferredLengthString.inc" #define _map StringStringMap #define _iterator StringStringMapIterator #define _pair StringStringPair #define _alt #include "templates/map.inc" #undef _alt #undef _iterator #undef _map #undef _value #undef _key end module gFTL_StringStringMap gFTL-shared-1.0.7/src/StringUnlimitedMap.F90000066400000000000000000000005731365653416100204240ustar00rootroot00000000000000module gFTL_StringUnlimitedMap #include "types/key_deferredLengthString.inc" #include "types/value_unlimitedPoly.inc" #define _map StringUnlimitedMap #define _iterator StringUnlimitedMapIterator #define _pair StringUnlimitedPair #define _alt #include "templates/map.inc" #undef _alt #undef _iterator #undef _map #undef _value #undef _key end module gFTL_StringUnlimitedMap gFTL-shared-1.0.7/src/StringVector.F90000066400000000000000000000004011365653416100172640ustar00rootroot00000000000000module gFTL_StringVector #include "types/deferredLengthString.inc" #define _vector StringVector #define _vectoriterator StringVectorIterator #include "templates/vector.inc" #undef _vectoriterator #undef _vector #undef _type end module gFTL_StringVector gFTL-shared-1.0.7/src/UnlimitedVector.F90000066400000000000000000000004061365653416100177550ustar00rootroot00000000000000module gFTL_UnlimitedVector #include "types/unlimitedPoly.inc" #define _vector UnlimitedVector #define _vectoriterator UnlimitedVectorIterator #include "templates/vector.inc" #undef _vectoriterator #undef _vector #undef _type end module gFTL_UnlimitedVector gFTL-shared-1.0.7/src/demo.F90000066400000000000000000000322601365653416100155670ustar00rootroot00000000000000program main use, intrinsic :: iso_fortran_env, only: INT32 use, intrinsic :: iso_fortran_env, only: INT64 use, intrinsic :: iso_fortran_env, only: REAL32 use, intrinsic :: iso_fortran_env, only: REAL64 use, intrinsic :: iso_fortran_env, only: REAL128 use gFTL_Integer32Vector use gFTL_Integer64Vector use gFTL_IntegerVector use gFTL_Real32Vector use gFTL_Real64Vector use gFTL_Real128Vector use gFTL_RealVector use gFTL_DoubleVector use gFTL_Complex32Vector use gFTL_Complex64Vector use gFTL_Complex128Vector use gFTL_ComplexVector use gFTL_DoubleComplexVector use gFTL_LogicalVector use gFTL_StringVector use gFTL_UnlimitedVector use gFTL_Integer32Integer32Map use gFTL_Integer32Integer64Map use gFTL_Integer32IntegerMap use gFTL_Integer32Real32Map use gFTL_Integer32Real64Map use gFTL_Integer32Real128Map use gFTL_Integer32RealMap use gFTL_Integer32DoubleMap use gFTL_Integer32Complex32Map use gFTL_Integer32Complex64Map use gFTL_Integer32Complex128Map use gFTL_Integer32ComplexMap use gFTL_Integer32DoubleComplexMap use gFTL_Integer32LogicalMap use gFTL_Integer32StringMap use gFTL_Integer32UnlimitedMap use gFTL_Integer64Integer32Map use gFTL_Integer64Integer64Map use gFTL_Integer64IntegerMap use gFTL_Integer64Real32Map use gFTL_Integer64Real64Map use gFTL_Integer64Real128Map use gFTL_Integer64RealMap use gFTL_Integer64DoubleMap use gFTL_Integer64Complex32Map use gFTL_Integer64Complex64Map use gFTL_Integer64Complex128Map use gFTL_Integer64ComplexMap use gFTL_Integer64DoubleComplexMap use gFTL_Integer64LogicalMap use gFTL_Integer64StringMap use gFTL_Integer64UnlimitedMap use gFTL_IntegerInteger32Map use gFTL_IntegerInteger64Map use gFTL_IntegerIntegerMap use gFTL_IntegerReal32Map use gFTL_IntegerReal64Map use gFTL_IntegerReal128Map use gFTL_IntegerRealMap use gFTL_IntegerDoubleMap use gFTL_IntegerComplex32Map use gFTL_IntegerComplex64Map use gFTL_IntegerComplex128Map use gFTL_IntegerComplexMap use gFTL_IntegerDoubleComplexMap use gFTL_IntegerLogicalMap use gFTL_IntegerStringMap use gFTL_IntegerUnlimitedMap use gFTL_StringInteger32Map use gFTL_StringInteger64Map use gFTL_StringIntegerMap use gFTL_StringReal32Map use gFTL_StringReal64Map use gFTL_StringReal128Map use gFTL_StringRealMap use gFTL_StringDoubleMap use gFTL_StringComplex32Map use gFTL_StringComplex64Map use gFTL_StringComplex128Map use gFTL_StringComplexMap use gFTL_StringDoubleComplexMap use gFTL_StringLogicalMap use gFTL_StringStringMap use gFTL_StringUnlimitedMap implicit none type(Integer32Vector) :: Integer32_vector type(Integer64Vector) :: Integer64_vector type(IntegerVector) :: Integer_vector type(Real32Vector) :: Real32_vector type(Real64Vector) :: Real64_vector type(Real128Vector) :: Real128_vector type(RealVector) :: Real_vector type(DoubleVector) :: Double_vector type(Complex32Vector) :: Complex32_vector type(Complex64Vector) :: Complex64_vector type(Complex128Vector) :: Complex128_vector type(ComplexVector) :: Complex_vector type(DoubleComplexVector) :: DoubleComplex_vector type(LogicalVector) :: Logical_vector type(StringVector) :: String_vector type(UnlimitedVector) :: Unlimited_vector type(Integer32Integer32Map) :: Integer32Integer32_map type(Integer32Integer64Map) :: Integer32Integer64_map type(Integer32IntegerMap) :: Integer32Integer_map type(Integer32Real32Map) :: Integer32Real32_map type(Integer32Real64Map) :: Integer32Real64_map type(Integer32Real128Map) :: Integer32Real128_map type(Integer32RealMap) :: Integer32Real_map type(Integer32DoubleMap) :: Integer32Double_map type(Integer32Complex32Map) :: Integer32Complex32_map type(Integer32Complex64Map) :: Integer32Complex64_map type(Integer32Complex128Map) :: Integer32Complex128_map type(Integer32ComplexMap) :: Integer32Complex_map type(Integer32DoubleComplexMap) :: Integer32DoubleComplex_map type(Integer32LogicalMap) :: Integer32Logical_map type(Integer32StringMap) :: Integer32String_map type(Integer32UnlimitedMap) :: Integer32Unlimited_map type(Integer64Integer32Map) :: Integer64Integer32_map type(Integer64Integer64Map) :: Integer64Integer64_map type(Integer64IntegerMap) :: Integer64Integer_map type(Integer64Real32Map) :: Integer64Real32_map type(Integer64Real64Map) :: Integer64Real64_map type(Integer64Real128Map) :: Integer64Real128_map type(Integer64RealMap) :: Integer64Real_map type(Integer64DoubleMap) :: Integer64Double_map type(Integer64Complex32Map) :: Integer64Complex32_map type(Integer64Complex64Map) :: Integer64Complex64_map type(Integer64Complex128Map) :: Integer64Complex128_map type(Integer64ComplexMap) :: Integer64Complex_map type(Integer64DoubleComplexMap) :: Integer64DoubleComplex_map type(Integer64LogicalMap) :: Integer64Logical_map type(Integer64StringMap) :: Integer64String_map type(Integer64UnlimitedMap) :: Integer64Unlimited_map type(IntegerInteger32Map) :: IntegerInteger32_map type(IntegerInteger64Map) :: IntegerInteger64_map type(IntegerIntegerMap) :: IntegerInteger_map type(IntegerReal32Map) :: IntegerReal32_map type(IntegerReal64Map) :: IntegerReal64_map type(IntegerReal128Map) :: IntegerReal128_map type(IntegerRealMap) :: IntegerReal_map type(IntegerDoubleMap) :: IntegerDouble_map type(IntegerComplex32Map) :: IntegerComplex32_map type(IntegerComplex64Map) :: IntegerComplex64_map type(IntegerComplex128Map) :: IntegerComplex128_map type(IntegerComplexMap) :: IntegerComplex_map type(IntegerDoubleComplexMap) :: IntegerDoubleComplex_map type(IntegerLogicalMap) :: IntegerLogical_map type(IntegerStringMap) :: IntegerString_map type(IntegerUnlimitedMap) :: IntegerUnlimited_map type(StringInteger32Map) :: StringInteger32_map type(StringInteger64Map) :: StringInteger64_map type(StringIntegerMap) :: StringInteger_map type(StringReal32Map) :: StringReal32_map type(StringReal64Map) :: StringReal64_map type(StringReal128Map) :: StringReal128_map type(StringRealMap) :: StringReal_map type(StringDoubleMap) :: StringDouble_map type(StringComplex32Map) :: StringComplex32_map type(StringComplex64Map) :: StringComplex64_map type(StringComplex128Map) :: StringComplex128_map type(StringComplexMap) :: StringComplex_map type(StringDoubleComplexMap) :: StringDoubleComplex_map type(StringLogicalMap) :: StringLogical_map type(StringStringMap) :: StringString_map type(StringUnlimitedMap) :: StringUnlimited_map call Integer32_vector%push_back(1_INT32) call Integer64_vector%push_back(1_INT64) call Integer_vector%push_back(1) call Real32_vector%push_back(1._REAL32) call Real64_vector%push_back(1._REAL64) #ifdef _ISO_REAL128 call Real128_vector%push_back(1._REAL128) #endif call Real_vector%push_back(1.) call Double_vector%push_back(1.d0) call Complex32_vector%push_back((1._REAL32,2._REAL32)) call Complex64_vector%push_back((1._REAL64,2._REAL64)) #ifdef _ISO_REAL128 call Complex128_vector%push_back((1._REAL128,2._REAL128)) #endif call Complex_vector%push_back((1.,2.)) call DoubleComplex_vector%push_back((1.d0,2.d0)) call Logical_vector%push_back(.true.) call String_vector%push_back('fido') call Unlimited_vector%push_back(1) call Unlimited_vector%push_back(1.) call Unlimited_vector%push_back(.true.) call Unlimited_vector%push_back('string') call Integer32Integer32_map%insert(1_INT32, 2_INT32) call Integer32Integer64_map%insert(1_INT32, 2_INT64) call Integer32Integer_map%insert(1_INT32, 2) Integer32Integer_map = Integer32Integer32_map call Integer32Real32_map%insert(1_INT32, 2._REAL32) call Integer32Real64_map%insert(1_INT32, 2._REAL64) #ifdef _ISO_REAL128 call Integer32Real128_map%insert(1_INT32, 2._REAL128) #endif call Integer32Real_map%insert(1_INT32, 2.) call Integer32Double_map%insert(1_INT32, 2.d0) call Integer32Complex32_map%insert(1_INT32, (2._REAL32,3._REAL32)) call Integer32Complex64_map%insert(1_INT32, (2._REAL64,3._REAL64)) #ifdef _ISO_REAL128 call Integer32Complex128_map%insert(1_INT32, (2._REAL128,3._REAL128)) #endif call Integer32Complex_map%insert(1_INT32, (2.,3.)) call Integer32DoubleComplex_map%insert(1_INT32, (2.d0,3.d0)) call Integer32Logical_map%insert(1_INT32, .true.) call Integer32String_map%insert(1_INT32, 'spot') call Integer32Unlimited_map%insert(1_INT32,2) call Integer32Unlimited_map%insert(1_INT32,2.) call Integer32Unlimited_map%insert(1_INT32,'string') call Integer64Integer32_map%insert(1_INT64, 2_INT32) call Integer64Integer64_map%insert(1_INT64, 2_INT64) call Integer64Integer_map%insert(1_INT64, 2) call Integer64Real32_map%insert(1_INT64, 2._REAL32) call Integer64Real64_map%insert(1_INT64, 2._REAL64) #ifdef _ISO_REAL128 call Integer64Real128_map%insert(1_INT64, 2._REAL128) #endif call Integer64Real_map%insert(1_INT64, 2.) call Integer64Double_map%insert(1_INT64, 2.d0) call Integer64Complex32_map%insert(1_INT64, (2._REAL32,3._REAL32)) call Integer64Complex64_map%insert(1_INT64, (2._REAL64,3._REAL64)) #ifdef _ISO_REAL128 call Integer64Complex128_map%insert(1_INT64, (2._REAL128,3._REAL128)) #endif call Integer64Complex_map%insert(1_INT64, (2.,3.)) call Integer64DoubleComplex_map%insert(1_INT64, (2.d0,3.d0)) call Integer64Logical_map%insert(1_INT64, .true.) call Integer64String_map%insert(1_INT64, 'spot') call Integer64Unlimited_map%insert(1_INT64,2) call Integer64Unlimited_map%insert(1_INT64,2.) call Integer64Unlimited_map%insert(1_INT64,'string') call IntegerInteger32_map%insert(1, 2_INT32) call IntegerInteger64_map%insert(1, 2_INT64) call IntegerInteger_map%insert(1, 2) call IntegerReal32_map%insert(1, 2._REAL32) call IntegerReal64_map%insert(1, 2._REAL64) #ifdef _ISO_REAL128 call IntegerReal128_map%insert(1, 2._REAL128) #endif call IntegerReal_map%insert(1, 2.) call IntegerDouble_map%insert(1, 2.d0) call IntegerComplex32_map%insert(1, (2._REAL32,3._REAL32)) call IntegerComplex64_map%insert(1, (2._REAL64,3._REAL64)) #ifdef _ISO_REAL128 call IntegerComplex128_map%insert(1, (2._REAL128,3._REAL128)) #endif call IntegerComplex_map%insert(1, (2.,3.)) call IntegerDoubleComplex_map%insert(1, (2.d0,3.d0)) call IntegerLogical_map%insert(1, .true.) call IntegerString_map%insert(1, 'spot') call IntegerUnlimited_map%insert(1,2) call IntegerUnlimited_map%insert(1,2.) call IntegerUnlimited_map%insert(1,'string') call StringInteger32_map%insert('A', 2_INT32) call StringInteger64_map%insert('A', 2_INT64) call StringInteger_map%insert('A', 2) call StringReal32_map%insert('A', 2._REAL32) call StringReal64_map%insert('A', 2._REAL64) #ifdef _ISO_REAL128 call StringReal128_map%insert('A', 2._REAL128) #endif call StringReal_map%insert('A', 2.) call StringDouble_map%insert('A', 2.d0) call StringComplex32_map%insert('A', (2._REAL32,3._REAL32)) call StringComplex64_map%insert('A', (2._REAL64,3._REAL64)) #ifdef _ISO_REAL128 call StringComplex128_map%insert('A', (2._REAL128,3._REAL128)) #endif call StringComplex_map%insert('A', (2.,3.)) call StringDoubleComplex_map%insert('A', (2.d0,3.d0)) call StringLogical_map%insert('A', .true.) call StringString_map%insert('A', 'spot') call StringUnlimited_map%insert('A',2) call StringUnlimited_map%insert('A',2.) call StringUnlimited_map%insert('A','string') end program main