summaryrefslogtreecommitdiff
path: root/archived/ptlibzippy/contrib/ada/CMakeLists.txt
blob: 4d933d8d6c2ad7d7545cc2bf0652f1b00671698e (plain)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
cmake_minimum_required(VERSION 3.12...3.31)

set(CMAKE_MODULE_PATH "${CMAKE_CURRENT_SOURCE_DIR}/cmake/Modules")

project(
    ptlibzippyAda
    VERSION 1.0.0
    LANGUAGES C ADA
    DESCRIPTION "A library for creating zipfiles based in PTlibzippy"
    HOMEPAGE_URL "http://projecttick.org/p/zlib")

option(PTLIBZIPPY_ADA_BUILD_SHARED "Enable building ada bindings shared library" ON)
option(PTLIBZIPPY_ADA_BUILD_STATIC "Enable building ada bindings static library" ON)
option(PTLIBZIPPY_ADA_BUILD_TESTING "Enable building tests for ada bindings library" ON)

if(WIN32 OR CYGWIN)
    set(ptlibzippy_Ada_static_suffix "s")
    set(CMAKE_DEBUG_POSTFIX "d")
endif(WIN32 OR CYGWIN)

if(NOT DEFINED PTLIBZIPPY_BUILD_ADA)
    if(PTLIBZIPPY_ADA_BUILD_SHARED)
        list(APPEND REQUIRED_COMPONENTS "shared")
    endif(PTLIBZIPPY_ADA_BUILD_SHARED)

    if(PTLIBZIPPY_ADA_BUILD_STATIC)
        list(APPEND REQUIRED_COMPONENTS "static")
    endif(PTLIBZIPPY_ADA_BUILD_STATIC)

    find_package(PTlibzippy REQUIRED COMPONENTS ${REQUIRED_COMPONENTS} CONFIG)
endif(NOT DEFINED PTLIBZIPPY_BUILD_ADA)

function(PTLIBZIPPY_ADA_findTestEnv testName)
    set(testEnv "PATH=")

    if(MSVC OR MINGW)
        set(separator "\\\;")
    else()
        set(separator ":")
    endif()

    string(APPEND testEnv "$<TARGET_FILE_DIR:PTlibzippy::PTlibzippy>${separator}")
    string(APPEND testEnv "$ENV{PATH}")

    set_tests_properties(${testName} PROPERTIES ENVIRONMENT "${testEnv}")
endfunction(PTLIBZIPPY_ADA_findTestEnv testName)

if(PTLIBZIPPY_ADA_BUILD_SHARED)
    ada_add_library(ptlibzippy_ada_Ada SHARED
        ptlib-thin.adb
        ptlib.adb)

    set_target_properties(ptlibzippy_ada_Ada
        PROPERTIES OUTPUT_NAME ptlibzippy-ada)

    target_link_libraries(ptlibzippy_ada_Ada
        INTERFACE PTlibzippy::PTlibzippy)

    ada_add_library(ptlibzippy_ada_streams SHARED
        ptlib-streams.adb)

    target_link_libraries(ptlibzippy_ada_streams
        PUBLIC
            ptlibzippy_ada_Ada)

    ada_find_ali(ptlibzippy_ada_streams)

    if(PTLIBZIPPY_ADA_BUILD_TESTING)
        enable_testing()
        ada_add_executable(ptlibzippy_ada_test test.adb)

        target_link_libraries(ptlibzippy_ada_test
            PRIVATE
                ptlibzippy_ada_Ada
                ptlibzippy_ada_streams)

        ada_find_ali(ptlibzippy_ada_test)

        add_test(NAME ptlibzippy_ada_ada-test COMMAND ptlibzippy_ada_test)
        set_tests_properties(ptlibzippy_ada_ada-test PROPERTIES FIXTURES_REQUIRED ptlibzippy_ada_cleanup)

        if(MSVC
           OR MSYS
           OR MINGW
           OR CYGWIN)
            ptlibzippy_ada_findtestenv(ptlibzippy_ada_ada-test)
        endif(
            MSVC
            OR MSYS
            OR MINGW
            OR CYGWIN)

        ada_add_executable(ptlibzippy_ada_buffer_demo buffer_demo.adb)

        target_link_libraries(ptlibzippy_ada_buffer_demo
            PRIVATE
                ptlibzippy_ada_Ada)

        ada_find_ali(ptlibzippy_ada_buffer_demo)

        add_test(NAME ptlibzippy_ada_buffer-demo COMMAND ptlibzippy_ada_buffer_demo)

        if(MSVC
           OR MSYS
           OR MINGW
           OR CYGWIN)
            ptlibzippy_ada_findtestenv(ptlibzippy_ada_buffer-demo)
        endif(
            MSVC
            OR MSYS
            OR MINGW
            OR CYGWIN)

        ada_add_executable(ptlibzippy_ada_mtest mtest.adb)

        target_link_libraries(ptlibzippy_ada_mtest
            PRIVATE
                ptlibzippy_ada_Ada)

        ada_find_ali(ptlibzippy_ada_mtest)

        #Not adding test as this is an endless-loop

        ada_add_executable(ptlibzippy_ada_read read.adb)

        target_link_libraries(ptlibzippy_ada_read
            PRIVATE
                ptlibzippy_ada_Ada)

        ada_find_ali(ptlibzippy_ada_read)

        add_test(NAME ptlibzippy_ada_read COMMAND ptlibzippy_ada_read)

        if(MSVC
           OR MSYS
           OR MINGW
           OR CYGWIN)
            ptlibzippy_ada_findtestenv(ptlibzippy_ada_read)
        endif(
            MSVC
            OR MSYS
            OR MINGW
            OR CYGWIN)
    endif(PTLIBZIPPY_ADA_BUILD_TESTING)
