From 470f2a5b403fa06170c6edbe9863e9abdf441952 Mon Sep 17 00:00:00 2001 From: rohan-elear <53178851+rohan-elear@users.noreply.github.com> Date: Wed, 29 Jan 2020 13:44:06 +0530 Subject: [PATCH] bugfix for unix builds (#5) * updated CMakeLists and conanfile.py from conan-center-index to add cross compilation for iOS and macOS builds --- .gitignore | 1 + CMakeLists.txt | 151 +++++++++++++++++++++++++++++++++++++++++++++++++ conanfile.py | 51 ++++++++++++----- 3 files changed, 188 insertions(+), 15 deletions(-) diff --git a/.gitignore b/.gitignore index 6347caa..2cd137e 100644 --- a/.gitignore +++ b/.gitignore @@ -109,3 +109,4 @@ /include /libjson-c.a /libjson-c.so +/build diff --git a/CMakeLists.txt b/CMakeLists.txt index 5e828ab..a4b884a 100644 --- a/CMakeLists.txt +++ b/CMakeLists.txt @@ -66,6 +66,7 @@ set(JSON_C_PUBLIC_HEADERS ./json_c_version.h ./json_inttypes.h ./json_object.h + ./json_object_iterator.h ./json_pointer.h ./json_tokener.h ./json_util.h @@ -134,3 +135,153 @@ if (UNIX) set(INSTALL_PKGCONFIG_DIR "${CMAKE_INSTALL_PREFIX}/lib/pkgconfig" CACHE PATH "Installation directory for pkgconfig (.pc) files") install(FILES ${CMAKE_BINARY_DIR}/json-c.pc DESTINATION "${INSTALL_PKGCONFIG_DIR}") endif () + +# ------------------------- Begin Generic CMake Variable Logging ------------------ + +# if you are building in-source, this is the same as CMAKE_SOURCE_DIR, otherwise +# this is the top level directory of your build tree +MESSAGE( STATUS "CMAKE_BINARY_DIR: " ${CMAKE_BINARY_DIR} ) + +# if you are building in-source, this is the same as CMAKE_CURRENT_SOURCE_DIR, otherwise this +# is the directory where the compiled or generated files from the current CMakeLists.txt will go to +MESSAGE( STATUS "CMAKE_CURRENT_BINARY_DIR: " ${CMAKE_CURRENT_BINARY_DIR} ) + +# this is the directory, from which cmake was started, i.e. the top level source directory +MESSAGE( STATUS "CMAKE_SOURCE_DIR: " ${CMAKE_SOURCE_DIR} ) + +# this is the directory where the currently processed CMakeLists.txt is located in +MESSAGE( STATUS "CMAKE_CURRENT_SOURCE_DIR: " ${CMAKE_CURRENT_SOURCE_DIR} ) + +# contains the full path to the top level directory of your build tree +MESSAGE( STATUS "PROJECT_BINARY_DIR: " ${PROJECT_BINARY_DIR} ) + +# contains the full path to the root of your project source directory, +# i.e. to the nearest directory where CMakeLists.txt contains the PROJECT() command +MESSAGE( STATUS "PROJECT_SOURCE_DIR: " ${PROJECT_SOURCE_DIR} ) + +# set this variable to specify a common place where CMake should put all executable files +# (instead of CMAKE_CURRENT_BINARY_DIR) +MESSAGE( STATUS "EXECUTABLE_OUTPUT_PATH: " ${EXECUTABLE_OUTPUT_PATH} ) + +# set this variable to specify a common place where CMake should put all libraries +# (instead of CMAKE_CURRENT_BINARY_DIR) +MESSAGE( STATUS "LIBRARY_OUTPUT_PATH: " ${LIBRARY_OUTPUT_PATH} ) + +# tell CMake to search first in directories listed in CMAKE_MODULE_PATH +# when you use FIND_PACKAGE() or INCLUDE() +MESSAGE( STATUS "CMAKE_MODULE_PATH: " ${CMAKE_MODULE_PATH} ) + +# this is the complete path of the cmake which runs currently (e.g. /usr/local/bin/cmake) +MESSAGE( STATUS "CMAKE_COMMAND: " ${CMAKE_COMMAND} ) + +# this is the CMake installation directory +MESSAGE( STATUS "CMAKE_ROOT: " ${CMAKE_ROOT} ) + +# this is the filename including the complete path of the file where this variable is used. +MESSAGE( STATUS "CMAKE_CURRENT_LIST_FILE: " ${CMAKE_CURRENT_LIST_FILE} ) + +# this is linenumber where the variable is used +MESSAGE( STATUS "CMAKE_CURRENT_LIST_LINE: " ${CMAKE_CURRENT_LIST_LINE} ) + +# this is used when searching for include files e.g. using the FIND_PATH() command. +MESSAGE( STATUS "CMAKE_INCLUDE_PATH: " ${CMAKE_INCLUDE_PATH} ) + +# this is used when searching for libraries e.g. using the FIND_LIBRARY() command. +MESSAGE( STATUS "CMAKE_LIBRARY_PATH: " ${CMAKE_LIBRARY_PATH} ) + +# the complete system name, e.g. "Linux-2.4.22", "FreeBSD-5.4-RELEASE" or "Windows 5.1" +MESSAGE( STATUS "CMAKE_SYSTEM: " ${CMAKE_SYSTEM} ) + +# the short system name, e.g. "Linux", "FreeBSD" or "Windows" +MESSAGE( STATUS "CMAKE_SYSTEM_NAME: " ${CMAKE_SYSTEM_NAME} ) + +# only the version part of CMAKE_SYSTEM +MESSAGE( STATUS "CMAKE_SYSTEM_VERSION: " ${CMAKE_SYSTEM_VERSION} ) + +# the processor name (e.g. "Intel(R) Pentium(R) M processor 2.00GHz") +MESSAGE( STATUS "CMAKE_SYSTEM_PROCESSOR: " ${CMAKE_SYSTEM_PROCESSOR} ) + +# is TRUE on all UNIX-like OS's, including Apple OS X and CygWin +MESSAGE( STATUS "UNIX: " ${UNIX} ) + +# is TRUE on Windows, including CygWin +MESSAGE( STATUS "WIN32: " ${WIN32} ) + +# is TRUE on Apple OS X +MESSAGE( STATUS "APPLE: " ${APPLE} ) + +# is TRUE when using the MinGW compiler in Windows +MESSAGE( STATUS "MINGW: " ${MINGW} ) + +# is TRUE on Windows when using the CygWin version of cmake +MESSAGE( STATUS "CYGWIN: " ${CYGWIN} ) + +# is TRUE on Windows when using a Borland compiler +MESSAGE( STATUS "BORLAND: " ${BORLAND} ) + +# Microsoft compiler +MESSAGE( STATUS "MSVC: " ${MSVC} ) +MESSAGE( STATUS "MSVC_IDE: " ${MSVC_IDE} ) +MESSAGE( STATUS "MSVC60: " ${MSVC60} ) +MESSAGE( STATUS "MSVC70: " ${MSVC70} ) +MESSAGE( STATUS "MSVC71: " ${MSVC71} ) +MESSAGE( STATUS "MSVC80: " ${MSVC80} ) +MESSAGE( STATUS "CMAKE_COMPILER_2005: " ${CMAKE_COMPILER_2005} ) + + +# set this to true if you don't want to rebuild the object files if the rules have changed, +# but not the actual source files or headers (e.g. if you changed the some compiler switches) +MESSAGE( STATUS "CMAKE_SKIP_RULE_DEPENDENCY: " ${CMAKE_SKIP_RULE_DEPENDENCY} ) + +# since CMake 2.1 the install rule depends on all, i.e. everything will be built before installing. +# If you don't like this, set this one to true. +MESSAGE( STATUS "CMAKE_SKIP_INSTALL_ALL_DEPENDENCY: " ${CMAKE_SKIP_INSTALL_ALL_DEPENDENCY} ) + +# If set, runtime paths are not added when using shared libraries. Default it is set to OFF +MESSAGE( STATUS "CMAKE_SKIP_RPATH: " ${CMAKE_SKIP_RPATH} ) + +# set this to true if you are using makefiles and want to see the full compile and link +# commands instead of only the shortened ones +MESSAGE( STATUS "CMAKE_VERBOSE_MAKEFILE: " ${CMAKE_VERBOSE_MAKEFILE} ) + +# this will cause CMake to not put in the rules that re-run CMake. This might be useful if +# you want to use the generated build files on another machine. +MESSAGE( STATUS "CMAKE_SUPPRESS_REGENERATION: " ${CMAKE_SUPPRESS_REGENERATION} ) + + +# A simple way to get switches to the compiler is to use ADD_DEFINITIONS(). +# But there are also two variables exactly for this purpose: + +# the compiler flags for compiling C sources +MESSAGE( STATUS "CMAKE_C_FLAGS: " ${CMAKE_C_FLAGS} ) + +# the compiler flags for compiling C++ sources +MESSAGE( STATUS "CMAKE_CXX_FLAGS: " ${CMAKE_CXX_FLAGS} ) + + +# Choose the type of build. Example: SET(CMAKE_BUILD_TYPE Debug) +MESSAGE( STATUS "CMAKE_BUILD_TYPE: " ${CMAKE_BUILD_TYPE} ) + +# if this is set to ON, then all libraries are built as shared libraries by default. +MESSAGE( STATUS "BUILD_SHARED_LIBS: " ${BUILD_SHARED_LIBS} ) + +# the compiler used for C files +MESSAGE( STATUS "CMAKE_C_COMPILER: " ${CMAKE_C_COMPILER} ) + +# the compiler used for C++ files +MESSAGE( STATUS "CMAKE_CXX_COMPILER: " ${CMAKE_CXX_COMPILER} ) + +# if the compiler is a variant of gcc, this should be set to 1 +MESSAGE( STATUS "CMAKE_COMPILER_IS_GNUCC: " ${CMAKE_COMPILER_IS_GNUCC} ) + +# if the compiler is a variant of g++, this should be set to 1 +MESSAGE( STATUS "CMAKE_COMPILER_IS_GNUCXX : " ${CMAKE_COMPILER_IS_GNUCXX} ) + +# the tools for creating libraries +MESSAGE( STATUS "CMAKE_AR: " ${CMAKE_AR} ) +MESSAGE( STATUS "CMAKE_RANLIB: " ${CMAKE_RANLIB} ) + +# +#MESSAGE( STATUS ": " ${} ) + +# ------------------------- End of Generic CMake Variable Logging ------------------ diff --git a/conanfile.py b/conanfile.py index 70900b7..73e4d28 100644 --- a/conanfile.py +++ b/conanfile.py @@ -1,27 +1,48 @@ -from conans import ConanFile, AutoToolsBuildEnvironment +from conans import ConanFile, CMake, tools class JsonclibConan(ConanFile): name = "json-c" + version = "0.13" + description = "JSON-C - A JSON implementation in C" + topics = ("conan", "json-c", "json", "encoding", "decoding", "manipulation") + url = "https://github.com/elear-solutions/json-c" license = "" - author = " " - url = "" - description = "This recipe file used to build and package binaries of json-c repository" - topics = ("", "", "") + generators = "cmake" settings = "os", "compiler", "build_type", "arch" - options = { "shared": [True, False] } - default_options = "shared=False" - generators = "make" + options = { + "shared": [True, False], + "fPIC": [True, False] + } + default_options = {key: False for key in options.keys()} + default_options ["shared"] = False + default_options ["fPIC"] = True + + def config_options(self): + if self.settings.os == "Windows": + del self.options.fPIC + + def configure(self): + del self.settings.compiler.libcxx + del self.settings.compiler.cppstd + + def _configure_cmake(self): + if tools.cross_building(self.settings) and self.settings.os != "Windows": + host = tools.get_gnu_triplet(str(self.settings.os), str(self.settings.arch)) + tools.replace_in_file("../CMakeLists.txt", + "execute_process(COMMAND ./configure ", + "execute_process(COMMAND ./configure --host %s " % host) + cmake = CMake(self) + cmake.configure(source_folder=".") + return cmake def build(self): - autotools = AutoToolsBuildEnvironment(self) - self.run("cd .. && autoreconf -fsi ") - autotools.configure(configure_dir="..",args=["--prefix=${PWD}"]) - autotools.make() - autotools.install() + cmake = self._configure_cmake() + cmake.build() + cmake.install() def package(self): - self.copy("*.h", dst="include", src="include") - self.copy("*", dst="lib", src="lib", keep_path=False) + self.copy("*.h", dst="include/json-c", src="package/include/json-c") + self.copy("*", dst="lib", src="package/lib", keep_path=False) def package_info(self): self.cpp_info.libs = [ "json-c" ]