CMake: Added contrib/ada.

contrib/CMakeLists.txt

@@ -1,5 +1,13 @@
+option(ZLIB_BUILD_ADA "Enable building of Ada bindings" OFF)
 option(ZLIB_BUILD_MINIZIP "Enable building libminizip contrib library" OFF)
 
+if(ZLIB_BUILD_ADA)
+    set(ZLIBADA_BUILD_SHARED ${ZLIB_BUILD_SHARED})
+    set(ZLIBADA_BUILD_STATIC ${ZLIB_BUILD_STATIC})
+    set(ZLIBADA_BUILD_TESTING ${ZLIB_BUILD_TESTING})
+    add_subdirectory(ada/)
+endif(ZLIB_BUILD_ADA)
+
 if(ZLIB_BUILD_MINIZIP)
     set(MINIZIP_BUILD_SHARED ${ZLIB_BUILD_SHARED})
     set(MINIZIP_BUILD_STATIC ${ZLIB_BUILD_STATIC})

contrib/ada/CMakeLists.txt

@@ -0,0 +1,214 @@
+cmake_minimum_required(VERSION 3.12...3.31)
+
+set(CMAKE_MODULE_PATH "${CMAKE_CURRENT_SOURCE_DIR}/cmake/Modules")
+
+project(
+    zlibAda
+    VERSION 1.0.0
+    LANGUAGES ADA
+    DESCRIPTION "A library for creating zipfiles based in zlib"
+    HOMEPAGE_URL "https://www.zlib.net")
+
+option(ZLIBADA_BUILD_SHARED "Enable building ada bindings shared library" ON)
+option(ZLIBADA_BUILD_STATIC "Enable building ada bindings static library" ON)
+option(ZLIBADA_BUILD_TESTING "Enable building tests for ada bindings library" ON)
+
+if(WIN32 OR CYGWIN)
+    set(zlibAda_static_suffix "s")
+    set(CMAKE_DEBUG_POSTFIX "d")
+endif(WIN32 OR CYGWIN)
+
+if(NOT DEFINED ZLIB_BUILD_ADA)
+    if(ZLIBADA_BUILD_SHARED)
+        list(APPEND REQUIRED_COMPONENTS "shared")
+    endif(ZLIBADA_BUILD_SHARED)
+
+    if(ZLIBADA_BUILD_STATIC)
+        list(APPEND REQUIRED_COMPONENTS "static")
+    endif(ZLIB_BUILD_STATIC)
+
+    find_package(ZLIB REQUIRED COMPONENTS ${REQUIRED_COMPONENTS} CONFIG)
+endif(NOT DEFINED ZLIB_BUILD_ADA)
+
+function(ZLIBADA_findTestEnv testName)
+    set(testEnv "PATH=")
+
+    if(MSVC OR MINGW)
+        set(separator "\\\;")
+    else()
+        set(separator ":")
+    endif()
+
+    string(APPEND testEnv "$<TARGET_FILE_DIR:ZLIB::ZLIB>${separator}")
+    string(APPEND testEnv "$ENV{PATH}")
+
+    set_tests_properties(${testName} PROPERTIES ENVIRONMENT "${testEnv}")
+endfunction(ZLIBADA_findTestEnv testName)
+
+if(ZLIBADA_BUILD_SHARED)
+    ada_add_library(zlib-Ada SHARED
+        zlib-thin.adb
+        zlib.adb)
+
+    target_link_libraries(zlib-Ada
+        INTERFACE ZLIB::ZLIB)
+
+    ada_add_library(zlib-streams SHARED
+        zlib-streams.adb)
+
+    target_link_libraries(zlib-streams
+        PUBLIC
+            zlib-Ada)
+
+    ada_find_ali(zlib-streams)
+
+    if(ZLIBADA_BUILD_TESTING)
+        enable_testing()
+        ada_add_executable(ada-test test.adb)
+
+        target_link_libraries(ada-test
+            PRIVATE
+                zlib-Ada
+                zlib-streams)
+
+        ada_find_ali(ada-test)
+
+        add_test(NAME zlibAda_ada-test COMMAND ada-test)
+        set_tests_properties(zlibAda_ada-test PROPERTIES FIXTURES_REQUIRED ada_cleanup)
+
+        if(MSVC
+           OR MSYS
+           OR MINGW
+           OR CYGWIN)
+            zlibada_findtestenv(zlibAda_ada-test)
+        endif(
+            MSVC
+            OR MSYS
+            OR MINGW
+            OR CYGWIN)
+
+        ada_add_executable(buffer_demo buffer_demo.adb)
+
+        target_link_libraries(buffer_demo
+            PRIVATE
+                zlib-Ada)
+
+        ada_find_ali(buffer_demo)
+
+        add_test(NAME zlibAda_buffer-demo COMMAND buffer_demo)
+
+        if(MSVC
+           OR MSYS
+           OR MINGW
+           OR CYGWIN)
+            zlibada_findtestenv(zlibAda_buffer-demo)
+        endif(
+            MSVC
+            OR MSYS
+            OR MINGW
+            OR CYGWIN)
+
+        ada_add_executable(mtest mtest.adb)
+
+        target_link_libraries(mtest
+            PRIVATE
+                zlib-Ada)
+
+        ada_find_ali(mtest)
+
+        #Not adding test as this is an endless-loop
+
+        ada_add_executable(read read.adb)
+
+        target_link_libraries(read
+            PRIVATE
+                zlib-Ada)
+
+        ada_find_ali(read)
+
+        add_test(NAME zlibAda_read COMMAND read)
+
+        if(MSVC
+           OR MSYS
+           OR MINGW
+           OR CYGWIN)
+            zlibada_findtestenv(zlibAda_read)
+        endif(
+            MSVC
+            OR MSYS
+            OR MINGW
+            OR CYGWIN)
+    endif(ZLIBADA_BUILD_TESTING)
+endif(ZLIBADA_BUILD_SHARED)
+
+if(ZLIBADA_BUILD_STATIC)
+    ada_add_library(zlib-AdaStatic STATIC
+        zlib-thin.adb
+        zlib.adb)
+
+    target_link_libraries(zlib-AdaStatic
+        INTERFACE ZLIB::ZLIBSTATIC)
+
+    set_target_properties(zlib-AdaStatic
+        PROPERTIES OUTPUT_NAME zlib-Ada${zlibAda_static_suffix})
+
+    ada_add_library(zlib-streamsStatic STATIC
+        zlib-streams.adb)
+
+    target_link_libraries(zlib-streamsStatic
+        PUBLIC
+            zlib-AdaStatic)
+
+    ada_find_ali(zlib-streamsStatic)
+
+    if(ZLIBADA_BUILD_TESTING)
+        enable_testing()
+        ada_add_executable(ada-testStatic test.adb)
+
+        target_link_libraries(ada-testStatic
+            PRIVATE
+                zlib-AdaStatic
+                zlib-streamsStatic)
+
+        ada_find_ali(ada-testStatic)
+
+        add_test(NAME zlibAda_ada-testStatic COMMAND ada-testStatic)
+        set_tests_properties(zlibAda_ada-testStatic PROPERTIES FIXTURES_REQUIRED ada_cleanup)
+
+        ada_add_executable(buffer_demoStatic buffer_demo.adb)
+
+        target_link_libraries(buffer_demoStatic
+            PRIVATE
+                zlib-AdaStatic)
+
+        ada_find_ali(buffer_demoStatic)
+
+        add_test(NAME zlibAda-buffer-demoStatic COMMAND buffer_demoStatic)
+
+        ada_add_executable(mtestStatic mtest.adb)
+
+        target_link_libraries(mtestStatic
+            PRIVATE
+                zlib-AdaStatic)
+
+        ada_find_ali(mtestStatic)
+
+        # Not adding test as this is an endless-loop
+
+        ada_add_executable(readStatic read.adb)
+
+        target_link_libraries(readStatic
+            PRIVATE
+                zlib-AdaStatic)
+
+        ada_find_ali(readStatic)
+
+        add_test(NAME zlibAda_readStatic COMMAND readStatic)
+    endif(ZLIBADA_BUILD_TESTING)
+endif(ZLIBADA_BUILD_STATIC)
+
+if(ZLIBADA_BUILD_TESTING)
+    add_test(NAME zlibAda_cleanup COMMAND ${CMAKE_COMMAND} -E rm ${CMAKE_CURRENT_BINARY_DIR}/testzlib.in
+        ${CMAKE_CURRENT_BINARY_DIR}/testzlib.out ${CMAKE_CURRENT_BINARY_DIR}/testzlib.zlb)
+    set_tests_properties(zlibAda_cleanup PROPERTIES FIXTURES_CLEANUP ada_cleanup)
+endif(ZLIBADA_BUILD_TESTING)

