Upgrade gflags to master
Merge commit 'cb7bb2b58469b0ba5132fbcf4893b2ca76dead1c' into master
Change-Id: Id6b07c15b3bef794984d6f326d6596f043d1dde5
diff --git a/aos/ipc_lib/ipc_comparison.cc b/aos/ipc_lib/ipc_comparison.cc
index 8774c73..cff2699 100644
--- a/aos/ipc_lib/ipc_comparison.cc
+++ b/aos/ipc_lib/ipc_comparison.cc
@@ -1,4 +1,4 @@
-#include "third_party/gflags/include/gflags/gflags.h"
+#include "gflags/gflags.h"
#include <fcntl.h>
#include <mqueue.h>
diff --git a/build_tests/gflags.cc b/build_tests/gflags.cc
index 150e330..20ce987 100644
--- a/build_tests/gflags.cc
+++ b/build_tests/gflags.cc
@@ -1,4 +1,4 @@
-#include "third_party/gflags/include/gflags/gflags.h"
+#include "gflags/gflags.h"
DEFINE_int32(test_flag, 0, "Test command-line flag");
diff --git a/third_party/gflags/.gitignore b/third_party/gflags/.gitignore
index 87ed3f9..d7c40e0 100644
--- a/third_party/gflags/.gitignore
+++ b/third_party/gflags/.gitignore
@@ -1,6 +1,8 @@
/xcode/
/build/
+/builds/
/build-*/
+/_build/
.DS_Store
CMakeCache.txt
DartConfiguration.tcl
@@ -15,3 +17,9 @@
/test/gflags_unittest_main.cc
/test/gflags_unittest-main.cc
/packages/
+CMakeLists.txt.user
+/bazel-bin
+/bazel-genfiles
+/bazel-gflags
+/bazel-out
+/bazel-testlogs
diff --git a/third_party/gflags/.travis.yml b/third_party/gflags/.travis.yml
new file mode 100644
index 0000000..0989c7c
--- /dev/null
+++ b/third_party/gflags/.travis.yml
@@ -0,0 +1,20 @@
+# Ubuntu 14.04 Trusty support, to get newer cmake and compilers.
+sudo: required
+dist: trusty
+
+language: cpp
+
+os:
+ - linux
+ - osx
+
+compiler:
+ - clang
+ - gcc
+
+env:
+ - CONFIG=Release
+ - CONFIG=Debug
+
+script:
+ - mkdir out && cd out && cmake -D CMAKE_BUILD_TYPE=$CONFIG -D GFLAGS_BUILD_SHARED_LIBS=ON -D GFLAGS_BUILD_STATIC_LIBS=ON -D GFLAGS_BUILD_TESTING=ON .. && cmake --build . --config $CONFIG && ctest
diff --git a/third_party/gflags/BUILD b/third_party/gflags/BUILD
index 5e8b505..0e7ccdd 100644
--- a/third_party/gflags/BUILD
+++ b/third_party/gflags/BUILD
@@ -1,53 +1,18 @@
+# Bazel (http://bazel.io/) BUILD file for gflags.
+#
+# See INSTALL.md for instructions for adding gflags to a Bazel workspace.
+
licenses(["notice"])
-common_copts = [
- "-Ithird_party/gflags/include/gflags",
- "-Ithird_party/empty_config_h",
- "-DHAVE_STDINT_H=",
- "-DHAVE_SYS_TYPES_H=",
- "-DHAVE_INTTYPES_H=",
- "-DHAVE_SYS_STAT_H=",
- "-DHAVE_UNISTD_H=",
- "-DHAVE_FNMATCH_H=",
- "-DHAVE_STRTOLL=",
- "-DHAVE_PTHREAD=",
- "-DHAVE_RWLOCK=",
- "-D__STDC_FORMAT_MACROS=1",
- "-DPATH_SEPARATOR=\"'/'\"",
- "-DGFLAGS_IS_A_DLL=0",
- "-DGFLAGS_DLL_DECL=",
- "-DGFLAGS_DLL_DEFINE_FLAG=",
- "-Wno-format-nonliteral",
- "-Wno-unused-local-typedefs",
- "-Wno-sign-compare",
- "-Wno-missing-field-initializers",
-]
+exports_files(["src/gflags_completions.sh", "COPYING.txt"])
-cc_library(
- name = "gflags",
- srcs = glob(
- [
- "src/*.cc",
- "src/*.h",
- ],
- exclude = [
- "src/windows_*",
- ],
- ) + [
- "include/gflags/gflags_declare.h",
- "include/gflags/gflags_gflags.h",
- ],
- hdrs = [
- "include/gflags/gflags.h",
- "include/gflags/gflags_completions.h",
- ],
- copts = common_copts,
- includes = ["include"],
- linkopts = [
- "-lpthread",
- ],
- visibility = ["//visibility:public"],
- deps = [
- "//third_party/empty_config_h",
- ],
+config_setting(
+ name = "x64_windows",
+ values = {"cpu": "x64_windows"},
)
+
+load(":bazel/gflags.bzl", "gflags_sources", "gflags_library")
+
+(hdrs, srcs) = gflags_sources(namespace=["gflags", "google"])
+gflags_library(hdrs=hdrs, srcs=srcs, threads=0)
+gflags_library(hdrs=hdrs, srcs=srcs, threads=1)
diff --git a/third_party/gflags/CMakeLists.txt b/third_party/gflags/CMakeLists.txt
index c32bce3..9dec647 100644
--- a/third_party/gflags/CMakeLists.txt
+++ b/third_party/gflags/CMakeLists.txt
@@ -1,29 +1,106 @@
-cmake_minimum_required (VERSION 2.8.12 FATAL_ERROR)
+## CMake configuration file of gflags project
+##
+## This CMakeLists.txt defines some gflags specific configuration variables
+## using the "gflags_define" utility macro. The default values of these variables
+## can be overridden either on the CMake command-line using the -D option of
+## the cmake command or in a super-project which includes the gflags source
+## tree by setting the GFLAGS_<varname> CMake variables before adding the
+## gflags source directory via CMake's "add_subdirectory" command. Only when
+## the non-cached variable GFLAGS_IS_SUBPROJECT has a value equivalent to FALSE,
+## these configuration variables are added to the CMake cache so they can be
+## edited in the CMake GUI. By default, GFLAGS_IS_SUBPROJECT is set to TRUE when
+## the CMAKE_SOURCE_DIR is not identical to the directory of this CMakeLists.txt
+## file, i.e., the top-level directory of the gflags project source tree.
+##
+## When this project is a subproject (GFLAGS_IS_SUBPROJECT is TRUE), the default
+## settings are such that only the static single-threaded library is built without
+## installation of the gflags files. The "gflags::gflags" target is in this case an ALIAS
+## library target for the "gflags_nothreads_static" library target. Targets which
+## depend on the gflags library should link to the "gflags::gflags" library target.
+##
+## Example CMakeLists.txt of user project which requires separate gflags installation:
+## cmake_minimum_required(VERSION 2.8.12 FATAL_ERROR)
+##
+## project(Foo)
+##
+## find_package(gflags REQUIRED)
+##
+## add_executable(foo src/foo.cc)
+## target_link_libraries(foo gflags::gflags)
+##
+## Example CMakeLists.txt of user project which requires separate single-threaded static gflags installation:
+## cmake_minimum_required(VERSION 2.8.12 FATAL_ERROR)
+##
+## project(Foo)
+##
+## find_package(gflags COMPONENTS nothreads_static)
+##
+## add_executable(foo src/foo.cc)
+## target_link_libraries(foo gflags::gflags)
+##
+## Example CMakeLists.txt of super-project which contains gflags source tree:
+## cmake_minimum_required(VERSION 2.8.12 FATAL_ERROR)
+##
+## project(Foo)
+##
+## add_subdirectory(gflags)
+##
+## add_executable(foo src/foo.cc)
+## target_link_libraries(foo gflags::gflags)
+##
+## Variables to configure the source files:
+## - GFLAGS_IS_A_DLL
+## - GFLAGS_NAMESPACE
+## - GFLAGS_ATTRIBUTE_UNUSED
+## - GFLAGS_INTTYPES_FORMAT
+##
+## Variables to configure the build:
+## - GFLAGS_SOVERSION
+## - GFLAGS_BUILD_SHARED_LIBS
+## - GFLAGS_BUILD_STATIC_LIBS
+## - GFLAGS_BUILD_gflags_LIB
+## - GFLAGS_BUILD_gflags_nothreads_LIB
+## - GFLAGS_BUILD_TESTING
+## - GFLAGS_BUILD_PACKAGING
+##
+## Variables to configure the installation:
+## - GFLAGS_INCLUDE_DIR
+## - GFLAGS_LIBRARY_INSTALL_DIR or LIB_INSTALL_DIR or LIB_SUFFIX
+## - GFLAGS_INSTALL_HEADERS
+## - GFLAGS_INSTALL_SHARED_LIBS
+## - GFLAGS_INSTALL_STATIC_LIBS
+
+cmake_minimum_required (VERSION 3.0.2 FATAL_ERROR)
if (POLICY CMP0042)
cmake_policy (SET CMP0042 NEW)
endif ()
+if (POLICY CMP0048)
+ cmake_policy (SET CMP0048 NEW)
+endif ()
+
# ----------------------------------------------------------------------------
# includes
-set (CMAKE_MODULE_PATH "${CMAKE_CURRENT_SOURCE_DIR}/cmake")
-include (utils)
+include ("${CMAKE_CURRENT_SOURCE_DIR}/cmake/utils.cmake")
# ----------------------------------------------------------------------------
# package information
-set (PACKAGE_NAME "gflags")
-set (PACKAGE_VERSION "2.2.0")
-set (PACKAGE_STRING "${PACKAGE_NAME} ${PACKAGE_VERSION}")
-set (PACKAGE_TARNAME "${PACKAGE_NAME}-${PACKAGE_VERSION}")
-set (PACKAGE_BUGREPORT "https://github.com/schuhschuh/gflags/issues")
+set (PACKAGE_NAME "gflags")
+set (PACKAGE_VERSION "2.2.1")
+set (PACKAGE_STRING "${PACKAGE_NAME} ${PACKAGE_VERSION}")
+set (PACKAGE_TARNAME "${PACKAGE_NAME}-${PACKAGE_VERSION}")
+set (PACKAGE_BUGREPORT "https://github.com/gflags/gflags/issues")
+set (PACKAGE_DESCRIPTION "A commandline flags library that allows for distributed flags.")
+set (PACKAGE_URL "http://gflags.github.io/gflags")
-project (${PACKAGE_NAME} CXX)
-if (CMAKE_VERSION VERSION_LESS 100)
+project (${PACKAGE_NAME} VERSION ${PACKAGE_VERSION} LANGUAGES CXX)
+if (CMAKE_VERSION VERSION_LESS 3.4)
# C language still needed because the following required CMake modules
# (or their dependencies, respectively) are not correctly handling
- # the case where only CXX is enabled.
- # - CheckTypeSize.cmake (fixed in CMake 3.1, cf. http://www.cmake.org/Bug/view.php?id=14056)
- # - FindThreads.cmake (--> CheckIncludeFiles.cmake <--)
+ # the case where only CXX is enabled
+ # - CheckTypeSize.cmake (fixed in CMake 3.1, cf. https://cmake.org/Bug/view.php?id=14056)
+ # - FindThreads.cmake (fixed in CMake 3.4, cf. https://cmake.org/Bug/view.php?id=14905)
enable_language (C)
endif ()
@@ -34,17 +111,45 @@
PACKAGE_VERSION_PATCH
)
-set (PACKAGE_SOVERSION "${PACKAGE_VERSION_MAJOR}")
+# shared library ABI version number, can be overridden by package maintainers
+# using -DGFLAGS_SOVERSION=XXX on the command-line
+if (GFLAGS_SOVERSION)
+ set (PACKAGE_SOVERSION "${GFLAGS_SOVERSION}")
+else ()
+ # TODO: Change default SOVERSION back to PACKAGE_VERSION_MAJOR with the
+ # next increase of major version number (i.e., 3.0.0 -> SOVERSION 3)
+ # The <major>.<minor> SOVERSION should be used for the 2.x releases
+ # versions only which temporarily broke the API by changing the default
+ # namespace from "google" to "gflags".
+ set (PACKAGE_SOVERSION "${PACKAGE_VERSION_MAJOR}.${PACKAGE_VERSION_MINOR}")
+endif ()
+
+# when gflags is included as subproject (e.g., as Git submodule/subtree) in the source
+# tree of a project that uses it, no variables should be added to the CMake cache;
+# users may set the non-cached variable GFLAGS_IS_SUBPROJECT before add_subdirectory(gflags)
+if (NOT DEFINED GFLAGS_IS_SUBPROJECT)
+ if ("^${CMAKE_SOURCE_DIR}$" STREQUAL "^${PROJECT_SOURCE_DIR}$")
+ set (GFLAGS_IS_SUBPROJECT FALSE)
+ else ()
+ set (GFLAGS_IS_SUBPROJECT TRUE)
+ endif ()
+endif ()
+
+# prefix for package variables in CMake configuration file
+string (TOUPPER "${PACKAGE_NAME}" PACKAGE_PREFIX)
+
+# convert file path on Windows with back slashes to path with forward slashes
+# otherwise this causes an issue with the cmake_install.cmake script
+file (TO_CMAKE_PATH "${CMAKE_INSTALL_PREFIX}" CMAKE_INSTALL_PREFIX)
# ----------------------------------------------------------------------------
# options
-if (NOT GFLAGS_NAMESPACE)
- # maintain binary backwards compatibility with gflags library version <= 2.0,
- # but at the same time enable the use of the preferred new "gflags" namespace
- set (GFLAGS_NAMESPACE "google;${PACKAGE_NAME}" CACHE STRING "Name(s) of library namespace (separate multiple options by semicolon)")
- mark_as_advanced (GFLAGS_NAMESPACE)
-endif ()
-set (GFLAGS_NAMESPACE_SECONDARY "${GFLAGS_NAMESPACE}")
+
+# maintain binary backwards compatibility with gflags library version <= 2.0,
+# but at the same time enable the use of the preferred new "gflags" namespace
+gflags_define (STRING NAMESPACE "Name(s) of library namespace (separate multiple options by semicolon)" "google;${PACKAGE_NAME}" "${PACKAGE_NAME}")
+gflags_property (NAMESPACE ADVANCED TRUE)
+set (GFLAGS_NAMESPACE_SECONDARY "${NAMESPACE}")
list (REMOVE_DUPLICATES GFLAGS_NAMESPACE_SECONDARY)
if (NOT GFLAGS_NAMESPACE_SECONDARY)
message (FATAL_ERROR "GFLAGS_NAMESPACE must be set to one (or more) valid C++ namespace identifier(s separated by semicolon \";\").")
@@ -57,46 +162,57 @@
list (GET GFLAGS_NAMESPACE_SECONDARY 0 GFLAGS_NAMESPACE)
list (REMOVE_AT GFLAGS_NAMESPACE_SECONDARY 0)
-option (BUILD_SHARED_LIBS "Request build of shared libraries." OFF)
-option (BUILD_STATIC_LIBS "Request build of static libraries (default if BUILD_SHARED_LIBS is OFF)." OFF)
-option (BUILD_gflags_LIB "Request build of the multi-threaded gflags library." ON)
-option (BUILD_gflags_nothreads_LIB "Request build of the single-threaded gflags library." ON)
-option (BUILD_PACKAGING "Enable build of distribution packages using CPack." OFF)
-option (BUILD_TESTING "Enable build of the unit tests and their execution using CTest." OFF)
-option (INSTALL_HEADERS "Request packaging of headers and other development files." ON)
+# cached build options when gflags is not a subproject, otherwise non-cached CMake variables
+# usage: gflags_define(BOOL <name> <doc> <default> [<subproject default>])
+gflags_define (BOOL BUILD_SHARED_LIBS "Request build of shared libraries." OFF OFF)
+gflags_define (BOOL BUILD_STATIC_LIBS "Request build of static libraries (default if BUILD_SHARED_LIBS is OFF)." OFF ON)
+gflags_define (BOOL BUILD_gflags_LIB "Request build of the multi-threaded gflags library." ON OFF)
+gflags_define (BOOL BUILD_gflags_nothreads_LIB "Request build of the single-threaded gflags library." ON ON)
+gflags_define (BOOL BUILD_PACKAGING "Enable build of distribution packages using CPack." OFF OFF)
+gflags_define (BOOL BUILD_TESTING "Enable build of the unit tests and their execution using CTest." OFF OFF)
+gflags_define (BOOL INSTALL_HEADERS "Request installation of headers and other development files." ON OFF)
+gflags_define (BOOL INSTALL_SHARED_LIBS "Request installation of shared libraries." ON ON)
+gflags_define (BOOL INSTALL_STATIC_LIBS "Request installation of static libraries." ON OFF)
+gflags_define (BOOL REGISTER_BUILD_DIR "Request entry of build directory in CMake's package registry." OFF OFF)
+gflags_define (BOOL REGISTER_INSTALL_PREFIX "Request entry of installed package in CMake's package registry." ON OFF)
-mark_as_advanced (CLEAR CMAKE_INSTALL_PREFIX)
-mark_as_advanced (CMAKE_CONFIGURATION_TYPES
- BUILD_STATIC_LIBS
- INSTALL_HEADERS)
-if (APPLE)
- mark_as_advanced(CMAKE_OSX_ARCHITECTURES
- CMAKE_OSX_DEPLOYMENT_TARGET
- CMAKE_OSX_SYSROOT)
-endif ()
+gflags_property (BUILD_STATIC_LIBS ADVANCED TRUE)
+gflags_property (INSTALL_HEADERS ADVANCED TRUE)
+gflags_property (INSTALL_SHARED_LIBS ADVANCED TRUE)
+gflags_property (INSTALL_STATIC_LIBS ADVANCED TRUE)
+
+if (NOT GFLAGS_IS_SUBPROJECT)
+ foreach (varname IN ITEMS CMAKE_INSTALL_PREFIX)
+ gflags_property (${varname} ADVANCED FALSE)
+ endforeach ()
+ foreach (varname IN ITEMS CMAKE_CONFIGURATION_TYPES CMAKE_OSX_ARCHITECTURES CMAKE_OSX_DEPLOYMENT_TARGET CMAKE_OSX_SYSROOT)
+ gflags_property (${varname} ADVANCED TRUE)
+ endforeach ()
+ if (NOT CMAKE_BUILD_TYPE AND NOT CMAKE_CXX_FLAGS)
+ gflags_set (CMAKE_BUILD_TYPE Release)
+ endif ()
+ if (CMAKE_CONFIGURATION_TYPES)
+ gflags_property (CMAKE_BUILD_TYPE STRINGS "${CMAKE_CONFIGURATION_TYPES}")
+ endif ()
+endif () # NOT GFLAGS_IS_SUBPROJECT
if (NOT BUILD_SHARED_LIBS AND NOT BUILD_STATIC_LIBS)
set (BUILD_STATIC_LIBS ON)
endif ()
if (NOT BUILD_gflags_LIB AND NOT BUILD_gflags_nothreads_LIB)
- message (FATAL_ERROR "At least one of BUILD_gflags_LIB and BUILD_gflags_nothreads_LIB must be ON.")
+ message (FATAL_ERROR "At least one of [GFLAGS_]BUILD_gflags_LIB and [GFLAGS_]BUILD_gflags_nothreads_LIB must be ON.")
endif ()
-if (NOT CMAKE_BUILD_TYPE AND NOT CMAKE_CXX_FLAGS)
- set_property (CACHE CMAKE_BUILD_TYPE PROPERTY VALUE Release)
+gflags_define (STRING INCLUDE_DIR "Name of include directory of installed header files relative to CMAKE_INSTALL_PREFIX/include/" "${PACKAGE_NAME}")
+gflags_property (INCLUDE_DIR ADVANCED TRUE)
+file (TO_CMAKE_PATH "${INCLUDE_DIR}" INCLUDE_DIR)
+if (IS_ABSOLUTE INCLUDE_DIR)
+ message (FATAL_ERROR "[GFLAGS_]INCLUDE_DIR must be a path relative to CMAKE_INSTALL_PREFIX/include/")
endif ()
-
-if (NOT GFLAGS_INCLUDE_DIR)
- set (GFLAGS_INCLUDE_DIR "${PACKAGE_NAME}" CACHE STRING "Name of include directory of installed header files")
- mark_as_advanced (GFLAGS_INCLUDE_DIR)
-else ()
- if (IS_ABSOLUTE GFLAGS_INCLUDE_DIR)
- message (FATAL_ERROR "GFLAGS_INCLUDE_DIR must be a path relative to CMAKE_INSTALL_PREFIX/include")
- endif ()
- if (GFLAGS_INCLUDE_DIR MATCHES "^\\.\\.[/\\]")
- message (FATAL_ERROR "GFLAGS_INCLUDE_DIR must not start with parent directory reference (../)")
- endif ()
+if (INCLUDE_DIR MATCHES "^\\.\\.[/\\]")
+ message (FATAL_ERROR "[GFLAGS_]INCLUDE_DIR must not start with parent directory reference (../)")
endif ()
+set (GFLAGS_INCLUDE_DIR "${INCLUDE_DIR}")
# ----------------------------------------------------------------------------
# system checks
@@ -112,12 +228,22 @@
if (MSVC)
set (HAVE_SYS_TYPES_H 1)
- set (HAVE_STDINT_H 1)
set (HAVE_STDDEF_H 1) # used by CheckTypeSize module
- set (HAVE_INTTYPES_H 0)
set (HAVE_UNISTD_H 0)
set (HAVE_SYS_STAT_H 1)
set (HAVE_SHLWAPI_H 1)
+ if (MSVC_VERSION VERSION_LESS 1600)
+ check_include_file_cxx ("stdint.h" HAVE_STDINT_H)
+ bool_to_int (HAVE_STDINT_H) # used in #if directive
+ else ()
+ set (HAVE_STDINT_H 1)
+ endif ()
+ if (MSVC_VERSION VERSION_LESS 1800)
+ check_include_file_cxx ("inttypes.h" HAVE_INTTYPES_H)
+ bool_to_int (HAVE_INTTYPES_H) # used in #if directive
+ else ()
+ set (HAVE_INTTYPES_H 1)
+ endif ()
else ()
foreach (fname IN ITEMS unistd stdint inttypes sys/types sys/stat fnmatch)
string (TOUPPER "${fname}" FNAME)
@@ -126,19 +252,19 @@
check_include_file_cxx ("${fname}.h" HAVE_${FNAME}_H)
endif ()
endforeach ()
+ if (NOT HAVE_FNMATCH_H AND OS_WINDOWS)
+ check_include_file_cxx ("shlwapi.h" HAVE_SHLWAPI_H)
+ endif ()
# the following are used in #if directives not #ifdef
bool_to_int (HAVE_STDINT_H)
bool_to_int (HAVE_SYS_TYPES_H)
bool_to_int (HAVE_INTTYPES_H)
- if (NOT HAVE_FNMATCH_H AND OS_WINDOWS)
- check_include_file_cxx ("shlwapi.h" HAVE_SHLWAPI_H)
- endif ()
endif ()
-set (GFLAGS_INTTYPES_FORMAT "" CACHE STRING "Format of integer types: \"C99\" (uint32_t), \"BSD\" (u_int32_t), \"VC7\" (__int32)")
-set_property (CACHE GFLAGS_INTTYPES_FORMAT PROPERTY STRINGS "C99;BSD;VC7")
-mark_as_advanced (GFLAGS_INTTYPES_FORMAT)
-if (NOT GFLAGS_INTTYPES_FORMAT)
+gflags_define (STRING INTTYPES_FORMAT "Format of integer types: \"C99\" (uint32_t), \"BSD\" (u_int32_t), \"VC7\" (__int32)" "")
+gflags_property (INTTYPES_FORMAT STRINGS "C99;BSD;VC7")
+gflags_property (INTTYPES_FORMAT ADVANCED TRUE)
+if (NOT INTTYPES_FORMAT)
set (TYPES uint32_t u_int32_t)
if (MSVC)
list (INSERT TYPES 0 __int32)
@@ -150,29 +276,30 @@
endif ()
endforeach ()
if (HAVE_uint32_t)
- set_property (CACHE GFLAGS_INTTYPES_FORMAT PROPERTY VALUE C99)
+ gflags_set (INTTYPES_FORMAT C99)
elseif (HAVE_u_int32_t)
- set_property (CACHE GFLAGS_INTTYPES_FORMAT PROPERTY VALUE BSD)
+ gflags_set (INTTYPES_FORMAT BSD)
elseif (HAVE___int32)
- set_property (CACHE GFLAGS_INTTYPES_FORMAT PROPERTY VALUE VC7)
+ gflags_set (INTTYPES_FORMAT VC7)
else ()
- mark_as_advanced (CLEAR GFLAGS_INTTYPES_FORMAT)
+ gflags_property (INTTYPES_FORMAT ADVANCED FALSE)
message (FATAL_ERROR "Do not know how to define a 32-bit integer quantity on your system!"
" Neither uint32_t, u_int32_t, nor __int32 seem to be available."
- " Set GFLAGS_INTTYPES_FORMAT to either C99, BSD, or VC7 and try again.")
+ " Set [GFLAGS_]INTTYPES_FORMAT to either C99, BSD, or VC7 and try again.")
endif ()
endif ()
# use of special characters in strings to circumvent bug #0008226
-if ("^${GFLAGS_INTTYPES_FORMAT}$" STREQUAL "^WIN$")
- set_property (CACHE GFLAGS_INTTYPES_FORMAT PROPERTY VALUE VC7)
+if ("^${INTTYPES_FORMAT}$" STREQUAL "^WIN$")
+ gflags_set (INTTYPES_FORMAT VC7)
endif ()
-if (NOT GFLAGS_INTTYPES_FORMAT MATCHES "^(C99|BSD|VC7)$")
- message (FATAL_ERROR "Invalid value for GFLAGS_INTTYPES_FORMAT! Choose one of \"C99\", \"BSD\", or \"VC7\"")
+if (NOT INTTYPES_FORMAT MATCHES "^(C99|BSD|VC7)$")
+ message (FATAL_ERROR "Invalid value for [GFLAGS_]INTTYPES_FORMAT! Choose one of \"C99\", \"BSD\", or \"VC7\"")
endif ()
+set (GFLAGS_INTTYPES_FORMAT "${INTTYPES_FORMAT}")
set (GFLAGS_INTTYPES_FORMAT_C99 0)
set (GFLAGS_INTTYPES_FORMAT_BSD 0)
set (GFLAGS_INTTYPES_FORMAT_VC7 0)
-set ("GFLAGS_INTTYPES_FORMAT_${GFLAGS_INTTYPES_FORMAT}" 1)
+set ("GFLAGS_INTTYPES_FORMAT_${INTTYPES_FORMAT}" 1)
if (MSVC)
set (HAVE_strtoll 0)
@@ -184,26 +311,29 @@
endif ()
endif ()
-set (CMAKE_THREAD_PREFER_PTHREAD TRUE)
-find_package (Threads)
-if (Threads_FOUND AND CMAKE_USE_PTHREADS_INIT)
- set (HAVE_PTHREAD 1)
- check_type_size (pthread_rwlock_t RWLOCK LANGUAGE CXX)
+if (BUILD_gflags_LIB)
+ set (CMAKE_THREAD_PREFER_PTHREAD TRUE)
+ find_package (Threads)
+ if (Threads_FOUND AND CMAKE_USE_PTHREADS_INIT)
+ set (HAVE_PTHREAD 1)
+ check_type_size (pthread_rwlock_t RWLOCK LANGUAGE CXX)
+ else ()
+ set (HAVE_PTHREAD 0)
+ endif ()
+ if (UNIX AND NOT HAVE_PTHREAD)
+ if (CMAKE_HAVE_PTHREAD_H)
+ set (what "library")
+ else ()
+ set (what ".h file")
+ endif ()
+ message (FATAL_ERROR "Could not find pthread${what}. Check the log file"
+ "\n\t${CMAKE_BINARY_DIR}${CMAKE_FILES_DIRECTORY}/CMakeError.log"
+ "\nor disable the build of the multi-threaded gflags library (BUILD_gflags_LIB=OFF).")
+ endif ()
else ()
set (HAVE_PTHREAD 0)
endif ()
-if (UNIX AND NOT HAVE_PTHREAD AND BUILD_gflags_LIB)
- if (CMAKE_HAVE_PTHREAD_H)
- set (what "library")
- else ()
- set (what ".h file")
- endif ()
- message (FATAL_ERROR "Could not find pthread${what}. Check the log file"
- "\n\t${CMAKE_BINARY_DIR}${CMAKE_FILES_DIRECTORY}/CMakeError.log"
- "\nor disable the build of the multi-threaded gflags library (BUILD_gflags_LIB=OFF).")
-endif ()
-
# ----------------------------------------------------------------------------
# source files - excluding root subdirectory and/or .in suffix
set (PUBLIC_HDRS
@@ -226,6 +356,7 @@
endif ()
set (PRIVATE_HDRS
+ "defines.h"
"config.h"
"util.h"
"mutex.h"
@@ -244,19 +375,25 @@
# ----------------------------------------------------------------------------
# configure source files
-if (CMAKE_COMPILER_IS_GNUCXX)
- set (GFLAGS_ATTRIBUTE_UNUSED "__attribute((unused))")
-else ()
- set (GFLAGS_ATTRIBUTE_UNUSED)
+if (NOT DEFINED GFLAGS_ATTRIBUTE_UNUSED)
+ if (CMAKE_COMPILER_IS_GNUCXX)
+ set (GFLAGS_ATTRIBUTE_UNUSED "__attribute((unused))")
+ else ()
+ set (GFLAGS_ATTRIBUTE_UNUSED)
+ endif ()
endif ()
# whenever we build a shared library (DLL on Windows), configure the public
-# headers of the API for use of this library rather than the optionally
+# headers of the API for use of this shared library rather than the optionally
# also build statically linked library; users can override GFLAGS_DLL_DECL
-if (BUILD_SHARED_LIBS)
- set (GFLAGS_IS_A_DLL 1)
-else ()
- set (GFLAGS_IS_A_DLL 0)
+# in particular, this done by setting the INTERFACE_COMPILE_DEFINITIONS of
+# static libraries to include an empty definition for GFLAGS_DLL_DECL
+if (NOT DEFINED GFLAGS_IS_A_DLL)
+ if (BUILD_SHARED_LIBS)
+ set (GFLAGS_IS_A_DLL 1)
+ else ()
+ set (GFLAGS_IS_A_DLL 0)
+ endif ()
endif ()
configure_headers (PUBLIC_HDRS ${PUBLIC_HDRS})
@@ -265,31 +402,36 @@
# ----------------------------------------------------------------------------
# output directories
-set (CMAKE_RUNTIME_OUTPUT_DIRECTORY "bin")
-set (CMAKE_LIBRARY_OUTPUT_DIRECTORY "lib")
-set (CMAKE_ARCHIVE_OUTPUT_DIRECTORY "lib")
+if (NOT GFLAGS_IS_SUBPROJECT)
+ set (CMAKE_RUNTIME_OUTPUT_DIRECTORY "bin")
+ set (CMAKE_LIBRARY_OUTPUT_DIRECTORY "lib")
+ set (CMAKE_ARCHIVE_OUTPUT_DIRECTORY "lib")
+endif ()
+# Set postfixes for generated libraries based on buildtype.
+set(CMAKE_RELEASE_POSTFIX "")
+set(CMAKE_DEBUG_POSTFIX "_debug")
# ----------------------------------------------------------------------------
# installation directories
if (OS_WINDOWS)
- set (RUNTIME_INSTALL_DIR Bin)
- set (LIBRARY_INSTALL_DIR Lib)
- set (INCLUDE_INSTALL_DIR Include)
- set (CONFIG_INSTALL_DIR CMake)
+ set (RUNTIME_INSTALL_DIR "bin")
+ set (LIBRARY_INSTALL_DIR "lib")
+ set (INCLUDE_INSTALL_DIR "include")
+ set (CONFIG_INSTALL_DIR "lib/cmake/${PACKAGE_NAME}")
+ set (PKGCONFIG_INSTALL_DIR)
else ()
set (RUNTIME_INSTALL_DIR bin)
# The LIB_INSTALL_DIR and LIB_SUFFIX variables are used by the Fedora
# package maintainers. Also package maintainers of other distribution
# packages need to be able to specify the name of the library directory.
- if (NOT LIB_INSTALL_DIR)
- set (LIB_INSTALL_DIR "lib${LIB_SUFFIX}")
+ if (NOT GFLAGS_LIBRARY_INSTALL_DIR AND LIB_INSTALL_DIR)
+ set (GFLAGS_LIBRARY_INSTALL_DIR "${LIB_INSTALL_DIR}")
endif ()
- set (LIBRARY_INSTALL_DIR "${LIB_INSTALL_DIR}"
- CACHE PATH "Directory of installed libraries, e.g., \"lib64\""
- )
- mark_as_advanced (LIBRARY_INSTALL_DIR)
+ gflags_define (PATH LIBRARY_INSTALL_DIR "Directory of installed libraries, e.g., \"lib64\"" "lib${LIB_SUFFIX}")
+ gflags_property (LIBRARY_INSTALL_DIR ADVANCED TRUE)
set (INCLUDE_INSTALL_DIR include)
set (CONFIG_INSTALL_DIR ${LIBRARY_INSTALL_DIR}/cmake/${PACKAGE_NAME})
+ set (PKGCONFIG_INSTALL_DIR ${LIBRARY_INSTALL_DIR}/pkgconfig)
endif ()
# ----------------------------------------------------------------------------
@@ -298,59 +440,110 @@
# static vs. shared
foreach (TYPE IN ITEMS STATIC SHARED)
if (BUILD_${TYPE}_LIBS)
+ string (TOLOWER "${TYPE}" type)
# whether or not targets are a DLL
if (OS_WINDOWS AND "^${TYPE}$" STREQUAL "^SHARED$")
set (GFLAGS_IS_A_DLL 1)
else ()
set (GFLAGS_IS_A_DLL 0)
endif ()
- string (TOLOWER "${TYPE}" type)
+ # filename suffix for static libraries on Windows
+ if (OS_WINDOWS AND "^${TYPE}$" STREQUAL "^STATIC$")
+ set (type_suffix "_${type}")
+ else ()
+ set (type_suffix "")
+ endif ()
# multi-threaded vs. single-threaded
foreach (opts IN ITEMS "" _nothreads)
if (BUILD_gflags${opts}_LIB)
- add_library (gflags${opts}-${type} ${TYPE} ${GFLAGS_SRCS} ${PRIVATE_HDRS} ${PUBLIC_HDRS})
+ set (target_name "gflags${opts}_${type}")
+ add_library (${target_name} ${TYPE} ${GFLAGS_SRCS} ${PRIVATE_HDRS} ${PUBLIC_HDRS})
+ set_target_properties (${target_name} PROPERTIES
+ OUTPUT_NAME "gflags${opts}${type_suffix}"
+ VERSION "${PACKAGE_VERSION}"
+ SOVERSION "${PACKAGE_SOVERSION}"
+ )
set (include_dirs "$<BUILD_INTERFACE:${PROJECT_BINARY_DIR}/include>")
if (INSTALL_HEADERS)
list (APPEND include_dirs "$<INSTALL_INTERFACE:${INCLUDE_INSTALL_DIR}>")
endif ()
- target_include_directories (gflags${opts}-${type}
+ target_include_directories (${target_name}
PUBLIC "${include_dirs}"
PRIVATE "${PROJECT_SOURCE_DIR}/src;${PROJECT_BINARY_DIR}/include/${GFLAGS_INCLUDE_DIR}"
)
+ target_compile_definitions (${target_name} PUBLIC GFLAGS_IS_A_DLL=${GFLAGS_IS_A_DLL})
if (opts MATCHES "nothreads")
- set (defines "GFLAGS_IS_A_DLL=${GFLAGS_IS_A_DLL};NOTHREADS")
- else ()
- set (defines "GFLAGS_IS_A_DLL=${GFLAGS_IS_A_DLL}")
- if (CMAKE_USE_PTHREADS_INIT)
- target_link_libraries (gflags${opts}-${type} ${CMAKE_THREAD_LIBS_INIT})
- endif ()
+ target_compile_definitions (${target_name} PRIVATE NO_THREADS)
+ elseif (CMAKE_USE_PTHREADS_INIT)
+ target_link_libraries (${target_name} ${CMAKE_THREAD_LIBS_INIT})
endif ()
- set_target_properties (
- gflags${opts}-${type} PROPERTIES COMPILE_DEFINITIONS "${defines}"
- OUTPUT_NAME "gflags${opts}"
- VERSION "${PACKAGE_VERSION}"
- SOVERSION "${PACKAGE_SOVERSION}"
- )
if (HAVE_SHLWAPI_H)
- target_link_libraries (gflags${opts}-${type} shlwapi.lib)
+ target_link_libraries (${target_name} shlwapi.lib)
endif ()
- if (NOT TARGET gflags${opts})
- add_custom_target (gflags${opts})
+ list (APPEND TARGETS ${target_name})
+ # add convenience make target for build of both shared and static libraries
+ if (NOT GFLAGS_IS_SUBPROJECT)
+ if (NOT TARGET gflags${opts})
+ add_custom_target (gflags${opts})
+ endif ()
+ add_dependencies (gflags${opts} ${target_name})
endif ()
- add_dependencies (gflags${opts} gflags${opts}-${type})
- list (APPEND TARGETS gflags${opts}-${type})
endif ()
endforeach ()
endif ()
endforeach ()
+# add ALIAS target for use in super-project, prefer static over shared, single-threaded over multi-threaded
+if (GFLAGS_IS_SUBPROJECT)
+ foreach (type IN ITEMS static shared)
+ foreach (opts IN ITEMS "_nothreads" "")
+ if (TARGET gflags${opts}_${type})
+ # Define "gflags" alias for super-projects treating targets of this library as part of their own project
+ # (also for backwards compatibility with gflags 2.2.1 which only defined this alias)
+ add_library (gflags ALIAS gflags${opts}_${type})
+ # Define "gflags::gflags" alias for projects that support both find_package(gflags) and add_subdirectory(gflags)
+ add_library (gflags::gflags ALIAS gflags${opts}_${type})
+ break ()
+ endif ()
+ endforeach ()
+ if (TARGET gflags::gflags)
+ break ()
+ endif ()
+ endforeach ()
+endif ()
+
# ----------------------------------------------------------------------------
# installation rules
+set (EXPORT_NAME ${PACKAGE_NAME}-targets)
file (RELATIVE_PATH INSTALL_PREFIX_REL2CONFIG_DIR "${CMAKE_INSTALL_PREFIX}/${CONFIG_INSTALL_DIR}" "${CMAKE_INSTALL_PREFIX}")
configure_file (cmake/config.cmake.in "${PROJECT_BINARY_DIR}/${PACKAGE_NAME}-config-install.cmake" @ONLY)
configure_file (cmake/version.cmake.in "${PROJECT_BINARY_DIR}/${PACKAGE_NAME}-config-version.cmake" @ONLY)
-install (TARGETS ${TARGETS} DESTINATION ${LIBRARY_INSTALL_DIR} EXPORT gflags-lib)
+if (BUILD_SHARED_LIBS AND INSTALL_SHARED_LIBS)
+ foreach (opts IN ITEMS "" _nothreads)
+ if (BUILD_gflags${opts}_LIB)
+ install (TARGETS gflags${opts}_shared
+ EXPORT ${EXPORT_NAME}
+ RUNTIME DESTINATION ${RUNTIME_INSTALL_DIR}
+ LIBRARY DESTINATION ${LIBRARY_INSTALL_DIR}
+ ARCHIVE DESTINATION ${LIBRARY_INSTALL_DIR}
+ )
+ endif ()
+ endforeach ()
+endif ()
+if (BUILD_STATIC_LIBS AND INSTALL_STATIC_LIBS)
+ foreach (opts IN ITEMS "" _nothreads)
+ if (BUILD_gflags${opts}_LIB)
+ install (TARGETS gflags${opts}_static
+ EXPORT ${EXPORT_NAME}
+ RUNTIME DESTINATION ${RUNTIME_INSTALL_DIR}
+ LIBRARY DESTINATION ${LIBRARY_INSTALL_DIR}
+ ARCHIVE DESTINATION ${LIBRARY_INSTALL_DIR}
+ )
+ endif ()
+ endforeach ()
+endif ()
+
if (INSTALL_HEADERS)
install (FILES ${PUBLIC_HDRS} DESTINATION ${INCLUDE_INSTALL_DIR}/${GFLAGS_INCLUDE_DIR})
install (
@@ -362,24 +555,50 @@
FILES "${PROJECT_BINARY_DIR}/${PACKAGE_NAME}-config-version.cmake"
DESTINATION ${CONFIG_INSTALL_DIR}
)
- install (EXPORT gflags-lib DESTINATION ${CONFIG_INSTALL_DIR} FILE ${PACKAGE_NAME}-export.cmake)
+ install (
+ EXPORT ${EXPORT_NAME}
+ NAMESPACE ${PACKAGE_NAME}::
+ DESTINATION ${CONFIG_INSTALL_DIR}
+ )
+ install (
+ EXPORT ${EXPORT_NAME}
+ FILE ${PACKAGE_NAME}-nonamespace-targets.cmake
+ DESTINATION ${CONFIG_INSTALL_DIR}
+ )
if (UNIX)
install (PROGRAMS src/gflags_completions.sh DESTINATION ${RUNTIME_INSTALL_DIR})
endif ()
endif ()
+if (PKGCONFIG_INSTALL_DIR)
+ configure_file ("cmake/package.pc.in" "${PROJECT_BINARY_DIR}/${PACKAGE_NAME}.pc" @ONLY)
+ install (FILES "${PROJECT_BINARY_DIR}/${PACKAGE_NAME}.pc" DESTINATION "${PKGCONFIG_INSTALL_DIR}")
+endif ()
+
# ----------------------------------------------------------------------------
# support direct use of build tree
set (INSTALL_PREFIX_REL2CONFIG_DIR .)
-export (TARGETS ${TARGETS} FILE "${PROJECT_BINARY_DIR}/${PACKAGE_NAME}-export.cmake")
-export (PACKAGE gflags)
+export (
+ TARGETS ${TARGETS}
+ NAMESPACE ${PACKAGE_NAME}::
+ FILE "${PROJECT_BINARY_DIR}/${EXPORT_NAME}.cmake"
+)
+export (
+ TARGETS ${TARGETS}
+ FILE "${PROJECT_BINARY_DIR}/${PACKAGE_NAME}-nonamespace-targets.cmake"
+)
+if (REGISTER_BUILD_DIR)
+ export (PACKAGE ${PACKAGE_NAME})
+endif ()
+if (REGISTER_INSTALL_PREFIX)
+ register_gflags_package(${CONFIG_INSTALL_DIR})
+endif ()
configure_file (cmake/config.cmake.in "${PROJECT_BINARY_DIR}/${PACKAGE_NAME}-config.cmake" @ONLY)
# ----------------------------------------------------------------------------
# testing - MUST follow the generation of the build tree config file
if (BUILD_TESTING)
include (CTest)
- enable_testing ()
add_subdirectory (test)
endif ()
@@ -393,10 +612,14 @@
"\n BUILD_SHARED_LIBS=ON"
"\n BUILD_STATIC_LIBS=OFF"
"\n INSTALL_HEADERS=OFF"
+ "\n INSTALL_SHARED_LIBS=ON"
"\nRecommended options for generation of development package:"
"\n BUILD_SHARED_LIBS=ON"
"\n BUILD_STATIC_LIBS=ON"
- "\n INSTALL_HEADERS=ON")
+ "\n INSTALL_HEADERS=ON"
+ "\n INSTALL_SHARED_LIBS=ON"
+ "\n INSTALL_STATIC_LIBS=ON"
+ )
endif ()
# default package generators
@@ -427,7 +650,7 @@
set (CPACK_PACKAGE_VERSION_MAJOR "${PACKAGE_VERSION_MAJOR}")
set (CPACK_PACKAGE_VERSION_MINOR "${PACKAGE_VERSION_MINOR}")
set (CPACK_PACKAGE_VERSION_PATCH "${PACKAGE_VERSION_PATCH}")
- set (CPACK_PACKAGE_DESCRIPTION_SUMMARY "A commandline flags library that allows for distributed flags.")
+ set (CPACK_PACKAGE_DESCRIPTION_SUMMARY "${PACKAGE_DESCRIPTION}")
set (CPACK_RESOURCE_FILE_WELCOME "${CMAKE_CURRENT_BINARY_DIR}/README.txt")
set (CPACK_RESOURCE_FILE_LICENSE "${CMAKE_CURRENT_LIST_DIR}/COPYING.txt")
set (CPACK_PACKAGE_DESCRIPTION_FILE "${CMAKE_CURRENT_BINARY_DIR}/README.txt")
@@ -439,7 +662,7 @@
# RPM package information -- used in cmake/package.cmake.in also for DEB
set (CPACK_RPM_PACKAGE_GROUP "Development/Libraries")
set (CPACK_RPM_PACKAGE_LICENSE "BSD")
- set (CPACK_RPM_PACKAGE_URL "http://schuhschuh.github.com/gflags")
+ set (CPACK_RPM_PACKAGE_URL "${PACKAGE_URL}")
set (CPACK_RPM_CHANGELOG_FILE "${CMAKE_CURRENT_LIST_DIR}/ChangeLog.txt")
if (INSTALL_HEADERS)
@@ -508,3 +731,11 @@
include (CPack)
endif () # BUILD_PACKAGING
+
+if (NOT GFLAGS_IS_SUBPROJECT AND NOT TARGET uninstall)
+ configure_file (
+ "${CMAKE_CURRENT_SOURCE_DIR}/cmake/cmake_uninstall.cmake.in"
+ "${CMAKE_CURRENT_BINARY_DIR}/cmake_uninstall.cmake" @ONLY
+ )
+ add_custom_target(uninstall COMMAND ${CMAKE_COMMAND} -P "${CMAKE_CURRENT_BINARY_DIR}/cmake_uninstall.cmake")
+endif ()
diff --git a/third_party/gflags/ChangeLog.txt b/third_party/gflags/ChangeLog.txt
index eea9f83..c26d0ab 100644
--- a/third_party/gflags/ChangeLog.txt
+++ b/third_party/gflags/ChangeLog.txt
@@ -1,3 +1,39 @@
+* Tue Jul 11 2017 - Andreas Schuh <andreas.schuh.84@gmail.com>
+
+- gflags: version 2.2.1
+- Link to online documentation in README
+- Merged 194: Include utils by file instead of CMAKE_MODULE_PATH search
+- Merged 195: Remove unused program_name variable
+- Merged 196: Enable language C for older CMake versions when needed
+- Merged 202: Changed include directory in bazel build
+- Merged 207: Mark single argument constructors in mutex.h as explicit
+- Merged 209: Use inttypes.h on VC++ 2013 and later
+- Merged 212: Fix statically linked gflags library with MSVC
+- Meregd 213: Modify installation paths on Windows for vcpkg
+- Merged 215: Fix static initialization order fiasco caused by global registry lock
+- Merged 216: Fix use of ARGC in CMake macros
+- Merged 222: Static code analyzer error regarding strncmp with empty kRootDir
+- Merged 224: Check HAVE_STDINT_H or HAVE_INTTYPES_H for older MSVC versions
+
+* Fri Nov 25 2016 - Andreas Schuh <andreas.schuh.84@gmail.com>
+
+- gflags: version 2.2.0
+- Merged 178: Implicitly convert dashes in option names to underscores
+- Merged 159: CI builds and automatic tests with Travis CI and AppVeyor
+- Merged 158: Use enum for flag value types
+- Merged 126: File name postfix for static libraries on Windows
+- Closed issue 120: Configure and install gflags.pc file for pkg-config users
+- Fixed issue 127: snprintf already defined when building with MSVC 2015
+- Fixed issue 51/138: Memory leaks reported by valgrind
+- Fixed issue 173: Validate flags only once
+- Fixed issue 168: Unsigned and signed comparison in gflags_reporting.cc
+- Fixed issues 176/153: Add -lpthread link argument to Bazel build, refactor BUILD rules
+- Fixed issue 89: Add GFLAGS_IS_A_DLL to imported CMake target INTERFACE_COMPILE_DEFINITIONS
+- Fixed issue 104: Set INTERFACE_INCLUDE_DIRECTORIES of exported CMake targets
+- Fixed issue 174: Missing gflags-targets.cmake file after installation
+- Fixed issue 186: Error linking to gflags IMPLIB with MSVC using CMake
+- Closed issue 106: Add example project to test use of gflags library
+
* Tue Mar 24 2014 - Andreas Schuh <andreas.schuh.84@gmail.com>
- gflags: version 2.1.2
diff --git a/third_party/gflags/INSTALL.md b/third_party/gflags/INSTALL.md
index b89d86d..76d7edd 100644
--- a/third_party/gflags/INSTALL.md
+++ b/third_party/gflags/INSTALL.md
@@ -8,10 +8,10 @@
For example on Debian/Ubuntu Linux, gflags can be installed using the
following command:
- sudo apt-get install gflags
+ sudo apt-get install libgflags-dev
-Compiling the source code
+Compiling the source code with CMake
=========================
The build system of gflags is since version 2.1 based on [CMake](http://cmake.org).
@@ -65,3 +65,19 @@
GFLAGS_INCLUDE_DIR | Name of headers installation directory relative to CMAKE_INSTALL_PREFIX.
LIBRARY_INSTALL_DIR | Name of library installation directory relative to CMAKE_INSTALL_PREFIX.
INSTALL_HEADERS | Request installation of public header files.
+
+Using gflags with [Bazel](http://bazel.io)
+=========================
+
+To use gflags in a Bazel project, map it in as an external dependency by editing
+your WORKSPACE file:
+
+ git_repository(
+ name = "com_github_gflags_gflags",
+ commit = "<INSERT COMMIT SHA HERE>",
+ remote = "https://github.com/gflags/gflags.git",
+ )
+
+You can then add `@com_github_gflags_gflags//:gflags` to the `deps` section of a
+`cc_binary` or `cc_library` rule, and `#include <gflags/gflags.h>` to include it
+in your source code.
diff --git a/third_party/gflags/README.md b/third_party/gflags/README.md
index 79bd202..9f3e3f2 100644
--- a/third_party/gflags/README.md
+++ b/third_party/gflags/README.md
@@ -1,3 +1,38 @@
+[](https://travis-ci.org/gflags/gflags)
+[](https://ci.appveyor.com/project/schuhschuh/gflags/branch/master)
+
+The documentation of the gflags library is available online at https://gflags.github.io/gflags/.
+
+11 July 2017
+------------
+
+I've just released gflags 2.2.1.
+
+This maintenance release primarily fixes build issues on Windows and
+false alarms reported by static code analyzers.
+
+Please report any further issues with this release using the GitHub issue tracker.
+
+
+25 November 2016
+----------------
+
+I've finally released gflags 2.2.0.
+
+This release adds support for use of the gflags library as external dependency
+not only in projects using CMake, but also [Bazel](https://bazel.build/),
+or [pkg-config](https://www.freedesktop.org/wiki/Software/pkg-config/).
+One new minor feature is added in this release: when a command flag argument
+contains dashes, these are implicitly converted to underscores.
+This is to allow those used to separate words of the flag name by dashes
+to do so, while the flag variable names are required to use underscores.
+
+Memory leaks reported by valgrind should be resolved by this release.
+This release fixes build errors with MS Visual Studio 2015.
+
+Please report any further issues with this release using the GitHub issue tracker.
+
+
24 March 2015
-------------
diff --git a/third_party/gflags/WORKSPACE b/third_party/gflags/WORKSPACE
new file mode 100644
index 0000000..f3707e9
--- /dev/null
+++ b/third_party/gflags/WORKSPACE
@@ -0,0 +1,6 @@
+# Copyright 2006 Google Inc. All Rights Reserved.
+# Use of this source code is governed by a BSD-style
+# license that can be found in the COPYING.txt file.
+
+# Bazel (http://bazel.io/) WORKSPACE file for gflags.
+workspace(name="com_github_gflags_gflags")
diff --git a/third_party/gflags/appveyor.yml b/third_party/gflags/appveyor.yml
new file mode 100644
index 0000000..a5110e5
--- /dev/null
+++ b/third_party/gflags/appveyor.yml
@@ -0,0 +1,68 @@
+# Configuration for continuous integration service at appveyor.com
+
+version: '{build}'
+
+os: Visual Studio 2015
+
+environment:
+ matrix:
+ - Toolset: v140
+ - Toolset: v120
+ - Toolset: v110
+ - Toolset: v100
+ - Toolset: v90
+
+platform:
+ - Win32
+ - x64
+
+configuration:
+ - Release
+
+matrix:
+ exclude:
+ - Toolset: v90
+ platform: x64
+ - Toolset: v100
+ platform: x64
+
+build:
+ verbosity: minimal
+
+before_build:
+- ps: |
+ Write-Output "Configuration: $env:CONFIGURATION"
+ Write-Output "Platform: $env:PLATFORM"
+ $generator = switch ($env:TOOLSET)
+ {
+ "v140" {"Visual Studio 14 2015"}
+ "v120" {"Visual Studio 12 2013"}
+ "v110" {"Visual Studio 11 2012"}
+ "v100" {"Visual Studio 10 2010"}
+ "v90" {"Visual Studio 9 2008"}
+ }
+ if ($env:PLATFORM -eq "x64")
+ {
+ $generator = "$generator Win64"
+ }
+
+build_script:
+- ps: |
+ md _build -Force | Out-Null
+ cd _build
+
+ & cmake -G "$generator" -D CMAKE_CONFIGURATION_TYPES="Debug;Release" -D GFLAGS_BUILD_TESTING=ON -D GFLAGS_BUILD_SHARED_LIBS=ON -D GFLAGS_BUILD_STATIC_LIBS=ON ..
+ if ($LastExitCode -ne 0) {
+ throw "Exec: $ErrorMessage"
+ }
+ & cmake --build . --config $env:CONFIGURATION
+ if ($LastExitCode -ne 0) {
+ throw "Exec: $ErrorMessage"
+ }
+
+test_script:
+- ps: |
+ & ctest -C $env:CONFIGURATION --output-on-failure
+ if ($LastExitCode -ne 0) {
+ throw "Exec: $ErrorMessage"
+ }
diff --git a/third_party/gflags/bazel/gflags.bzl b/third_party/gflags/bazel/gflags.bzl
new file mode 100644
index 0000000..5f2d20d
--- /dev/null
+++ b/third_party/gflags/bazel/gflags.bzl
@@ -0,0 +1,104 @@
+# ------------------------------------------------------------------------------
+# Add native rules to configure source files
+def gflags_sources(namespace=["google", "gflags"]):
+ native.genrule(
+ name = "gflags_declare_h",
+ srcs = ["src/gflags_declare.h.in"],
+ outs = ["gflags_declare.h"],
+ cmd = ("awk '{ " +
+ "gsub(/@GFLAGS_NAMESPACE@/, \"" + namespace[0] + "\"); " +
+ "gsub(/@(HAVE_STDINT_H|HAVE_SYS_TYPES_H|HAVE_INTTYPES_H|GFLAGS_INTTYPES_FORMAT_C99)@/, \"1\"); " +
+ "gsub(/@([A-Z0-9_]+)@/, \"0\"); " +
+ "print; }' $(<) > $(@)")
+ )
+ gflags_ns_h_files = []
+ for ns in namespace[1:]:
+ gflags_ns_h_file = "gflags_{}.h".format(ns)
+ native.genrule(
+ name = gflags_ns_h_file.replace('.', '_'),
+ srcs = ["src/gflags_ns.h.in"],
+ outs = [gflags_ns_h_file],
+ cmd = ("awk '{ " +
+ "gsub(/@ns@/, \"" + ns + "\"); " +
+ "gsub(/@NS@/, \"" + ns.upper() + "\"); " +
+ "print; }' $(<) > $(@)")
+ )
+ gflags_ns_h_files.append(gflags_ns_h_file)
+ native.genrule(
+ name = "gflags_h",
+ srcs = ["src/gflags.h.in"],
+ outs = ["gflags.h"],
+ cmd = ("awk '{ " +
+ "gsub(/@GFLAGS_ATTRIBUTE_UNUSED@/, \"\"); " +
+ "gsub(/@INCLUDE_GFLAGS_NS_H@/, \"" + '\n'.join(["#include \\\"gflags/{}\\\"".format(hdr) for hdr in gflags_ns_h_files]) + "\"); " +
+ "print; }' $(<) > $(@)")
+ )
+ native.genrule(
+ name = "gflags_completions_h",
+ srcs = ["src/gflags_completions.h.in"],
+ outs = ["gflags_completions.h"],
+ cmd = "awk '{ gsub(/@GFLAGS_NAMESPACE@/, \"" + namespace[0] + "\"); print; }' $(<) > $(@)"
+ )
+ hdrs = [":gflags_h", ":gflags_declare_h", ":gflags_completions_h"]
+ hdrs.extend([':' + hdr.replace('.', '_') for hdr in gflags_ns_h_files])
+ srcs = [
+ "src/config.h",
+ "src/gflags.cc",
+ "src/gflags_completions.cc",
+ "src/gflags_reporting.cc",
+ "src/mutex.h",
+ "src/util.h",
+ ] + select({
+ ":x64_windows": [
+ "src/windows_port.cc",
+ "src/windows_port.h",
+ ],
+ "//conditions:default": [],
+ })
+ return [hdrs, srcs]
+
+# ------------------------------------------------------------------------------
+# Add native rule to build gflags library
+def gflags_library(hdrs=[], srcs=[], threads=1):
+ name = "gflags"
+ copts = [
+ "-DGFLAGS_BAZEL_BUILD",
+ "-DGFLAGS_INTTYPES_FORMAT_C99",
+ "-DGFLAGS_IS_A_DLL=0",
+ # macros otherwise defined by CMake configured defines.h file
+ "-DHAVE_STDINT_H",
+ "-DHAVE_SYS_TYPES_H",
+ "-DHAVE_INTTYPES_H",
+ "-DHAVE_SYS_STAT_H",
+ "-DHAVE_STRTOLL",
+ "-DHAVE_STRTOQ",
+ "-DHAVE_RWLOCK",
+ "-Wno-format-nonliteral",
+ ] + select({
+ ":x64_windows": [
+ "-DOS_WINDOWS",
+ ],
+ "//conditions:default": [
+ "-DHAVE_UNISTD_H",
+ "-DHAVE_FNMATCH_H",
+ "-DHAVE_PTHREAD",
+ ],
+ })
+ linkopts = []
+ if threads:
+ linkopts += select({
+ ":x64_windows": [],
+ "//conditions:default": ["-lpthread"],
+ })
+ else:
+ name += "_nothreads"
+ copts += ["-DNO_THREADS"]
+ native.cc_library(
+ name = name,
+ hdrs = hdrs,
+ srcs = srcs,
+ copts = copts,
+ linkopts = linkopts,
+ visibility = ["//visibility:public"],
+ include_prefix = 'gflags'
+ )
diff --git a/third_party/gflags/cmake/cmake_uninstall.cmake.in b/third_party/gflags/cmake/cmake_uninstall.cmake.in
new file mode 100644
index 0000000..d00a516
--- /dev/null
+++ b/third_party/gflags/cmake/cmake_uninstall.cmake.in
@@ -0,0 +1,26 @@
+if(NOT EXISTS "@CMAKE_CURRENT_BINARY_DIR@/install_manifest.txt")
+ message(FATAL_ERROR "Cannot find install manifest: @CMAKE_CURRENT_BINARY_DIR@/install_manifest.txt")
+endif(NOT EXISTS "@CMAKE_CURRENT_BINARY_DIR@/install_manifest.txt")
+
+if (NOT DEFINED CMAKE_INSTALL_PREFIX)
+ set (CMAKE_INSTALL_PREFIX "@CMAKE_INSTALL_PREFIX@")
+endif ()
+ message(${CMAKE_INSTALL_PREFIX})
+
+file(READ "@CMAKE_CURRENT_BINARY_DIR@/install_manifest.txt" files)
+string(REGEX REPLACE "\n" ";" files "${files}")
+foreach(file ${files})
+ message(STATUS "Uninstalling $ENV{DESTDIR}${file}")
+ if(IS_SYMLINK "$ENV{DESTDIR}${file}" OR EXISTS "$ENV{DESTDIR}${file}")
+ exec_program(
+ "@CMAKE_COMMAND@" ARGS "-E remove \"$ENV{DESTDIR}${file}\""
+ OUTPUT_VARIABLE rm_out
+ RETURN_VALUE rm_retval
+ )
+ if(NOT "${rm_retval}" STREQUAL 0)
+ message(FATAL_ERROR "Problem when removing $ENV{DESTDIR}${file}")
+ endif(NOT "${rm_retval}" STREQUAL 0)
+ else(IS_SYMLINK "$ENV{DESTDIR}${file}" OR EXISTS "$ENV{DESTDIR}${file}")
+ message(STATUS "File $ENV{DESTDIR}${file} does not exist.")
+ endif(IS_SYMLINK "$ENV{DESTDIR}${file}" OR EXISTS "$ENV{DESTDIR}${file}")
+endforeach(file)
diff --git a/third_party/gflags/cmake/config.cmake.in b/third_party/gflags/cmake/config.cmake.in
index a7419c2..a512c2a 100644
--- a/third_party/gflags/cmake/config.cmake.in
+++ b/third_party/gflags/cmake/config.cmake.in
@@ -1,13 +1,27 @@
## gflags CMake configuration file
# library version information
-set (@PACKAGE_NAME@_VERSION_STRING "@PACKAGE_VERSION@")
-set (@PACKAGE_NAME@_VERSION_MAJOR @PACKAGE_VERSION_MAJOR@)
-set (@PACKAGE_NAME@_VERSION_MINOR @PACKAGE_VERSION_MINOR@)
-set (@PACKAGE_NAME@_VERSION_PATCH @PACKAGE_VERSION_PATCH@)
+set (@PACKAGE_PREFIX@_VERSION_STRING "@PACKAGE_VERSION@")
+set (@PACKAGE_PREFIX@_VERSION_MAJOR @PACKAGE_VERSION_MAJOR@)
+set (@PACKAGE_PREFIX@_VERSION_MINOR @PACKAGE_VERSION_MINOR@)
+set (@PACKAGE_PREFIX@_VERSION_PATCH @PACKAGE_VERSION_PATCH@)
# import targets
-include ("${CMAKE_CURRENT_LIST_DIR}/@PACKAGE_NAME@-export.cmake")
+if (NOT DEFINED @PACKAGE_PREFIX@_USE_TARGET_NAMESPACE)
+ set (@PACKAGE_PREFIX@_USE_TARGET_NAMESPACE FALSE)
+endif ()
+if (@PACKAGE_PREFIX@_USE_TARGET_NAMESPACE)
+ include ("${CMAKE_CURRENT_LIST_DIR}/@EXPORT_NAME@.cmake")
+ set (@PACKAGE_PREFIX@_TARGET_NAMESPACE @PACKAGE_NAME@)
+else ()
+ include ("${CMAKE_CURRENT_LIST_DIR}/@PACKAGE_NAME@-nonamespace-targets.cmake")
+ set (@PACKAGE_PREFIX@_TARGET_NAMESPACE)
+endif ()
+if (@PACKAGE_PREFIX@_TARGET_NAMESPACE)
+ set (@PACKAGE_PREFIX@_TARGET_PREFIX ${@PACKAGE_PREFIX@_TARGET_NAMESPACE}::)
+else ()
+ set (@PACKAGE_PREFIX@_TARGET_PREFIX)
+endif ()
# installation prefix
get_filename_component (CMAKE_CURRENT_LIST_DIR "${CMAKE_CURRENT_LIST_FILE}" PATH)
@@ -18,94 +32,152 @@
# Newer versions of CMake set the INTERFACE_INCLUDE_DIRECTORIES property
# of the imported targets. It is hence not necessary to add this path
# manually to the include search path for targets which link to gflags.
-set (@PACKAGE_NAME@_INCLUDE_DIR "${_INSTALL_PREFIX}/@INCLUDE_INSTALL_DIR@")
+set (@PACKAGE_PREFIX@_INCLUDE_DIR "${_INSTALL_PREFIX}/@INCLUDE_INSTALL_DIR@")
-# default settings
-if (NOT DEFINED @PACKAGE_NAME@_SHARED)
- if (TARGET @PACKAGE_NAME@-static OR TARGET @PACKAGE_NAME@_nothreads-static)
- set (@PACKAGE_NAME@_SHARED FALSE)
+if (@PACKAGE_NAME@_FIND_COMPONENTS)
+ foreach (@PACKAGE_NAME@_FIND_COMPONENT IN LISTS @PACKAGE_NAME@_FIND_COMPONENTS)
+ if (@PACKAGE_NAME@_FIND_REQUIRED_${@PACKAGE_NAME@_FIND_COMPONENT} AND NOT TARGET @PACKAGE_NAME@_${@PACKAGE_NAME@_FIND_COMPONENT})
+ message (FATAL_ERROR "Package @PACKAGE_NAME@ was installed without required component ${@PACKAGE_NAME@_FIND_COMPONENT}!")
+ endif ()
+ endforeach ()
+ list (GET @PACKAGE_NAME@_FIND_COMPONENTS 0 @PACKAGE_NAME@_FIND_COMPONENT)
+else ()
+ set (@PACKAGE_NAME@_FIND_COMPONENT)
+endif ()
+
+# default settings of @PACKAGE_PREFIX@_SHARED and @PACKAGE_PREFIX@_NOTHREADS
+#
+# It is recommended to use either one of the following find_package commands
+# instead of setting the @PACKAGE_PREFIX@_(SHARED|NOTHREADS) variables:
+# - find_package(@PACKAGE_NAME@ REQUIRED)
+# - find_package(@PACKAGE_NAME@ COMPONENTS nothreads_static)
+# - find_package(@PACKAGE_NAME@ COMPONENTS nothreads_shared)
+# - find_package(@PACKAGE_NAME@ COMPONENTS static)
+# - find_package(@PACKAGE_NAME@ COMPONENTS shared)
+if (NOT DEFINED @PACKAGE_PREFIX@_SHARED)
+ if (DEFINED @PACKAGE_NAME@_SHARED)
+ set (@PACKAGE_PREFIX@_SHARED ${@PACKAGE_NAME@_SHARED})
+ elseif (@PACKAGE_NAME@_FIND_COMPONENT)
+ if (@PACKAGE_NAME@_FIND_COMPONENT MATCHES "shared")
+ set (@PACKAGE_PREFIX@_SHARED TRUE)
+ else ()
+ set (@PACKAGE_PREFIX@_SHARED FALSE)
+ endif ()
+ elseif (TARGET ${@PACKAGE_PREFIX@_TARGET_PREFIX}@PACKAGE_NAME@_shared OR TARGET ${@PACKAGE_PREFIX@_TARGET_PREFIX}@PACKAGE_NAME@_nothreads_shared)
+ set (@PACKAGE_PREFIX@_SHARED TRUE)
else ()
- set (@PACKAGE_NAME@_SHARED TRUE)
+ set (@PACKAGE_PREFIX@_SHARED FALSE)
endif ()
endif ()
-if (NOT DEFINED @PACKAGE_NAME@_NOTHREADS)
- if (TARGET @PACKAGE_NAME@-static OR TARGET @PACKAGE_NAME@-shared)
- set (@PACKAGE_NAME@_NOTHREADS FALSE)
+if (NOT DEFINED @PACKAGE_PREFIX@_NOTHREADS)
+ if (DEFINED @PACKAGE_NAME@_NOTHREADS)
+ set (@PACKAGE_PREFIX@_NOTHREADS ${@PACKAGE_NAME@_NOTHREADS})
+ elseif (@PACKAGE_NAME@_FIND_COMPONENT)
+ if (@PACKAGE_NAME@_FIND_COMPONENT MATCHES "nothreads")
+ set (@PACKAGE_PREFIX@_NOTHREADS TRUE)
+ else ()
+ set (@PACKAGE_PREFIX@_NOTHREADS FALSE)
+ endif ()
+ elseif (TARGET ${@PACKAGE_PREFIX@_TARGET_PREFIX}PACKAGE_NAME@_static OR TARGET ${@PACKAGE_PREFIX@_TARGET_PREFIX}@PACKAGE_NAME@_shared)
+ set (@PACKAGE_PREFIX@_NOTHREADS FALSE)
else ()
- set (@PACKAGE_NAME@_NOTHREADS TRUE)
+ set (@PACKAGE_PREFIX@_NOTHREADS TRUE)
endif ()
endif ()
# choose imported library target
-if (NOT @PACKAGE_NAME@_TARGET)
- if (@PACKAGE_NAME@_SHARED)
- if (@PACKAGE_NAME@_NOTHREADS)
- set (@PACKAGE_NAME@_TARGET @PACKAGE_NAME@_nothreads-shared)
+if (NOT @PACKAGE_PREFIX@_TARGET)
+ if (@PACKAGE_NAME@_TARGET)
+ set (@PACKAGE_PREFIX@_TARGET ${@PACKAGE_NAME@_TARGET})
+ elseif (@PACKAGE_PREFIX@_SHARED)
+ if (@PACKAGE_PREFIX@_NOTHREADS)
+ set (@PACKAGE_PREFIX@_TARGET ${@PACKAGE_PREFIX@_TARGET_PREFIX}@PACKAGE_NAME@_nothreads_shared)
else ()
- set (@PACKAGE_NAME@_TARGET @PACKAGE_NAME@-shared)
+ set (@PACKAGE_PREFIX@_TARGET ${@PACKAGE_PREFIX@_TARGET_PREFIX}@PACKAGE_NAME@_shared)
endif ()
else ()
- if (@PACKAGE_NAME@_NOTHREADS)
- set (@PACKAGE_NAME@_TARGET @PACKAGE_NAME@_nothreads-static)
+ if (@PACKAGE_PREFIX@_NOTHREADS)
+ set (@PACKAGE_PREFIX@_TARGET ${@PACKAGE_PREFIX@_TARGET_PREFIX}@PACKAGE_NAME@_nothreads_static)
else ()
- set (@PACKAGE_NAME@_TARGET @PACKAGE_NAME@-static)
+ set (@PACKAGE_PREFIX@_TARGET ${@PACKAGE_PREFIX@_TARGET_PREFIX}@PACKAGE_NAME@_static)
endif ()
endif ()
endif ()
-if (NOT TARGET ${@PACKAGE_NAME@_TARGET})
- message (FATAL_ERROR "Your @PACKAGE_NAME@ installation does not contain a ${@PACKAGE_NAME@_TARGET} library target!"
- " Try a different combination of @PACKAGE_NAME@_SHARED and @PACKAGE_NAME@_NOTHREADS.")
+if (NOT TARGET ${@PACKAGE_PREFIX@_TARGET})
+ message (FATAL_ERROR "Your @PACKAGE_NAME@ installation does not contain a ${@PACKAGE_PREFIX@_TARGET} library target!"
+ " Try a different combination of @PACKAGE_PREFIX@_SHARED and @PACKAGE_PREFIX@_NOTHREADS.")
endif ()
-# add more convenient "@PACKAGE_NAME@" import target
-if (NOT TARGET @PACKAGE_NAME@)
- if (@PACKAGE_NAME@_SHARED)
- add_library (@PACKAGE_NAME@ SHARED IMPORTED)
+# add more convenient "${@PACKAGE_PREFIX@_TARGET_PREFIX}@PACKAGE_NAME@" import target
+if (NOT TARGET ${@PACKAGE_PREFIX@_TARGET_PREFIX}@PACKAGE_NAME@)
+ if (@PACKAGE_PREFIX@_SHARED)
+ add_library (${@PACKAGE_PREFIX@_TARGET_PREFIX}@PACKAGE_NAME@ SHARED IMPORTED)
else ()
- add_library (@PACKAGE_NAME@ STATIC IMPORTED)
+ add_library (${@PACKAGE_PREFIX@_TARGET_PREFIX}@PACKAGE_NAME@ STATIC IMPORTED)
endif ()
- # INTERFACE_INCLUDE_DIRECTORIES
- get_target_property (_@PACKAGE_NAME@_INCLUDES ${@PACKAGE_NAME@_TARGET} INTERFACE_INCLUDE_DIRECTORIES)
- if (_@PACKAGE_NAME@_INCLUDES)
- set_target_properties(@PACKAGE_NAME@ PROPERTIES
- INTERFACE_INCLUDE_DIRECTORIES "${_@PACKAGE_NAME@_INCLUDES}"
- )
- endif ()
- unset (_@PACKAGE_NAME@_INCLUDES)
- # set configuration specific properties
- get_target_property (_@PACKAGE_NAME@_CONFIGURATIONS ${@PACKAGE_NAME@_TARGET} IMPORTED_CONFIGURATIONS)
- set_target_properties (@PACKAGE_NAME@ PROPERTIES IMPORTED_CONFIGURATIONS "${_@PACKAGE_NAME@_CONFIGURATIONS}")
- foreach (_@PACKAGE_NAME@_CONFIG IN LISTS _@PACKAGE_NAME@_CONFIGURATIONS)
- # IMPORTED_LOCATION_<config>
- get_target_property (_@PACKAGE_NAME@_LOCATION ${@PACKAGE_NAME@_TARGET} IMPORTED_LOCATION_${_@PACKAGE_NAME@_CONFIG})
- if (_@PACKAGE_NAME@_LOCATION)
- set_target_properties(@PACKAGE_NAME@ PROPERTIES
- IMPORTED_LOCATION_${_@PACKAGE_NAME@_CONFIG} "${_@PACKAGE_NAME@_LOCATION}"
+ # copy INTERFACE_* properties
+ foreach (_@PACKAGE_PREFIX@_PROPERTY_NAME IN ITEMS
+ COMPILE_DEFINITIONS
+ COMPILE_FEATURES
+ COMPILE_OPTIONS
+ INCLUDE_DIRECTORIES
+ LINK_LIBRARIES
+ POSITION_INDEPENDENT_CODE
+ )
+ get_target_property (_@PACKAGE_PREFIX@_PROPERTY_VALUE ${@PACKAGE_PREFIX@_TARGET} INTERFACE_${_@PACKAGE_PREFIX@_PROPERTY_NAME})
+ if (_@PACKAGE_PREFIX@_PROPERTY_VALUE)
+ set_target_properties(${@PACKAGE_PREFIX@_TARGET_PREFIX}@PACKAGE_NAME@ PROPERTIES
+ INTERFACE_${_@PACKAGE_PREFIX@_PROPERTY_NAME} "${_@PACKAGE_PREFIX@_PROPERTY_VALUE}"
)
endif ()
- unset (_@PACKAGE_NAME@_LOCATION)
- # IMPORTED_LINK_INTERFACE_LANGUAGES_<config> (static)
- get_target_property (_@PACKAGE_NAME@_LANGUAGES ${@PACKAGE_NAME@_TARGET} IMPORTED_LINK_INTERFACE_LANGUAGES_${_@PACKAGE_NAME@_CONFIG})
- if (_@PACKAGE_NAME@_LANGUAGES)
- set_target_properties(@PACKAGE_NAME@ PROPERTIES
- IMPORTED_LINK_INTERFACE_LANGUAGES_${_@PACKAGE_NAME@_CONFIG} "${_@PACKAGE_NAME@_LANGUAGES}"
- )
- endif ()
- unset (_@PACKAGE_NAME@_LANGUAGES)
- # IMPORTED_SONAME_<config> (shared)
- get_target_property (_@PACKAGE_NAME@_SONAME ${@PACKAGE_NAME@_TARGET} IMPORTED_SONAME_${_@PACKAGE_NAME@_CONFIG})
- if (_@PACKAGE_NAME@_SONAME)
- set_target_properties(@PACKAGE_NAME@ PROPERTIES
- IMPORTED_SONAME_${_@PACKAGE_NAME@_CONFIG} "${_@PACKAGE_NAME@_SONAME}"
- )
- endif ()
- unset (_@PACKAGE_NAME@_SONAME)
endforeach ()
- unset (_@PACKAGE_NAME@_CONFIGURATIONS)
+ # copy IMPORTED_*_<CONFIG> properties
+ get_target_property (_@PACKAGE_PREFIX@_CONFIGURATIONS ${@PACKAGE_PREFIX@_TARGET} IMPORTED_CONFIGURATIONS)
+ set_target_properties (${@PACKAGE_PREFIX@_TARGET_PREFIX}@PACKAGE_NAME@ PROPERTIES IMPORTED_CONFIGURATIONS "${_@PACKAGE_PREFIX@_CONFIGURATIONS}")
+ foreach (_@PACKAGE_PREFIX@_PROPERTY_NAME IN ITEMS
+ IMPLIB
+ LOCATION
+ LINK_DEPENDENT_LIBRARIES
+ LINK_INTERFACE_LIBRARIES
+ LINK_INTERFACE_LANGUAGES
+ LINK_INTERFACE_MULTIPLICITY
+ NO_SONAME
+ SONAME
+ )
+ foreach (_@PACKAGE_PREFIX@_CONFIG IN LISTS _@PACKAGE_PREFIX@_CONFIGURATIONS)
+ get_target_property (_@PACKAGE_PREFIX@_PROPERTY_VALUE ${@PACKAGE_PREFIX@_TARGET} IMPORTED_${_@PACKAGE_PREFIX@_PROPERTY_NAME}_${_@PACKAGE_PREFIX@_CONFIG})
+ if (_@PACKAGE_PREFIX@_PROPERTY_VALUE)
+ set_target_properties(${@PACKAGE_PREFIX@_TARGET_PREFIX}@PACKAGE_NAME@ PROPERTIES
+ IMPORTED_${_@PACKAGE_PREFIX@_PROPERTY_NAME}_${_@PACKAGE_PREFIX@_CONFIG} "${_@PACKAGE_PREFIX@_PROPERTY_VALUE}"
+ )
+ endif ()
+ endforeach ()
+ endforeach ()
+ unset (_@PACKAGE_PREFIX@_CONFIGURATIONS)
+ unset (_@PACKAGE_PREFIX@_CONFIG)
+ unset (_@PACKAGE_PREFIX@_PROPERTY_NAME)
+ unset (_@PACKAGE_PREFIX@_PROPERTY_VALUE)
endif ()
# alias for default import target to be compatible with older CMake package configurations
-set (@PACKAGE_NAME@_LIBRARIES "${@PACKAGE_NAME@_TARGET}")
+set (@PACKAGE_PREFIX@_LIBRARIES "${@PACKAGE_PREFIX@_TARGET}")
+
+# set @PACKAGE_NAME@_* variables for backwards compatibility
+if (NOT "^@PACKAGE_NAME@$" STREQUAL "^@PACKAGE_PREFIX@$")
+ foreach (_@PACKAGE_PREFIX@_VARIABLE IN ITEMS
+ VERSION_STRING
+ VERSION_MAJOR
+ VERSION_MINOR
+ VERSION_PATCH
+ INCLUDE_DIR
+ LIBRARIES
+ TARGET
+ )
+ set (@PACKAGE_NAME@_${_@PACKAGE_PREFIX@_VARIABLE} "${@PACKAGE_PREFIX@_${_@PACKAGE_PREFIX@_VARIABLE}}")
+ endforeach ()
+ unset (_@PACKAGE_PREFIX@_VARIABLE)
+endif ()
# unset private variables
+unset (@PACKAGE_NAME@_FIND_COMPONENT)
unset (_INSTALL_PREFIX)
diff --git a/third_party/gflags/cmake/package.pc.in b/third_party/gflags/cmake/package.pc.in
new file mode 100644
index 0000000..80df818
--- /dev/null
+++ b/third_party/gflags/cmake/package.pc.in
@@ -0,0 +1,14 @@
+prefix=@CMAKE_INSTALL_PREFIX@
+exec_prefix=${prefix}
+bindir=${prefix}/@RUNTIME_INSTALL_DIR@
+libdir=${prefix}/@LIBRARY_INSTALL_DIR@
+includedir=${prefix}/@INCLUDE_INSTALL_DIR@
+
+Name: @PACKAGE_NAME@
+Version: @PACKAGE_VERSION@
+Description: @PACKAGE_DESCRIPTION@
+URL: @PACKAGE_URL@
+Requires:
+Libs: -L${libdir} -lgflags
+Libs.private: -lpthread
+Cflags: -I${includedir}
diff --git a/third_party/gflags/cmake/utils.cmake b/third_party/gflags/cmake/utils.cmake
index 9cef463..d039e5c 100644
--- a/third_party/gflags/cmake/utils.cmake
+++ b/third_party/gflags/cmake/utils.cmake
@@ -11,7 +11,7 @@
endmacro ()
# ----------------------------------------------------------------------------
-## Extract version numbers from version string.
+## Extract version numbers from version string
function (version_numbers version major minor patch)
if (version MATCHES "([0-9]+)(\\.[0-9]+)?(\\.[0-9]+)?(rc[1-9][0-9]*|[a-z]+)?")
if (CMAKE_MATCH_1)
@@ -42,6 +42,77 @@
endfunction ()
# ----------------------------------------------------------------------------
+## Determine if cache entry exists
+macro (gflags_is_cached retvar varname)
+ if (DEFINED ${varname})
+ get_property (${retvar} CACHE ${varname} PROPERTY TYPE SET)
+ else ()
+ set (${retvar} FALSE)
+ endif ()
+endmacro ()
+
+# ----------------------------------------------------------------------------
+## Add gflags configuration variable
+#
+# The default value of the (cached) configuration value can be overridden either
+# on the CMake command-line or the super-project by setting the GFLAGS_<varname>
+# variable. When gflags is a subproject of another project (GFLAGS_IS_SUBPROJECT),
+# the variable is not added to the CMake cache. Otherwise it is cached.
+macro (gflags_define type varname docstring default)
+ # note that ARGC must be expanded here, as it is not a "real" variable
+ # (see the CMake documentation for the macro command)
+ if ("${ARGC}" GREATER 5)
+ message (FATAL_ERROR "gflags_variable: Too many macro arguments")
+ endif ()
+ if (NOT DEFINED GFLAGS_${varname})
+ if (GFLAGS_IS_SUBPROJECT AND "${ARGC}" EQUAL 5)
+ set (GFLAGS_${varname} "${ARGV4}")
+ else ()
+ set (GFLAGS_${varname} "${default}")
+ endif ()
+ endif ()
+ if (GFLAGS_IS_SUBPROJECT)
+ if (NOT DEFINED ${varname})
+ set (${varname} "${GFLAGS_${varname}}")
+ endif ()
+ else ()
+ set (${varname} "${GFLAGS_${varname}}" CACHE ${type} "${docstring}")
+ endif ()
+endmacro ()
+
+# ----------------------------------------------------------------------------
+## Set property of cached gflags configuration variable
+macro (gflags_property varname property value)
+ gflags_is_cached (_cached ${varname})
+ if (_cached)
+ # note that property must be expanded here, as it is not a "real" variable
+ # (see the CMake documentation for the macro command)
+ if ("${property}" STREQUAL "ADVANCED")
+ if (${value})
+ mark_as_advanced (FORCE ${varname})
+ else ()
+ mark_as_advanced (CLEAR ${varname})
+ endif ()
+ else ()
+ set_property (CACHE ${varname} PROPERTY "${property}" "${value}")
+ endif ()
+ endif ()
+ unset (_cached)
+endmacro ()
+
+# ----------------------------------------------------------------------------
+## Modify value of gflags configuration variable
+macro (gflags_set varname value)
+ gflags_is_cached (_cached ${varname})
+ if (_cached)
+ set_property (CACHE ${varname} PROPERTY VALUE "${value}")
+ else ()
+ set (${varname} "${value}")
+ endif ()
+ unset (_cached)
+endmacro ()
+
+# ----------------------------------------------------------------------------
## Configure public header files
function (configure_headers out)
set (tmp)
@@ -94,3 +165,41 @@
WORKING_DIRECTORY "${GFLAGS_FLAGFILES_DIR}"
)
endmacro ()
+
+# ------------------------------------------------------------------------------
+## Register installed package with CMake
+#
+# This function adds an entry to the CMake registry for packages with the
+# path of the directory where the package configuration file of the installed
+# package is located in order to help CMake find the package in a custom
+# installation prefix. This differs from CMake's export(PACKAGE) command
+# which registers the build directory instead.
+function (register_gflags_package CONFIG_DIR)
+ if (NOT IS_ABSOLUTE "${CONFIG_DIR}")
+ set (CONFIG_DIR "${CMAKE_INSTALL_PREFIX}/${CONFIG_DIR}")
+ endif ()
+ string (MD5 REGISTRY_ENTRY "${CONFIG_DIR}")
+ if (WIN32)
+ install (CODE
+ "execute_process (
+ COMMAND reg add \"HKCU\\\\Software\\\\Kitware\\\\CMake\\\\Packages\\\\${PACKAGE_NAME}\" /v \"${REGISTRY_ENTRY}\" /d \"${CONFIG_DIR}\" /t REG_SZ /f
+ RESULT_VARIABLE RT
+ ERROR_VARIABLE ERR
+ OUTPUT_QUIET
+ )
+ if (RT EQUAL 0)
+ message (STATUS \"Register: Added HKEY_CURRENT_USER\\\\Software\\\\Kitware\\\\CMake\\\\Packages\\\\${PACKAGE_NAME}\\\\${REGISTRY_ENTRY}\")
+ else ()
+ string (STRIP \"\${ERR}\" ERR)
+ message (STATUS \"Register: Failed to add registry entry: \${ERR}\")
+ endif ()"
+ )
+ elseif (IS_DIRECTORY "$ENV{HOME}")
+ file (WRITE "${PROJECT_BINARY_DIR}/${PACKAGE_NAME}-registry-entry" "${CONFIG_DIR}")
+ install (
+ FILES "${PROJECT_BINARY_DIR}/${PACKAGE_NAME}-registry-entry"
+ DESTINATION "$ENV{HOME}/.cmake/packages/${PACKAGE_NAME}"
+ RENAME "${REGISTRY_ENTRY}"
+ )
+ endif ()
+endfunction ()
diff --git a/third_party/gflags/doc b/third_party/gflags/doc
index e1d15b3..679df49 160000
--- a/third_party/gflags/doc
+++ b/third_party/gflags/doc
@@ -1 +1 @@
-Subproject commit e1d15b33406ec571095e7a91dbc4b2ada1ae3bac
+Subproject commit 679df49798e2d9766975399baf063446e0957bba
diff --git a/third_party/gflags/src/config.h b/third_party/gflags/src/config.h
new file mode 100644
index 0000000..b90b7e6
--- /dev/null
+++ b/third_party/gflags/src/config.h
@@ -0,0 +1,57 @@
+// Note: This header file is only used internally. It is not part of public interface!
+
+#ifndef GFLAGS_CONFIG_H_
+#define GFLAGS_CONFIG_H_
+
+
+// ---------------------------------------------------------------------------
+// System checks
+
+// CMake build configuration is written to defines.h file, unused by Bazel build
+#if !defined(GFLAGS_BAZEL_BUILD)
+# include "defines.h"
+#endif
+
+// gcc requires this to get PRId64, etc.
+#if defined(HAVE_INTTYPES_H) && !defined(__STDC_FORMAT_MACROS)
+# define __STDC_FORMAT_MACROS 1
+#endif
+
+// ---------------------------------------------------------------------------
+// Path separator
+#ifndef PATH_SEPARATOR
+# ifdef OS_WINDOWS
+# define PATH_SEPARATOR '\\'
+# else
+# define PATH_SEPARATOR '/'
+# endif
+#endif
+
+// ---------------------------------------------------------------------------
+// Windows
+
+// Always export symbols when compiling a shared library as this file is only
+// included by internal modules when building the gflags library itself.
+// The gflags_declare.h header file will set it to import these symbols otherwise.
+#ifndef GFLAGS_DLL_DECL
+# if GFLAGS_IS_A_DLL && defined(_MSC_VER)
+# define GFLAGS_DLL_DECL __declspec(dllexport)
+# else
+# define GFLAGS_DLL_DECL
+# endif
+#endif
+// Flags defined by the gflags library itself must be exported
+#ifndef GFLAGS_DLL_DEFINE_FLAG
+# define GFLAGS_DLL_DEFINE_FLAG GFLAGS_DLL_DECL
+#endif
+
+#ifdef OS_WINDOWS
+// The unittests import the symbols of the shared gflags library
+# if GFLAGS_IS_A_DLL && defined(_MSC_VER)
+# define GFLAGS_DLL_DECL_FOR_UNITTESTS __declspec(dllimport)
+# endif
+# include "windows_port.h"
+#endif
+
+
+#endif // GFLAGS_CONFIG_H_
diff --git a/third_party/gflags/src/config.h.in b/third_party/gflags/src/config.h.in
deleted file mode 100644
index a8708da..0000000
--- a/third_party/gflags/src/config.h.in
+++ /dev/null
@@ -1,112 +0,0 @@
-/* Generated from config.h.in during build configuration using CMake. */
-
-// Note: This header file is only used internally. It is not part of public interface!
-
-// ---------------------------------------------------------------------------
-// System checks
-
-// Define if you build this library for a MS Windows OS.
-#cmakedefine OS_WINDOWS
-
-// Define if you have the <stdint.h> header file.
-#cmakedefine HAVE_STDINT_H
-
-// Define if you have the <sys/types.h> header file.
-#cmakedefine HAVE_SYS_TYPES_H
-
-// Define if you have the <inttypes.h> header file.
-#cmakedefine HAVE_INTTYPES_H
-
-// Define if you have the <sys/stat.h> header file.
-#cmakedefine HAVE_SYS_STAT_H
-
-// Define if you have the <unistd.h> header file.
-#cmakedefine HAVE_UNISTD_H
-
-// Define if you have the <fnmatch.h> header file.
-#cmakedefine HAVE_FNMATCH_H
-
-// Define if you have the <shlwapi.h> header file (Windows 2000/XP).
-#cmakedefine HAVE_SHLWAPI_H
-
-// Define if you have the strtoll function.
-#cmakedefine HAVE_STRTOLL
-
-// Define if you have the strtoq function.
-#cmakedefine HAVE_STRTOQ
-
-// Define if you have the <pthread.h> header file.
-#cmakedefine HAVE_PTHREAD
-
-// Define if your pthread library defines the type pthread_rwlock_t
-#cmakedefine HAVE_RWLOCK
-
-// gcc requires this to get PRId64, etc.
-#if defined(HAVE_INTTYPES_H) && !defined(__STDC_FORMAT_MACROS)
-# define __STDC_FORMAT_MACROS 1
-#endif
-
-// ---------------------------------------------------------------------------
-// Package information
-
-// Name of package.
-#define PACKAGE @PROJECT_NAME@
-
-// Define to the full name of this package.
-#define PACKAGE_NAME @PACKAGE_NAME@
-
-// Define to the full name and version of this package.
-#define PACKAGE_STRING @PACKAGE_STRING@
-
-// Define to the one symbol short name of this package.
-#define PACKAGE_TARNAME @PACKAGE_TARNAME@
-
-// Define to the version of this package.
-#define PACKAGE_VERSION @PACKAGE_VERSION@
-
-// Version number of package.
-#define VERSION PACKAGE_VERSION
-
-// Define to the address where bug reports for this package should be sent.
-#define PACKAGE_BUGREPORT @PACKAGE_BUGREPORT@
-
-// ---------------------------------------------------------------------------
-// Path separator
-#ifndef PATH_SEPARATOR
-# ifdef OS_WINDOWS
-# define PATH_SEPARATOR '\\'
-# else
-# define PATH_SEPARATOR '/'
-# endif
-#endif
-
-// ---------------------------------------------------------------------------
-// Windows
-
-// Whether gflags library is a DLL.
-#ifndef GFLAGS_IS_A_DLL
-# define GFLAGS_IS_A_DLL 0
-#endif
-
-// Always export symbols when compiling a shared library as this file is only
-// included by internal modules when building the gflags library itself.
-// The gflags_declare.h header file will set it to import these symbols otherwise.
-#ifndef GFLAGS_DLL_DECL
-# if GFLAGS_IS_A_DLL && defined(_MSC_VER)
-# define GFLAGS_DLL_DECL __declspec(dllexport)
-# else
-# define GFLAGS_DLL_DECL
-# endif
-#endif
-// Flags defined by the gflags library itself must be exported
-#ifndef GFLAGS_DLL_DEFINE_FLAG
-# define GFLAGS_DLL_DEFINE_FLAG GFLAGS_DLL_DECL
-#endif
-
-#ifdef OS_WINDOWS
-// The unittests import the symbols of the shared gflags library
-# if GFLAGS_IS_A_DLL && defined(_MSC_VER)
-# define GFLAGS_DLL_DECL_FOR_UNITTESTS __declspec(dllimport)
-# endif
-# include "windows_port.h"
-#endif
diff --git a/third_party/gflags/src/defines.h.in b/third_party/gflags/src/defines.h.in
new file mode 100644
index 0000000..dfb214e
--- /dev/null
+++ b/third_party/gflags/src/defines.h.in
@@ -0,0 +1,48 @@
+/* Generated from defines.h.in during build configuration using CMake. */
+
+// Note: This header file is only used internally. It is not part of public interface!
+// Any cmakedefine is defined using the -D flag instead when Bazel is used.
+// For Bazel, this file is thus not used to avoid a private file in $(GENDIR).
+
+#ifndef GFLAGS_DEFINES_H_
+#define GFLAGS_DEFINES_H_
+
+
+// Define if you build this library for a MS Windows OS.
+#cmakedefine OS_WINDOWS
+
+// Define if you have the <stdint.h> header file.
+#cmakedefine HAVE_STDINT_H
+
+// Define if you have the <sys/types.h> header file.
+#cmakedefine HAVE_SYS_TYPES_H
+
+// Define if you have the <inttypes.h> header file.
+#cmakedefine HAVE_INTTYPES_H
+
+// Define if you have the <sys/stat.h> header file.
+#cmakedefine HAVE_SYS_STAT_H
+
+// Define if you have the <unistd.h> header file.
+#cmakedefine HAVE_UNISTD_H
+
+// Define if you have the <fnmatch.h> header file.
+#cmakedefine HAVE_FNMATCH_H
+
+// Define if you have the <shlwapi.h> header file (Windows 2000/XP).
+#cmakedefine HAVE_SHLWAPI_H
+
+// Define if you have the strtoll function.
+#cmakedefine HAVE_STRTOLL
+
+// Define if you have the strtoq function.
+#cmakedefine HAVE_STRTOQ
+
+// Define if you have the <pthread.h> header file.
+#cmakedefine HAVE_PTHREAD
+
+// Define if your pthread library defines the type pthread_rwlock_t
+#cmakedefine HAVE_RWLOCK
+
+
+#endif // GFLAGS_DEFINES_H_
diff --git a/third_party/gflags/src/gflags.cc b/third_party/gflags/src/gflags.cc
index 285050f..e0171fe 100644
--- a/third_party/gflags/src/gflags.cc
+++ b/third_party/gflags/src/gflags.cc
@@ -88,7 +88,7 @@
// are, similarly, mostly hooks into the functionality described above.
#include "config.h"
-#include "gflags.h"
+#include "gflags/gflags.h"
#include <assert.h>
#include <ctype.h>
@@ -96,6 +96,7 @@
#if defined(HAVE_FNMATCH_H)
# include <fnmatch.h>
#elif defined(HAVE_SHLWAPI_H)
+# define NO_SHLWAPI_ISOS
# include <shlwapi.h>
#endif
#include <stdarg.h> // For va_list and related operations
@@ -111,6 +112,9 @@
#include "mutex.h"
#include "util.h"
+using namespace MUTEX_NAMESPACE;
+
+
// Special flags, type 1: the 'recursive' flags. They set another flag's val.
DEFINE_string(flagfile, "", "load flags from file");
DEFINE_string(fromenv, "", "set flags from the environment"
@@ -167,12 +171,10 @@
// Report Error and exit if requested.
static void ReportError(DieWhenReporting should_die, const char* format, ...) {
- char error_message[255];
va_list ap;
va_start(ap, format);
- vsnprintf(error_message, sizeof(error_message), format, ap);
+ vfprintf(stderr, format, ap);
va_end(ap);
- fprintf(stderr, "%s", error_message);
fflush(stderr); // should be unnecessary, but cygwin's rxvt buffers stderr
if (should_die == DIE) gflags_exitfunc(1);
}
@@ -188,34 +190,41 @@
class CommandLineFlag;
class FlagValue {
public:
- FlagValue(void* valbuf, const char* type, bool transfer_ownership_of_value);
+ enum ValueType {
+ FV_BOOL = 0,
+ FV_INT32 = 1,
+ FV_UINT32 = 2,
+ FV_INT64 = 3,
+ FV_UINT64 = 4,
+ FV_DOUBLE = 5,
+ FV_STRING = 6,
+ FV_MAX_INDEX = 6,
+ };
+
+ template <typename FlagType>
+ FlagValue(FlagType* valbuf, bool transfer_ownership_of_value);
~FlagValue();
bool ParseFrom(const char* spec);
string ToString() const;
+ ValueType Type() const { return static_cast<ValueType>(type_); }
+
private:
friend class CommandLineFlag; // for many things, including Validate()
friend class GFLAGS_NAMESPACE::FlagSaverImpl; // calls New()
friend class FlagRegistry; // checks value_buffer_ for flags_by_ptr_ map
- template <typename T> friend T GetFromEnv(const char*, const char*, T);
+ template <typename T> friend T GetFromEnv(const char*, T);
friend bool TryParseLocked(const CommandLineFlag*, FlagValue*,
const char*, string*); // for New(), CopyFrom()
- enum ValueType {
- FV_BOOL = 0,
- FV_INT32 = 1,
- FV_INT64 = 2,
- FV_UINT64 = 3,
- FV_DOUBLE = 4,
- FV_STRING = 5,
- FV_MAX_INDEX = 5,
- };
+ template <typename FlagType>
+ struct FlagValueTraits;
+
const char* TypeName() const;
bool Equal(const FlagValue& x) const;
FlagValue* New() const; // creates a new one with default value
void CopyFrom(const FlagValue& x);
- int ValueSize() const;
// Calls the given validate-fn on value_buffer_, and returns
// whatever it returns. But first casts validate_fn_proto to a
@@ -223,14 +232,33 @@
// (*validate_fn)(bool) for a bool flag).
bool Validate(const char* flagname, ValidateFnProto validate_fn_proto) const;
- void* value_buffer_; // points to the buffer holding our data
- int8 type_; // how to interpret value_
- bool owns_value_; // whether to free value on destruct
+ void* const value_buffer_; // points to the buffer holding our data
+ const int8 type_; // how to interpret value_
+ const bool owns_value_; // whether to free value on destruct
FlagValue(const FlagValue&); // no copying!
void operator=(const FlagValue&);
};
+// Map the given C++ type to a value of the ValueType enum at compile time.
+#define DEFINE_FLAG_TRAITS(type, value) \
+ template <> \
+ struct FlagValue::FlagValueTraits<type> { \
+ static const ValueType kValueType = value; \
+ }
+
+// Define full template specializations of the FlagValueTraits template
+// for all supported flag types.
+DEFINE_FLAG_TRAITS(bool, FV_BOOL);
+DEFINE_FLAG_TRAITS(int32, FV_INT32);
+DEFINE_FLAG_TRAITS(uint32, FV_UINT32);
+DEFINE_FLAG_TRAITS(int64, FV_INT64);
+DEFINE_FLAG_TRAITS(uint64, FV_UINT64);
+DEFINE_FLAG_TRAITS(double, FV_DOUBLE);
+DEFINE_FLAG_TRAITS(std::string, FV_STRING);
+
+#undef DEFINE_FLAG_TRAITS
+
// This could be a templated method of FlagValue, but doing so adds to the
// size of the .o. Since there's no type-safety here anyway, macro is ok.
@@ -238,16 +266,12 @@
#define OTHER_VALUE_AS(fv, type) *reinterpret_cast<type*>(fv.value_buffer_)
#define SET_VALUE_AS(type, value) VALUE_AS(type) = (value)
-FlagValue::FlagValue(void* valbuf, const char* type,
+template <typename FlagType>
+FlagValue::FlagValue(FlagType* valbuf,
bool transfer_ownership_of_value)
: value_buffer_(valbuf),
+ type_(FlagValueTraits<FlagType>::kValueType),
owns_value_(transfer_ownership_of_value) {
- for (type_ = 0; type_ <= FV_MAX_INDEX; ++type_) {
- if (!strcmp(type, TypeName())) {
- break;
- }
- }
- assert(type_ <= FV_MAX_INDEX); // Unknown typename
}
FlagValue::~FlagValue() {
@@ -257,6 +281,7 @@
switch (type_) {
case FV_BOOL: delete reinterpret_cast<bool*>(value_buffer_); break;
case FV_INT32: delete reinterpret_cast<int32*>(value_buffer_); break;
+ case FV_UINT32: delete reinterpret_cast<uint32*>(value_buffer_); break;
case FV_INT64: delete reinterpret_cast<int64*>(value_buffer_); break;
case FV_UINT64: delete reinterpret_cast<uint64*>(value_buffer_); break;
case FV_DOUBLE: delete reinterpret_cast<double*>(value_buffer_); break;
@@ -305,6 +330,16 @@
SET_VALUE_AS(int32, static_cast<int32>(r));
return true;
}
+ case FV_UINT32: {
+ while (*value == ' ') value++;
+ if (*value == '-') return false; // negative number
+ const uint64 r = strtou64(value, &end, base);
+ if (errno || end != value + strlen(value)) return false; // bad parse
+ if (static_cast<uint32>(r) != r) // worked, but number out of range
+ return false;
+ SET_VALUE_AS(uint32, static_cast<uint32>(r));
+ return true;
+ }
case FV_INT64: {
const int64 r = strto64(value, &end, base);
if (errno || end != value + strlen(value)) return false; // bad parse
@@ -340,6 +375,9 @@
case FV_INT32:
snprintf(intbuf, sizeof(intbuf), "%" PRId32, VALUE_AS(int32));
return intbuf;
+ case FV_UINT32:
+ snprintf(intbuf, sizeof(intbuf), "%" PRIu32, VALUE_AS(uint32));
+ return intbuf;
case FV_INT64:
snprintf(intbuf, sizeof(intbuf), "%" PRId64, VALUE_AS(int64));
return intbuf;
@@ -366,6 +404,9 @@
case FV_INT32:
return reinterpret_cast<bool (*)(const char*, int32)>(
validate_fn_proto)(flagname, VALUE_AS(int32));
+ case FV_UINT32:
+ return reinterpret_cast<bool (*)(const char*, uint32)>(
+ validate_fn_proto)(flagname, VALUE_AS(uint32));
case FV_INT64:
return reinterpret_cast<bool (*)(const char*, int64)>(
validate_fn_proto)(flagname, VALUE_AS(int64));
@@ -388,6 +429,7 @@
static const char types[] =
"bool\0xx"
"int32\0x"
+ "uint32\0"
"int64\0x"
"uint64\0"
"double\0"
@@ -406,6 +448,7 @@
switch (type_) {
case FV_BOOL: return VALUE_AS(bool) == OTHER_VALUE_AS(x, bool);
case FV_INT32: return VALUE_AS(int32) == OTHER_VALUE_AS(x, int32);
+ case FV_UINT32: return VALUE_AS(uint32) == OTHER_VALUE_AS(x, uint32);
case FV_INT64: return VALUE_AS(int64) == OTHER_VALUE_AS(x, int64);
case FV_UINT64: return VALUE_AS(uint64) == OTHER_VALUE_AS(x, uint64);
case FV_DOUBLE: return VALUE_AS(double) == OTHER_VALUE_AS(x, double);
@@ -415,14 +458,14 @@
}
FlagValue* FlagValue::New() const {
- const char *type = TypeName();
switch (type_) {
- case FV_BOOL: return new FlagValue(new bool(false), type, true);
- case FV_INT32: return new FlagValue(new int32(0), type, true);
- case FV_INT64: return new FlagValue(new int64(0), type, true);
- case FV_UINT64: return new FlagValue(new uint64(0), type, true);
- case FV_DOUBLE: return new FlagValue(new double(0.0), type, true);
- case FV_STRING: return new FlagValue(new string, type, true);
+ case FV_BOOL: return new FlagValue(new bool(false), true);
+ case FV_INT32: return new FlagValue(new int32(0), true);
+ case FV_UINT32: return new FlagValue(new uint32(0), true);
+ case FV_INT64: return new FlagValue(new int64(0), true);
+ case FV_UINT64: return new FlagValue(new uint64(0), true);
+ case FV_DOUBLE: return new FlagValue(new double(0.0), true);
+ case FV_STRING: return new FlagValue(new string, true);
default: assert(false); return NULL; // unknown type
}
}
@@ -432,6 +475,7 @@
switch (type_) {
case FV_BOOL: SET_VALUE_AS(bool, OTHER_VALUE_AS(x, bool)); break;
case FV_INT32: SET_VALUE_AS(int32, OTHER_VALUE_AS(x, int32)); break;
+ case FV_UINT32: SET_VALUE_AS(uint32, OTHER_VALUE_AS(x, uint32)); break;
case FV_INT64: SET_VALUE_AS(int64, OTHER_VALUE_AS(x, int64)); break;
case FV_UINT64: SET_VALUE_AS(uint64, OTHER_VALUE_AS(x, uint64)); break;
case FV_DOUBLE: SET_VALUE_AS(double, OTHER_VALUE_AS(x, double)); break;
@@ -440,22 +484,6 @@
}
}
-int FlagValue::ValueSize() const {
- if (type_ > FV_MAX_INDEX) {
- assert(false); // unknown type
- return 0;
- }
- static const uint8 valuesize[] = {
- sizeof(bool),
- sizeof(int32),
- sizeof(int64),
- sizeof(uint64),
- sizeof(double),
- sizeof(string),
- };
- return valuesize[type_];
-}
-
// --------------------------------------------------------------------
// CommandLineFlag
// This represents a single flag, including its name, description,
@@ -484,11 +512,14 @@
ValidateFnProto validate_function() const { return validate_fn_proto_; }
const void* flag_ptr() const { return current_->value_buffer_; }
+ FlagValue::ValueType Type() const { return defvalue_->Type(); }
+
void FillCommandLineFlagInfo(struct CommandLineFlagInfo* result);
// If validate_fn_proto_ is non-NULL, calls it on value, returns result.
bool Validate(const FlagValue& value) const;
bool ValidateCurrent() const { return Validate(*current_); }
+ bool Modified() const { return modified_; }
private:
// for SetFlagLocked() and setting flags_by_ptr_
@@ -531,26 +562,14 @@
}
const char* CommandLineFlag::CleanFileName() const {
- // Compute top-level directory & file that this appears in
- // search full path backwards.
- // Stop going backwards at kRootDir; and skip by the first slash.
- static const char kRootDir[] = ""; // can set this to root directory,
-
- if (sizeof(kRootDir)-1 == 0) // no prefix to strip
- return filename();
-
- const char* clean_name = filename() + strlen(filename()) - 1;
- while ( clean_name > filename() ) {
- if (*clean_name == PATH_SEPARATOR) {
- if (strncmp(clean_name, kRootDir, sizeof(kRootDir)-1) == 0) {
- clean_name += sizeof(kRootDir)-1; // past root-dir
- break;
- }
- }
- --clean_name;
- }
- while ( *clean_name == PATH_SEPARATOR ) ++clean_name; // Skip any slashes
- return clean_name;
+ // This function has been used to strip off a common prefix from
+ // flag source file names. Because flags can be defined in different
+ // shared libraries, there may not be a single common prefix.
+ // Further, this functionality hasn't been active for many years.
+ // Need a better way to produce more user friendly help output or
+ // "anonymize" file paths in help output, respectively.
+ // Follow issue at: https://github.com/gflags/gflags/issues/86
+ return filename();
}
void CommandLineFlag::FillCommandLineFlagInfo(
@@ -661,7 +680,7 @@
private:
friend class GFLAGS_NAMESPACE::FlagSaverImpl; // reads all the flags in order to copy them
- friend class CommandLineFlagParser; // for ValidateAllFlags
+ friend class CommandLineFlagParser; // for ValidateUnmodifiedFlags
friend void GFLAGS_NAMESPACE::GetAllFlags(vector<CommandLineFlagInfo>*);
// The map from name to flag, for FindFlagLocked().
@@ -677,7 +696,6 @@
static FlagRegistry* global_registry_; // a singleton registry
Mutex lock_;
- static Mutex global_registry_lock_;
static void InitGlobalRegistry();
@@ -722,7 +740,12 @@
CommandLineFlag* FlagRegistry::FindFlagLocked(const char* name) {
FlagConstIterator i = flags_.find(name);
if (i == flags_.end()) {
- return NULL;
+ // If the name has dashes in it, try again after replacing with
+ // underscores.
+ if (strchr(name, '-') == NULL) return NULL;
+ string name_rep = name;
+ std::replace(name_rep.begin(), name_rep.end(), '-', '_');
+ return FindFlagLocked(name_rep.c_str());
} else {
return i->second;
}
@@ -774,7 +797,7 @@
kError, key->c_str());
return NULL;
}
- if (strcmp(flag->type_name(), "bool") != 0) {
+ if (flag->Type() != FlagValue::FV_BOOL) {
// 'x' exists but is not boolean, so we're not in the exception case.
*error_message = StringPrintf(
"%sboolean value (%s) specified for %s command line flag\n",
@@ -788,7 +811,7 @@
}
// Assign a value if this is a boolean flag
- if (*v == NULL && strcmp(flag->type_name(), "bool") == 0) {
+ if (*v == NULL && flag->Type() == FlagValue::FV_BOOL) {
*v = "1"; // the --nox case was already handled, so this is the --x case
}
@@ -875,10 +898,10 @@
// Get the singleton FlagRegistry object
FlagRegistry* FlagRegistry::global_registry_ = NULL;
-Mutex FlagRegistry::global_registry_lock_(Mutex::LINKER_INITIALIZED);
FlagRegistry* FlagRegistry::GlobalRegistry() {
- MutexLock acquire_lock(&global_registry_lock_);
+ static Mutex lock(Mutex::LINKER_INITIALIZED);
+ MutexLock acquire_lock(&lock);
if (!global_registry_) {
global_registry_ = new FlagRegistry;
}
@@ -917,8 +940,9 @@
// In gflags_reporting.cc:HandleCommandLineHelpFlags().
// Stage 3: validate all the commandline flags that have validators
- // registered.
- void ValidateAllFlags();
+ // registered and were not set/modified by ParseNewCommandLineFlags.
+ void ValidateFlags(bool all);
+ void ValidateUnmodifiedFlags();
// Stage 4: report any errors and return true if any were found.
bool ReportErrors();
@@ -1005,9 +1029,6 @@
uint32 CommandLineFlagParser::ParseNewCommandLineFlags(int* argc, char*** argv,
bool remove_flags) {
- const char *program_name = strrchr((*argv)[0], PATH_SEPARATOR); // nix path
- program_name = (program_name == NULL ? (*argv)[0] : program_name+1);
-
int first_nonopt = *argc; // for non-options moved to the end
registry_->Lock();
@@ -1015,17 +1036,15 @@
char* arg = (*argv)[i];
// Like getopt(), we permute non-option flags to be at the end.
- if (arg[0] != '-' || // must be a program argument
- (arg[0] == '-' && arg[1] == '\0')) { // "-" is an argument, not a flag
+ if (arg[0] != '-' || arg[1] == '\0') { // must be a program argument: "-" is an argument, not a flag
memmove((*argv) + i, (*argv) + i+1, (*argc - (i+1)) * sizeof((*argv)[i]));
(*argv)[*argc-1] = arg; // we go last
first_nonopt--; // we've been pushed onto the stack
i--; // to undo the i++ in the loop
continue;
}
-
- if (arg[0] == '-') arg++; // allow leading '-'
- if (arg[0] == '-') arg++; // or leading '--'
+ arg++; // skip leading '-'
+ if (arg[0] == '-') arg++; // or leading '--'
// -- alone means what it does for GNU: stop options parsing
if (*arg == '\0') {
@@ -1047,7 +1066,7 @@
if (value == NULL) {
// Boolean options are always assigned a value by SplitArgumentLocked()
- assert(strcmp(flag->type_name(), "bool") != 0);
+ assert(flag->Type() != FlagValue::FV_BOOL);
if (i+1 >= first_nonopt) {
// This flag needs a value, but there is nothing available
error_flags_[key] = (string(kError) + "flag '" + (*argv)[i] + "'"
@@ -1072,7 +1091,7 @@
// "-lat -30.5" would trigger the warning. The common cases we
// want to solve talk about true and false as values.
if (value[0] == '-'
- && strcmp(flag->type_name(), "string") == 0
+ && flag->Type() == FlagValue::FV_STRING
&& (strstr(flag->help(), "true")
|| strstr(flag->help(), "false"))) {
LOG(WARNING) << "Did you really mean to set flag '"
@@ -1137,8 +1156,8 @@
}
const string envname = string("FLAGS_") + string(flagname);
- string envval;
- if (!SafeGetEnv(envname.c_str(), envval)) {
+ string envval;
+ if (!SafeGetEnv(envname.c_str(), envval)) {
if (errors_are_fatal) {
error_flags_[flagname] = (string(kError) + envname +
" not found in environment\n");
@@ -1184,23 +1203,31 @@
return msg;
}
-void CommandLineFlagParser::ValidateAllFlags() {
+void CommandLineFlagParser::ValidateFlags(bool all) {
FlagRegistryLock frl(registry_);
for (FlagRegistry::FlagConstIterator i = registry_->flags_.begin();
i != registry_->flags_.end(); ++i) {
- if (!i->second->ValidateCurrent()) {
+ if ((all || !i->second->Modified()) && !i->second->ValidateCurrent()) {
// only set a message if one isn't already there. (If there's
// an error message, our job is done, even if it's not exactly
// the same error.)
- if (error_flags_[i->second->name()].empty())
+ if (error_flags_[i->second->name()].empty()) {
error_flags_[i->second->name()] =
string(kError) + "--" + i->second->name() +
- " must be set on the commandline"
- " (default value fails validation)\n";
+ " must be set on the commandline";
+ if (!i->second->Modified()) {
+ error_flags_[i->second->name()] += " (default value fails validation)";
+ }
+ error_flags_[i->second->name()] += "\n";
+ }
}
}
}
+void CommandLineFlagParser::ValidateUnmodifiedFlags() {
+ ValidateFlags(false);
+}
+
bool CommandLineFlagParser::ReportErrors() {
// error_flags_ indicates errors we saw while parsing.
// But we ignore undefined-names if ok'ed by --undef_ok
@@ -1252,7 +1279,11 @@
for (; line_end; flagfile_contents = line_end + 1) {
while (*flagfile_contents && isspace(*flagfile_contents))
++flagfile_contents;
- line_end = strchr(flagfile_contents, '\n');
+ // Windows uses "\r\n"
+ line_end = strchr(flagfile_contents, '\r');
+ if (line_end == NULL)
+ line_end = strchr(flagfile_contents, '\n');
+
size_t len = line_end ? line_end - flagfile_contents
: strlen(flagfile_contents);
string line(flagfile_contents, len);
@@ -1332,14 +1363,14 @@
// --------------------------------------------------------------------
template<typename T>
-T GetFromEnv(const char *varname, const char* type, T dflt) {
+T GetFromEnv(const char *varname, T dflt) {
std::string valstr;
if (SafeGetEnv(varname, valstr)) {
- FlagValue ifv(new T, type, true);
+ FlagValue ifv(new T, true);
if (!ifv.ParseFrom(valstr.c_str())) {
ReportError(DIE, "ERROR: error parsing env variable '%s' with value '%s'\n",
varname, valstr.c_str());
- }
+ }
return OTHER_VALUE_AS(ifv, T);
} else return dflt;
}
@@ -1386,22 +1417,48 @@
// values in a global destructor.
// --------------------------------------------------------------------
-FlagRegisterer::FlagRegisterer(const char* name, const char* type,
- const char* help, const char* filename,
- void* current_storage, void* defvalue_storage) {
+namespace {
+void RegisterCommandLineFlag(const char* name,
+ const char* help,
+ const char* filename,
+ FlagValue* current,
+ FlagValue* defvalue) {
if (help == NULL)
help = "";
- // FlagValue expects the type-name to not include any namespace
- // components, so we get rid of those, if any.
- if (strchr(type, ':'))
- type = strrchr(type, ':') + 1;
- FlagValue* current = new FlagValue(current_storage, type, false);
- FlagValue* defvalue = new FlagValue(defvalue_storage, type, false);
// Importantly, flag_ will never be deleted, so storage is always good.
- CommandLineFlag* flag = new CommandLineFlag(name, help, filename,
- current, defvalue);
- FlagRegistry::GlobalRegistry()->RegisterFlag(flag); // default registry
+ CommandLineFlag* flag =
+ new CommandLineFlag(name, help, filename, current, defvalue);
+ FlagRegistry::GlobalRegistry()->RegisterFlag(flag); // default registry
}
+}
+
+template <typename FlagType>
+FlagRegisterer::FlagRegisterer(const char* name,
+ const char* help,
+ const char* filename,
+ FlagType* current_storage,
+ FlagType* defvalue_storage) {
+ FlagValue* const current = new FlagValue(current_storage, false);
+ FlagValue* const defvalue = new FlagValue(defvalue_storage, false);
+ RegisterCommandLineFlag(name, help, filename, current, defvalue);
+}
+
+// Force compiler to generate code for the given template specialization.
+#define INSTANTIATE_FLAG_REGISTERER_CTOR(type) \
+ template GFLAGS_DLL_DECL FlagRegisterer::FlagRegisterer( \
+ const char* name, const char* help, const char* filename, \
+ type* current_storage, type* defvalue_storage)
+
+// Do this for all supported flag types.
+INSTANTIATE_FLAG_REGISTERER_CTOR(bool);
+INSTANTIATE_FLAG_REGISTERER_CTOR(int32);
+INSTANTIATE_FLAG_REGISTERER_CTOR(uint32);
+INSTANTIATE_FLAG_REGISTERER_CTOR(int64);
+INSTANTIATE_FLAG_REGISTERER_CTOR(uint64);
+INSTANTIATE_FLAG_REGISTERER_CTOR(double);
+INSTANTIATE_FLAG_REGISTERER_CTOR(std::string);
+
+#undef INSTANTIATE_FLAG_REGISTERER_CTOR
// --------------------------------------------------------------------
// GetAllFlags()
@@ -1451,65 +1508,58 @@
// These values are not protected by a Mutex because they are normally
// set only once during program startup.
-static const char* argv0 = "UNKNOWN"; // just the program name
-static const char* cmdline = ""; // the entire command-line
+static string argv0("UNKNOWN"); // just the program name
+static string cmdline; // the entire command-line
+static string program_usage;
static vector<string> argvs;
static uint32 argv_sum = 0;
-static const char* program_usage = NULL;
void SetArgv(int argc, const char** argv) {
static bool called_set_argv = false;
- if (called_set_argv) // we already have an argv for you
- return;
-
+ if (called_set_argv) return;
called_set_argv = true;
- assert(argc > 0); // every program has at least a progname
- argv0 = strdup(argv[0]); // small memory leak, but fn only called once
- assert(argv0);
+ assert(argc > 0); // every program has at least a name
+ argv0 = argv[0];
- string cmdline_string; // easier than doing strcats
+ cmdline.clear();
for (int i = 0; i < argc; i++) {
- if (i != 0) {
- cmdline_string += " ";
- }
- cmdline_string += argv[i];
+ if (i != 0) cmdline += " ";
+ cmdline += argv[i];
argvs.push_back(argv[i]);
}
- cmdline = strdup(cmdline_string.c_str()); // another small memory leak
- assert(cmdline);
// Compute a simple sum of all the chars in argv
- for (const char* c = cmdline; *c; c++)
+ argv_sum = 0;
+ for (string::const_iterator c = cmdline.begin(); c != cmdline.end(); ++c) {
argv_sum += *c;
+ }
}
const vector<string>& GetArgvs() { return argvs; }
-const char* GetArgv() { return cmdline; }
-const char* GetArgv0() { return argv0; }
+const char* GetArgv() { return cmdline.c_str(); }
+const char* GetArgv0() { return argv0.c_str(); }
uint32 GetArgvSum() { return argv_sum; }
const char* ProgramInvocationName() { // like the GNU libc fn
return GetArgv0();
}
const char* ProgramInvocationShortName() { // like the GNU libc fn
- const char* slash = strrchr(argv0, '/');
+ size_t pos = argv0.rfind('/');
#ifdef OS_WINDOWS
- if (!slash) slash = strrchr(argv0, '\\');
+ if (pos == string::npos) pos = argv0.rfind('\\');
#endif
- return slash ? slash + 1 : argv0;
+ return (pos == string::npos ? argv0.c_str() : (argv0.c_str() + pos + 1));
}
void SetUsageMessage(const string& usage) {
- if (program_usage != NULL)
- ReportError(DIE, "ERROR: SetUsageMessage() called twice\n");
- program_usage = strdup(usage.c_str()); // small memory leak
+ program_usage = usage;
}
const char* ProgramUsage() {
- if (program_usage) {
- return program_usage;
+ if (program_usage.empty()) {
+ return "Warning: SetUsageMessage() never called";
}
- return "Warning: SetUsageMessage() never called";
+ return program_usage.c_str();
}
// --------------------------------------------------------------------
@@ -1517,16 +1567,14 @@
// VersionString()
// --------------------------------------------------------------------
-static const char* version_string = NULL;
+static string version_string;
void SetVersionString(const string& version) {
- if (version_string != NULL)
- ReportError(DIE, "ERROR: SetVersionString() called twice\n");
- version_string = strdup(version.c_str()); // small memory leak
+ version_string = version;
}
const char* VersionString() {
- return version_string ? version_string : "";
+ return version_string.c_str();
}
@@ -1787,6 +1835,7 @@
// --------------------------------------------------------------------
// BoolFromEnv()
// Int32FromEnv()
+// Uint32FromEnv()
// Int64FromEnv()
// Uint64FromEnv()
// DoubleFromEnv()
@@ -1798,19 +1847,22 @@
// --------------------------------------------------------------------
bool BoolFromEnv(const char *v, bool dflt) {
- return GetFromEnv(v, "bool", dflt);
+ return GetFromEnv(v, dflt);
}
int32 Int32FromEnv(const char *v, int32 dflt) {
- return GetFromEnv(v, "int32", dflt);
+ return GetFromEnv(v, dflt);
+}
+uint32 Uint32FromEnv(const char *v, uint32 dflt) {
+ return GetFromEnv(v, dflt);
}
int64 Int64FromEnv(const char *v, int64 dflt) {
- return GetFromEnv(v, "int64", dflt);
+ return GetFromEnv(v, dflt);
}
uint64 Uint64FromEnv(const char *v, uint64 dflt) {
- return GetFromEnv(v, "uint64", dflt);
+ return GetFromEnv(v, dflt);
}
double DoubleFromEnv(const char *v, double dflt) {
- return GetFromEnv(v, "double", dflt);
+ return GetFromEnv(v, dflt);
}
#ifdef _MSC_VER
@@ -1846,6 +1898,10 @@
bool (*validate_fn)(const char*, int32)) {
return AddFlagValidator(flag, reinterpret_cast<ValidateFnProto>(validate_fn));
}
+bool RegisterFlagValidator(const uint32* flag,
+ bool (*validate_fn)(const char*, uint32)) {
+ return AddFlagValidator(flag, reinterpret_cast<ValidateFnProto>(validate_fn));
+}
bool RegisterFlagValidator(const int64* flag,
bool (*validate_fn)(const char*, int64)) {
return AddFlagValidator(flag, reinterpret_cast<ValidateFnProto>(validate_fn));
@@ -1901,7 +1957,7 @@
HandleCommandLineHelpFlags(); // may cause us to exit on --help, etc.
// See if any of the unset flags fail their validation checks
- parser.ValidateAllFlags();
+ parser.ValidateUnmodifiedFlags();
if (parser.ReportErrors()) // may cause us to exit on illegal flags
gflags_exitfunc(1);
diff --git a/third_party/gflags/src/gflags.h.in b/third_party/gflags/src/gflags.h.in
index 0324d39..7b218b9 100644
--- a/third_party/gflags/src/gflags.h.in
+++ b/third_party/gflags/src/gflags.h.in
@@ -81,12 +81,12 @@
#include <string>
#include <vector>
-#include "gflags_declare.h" // IWYU pragma: export
+#include "gflags/gflags_declare.h" // IWYU pragma: export
// We always want to export variables defined in user code
#ifndef GFLAGS_DLL_DEFINE_FLAG
-# ifdef _MSC_VER
+# if GFLAGS_IS_A_DLL && defined(_MSC_VER)
# define GFLAGS_DLL_DEFINE_FLAG __declspec(dllexport)
# else
# define GFLAGS_DLL_DEFINE_FLAG
@@ -128,6 +128,7 @@
// validator is already registered for this flag).
extern GFLAGS_DLL_DECL bool RegisterFlagValidator(const bool* flag, bool (*validate_fn)(const char*, bool));
extern GFLAGS_DLL_DECL bool RegisterFlagValidator(const int32* flag, bool (*validate_fn)(const char*, int32));
+extern GFLAGS_DLL_DECL bool RegisterFlagValidator(const uint32* flag, bool (*validate_fn)(const char*, uint32));
extern GFLAGS_DLL_DECL bool RegisterFlagValidator(const int64* flag, bool (*validate_fn)(const char*, int64));
extern GFLAGS_DLL_DECL bool RegisterFlagValidator(const uint64* flag, bool (*validate_fn)(const char*, uint64));
extern GFLAGS_DLL_DECL bool RegisterFlagValidator(const double* flag, bool (*validate_fn)(const char*, double));
@@ -313,6 +314,7 @@
extern GFLAGS_DLL_DECL bool BoolFromEnv(const char *varname, bool defval);
extern GFLAGS_DLL_DECL int32 Int32FromEnv(const char *varname, int32 defval);
+extern GFLAGS_DLL_DECL uint32 Uint32FromEnv(const char *varname, uint32 defval);
extern GFLAGS_DLL_DECL int64 Int64FromEnv(const char *varname, int64 defval);
extern GFLAGS_DLL_DECL uint64 Uint64FromEnv(const char *varname, uint64 defval);
extern GFLAGS_DLL_DECL double DoubleFromEnv(const char *varname, double defval);
@@ -429,11 +431,37 @@
class GFLAGS_DLL_DECL FlagRegisterer {
public:
- FlagRegisterer(const char* name, const char* type,
+ // We instantiate this template ctor for all supported types,
+ // so it is possible to place implementation of the FlagRegisterer ctor in
+ // .cc file.
+ // Calling this constructor with unsupported type will produce linker error.
+ template <typename FlagType>
+ FlagRegisterer(const char* name,
const char* help, const char* filename,
- void* current_storage, void* defvalue_storage);
+ FlagType* current_storage, FlagType* defvalue_storage);
};
+// Force compiler to not generate code for the given template specialization.
+#if defined(_MSC_VER) && _MSC_VER < 1800 // Visual Studio 2013 version 12.0
+ #define GFLAGS_DECLARE_FLAG_REGISTERER_CTOR(type)
+#else
+ #define GFLAGS_DECLARE_FLAG_REGISTERER_CTOR(type) \
+ extern template GFLAGS_DLL_DECL FlagRegisterer::FlagRegisterer( \
+ const char* name, const char* help, const char* filename, \
+ type* current_storage, type* defvalue_storage)
+#endif
+
+// Do this for all supported flag types.
+GFLAGS_DECLARE_FLAG_REGISTERER_CTOR(bool);
+GFLAGS_DECLARE_FLAG_REGISTERER_CTOR(int32);
+GFLAGS_DECLARE_FLAG_REGISTERER_CTOR(uint32);
+GFLAGS_DECLARE_FLAG_REGISTERER_CTOR(int64);
+GFLAGS_DECLARE_FLAG_REGISTERER_CTOR(uint64);
+GFLAGS_DECLARE_FLAG_REGISTERER_CTOR(double);
+GFLAGS_DECLARE_FLAG_REGISTERER_CTOR(std::string);
+
+#undef GFLAGS_DECLARE_FLAG_REGISTERER_CTOR
+
// If your application #defines STRIP_FLAG_HELP to a non-zero value
// before #including this file, we remove the help message from the
// binary file. This can reduce the size of the resulting binary
@@ -471,9 +499,9 @@
static const type FLAGS_nono##name = value; \
/* We always want to export defined variables, dll or no */ \
GFLAGS_DLL_DEFINE_FLAG type FLAGS_##name = FLAGS_nono##name; \
- type FLAGS_no##name = FLAGS_nono##name; \
+ static type FLAGS_no##name = FLAGS_nono##name; \
static GFLAGS_NAMESPACE::FlagRegisterer o_##name( \
- #name, #type, MAYBE_STRIPPED_HELP(help), __FILE__, \
+ #name, MAYBE_STRIPPED_HELP(help), __FILE__, \
&FLAGS_##name, &FLAGS_no##name); \
} \
using fL##shorttype::FLAGS_##name
@@ -508,6 +536,10 @@
DEFINE_VARIABLE(GFLAGS_NAMESPACE::int32, I, \
name, val, txt)
+#define DEFINE_uint32(name,val, txt) \
+ DEFINE_VARIABLE(GFLAGS_NAMESPACE::uint32, U, \
+ name, val, txt)
+
#define DEFINE_int64(name, val, txt) \
DEFINE_VARIABLE(GFLAGS_NAMESPACE::int64, I64, \
name, val, txt)
@@ -538,6 +570,26 @@
}
inline clstring* dont_pass0toDEFINE_string(char *stringspot,
int value);
+
+// Auxiliary class used to explicitly call destructor of string objects
+// allocated using placement new during static program deinitialization.
+// The destructor MUST be an inline function such that the explicit
+// destruction occurs in the same compilation unit as the placement new.
+class StringFlagDestructor {
+ void *current_storage_;
+ void *defvalue_storage_;
+
+public:
+
+ StringFlagDestructor(void *current, void *defvalue)
+ : current_storage_(current), defvalue_storage_(defvalue) {}
+
+ ~StringFlagDestructor() {
+ reinterpret_cast<clstring*>(current_storage_ )->~clstring();
+ reinterpret_cast<clstring*>(defvalue_storage_)->~clstring();
+ }
+};
+
} // namespace fLS
// We need to define a var named FLAGS_no##name so people don't define
@@ -550,13 +602,15 @@
#define DEFINE_string(name, val, txt) \
namespace fLS { \
using ::fLS::clstring; \
+ using ::fLS::StringFlagDestructor; \
static union { void* align; char s[sizeof(clstring)]; } s_##name[2]; \
clstring* const FLAGS_no##name = ::fLS:: \
dont_pass0toDEFINE_string(s_##name[0].s, \
val); \
static GFLAGS_NAMESPACE::FlagRegisterer o_##name( \
- #name, "string", MAYBE_STRIPPED_HELP(txt), __FILE__, \
- s_##name[0].s, new (s_##name[1].s) clstring(*FLAGS_no##name)); \
+ #name, MAYBE_STRIPPED_HELP(txt), __FILE__, \
+ FLAGS_no##name, new (s_##name[1].s) clstring(*FLAGS_no##name)); \
+ static StringFlagDestructor d_##name(s_##name[0].s, s_##name[1].s); \
extern GFLAGS_DLL_DEFINE_FLAG clstring& FLAGS_##name; \
using fLS::FLAGS_##name; \
clstring& FLAGS_##name = *FLAGS_no##name; \
diff --git a/third_party/gflags/src/gflags_completions.cc b/third_party/gflags/src/gflags_completions.cc
index 3a47623..c53a128 100644
--- a/third_party/gflags/src/gflags_completions.cc
+++ b/third_party/gflags/src/gflags_completions.cc
@@ -46,9 +46,6 @@
// 5a) Force bash to place most-relevent groups at the top of the list
// 5b) Trim most flag's descriptions to fit on a single terminal line
-
-#include "config.h"
-
#include <stdio.h>
#include <stdlib.h>
#include <string.h> // for strlen
@@ -58,7 +55,9 @@
#include <utility>
#include <vector>
-#include "gflags.h"
+#include "config.h"
+#include "gflags/gflags.h"
+#include "gflags/gflags_completions.h"
#include "util.h"
using std::set;
@@ -120,7 +119,7 @@
NotableFlags *notable_flags);
static void TryFindModuleAndPackageDir(
- const vector<CommandLineFlagInfo> all_flags,
+ const vector<CommandLineFlagInfo> &all_flags,
string *module,
string *package_dir);
@@ -180,6 +179,11 @@
bool flag_description_substring_search;
bool return_all_matching_flags;
bool force_no_update;
+ CompletionOptions(): flag_name_substring_search(false),
+ flag_location_substring_search(false),
+ flag_description_substring_search(false),
+ return_all_matching_flags(false),
+ force_no_update(false) { }
};
// Notable flags are flags that are special or preferred for some
@@ -203,7 +207,7 @@
static void PrintFlagCompletionInfo(void) {
string cursor_word = FLAGS_tab_completion_word;
string canonical_token;
- CompletionOptions options = { };
+ CompletionOptions options = CompletionOptions();
CanonicalizeCursorWordAndSearchOptions(
cursor_word,
&canonical_token,
@@ -470,7 +474,7 @@
}
static void TryFindModuleAndPackageDir(
- const vector<CommandLineFlagInfo> all_flags,
+ const vector<CommandLineFlagInfo> &all_flags,
string *module,
string *package_dir) {
module->clear();
@@ -546,8 +550,7 @@
vector<DisplayInfoGroup> output_groups;
bool perfect_match_found = false;
- if (lines_so_far < max_desired_lines &&
- !notable_flags->perfect_match_flag.empty()) {
+ if (!notable_flags->perfect_match_flag.empty()) {
perfect_match_found = true;
DisplayInfoGroup group =
{ "",
diff --git a/third_party/gflags/src/gflags_declare.h.in b/third_party/gflags/src/gflags_declare.h.in
index 279db24..752a34d 100644
--- a/third_party/gflags/src/gflags_declare.h.in
+++ b/third_party/gflags/src/gflags_declare.h.in
@@ -45,18 +45,27 @@
// ---------------------------------------------------------------------------
// Windows DLL import/export.
-// We always want to import the symbols of the gflags library
+// Whether gflags library is a DLL.
+//
+// Set to 1 by default when the shared gflags library was built on Windows.
+// Must be overwritten when this header file is used with the optionally also
+// built static library instead; set by CMake's INTERFACE_COMPILE_DEFINITIONS.
+#ifndef GFLAGS_IS_A_DLL
+# define GFLAGS_IS_A_DLL @GFLAGS_IS_A_DLL@
+#endif
+
+// We always want to import the symbols of the gflags library.
#ifndef GFLAGS_DLL_DECL
-# if @GFLAGS_IS_A_DLL@ && defined(_MSC_VER)
+# if GFLAGS_IS_A_DLL && defined(_MSC_VER)
# define GFLAGS_DLL_DECL __declspec(dllimport)
# else
# define GFLAGS_DLL_DECL
# endif
#endif
-// We always want to import variables declared in user code
+// We always want to import variables declared in user code.
#ifndef GFLAGS_DLL_DECLARE_FLAG
-# ifdef _MSC_VER
+# if GFLAGS_IS_A_DLL && defined(_MSC_VER)
# define GFLAGS_DLL_DECLARE_FLAG __declspec(dllimport)
# else
# define GFLAGS_DLL_DECLARE_FLAG
@@ -120,6 +129,9 @@
#define DECLARE_int32(name) \
DECLARE_VARIABLE(::GFLAGS_NAMESPACE::int32, I, name)
+#define DECLARE_uint32(name) \
+ DECLARE_VARIABLE(::GFLAGS_NAMESPACE::uint32, U, name)
+
#define DECLARE_int64(name) \
DECLARE_VARIABLE(::GFLAGS_NAMESPACE::int64, I64, name)
@@ -132,7 +144,6 @@
#define DECLARE_string(name) \
/* We always want to import declared variables, dll or no */ \
namespace fLS { \
- using ::fLS::clstring; \
extern GFLAGS_DLL_DECLARE_FLAG ::fLS::clstring& FLAGS_##name; \
} \
using fLS::FLAGS_##name
diff --git a/third_party/gflags/src/gflags_ns.h.in b/third_party/gflags/src/gflags_ns.h.in
index f692666..ef6ac29 100644
--- a/third_party/gflags/src/gflags_ns.h.in
+++ b/third_party/gflags/src/gflags_ns.h.in
@@ -77,6 +77,7 @@
using GFLAGS_NAMESPACE::ReadFromFlagsFile;
using GFLAGS_NAMESPACE::BoolFromEnv;
using GFLAGS_NAMESPACE::Int32FromEnv;
+using GFLAGS_NAMESPACE::Uint32FromEnv;
using GFLAGS_NAMESPACE::Int64FromEnv;
using GFLAGS_NAMESPACE::Uint64FromEnv;
using GFLAGS_NAMESPACE::DoubleFromEnv;
diff --git a/third_party/gflags/src/gflags_reporting.cc b/third_party/gflags/src/gflags_reporting.cc
index 9cc41a7..29be922 100644
--- a/third_party/gflags/src/gflags_reporting.cc
+++ b/third_party/gflags/src/gflags_reporting.cc
@@ -56,8 +56,8 @@
#include <vector>
#include "config.h"
-#include "gflags.h"
-#include "gflags_completions.h"
+#include "gflags/gflags.h"
+#include "gflags/gflags_completions.h"
#include "util.h"
@@ -126,7 +126,8 @@
string final_string = "";
int chars_in_line = 0; // how many chars in current line so far?
while (1) {
- assert(chars_left == strlen(c_string)); // Unless there's a \0 in there?
+ assert(static_cast<size_t>(chars_left)
+ == strlen(c_string)); // Unless there's a \0 in there?
const char* newline = strchr(c_string, '\n');
if (newline == NULL && chars_in_line+chars_left < kLineLength) {
// The whole remainder of the string fits on this line
@@ -295,10 +296,10 @@
}
}
-void ShowUsageWithFlagsRestrict(const char *argv0, const char *restrict) {
+void ShowUsageWithFlagsRestrict(const char *argv0, const char *restrict_) {
vector<string> substrings;
- if (restrict != NULL && *restrict != '\0') {
- substrings.push_back(restrict);
+ if (restrict_ != NULL && *restrict_ != '\0') {
+ substrings.push_back(restrict_);
}
ShowUsageWithFlagsMatching(argv0, substrings);
}
@@ -388,8 +389,8 @@
gflags_exitfunc(1);
} else if (!FLAGS_helpon.empty()) {
- string restrict = PATH_SEPARATOR + FLAGS_helpon + ".";
- ShowUsageWithFlagsRestrict(progname, restrict.c_str());
+ string restrict_ = PATH_SEPARATOR + FLAGS_helpon + ".";
+ ShowUsageWithFlagsRestrict(progname, restrict_.c_str());
gflags_exitfunc(1);
} else if (!FLAGS_helpmatch.empty()) {
diff --git a/third_party/gflags/src/mutex.h b/third_party/gflags/src/mutex.h
index 0bdd9d5..7d7c364 100644
--- a/third_party/gflags/src/mutex.h
+++ b/third_party/gflags/src/mutex.h
@@ -106,7 +106,7 @@
#ifndef GFLAGS_MUTEX_H_
#define GFLAGS_MUTEX_H_
-#include "gflags_declare.h" // to figure out pthreads support
+#include "gflags/gflags_declare.h" // to figure out pthreads support
#if defined(NO_THREADS)
typedef int MutexType; // to keep a lock-count
@@ -166,7 +166,7 @@
// It inhibits work being done by the destructor, which makes it
// safer for code that tries to acqiure this mutex in their global
// destructor.
- inline Mutex(LinkerInitialized);
+ explicit inline Mutex(LinkerInitialized);
// Destructor
inline ~Mutex();
@@ -197,7 +197,7 @@
inline void SetIsSafe() { is_safe_ = true; }
// Catch the error of writing Mutex when intending MutexLock.
- Mutex(Mutex* /*ignored*/) {}
+ explicit Mutex(Mutex* /*ignored*/) {}
// Disallow "evil" constructors
Mutex(const Mutex&);
void operator=(const Mutex&);
@@ -344,8 +344,5 @@
} // namespace MUTEX_NAMESPACE
-using namespace MUTEX_NAMESPACE;
-
-#undef MUTEX_NAMESPACE
#endif /* #define GFLAGS_MUTEX_H__ */
diff --git a/third_party/gflags/src/util.h b/third_party/gflags/src/util.h
index 366e1be..164e3cf 100644
--- a/third_party/gflags/src/util.h
+++ b/third_party/gflags/src/util.h
@@ -37,7 +37,6 @@
#include "config.h"
#include <assert.h>
-#include <config.h>
#ifdef HAVE_INTTYPES_H
# include <inttypes.h>
#endif
@@ -88,9 +87,10 @@
// -- utility macros ---------------------------------------------------------
-template <bool> struct CompileAssert {};
+template <bool b> struct CompileAssert;
+template <> struct CompileAssert<true> {};
#define COMPILE_ASSERT(expr, msg) \
- typedef CompileAssert<(bool(expr))> msg[bool(expr) ? 1 : -1]
+ enum { assert_##msg = sizeof(CompileAssert<bool(expr)>) }
// Returns the number of elements in an array.
#define arraysize(arr) (sizeof(arr)/sizeof(*(arr)))
diff --git a/third_party/gflags/src/windows_port.cc b/third_party/gflags/src/windows_port.cc
index 9ccb630..b5b7194 100644
--- a/third_party/gflags/src/windows_port.cc
+++ b/third_party/gflags/src/windows_port.cc
@@ -44,6 +44,7 @@
// These call the windows _vsnprintf, but always NUL-terminate.
#if !defined(__MINGW32__) && !defined(__MINGW64__) /* mingw already defines */
+#if !(defined(_MSC_VER) && _MSC_VER >= 1900) /* msvc 2015 already defines */
#ifdef _MSC_VER
# pragma warning(push)
@@ -59,8 +60,6 @@
# pragma warning(pop)
#endif
-#if _MSC_VER < 1900 // msvs 2015 finally includes snprintf
-
int snprintf(char *str, size_t size, const char *format, ...) {
int r;
va_list ap;
@@ -70,6 +69,5 @@
return r;
}
-#endif
-
+#endif /* if !(defined(_MSC_VER) && _MSC_VER >= 1900) */
#endif /* #if !defined(__MINGW32__) && !defined(__MINGW64__) */
diff --git a/third_party/gflags/src/windows_port.h b/third_party/gflags/src/windows_port.h
index c8ff24f..61cf5b7 100644
--- a/third_party/gflags/src/windows_port.h
+++ b/third_party/gflags/src/windows_port.h
@@ -63,12 +63,14 @@
* name vsnprintf, since windows defines that (but not snprintf (!)).
*/
#if !defined(__MINGW32__) && !defined(__MINGW64__) /* mingw already defines */
+#if !(defined(_MSC_VER) && _MSC_VER >= 1900) /* msvc 2015 already defines */
extern GFLAGS_DLL_DECL int snprintf(char *str, size_t size,
const char *format, ...);
extern int GFLAGS_DLL_DECL safe_vsnprintf(char *str, size_t size,
const char *format, va_list ap);
#define vsnprintf(str, size, format, ap) safe_vsnprintf(str, size, format, ap)
#define va_copy(dst, src) (dst) = (src)
+#endif
#endif /* #if !defined(__MINGW32__) && !defined(__MINGW64__) */
#ifdef _MSC_VER
@@ -107,10 +109,14 @@
#define unlink _unlink
#endif
+#if defined(_MSC_VER) && _MSC_VER >= 1800
+#include <inttypes.h>
+#else
#define PRId32 "d"
#define PRIu32 "u"
#define PRId64 "I64d"
#define PRIu64 "I64u"
+#endif
#if !defined(__MINGW32__) && !defined(__MINGW64__)
#define strtoq _strtoi64
diff --git a/third_party/gflags/test/CMakeLists.txt b/third_party/gflags/test/CMakeLists.txt
index 77b582f..4cd1e69 100644
--- a/third_party/gflags/test/CMakeLists.txt
+++ b/third_party/gflags/test/CMakeLists.txt
@@ -18,13 +18,16 @@
if (BUILD_SHARED_LIBS)
set (type shared)
+ if (GFLAGS_IS_A_DLL)
+ add_definitions(-DGFLAGS_IS_A_DLL)
+ endif ()
else ()
set (type static)
endif ()
if (BUILD_gflags_LIB)
- link_libraries (gflags-${type})
+ link_libraries (gflags_${type})
else ()
- link_libraries (gflags_nothreads-${type})
+ link_libraries (gflags_nothreads_${type})
endif ()
# ----------------------------------------------------------------------------
@@ -37,6 +40,7 @@
NAME strip_flags_binary
COMMAND "${CMAKE_COMMAND}" "-DBINARY=$<TARGET_FILE:gflags_strip_flags_test>"
-P "${CMAKE_CURRENT_SOURCE_DIR}/gflags_strip_flags_test.cmake"
+ CONFIGURATIONS Release MinSizeRel
)
# ----------------------------------------------------------------------------
diff --git a/third_party/gflags/test/config/CMakeLists.txt b/third_party/gflags/test/config/CMakeLists.txt
index b5bc282..6190b25 100644
--- a/third_party/gflags/test/config/CMakeLists.txt
+++ b/third_party/gflags/test/config/CMakeLists.txt
@@ -1,10 +1,10 @@
## gflags package configuration tests
-cmake_minimum_required (VERSION 2.8)
+cmake_minimum_required (VERSION 2.8.12 FATAL_ERROR)
project (gflags_${TEST_NAME})
find_package (gflags REQUIRED)
add_executable (foo main.cc)
-target_link_libraries (foo gflags)
+target_link_libraries (foo gflags::gflags)
diff --git a/third_party/gflags/test/config/main.cc b/third_party/gflags/test/config/main.cc
index 9b2b898..3c033e3 100644
--- a/third_party/gflags/test/config/main.cc
+++ b/third_party/gflags/test/config/main.cc
@@ -3,10 +3,18 @@
DEFINE_string(message, "Hello World!", "The message to print");
+static bool ValidateMessage(const char* flagname, const std::string &message)
+{
+ return !message.empty();
+}
+DEFINE_validator(message, ValidateMessage);
+
int main(int argc, char **argv)
{
gflags::SetUsageMessage("Test CMake configuration of gflags library (gflags-config.cmake)");
+ gflags::SetVersionString("0.1");
gflags::ParseCommandLineFlags(&argc, &argv, true);
std::cout << FLAGS_message << std::endl;
+ gflags::ShutDownCommandLineFlags();
return 0;
}
diff --git a/third_party/gflags/test/config_for_unittests.h b/third_party/gflags/test/config_for_unittests.h
deleted file mode 100644
index 914571b..0000000
--- a/third_party/gflags/test/config_for_unittests.h
+++ /dev/null
@@ -1,79 +0,0 @@
-// Copyright (c) 2007, Google Inc.
-// All rights reserved.
-//
-// Redistribution and use in source and binary forms, with or without
-// modification, are permitted provided that the following conditions are
-// met:
-//
-// * Redistributions of source code must retain the above copyright
-// notice, this list of conditions and the following disclaimer.
-// * Redistributions in binary form must reproduce the above
-// copyright notice, this list of conditions and the following disclaimer
-// in the documentation and/or other materials provided with the
-// distribution.
-// * Neither the name of Google Inc. nor the names of its
-// contributors may be used to endorse or promote products derived from
-// this software without specific prior written permission.
-//
-// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
-// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
-// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
-// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
-// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
-// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
-// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
-// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
-// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
-// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
-// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-
-// ---
-// All Rights Reserved.
-//
-//
-// This file is needed for windows -- unittests are not part of the
-// gflags dll, but still want to include config.h just like the
-// dll does, so they can use internal tools and APIs for testing.
-//
-// The problem is that config.h declares GFLAGS_DLL_DECL to be
-// for exporting symbols, but the unittest needs to *import* symbols
-// (since it's not the dll).
-//
-// The solution is to have this file, which is just like config.h but
-// sets GFLAGS_DLL_DECL to do a dllimport instead of a dllexport.
-//
-// The reason we need this extra GFLAGS_DLL_DECL_FOR_UNITTESTS
-// variable is in case people want to set GFLAGS_DLL_DECL explicitly
-// to something other than __declspec(dllexport). In that case, they
-// may want to use something other than __declspec(dllimport) for the
-// unittest case. For that, we allow folks to define both
-// GFLAGS_DLL_DECL and GFLAGS_DLL_DECL_FOR_UNITTESTS explicitly.
-//
-// NOTE: This file is equivalent to config.h on non-windows systems,
-// which never defined GFLAGS_DLL_DECL_FOR_UNITTESTS and always
-// define GFLAGS_DLL_DECL to the empty string.
-
-#include "config.h"
-
-#ifdef GFLAGS_DLL_DECL
-# undef GFLAGS_DLL_DECL
-#endif
-#ifdef GFLAGS_DLL_DEFINE_FLAG
-# undef GFLAGS_DLL_DEFINE_FLAG
-#endif
-#ifdef GFLAGS_DLL_DECLARE_FLAG
-# undef GFLAGS_DLL_DECLARE_FLAG
-#endif
-
-#ifdef GFLAGS_DLL_DECL_FOR_UNITTESTS
-# define GFLAGS_DLL_DECL GFLAGS_DLL_DECL_FOR_UNITTESTS
-#else
-# define GFLAGS_DLL_DECL // if DLL_DECL_FOR_UNITTESTS isn't defined, use ""
-#endif
-
-// Import flags defined by gflags.cc
-#if GFLAGS_IS_A_DLL && defined(_MSC_VER)
-# define GFLAGS_DLL_DECLARE_FLAG __declspec(dllimport)
-#else
-# define GFLAGS_DLL_DECLARE_FLAG
-#endif
\ No newline at end of file
diff --git a/third_party/gflags/test/gflags_declare_flags.cc b/third_party/gflags/test/gflags_declare_flags.cc
old mode 100644
new mode 100755
index dc53de5..3d952a8
--- a/third_party/gflags/test/gflags_declare_flags.cc
+++ b/third_party/gflags/test/gflags_declare_flags.cc
@@ -1,8 +1,11 @@
+#define GFLAGS_DLL_DECLARE_FLAG
+
#include <iostream>
#include <gflags/gflags_declare.h>
DECLARE_string(message); // in gflags_delcare_test.cc
+void print_message();
void print_message()
{
std::cout << FLAGS_message << std::endl;
diff --git a/third_party/gflags/test/gflags_declare_test.cc b/third_party/gflags/test/gflags_declare_test.cc
index 707bcc0..47d11c2 100644
--- a/third_party/gflags/test/gflags_declare_test.cc
+++ b/third_party/gflags/test/gflags_declare_test.cc
@@ -5,8 +5,8 @@
int main(int argc, char **argv)
{
- gflags::SetUsageMessage("Test compilation and use of gflags_declare.h");
- gflags::ParseCommandLineFlags(&argc, &argv, true);
+ GFLAGS_NAMESPACE::SetUsageMessage("Test compilation and use of gflags_declare.h");
+ GFLAGS_NAMESPACE::ParseCommandLineFlags(&argc, &argv, true);
print_message();
return 0;
}
diff --git a/third_party/gflags/test/gflags_strip_flags_test.cc b/third_party/gflags/test/gflags_strip_flags_test.cc
old mode 100644
new mode 100755
index 25ef53a..143f0c6
--- a/third_party/gflags/test/gflags_strip_flags_test.cc
+++ b/third_party/gflags/test/gflags_strip_flags_test.cc
@@ -34,7 +34,6 @@
// script that runs 'strings' over this program and makes sure
// that the help string is not in there.
-#include "config_for_unittests.h"
#define STRIP_FLAG_HELP 1
#include <gflags/gflags.h>
diff --git a/third_party/gflags/test/gflags_strip_flags_test.cmake b/third_party/gflags/test/gflags_strip_flags_test.cmake
index bd419c4..5bb5cc1 100644
--- a/third_party/gflags/test/gflags_strip_flags_test.cmake
+++ b/third_party/gflags/test/gflags_strip_flags_test.cmake
@@ -1,7 +1,7 @@
if (NOT BINARY)
- message (FATAl_ERROR "BINARY file to check not specified!")
+ message (FATAL_ERROR "BINARY file to check not specified!")
endif ()
file (STRINGS "${BINARY}" strings REGEX "This text should be stripped out")
if (strings)
message (FATAL_ERROR "Text not stripped from binary like it should be: ${BINARY}")
-endif ()
\ No newline at end of file
+endif ()
diff --git a/third_party/gflags/test/gflags_unittest.cc b/third_party/gflags/test/gflags_unittest.cc
old mode 100644
new mode 100755
index 80f7398..9a922ef
--- a/third_party/gflags/test/gflags_unittest.cc
+++ b/third_party/gflags/test/gflags_unittest.cc
@@ -32,9 +32,11 @@
// For now, this unit test does not cover all features of
// gflags.cc
-#include "config_for_unittests.h"
#include <gflags/gflags.h>
+#include "config.h"
+#include "util.h"
+
#include <math.h> // for isinf() and isnan()
#include <stdio.h>
#include <stdlib.h>
@@ -44,7 +46,6 @@
#endif
#include <vector>
#include <string>
-#include "util.h"
TEST_INIT
EXPECT_DEATH_INIT
@@ -74,6 +75,7 @@
DEFINE_bool(test_bool, false, "tests bool-ness");
DEFINE_int32(test_int32, -1, "");
DEFINE_int64(test_int64, -2, "");
+DEFINE_uint32(test_uint32, 1, "");
DEFINE_uint64(test_uint64, 2, "");
DEFINE_double(test_double, -1.0, "");
DEFINE_string(test_string, "initial", "");
@@ -114,6 +116,7 @@
DEFINE_bool(unused_bool, true, "unused bool-ness");
DEFINE_int32(unused_int32, -1001, "");
DEFINE_int64(unused_int64, -2001, "");
+DEFINE_uint32(unused_uint32, 1000, "");
DEFINE_uint64(unused_uint64, 2000, "");
DEFINE_double(unused_double, -1000.0, "");
DEFINE_string(unused_string, "unused", "");
@@ -213,7 +216,7 @@
int32 FLAGS_tldflag1 = FLAGS_nonotldflag1;
int32 FLAGS_notldflag1 = FLAGS_nonotldflag1;
static FlagRegisterer o_tldflag1(
- "tldflag1", "int32",
+ "tldflag1",
"should show up in --helpshort", "gflags_unittest.cc",
&FLAGS_tldflag1, &FLAGS_notldflag1);
}
@@ -224,7 +227,7 @@
int32 FLAGS_tldflag2 = FLAGS_nonotldflag2;
int32 FLAGS_notldflag2 = FLAGS_nonotldflag2;
static FlagRegisterer o_tldflag2(
- "tldflag2", "int32",
+ "tldflag2",
"should show up in --helpshort", "gflags_unittest.",
&FLAGS_tldflag2, &FLAGS_notldflag2);
}
@@ -276,6 +279,7 @@
AssertIsType<bool>(FLAGS_test_bool);
AssertIsType<int32>(FLAGS_test_int32);
AssertIsType<int64>(FLAGS_test_int64);
+ AssertIsType<uint32>(FLAGS_test_uint32);
AssertIsType<uint64>(FLAGS_test_uint64);
AssertIsType<double>(FLAGS_test_double);
AssertIsType<string>(FLAGS_test_string);
@@ -353,6 +357,19 @@
false,
123,
123.0);
+
+ // Test that flags can use dashes instead of underscores.
+ TestFlagString(
+ // Flag string
+ "-test-string=initial\n"
+ "--test-bool=false\n"
+ "--test-int32=123\n"
+ "--test-double=123.0\n",
+ // Expected values
+ "initial",
+ false,
+ 123,
+ 123.0);
}
// Tests the filename part of the flagfile
@@ -590,12 +607,16 @@
FLAGS_test_bool = true;
FLAGS_test_int32 = 119;
FLAGS_test_int64 = 1191;
- FLAGS_test_uint64 = 11911;
+ FLAGS_test_uint32 = 11911;
+ FLAGS_test_uint64 = 119111;
EXPECT_EQ("",
SetCommandLineOption("test_bool", "12"));
EXPECT_EQ("",
+ SetCommandLineOption("test_uint32", "-1970"));
+
+ EXPECT_EQ("",
SetCommandLineOption("test_int32", "7000000000000"));
EXPECT_EQ("",
@@ -608,6 +629,7 @@
EXPECT_EQ("", SetCommandLineOption("test_bool", ""));
EXPECT_EQ("", SetCommandLineOption("test_int32", ""));
EXPECT_EQ("", SetCommandLineOption("test_int64", ""));
+ EXPECT_EQ("", SetCommandLineOption("test_uint32", ""));
EXPECT_EQ("", SetCommandLineOption("test_uint64", ""));
EXPECT_EQ("", SetCommandLineOption("test_double", ""));
EXPECT_EQ("test_string set to \n", SetCommandLineOption("test_string", ""));
@@ -615,7 +637,8 @@
EXPECT_TRUE(FLAGS_test_bool);
EXPECT_EQ(119, FLAGS_test_int32);
EXPECT_EQ(1191, FLAGS_test_int64);
- EXPECT_EQ(11911, FLAGS_test_uint64);
+ EXPECT_EQ(11911, FLAGS_test_uint32);
+ EXPECT_EQ(119111, FLAGS_test_uint64);
}
@@ -668,14 +691,19 @@
EXPECT_EQ(-1, Int32FromEnv("INT_VAL2", 10));
EXPECT_EQ(10, Int32FromEnv("INT_VAL_UNKNOWN", 10));
- setenv("INT_VAL3", "1099511627776", 1);
+ setenv("INT_VAL3", "4294967295", 1);
+ EXPECT_EQ(1, Uint32FromEnv("INT_VAL1", 10));
+ EXPECT_EQ(4294967295L, Uint32FromEnv("INT_VAL3", 30));
+ EXPECT_EQ(10, Uint32FromEnv("INT_VAL_UNKNOWN", 10));
+
+ setenv("INT_VAL4", "1099511627776", 1);
EXPECT_EQ(1, Int64FromEnv("INT_VAL1", 20));
EXPECT_EQ(-1, Int64FromEnv("INT_VAL2", 20));
- EXPECT_EQ(1099511627776LL, Int64FromEnv("INT_VAL3", 20));
+ EXPECT_EQ(1099511627776LL, Int64FromEnv("INT_VAL4", 20));
EXPECT_EQ(20, Int64FromEnv("INT_VAL_UNKNOWN", 20));
EXPECT_EQ(1, Uint64FromEnv("INT_VAL1", 30));
- EXPECT_EQ(1099511627776ULL, Uint64FromEnv("INT_VAL3", 30));
+ EXPECT_EQ(1099511627776ULL, Uint64FromEnv("INT_VAL4", 30));
EXPECT_EQ(30, Uint64FromEnv("INT_VAL_UNKNOWN", 30));
// I pick values here that can be easily represented exactly in floating-point
@@ -711,6 +739,11 @@
EXPECT_DEATH(Int32FromEnv("INT_BAD3", 10), "error parsing env variable");
EXPECT_DEATH(Int32FromEnv("INT_BAD4", 10), "error parsing env variable");
+ EXPECT_DEATH(Uint32FromEnv("INT_BAD1", 10), "error parsing env variable");
+ EXPECT_DEATH(Uint32FromEnv("INT_BAD2", 10), "error parsing env variable");
+ EXPECT_DEATH(Uint32FromEnv("INT_BAD3", 10), "error parsing env variable");
+ EXPECT_DEATH(Uint32FromEnv("INT_BAD4", 10), "error parsing env variable");
+
setenv("BIGINT_BAD1", "18446744073709551616000", 1);
EXPECT_DEATH(Int64FromEnv("INT_BAD1", 20), "error parsing env variable");
EXPECT_DEATH(Int64FromEnv("INT_BAD3", 20), "error parsing env variable");
@@ -814,9 +847,10 @@
// Initializes the flags.
FLAGS_test_bool = false;
FLAGS_test_int32 = -1;
- FLAGS_test_int64 = -2;
- FLAGS_test_uint64 = 3;
- FLAGS_test_double = 4.0;
+ FLAGS_test_uint32 = 2;
+ FLAGS_test_int64 = -3;
+ FLAGS_test_uint64 = 4;
+ FLAGS_test_double = 5.0;
FLAGS_test_string = "good";
// Saves the flag states.
@@ -826,8 +860,9 @@
// Modifies the flags.
FLAGS_test_bool = true;
FLAGS_test_int32 = -5;
- FLAGS_test_int64 = -6;
- FLAGS_test_uint64 = 7;
+ FLAGS_test_uint32 = 6;
+ FLAGS_test_int64 = -7;
+ FLAGS_test_uint64 = 8;
FLAGS_test_double = 8.0;
FLAGS_test_string = "bad";
@@ -837,9 +872,10 @@
// Verifies the flag values were restored.
EXPECT_FALSE(FLAGS_test_bool);
EXPECT_EQ(-1, FLAGS_test_int32);
- EXPECT_EQ(-2, FLAGS_test_int64);
- EXPECT_EQ(3, FLAGS_test_uint64);
- EXPECT_DOUBLE_EQ(4.0, FLAGS_test_double);
+ EXPECT_EQ(2, FLAGS_test_uint32);
+ EXPECT_EQ(-3, FLAGS_test_int64);
+ EXPECT_EQ(4, FLAGS_test_uint64);
+ EXPECT_DOUBLE_EQ(5.0, FLAGS_test_double);
EXPECT_EQ("good", FLAGS_test_string);
}
@@ -1332,7 +1368,7 @@
// addresses of these variables will be overwritten... Stack smash!
static bool current_storage;
static bool defvalue_storage;
- FlagRegisterer fr("flag_name", "bool", 0, "filename",
+ FlagRegisterer fr("flag_name", NULL, "filename",
¤t_storage, &defvalue_storage);
CommandLineFlagInfo fi;
EXPECT_TRUE(GetCommandLineFlagInfo("flag_name", &fi));
@@ -1485,7 +1521,7 @@
} // unnamed namespace
-int main(int argc, char **argv) {
+static int main(int argc, char **argv) {
// Run unit tests only if called without arguments, otherwise this program
// is used by an "external" usage test
@@ -1514,7 +1550,7 @@
// The non-recommended way:
FLAGS_changed_bool2 = true;
- SetUsageMessage(usage_message.c_str());
+ SetUsageMessage(usage_message);
SetVersionString("test_version");
ParseCommandLineFlags(&argc, &argv, true);
MakeTmpdir(&FLAGS_test_tmpdir);
diff --git a/third_party/gflags/test/nc/CMakeLists.txt b/third_party/gflags/test/nc/CMakeLists.txt
index e425d91..d00b07d 100644
--- a/third_party/gflags/test/nc/CMakeLists.txt
+++ b/third_party/gflags/test/nc/CMakeLists.txt
@@ -1,6 +1,6 @@
## gflags negative compilation tests
-cmake_minimum_required (VERSION 2.8)
+cmake_minimum_required (VERSION 2.8.12 FATAL_ERROR)
if (NOT TEST_NAME)
message (FATAL_ERROR "Missing TEST_NAME CMake flag")
@@ -13,4 +13,4 @@
include_directories ("${CMAKE_CURRENT_SOURCE_DIR}/..")
add_definitions (-DTEST_${TEST_NAME_UPPER})
add_executable (gflags_${TEST_NAME} gflags_nc.cc)
-target_link_libraries(gflags_${TEST_NAME} ${gflags_LIBRARIES})
+target_link_libraries(gflags_${TEST_NAME} gflags)
diff --git a/y2018/control_loops/python/2d_plot.cc b/y2018/control_loops/python/2d_plot.cc
index 52b8b34..9fb1a35 100644
--- a/y2018/control_loops/python/2d_plot.cc
+++ b/y2018/control_loops/python/2d_plot.cc
@@ -2,7 +2,7 @@
#include <cmath>
#include <thread>
-#include "third_party/gflags/include/gflags/gflags.h"
+#include "gflags/gflags.h"
#include "third_party/matplotlib-cpp/matplotlibcpp.h"
DEFINE_double(yrange, 1.0, "+- y max");
diff --git a/y2018/control_loops/python/3d_plot.cc b/y2018/control_loops/python/3d_plot.cc
index ff1e293..676da65 100644
--- a/y2018/control_loops/python/3d_plot.cc
+++ b/y2018/control_loops/python/3d_plot.cc
@@ -2,7 +2,7 @@
#include <cmath>
#include <thread>
-#include "third_party/gflags/include/gflags/gflags.h"
+#include "gflags/gflags.h"
#include "third_party/matplotlib-cpp/matplotlibcpp.h"
#include "y2018/control_loops/python/arm_bounds.h"
diff --git a/y2018/control_loops/python/arm_mpc.cc b/y2018/control_loops/python/arm_mpc.cc
index a032cae..d603156 100644
--- a/y2018/control_loops/python/arm_mpc.cc
+++ b/y2018/control_loops/python/arm_mpc.cc
@@ -5,7 +5,7 @@
#include <ct/optcon/optcon.h>
#include <Eigen/Eigenvalues>
-#include "third_party/gflags/include/gflags/gflags.h"
+#include "gflags/gflags.h"
#include "third_party/matplotlib-cpp/matplotlibcpp.h"
#include "y2018/control_loops/python/arm_bounds.h"
#include "y2018/control_loops/python/dlqr.h"
diff --git a/y2018/control_loops/superstructure/arm/dynamics.h b/y2018/control_loops/superstructure/arm/dynamics.h
index 3624f58..cdbd6fe 100644
--- a/y2018/control_loops/superstructure/arm/dynamics.h
+++ b/y2018/control_loops/superstructure/arm/dynamics.h
@@ -4,7 +4,7 @@
#include "Eigen/Dense"
#include "frc971/control_loops/runge_kutta.h"
-#include "third_party/gflags/include/gflags/gflags.h"
+#include "gflags/gflags.h"
DECLARE_bool(gravity);
diff --git a/y2018/control_loops/superstructure/arm/trajectory.cc b/y2018/control_loops/superstructure/arm/trajectory.cc
index d251330..2157ca7 100644
--- a/y2018/control_loops/superstructure/arm/trajectory.cc
+++ b/y2018/control_loops/superstructure/arm/trajectory.cc
@@ -4,7 +4,7 @@
#include "aos/logging/logging.h"
#include "frc971/control_loops/dlqr.h"
#include "frc971/control_loops/jacobian.h"
-#include "third_party/gflags/include/gflags/gflags.h"
+#include "gflags/gflags.h"
#include "y2018/control_loops/superstructure/arm/dynamics.h"
DEFINE_double(lqr_proximal_pos, 0.15, "Position LQR gain");
diff --git a/y2018/control_loops/superstructure/arm/trajectory_plot.cc b/y2018/control_loops/superstructure/arm/trajectory_plot.cc
index b1e089c..eb3f7c1 100644
--- a/y2018/control_loops/superstructure/arm/trajectory_plot.cc
+++ b/y2018/control_loops/superstructure/arm/trajectory_plot.cc
@@ -1,6 +1,6 @@
#include "y2018/control_loops/superstructure/arm/trajectory.h"
-#include "third_party/gflags/include/gflags/gflags.h"
+#include "gflags/gflags.h"
#include "third_party/matplotlib-cpp/matplotlibcpp.h"
#include "y2018/control_loops/superstructure/arm/dynamics.h"
#include "y2018/control_loops/superstructure/arm/ekf.h"
diff --git a/y2018/vision/image_streamer.cc b/y2018/vision/image_streamer.cc
index dea6a77..c4320f2 100644
--- a/y2018/vision/image_streamer.cc
+++ b/y2018/vision/image_streamer.cc
@@ -11,7 +11,7 @@
#include "aos/vision/events/socket_types.h"
#include "aos/vision/events/udp.h"
#include "aos/vision/image/reader.h"
-#include "third_party/gflags/include/gflags/gflags.h"
+#include "gflags/gflags.h"
#include "y2018/vision.pb.h"
using ::aos::events::DataSocket;