quickstep-commits mailing list archives

Site index · List index
Message view « Date » · « Thread »
Top « Date » · « Thread »
From hbdeshm...@apache.org
Subject [48/51] [abbrv] [partial] incubator-quickstep git commit: Added shell script to download prerequisite third party libs
Date Thu, 19 Jan 2017 20:07:25 GMT
http://git-wip-us.apache.org/repos/asf/incubator-quickstep/blob/b249eb11/third_party/gflags/ChangeLog.txt
----------------------------------------------------------------------
diff --git a/third_party/gflags/ChangeLog.txt b/third_party/gflags/ChangeLog.txt
deleted file mode 100644
index eea9f83..0000000
--- a/third_party/gflags/ChangeLog.txt
+++ /dev/null
@@ -1,218 +0,0 @@
-* Tue Mar 24 2014 - Andreas Schuh <andreas.schuh.84@gmail.com>
-
-- gflags: version 2.1.2
-- Moved project to GitHub
-- Added GFLAGS_NAMESPACE definition to gflags_declare.h
-- Fixed issue 94: Keep "google" as primary namespace and import symbols into "gflags" namespace
-- Fixed issue 96: Fix binary ABI compatibility with gflags 2.0 using "google" as primary namespace
-- Fixed issue 97/101: Removed (patched) CMake modules and enabled C language instead
-- Fixed issue 103: Set CMake policy CMP0042 to silence warning regarding MACOS_RPATH setting
-
-* Sun Mar 20 2014 - Andreas Schuh <google-gflags@googlegroups.com>
-
-- gflags: version 2.1.1
-- Fixed issue 77: GFLAGS_IS_A_DLL expands to empty string in gflags_declare.h
-- Fixed issue 79: GFLAGS_NAMESPACE not expanded to actual namespace in gflags_declare.h
-- Fixed issue 80: Allow include path to differ from GFLAGS_NAMESPACE
-
-* Thu Mar 20 2014 - Andreas Schuh <google-gflags@googlegroups.com>
-
-- gflags: version 2.1.0
-- Build system configuration using CMake instead of autotools
-- CPack packaging support for Debian/Ubuntu, Red Hat, and Mac OS X
-- Fixed issue 54: Fix "invalid suffix on literal" (C++11)
-- Fixed issue 57: Use _strdup instead of strdup on Windows
-- Fixed issue 62: Change all preprocessor include guards to start with GFLAGS_
-- Fixed issue 64: Add DEFINE_validator macro
-- Fixed issue 73: Warnings in Visual Studio 2010 and unable to compile unit test
-
-* Wed Jan 25 2012 - Google Inc. <google-gflags@googlegroups.com>
-
-- gflags: version 2.0
-- Changed the 'official' gflags email in setup.py/etc
-- Renamed google-gflags.sln to gflags.sln
-- Changed copyright text to reflect Google's relinquished ownership
-
-* Tue Dec 20 2011 - Google Inc. <opensource@google.com>
-
-- google-gflags: version 1.7
-- Add CommandLineFlagInfo::flag_ptr pointing to current storage (musji)
-- PORTING: flush after writing to stderr, needed on cygwin
-- PORTING: Clean up the GFLAGS_DLL_DECL stuff better
-- Fix a bug in StringPrintf() that affected large strings (csilvers)
-- Die at configure-time when g++ isn't installed
-
-* Fri Jul 29 2011 - Google Inc. <opensource@google.com>
-
-- google-gflags: version 1.6
-- BUGFIX: Fix a bug where we were leaving out a required $(top_srcdir)
-- Fix definition of clstring (jyrki)
-- Split up flag declares into its own file (jyrki)
-- Add --version support (csilvers)
-- Update the README for gflags with static libs
-- Update acx_pthread.m4 for nostdlib
-- Change ReparseCommandLineFlags to return void (csilvers)
-- Some doc typofixes and example augmentation (various)
-
-* Mon Jan 24 2011 - Google Inc. <opensource@google.com>
-
-- google-gflags: version 1.5
-- Better reporting of current vs default value (handler)
-- Add API for cleaning up of memory at program-exit (jmarantz)
-- Fix macros to work inside namespaces (csilvers)
-- Use our own string typedef in case string is redefined (csilvers)
-- Updated to autoconf 2.65
-
-* Wed Oct 13 2010 - Google Inc. <opensource@google.com>
-
-- google-gflags: version 1.4
-- Add a check to prevent passing 0 to DEFINE_string (jorg)
-- Reduce compile (.o) size (jyrki)
-- Some small changes to quiet debug compiles (alexk)
-- PORTING: better support static linking on windows (csilvers)
-- DOCUMENTATION: change default values, use validators, etc.
-- Update the NEWS file to be non-empty
-- Add pkg-config (.pc) files for libgflags and libgflags_nothreads
-
-* Mon Jan  4 2010 - Google Inc. <opensource@google.com>
-
-- google-gflags: version 1.3
-- PORTABILITY: can now build and run tests under MSVC (csilvers)
-- Remove the python gflags code, which is now its own package (tansell)
-- Clarify that "last flag wins" in the docs (csilvers)
-- Comment danger of using GetAllFlags in validators (wojtekm)
-- PORTABILITY: Some fixes necessary for c++0x (mboerger)
-- Makefile fix: $(srcdir) -> $(top_srcdir) in one place (csilvres)
-- INSTALL: autotools to autoconf v2.64 + automake v1.11 (csilvers)
-
-* Thu Sep 10 2009 - Google Inc. <opensource@google.com>
-
-- google-gflags: version 1.2
-- PORTABILITY: can now build and run tests under mingw (csilvers)
-- Using a string arg for a bool flag is a compile-time error (rbayardo)
-- Add --helpxml to gflags.py (salcianu)
-- Protect against a hypothetical global d'tor mutex problem (csilvers)
-- BUGFIX: can now define a flag after 'using namespace google' (hamaji)
-
-* Tue Apr 14 2009 - Google Inc. <opensource@google.com>
-
-- google-gflags: version 1.1
-- Add both foo and nofoo for boolean flags, with --undefok (andychu)
-- Better document how validators work (wojtekm)
-- Improve binary-detection for bash-completion (mtamsky)
-- Python: Add a concept of "key flags", used with --help (salcianu)
-- Python: Robustify flag_values (salcianu)
-- Python: Add a new DEFINE_bool alias (keir, andrewliu)
-- Python: Do module introspection based on module name (dsturtevant)
-- Fix autoconf a bit better, especially on windows and solaris (ajenjo)
-- BUG FIX: gflags_nothreads was linking against the wrong lib (ajenjo)
-- BUG FIX: threads-detection failed on FreeBSD; replace it (ajenjo)
-- PORTABILITY: Quiet an internal compiler error with SUSE 10 (csilvers)
-- PORTABILITY: Update deb.sh for more recenty debuilds (csilvers)
-- PORTABILITY: #include more headers to satify new gcc's (csilvers)
-- INSTALL: Updated to autoconf 2.61 and libtool 1.5.26 (csilvers)
-
-* Fri Oct  3 2008 - Google Inc. <opensource@google.com>
-
-- google-gflags: version 1.0
-- Add a missing newline to an error string (bcmills)
-- (otherwise exactly the same as gflags 1.0rc2)
-
-* Thu Sep 18 2008 - Google Inc. <opensource@google.com>
-
-- google-gflags: version 1.0rc2
-- Report current flag values in --helpxml (hdn)
-- Fix compilation troubles with gcc 4.3.3 (simonb)
-- BUG FIX: I was missing a std:: in DECLARE_string (csilvers)
-- BUG FIX: Clarify in docs how to specify --bool flags (csilvers)
-- BUG FIX: Fix --helpshort for source files not in a subdir (csilvers)
-- BUG FIX: Fix python unittest for 64-bit builds (bcmills)
-
-* Tue Aug 19 2008 - Google Inc. <opensource@google.com>
-
-- google-gflags: version 1.0rc1
-- Move #include files from google/ to gflags/ (csilvers)
-- Small optimizations to reduce binary (library) size (jyrki)
-- BUGFIX: forgot a std:: in one of the .h files (csilvers)
-- Speed up locking by making sure calls are inlined (ajenjo)
-- 64-BIT COMPATIBILITY: Use %PRId64 instead of %lld (csilvers)
-- PORTABILITY: fix Makefile to work with Cygwin (ajenjo)
-- PORTABILITY: fix code to compile under Visual Studio (ajenjo)
-- PORTABILITY: fix code to compile under Solaris 10 with CC (csilvers)
-
-* Mon Jul 21 2008 - Google Inc. <opensource@google.com>
-
-- google-gflags: version 0.9
-- Add the ability to validate a command-line flag (csilvers)
-- Add completion support for commandline flags in bash (daven)
-- Add -W compile flags to Makefile, when using gcc (csilvers)
-- Allow helpstring to be NULL (cristianoc)
-- Improved documentation of classes in the .cc file (csilvers)
-- Fix python bug with AppendFlagValues + shortnames (jjtswan)
-- Use bool instead of int for boolean flags in gflags.py (bcmills)
-- Simplify the way we declare flags, now more foolproof (csilvers)
-- Better error messages when bool flags collide (colohan)
-- Only evaluate DEFINE_foo macro args once (csilvers)
-
-* Wed Mar 26 2008 - Google Inc. <opensource@google.com>
-
-- google-gflags: version 0.8
-- Export DescribeOneFlag() in the API
-- Add support for automatic line wrapping at 80 cols for gflags.py
-- Bugfix: do not treat an isolated "-" the same as an isolated "--"
-- Update rpm spec to point to Google Code rather than sourceforge (!)
-- Improve documentation (including documenting thread-safety)
-- Improve #include hygiene
-- Improve testing
-
-* Thu Oct 18 2007 - Google Inc. <opensource@google.com>
-
-- google-gflags: version 0.7
-- Deal even more correctly with libpthread not linked in (csilvers)
-- Add STRIP_LOG, an improved DO_NOT_SHOW_COMMANDLINE_HELP (sioffe)
-- Be more accurate printing default flag values in --help (dsturtevant)
-- Reduce .o file size a bit by using shorter namespace names (jeff)
-- Use relative install path, so 'setup.py --home' works (csilvers)
-- Notice when a boolean flag has a non-boolean default (bnmouli)
-- Broaden --helpshort to match foo-main.cc and foo_main.cc (hendrie)
-- Fix "no modules match" message for --helpshort, etc (hendrie)
-
-* Wed Aug 15 2007 - Google Inc. <opensource@google.com>
-
-- google-gflags: version 0.6
-- Deal correctly with case that libpthread is not linked in (csilvers)
-- Update Makefile/tests so we pass "make distcheck" (csilvers)
-- Document and test that last assignment to a flag wins (wan)
-
-* Tue Jun 12 2007 - Google Inc. <opensource@google.com>
-
-- google-gflags: version 0.5
-- Include all m4 macros in the distribution (csilvers)
-- Python: Fix broken data_files field in setup.py (sidlon)
-- Python: better string serliaizing and unparsing (abo, csimmons)
-- Fix checks for NaN and inf to work with Mac OS X (csilvers)
-
-* Thu Apr 19 2007 - Google Inc. <opensource@google.com>
-
-- google-gflags: version 0.4
-- Remove is_default from GetCommandLineFlagInfo (csilvers)
-- Portability fixes: includes, strtoll, gcc4.3 errors (csilvers)
-- A few doc typo cleanups (csilvers)
-
-* Wed Mar 28 2007 - Google Inc. <opensource@google.com>
-
-- google-gflags: version 0.3
-- python portability fix: use popen instead of subprocess (csilvers)
-- Add is_default to CommandLineFlagInfo (pchien)
-- Make docs a bit prettier (csilvers)
-- Actually include the python files in the distribution! :-/ (csilvers)
-
-* Mon Jan 22 2007 - Google Inc. <opensource@google.com>
-
-- google-gflags: version 0.2
-- added support for python commandlineflags, as well as c++
-- gflags2man, a script to turn flags into a man page (dchristian)
-
-* Wed Dec 13 2006 - Google Inc. <opensource@google.com>
-
-- google-gflags: version 0.1