contrib/ada/cmake/Modules/CMakeADACompiler.cmake.in

@@ -0,0 +1,23 @@
+set(CMAKE_ADA_COMPILER "@CMAKE_ADA_COMPILER@")
+set(CMAKE_ADA_COMPILER_ARG1 "@CMAKE_ADA_COMPILER_ARG1@")
+set(CMAKE_ADA_COMPILER_ID "@CMAKE_ADA_COMPILER_ID@")
+set(CMAKE_ADA_COMPILER_VERSION "@CMAKE_ADA_COMPILER_VERSION@")
+set(CMAKE_ADA_PLATFORM_ID "@CMAKE_ADA_PLATFORM_ID@")
+set(CMAKE_AR "@CMAKE_AR@")
+#set(CMAKE_RANLIB "@CMAKE_RANLIB@")
+#set(CMAKE_LINKER "@CMAKE_LINKER@")
+set(CMAKE_ADA_COMPILER_LOADED TRUE)
+set(CMAKE_ADA_COMPILER_WORKS @CMAKE_ADA_COMPILER_WORKS@)
+#set(CMAKE_ADA_ABI_COMPILED @CMAKE_ADA_ABI_COMPILED@)
+
+set(CMAKE_ADA_COMPILER_ENV_VAR "ADA")
+
+set(CMAKE_ADA_COMPILER_ID_RUN TRUE)
+set(CMAKE_ADA_SOURCE_FILE_EXTENSIONS adb;ADB)
+set(CMAKE_ADA_IGNORE_EXTENSIONS ;o;O;obj;OBJ;ali)
+
+set(CMAKE_ADA_BINDER_HELPER "@CMAKE_ADA_BINDER_HELPER@")
+set(CMAKE_ADA_COMPILER_HELPER "@CMAKE_ADA_COMPILER_HELPER@")
+set(CMAKE_ADA_EXE_LINK_HELPER "@CMAKE_ADA_EXE_LINK_HELPER@")
+set(CMAKE_ADA_SHARED_LINK_HELPER "@CMAKE_ADA_SHARED_LINK_HELPER@")
+set(CMAKE_ADA_STATIC_LINK_HELPER "@CMAKE_ADA_STATIC_LINK_HELPER@")