endif(PTLIBZIPPY_ADA_BUILD_SHARED)

if(PTLIBZIPPY_ADA_BUILD_STATIC)
    ada_add_library(ptlibzippy_ada_AdaStatic STATIC
        ptlib-thin.adb
        ptlib.adb)

    target_link_libraries(ptlibzippy_ada_AdaStatic
        INTERFACE PTlibzippy::PTlibzippyStatic)

    set_target_properties(ptlibzippy_ada_AdaStatic
        PROPERTIES OUTPUT_NAME ptlibzippy-ada${ptlibzippy_Ada_static_suffix})

    ada_add_library(ptlibzippy_ada_streamsStatic STATIC
        ptlib-streams.adb)

    target_link_libraries(ptlibzippy_ada_streamsStatic
        PUBLIC
            ptlibzippy_ada_AdaStatic)

    ada_find_ali(ptlibzippy_ada_streamsStatic)

    if(PTLIBZIPPY_ADA_BUILD_TESTING)
        enable_testing()
        ada_add_executable(ptlibzippy_ada_testStatic test.adb)

        target_link_libraries(ptlibzippy_ada_testStatic
            PRIVATE
                ptlibzippy_ada_AdaStatic
                ptlibzippy_ada_streamsStatic)

        ada_find_ali(ptlibzippy_ada_testStatic)

        add_test(NAME ptlibzippy_ada_testStatic COMMAND ptlibzippy_ada_testStatic)
        set_tests_properties(ptlibzippy_ada_testStatic PROPERTIES FIXTURES_REQUIRED ptlibzippy_ada_cleanup)

        ada_add_executable(ptlibzippy_ada_buffer-demoStatic buffer_demo.adb)

        target_link_libraries(ptlibzippy_ada_buffer-demoStatic
            PRIVATE
                ptlibzippy_ada_AdaStatic)

        ada_find_ali(ptlibzippy_ada_buffer-demoStatic)

        add_test(NAME ptlibzippy_ada_buffer-demoStatic COMMAND ptlibzippy_ada_buffer-demoStatic)

        ada_add_executable(ptlibzippy_ada_mtestStatic mtest.adb)

        target_link_libraries(ptlibzippy_ada_mtestStatic
            PRIVATE
                ptlibzippy_ada_AdaStatic)

        ada_find_ali(ptlibzippy_ada_mtestStatic)

        # Not adding test as this is an endless-loop

        ada_add_executable(ptlibzippy_ada_readStatic read.adb)

        target_link_libraries(ptlibzippy_ada_readStatic
            PRIVATE
                ptlibzippy_ada_AdaStatic)

        ada_find_ali(ptlibzippy_ada_readStatic)

        add_test(NAME ptlibzippy_ada_readStatic COMMAND ptlibzippy_ada_readStatic)
    endif(PTLIBZIPPY_ADA_BUILD_TESTING)
endif(PTLIBZIPPY_ADA_BUILD_STATIC)

if(PTLIBZIPPY_ADA_BUILD_TESTING)
    add_test(NAME ptlibzippy_ada_cleanup COMMAND ${CMAKE_COMMAND} -E rm ${CMAKE_CURRENT_BINARY_DIR}/testptlibzippy.in
        ${CMAKE_CURRENT_BINARY_DIR}/testptlibzippy.out ${CMAKE_CURRENT_BINARY_DIR}/testptlibzippy.zlb)
    set_tests_properties(ptlibzippy_ada_cleanup PROPERTIES FIXTURES_CLEANUP ptlibzippy_ada_cleanup)
endif(PTLIBZIPPY_ADA_BUILD_TESTING)