http://git-wip-us.apache.org/repos/asf/incubator-quickstep/blob/b249eb11/third_party/gflags/INSTALL.md
----------------------------------------------------------------------
diff --git a/third_party/gflags/INSTALL.md b/third_party/gflags/INSTALL.md
deleted file mode 100644
index d054193..0000000
--- a/third_party/gflags/INSTALL.md
+++ /dev/null
@@ -1,54 +0,0 @@
-Installing a binary distribution package
-========================================
-
-No official binary distribution packages are provided by the gflags developers.
-There may, however, be binary packages available for your OS. Please consult
-also the package repositories of your Linux distribution.
-
-For example on Debian/Ubuntu Linux, gflags can be installed using the
-following command:
-
-    sudo apt-get install gflags
-
-
-Compiling the source code
-=========================
-
-The build system of gflags is since version 2.1 based on [CMake](http://cmake.org).
-The common steps to build, test, and install software are therefore:
-
-1. Extract source files.
-2. Create build directory and change to it.
-3. Run CMake to configure the build tree.
-4. Build the software using selected build tool.
-5. Test the built software.
-6. Install the built files.
-
-On Unix-like systems with GNU Make as build tool, these build steps can be
-summarized by the following sequence of commands executed in a shell,
-where ```$package``` and ```$version``` are shell variables which represent
-the name of this package and the obtained version of the software.
-
-    $ tar xzf gflags-$version-source.tar.gz
-    $ cd gflags-$version
-    $ mkdir build && cd build
-    $ ccmake ..
-    
-      - Press 'c' to configure the build system and 'e' to ignore warnings.
-      - Set CMAKE_INSTALL_PREFIX and other CMake variables and options.
-      - Continue pressing 'c' until the option 'g' is available.
-      - Then press 'g' to generate the configuration files for GNU Make.
-    
-    $ make
-    $ make test    (optional)
-    $ make install (optional)
-
-In the following, only gflags-specific CMake settings available to
-configure the build and installation are documented.
-
-
-CMake Option           | Description
----------------------- | -------------------------------------------------------
-CMAKE_INSTALL_PREFIX   | Installation directory, e.g., "/usr/local" on Unix and "C:\Program Files\gflags" on Windows.
-GFLAGS_NAMESPACE       | Name of the C++ namespace to be used by the gflags library. Note that the public source header files are installed in a subdirectory named after this namespace. To maintain backwards compatibility with the Google Commandline Flags, set this variable to "google". The default is "gflags".
-GFLAGS_INCLUDE_DIR     | Name of include subdirectory where headers are installed into.

http://git-wip-us.apache.org/repos/asf/incubator-quickstep/blob/b249eb11/third_party/gflags/README.md
----------------------------------------------------------------------
diff --git a/third_party/gflags/README.md b/third_party/gflags/README.md
deleted file mode 100644
index 640e436..0000000
--- a/third_party/gflags/README.md
+++ /dev/null
@@ -1,263 +0,0 @@
-24 March 2015
--------------
-
-Released gflags 2.1.2 with fixes of ABI incompatibilities to 2.0 caused
-by namespace change. The deprecated "google" namespace is yet kept as primary
-namespace while sybmols are imported into the new "gflags" namespace by default.
-This can be configured using GFLAGS_NAMESPACE and GLAGS_INCLUDE_DIR. Problems
-with the (patched) CMake modules FindThreads.cmake and CheckTypeSize.cmake
-are resolved by re-enabling the C language again even though gflags is C++.
-
-Finalized move of gflags project from Google Code to GitHub.
-Email addresses of original issue reporters got lost in the process.
-Given the age of most issue reports, this should be neglibable.
-
-Please report any further issues using the GitHub issue tracker.
-
-
-30 March 2014
--------------
-
-I've just released gflags 2.1.1.
-
-This release fixes a few bugs in the configuration of gflags\_declare.h
-and adds a separate GFLAGS\_INCLUDE\_DIR CMake variable to the build configuration.
-Setting GFLAGS\_NAMESPACE to "google" no longer changes also the include
-path of the public header files. This allows the use of the library with
-other Google projects such as glog which still use the deprecated "google"
-namespace for the gflags library, but include it as "gflags/gflags.h".
-
-20 March 2014
--------------
-
-I've just released gflags 2.1.
-
-The major changes are the use of CMake for the build configuration instead
-of the autotools and packaging support through CPack. The default namespace
-of all C++ symbols is now "gflags" instead of "google". This can be
-configured via the GFLAGS\_NAMESPACE variable.
-
-This release compiles with all major compilers without warnings and passed
-the unit tests on  Ubuntu 12.04, Windows 7 (Visual Studio 2008 and 2010,
-Cygwin, MinGW), and Mac OS X (Xcode 5.1).
-
-The SVN repository on Google Code is now frozen and replaced by a Git
-repository such that it can be used as Git submodule by projects. The main
-hosting of this project remains at Google Code. Thanks to the distributed
-character of Git, I can push (and pull) changes from both GitHub and Google Code
-in order to keep the two public repositories in sync.
-When fixing an issue for a pull request through either of these hosting
-platforms, please reference the issue number as
-[described here](https://code.google.com/p/support/wiki/IssueTracker#Integration_with_version_control).
-For the further development, I am following the
-[Git branching model](http://nvie.com/posts/a-successful-git-branching-model/)
-with feature branch names prefixed by "feature/" and bugfix branch names
-prefixed by "bugfix/", respectively.
-
-Binary and source [packages](https://github.com/schuhschuh/gflags/releases) are available on GitHub.
-
-
-14 January 2013
----------------
-
-The migration of the build system to CMake is almost complete.
-What remains to be done is rewriting the tests in Python such they can be
-executed on non-Unix platforms and splitting them up into separate CTest tests.
-Though merging these changes into the master branch yet remains to be done,
-it is recommended to already start using the
-[cmake-migration](https://github.com/schuhschuh/gflags/tree/cmake-migration) branch.
-
-
-20 April 2013
--------------
-
-More than a year has past since I (Andreas) took over the maintenance for
-`gflags`. Only few minor changes have been made since then, much to my regret.
-To get more involved and stimulate participation in the further
-development of the library, I moved the project source code today to
-[GitHub](https://github.com/schuhschuh/gflags).
-I believe that the strengths of [Git](http://git-scm.com/) will allow for better community collaboration
-as well as ease the integration of changes made by others. I encourage everyone
-who would like to contribute to send me pull requests.
-Git's lightweight feature branches will also provide the right tool for more
-radical changes which should only be merged back into the master branch
-after these are complete and implement the desired behavior.
-
-The SVN repository remains accessible at Google Code and I will keep the
-master branch of the Git repository hosted at GitHub and the trunk of the
-Subversion repository synchronized. Initially, I was going to simply switch the
-Google Code project to Git, but in this case the SVN repository would be
-frozen and force everyone who would like the latest development changes to
-use Git as well. Therefore I decided to host the public Git repository at GitHub
-instead.
-
-Please continue to report any issues with gflags on Google Code. The GitHub project will
-only be used to host the Git repository.
-
-One major change of the project structure I have in mind for the next weeks
-is the migration from autotools to [CMake](http://www.cmake.org/).
-Check out the (unstable!)
-[cmake-migration](https://github.com/schuhschuh/gflags/tree/cmake-migration)
-branch on GitHub for details.
-
-
-25 January 2012
----------------
-
-I've just released gflags 2.0.
-
-The `google-gflags` project has been renamed to `gflags`.  I
-(csilvers) am stepping down as maintainer, to be replaced by Andreas
-Schuh.  Welcome to the team, Andreas!  I've seen the energy you have
-around gflags and the ideas you have for the project going forward,
-and look forward to having you on the team.
-
-I bumped the major version number up to 2 to reflect the new community
-ownership of the project.  All the [changes](ChangeLog.txt)
-are related to the renaming.  There are no functional changes from
-gflags 1.7.  In particular, I've kept the code in the namespace
-`google`, though in a future version it should be renamed to `gflags`.
-I've also kept the `/usr/local/include/google/` subdirectory as
-synonym of `/usr/local/include/gflags/`, though the former name has
-been obsolete for some time now.
-
-
-18 January 2011
----------------
-
-The `google-gflags` Google Code page has been renamed to
-`gflags`, in preparation for the project being renamed to
-`gflags`.  In the coming weeks, I'll be stepping down as
-maintainer for the gflags project, and as part of that Google is
-relinquishing ownership of the project; it will now be entirely
-community run.  The name change reflects that shift.
-
-
-20 December 2011
-----------------
-
-I've just released gflags 1.7.  This is a minor release; the major
-change is that `CommandLineFlagInfo` now exports the address in memory
-where the flag is located.  There has also been a bugfix involving
-very long --help strings, and some other minor [changes](ChangeLog.txt).
-
-29 July 2011
-------------
-
-I've just released gflags 1.6.  The major new feature in this release
-is support for setting version info, so that --version does something
-useful.
-
-One minor change has required bumping the library number:
-`ReparseCommandlineFlags` now returns `void` instead of `int` (the int
-return value was always meaningless).  Though I doubt anyone ever used
-this (meaningless) return value, technically it's a change to the ABI
-that requires a version bump.  A bit sad.
-
-There's also a procedural change with this release: I've changed the
-internal tools used to integrate Google-supplied patches for gflags
-into the opensource release.  These new tools should result in more
-frequent updates with better change descriptions.  They will also
-result in future `ChangeLog` entries being much more verbose (for better
-or for worse).
-
-See the [ChangeLog](ChangeLog.txt) for a full list of changes for this release.
-
-24 January 2011
----------------
-
-I've just released gflags 1.5.  This release has only minor changes
-from 1.4, including some slightly better reporting in --help, and
-an new memory-cleanup function that can help when running gflags-using
-libraries under valgrind.  The major change is to fix up the macros
-(`DEFINE_bool` and the like) to work more reliably inside namespaces.
-
-If you have not had a problem with these macros, and don't need any of
-the other changes described, there is no need to upgrade.  See the
-[ChangeLog](ChangeLog.txt) for a full list of changes for this release.
-
-11 October 2010
----------------
-
-I've just released gflags 1.4.  This release has only minor changes
-from 1.3, including some documentation tweaks and some work to make
-the library smaller.  If 1.3 is working well for you, there's no
-particular reason to upgrade.
-
-4 January 2010
---------------
-
-I've just released gflags 1.3.  gflags now compiles under MSVC, and
-all tests pass.  I **really** never thought non-unix-y Windows folks
-would want gflags, but at least some of them do.
-
-The major news, though, is that I've separated out the python package
-into its own library, [python-gflags](http://code.google.com/p/python-gflags).
-If you're interested in the Python version of gflags, that's the place to
-get it now.
-
-10 September 2009
------------------
-
-I've just released gflags 1.2.  The major change from gflags 1.1 is it
-now compiles under MinGW (as well as cygwin), and all tests pass.  I
-never thought Windows folks would want unix-style command-line flags,
-since they're so different from the Windows style, but I guess I was
-wrong!
-
-The other changes are minor, such as support for --htmlxml in the
-python version of gflags.
-
-15 April 2009
--------------
-
-I've just released gflags 1.1.  It has only minor changes fdrom gflags
-1.0 (see the [ChangeLog](ChangeLog.txt) for details).
-The major change is that I moved to a new system for creating .deb and .rpm files.
-This allows me to create x86\_64 deb and rpm files.
-
-In the process of moving to this new system, I noticed an
-inconsistency: the tar.gz and .rpm files created libraries named
-libgflags.so, but the deb file created libgoogle-gflags.so.  I have
-fixed the deb file to create libraries like the others.  I'm no expert
-in debian packaging, but I believe this has caused the package name to
-change as well.  Please let me know (at
-[[mailto:google-gflags@googlegroups.com](mailto:google-gflags@googlegroups.com)
-google-gflags@googlegroups.com]) if this causes problems for you --
-especially if you know of a fix!  I would be happy to change the deb
-packages to add symlinks from the old library name to the new
-(libgoogle-gflags.so -> libgflags.so), but that is beyond my knowledge
-of how to make .debs.
-
-If you've tried to install a .rpm or .deb and it doesn't work for you,
-let me know.  I'm excited to finally have 64-bit package files, but
-there may still be some wrinkles in the new system to iron out.
-
-1 October 2008
---------------
-
-gflags 1.0rc2 was out for a few weeks without any issues, so gflags
-1.0 is now released.  This is much like gflags 0.9.  The major change
-is that the .h files have been moved from `/usr/include/google` to
-`/usr/include/gflags`.  While I have backwards-compatibility
-forwarding headeds in place, please rewrite existing code to say
-```
-   #include <gflags/gflags.h>
-```
-instead of
-```
-   #include <google/gflags.h>
-```
-
-I've kept the default namespace to google.  You can still change with
-with the appropriate flag to the configure script (`./configure
---help` to see the flags).  If you have feedback as to whether the
-default namespace should change to gflags, which would be a
-non-backwards-compatible change, send mail to
-`google-gflags@googlegroups.com`!
-
-Version 1.0 also has some neat new features, like support for bash
-commandline-completion of help flags.  See the [ChangeLog](ChangeLog.txt)
-for more details.
-
-If I don't hear any bad news for a few weeks, I'll release 1.0-final.

http://git-wip-us.apache.org/repos/asf/incubator-quickstep/blob/b249eb11/third_party/gflags/cmake/README_runtime.txt
----------------------------------------------------------------------
diff --git a/third_party/gflags/cmake/README_runtime.txt b/third_party/gflags/cmake/README_runtime.txt
deleted file mode 100644
index d2556b2..0000000
--- a/third_party/gflags/cmake/README_runtime.txt
+++ /dev/null
@@ -1,4 +0,0 @@
-This package contains runtime libraries only which are required
-by applications that use these libraries for the commandline flags
-processing. If you want to develop such application, download
-and install the development package instead.

http://git-wip-us.apache.org/repos/asf/incubator-quickstep/blob/b249eb11/third_party/gflags/cmake/config.cmake.in
----------------------------------------------------------------------
diff --git a/third_party/gflags/cmake/config.cmake.in b/third_party/gflags/cmake/config.cmake.in
deleted file mode 100644
index 77a8a67..0000000
--- a/third_party/gflags/cmake/config.cmake.in
+++ /dev/null
@@ -1,23 +0,0 @@
-## 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@)
-
-# import targets
-include ("${CMAKE_CURRENT_LIST_DIR}/@PACKAGE_NAME@-export.cmake")
-
-# installation prefix
-get_filename_component (CMAKE_CURRENT_LIST_DIR "${CMAKE_CURRENT_LIST_FILE}" PATH)
-get_filename_component (_INSTALL_PREFIX "${CMAKE_CURRENT_LIST_DIR}/@INSTALL_PREFIX_REL2CONFIG_DIR@" ABSOLUTE)
-
-# include directory
-set (@PACKAGE_NAME@_INCLUDE_DIR "${_INSTALL_PREFIX}/@INCLUDE_INSTALL_DIR@")
-
-# gflags library
-set (@PACKAGE_NAME@_LIBRARIES gflags)
-
-# unset private variables
-unset (_INSTALL_PREFIX)

http://git-wip-us.apache.org/repos/asf/incubator-quickstep/blob/b249eb11/third_party/gflags/cmake/execute_test.cmake
----------------------------------------------------------------------
diff --git a/third_party/gflags/cmake/execute_test.cmake b/third_party/gflags/cmake/execute_test.cmake
deleted file mode 100644
index df008cf..0000000
--- a/third_party/gflags/cmake/execute_test.cmake
+++ /dev/null
@@ -1,53 +0,0 @@
-# ----------------------------------------------------------------------------
-# sanitize string stored in variable for use in regular expression.
-macro (sanitize_for_regex STRVAR)
-  string (REGEX REPLACE "([.+*?^$()])" "\\\\\\1" ${STRVAR} "${${STRVAR}}")
-endmacro ()
-
-# ----------------------------------------------------------------------------
-# script arguments
-if (NOT COMMAND)
-  message (FATAL_ERROR "Test command not specified!")
-endif ()
-if (NOT DEFINED EXPECTED_RC)
-  set (EXPECTED_RC 0)
-endif ()
-if (EXPECTED_OUTPUT)
-  sanitize_for_regex(EXPECTED_OUTPUT)
-endif ()
-if (UNEXPECTED_OUTPUT)
-  sanitize_for_regex(UNEXPECTED_OUTPUT)
-endif ()
-
-# ----------------------------------------------------------------------------
-# set a few environment variables (useful for --tryfromenv)
-set (ENV{FLAGS_undefok} "foo,bar")
-set (ENV{FLAGS_weirdo}  "")
-set (ENV{FLAGS_version} "true")
-set (ENV{FLAGS_help}    "false")
-
-# ----------------------------------------------------------------------------
-# execute test command
-execute_process(
-  COMMAND ${COMMAND}
-  RESULT_VARIABLE RC
-  OUTPUT_VARIABLE OUTPUT
-  ERROR_VARIABLE  OUTPUT
-)
-
-if (OUTPUT)
-  message ("${OUTPUT}")
-endif ()
-
-# ----------------------------------------------------------------------------
-# check test result
-if (NOT RC EQUAL EXPECTED_RC)
-  string (REPLACE ";" " " COMMAND "${COMMAND}")
-  message (FATAL_ERROR "Command:\n\t${COMMAND}\nExit status is ${RC}, expected ${EXPECTED_RC}")
-endif ()
-if (EXPECTED_OUTPUT AND NOT OUTPUT MATCHES "${EXPECTED_OUTPUT}")
-  message (FATAL_ERROR "Test output does not match expected output: ${EXPECTED_OUTPUT}")
-endif ()
-if (UNEXPECTED_OUTPUT AND OUTPUT MATCHES "${UNEXPECTED_OUTPUT}")
-  message (FATAL_ERROR "Test output matches unexpected output: ${UNEXPECTED_OUTPUT}")
-endif ()
\ No newline at end of file

http://git-wip-us.apache.org/repos/asf/incubator-quickstep/blob/b249eb11/third_party/gflags/cmake/package.cmake.in
----------------------------------------------------------------------
diff --git a/third_party/gflags/cmake/package.cmake.in b/third_party/gflags/cmake/package.cmake.in
deleted file mode 100644
index aaec792..0000000
--- a/third_party/gflags/cmake/package.cmake.in
+++ /dev/null
@@ -1,49 +0,0 @@
-# Per-generator CPack configuration file. See CPACK_PROJECT_CONFIG_FILE documented at
-# http://www.cmake.org/cmake/help/v2.8.12/cpack.html#variable:CPACK_PROJECT_CONFIG_FILE
-#
-# All common CPACK_* variables are set in CMakeLists.txt already. This file only
-# overrides some of these to provide package generator specific settings.
-
-# whether package contains all development files or only runtime files
-set (DEVEL @INSTALL_HEADERS@)
-
-# ------------------------------------------------------------------------------
-# Mac OS X package
-if (CPACK_GENERATOR MATCHES "PackageMaker|DragNDrop")
-
-  set (CPACK_PACKAGE_FILE_NAME "${CPACK_PACKAGE_NAME}")
-  if (DEVEL)
-    set (CPACK_PACKAGE_FILE_NAME "${CPACK_PACKAGE_FILE_NAME}-devel")
-  endif ()
-  set (CPACK_PACKAGE_FILE_NAME "${CPACK_PACKAGE_FILE_NAME}-${CPACK_PACKAGE_VERSION}")
-
-# ------------------------------------------------------------------------------
-# Debian package
-elseif (CPACK_GENERATOR MATCHES "DEB")
-
-  set (CPACK_PACKAGE_FILE_NAME   "lib${CPACK_PACKAGE_NAME}")
-  if (DEVEL)
-    set (CPACK_PACKAGE_FILE_NAME "${CPACK_PACKAGE_FILE_NAME}-dev")
-  else ()
-    set (CPACK_PACKAGE_FILE_NAME "${CPACK_PACKAGE_FILE_NAME}0")
-  endif ()
-  set (CPACK_PACKAGE_FILE_NAME   "${CPACK_PACKAGE_FILE_NAME}_${CPACK_PACKAGE_VERSION}-1_${CPACK_PACKAGE_ARCHITECTURE}")
-
-  set (CPACK_DEBIAN_PACKAGE_DEPENDS)
-  set (CPACK_DEBIAN_PACKAGE_SECTION      "devel")
-  set (CPACK_DEBIAN_PACKAGE_PRIORITY     "optional")
-  set (CPACK_DEBIAN_PACKAGE_HOMEPAGE     "${CPACK_RPM_PACKAGE_URL}")
-  set (CPACK_DEBIAN_PACKAGE_MAINTAINER   "${CPACK_PACKAGE_VENDOR}")
-  set (CPACK_DEBIAN_PACKAGE_ARCHITECTURE "${CPACK_PACKAGE_ARCHITECTURE}")
-
-# ------------------------------------------------------------------------------
-# RPM package
-elseif (CPACK_GENERATOR MATCHES "RPM")
-
-  set (CPACK_PACKAGE_FILE_NAME   "${CPACK_PACKAGE_NAME}")
-  if (DEVEL)
-    set (CPACK_PACKAGE_FILE_NAME "${CPACK_PACKAGE_FILE_NAME}-devel")
-  endif ()
-  set (CPACK_PACKAGE_FILE_NAME   "${CPACK_PACKAGE_FILE_NAME}-${CPACK_PACKAGE_VERSION}-1.${CPACK_PACKAGE_ARCHITECTURE}")
-
-endif ()

http://git-wip-us.apache.org/repos/asf/incubator-quickstep/blob/b249eb11/third_party/gflags/cmake/utils.cmake
----------------------------------------------------------------------
diff --git a/third_party/gflags/cmake/utils.cmake b/third_party/gflags/cmake/utils.cmake
deleted file mode 100644
index 9cef463..0000000
--- a/third_party/gflags/cmake/utils.cmake
+++ /dev/null
@@ -1,96 +0,0 @@
-## Utility CMake functions.
-
-# ----------------------------------------------------------------------------
-## Convert boolean value to 0 or 1
-macro (bool_to_int VAR)
-  if (${VAR})
-    set (${VAR} 1)
-  else ()
-    set (${VAR} 0)
-  endif ()
-endmacro ()
-
-# ----------------------------------------------------------------------------
-## 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)
-      set (_major ${CMAKE_MATCH_1})
-    else ()
-      set (_major 0)
-    endif ()
-    if (CMAKE_MATCH_2)
-      set (_minor ${CMAKE_MATCH_2})
-      string (REGEX REPLACE "^\\." "" _minor "${_minor}")
-    else ()
-      set (_minor 0)
-    endif ()
-    if (CMAKE_MATCH_3)
-      set (_patch ${CMAKE_MATCH_3})
-      string (REGEX REPLACE "^\\." "" _patch "${_patch}")
-    else ()
-      set (_patch 0)
-    endif ()
-  else ()
-    set (_major 0)
-    set (_minor 0)
-    set (_patch 0)
-  endif ()
-  set ("${major}" "${_major}" PARENT_SCOPE)
-  set ("${minor}" "${_minor}" PARENT_SCOPE)
-  set ("${patch}" "${_patch}" PARENT_SCOPE)
-endfunction ()
-
-# ----------------------------------------------------------------------------
-## Configure public header files
-function (configure_headers out)
-  set (tmp)
-  foreach (src IN LISTS ARGN)
-    if (IS_ABSOLUTE "${src}")
-      list (APPEND tmp "${src}")
-    elseif (EXISTS "${PROJECT_SOURCE_DIR}/src/${src}.in")
-      configure_file ("${PROJECT_SOURCE_DIR}/src/${src}.in" "${PROJECT_BINARY_DIR}/include/${GFLAGS_INCLUDE_DIR}/${src}" @ONLY)
-      list (APPEND tmp "${PROJECT_BINARY_DIR}/include/${GFLAGS_INCLUDE_DIR}/${src}")
-    else ()
-	    configure_file ("${PROJECT_SOURCE_DIR}/src/${src}" "${PROJECT_BINARY_DIR}/include/${GFLAGS_INCLUDE_DIR}/${src}" COPYONLY)
-      list (APPEND tmp "${PROJECT_BINARY_DIR}/include/${GFLAGS_INCLUDE_DIR}/${src}")
-    endif ()
-  endforeach ()
-  set (${out} "${tmp}" PARENT_SCOPE)
-endfunction ()
-
-# ----------------------------------------------------------------------------
-## Configure source files with .in suffix
-function (configure_sources out)
-  set (tmp)
-  foreach (src IN LISTS ARGN)
-    if (src MATCHES ".h$" AND EXISTS "${PROJECT_SOURCE_DIR}/src/${src}.in")
-      configure_file ("${PROJECT_SOURCE_DIR}/src/${src}.in" "${PROJECT_BINARY_DIR}/include/${GFLAGS_INCLUDE_DIR}/${src}" @ONLY)
-      list (APPEND tmp "${PROJECT_BINARY_DIR}/include/${GFLAGS_INCLUDE_DIR}/${src}")
-    else ()
-      list (APPEND tmp "${PROJECT_SOURCE_DIR}/src/${src}")
-    endif ()
-  endforeach ()
-  set (${out} "${tmp}" PARENT_SCOPE)
-endfunction ()
-
-# ----------------------------------------------------------------------------
-## Add usage test
-#
-# Using PASS_REGULAR_EXPRESSION and FAIL_REGULAR_EXPRESSION would
-# do as well, but CMake/CTest does not allow us to specify an
-# expected exit status. Moreover, the execute_test.cmake script
-# sets environment variables needed by the --fromenv/--tryfromenv tests.
-macro (add_gflags_test name expected_rc expected_output unexpected_output cmd)
-  set (args "--test_tmpdir=${PROJECT_BINARY_DIR}/Testing/Temporary"
-            "--srcdir=${PROJECT_SOURCE_DIR}/test")
-  add_test (
-    NAME    ${name}
-    COMMAND "${CMAKE_COMMAND}" "-DCOMMAND:STRING=$<TARGET_FILE:${cmd}>;${args};${ARGN}"
-                               "-DEXPECTED_RC:STRING=${expected_rc}"
-                               "-DEXPECTED_OUTPUT:STRING=${expected_output}"
-                               "-DUNEXPECTED_OUTPUT:STRING=${unexpected_output}"
-                               -P "${PROJECT_SOURCE_DIR}/cmake/execute_test.cmake"
-    WORKING_DIRECTORY "${GFLAGS_FLAGFILES_DIR}"
-  )
-endmacro ()

http://git-wip-us.apache.org/repos/asf/incubator-quickstep/blob/b249eb11/third_party/gflags/cmake/version.cmake.in
----------------------------------------------------------------------
diff --git a/third_party/gflags/cmake/version.cmake.in b/third_party/gflags/cmake/version.cmake.in
deleted file mode 100644
index 1e1af05..0000000
--- a/third_party/gflags/cmake/version.cmake.in
+++ /dev/null
@@ -1,21 +0,0 @@
-## gflags CMake configuration version file
-
-# -----------------------------------------------------------------------------
-# library version
-set (PACKAGE_VERSION "@PACKAGE_VERSION@")
-
-# -----------------------------------------------------------------------------
-# check compatibility
-
-# Perform compatibility check here using the input CMake variables.
-# See example in http://www.cmake.org/Wiki/CMake_2.6_Notes.
-
-set (PACKAGE_VERSION_COMPATIBLE TRUE)
-set (PACKAGE_VERSION_UNSUITABLE FALSE)
-
-if ("${PACKAGE_FIND_VERSION_MAJOR}" EQUAL "@PACKAGE_VERSION_MAJOR@" AND
-    "${PACKAGE_FIND_VERSION_MINOR}" EQUAL "@PACKAGE_VERSION_MINOR@")
-  set (PACKAGE_VERSION_EXACT TRUE)
-else ()
-  set (PACKAGE_VERSION_EXACT FALSE)
-endif ()

http://git-wip-us.apache.org/repos/asf/incubator-quickstep/blob/b249eb11/third_party/gflags/doc/designstyle.css
----------------------------------------------------------------------
diff --git a/third_party/gflags/doc/designstyle.css b/third_party/gflags/doc/designstyle.css
deleted file mode 100644
index f5d1ec2..0000000
--- a/third_party/gflags/doc/designstyle.css
+++ /dev/null
@@ -1,115 +0,0 @@
-body {
-  background-color: #ffffff;
-  color: black;
-  margin-right: 1in;
-  margin-left: 1in;
-}
-
-
-h1, h2, h3, h4, h5, h6 {
-  color: #3366ff;
-  font-family: sans-serif;
-}
-@media print {
-  /* Darker version for printing */
-  h1, h2, h3, h4, h5, h6 {
-    color: #000080;
-    font-family: helvetica, sans-serif;
-  }
-}
-
-h1 { 
-  text-align: center;
-  font-size: 18pt;
-}
-h2 {
-  margin-left: -0.5in;
-}
-h3 {
-  margin-left: -0.25in;
-}
-h4 {
-  margin-left: -0.125in;
-}
-hr {
-  margin-left: -1in;
-}
-
-/* Definition lists: definition term bold */
-dt {
-  font-weight: bold;
-}
-
-address {
-  text-align: right;
-}
-/* Use the <code> tag for bits of code and <var> for variables and objects. */
-code,pre,samp,var {
-  color: #006000;
-}
-/* Use the <file> tag for file and directory paths and names. */
-file {
-  color: #905050;
-  font-family: monospace;
-}
-/* Use the <kbd> tag for stuff the user should type. */
-kbd {
-  color: #600000;
-}
-div.note p {
-  float: right;
-  width: 3in;
-  margin-right: 0%;
-  padding: 1px;
-  border: 2px solid #6060a0;
-  background-color: #fffff0;
-}
-
-UL.nobullets {
-  list-style-type: none;
-  list-style-image: none;
-  margin-left: -1em;
-}
-
-/*
-body:after {
-  content: "Google Confidential";
-}
-*/
-
-/* pretty printing styles.  See prettify.js */
-.str { color: #080; }
-.kwd { color: #008; }
-.com { color: #800; }
-.typ { color: #606; }
-.lit { color: #066; }
-.pun { color: #660; }
-.pln { color: #000; }
-.tag { color: #008; }
-.atn { color: #606; }
-.atv { color: #080; }
-pre.prettyprint { padding: 2px; border: 1px solid #888; }
-
-.embsrc { background: #eee; }
-
-@media print {
-  .str { color: #060; }
-  .kwd { color: #006; font-weight: bold; }
-  .com { color: #600; font-style: italic; }
-  .typ { color: #404; font-weight: bold; }
-  .lit { color: #044; }
-  .pun { color: #440; }
-  .pln { color: #000; }
-  .tag { color: #006; font-weight: bold; }
-  .atn { color: #404; }
-  .atv { color: #060; }
-}
-
-/* Table Column Headers */
-.hdr { 
-  color: #006; 
-  font-weight: bold; 
-  background-color: #dddddd; }
-.hdr2 { 
-  color: #006; 
-  background-color: #eeeeee; }
\ No newline at end of file

http://git-wip-us.apache.org/repos/asf/incubator-quickstep/blob/b249eb11/third_party/gflags/doc/index.html
----------------------------------------------------------------------
diff --git a/third_party/gflags/doc/index.html b/third_party/gflags/doc/index.html
deleted file mode 100644
index 3a66713..0000000
--- a/third_party/gflags/doc/index.html
+++ /dev/null
@@ -1,558 +0,0 @@
-<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.0 Transitional//EN">
-
-<html>
-<head>
-<title>How To Use Gflags (formerly Google Commandline Flags)</title>
-
-<meta http-equiv="Content-Type" content="text/html; charset=utf-8">
-<link href="designstyle.css" type="text/css" rel="stylesheet">
-<style type="text/css">
-<!--
-  ol.bluelist li {
-    color: #3366ff;
-    font-family: sans-serif;
-  }
-  ol.bluelist li p {
-    color: #000;
-    font-family: "Times Roman", times, serif;
-  }
-  ul.blacklist li {
-    color: #000;
-    font-family: "Times Roman", times, serif;
-  }
-//-->
-</style>
-</head>
-
-<body>
-
-<h1>How To Use gflags (formerly Google Commandline Flags)</h1>
-<small>(as of
-<script type=text/javascript>
-  var lm = new Date(document.lastModified);
-  document.write(lm.toDateString());
-</script>)
-</small>
-<br>
-
-<blockquote><dl>
-  <dt> Table of contents </dt>
-  <dd> <a href="#intro">Introduction</a> </dd>
-  <dd> <a href="#cmake">Finding and Linking to gflags using CMake</a></dd>
-  <dd> <a href="#define">DEFINE: Defining Flags In Program</A> </dd>
-  <dd> <a href="#using">Accessing the Flag</A> </dd>
-  <dd> <a href="#declare">DECLARE: Using the Flag in a Different File</a> </dd>
-  <dd> <a href="#validate">RegisterFlagValidator: Sanity-checking Flag Values</a> </dd>
-  <dd> <a href="#together">Putting It Together: How to Set Up Flags</a> </dd>
-  <dd> <a href="#commandline">Setting Flags on the Command Line</a> </dd>
-  <dd> <a href="#varz">Setting Flags at Runtime</a> </dd>
-  <dd> <a href="#default">Changing the Default Flag Value</a> </dd>
-  <dd> <a href="#special">Special Flags</a> </dd>
-  <dd> <a href="#api">The API</a> </dd>
-  <dd> <br/> </dd>
-</dl></blockquote>
-
-<h2> <A NAME=intro>Introduction, and Comparison to Other Commandline
-     Flags Libraries</A> </h2>
-
-<p><b>Commandline flags</b> are flags that users specify on the
-command line when they run an executable.  In the command</p>
-<pre>
-   fgrep -l -f /var/tmp/foo johannes brahms
-</pre>
-<p><code>-l</code> and <code>-f /var/tmp/foo</code> are the two
-commandline flags.  (<code>johannes</code> and <code>brahms</code>,
-which don't start with a dash, are <b>commandline arguments</b>.)</p>
-
-<p>Typically, an application lists what flags the user is allowed to
-pass in, and what arguments they take -- in this example,
-<code>-l</code> takes no argument, and <code>-f</code> takes a
-string (in particular, a filename) as an argument.  Users can use a
-library to help parse the commandline and store the flags in some data
-structure.</p>
-
-<p>Gflags, the commandline flags library used within Google,
-differs from other libraries,
-such as <code>getopt()</code>, in that flag definitions can be
-scattered around the source code, and not just listed in one place
-such as <code>main()</code>.  In practice, this means that a single
-source-code file will define and use flags that are meaningful to that
-file.  Any application that links in that file will get the flags, and
-the gflags library will automatically handle that
-flag appropriately.</p>
-
-<p>There's significant gain in flexibility, and ease of code reuse,
-due to this technique.  However, there is a danger that two files will
-define the same flag, and then give an error when they're linked
-together.</p>
-
-<p>The rest of this document describes how to use the commandlineflag
-library.  It's a C++ library, so examples are in C++.  However, there
-is a Python port with the same functionality, and this discussion
-translates directly to Python.</p>
-
-<h2> <A name=cmake>Finding and Linking to gflags </A> using CMake</h2>
-
-<p> Using gflags within a project which uses <A href="http://www.cmake.org">CMake</A> for its build system is easy. Therefore, simply add the following CMake code to your <code>CMakeLists.txt</code> file.
-
-<pre>
-   find_package (gflags REQUIRED)
-   include_directories (${gflags_INCLUDE_DIR})
-   
-   add_executable (foo main.cc)
-   target_link_libraries (foo gflags)
-</pre>
-
-<h2> <A name=define>DEFINE: Defining Flags In Program</A> </h2>
-
-<p> Defining a flag is easy: just use the appropriate macro for the
-type you want the flag to be, as defined at the bottom of
-<code>gflags/gflags.h</code>.  Here's an example file,
-<code>foo.cc</code>:</p>
-
-<pre>
-   #include &lt;gflags/gflags.h&gt;
-
-   DEFINE_bool(big_menu, true, "Include 'advanced' options in the menu listing");
-   DEFINE_string(languages, "english,french,german",
-                 "comma-separated list of languages to offer in the 'lang' menu");
-</pre>
-
-<p><code>DEFINE_bool</code> defines a boolean flag.  Here are the
-types supported:</p>
-<ul>
-  <li> <code>DEFINE_bool</code>: boolean
-  <li> <code>DEFINE_int32</code>: 32-bit integer
-  <li> <code>DEFINE_int64</code>: 64-bit integer
-  <li> <code>DEFINE_uint64</code>: unsigned 64-bit integer
-  <li> <code>DEFINE_double</code>: double
-  <li> <code>DEFINE_string</code>: C++ string
-</ul>
-
-<p>Note that there are no 'complex' types like lists: the "languages"
-flag in our example is a list of strings, but is defined of type
-"string", not "list_of_string" or similar.  This is by design.  We'd
-rather use only simple types for the flags, and allow for complex,
-arbitrary parsing routines to parse them, than to try to put the logic
-inside the flags library proper.</p>
-
-<p>All DEFINE macros take the same three arguments: the name of the
-flag, its default value, and a 'help' string that describes its use.
-The 'help' string is displayed when the user runs the application with
-the <A HREF="#special"><code>--help</code> flag</A>.</p>
-
-<p>You can define a flag in any source-code file in your executable.
-Only define a flag once!  If you want to access a flag in more than
-one source file, DEFINE it in one file, and <A
-HREF="#declare">DECLARE</A> it in the others.  Even better, DEFINE it
-in <code>foo.cc</code> and DECLARE it in <code>foo.h</code>; then
-everyone who <code>#includes foo.h</code> can use the flag.</p>
-
-<p>
-Defining flags in libraries rather than in main() is powerful, but
-does have some costs. One is that a library might not have a good
-default value for its flags, for example if the flag holds a
-filename that might not exist in some environments. To mitigate such problems,
-you can use <a href="#validate">flag validators</a> to ensure prompt
-notification (in the form of a crash) of an invalid flag value.
-</p>
-
-<p>Note that while most functions in this library are defined in the
-<code>google</code> namespace, <code>DEFINE_foo</code> (and
-<code>DECLARE_foo</code>, <A HREF="#declare">below</A>), should always
-be in the global namespace.</p>
-
-
-<h2> <A name=using>Accessing the Flag</A> </h2>
-
-<p>All defined flags are available to the program as just a normal
-variable, with the prefix <code>FLAGS_</code> prepended.  In the above
-example, the macros define two variables, <code>FLAGS_big_menu</code>
-(a bool), and <code>FLAGS_languages</code> (a C++ string).</p>
-
-<p>You can read and write to the flag just like any other
-variable:</p>
-<pre>
-   if (FLAGS_consider_made_up_languages)
-     FLAGS_languages += ",klingon";   // implied by --consider_made_up_languages
-   if (FLAGS_languages.find("finnish") != string::npos)
-     HandleFinnish();
-</pre>
-
-<p>You can also get and set flag values via special functions in
-<code>gflags.h</code>.  That's a rarer use case, though.</p>
-
-
-<h2> <A name=declare>DECLARE: Using the Flag in a Different File</A> </h2>
-
-<p>Accessing a flag in the manner of the previous section only works
-if the flag was <code>DEFINE</code>-ed at the top of the file.  If it
-wasn't, you'll get an 'unknown variable' error.</p>
-
-<p>The <code>DECLARE_type</code> macro is available when you want to
-use a flag that's defined in another file.  For instance, if I were
-writing <code>bar.cc</code> but wanted to access the big_menu, flag, I
-would put this near the top of <code>bar.cc</code>:</p>
-<pre>
-   DECLARE_bool(big_menu);
-</pre>
-
-<p>This is functionally equivalent to saying <code>extern
-FLAGS_big_menu</code>.</p>
-
-<p>Note that such an extern declaration introduces a dependency
-between your file and the file that defines the <code>big_menu</code>
-flag: <code>foo.cc</code>, in this case.  Such implicit dependencies
-can be difficult to manage in large projects.  For that reason we
-recommend the following guideline:</p>
-
-<blockquote>
-If you DEFINE a flag in <code>foo.cc</code>, either don't DECLARE it
-at all, only DECLARE it in tightly related tests, or only DECLARE
-it in <code>foo.h</code>.
-</blockquote>
-
-<p>You should go the do-not-DECLARE route when the flag is only needed
-by <code>foo.cc</code>, and not in any other file. If you want to
-modify the value of the flag in the related test file to see if it is
-functioning as expected, DECLARE it in the <code>foo_test.cc</code>
-file.
-
-<p>If the flag does span multiple files, DECLARE it in the associated
-<code>.h</code> file, and make others <code>#include</code> that
-<code>.h</code> file if they want to access the flag.  The
-<code>#include</code> will make explicit the dependency between the
-two files. This causes the flag to be a global variable.</p>
-
-
-<h2> <A name=validate>RegisterFlagValidator: Sanity-checking Flag Values</A> </h2>
-
-<p>After DEFINE-ing a flag, you may optionally register a validator
-function with the flag.  If you do this, after the flag is parsed from
-the commandline, and whenever its value is changed via a call to
-<code>SetCommandLineOption()</code>, the validator function is called
-with the new value as an argument.  The validator function should
-return 'true' if the flag value is valid, and false otherwise.
-If the function returns false for the new setting of the
-flag, the flag will retain its current value. If it returns false for the
-default value, ParseCommandLineFlags will die.
-
-<p>Here is an example use of this functionality:</p>
-<pre>
-static bool ValidatePort(const char* flagname, int32 value) {
-   if (value > 0 && value < 32768)   // value is ok
-     return true;
-   printf("Invalid value for --%s: %d\n", flagname, (int)value);
-   return false;
-}
-DEFINE_int32(port, 0, "What port to listen on");
-static const bool port_dummy = RegisterFlagValidator(&FLAGS_port, &ValidatePort);
-</pre>
-
-<p>By doing the registration at global initialization time (right
-after the DEFINE), we ensure that the registration happens before
-the commandline is parsed at the beginning of <code>main()</code>.</p>
-
-<p><code>RegisterFlagValidator()</code> returns true if the
-registration is successful.  It return false if the registration fails
-because a) the first argument does not refer to a commandline flag, or
-b) a different validator has already been registered for this flag.</p>
-
-
-<h2> <A name=together>Putting It Together: How to Set Up Flags</A> </h2>
-
-<p>The final piece is the one that tells the executable to process the
-commandline flags, and set the <code>FLAGS_*</code> variables to the
-appropriate, non-default value based on what is seen on the
-commandline.  This is equivalent to the <code>getopt()</code> call in
-the getopt library, but has much less overhead to use.  In fact, it's
-just a single function call:</p>
-
-<pre>
-   gflags::ParseCommandLineFlags(&argc, &argv, true);
-</pre>
-
-<p>Usually, this code is at the beginning of <code>main()</code>.
-<code>argc</code> and <code>argv</code> are exactly as passed in to
-<code>main()</code>.  This routine might modify them, which is why
-pointers to them are passed in.</p>
-
-<p>The last argument is called "remove_flags".  If true, then
-<code>ParseCommandLineFlags</code> removes the flags and their
-arguments from <code>argv</code>, and modifies <code>argc</code>
-appropriately.  In this case, after the function call,
-<code>argv</code> will hold only commandline arguments, and not
-commandline flags.</p>
-
-<p>If, on the other hand, <code>remove_flags</code> is false, then
-<code>ParseCommandLineFlags</code> will leave argc unchanged, but will
-rearrange the arguments in argv so that the flags are all at the
-beginning.  For example, if the input is <code>"/bin/foo" "arg1" "-q"
-"arg2"</code> (which is legal but weird), the function will rearrange
-<code>argv</code> so it reads <code>"/bin/foo", "-q", "arg1",
-"arg2"</code>.  In this case, <code>ParseCommandLineFlags</code>
-returns the index into argv that holds the first commandline argument:
-that is, the index past the last flag.  (In this example, it would
-return 2, since <code>argv[2]</code> points to <code>arg1</code>.)</p>
-
-<p>In either case, the <code>FLAGS_*</code> variables are modified
-based on what was <A HREF="#commandline">passed in on the
-commandline</A>.</p>
-
-
-<h2> <A name=commandline>Setting Flags on the Command Line</A> </h2>
-
-<p>The reason you make something a flag instead of a compile-time
-constant, is so users can specify a non-default value on the
-commandline.  Here's how they might do it for an application that
-links in <code>foo.cc</code>:</p>
-<pre>
-   app_containing_foo --nobig_menu -languages="chinese,japanese,korean" ...
-</pre>
-
-<p>This sets <code>FLAGS_big_menu = false;</code> and
-<code>FLAGS_languages = "chinese,japanese,korean"</code>, when
-<code>ParseCommandLineFlags</code> is run.</p>
-
-<p>Note the atypical syntax for setting a boolean flag to false:
-putting "no" in front of its name.  There's a fair bit of flexibility
-to how flags may be specified.  Here's an example of all the ways to
-specify the "languages" flag:</p>
-<ul>
-  <li> <code>app_containing_foo --languages="chinese,japanese,korean"</code>
-  <li> <code>app_containing_foo -languages="chinese,japanese,korean"</code>
-  <li> <code>app_containing_foo --languages "chinese,japanese,korean"</code>
-  <li> <code>app_containing_foo -languages "chinese,japanese,korean"</code>
-</ul>
-
-<p>For boolean flags, the possibilities are slightly different:</p>
-<ul>
-  <li> <code>app_containing_foo --big_menu</code>
-  <li> <code>app_containing_foo --nobig_menu</code>
-  <li> <code>app_containing_foo --big_menu=true</code>
-  <li> <code>app_containing_foo --big_menu=false</code>
-</ul>
-<p>(as well as the single-dash variant on all of these).</p>
-
-<p>Despite this flexibility, we recommend using only a single form:
-<code>--variable=value</code> for non-boolean flags, and
-<code>--variable/--novariable</code> for boolean flags.  This
-consistency will make your code more readable, and is also the format
-required for certain special-use cases like <A
-HREF="#flagfiles">flagfiles</A>.</p>
-
-<p>It is a fatal error to specify a flag on the commandline that has
-not been DEFINED somewhere in the executable.  If you need that
-functionality for some reason -- say you want to use the same set of
-flags for several executables, but not all of them DEFINE every flag
-in your list -- you can specify <A
-HREF="#special"><code>--undefok</code></A> to suppress the error.</p>
-
-<p>As in getopt(), <code>--</code> by itself will terminate flags
-processing.  So in <code>foo -f1 1 -- -f2 2</code>, <code>f1</code> is
-considered a flag, but <code>-f2</code> is not.</p>
-
-<p>If a flag is specified more than once, only the last specification
-is used; the others are ignored.</p>
-
-<p>Note that flags do not have single-letter synonyms, like they do in
-the getopt library, nor do we allow "combining" flags behind a
-single dash, as in <code>ls -la</code>.</p>
-
-
-
-<h2> <A name=default>Changing the Default Flag Value</A> </h2>
-
-<p>Sometimes a flag is defined in a library, and you want to change
-its default value in one application but not others.  It's simple to
-do this: just assign a new value to the flag in <code>main()</code>,
-before calling <code>ParseCommandLineFlags()</code>:</p>
-<pre>
-   DECLARE_bool(lib_verbose);   // mylib has a lib_verbose flag, default is false
-   int main(int argc, char** argv) {
-     FLAGS_lib_verbose = true;  // in my app, I want a verbose lib by default
-     ParseCommandLineFlags(...);
-   }
-</pre>
-
-<p>For this application, users can still set the flag value on the
-commandline, but if they do not, the flag's value will default to
-true.</p>
-
-
-<h2> <A name="special">Special Flags</a> </h2>
-
-<p>There are a few flags defined by the commandlineflags module
-itself, and are available to all applications that use
-commandlineflags.  These fall into
-three categories.  First are the 'reporting' flags that, when found, cause
-the application to print some information about itself and exit.</p>
-
-<table><tr valign=top>
-  <td><code>--help</code></td>
-  <td>shows all flags from all files, sorted by file and then by name;
-      shows the flagname, its default value, and its help string</td>
-</tr><tr valign=top>
-  <td><code>--helpfull</code></td>
-  <td>same as -help, but unambiguously asks for all flags
-     (in case -help changes in the future)</td>
-</tr><tr valign=top>
-  <td><code>--helpshort</code></td>
-  <td>shows only flags for the file with the same name as the executable 
-      (usually the one containing <code>main()</code>)</td>
-</tr><tr valign=top>
-  <td><code>--helpxml</code></td>
-  <td>like --help, but output is in xml for easier parsing</td>
-</tr><tr valign=top>
-  <td><code>--helpon=FILE &nbsp;</code></td>
-  <td>shows only flags defined in FILE.*</td>
-</tr><tr valign=top>
-  <td><code>--helpmatch=S</code></td>
-  <td>shows only flags defined in *S*.*</td>
-</tr><tr valign=top>
-  <td><code>--helppackage</code></td>
-  <td>shows flags defined in files in same directory as <code>main()</code></td>
-</tr><tr valign=top>
-  <td><code>--version</code></td>
-  <td>prints version info for the executable</td>
-</tr></table>
-
-<p>Second are the flags that affect how other flags are parsed.</p>
-
-<table><tr valign=top>
-  <td><code>--undefok=flagname,flagname,...</code></td>
-  <td>for those names listed as the argument to <code>--undefok</code>,
-      suppress the normal error-exit that occurs when
-      <code>--name</code> is seen on the commandline, but
-      <code>name</code> has not been DEFINED anywhere in the
-      application
-</table>
-
-<p>Third are the 'recursive' flags, that cause other flag values to be
-set: <code>--fromenv</code>, <code>--tryfromenv</code>,
-<code>--flagfile</code>.  These are described below in more
-detail.</p>
-
-<h3> <code>--fromenv</code> </h3>
-
-<p><code>--fromenv=foo,bar</code> says to read the values for the
-<code>foo</code> and <code>bar</code> flags from the environment.
-In concert with this flag, you must actually set the values in the
-environment, via a line like one of the two below:</p>
-<pre>
-   export FLAGS_foo=xxx; export FLAGS_bar=yyy   # sh
-   setenv FLAGS_foo xxx; setenv FLAGS_bar yyy   # tcsh
-</pre>
-<p>This is equivalent to specifying <code>--foo=xxx</code>,
-<code>--bar=yyy</code> on the commandline.</p>
-
-<p>Note it is a fatal error to say <code>--fromenv=foo</code> if
-<code>foo</code> is not DEFINED somewhere in the application.  (Though
-you can suppress this error via <code>--undefok=foo</code>, just like
-for any other flag.)</p>
-
-<p>It is also a fatal error to say <code>--fromenv=foo</code> if
-<code>FLAGS_foo</code> is not actually defined in the environment.</p>
-
-<h3> <code>--tryfromenv</code> </h3>
-
-<p><code>--tryfromenv</code> is exactly like <code>--fromenv</code>,
-except it is <b>not</b> a fatal error to say
-<code>--tryfromenv=foo</code> if <code>FLAGS_foo</code> is not
-actually defined in the environment.  Instead, in such cases,
-<code>FLAGS_foo</code> just keeps its default value as specified in
-the application.</p>
-
-<p>Note it is still an error to say <code>--tryfromenv=foo</code> if
-<code>foo</code> is not DEFINED somewhere in the application.</p>
-
-<h3> <code>--flagfile</code> </h3>
-
-<p><code>--flagfile=f</code> tells the commandlineflags module to read
-the file <code>f</code>, and to run all the flag-assignments found in
-that file as if these flags had been specified on the commandline.</p>
-
-<p>In its simplest form, <code>f</code> should just be a list of flag
-assignments, one per line.  Unlike on the commandline, the equals sign
-separating a flagname from its argument is <i>required</i> for
-flagfiles.  An example flagfile, <code>/tmp/myflags</code>:</p>
-<pre>
---nobig_menus
---languages=english,french
-</pre>
-
-<p>With this flagfile, the following two lines are equivalent:<p>
-<pre>
-   ./myapp --foo --nobig_menus --languages=english,french --bar
-   ./myapp --foo --flagfile=/tmp/myflags --bar
-</pre>
-
-<p>Note that many errors are silently suppressed in flagfiles.  In
-particular, unrecognized flagnames are silently ignored, as are flags
-that are missing a required value (e.g., a flagfile that just says
-<code>--languages</code>).</p>
-
-<p>The general format of a flagfile is a bit more complicated than the
-simple, common case above.  It is: a sequence of filenames, one per
-line, followed by a sequence of flags, one per line, repeated as many
-times as desired.  Filenames in a flagfile can use wildcards
-(<code>*</code> and <code>?</code>), and the sequence of flags located
-after a sequence of filenames is processed only if the current
-executable's name matches one of the filenames.  It is possible to
-start the flagfile with a sequence of flags instead of a sequence of
-filenames; if such a sequence of flags is present, these flags are
-applied to the current executable no matter what it is.</p>
-
-<p>Lines that start with a <code>#</code> are ignored as comments.
-Leading whitespace is also ignored in flagfiles, as are blank
-lines.</p>
-
-<p>It is possible for a flagfile to use the <code>--flagfile</code>
-flag to include another flagfile.</p>
-
-<p>Flags are always processed in the expected order.  That is,
-processing begins by examining the flags specified directly on the
-command line.  If a flagfile is specified, its contents are processed,
-and then processing continues with remaining flags from the command
-line.</p>
-
-
-<h2> <A name="api">The API</a> </h2>
-
-<p>In addition to accessing <code>FLAGS_foo</code> directly, it is
-possible to access the flags programmatically, through an API.  It is
-also possible to access information about a flag, such as its default
-value and help-string.  A <code>FlagSaver</code> makes it easy to
-modify flags and then automatically undo the modifications later.
-Finally, there are somewhat unrelated, but useful, routines to easily
-access parts of <code>argv</code> outside main, including the program
-name (<code>argv[0]</code>).</p>
-
-<p>For more information about these routines, and other useful helper
-methods such as <code>gflags::SetUsageMessage()</code> and
-<code>gflags::SetVersionString</code>, see <code>gflags.h</code>.</p>
-
-
-<h2> <A name="misc">Miscellaneous Notes</code> </h2>
-
-<p>If your application has code like this:</p>
-<pre>
-   #define STRIP_FLAG_HELP 1    // this must go before the #include!
-   #include &lt;gflags/gflags.h&gt;
-</pre>
-<p>we will remove the help messages from the compiled source. This can
-reduce the size of the resulting binary somewhat, and may also be
-useful for security reasons.</p>
-
-
-<hr>
-<address>
-Craig Silverstein, Andreas Schuh<br>
-<script type=text/javascript>
-  var lm = new Date(document.lastModified);
-  document.write(lm.toDateString());
-</script>
-</address>
-
-</body>
-</html>

http://git-wip-us.apache.org/repos/asf/incubator-quickstep/blob/b249eb11/third_party/gflags/src/config.h.in
----------------------------------------------------------------------
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


Mime
View raw message