contrib/ada/cmake/Modules/CMakeADAInformation.cmake

@@ -0,0 +1,149 @@
+include(CMakeLanguageInformation)
+
+set(CMAKE_ADA_OUTPUT_EXTENSION .o)
+set(CMAKE_ADA_OUTPUT_EXTENSION_REPLACE TRUE)
+
+if(CMAKE_USER_MAKE_RULES_OVERRIDE)
+    include(${CMAKE_USER_MAKE_RULES_OVERRIDE} RESULT_VARIABLE _override)
+    set(CMAKE_USER_MAKE_RULES_OVERRIDE "${_override}")
+endif(CMAKE_USER_MAKE_RULES_OVERRIDE)
+
+
+if(CMAKE_USER_MAKE_RULES_OVERRIDE_ADA)
+    include(${CMAKE_USER_MAKE_RULES_OVERRIDE_ADA} RESULT_VARIABLE _override)
+    set(CMAKE_USER_MAKE_RULES_OVERRIDE_ADA "${_override}")
+endif(CMAKE_USER_MAKE_RULES_OVERRIDE_ADA)
+
+set(CMAKE_ADA_FLAGS_INIT "$ENV{ADAFLAGS} ${CMAKE_ADA_FLAGS_INIT}")
+
+string(APPEND CMAKE_ADA_FLAGS_INIT " ")
+string(APPEND CMAKE_ADA_FLAGS_DEBUG_INIT " -g")
+string(APPEND CMAKE_ADA_FLAGS_MINSIZEREL_INIT " -Os")
+string(APPEND CMAKE_ADA_FLAGS_RELEASE_INIT " -O3")
+string(APPEND CMAKE_ADA_FLAGS_RELWITHDEBINFO_INIT " -O2 -g")
+
+cmake_initialize_per_config_variable(CMAKE_ADA_FLAGS "Flags used by the Ada compiler")
+
+if(CMAKE_ADA_STANDARD_LIBRARIES_INIT)
+    set(CMAKE_ADA_STANDARD_LIBRARIES
+        "${CMAKE_ADA_STANDARD_LIBRARIES_INIT}"
+        CACHE
+        STRING "Libraries linked by default with all Ada applications.")
+    mark_as_advanced(CMAKE_ADA_STANDARD_LIBRARIES)
+endif(CMAKE_ADA_STANDARD_LIBRARIES_INIT)
+
+if(NOT CMAKE_ADA_COMPILER_LAUNCHER AND DEFINED ENV{CMAKE_ADA_COMPILER_LAUNCHER})
+    set(CMAKE_ADA_COMPILER_LAUNCHER
+        "$ENV{CMAKE_ADA_COMPILER_LAUNCHER}"
+        CACHE
+        STRING "Compiler launcher for Ada.")
+endif(NOT CMAKE_ADA_COMPILER_LAUNCHER AND DEFINED ENV{CMAKE_ADA_COMPILER_LAUNCHER})
+
+if(NOT CMAKE_ADA_LINKER_LAUNCHER AND DEFINED ENV{CMAKE_ADA_LINKER_LAUNCHER})
+    set(CMAKE_ADA_LINKER_LAUNCHER
+        "$ENV{CMAKE_ADA_LINKER_LAUNCHER}"
+        CACHE
+        STRING "Linker launcher for Ada.")
+endif(NOT CMAKE_ADA_LINKER_LAUNCHER AND DEFINED ENV{CMAKE_ADA_LINKER_LAUNCHER})
+
+include(CMakeCommonLanguageInclude)
+_cmake_common_language_platform_flags(ADA)
+
+if(NOT CMAKE_ADA_CREATE_SHARED_LIBRARY)
+    set(CMAKE_ADA_CREATE_SHARED_LIBRARY
+        "${CMAKE_ADA_BINDER_HELPER} <CMAKE_ADA_COMPILER> <OBJECTS> FLAGS <FLAGS> <LINK_FLAGS>"
+        "${CMAKE_ADA_SHARED_LINK_HELPER} <CMAKE_ADA_COMPILER> <TARGET> <OBJECTS> <LINK_LIBRARIES>")
+endif(NOT CMAKE_ADA_CREATE_SHARED_LIBRARY)
+
+if(NOT CMAKE_ADA_CREATE_STATIC_LIBRARY)
+    set(CMAKE_ADA_CREATE_STATIC_LIBRARY
+        "${CMAKE_ADA_STATIC_LINK_HELPER} ${CMAKE_AR} <TARGET> <OBJECTS>")
+endif(NOT CMAKE_ADA_CREATE_STATIC_LIBRARY)
+# create a C shared module just copy the shared library rule
+#if(NOT CMAKE_C_CREATE_SHARED_MODULE)
+#  set(CMAKE_C_CREATE_SHARED_MODULE ${CMAKE_C_CREATE_SHARED_LIBRARY})
+#endif()
+
+# Create a static archive incrementally for large object file counts.
+# If CMAKE_C_CREATE_STATIC_LIBRARY is set it will override these.
+#if(NOT DEFINED CMAKE_C_ARCHIVE_CREATE)
+#  set(CMAKE_C_ARCHIVE_CREATE "<CMAKE_AR> qc <TARGET> <LINK_FLAGS> <OBJECTS>")
+#endif()
+#if(NOT DEFINED CMAKE_C_ARCHIVE_APPEND)
+#  set(CMAKE_C_ARCHIVE_APPEND "<CMAKE_AR> q <TARGET> <LINK_FLAGS> <OBJECTS>")
+#endif()
+#if(NOT DEFINED CMAKE_C_ARCHIVE_FINISH)
+#  set(CMAKE_C_ARCHIVE_FINISH "<CMAKE_RANLIB> <TARGET>")
+#endif()
+
+if(NOT CMAKE_ADA_COMPILE_OBJECT)
+    set(CMAKE_ADA_COMPILE_OBJECT
+        "${CMAKE_ADA_COMPILER_HELPER} <CMAKE_ADA_COMPILER> <OBJECT_DIR> <SOURCE> <FLAGS>")
+endif(NOT CMAKE_ADA_COMPILE_OBJECT)
+
+if(NOT CMAKE_ADA_LINK_EXECUTABLE)
+    set(CMAKE_ADA_LINK_EXECUTABLE
+        "${CMAKE_ADA_BINDER_HELPER} <CMAKE_ADA_COMPILER> <OBJECTS> FLAGS <FLAGS> <LINK_FLAGS>"
+        "${CMAKE_ADA_EXE_LINK_HELPER} <CMAKE_ADA_COMPILER> <TARGET> <FLAGS> <CMAKE_C_LINK_FLAGS> <LINK_FLAGS> OBJ <OBJECTS> LIBS <LINK_LIBRARIES>")
+endif(NOT CMAKE_ADA_LINK_EXECUTABLE)
+
+function(ada_add_executable)
+    if(ARGC GREATER 1)
+        math(EXPR last_index "${ARGC} - 1")
+        foreach(source RANGE 1 ${last_index})
+            list(APPEND SOURCES ${ARGV${source}})
+            string(REPLACE ".adb" "" ali "${ARGV${source}}")
+            set(clean_file "CMakeFiles/${ARGV0}.dir/${ali}.ali")
+            list(APPEND CLEAN_FILES ${clean_file})
+            list(APPEND CLEAN_FILES b~${ali}.adb)
+            list(APPEND CLEAN_FILES b~${ali}.ads)
+            list(APPEND CLEAN_FILES b~${ali}.ali)
+            list(APPEND CLEAN_FILES b~${ali}.o)
+        endforeach(source RANGE 1 ${ARGC})
+
+        add_executable(${ARGV0} ${ARGV1} ${SOURCES})
+
+        set_target_properties(${ARGV0}
+            PROPERTIES
+                ADDITIONAL_CLEAN_FILES "${CLEAN_FILES}")
+    endif(ARGC GREATER 1)
+endfunction(ada_add_executable)
+
+function(ada_add_library)
+    if(ARGC GREATER 2)
+        math(EXPR last_index "${ARGC} - 1")
+        foreach(source RANGE 2 ${last_index})
+            list(APPEND SOURCES ${ARGV${source}})
+            string(REPLACE ".adb" "" ali "${ARGV${source}}")
+            set(clean_file "CMakeFiles/${ARGV0}.dir/${ali}.ali")
+            list(APPEND CLEAN_FILES ${clean_file})
+            list(APPEND CLEAN_FILES b~${ali}.adb)
+            list(APPEND CLEAN_FILES b~${ali}.ads)
+            list(APPEND CLEAN_FILES b~${ali}.ali)
+            list(APPEND CLEAN_FILES b~${ali}.o)
+        endforeach(source RANGE 2 ${ARGC})
+
+        add_library(${ARGV0} ${ARGV1} ${SOURCES})
+
+        set_target_properties(${ARGV0}
+            PROPERTIES
+                ADDITIONAL_CLEAN_FILES "${CLEAN_FILES};dummylib.adb;dummylib.ali;dummylib.o"
+                ALI_FLAG "-aO${CMAKE_CURRENT_BINARY_DIR}/CMakeFiles/${ARGV0}.dir/")
+    endif(ARGC GREATER 2)
+endfunction(ada_add_library)
+
+function(ada_find_ali)
+    get_target_property(link_libs ${ARGV0} LINK_LIBRARIES)
+
+    foreach(lib IN LISTS link_libs)
+        get_target_property(ali ${lib} ALI_FLAG)
+        string(APPEND FLAGS ${ali} " ")
+        unset(ali)
+    endforeach(lib IN LISTS link_libs)
+
+    set_target_properties(${ARGV0}
+        PROPERTIES
+            LINK_FLAGS ${FLAGS})
+endfunction(ada_find_ali)
+
+set(CMAKE_ADA_INFORMATION_LOADED TRUE)

