|
0
|
1 # |
|
|
2 # CMakeLists.txt -- CMake build system for malikania |
|
|
3 # |
|
|
4 # Copyright (c) 2013-2016 Malikania Authors |
|
|
5 # |
|
|
6 # Permission to use, copy, modify, and/or distribute this software for any |
|
|
7 # purpose with or without fee is hereby granted, provided that the above |
|
|
8 # copyright notice and this permission notice appear in all copies. |
|
|
9 # |
|
|
10 # THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES |
|
|
11 # WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF |
|
|
12 # MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR |
|
|
13 # ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES |
|
|
14 # WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN |
|
|
15 # ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF |
|
|
16 # OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE. |
|
|
17 # |
|
|
18 |
|
|
19 include(CMakeParseArguments) |
|
|
20 |
|
|
21 # --------------------------------------------------------- |
|
|
22 # The following macros are available: |
|
|
23 # |
|
|
24 # malikania_generate_book |
|
|
25 # ----------------------- |
|
|
26 # |
|
|
27 # malikania_generate_book( |
|
|
28 # name The target name (book-${name}) |
|
|
29 # output The output file name |
|
|
30 # sources The sources files, kept in order |
|
|
31 # ) |
|
|
32 # |
|
|
33 # Generate a book using pandoc. |
|
|
34 # |
|
|
35 # malikania_generate_uml |
|
|
36 # ---------------------- |
|
|
37 # |
|
|
38 # malikania_generate_uml( |
|
|
39 # NAME The target name |
|
|
40 # DIRECTORY Output directory (relative to docs_BINARY_DIR) |
|
|
41 # SOURCES The sources files |
|
|
42 # ) |
|
|
43 # |
|
|
44 # Generate a target uml-${NAME} with all ${SOURCES} specified to be processed by plantuml. |
|
|
45 # |
|
|
46 # malikania_define_executable |
|
|
47 # --------------------------- |
|
|
48 # |
|
|
49 # malikania_define_executable( |
|
|
50 # TARGET The target name |
|
|
51 # SOURCES The list of sources |
|
|
52 # FLAGS (Optional) List of flags |
|
|
53 # INCLUDES (Optional) List of include directories |
|
|
54 # LIBRARIES (Optional) List of libraries |
|
|
55 # ) |
|
|
56 # |
|
|
57 # Create an executable. Be sure to quote SOURCES, if not only the first file will be passed. |
|
|
58 # If you need flags, just pass them without -D or /D, this is automatically done for you. |
|
|
59 # |
|
|
60 # malikania_create_library |
|
|
61 # ------------------------ |
|
|
62 # |
|
|
63 # malikania_create_library( |
|
|
64 # TARGET The target name |
|
|
65 # SOURCES The sources |
|
|
66 # FLAGS (Optional) List of flags |
|
|
67 # PRIVATE_INCLUDES (Optional) List of includes only for building the library |
|
|
68 # PUBLIC_INCLUDES (Optional) List of public includes to share with the library users |
|
|
69 # LIBRARIES (Optional) List of libraries to link against |
|
|
70 # ) |
|
|
71 # |
|
|
72 # Create a shared library. Follow the same specification as malikania_define_executable. |
|
|
73 # However, additional PRIVATE_INCLUDES and PUBLIC_INCLUDES are available. |
|
|
74 # |
|
|
75 # malikania_create_test |
|
|
76 # --------------------- |
|
|
77 # |
|
|
78 # malikania_create_test( |
|
|
79 # NAME Test name (must be lowercase) |
|
|
80 # SOURCES Test sources files |
|
|
81 # LIBRARIES (Optional) Libraries to link to |
|
|
82 # RESOURCES (Optional) Resources files to copy verbatim |
|
|
83 # ) |
|
|
84 # |
|
|
85 # This will generate a target named test-<name> where name is the parameter NAME. The test is created |
|
|
86 # under CMAKE_BINARY_DIR/test/<NAME> and resources are copied there with the same hierarchy. |
|
|
87 # |
|
|
88 # setg |
|
|
89 # ---- |
|
|
90 # |
|
|
91 # setg(var value) |
|
|
92 # |
|
|
93 # Set a cache variable internal with name var. |
|
|
94 # |
|
|
95 # --------------------------------------------------------- |
|
|
96 |
|
|
97 function(apply_flags target flags) |
|
|
98 # Add MALIKANIA_BUILD to enable declspec(dllexport) on Windows |
|
|
99 if (${flags}) |
|
|
100 target_compile_definitions( |
|
|
101 ${target} |
|
|
102 PRIVATE ${flags} |
|
|
103 PRIVATE "MALIKANIA_BUILD" |
|
|
104 ) |
|
|
105 endif () |
|
|
106 endfunction() |
|
|
107 |
|
|
108 function(apply_public_includes target var) |
|
|
109 if (${var}) |
|
|
110 target_include_directories(${target} PUBLIC ${${var}}) |
|
|
111 endif () |
|
|
112 endfunction() |
|
|
113 |
|
|
114 function(apply_private_includes target var) |
|
|
115 if (${var}) |
|
|
116 target_include_directories(${target} PRIVATE ${${var}}) |
|
|
117 endif () |
|
|
118 endfunction() |
|
|
119 |
|
|
120 function(apply_includes target var) |
|
|
121 if (${var}) |
|
|
122 target_include_directories(${target} PRIVATE ${${var}}) |
|
|
123 endif () |
|
|
124 endfunction() |
|
|
125 |
|
|
126 function(apply_libraries target libs) |
|
|
127 if (${libs}) |
|
|
128 target_link_libraries(${target} ${${libs}}) |
|
|
129 endif () |
|
|
130 endfunction() |
|
|
131 |
|
|
132 function(check_args prefix list) |
|
|
133 foreach (e ${list}) |
|
|
134 if (NOT ${prefix}_${e}) |
|
|
135 message(FATAL_ERROR "Please set `${e}' parameter") |
|
|
136 endif () |
|
|
137 endforeach () |
|
|
138 endfunction() |
|
|
139 |
|
|
140 function(malikania_define_executable) |
|
|
141 set(singleArgs TARGET) |
|
|
142 set(multiArgs SOURCES FLAGS INCLUDES LIBRARIES) |
|
|
143 set(mandatory TARGET SOURCES) |
|
|
144 |
|
|
145 cmake_parse_arguments(EXE "" "${singleArgs}" "${multiArgs}" ${ARGN}) |
|
|
146 check_args(EXE ${mandatory}) |
|
|
147 |
|
|
148 add_executable(${EXE_TARGET} ${EXE_SOURCES}) |
|
|
149 |
|
|
150 apply_libraries(${EXE_TARGET} EXE_LIBRARIES) |
|
|
151 apply_includes(${EXE_TARGET} EXE_INCLUDES) |
|
|
152 apply_flags(${EXE_TARGET} EXE_FLAGS) |
|
|
153 endfunction() |
|
|
154 |
|
|
155 function(malikania_create_library) |
|
|
156 set(singleArgs TARGET) |
|
|
157 set(multiArgs SOURCES FLAGS PRIVATE_INCLUDES PUBLIC_INCLUDES LIBRARIES) |
|
|
158 set(mandatory TARGET SOURCES) |
|
|
159 |
|
|
160 cmake_parse_arguments(LIB "" "${singleArgs}" "${multiArgs}" ${ARGN}) |
|
|
161 check_args(LIB ${mandatory}) |
|
|
162 |
|
|
163 add_library(${LIB_TARGET} SHARED ${LIB_SOURCES}) |
|
|
164 |
|
|
165 # Remove lib suffix to avoid conflict with client and libclient targets |
|
|
166 set_target_properties( |
|
|
167 ${LIB_TARGET} |
|
|
168 PROPERTIES |
|
|
169 PREFIX "" |
|
|
170 ) |
|
|
171 |
|
|
172 list(APPEND LIB_LIBRARIES duktape) |
|
|
173 |
|
|
174 apply_libraries(${LIB_TARGET} LIB_LIBRARIES) |
|
|
175 apply_private_includes(${LIB_TARGET} LIB_PRIVATE_INCLUDES) |
|
|
176 apply_public_includes(${LIB_TARGET} LIB_PUBLIC_INCLUDES) |
|
|
177 apply_flags(${LIB_TARGET} LIB_FLAGS) |
|
|
178 endfunction() |
|
|
179 |
|
|
180 function(malikania_generate_uml) |
|
|
181 set(options "") |
|
|
182 set(oneValueArgs NAME DIRECTORY) |
|
|
183 set(multiValueArgs SOURCES) |
|
|
184 |
|
|
185 cmake_parse_arguments(UML "${options}" "${oneValueArgs}" "${multiValueArgs}" ${ARGN}) |
|
|
186 |
|
|
187 foreach (f ${UML_SOURCES}) |
|
|
188 get_filename_component(filename ${f} NAME_WE) |
|
|
189 |
|
|
190 list(APPEND outputs ${docs_BINARY_DIR}/uml/${filename}.png) |
|
|
191 |
|
|
192 add_custom_command( |
|
|
193 OUTPUT ${docs_BINARY_DIR}/uml/${filename}.png |
|
|
194 DEPENDS ${f} |
|
|
195 COMMAND |
|
|
196 ${CMAKE_COMMAND} -E make_directory ${docs_BINARY_DIR}/uml |
|
|
197 COMMAND |
|
|
198 ${Java_JAVA_EXECUTABLE} -jar ${PLANTUML_JAR} ${f} -o ${docs_BINARY_DIR}/uml |
|
|
199 VERBATIM |
|
|
200 ) |
|
|
201 endforeach () |
|
|
202 |
|
|
203 add_custom_target( |
|
|
204 docs-uml-${UML_NAME} |
|
|
205 DEPENDS ${outputs} |
|
|
206 SOURCES ${UML_SOURCES} |
|
|
207 ) |
|
|
208 |
|
|
209 add_dependencies(docs-uml docs-uml-${UML_NAME}) |
|
|
210 endfunction() |
|
|
211 |
|
|
212 function(malikania_create_test) |
|
|
213 set(singleArgs NAME) |
|
|
214 set(multiArgs LIBRARIES SOURCES RESOURCES) |
|
|
215 |
|
|
216 set(mandatory NAME SOURCES) |
|
|
217 |
|
|
218 cmake_parse_arguments(TEST "" "${singleArgs}" "${multiArgs}" ${ARGN}) |
|
|
219 check_args(TEST ${mandatory}) |
|
|
220 |
|
|
221 file(MAKE_DIRECTORY ${CMAKE_BINARY_DIR}/test/${TEST_NAME}) |
|
|
222 |
|
|
223 if (UNIX) |
|
|
224 list(APPEND TEST_LIBRARIES pthread) |
|
|
225 endif () |
|
|
226 |
|
|
227 # Resources files added before as custom output |
|
|
228 foreach (f ${TEST_RESOURCES}) |
|
|
229 get_filename_component(absolute ${f} ABSOLUTE) |
|
|
230 file(RELATIVE_PATH basename ${CMAKE_CURRENT_SOURCE_DIR} ${absolute}) |
|
|
231 set(output ${CMAKE_BINARY_DIR}/test/${TEST_NAME}/${basename}) |
|
|
232 |
|
|
233 add_custom_command( |
|
|
234 OUTPUT ${output} |
|
|
235 COMMAND ${CMAKE_COMMAND} -E copy ${absolute} ${output} |
|
|
236 DEPENDS ${absolute} |
|
|
237 ) |
|
|
238 |
|
|
239 list(APPEND TEST_SOURCES ${absolute}) |
|
|
240 list(APPEND outputs ${output}) |
|
|
241 endforeach () |
|
|
242 |
|
|
243 add_executable(test-${TEST_NAME} ${TEST_SOURCES} ${outputs}) |
|
|
244 source_group(private\\Resources FILES ${outputs}) |
|
|
245 target_compile_definitions(test-${TEST_NAME} PRIVATE SOURCE_DIRECTORY=\"${CMAKE_BINARY_DIR}/test/${TEST_NAME}\") |
|
|
246 set_target_properties( |
|
|
247 test-${TEST_NAME} |
|
|
248 PROPERTIES |
|
|
249 RUNTIME_OUTPUT_DIRECTORY ${CMAKE_BINARY_DIR}/test/${TEST_NAME} |
|
|
250 RUNTIME_OUTPUT_DIRECTORY_DEBUG ${CMAKE_BINARY_DIR}/test/${TEST_NAME} |
|
|
251 RUNTIME_OUTPUT_DIRECTORY_RELEASE ${CMAKE_BINARY_DIR}/test/${TEST_NAME} |
|
|
252 RUNTIME_OUTPUT_DIRECTORY_RELWITHDEBINFO ${CMAKE_BINARY_DIR}/test/${TEST_NAME} |
|
|
253 RUNTIME_OUTPUT_DIRECTORY_MINSIZEREL ${CMAKE_BINARY_DIR}/test/${TEST_NAME} |
|
|
254 ) |
|
|
255 add_test( |
|
|
256 NAME ${TEST_NAME} |
|
|
257 COMMAND $<TARGET_FILE:test-${TEST_NAME}> |
|
|
258 WORKING_DIRECTORY ${CMAKE_BINARY_DIR}/test/${TEST_NAME} |
|
|
259 ) |
|
|
260 |
|
|
261 target_link_libraries( |
|
|
262 test-${TEST_NAME} |
|
|
263 ${TEST_LIBRARIES} |
|
|
264 gtest |
|
|
265 ) |
|
|
266 |
|
|
267 add_dependencies(tests test-${TEST_NAME}) |
|
|
268 endfunction() |
|
|
269 |
|
|
270 function(malikania_generate_book name output sources) |
|
|
271 pandoc( |
|
|
272 TARGET docs-book-${name} |
|
|
273 SOURCES ${sources} |
|
|
274 OUTPUT ${docs_BINARY_DIR}/books/${output} |
|
|
275 FROM markdown |
|
|
276 TO latex |
|
|
277 TOC |
|
|
278 STANDALONE |
|
|
279 MAKE_DIRECTORY |
|
|
280 WORKING_DIRECTORY "${CMAKE_CURRENT_SOURCE_DIR}" |
|
|
281 ) |
|
|
282 |
|
|
283 add_dependencies(docs-books docs-book-${name}) |
|
|
284 endfunction() |
|
|
285 |
|
|
286 macro(setg var value) |
|
|
287 set(${var} ${value} CACHE INTERNAL "" FORCE) |
|
|
288 endmacro() |
