Mercurial > malikania

comparison extern/jansson/CMakeLists.txt @ 0:8991989c4708

Find changesets by keywords (author, files, the commit message), revision number or hash, or revset expression.
Initial import
author David Demelier <markand@malikania.fr>
date Tue, 22 Mar 2016 18:26:05 +0100
parents
children
comparison
equal deleted inserted replaced
-1:000000000000 0:8991989c4708
1 #
2 # This is a modified version for irccd.
3 # -------------------------------------------------------------------
4 #
5 # - installation stuff has been removed,
6 # - documentation process has been removed.
7 # - style has been adapted to match our conventions.
8 # - comments and unneeded stuff have been removed.
9 #
10
11 project (jansson C)
12
13 option(USE_URANDOM "Use /dev/urandom to seed the hash function." ON)
14 option(USE_WINDOWS_CRYPTOAPI "Use CryptGenRandom to seed the hash function." ON)
15
16 # for CheckFunctionKeywords
17 set(CMAKE_MODULE_PATH "${CMAKE_CURRENT_SOURCE_DIR}/cmake")
18
19 include(CheckCSourceCompiles)
20 include(CheckFunctionExists)
21 include(CheckFunctionKeywords)
22 include(CheckIncludeFiles)
23 include(CheckTypeSize)
24
25 if (MSVC)
26 # Turn off Microsofts "security" warnings.
27 add_definitions( "/W3 /D_CRT_SECURE_NO_WARNINGS /wd4005 /wd4996 /nologo" )
28
29 if (STATIC_CRT)
30 set(CMAKE_C_FLAGS_RELEASE "/MT")
31 set(CMAKE_C_FLAGS_DEBUG "/MTd")
32 endif()
33 endif()
34
35 if (NOT WIN32 AND (CMAKE_COMPILER_IS_GNUCC OR CMAKE_COMPILER_IS_GNUCXX))
36 add_definitions("-fPIC")
37 endif()
38
39 check_include_files(endian.h HAVE_ENDIAN_H)
40 check_include_files(fcntl.h HAVE_FCNTL_H)
41 check_include_files(sched.h HAVE_SCHED_H)
42 check_include_files(unistd.h HAVE_UNISTD_H)
43 check_include_files(sys/param.h HAVE_SYS_PARAM_H)
44 check_include_files(sys/stat.h HAVE_SYS_STAT_H)
45 check_include_files(sys/time.h HAVE_SYS_TIME_H)
46 check_include_files(sys/time.h HAVE_SYS_TYPES_H)
47
48 check_function_exists(close HAVE_CLOSE)
49 check_function_exists(getpid HAVE_GETPID)
50 check_function_exists(gettimeofday HAVE_GETTIMEOFDAY)
51 check_function_exists(open HAVE_OPEN)
52 check_function_exists(read HAVE_READ)
53 check_function_exists(sched_yield HAVE_SCHED_YIELD)
54
55 # Check for the int-type includes
56 check_include_files(stdint.h HAVE_STDINT_H)
57
58 # Check our 64 bit integer sizes
59 check_type_size(__int64 __INT64)
60 check_type_size(int64_t INT64_T)
61 check_type_size("long long" LONG_LONG_INT)
62
63 # Check our 32 bit integer sizes
64 check_type_size(int32_t INT32_T)
65 check_type_size(__int32 __INT32)
66 check_type_size("long" LONG_INT)
67 check_type_size("int" INT)
68
69 if (HAVE_INT32_T)
70 set(JSON_INT32 int32_t)
71 elseif (HAVE___INT32)
72 set(JSON_INT32 __int32)
73 elseif (HAVE_LONG_INT AND (${LONG_INT} EQUAL 4))
74 set(JSON_INT32 long)
75 elseif (HAVE_INT AND (${INT} EQUAL 4))
76 set(JSON_INT32 int)
77 else ()
78 message (FATAL_ERROR "Could not detect a valid 32-bit integer type")
79 endif ()
80
81 check_type_size("unsigned long" UNSIGNED_LONG_INT)
82 check_type_size("unsigned int" UNSIGNED_INT)
83 check_type_size("unsigned short" UNSIGNED_SHORT)
84 check_type_size(uint32_t UINT32_T)
85 check_type_size(__uint32 __UINT32)
86
87 if (HAVE_UINT32_T)
88 set(JSON_UINT32 uint32_t)
89 elseif (HAVE___UINT32)
90 set(JSON_UINT32 __uint32)
91 elseif (HAVE_UNSIGNED_LONG_INT AND (${UNSIGNED_LONG_INT} EQUAL 4))
92 set(JSON_UINT32 "unsigned long")
93 elseif (HAVE_UNSIGNED_INT AND (${UNSIGNED_INT} EQUAL 4))
94 set(JSON_UINT32 "unsigned int")
95 else ()
96 message(FATAL_ERROR "Could not detect a valid unsigned 32-bit integer type")
97 endif ()
98
99 check_type_size(uint16_t UINT16_T)
100 check_type_size(__uint16 __UINT16)
101
102 if (HAVE_UINT16_T)
103 set(JSON_UINT16 uint16_t)
104 elseif (HAVE___UINT16)
105 set(JSON_UINT16 __uint16)
106 elseif (HAVE_UNSIGNED_INT AND (${UNSIGNED_INT} EQUAL 2))
107 set(JSON_UINT16 "unsigned int")
108 elseif (HAVE_UNSIGNED_SHORT AND (${UNSIGNED_SHORT} EQUAL 2))
109 set(JSON_UINT16 "unsigned short")
110 else ()
111 message(FATAL_ERROR "Could not detect a valid unsigned 16-bit integer type")
112 endif ()
113
114 check_type_size(uint8_t UINT8_T)
115 check_type_size(__uint8 __UINT8)
116
117 if (HAVE_UINT8_T)
118 set(JSON_UINT8 uint8_t)
119 elseif (HAVE___UINT8)
120 set(JSON_UINT8 __uint8)
121 else ()
122 set(JSON_UINT8 "unsigned char")
123 endif ()
124
125 # Check for ssize_t and SSIZE_T existance.
126 check_type_size(ssize_t SSIZE_T)
127 check_type_size(SSIZE_T UPPERCASE_SSIZE_T)
128
129 if(NOT HAVE_SSIZE_T)
130 if(HAVE_UPPERCASE_SSIZE_T)
131 set(JSON_SSIZE SSIZE_T)
132 else()
133 set(JSON_SSIZE int)
134 endif()
135 endif()
136
137 set(CMAKE_EXTRA_INCLUDE_FILES "")
138
139 # Check for all the variants of strtoll
140 check_function_exists(strtoll HAVE_STRTOLL)
141 check_function_exists(strtoq HAVE_STRTOQ)
142 check_function_exists(_strtoi64 HAVE__STRTOI64)
143
144 # Figure out what variant we should use
145 if (HAVE_STRTOLL)
146 set(JSON_STRTOINT strtoll)
147 elseif (HAVE_STRTOQ)
148 set(JSON_STRTOINT strtoq)
149 elseif (HAVE__STRTOI64)
150 set(JSON_STRTOINT _strtoi64)
151 else ()
152 # fallback to strtol (32 bit)
153 # this will set all the required variables
154 set (JSON_STRTOINT strtol)
155 set (JSON_INT_T long)
156 set (JSON_INTEGER_FORMAT "\"ld\"")
157 endif ()
158
159 # if we haven't defined JSON_INT_T, then we have a 64 bit conversion function.
160 # detect what to use for the 64 bit type.
161 # Note: I will prefer long long if I can get it, as that is what the automake system aimed for.
162 if (NOT DEFINED JSON_INT_T)
163 if (HAVE_LONG_LONG_INT AND (${LONG_LONG_INT} EQUAL 8))
164 set(JSON_INT_T "long long")
165 elseif (HAVE_INT64_T)
166 set(JSON_INT_T int64_t)
167 elseif (HAVE___INT64)
168 set(JSON_INT_T __int64)
169 else ()
170 message(FATAL_ERROR "Could not detect 64 bit type, although I detected the strtoll equivalent")
171 endif ()
172
173 # Apparently, Borland BCC and MSVC wants I64d,
174 # Borland BCC could also accept LD
175 # and gcc wants ldd,
176 # I am not sure what cygwin will want, so I will assume I64d
177
178 if (WIN32) # matches both msvc and cygwin
179 set(JSON_INTEGER_FORMAT "\"I64d\"")
180 else ()
181 set(JSON_INTEGER_FORMAT "\"lld\"")
182 endif ()
183 endif ()
184
185
186 # If locale.h and localeconv() are available, define to 1, otherwise to 0.
187 check_include_files (locale.h HAVE_LOCALE_H)
188 check_function_exists (localeconv HAVE_LOCALECONV)
189
190 if (HAVE_LOCALECONV AND HAVE_LOCALE_H)
191 set(JSON_HAVE_LOCALECONV 1)
192 else ()
193 set(JSON_HAVE_LOCALECONV 0)
194 endif()
195
196 # check if we have setlocale
197 check_function_exists(setlocale HAVE_SETLOCALE)
198
199 # Check what the inline keyword is.
200 # Note that the original JSON_INLINE was always set to just 'inline', so this goes further.
201 check_function_keywords("inline")
202 check_function_keywords("__inline")
203 check_function_keywords("__inline__")
204
205 if (HAVE_INLINE)
206 set(JSON_INLINE inline)
207 elseif (HAVE___INLINE)
208 set(JSON_INLINE __inline)
209 elseif (HAVE___INLINE__)
210 set(JSON_INLINE __inline__)
211 else()
212 # no inline on this platform
213 set (JSON_INLINE)
214 endif()
215
216 # Find our snprintf
217 check_function_exists (snprintf HAVE_SNPRINTF)
218 check_function_exists (_snprintf HAVE__SNPRINTF)
219
220 if (HAVE_SNPRINTF)
221 set(JSON_SNPRINTF snprintf)
222 elseif (HAVE__SNPRINTF)
223 set(JSON_SNPRINTF _snprintf)
224 endif ()
225
226 check_c_source_compiles ("int main() { unsigned long val; __sync_bool_compare_and_swap(&val, 0, 1); return 0; } " HAVE_SYNC_BUILTINS)
227 check_c_source_compiles ("int main() { char l; unsigned long v; __atomic_test_and_set(&l, __ATOMIC_RELAXED); __atomic_store_n(&v, 1, __ATOMIC_RELEASE); __atomic_load_n(&v, __ATOMIC_ACQUIRE); return 0; }" HAVE_ATOMIC_BUILTINS)
228
229 # configure the public config file
230 configure_file (${CMAKE_CURRENT_SOURCE_DIR}/cmake/jansson_config.h.cmake
231 ${CMAKE_CURRENT_BINARY_DIR}/include/jansson_config.h)
232
233 # Copy the jansson.h file to the public include folder
234 file (COPY ${CMAKE_CURRENT_SOURCE_DIR}/src/jansson.h
235 DESTINATION ${CMAKE_CURRENT_BINARY_DIR}/include/)
236
237 add_definitions(-DJANSSON_USING_CMAKE)
238
239 # configure the private config file
240 configure_file(${CMAKE_CURRENT_SOURCE_DIR}/cmake/jansson_private_config.h.cmake
241 ${CMAKE_CURRENT_BINARY_DIR}/private_include/jansson_private_config.h)
242
243 # and tell the source code to include it
244 add_definitions(-DHAVE_CONFIG_H)
245
246 include_directories(${CMAKE_CURRENT_BINARY_DIR}/include)
247 include_directories(${CMAKE_CURRENT_BINARY_DIR}/private_include)
248
249 # Add the lib sources.
250 file(GLOB JANSSON_SRC src/*.c)
251
252 set(
253 JANSSON_HDR_PRIVATE
254 ${CMAKE_CURRENT_SOURCE_DIR}/src/hashtable.h
255 ${CMAKE_CURRENT_SOURCE_DIR}/src/jansson_private.h
256 ${CMAKE_CURRENT_SOURCE_DIR}/src/strbuffer.h
257 ${CMAKE_CURRENT_SOURCE_DIR}/src/utf.h
258 ${CMAKE_CURRENT_BINARY_DIR}/private_include/jansson_private_config.h
259 )
260
261 set(
262 JANSSON_HDR_PUBLIC
263 ${CMAKE_CURRENT_BINARY_DIR}/include/jansson_config.h
264 ${CMAKE_CURRENT_SOURCE_DIR}/src/jansson.h
265 )
266
267 malikania_create_library(
268 TARGET extern-jansson
269 SOURCES
270 ${JANSSON_SRC}
271 ${JANSSON_HDR_PRIVATE}
272 ${JANSSON_HDR_PUBLIC}
273 PUBLIC_INCLUDES
274 ${jansson_SOURCE_DIR}/src
275 ${jansson_BINARY_DIR}/include
276 )