contrib/ada/cmake/Modules/CMakeDetermineADACompiler.cmake

@@ -0,0 +1,33 @@
+include(${CMAKE_ROOT}/Modules/CMakeDetermineCompiler.cmake)
+
+# Load system-specific compiler preferences for this language.
+include(Platform/${CMAKE_SYSTEM_NAME}-Determine-Ada OPTIONAL)
+include(Platform/${CMAKE_SYSTEM_NAME}-Ada OPTIONAL)
+
+if(NOT CMAKE_ADA_COMPILER_NAMES)
+    set(CMAKE_ADA_COMPILER_NAMES gnat)
+
+    foreach(ver RANGE 11 99)
+        list(APPEND CMAKE_ADA_COMPILER_NAMES gnat-${ver})
+    endforeach(ver RANGE 11 99)
+endif(NOT CMAKE_ADA_COMPILER_NAMES)
+
+if(NOT CMAKE_ADA_COMPILER)
+    set(CMAKE_ADA_COMPILER_INIT NOTFOUND)
+    _cmake_find_compiler(ADA)
+else(NOT CMAKE_REAL_ADA_COMPILER)
+    _cmake_find_compiler_path(ADA)
+endif(NOT CMAKE_ADA_COMPILER)
+
+mark_as_advanced(CMAKE_ADA_COMPILER)
+set(CMAKE_ADA_COMPILER_ID "GNU")
+set(CMAKE_ADA_BINDER_HELPER "${CMAKE_COMMAND} -P ${CMAKE_CURRENT_SOURCE_DIR}/cmake/binder_helper.cmake")
+set(CMAKE_ADA_COMPILER_HELPER "${CMAKE_COMMAND} -P ${CMAKE_CURRENT_SOURCE_DIR}/cmake/compile_helper.cmake")
+set(CMAKE_ADA_EXE_LINK_HELPER "${CMAKE_COMMAND} -P ${CMAKE_CURRENT_SOURCE_DIR}/cmake/exe_link_helper.cmake")
+set(CMAKE_ADA_SHARED_LINK_HELPER "${CMAKE_COMMAND} -P ${CMAKE_CURRENT_SOURCE_DIR}/cmake/shared_link_helper.cmake")
+set(CMAKE_ADA_STATIC_LINK_HELPER "${CMAKE_COMMAND} -P ${CMAKE_CURRENT_SOURCE_DIR}/cmake/static_link_helper.cmake")
+
+configure_file(
+    ${CMAKE_CURRENT_SOURCE_DIR}/cmake/Modules/CMakeADACompiler.cmake.in
+    ${CMAKE_PLATFORM_INFO_DIR}/CMakeADACompiler.cmake
+    @ONLY)

contrib/ada/cmake/Modules/CMakeTestADACompiler.cmake

@@ -0,0 +1,46 @@
+include(CMakeTestCompilerCommon)
+unset(CMAKE_ADA_COMPILER_WORKS CACHE)
+
+if(NOT CMAKE_ADA_COMPILER_WORKS)
+    PrintTestCompilerStatus("ADA" "")
+    set(_ADA_TEST_FILE "${CMAKE_BINARY_DIR}/${CMAKE_FILES_DIRECTORY}/CMakeTmp/main.adb")
+
+    file(WRITE ${_ADA_TEST_FILE}
+        "with Ada.Text_IO; use Ada.Text_IO;\n"
+        "\n"
+        "procedure main is\n"
+        "begin\n"
+        "Put_Line(\"Hello, World!\");\n"
+        "end Main;\n")
+
+    try_compile(CMAKE_ADA_COMPILER_WORKS ${CMAKE_BINARY_DIR}
+                ${_ADA_TEST_FILE}
+                OUTPUT_VARIABLE __CMAKE_ADA_COMPILER_OUTPUT)
+
+    set(CMAKE_ADA_COMPILER_WORKS ${CMAKE_ADA_COMPILER_WORKS})
+    unset(CMAKE_ADA_COMPILER_WORKS CACHE)
+    set(ADA_TEST_WAS_RUN TRUE)
+endif(NOT CMAKE_ADA_COMPILER_WORKS)
+
+if(NOT CMAKE_ADA_COMPILER_WORKS)
+    PrintTestCompilerStatus("ADA" " -- broken")
+
+    file(APPEND ${CMAKE_BINARY_DIR}${CMAKE_FILES_DIRECTORY}/CMakeError.log
+        "Determining if the Ada compiler works failed with "
+        "the following output:\n${__CMAKE_ADA_COMPILER_OUTPUT}\n\n")
+
+    message(FATAL_ERROR "The Ada compiler \"${CMAKE_ADA_COMPILER}\" "
+        "is not able to compile a simple test program.\nIt fails "
+        "with the following output:\n ${__CMAKE_ADA_COMPILER_OUTPUT}\n\n"
+        "CMake will not be able to correctly generate this project.")
+else(NOT CMAKE_ADA_COMPILER_WORKS)
+    if(ADA_TEST_WAS_RUN)
+        PrintTestCompilerStatus("ADA" " -- works")
+
+        file(APPEND ${CMAKE_BINARY_DIR}${CMAKE_FILES_DIRECTORY}/CMakeOutput.log
+            "Determining if the Ada compiler works passed with "
+            "the following output:\n${__CMAKE_ADA_COMPILER_OUTPUT}\n\n")
+    endif(ADA_TEST_WAS_RUN)
+endif(NOT CMAKE_ADA_COMPILER_WORKS)
+
+unset(__CMAKE_ADA_COMPILER_OUTPUT)

contrib/ada/cmake/binder_helper.cmake

@@ -0,0 +1,41 @@
+#CMAKE_ARGV0 = /path/to/cmake
+#CMAKE_ARGV1 = -P
+#CMAKE_ARGV2 = path/to/this/file
+#CMAKE_ARGV3 = binder
+#CMAKE_ARGV4 = ali
+
+if(NOT CMAKE_ARGV3)
+    message(FATAL_ERROR "binder not set")
+endif(NOT CMAKE_ARGV3)
+
+string(REPLACE ".o" ".ali" ALI ${CMAKE_ARGV4})
+
+set (REACHED_FLAGS FALSE)
+#iterate over additional objects, only the main one is needed
+foreach(arg RANGE 5 ${CMAKE_ARGC})
+    if(CMAKE_ARGV${arg} STREQUAL FLAGS)
+        set(REACHED_FLAGS TRUE)
+        continue()
+    endif(CMAKE_ARGV${arg} STREQUAL FLAGS)
+
+    if(REACHED_FLAGS)
+        list(APPEND FLAGS ${CMAKE_ARGV${arg}})
+    endif(REACHED_FLAGS)
+endforeach(arg RANGE 5 CMAKE_ARGC)
+
+#first see if there is a main function
+execute_process(COMMAND ${CMAKE_ARGV3} bind ${ALI} ${FLAGS}
+                RESULT_VARIABLE MAIN_RESULT
+                OUTPUT_VARIABLE dont_care
+                ERROR_VARIABLE ERROR)
+
+if(MAIN_RESULT)
+    execute_process(COMMAND ${CMAKE_ARGV3} bind -n ${ALI} ${FLAGS}
+                    RESULT_VARIABLE RESULT
+                    OUTPUT_VARIABLE dont_care
+                    ERROR_VARIABLE ERROR)
+endif(MAIN_RESULT)
+
+if(RESULT)
+    message(FATAL_ERROR ${RESULT} ${ERROR})
+endif(RESULT)

contrib/ada/cmake/compile_helper.cmake

@@ -0,0 +1,32 @@
+#CMAKE_ARGV0 = /path/to/cmake
+#CMAKE_ARGV1 = -P
+#CMAKE_ARGV2 = path/to/this/file
+#CMAKE_ARGV3 = compiler
+#CMAKE_ARGV4 = OBJECT-DIR
+#CMAKE_ARGV5 = source-file
+
+if(NOT CMAKE_ARGV3)
+    message(FATAL_ERROR "compiler not set")
+endif(NOT CMAKE_ARGV3)
+
+if(NOT CMAKE_ARGV4)
+    message(FATAL_ERROR "object dir not set")
+endif(NOT CMAKE_ARGV4)
+
+if(NOT CMAKE_ARGV5)
+    message(FATAL_ERROR "source not set")
+endif(NOT CMAKE_ARGV5)
+
+foreach(arg RANGE 6 ${CMAKE_ARGC})
+    list(APPEND FLAGS "${CMAKE_ARGV${arg}}")
+endforeach(arg RANGE 6 ${CMAKE_ARGC})
+
+execute_process(COMMAND ${CMAKE_ARGV3} compile ${FLAGS} ${CMAKE_ARGV5}
+                WORKING_DIRECTORY ${CMAKE_ARGV4}
+                RESULT_VARIABLE RESULT
+                OUTPUT_VARIABLE dont_care
+                ERROR_VARIABLE ERROR)
+
+if(RESULT)
+    message(FATAL_ERROR ${RESULT} ${ERROR})
+endif(RESULT)

contrib/ada/cmake/exe_link_helper.cmake

@@ -0,0 +1,53 @@
+#CMAKE_ARGV0 = /path/to/cmake
+#CMAKE_ARGV1 = -P
+#CMAKE_ARGV2 = path/to/this/file
+#CMAKE_ARGV3 = linker
+#CMAKE_ARGV4 = output-name
+#CMAKE_ARGV5...CMAKE_AGVN = OBJECTS
+#CMAKE_ARGVN+1 = LIBS
+#CMAKE_ARGVN+2...CMAKE_ARGVM libraries
+
+if(NOT CMAKE_ARGV3)
+    message(FATAL_ERROR "linker not set")
+endif(NOT CMAKE_ARGV3)
+
+set(REACHED_LIBS FALSE)
+set(REACHED_OBJ FALSE)
+foreach(arg RANGE 5 ${CMAKE_ARGC})
+    if(CMAKE_ARGV${arg} STREQUAL LIBS)
+        set(REACHED_LIBS TRUE)
+        set(REACHED_OBJ FALSE)
+        continue()
+    endif(CMAKE_ARGV${arg} STREQUAL LIBS)
+
+    if(CMAKE_ARGV${arg} STREQUAL OBJ)
+        set(REACHED_LIBS FALSE)
+        set(REACHED_OBJ TRUE)
+        continue()
+    endif(CMAKE_ARGV${arg} STREQUAL OBJ)
+
+    if(CMAKE_ARGC EQUAL arg)
+        continue()
+    endif(CMAKE_ARGC EQUAL arg)
+
+    if(REACHED_LIBS)
+        list(APPEND LIBS "${CMAKE_ARGV${arg}}")
+    elseif(REACHED_OBJ AND NOT ALI)
+        string(REPLACE ".o" ".ali" ALI "${CMAKE_ARGV${arg}}")
+    else(REACHED_LIBS)
+        string(SUBSTRING "${CMAKE_ARGV${arg}}" 0 3 start)
+
+        if(NOT start STREQUAL -aO)
+            list(APPEND FLAGS "${CMAKE_ARGV${arg}}")
+        endif(NOT start STREQUAL -aO)
+    endif(REACHED_LIBS)
+endforeach(arg RANGE 5 ${CMAKE_ARGC})
+
+execute_process(COMMAND ${CMAKE_ARGV3} link ${ALI} -o ${CMAKE_ARGV4} ${FLAGS} ${OTHER_OBJECTS} ${LIBS}
+                RESULT_VARIABLE RESULT
+                OUTPUT_VARIABLE dont_care
+                ERROR_VARIABLE ERROR)
+
+if(RESULT)
+    message(FATAL_ERROR ${RESULT} ${ERROR})
+endif(RESULT)

contrib/ada/cmake/shared_link_helper.cmake

@@ -0,0 +1,52 @@
+#CMAKE_ARGV0 = /path/to/cmake
+#CMAKE_ARGV1 = -P
+#CMAKE_ARGV2 = path/to/this/file
+#CMAKE_ARGV3 = linker
+#CMAKE_ARGV4 = output-name
+#CMAKE_ARGV5...CMAKE_AGVN = OBJECTS
+#CMAKE_ARGVN+1 = LIBS
+#CMAKE_ARGVN+2...CMAKE_ARGVM libraries
+
+if(NOT CMAKE_ARGV3)
+    message(FATAL_ERROR "linker not set")
+endif(NOT CMAKE_ARGV3)
+
+set(REACHED_FILES FALSE)
+foreach(arg RANGE 5 ${CMAKE_ARGC})
+    if(CMAKE_ARGV${arg} STREQUAL "LIBS")
+        set(REACHED_FILES TRUE)
+        continue()
+    endif(CMAKE_ARGV${arg} STREQUAL "LIBS")
+
+    if(CMAKE_ARGC EQUAL arg)
+        continue()
+    endif(CMAKE_ARGC EQUAL arg)
+
+    if(REACHED_LIBS)
+        list(APPEND LIBS "${CMAKE_ARGV${arg}} ")
+    else(REACHED_LIBS)
+        list(APPEND OBJECT_FILES "${CMAKE_ARGV${arg}}")
+    endif(REACHED_LIBS)
+endforeach(arg RANGE 5 ${CMAKE_ARGC})
+
+file(WRITE dummylib.adb
+    "procedure dummylib is\n"
+    "begin\n"
+    "   null;\n"
+    "end;\n")
+
+execute_process(COMMAND ${CMAKE_ARGV3} compile -fPIC dummylib.adb
+                OUTPUT_VARIABLE dont_care
+                ERROR_VARIABLE ERROR)
+execute_process(COMMAND ${CMAKE_ARGV3} bind -n dummylib.ali
+                OUTPUT_VARIABLE dont_care
+                ERROR_VARIABLE ERROR)
+
+execute_process(COMMAND ${CMAKE_ARGV3} link -shared dummylib.ali -o ${CMAKE_ARGV4} ${OBJECT_FILES} ${LIBS}
+                RESULT_VARIABLE RESULT
+                OUTPUT_VARIABLE dont_care
+                ERROR_VARIABLE ERROR)
+
+if(RESULT)
+    message(FATAL_ERROR ${RESULT} ${ERROR})
+endif(RESULT)

contrib/ada/cmake/static_link_helper.cmake

@@ -0,0 +1,25 @@
+#CMAKE_ARGV0 = /path/to/cmake
+#CMAKE_ARGV1 = -P
+#CMAKE_ARGV2 = path/to/this/file
+#CMAKE_ARGV3 = path/to/ar
+#CMAKE_ARGV4 = output-name
+#CMAKE_ARGV5...CMAKE_AGVN = OBJECTS
+
+if(NOT CMAKE_ARGV3)
+    message(FATAL_ERROR "linker not set")
+endif(NOT CMAKE_ARGV3)
+
+foreach(arg RANGE 5 ${CMAKE_ARGC})
+    if(NOT CMAKE_ARGC EQUAL arg)
+        list(APPEND OBJECT_FILES "${CMAKE_ARGV${arg}}")
+    endif(NOT CMAKE_ARGC EQUAL arg)
+endforeach(arg RANGE 6 ${CMAKE_ARGC})
+
+execute_process(COMMAND ${CMAKE_ARGV3} rcs ${CMAKE_ARGV4} ${OBJECT_FILES}
+                RESULT_VARIABLE RESULT
+                OUTPUT_VARIABLE dont_care
+                ERROR_VARIABLE ERROR)
+
+if(RESULT)
+    message(FATAL_ERROR ${RESULT} ${ERROR})
+endif(RESULT)