pax_global_header 0000666 0000000 0000000 00000000064 12732311114 0014505 g ustar 00root root 0000000 0000000 52 comment=0979a4b48ccec520e7f5fdd208adf7ace91c274a
mongo-cxx-driver-legacy-1.1.2/ 0000775 0000000 0000000 00000000000 12732311114 0016160 5 ustar 00root root 0000000 0000000 mongo-cxx-driver-legacy-1.1.2/.gitignore 0000664 0000000 0000000 00000000205 12732311114 0020145 0 ustar 00root root 0000000 0000000
# Directories that are generated
/build
/docs
/callgrind.out.*
/massif.out.*
*~
*.pyc
*#
.#*
#osx
.DS_Store
._.DS_Store
*.fuse_*
mongo-cxx-driver-legacy-1.1.2/.mci.yml 0000664 0000000 0000000 00000056530 12732311114 0017542 0 ustar 00root root 0000000 0000000 #######################################
# CXX Driver Config for MCI #
#######################################
## Some variables for convenience:
cxx_driver_variables:
## The basic set of tests to run on most buildvariants
latest_test_list: &latest_tests
- name: "compile"
- name: "unit-test"
- name: "integration-test-latest"
- name: "integration-test-latest-with-auth"
- name: "client-test-latest"
## Note that the in 3.0, the default storage engine is MMAPv1 and
## WiredTiger is opt-in, but as of MongoDB 3.1.4, the
## default is WiredTiger and MMAPv1 is opt-in.
storage_engine_test_list: &storage_engine_tests
- name: "compile"
- name: "unit-test"
- name: "integration-test-3.0"
- name: "integration-test-3.0-with-WiredTiger"
- name: "integration-test-3.2"
- name: "integration-test-3.2-with-MMAPv1"
- name: "client-test-3.0"
- name: "client-test-3.0-with-WiredTiger"
- name: "client-test-3.2"
- name: "client-test-3.2-with-MMAPv1"
version_test_list: &version_tests
- name: "compile"
- name: "lint"
- name: "unit-test"
- name: "integration-test-2.2"
- name: "integration-test-2.4"
- name: "integration-test-2.6"
- name: "integration-test-3.0"
- name: "integration-test-3.2"
- name: "integration-test-latest"
- name: "client-test-2.2"
- name: "client-test-2.4"
- name: "client-test-2.6"
- name: "client-test-3.0"
- name: "client-test-3.2"
- name: "client-test-latest"
## Common download urls (merge in as hashes)
mongo_download_url_prefixes:
ubuntu1404: &mongo_url_ubuntu1404
mongo_url_prefix: "http://downloads.mongodb.com/linux/mongodb-linux-x86_64-"
mongo_url_platform: "ubuntu1404-"
windows64-bitcomm: &mongo_url_windows64
mongo_url_prefix: "http://downloads.mongodb.com/win32/mongodb-win32-x86_64-"
mongo_url_platform: "windows-64-"
windows32: &mongo_url_windows32
mongo_url_prefix: "http://downloads.mongodb.org/win32/mongodb-win32-i386-"
mongo_url_enterprise_keyword: ""
rhel55: &mongo_url_rhel55
mongo_url_prefix: "http://downloads.mongodb.com/linux/mongodb-linux-x86_64-"
mongo_url_platform: "rhel57-"
rhel55_32: &mongo_url_rhel55_32
mongo_url_prefix: "http://downloads.mongodb.org/linux/mongodb-linux-i686-"
mongo_url_enterprise_keyword: ""
mongo_url_subscription_keyword: ""
osx-1010: &mongo_url_osx_1010
mongo_url_prefix: "http://downloads.mongodb.org/osx/mongodb-osx-x86_64-"
mongo_url_enterprise_keyword: ""
## Common sets of scons flags
scons_flags:
standard: &scons_flags_64
scons_flags: "--64 --ssl --use-sasl-client --sharedclient"
standard_32: &scons_flags_32
scons_flags: "--32 --ssl --use-sasl-client --sharedclient"
ubuntu_c++11: &scons_flags_cpp11
scons_flags: "--64 --c++11 --ssl --use-sasl-client --sharedclient"
osx_1010: &scons_flags_osx_1010
scons_flags: "--64 --ssl --use-sasl-client --sharedclient --osx-version-min=10.7 --libc++"
## test all plausible combinations of static/dynamic mongo client and windows runtime:
static_windows: &scons_flags_64_windows_static
scons_flags: "--64 --ssl --use-sasl-client"
dynamic_RT_windows: &scons_flags_64_windows_dynamic_rt
scons_flags: "--64 --ssl --use-sasl-client --dynamic-windows"
dynamic_windows: &scons_flags_64_windows_dynamic
scons_flags: "--64 --ssl --use-sasl-client --dynamic-windows --sharedclient"
32bit_windows: &scons_flags_32_windows_dynamic
scons_flags: "--32 --dynamic-windows --sharedclient"
## Special compile flags
compile_flags:
debug: &compile_flags_debug
compile_flags: "--dbg=on"
parallel_compile_flags:
proc_parallel: ¶llel_compile_flags_proc
parallel_compile_flags: "-j$(grep -c ^processor /proc/cpuinfo)"
sysctl_parallel: ¶llel_compile_flags_sysctl
parallel_compile_flags: "-j$(sysctl -n hw.logicalcpu)"
## Scripts that are shared between buildvariants
scripts:
mongo_orchestration:
windows: &mongo_orchestration_windows
start_mongo_orchestration: |
echo "Installing Mongo Orchestration..."
trap 'set +o errexit; mongo-orchestration stop;' EXIT
taskkill.exe /fi python /f
echo "Starting Mongo Orchestration..."
echo "{ \"releases\": { \"default\": \"c:\\\\mongodb\\\\bin\" }, \"last_updated\": \"2014-08-29 20:57:00.000000\" }" > orchestration.config
mongo-orchestration -f orchestration.config -e default -s wsgiref start --socket-timeout-ms=60000
sleep 15
linux: &mongo_orchestration_linux
## we are going to manually install mongo-orchestration for now on Linux until it is stable enough that we don't always to install from HEAD
start_mongo_orchestration: |
echo "Installing Mongo Orchestration..."
trap 'set +o errexit; mongo-orchestration stop;' EXIT
echo "Starting Mongo Orchestration..."
echo "{ \"releases\": { \"default\": \"`pwd`/mongodb/bin\" }, \"last_updated\": \"2014-08-29 20:57:00.000000\" }" > orchestration.config
TMPDIR=/data/db mongo-orchestration -f orchestration.config -e default start --socket-timeout-ms=60000
sleep 15
osx: &mongo_orchestration_osx
start_mongo_orchestration: |
echo "Starting Mongo Orchestration..."
trap 'set +o errexit; /usr/local/bin/mongo-orchestration stop;' EXIT
echo "{ \"releases\": { \"default\": \"`pwd`/mongodb/bin\" }, \"last_updated\": \"2014-08-29 20:57:00.000000\" }" > orchestration.config
TMPDIR=/data/db /usr/local/bin/mongo-orchestration -f orchestration.config -e default start # --socket-timeout-ms=60000 <- uncomment when OSX builders get new MO
sleep 15
## Other os-specific attributes, grouped by OS
## Misc. for Windows builds
windows_compilers:
## msvc2010
msvc2010: &with_msvc2010
toolchain_flags: --msvc-version=10.0
libpath: --libpath="c:\local\boost_1_57_0\lib64-msvc-10.0"
cpppath: --cpppath="c:\local\boost_1_57_0"
dllpath: --runtime-library-search-path="c:\local\boost_1_57_0\lib64-msvc-10.0,c:\openssl\bin,c:\sasl\bin,c:\curl\dlls"
extrapath: --extrapath="c:\openssl,c:\sasl,c:\curl"
## msvc2013, 32-bit boost headers
msvc2013-32: &with_msvc2010_32bit
toolchain_flags: --msvc-version=10.0
libpath: --libpath="c:\local\boost_1_57_0\lib32-msvc-10.0"
cpppath: --cpppath="c:\local\boost_1_57_0"
dllpath: --runtime-library-search-path="c:\local\boost_1_57_0\lib32-msvc-10.0,c:\curl\dlls"
extrapath: --extrapath="c:\curl"
msvc2013: &with_msvc2013
toolchain_flags: --msvc-version=12.0
libpath: --libpath="c:\local\boost_1_56_0\lib64-msvc-12.0"
cpppath: --cpppath="c:\local\boost_1_56_0"
dllpath: --runtime-library-search-path="c:\local\boost_1_56_0\lib64-msvc-12.0,c:\openssl\bin,c:\sasl\bin,c:\curl\dlls"
extrapath: --extrapath="c:\openssl,c:\sasl,c:\curl"
msvc2015: &with_msvc2015
toolchain_flags: --msvc-version=14.0
libpath: --libpath="c:\local\boost_1_60_0\lib64-msvc-14.0"
cpppath: --cpppath="c:\local\boost_1_60_0"
dllpath: --runtime-library-search-path="c:\local\boost_1_60_0\lib64-msvc-14.0,c:\openssl\bin,c:\sasl\bin,c:\curl\dlls"
extrapath: --extrapath="c:\openssl,c:\sasl,c:\curl"
## all windows buildvariants have these attributes in common
windows_common: &windows_common
mongo_url_extension: "zip"
scons: scons.bat
extension: ".exe"
windows: true
<<: *mongo_orchestration_windows
## Paths for OS X builds
osx_fixups:
scons:
boost_headers: &extrapath_osx_1010
extrapath: --extrapath="/usr/local"
## Paths and flags for RHEL 5.5 builds
rhel55_fixups:
scons:
warning_flags: &warning_flags_rhel55
# For some reason GCC on RHEL 5.5 gives lots of warnings from its own headers when using
# visibility attributes.
warning_flags: --disable-warnings-as-errors
cpp:
cpp_boost: &cpppath_rhel55
cpppath: --cpppath="/usr/include/boost141"
lib:
lib32_boost: &libpath_rhel55_32
libpath: --libpath="/usr/lib/boost141"
lib64_boost: &libpath_rhel55_64
libpath: --libpath="/usr/lib64/boost141"
#######################################
# Functions #
#######################################
functions:
"fetch source" :
command: git.get_project
params:
directory: mongo-cxx-driver
"fetch mongodb" :
command: shell.exec
params:
working_dir: "mongo-cxx-driver"
script: |
set -o verbose
set -o errexit
curl -s ${mongo_url} --output mongo_enterprise.${ext|tgz}
${decompress} mongo_enterprise.${ext|tgz}
mv mongodb* mongodb
chmod +x ./mongodb/bin/mongod${extension}
if [ ${windows|false} = true ]; then
cp -r mongodb /cygdrive/c/mongodb
#This won't run on a 32bit OS.
./mongodb/bin/vcredist_x64${extension} /Q
fi
"fetch artifacts" :
command: s3.get
params:
aws_key: ${aws_key}
aws_secret: ${aws_secret}
remote_file: mongo-cxx-driver/${build_variant}/${revision}/artifacts/mongo-${build_id}.tar.gz
bucket: mciuploads
extract_to: mongo-cxx-driver
"use WiredTiger storage" :
command: expansions.update
params:
updates:
- key: "orchestration_preset"
value: "--mongo-orchestration-preset=wiredtiger.json"
"use MMAPv1 storage" :
command: expansions.update
params:
updates:
- key: "orchestration_preset"
# Requires mongo-orchestration 0.4
value: "--mongo-orchestration-preset=mmapv1.json"
"use auth" :
command: expansions.update
params:
updates:
- key: "orchestration_preset"
# Requires mongo-orchestration 0.4.2
value: "--mongo-orchestration-preset=auth.json"
"set version 2.2" :
command: expansions.update
params:
updates:
- key: "mongo_url"
value: ${mongo_url_prefix}${mongo_url_subscription_keyword|subscription-}${mongo_url_platform|}2.2.7.${mongo_url_extension|tgz}
"set version 2.4" :
command: expansions.update
params:
updates:
- key: "mongo_url"
value: ${mongo_url_prefix}${mongo_url_subscription_keyword|subscription-}${mongo_url_platform|}2.4.14.${mongo_url_extension|tgz}
"set version 2.6" :
command: expansions.update
params:
updates:
- key: "mongo_url"
value: ${mongo_url_prefix}${mongo_url_enterprise_keyword|enterprise-}${mongo_url_platform|}2.6.12.${mongo_url_extension|tgz}
"set version 3.0" :
command: expansions.update
params:
updates:
- key: "mongo_url"
value: ${mongo_url_prefix}${mongo_url_enterprise_keyword|enterprise-}${mongo_url_platform|}3.0.11.${mongo_url_extension|tgz}
"set version 3.2" :
command: expansions.update
params:
updates:
- key: "mongo_url"
value: ${mongo_url_prefix}${mongo_url_enterprise_keyword|enterprise-}${mongo_url_platform|}3.2.5.${mongo_url_extension|tgz}
"set version latest" :
command: expansions.update
params:
updates:
- key: "mongo_url"
value: ${mongo_url_prefix}${mongo_url_enterprise_keyword|"enterprise-"}${mongo_url_platform|}latest.${mongo_url_extension|tgz}
"run integration tests" :
command: shell.exec
params:
working_dir: "mongo-cxx-driver"
script: |
${start_mongo_orchestration}
${scons|scons} ${scons_flags} ${warning_flags} ${compile_flags} ${toolchain_flags} ${extrapath} ${dllpath} ${cpppath} ${libpath} ${orchestration_preset} integration
"run client tests" :
command: shell.exec
params:
working_dir: "mongo-cxx-driver"
script: |
${start_mongo_orchestration}
${scons|scons} ${scons_flags} ${warning_flags} ${compile_flags} ${toolchain_flags} ${extrapath} ${dllpath} ${cpppath} ${libpath} ${orchestration_preset} examples
pre:
- command: expansions.fetch
params:
keys:
- local_key: "aws_key"
remote_key: "project_aws_key"
- local_key: "aws_secret"
remote_key: "project_aws_secret"
- command: shell.exec
params:
script: |
rm -rf "mongo-cxx-driver"
if [ ! -e /data/db ]; then
mkdir /data/db
elif [ ! -d /data/db ]; then
echo "/data/db already exists and is not a directory!"
exit 1
fi
post:
- command: shell.exec
params:
script: |
cd mongo-cxx-driver && mongo-orchestration stop
${killall_mci|pkill -9 mongo-orchestration; pkill -9 mongod; pkill -9 mongos;}
#######################################
# Tasks #
#######################################
tasks:
- name: lint
commands:
- func: "fetch source"
- command: git.apply_patch
params:
directory: "mongo-cxx-driver"
- command: shell.exec
params:
working_dir: "mongo-cxx-driver"
script: |
set -o errexit
set -o verbose
${scons|scons} ${scons_flags} ${warning_flags} ${compile_flags} ${toolchain_flags} ${extrapath} ${dllpath} ${cpppath} ${libpath} lint
- name: compile
commands:
- func: "fetch source"
- command: git.apply_patch
params:
directory: "mongo-cxx-driver"
- command: shell.exec
params:
working_dir: "mongo-cxx-driver"
script: |
set -o errexit
set -o verbose
${scons|scons} ${scons_flags} ${warning_flags} ${compile_flags} ${parallel_compile_flags} ${toolchain_flags} ${extrapath} ${dllpath} ${cpppath} ${libpath} ${compile_target|all check-install}
- command: shell.exec
params:
working_dir: "mongo-cxx-driver"
script: |
set -o errexit
set -o verbose
tar -czf ../mongo-cxx-driver.tar.gz .
- command: s3.put
params:
aws_key: ${aws_key}
aws_secret: ${aws_secret}
local_file: mongo-cxx-driver.tar.gz
remote_file: mongo-cxx-driver/${build_variant}/${revision}/artifacts/mongo-${build_id}.tar.gz
bucket: mciuploads
permissions: public-read
content_type: ${content_type|application/x-gzip}
- name: "unit-test"
depends_on:
- name: "compile"
commands:
- func: "fetch artifacts"
- command: shell.exec
params:
working_dir: "mongo-cxx-driver"
script: |
set -o verbose
${scons|scons} ${scons_flags} ${warning_flags} ${compile_flags} ${toolchain_flags} ${extrapath} ${dllpath} ${cpppath} ${libpath} unit
- name: "integration-test-2.2"
depends_on:
- name: "compile"
commands:
- func: "set version 2.2"
- func: "fetch artifacts"
- func: "fetch mongodb"
- func: "run integration tests"
- name: "integration-test-2.4"
depends_on:
- name: "compile"
commands:
- func: "set version 2.4"
- func: "fetch artifacts"
- func: "fetch mongodb"
- func: "run integration tests"
- name: "integration-test-2.6"
depends_on:
- name: "compile"
commands:
- func: "set version 2.6"
- func: "fetch artifacts"
- func: "fetch mongodb"
- func: "run integration tests"
- name: "integration-test-3.0"
depends_on:
- name: "compile"
commands:
- func: "set version 3.0"
- func: "fetch artifacts"
- func: "fetch mongodb"
- func: "run integration tests"
- name: "integration-test-3.0-with-WiredTiger"
depends_on:
- name: "compile"
commands:
- func: "set version 3.0"
- func: "use WiredTiger storage"
- func: "fetch artifacts"
- func: "fetch mongodb"
- func: "run integration tests"
- name: "integration-test-3.2"
depends_on:
- name: "compile"
commands:
- func: "set version 3.2"
- func: "fetch artifacts"
- func: "fetch mongodb"
- func: "run integration tests"
- name: "integration-test-3.2-with-MMAPv1"
depends_on:
- name: "compile"
commands:
- func: "set version 3.2"
- func: "use MMAPv1 storage"
- func: "fetch artifacts"
- func: "fetch mongodb"
- func: "run integration tests"
- name: "integration-test-latest"
depends_on:
- name: "compile"
commands:
- func: "set version latest"
- func: "fetch artifacts"
- func: "fetch mongodb"
- func: "run integration tests"
- name: "integration-test-latest-with-auth"
depends_on:
- name: "compile"
commands:
- func: "set version latest"
- func: "fetch artifacts"
- func: "use auth"
- func: "fetch mongodb"
- func: "run integration tests"
- name: "client-test-2.2"
depends_on:
- name: "compile"
commands:
- func: "set version 2.2"
- func: "fetch artifacts"
- func: "fetch mongodb"
- func: "run client tests"
- name: "client-test-2.4"
depends_on:
- name: "compile"
commands:
- func: "set version 2.4"
- func: "fetch artifacts"
- func: "fetch mongodb"
- func: "run client tests"
- name: "client-test-2.6"
depends_on:
- name: "compile"
commands:
- func: "set version 2.6"
- func: "fetch artifacts"
- func: "fetch mongodb"
- func: "run client tests"
- name: "client-test-3.0"
depends_on:
- name: "compile"
commands:
- func: "set version 3.0"
- func: "fetch artifacts"
- func: "fetch mongodb"
- func: "run client tests"
- name: "client-test-3.0-with-WiredTiger"
depends_on:
- name: "compile"
commands:
- func: "set version 3.0"
- func: "use WiredTiger storage"
- func: "fetch artifacts"
- func: "fetch mongodb"
- func: "run client tests"
- name: "client-test-3.2"
depends_on:
- name: "compile"
commands:
- func: "set version 3.0"
- func: "fetch artifacts"
- func: "fetch mongodb"
- func: "run client tests"
- name: "client-test-3.2-with-MMAPv1"
depends_on:
- name: "compile"
commands:
- func: "set version 3.0"
- func: "use MMAPv1 storage"
- func: "fetch artifacts"
- func: "fetch mongodb"
- func: "run client tests"
- name: "client-test-latest"
depends_on:
- name: "compile"
commands:
- func: "set version latest"
- func: "fetch artifacts"
- func: "fetch mongodb"
- func: "run client tests"
#######################################
# Buildvariants #
#######################################
buildvariants:
#######################################
# Linux Buildvariants #
#######################################
## RHEL 5.5
- name: rhel55
display_name: "RHEL 5.5"
expansions:
<<: *scons_flags_64
<<: *parallel_compile_flags_proc
<<: *warning_flags_rhel55
<<: *cpppath_rhel55
<<: *libpath_rhel55_64
<<: *mongo_url_rhel55
<<: *mongo_orchestration_linux
run_on:
- rhel55-test
tasks: *version_tests
## RHEL 5.5 32-bit
- name: rhel55-32-bit
display_name: "RHEL 5.5 32-bit"
expansions:
<<: *scons_flags_32
<<: *parallel_compile_flags_proc
<<: *warning_flags_rhel55
<<: *cpppath_rhel55
<<: *libpath_rhel55_32
<<: *mongo_url_rhel55_32
<<: *mongo_orchestration_linux
run_on:
- rhel55-test
tasks: *latest_tests
## Ubuntu 1404
- name: ubuntu1404
display_name: "Ubuntu1404"
expansions:
<<: *scons_flags_64
<<: *parallel_compile_flags_proc
<<: *mongo_url_ubuntu1404
<<: *mongo_orchestration_linux
run_on:
- ubuntu1404-test
tasks: *storage_engine_tests
## Ubuntu 1404 DEBUG
- name: ubuntu1404-debug
display_name: "Ubuntu1404 dbg"
expansions:
<<: *compile_flags_debug
<<: *parallel_compile_flags_proc
<<: *scons_flags_64
<<: *mongo_url_ubuntu1404
<<: *mongo_orchestration_linux
run_on:
- ubuntu1404-test
tasks: *latest_tests
## Ubuntu 1404 C++11
- name: ubuntu1404-cpp11
display_name: "Ubuntu1404 C++11"
expansions:
<<: *scons_flags_cpp11
<<: *parallel_compile_flags_proc
<<: *mongo_url_ubuntu1404
<<: *mongo_orchestration_linux
run_on:
- ubuntu1404-test
tasks: *latest_tests
#######################################
# OS X Buildvariants #
#######################################
## OS X 10.8
- name: os-x-107
display_name: "OS X 10.7"
expansions:
<<: *mongo_url_osx_1010
<<: *scons_flags_osx_1010
<<: *parallel_compile_flags_sysctl
<<: *extrapath_osx_1010
<<: *mongo_orchestration_osx
run_on:
- osx-1010
tasks: *latest_tests
#######################################
# Windows Buildvariants #
#######################################
## Windows 32-bit (msvc2010)
## dynamic client and RT
- name: windows-32-msvc2010-dyn-dyn
display_name: "Win32(2010) dyn-dyn"
expansions:
<<: *windows_common
<<: *scons_flags_32_windows_dynamic
<<: *parallel_compile_flags_proc
<<: *mongo_url_windows32
<<: *with_msvc2010_32bit
compile_target: driver build-unit
run_on:
- windows-64-vs2010-compile
tasks:
- name: "compile"
- name: "unit-test"
## Windows 64-bit (msvc2010)
## static client and RT
- name: windows-64-msvc2010-static-static
display_name: "Win64(2010) static-static"
expansions:
<<: *windows_common
<<: *scons_flags_64_windows_static
<<: *parallel_compile_flags_proc
<<: *mongo_url_windows64
<<: *with_msvc2010
run_on:
- windows-64-vs2010-compile
tasks: *latest_tests
## Windows 64-bit DEBUG DYNAMIC (msvc2010)
## dynamic client and RT
- name: windows-64-msvc2010-dbg-dyn-dyn
display_name: "Win64(2010) dbg dyn-dyn"
expansions:
<<: *windows_common
<<: *compile_flags_debug
<<: *parallel_compile_flags_proc
<<: *scons_flags_64_windows_dynamic
<<: *mongo_url_windows64
<<: *with_msvc2010
run_on:
- windows-64-vs2010-compile
tasks: *latest_tests
## Windows 64-bit DYNAMIC (msvc2013)
## dynamic client and RT
- name: windows-64-msvc2013-dyn-dyn
display_name: "Win64(2013) dyn-dyn"
expansions:
<<: *windows_common
<<: *parallel_compile_flags_proc
<<: *scons_flags_64_windows_dynamic
<<: *mongo_url_windows64
<<: *with_msvc2013
run_on:
- windows-64-vs2013-compile
tasks: *latest_tests
## Windows 64-bit (msvc2013) DYNAMIC-RT
## static client, dynamic RT
- name: windows-64-msvc-2013-static-dyn
display_name: "Win64(2013) static-dyn"
expansions:
<<: *windows_common
<<: *parallel_compile_flags_proc
<<: *scons_flags_64_windows_dynamic_rt
<<: *mongo_url_windows64
<<: *with_msvc2013
run_on:
- windows-64-vs2013-compile
tasks: *latest_tests
## Windows 64-bit DYNAMIC (msvc2015)
## dynamic client and RT
- name: windows-64-msvc2015-dyn-dyn
display_name: "Win64(2015) dyn-dyn"
expansions:
<<: *windows_common
<<: *parallel_compile_flags_proc
<<: *scons_flags_64_windows_dynamic
<<: *mongo_url_windows64
<<: *with_msvc2015
run_on:
- windows-64-vs2015-compile
tasks: *latest_tests
mongo-cxx-driver-legacy-1.1.2/.travis.yml 0000664 0000000 0000000 00000005303 12732311114 0020272 0 ustar 00root root 0000000 0000000 language: cpp
compiler:
- gcc
- clang
env:
global:
- MONGO_REPO="http://repo.mongodb.com/apt/ubuntu"
- REPO_TYPE="precise/mongodb-enterprise/2.6 multiverse"
- SOURCES_LOC="/etc/apt/sources.list.d/mongodb-enterprise.list"
- KEY_SERVER="hkp://keyserver.ubuntu.com:80"
- MONGOD_PARAMS="--setParameter=enableTestCommands=1"
- MONGOD_OPTS="--port 27999 --httpinterface --dbpath ./data --fork --logpath mongod.log ${MONGOD_PARAMS}"
matrix:
- SANITIZE= DEBUG=
- SANITIZE= DEBUG=--dbg=on
- SANITIZE=--sanitize=address --llvm-symbolizer=llvm-symbolizer-3.4 DEBUG=--dbg=on
- SANITIZE=--sanitize=undefined DEBUG=--dbg=on
matrix:
exclude:
- compiler: gcc
env: SANITIZE=--sanitize=undefined DEBUG=--dbg=on
# Setup required repositories before installation
before_install:
# GCC 4.8.1
- if [ "$CXX" == "g++" ]; then sudo add-apt-repository -y ppa:ubuntu-toolchain-r/test; fi
# Clang 3.4
- if [ "$CXX" == "clang++" ]; then sudo add-apt-repository -y ppa:h-rayflood/llvm; fi
# Boost 1.49
- sudo add-apt-repository -y ppa:jkeiren/ppa
# MongoDB Enterprise Edition 2.6
- sudo apt-key adv --keyserver ${KEY_SERVER} --recv 7F0CEB10
- echo "deb ${MONGO_REPO} ${REPO_TYPE}" | sudo tee ${SOURCES_LOC}
# Update all the repositories
- sudo apt-get update -qq
install:
# GCC 4.8.1
- if [ "$CXX" = "g++" ]; then sudo apt-get install -qq g++-4.8; fi
- if [ "$CXX" = "g++" ]; then export CXX="g++-4.8"; export CC="gcc-4.8"; fi
# Clang 3.4
- if [ "$CXX" == "clang++" ]; then sudo apt-get install --allow-unauthenticated -qq clang-3.4; fi
- if [ "$CXX" == "clang++" ]; then export CXX="clang++-3.4"; export CC="clang-3.4"; fi
# Install Boost 1.49 dependencies via PPA
- sudo apt-get install -qq
libboost1.49-dev
libboost-program-options1.49-dev
libboost-filesystem1.49-dev
libboost-thread1.49-dev
libboost-regex1.49-dev
# Install MongoDB Enterprise and let smoke drive
- sudo apt-get install mongodb-enterprise-server
before_script:
# Set SCONS_FLAGS based on new $CXX and $CC
- $CXX --version
- export GTEST_PARAMS="--gtest-filter=-SASL*"
- export SCONS_CONCURRENCY_FLAG="-j3"
- export SCONS_FLAGS="--mute --ssl --use-sasl-client $GTEST_PARAMS --cxx=$CXX --cc=$CC $DEBUG $SANITIZE"
# Run lint
- scons $SCONS_FLAGS lint
# Build all targets
- scons $SCONS_FLAGS $SCONS_CONCURRENCY_FLAG all
# Install the driver
- scons $SCONS_FLAGS $SCONS_CONCURRENCY_FLAG install
# Check the installation
- scons $SCONS_FLAGS check-install
# Start Mongo Orchestration
- mongod --version
script:
# Test the driver
- scons $SCONS_FLAGS unit
mongo-cxx-driver-legacy-1.1.2/.ycm_extra_conf.py 0000664 0000000 0000000 00000013404 12732311114 0021612 0 ustar 00root root 0000000 0000000 # This file is NOT licensed under the GPLv3, which is the license for the rest
# of YouCompleteMe.
#
# Here's the license text for this file:
#
# This is free and unencumbered software released into the public domain.
#
# Anyone is free to copy, modify, publish, use, compile, sell, or
# distribute this software, either in source code form or as a compiled
# binary, for any purpose, commercial or non-commercial, and by any
# means.
#
# In jurisdictions that recognize copyright laws, the author or authors
# of this software dedicate any and all copyright interest in the
# software to the public domain. We make this dedication for the benefit
# of the public at large and to the detriment of our heirs and
# successors. We intend this dedication to be an overt act of
# relinquishment in perpetuity of all present and future rights to this
# software under copyright law.
#
# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
# EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
# MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
# IN NO EVENT SHALL THE AUTHORS BE LIABLE FOR ANY CLAIM, DAMAGES OR
# OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE,
# ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
# OTHER DEALINGS IN THE SOFTWARE.
#
# For more information, please refer to
import os
import ycm_core
# These are the compilation flags that will be used in case there's no
# compilation database set (by default, one is not set).
# CHANGE THIS LIST OF FLAGS. YES, THIS IS THE DROID YOU HAVE BEEN LOOKING FOR.
flags = [
'-std=c++',
'-x',
'c++',
'-DBOOST_ALL_NO_LIB',
'-D_SCONS',
'-D_DEBUG',
'-DMONGO_EXPOSE_MACROS',
'-DSUPPORT_UTF8',
'-D_FILE_OFFSET_BITS=64',
'-DMONGO_HAVE___THREAD',
'-DMONGO_HAVE_HEADER_UNISTD_H',
'-DMONGO_HAVE_EXECINFO_BACKTRACE',
'-DXP_UNIX',
'-I.',
'-I./src/',
'-I./src/third_party',
'-I./src/third_party/gtest-1.7.0/include',
'-I./build/linux2/normal/',
'-I./build/cached/',
'-I./build/cached/mongo',
'-isystem/Applications/Xcode.app/Contents/Developer/Toolchains/XcodeDefault.xctoolchain/usr/bin/../include/c++/v1',
'-Wall',
'-Wextra',
'-Wc++11-compat',
'-Wno-long-long',
'-Wno-variadic-macros',
'-Wno-unknown-pragmas',
'-Wno-unused-private-field',
'-Wno-unused-parameter',
'-Wsign-compare',
'-Wmismatched-tags',
'-Winvalid-pch',
'-Wnon-virtual-dtor',
'-Woverloaded-virtual',
'-pipe'
]
# Set this to the absolute path to the folder (NOT the file!) containing the
# compile_commands.json file to use that instead of 'flags'. See here for
# more details: http://clang.llvm.org/docs/JSONCompilationDatabase.html
#
# Most projects will NOT need to set this to anything; you can just change the
# 'flags' list of compilation flags. Notice that YCM itself uses that approach.
compilation_database_folder = ''
if os.path.exists(compilation_database_folder):
database = ycm_core.CompilationDatabase(compilation_database_folder)
else:
database = None
SOURCE_EXTENSIONS = ['.cpp', '.cxx', '.cc', '.c', '.m', '.mm']
def DirectoryOfThisScript():
return os.path.dirname(os.path.abspath(__file__))
def MakeRelativePathsInFlagsAbsolute(flags, working_directory):
if not working_directory:
return list(flags)
new_flags = []
make_next_absolute = False
path_flags = ['-isystem', '-I', '-iquote', '--sysroot=']
for flag in flags:
new_flag = flag
if make_next_absolute:
make_next_absolute = False
if not flag.startswith('/'):
new_flag = os.path.join(working_directory, flag)
for path_flag in path_flags:
if flag == path_flag:
make_next_absolute = True
break
if flag.startswith(path_flag):
path = flag[len(path_flag):]
new_flag = path_flag + os.path.join(working_directory, path)
break
if new_flag:
new_flags.append(new_flag)
return new_flags
def IsHeaderFile(filename):
extension = os.path.splitext(filename)[1]
return extension in ['.h', '.hxx', '.hpp', '.hh']
def GetCompilationInfoForFile(filename):
# The compilation_commands.json file generated by CMake does not have
# entries for header files. So we do our best by asking the db for flags
# for a corresponding source file, if any. If one exists, the flags for
# that file should be good enough.
if IsHeaderFile(filename):
basename = os.path.splitext(filename)[0]
for extension in SOURCE_EXTENSIONS:
replacement_file = basename + extension
if os.path.exists(replacement_file):
compilation_info = database.GetCompilationInfoForFile(
replacement_file)
if compilation_info.compiler_flags_:
return compilation_info
return None
return database.GetCompilationInfoForFile(filename)
def FlagsForFile(filename, **kwargs):
if database:
# Bear in mind that compilation_info.compiler_flags_ does NOT return a
# python list, but a "list-like" StringVec object
compilation_info = GetCompilationInfoForFile(filename)
if not compilation_info:
return None
final_flags = MakeRelativePathsInFlagsAbsolute(
compilation_info.compiler_flags_,
compilation_info.compiler_working_dir_)
try:
final_flags.remove('-stdlib=libc++')
except ValueError:
pass
else:
relative_to = DirectoryOfThisScript()
final_flags = MakeRelativePathsInFlagsAbsolute(flags, relative_to)
return {
'flags': final_flags,
'do_cache': True
}
mongo-cxx-driver-legacy-1.1.2/APACHE-2.0.txt 0000664 0000000 0000000 00000026136 12732311114 0020147 0 ustar 00root root 0000000 0000000
Apache License
Version 2.0, January 2004
http://www.apache.org/licenses/
TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
1. Definitions.
"License" shall mean the terms and conditions for use, reproduction,
and distribution as defined by Sections 1 through 9 of this document.
"Licensor" shall mean the copyright owner or entity authorized by
the copyright owner that is granting the License.
"Legal Entity" shall mean the union of the acting entity and all
other entities that control, are controlled by, or are under common
control with that entity. For the purposes of this definition,
"control" means (i) the power, direct or indirect, to cause the
direction or management of such entity, whether by contract or
otherwise, or (ii) ownership of fifty percent (50%) or more of the
outstanding shares, or (iii) beneficial ownership of such entity.
"You" (or "Your") shall mean an individual or Legal Entity
exercising permissions granted by this License.
"Source" form shall mean the preferred form for making modifications,
including but not limited to software source code, documentation
source, and configuration files.
"Object" form shall mean any form resulting from mechanical
transformation or translation of a Source form, including but
not limited to compiled object code, generated documentation,
and conversions to other media types.
"Work" shall mean the work of authorship, whether in Source or
Object form, made available under the License, as indicated by a
copyright notice that is included in or attached to the work
(an example is provided in the Appendix below).
"Derivative Works" shall mean any work, whether in Source or Object
form, that is based on (or derived from) the Work and for which the
editorial revisions, annotations, elaborations, or other modifications
represent, as a whole, an original work of authorship. For the purposes
of this License, Derivative Works shall not include works that remain
separable from, or merely link (or bind by name) to the interfaces of,
the Work and Derivative Works thereof.
"Contribution" shall mean any work of authorship, including
the original version of the Work and any modifications or additions
to that Work or Derivative Works thereof, that is intentionally
submitted to Licensor for inclusion in the Work by the copyright owner
or by an individual or Legal Entity authorized to submit on behalf of
the copyright owner. For the purposes of this definition, "submitted"
means any form of electronic, verbal, or written communication sent
to the Licensor or its representatives, including but not limited to
communication on electronic mailing lists, source code control systems,
and issue tracking systems that are managed by, or on behalf of, the
Licensor for the purpose of discussing and improving the Work, but
excluding communication that is conspicuously marked or otherwise
designated in writing by the copyright owner as "Not a Contribution."
"Contributor" shall mean Licensor and any individual or Legal Entity
on behalf of whom a Contribution has been received by Licensor and
subsequently incorporated within the Work.
2. Grant of Copyright License. Subject to the terms and conditions of
this License, each Contributor hereby grants to You a perpetual,
worldwide, non-exclusive, no-charge, royalty-free, irrevocable
copyright license to reproduce, prepare Derivative Works of,
publicly display, publicly perform, sublicense, and distribute the
Work and such Derivative Works in Source or Object form.
3. Grant of Patent License. Subject to the terms and conditions of
this License, each Contributor hereby grants to You a perpetual,
worldwide, non-exclusive, no-charge, royalty-free, irrevocable
(except as stated in this section) patent license to make, have made,
use, offer to sell, sell, import, and otherwise transfer the Work,
where such license applies only to those patent claims licensable
by such Contributor that are necessarily infringed by their
Contribution(s) alone or by combination of their Contribution(s)
with the Work to which such Contribution(s) was submitted. If You
institute patent litigation against any entity (including a
cross-claim or counterclaim in a lawsuit) alleging that the Work
or a Contribution incorporated within the Work constitutes direct
or contributory patent infringement, then any patent licenses
granted to You under this License for that Work shall terminate
as of the date such litigation is filed.
4. Redistribution. You may reproduce and distribute copies of the
Work or Derivative Works thereof in any medium, with or without
modifications, and in Source or Object form, provided that You
meet the following conditions:
(a) You must give any other recipients of the Work or
Derivative Works a copy of this License; and
(b) You must cause any modified files to carry prominent notices
stating that You changed the files; and
(c) You must retain, in the Source form of any Derivative Works
that You distribute, all copyright, patent, trademark, and
attribution notices from the Source form of the Work,
excluding those notices that do not pertain to any part of
the Derivative Works; and
(d) If the Work includes a "NOTICE" text file as part of its
distribution, then any Derivative Works that You distribute must
include a readable copy of the attribution notices contained
within such NOTICE file, excluding those notices that do not
pertain to any part of the Derivative Works, in at least one
of the following places: within a NOTICE text file distributed
as part of the Derivative Works; within the Source form or
documentation, if provided along with the Derivative Works; or,
within a display generated by the Derivative Works, if and
wherever such third-party notices normally appear. The contents
of the NOTICE file are for informational purposes only and
do not modify the License. You may add Your own attribution
notices within Derivative Works that You distribute, alongside
or as an addendum to the NOTICE text from the Work, provided
that such additional attribution notices cannot be construed
as modifying the License.
You may add Your own copyright statement to Your modifications and
may provide additional or different license terms and conditions
for use, reproduction, or distribution of Your modifications, or
for any such Derivative Works as a whole, provided Your use,
reproduction, and distribution of the Work otherwise complies with
the conditions stated in this License.
5. Submission of Contributions. Unless You explicitly state otherwise,
any Contribution intentionally submitted for inclusion in the Work
by You to the Licensor shall be under the terms and conditions of
this License, without any additional terms or conditions.
Notwithstanding the above, nothing herein shall supersede or modify
the terms of any separate license agreement you may have executed
with Licensor regarding such Contributions.
6. Trademarks. This License does not grant permission to use the trade
names, trademarks, service marks, or product names of the Licensor,
except as required for reasonable and customary use in describing the
origin of the Work and reproducing the content of the NOTICE file.
7. Disclaimer of Warranty. Unless required by applicable law or
agreed to in writing, Licensor provides the Work (and each
Contributor provides its Contributions) on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
implied, including, without limitation, any warranties or conditions
of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
PARTICULAR PURPOSE. You are solely responsible for determining the
appropriateness of using or redistributing the Work and assume any
risks associated with Your exercise of permissions under this License.
8. Limitation of Liability. In no event and under no legal theory,
whether in tort (including negligence), contract, or otherwise,
unless required by applicable law (such as deliberate and grossly
negligent acts) or agreed to in writing, shall any Contributor be
liable to You for damages, including any direct, indirect, special,
incidental, or consequential damages of any character arising as a
result of this License or out of the use or inability to use the
Work (including but not limited to damages for loss of goodwill,
work stoppage, computer failure or malfunction, or any and all
other commercial damages or losses), even if such Contributor
has been advised of the possibility of such damages.
9. Accepting Warranty or Additional Liability. While redistributing
the Work or Derivative Works thereof, You may choose to offer,
and charge a fee for, acceptance of support, warranty, indemnity,
or other liability obligations and/or rights consistent with this
License. However, in accepting such obligations, You may act only
on Your own behalf and on Your sole responsibility, not on behalf
of any other Contributor, and only if You agree to indemnify,
defend, and hold each Contributor harmless for any liability
incurred by, or claims asserted against, such Contributor by reason
of your accepting any such warranty or additional liability.
END OF TERMS AND CONDITIONS
APPENDIX: How to apply the Apache License to your work.
To apply the Apache License to your work, attach the following
boilerplate notice, with the fields enclosed by brackets "[]"
replaced with your own identifying information. (Don't include
the brackets!) The text should be enclosed in the appropriate
comment syntax for the file format. We also recommend that a
file or class name and description of purpose be included on the
same "printed page" as the copyright notice for easier
identification within third-party archives.
Copyright [yyyy] [name of copyright owner]
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
mongo-cxx-driver-legacy-1.1.2/CONTRIBUTING.md 0000664 0000000 0000000 00000007363 12732311114 0020422 0 ustar 00root root 0000000 0000000 ## Contributing to the MongoDB Legacy C++ Driver Project
Pull requests are always welcome, and the MongoDB dev team appreciates any help the community can
give to help make MongoDB better.
For any particular improvement you want to make, you can begin a discussion on the
[MongoDB Developers Forum][dev-forum]. This is the best place discuss your proposed improvement (and its
implementation) with the core development team.
[dev-forum]: https://groups.google.com/forum/?fromgroups#!forum/mongodb-dev "MongoDB Developers Forum"
## Getting Started
- Create a [MongoDB JIRA account][jira-account].
- Create a [Github account][github-account].
- Fork the repository on Github at https://github.com/mongodb/mongo-cxx-driver.
- Check out the 'legacy' branch 'git checkout legacy'
[jira-account]: https://jira.mongodb.org/secure/Signup!default.jspa "MongoDB JIRA Signup"
[github-account]: https://github.com/signup/free "Githup Signup"
## JIRA Tickets
All commits to the C++ driver repository must reference an issue in the [CXX project][cxx-project]
of the MongoDB JIRA. Before creating any new tickets, please search the existing backlog for any open
tickets that represent your change request. If there is not one, then you should create a new
ticket. Tickets specific to the legacy driver should be filed the label [legacy-cxx][legacy-cxx].
For bugs, please clearly describe the issue you are resolving, including the platforms on which
the issue is present and clear steps to reproduce.
For improvements or feature requests, be sure to explain the goal or use case and the approach
your solution will take.
[cxx-project]: https://jira.mongodb.org/browse/CXX
[legacy-cxx]: https://jira.mongodb.org/browse/CXX-69?jql=labels%20%3D%20legacy-cxx
## The Life Cycle of a Pull Request
Here's what happens when you submit a pull request:
- The MongoDB engineering team will review your pull request to make sure you have included a
CXX ticket in your request and signed the contributor agreement.
- You should receive a response from one of our engineers with additional questions about your
contributions.
- If your pull request matches a ticket and is aligned with the Server Roadmap, it will get
triaged and reviewed by the C++ driver and Kernel teams.
- Pull requests that have been reviewed and approved will be signed off and merged into a
development branch and the associated JIRA CXX issue will be resolved with an expected
fixVersion.
## Style Guide
All commits to the legacy branch must follow the [kernel development rules][kernel-dev-rules].
In particular, all code must follow the MongoDB [kernel code style guidelines][kernel-style-guide].
For anything not covered in this document you should default to the [Google CPP Style Guide][google-style-guide].
Your commit message should also be prefaced with the relevant JIRA ticket, e.g. "CXX-XXX Fixed a bug in aggregation".
[kernel-dev-rules]: http://dochub.mongodb.org/core/kernelcodedevelopmentrules
[kernel-style-guide]: http://dochub.mongodb.org/core/kernelcodestyle
[google-style-guide]: http://google-styleguide.googlecode.com/svn/trunk/cppguide.xml
## Testing
Every non-trivial change to the code base should be accompanied by a relevant addition to or
modification of the test suite. If you don't believe this is necessary, please add an explanation
in the JIRA ticket why no such changes are either needed or possible.
All changes must also pass the full test suite (including your test additions/changes) on your
local machine before you open a pull request.
## Contributor Agreement
A patch will only be considered for merging into the upstream codebase after you have signed the
[contributor agreement][contributor-agreement].
[contributor-agreement]: http://www.mongodb.com/contributor "MongoDB Contributor Agreement"
mongo-cxx-driver-legacy-1.1.2/README.md 0000664 0000000 0000000 00000005516 12732311114 0017446 0 ustar 00root root 0000000 0000000 # MongoDB C++ Driver [](https://travis-ci.org/mongodb/mongo-cxx-driver)
Welcome to the MongoDB C++ Driver!
Please see our [wiki page](https://github.com/mongodb/mongo-cxx-driver/wiki/Download-and-Compile-the-Legacy-Driver) for information about building, testing, and using the driver.
Version [1.1.1](https://github.com/mongodb/mongo-cxx-driver/releases/tag/legacy-1.1.1) of the
C++ legacy driver has been released. Please report any bugs or issues in the C++
[JIRA project](http://jira.mongodb.org/browse/CXX).
You should only use the "legacy" branch if you had been previously using
the "26compat" branch (or the driver inside of the server source) and want to
benefit from incremental improvements while having the same overall
API.
> **Note:** As of MongoDB 2.6.0-rc1, it is no longer possible to build the driver from the server sources: this repository is the only approved source for C++ driver builds.
## Repository Overview
| Branch | Stability | Development | Purpose |
| -------- | ------------| ----------------- | ----------------------------------------------------- |
| master | Stable | Stable Evolution | New C++11 driver |
| legacy | Stable | Stable Evolution | Primary stable C++ driver release |
| 26compat | Stable | Maintenance Only | Drop in replacement for users of existing 2.6 era C++ driver |
Please note that stable branches are only production quality at stable release tags. Other
commits or pre-release tags on a stable branch represent ongoing development work towards the
next stable release, and therefore may be unstable.
## Components
- `libmongoclient.[so|dylib|dll]` - The shared mongoclient library (but see notes)
- `libmongoclient.a` - The static mongoclient library
## Building and Usage
- [Download and Compile](https://github.com/mongodb/mongo-cxx-driver/wiki/Download%20and%20Compile)
- [Tutorial](https://github.com/mongodb/mongo-cxx-driver/wiki/Tutorial)
## Bugs and Issues
See http://jira.mongodb.org/browse/CXX
## Notes
Use of the shared library is experimental on windows and is currently
discouraged. This is primarily due to the complexity of ensuring a matching
implementation of STL types between library and consumer code. This problem
is unique to windows, as the consistent use of system libraries largely
mitigates this danger.
## Documentation
http://docs.mongodb.org/ecosystem/drivers/cpp/
## Mailing Lists and IRC
http://dochub.mongodb.org/core/community
## License
The source files in this repository are made available under the terms of the
Apache License, version 2.0.
mongo-cxx-driver-legacy-1.1.2/SConstruct 0000664 0000000 0000000 00000216640 12732311114 0020223 0 ustar 00root root 0000000 0000000 # -*- mode: python; -*-
import copy
import datetime
import imp
import os
import platform as py_platform
import re
import shlex
import shutil
import stat
import sys
import textwrap
import types
import urllib
import urllib2
import buildscripts.utils
import buildscripts.docs
import buildscripts.lint
import buildscripts.clang_format
EnsureSConsVersion( 1, 1, 0 )
def versiontuple(v):
return tuple(map(int, (v.split("."))))
# --- platform identification ---
#
# This needs to precede the options section so that we can only offer some options on certain
# platforms.
platform = os.sys.platform
nix = False
linux = False
darwin = False
windows = False
freebsd = False
openbsd = False
solaris = False
if "darwin" == platform:
darwin = True
platform = "osx" # prettier than darwin
elif platform.startswith("linux"):
linux = True
platform = "linux"
elif "sunos5" == platform:
solaris = True
elif platform.startswith( "freebsd" ):
freebsd = True
elif platform.startswith( "openbsd" ):
openbsd = True
elif "win32" == platform:
windows = True
else:
print( "No special config for [" + platform + "] which probably means it won't work" )
nix = not windows
# --- options ----
use_clang = False
options = {}
def add_option( name, help, nargs, contributesToVariantDir,
dest=None, default = None, type="string", choices=None, metavar=None, const=None ):
if dest is None:
dest = name
if type == 'choice' and not metavar:
metavar = '[' + '|'.join(choices) + ']'
AddOption( "--" + name ,
dest=dest,
type=type,
nargs=nargs,
action="store",
choices=choices,
default=default,
metavar=metavar,
const=const,
help=help )
options[name] = { "help" : help ,
"nargs" : nargs ,
"contributesToVariantDir" : contributesToVariantDir ,
"dest" : dest,
"default": default }
def get_option( name ):
return GetOption( name )
def has_option( name ):
x = get_option( name )
if x is None:
return False
if x == False:
return False
if x == "":
return False
return True
def get_variant_dir():
build_dir = get_option('build-dir').rstrip('/')
if has_option('variant-dir'):
return (build_dir + '/' + get_option('variant-dir')).rstrip('/')
substitute = lambda x: re.sub( "[:,\\\\/]" , "_" , x )
a = []
for name in options:
o = options[name]
if not has_option( o["dest"] ):
continue
if not o["contributesToVariantDir"]:
continue
if get_option(o["dest"]) == o["default"]:
continue
if o["nargs"] == 0:
a.append( name )
else:
x = substitute( get_option( name ) )
a.append( name + "_" + x )
extras = []
if has_option("extra-variant-dirs"):
extras = [substitute(x) for x in get_option( 'extra-variant-dirs' ).split( ',' )]
if has_option("add-branch-to-variant-dir"):
extras += ["branch_" + substitute( buildscripts.utils.getGitBranch() )]
if has_option('cache'):
s = "cached"
s += "/".join(extras) + "/"
else:
s = "${PYSYSPLATFORM}/"
a += extras
if len(a) > 0:
a.sort()
s += "/".join( a ) + "/"
else:
s += "normal/"
return (build_dir + '/' + s).rstrip('/')
# build output
add_option( "mute" , "do not display commandlines for compiling and linking, to reduce screen noise", 0, False )
# installation/packaging
add_option( "prefix" , "installation prefix" , 1 , False, default='$BUILD_DIR/install' )
add_option( "extra-variant-dirs", "extra variant dir components, separated by commas", 1, False)
add_option( "add-branch-to-variant-dir", "add current git branch to the variant dir", 0, False )
add_option( "build-dir", "build output directory", 1, False, default='#build')
add_option( "variant-dir", "override variant subdirectory", 1, False )
add_option( "sharedclient", "build a libmongoclient.so/.dll" , 0 , False )
# linking options
add_option( "release" , "release build" , 0 , True )
add_option( "lto", "enable link time optimizations (experimental, except with MSVC)" , 0 , True )
add_option( "dynamic-windows", "dynamically link on Windows", 0, True)
add_option( "dynamic-boost", "dynamically link boost libraries on Windows", "?", True,
type="choice", choices=["on", "off", "auto"], default="auto", const="on" )
add_option( "disable-declspec-thread", "don't use __declspec(thread) on Windows", 0, True)
# base compile flags
add_option( "64" , "whether to force 64 bit" , 0 , True , "force64" )
add_option( "32" , "whether to force 32 bit" , 0 , True , "force32" )
add_option( "endian" , "endianness of target platform" , 1 , False , "endian",
type="choice", choices=["big", "little", "auto"], default="auto" )
add_option( "cxx", "compiler to use" , 1 , True )
add_option( "cc", "compiler to use for c" , 1 , True )
add_option( "cc-use-shell-environment", "use $CC from shell for C compiler" , 0 , False )
add_option( "cxx-use-shell-environment", "use $CXX from shell for C++ compiler" , 0 , False )
add_option( "c++11", "enable c++11 support (experimental)", "?", True,
type="choice", choices=["on", "off", "auto"], const="on", default="off" )
add_option( "cpppath", "Include path if you have headers in a nonstandard directory" , 1 , False )
add_option( "libpath", "Library path if you have libraries in a nonstandard directory" , 1 , False )
add_option( "extrapath", "comma separated list of add'l paths (--extrapath /opt/foo/,/foo) static linking" , 1 , False )
add_option( "extralib", "comma separated list of libraries (--extralib js_static,readline" , 1 , False )
add_option("runtime-library-search-path",
"comma separated list of dirs to append to PATH to find dynamic libs at runtime",
1, False)
add_option( "ssl" , "Enable SSL" , 0 , True )
# library choices
add_option( "libc++", "use libc++ (experimental, requires clang)", 0, True )
# new style debug and optimize flags
add_option( "dbg", "Enable runtime debugging checks", "?", True, "dbg",
type="choice", choices=["on", "off"], const="on" )
add_option( "opt", "Enable compile-time optimization", "?", True, "opt",
type="choice", choices=["on", "off"], const="on" )
add_option( "sanitize", "enable selected sanitizers", 1, True, metavar="san1,san2,...sanN" )
add_option( "llvm-symbolizer", "name of (or path to) the LLVM symbolizer", 1, False, default="llvm-symbolizer" )
add_option( "gcov" , "compile with flags for gcov" , 0 , True )
add_option("use-sasl-client", "Support SASL authentication in the client library", 0, False)
add_option('build-fast-and-loose', "NEVER for production builds", 0, False)
add_option( "boost-lib-search-suffixes",
"Comma delimited sequence of boost library suffixes to search",
1, False )
add_option('disable-warnings-as-errors', "Don't add -Werror to compiler command line", 0, False)
add_option('propagate-shell-environment',
"Pass shell environment to sub-processes (NEVER for production builds)",
0, False)
add_option('gtest-filter', "Pass argument as filter to gtest", 1, False)
add_option('mongo-orchestration-preset',
"Pass argument to mongo-orchestration as the configuration preset",
1, False, default='basic.json' )
add_option('mongo-orchestration-host',
"Host mongo-orchestration is running on",
1, False, default='localhost' )
add_option('mongo-orchestration-port',
"Host mongo-orchestration is running on",
1, False, default='8889' )
add_option('variables-help',
"Print the help text for SCons variables", 0, False)
if darwin:
add_option("osx-version-min", "minimum OS X version to support", 1, True)
elif windows:
win_version_min_choices = {
'xpsp3' : ('0501', '0300'),
'ws03sp2' : ('0502', '0200'),
'vista' : ('0600', '0000'),
'ws08r2' : ('0601', '0000'),
'win7' : ('0601', '0000'),
'win8' : ('0602', '0000'),
}
add_option("win-version-min", "minimum Windows version to support", 1, True,
type = 'choice', default = None,
choices = win_version_min_choices.keys())
# Someday get rid of --32 and --64 for windows and use these with a --msvc-target-arch flag
# that mirrors msvc-host-arch.
msvc_arch_choices = ['x86', 'i386', 'amd64', 'emt64', 'x86_64', 'ia64']
add_option("msvc-host-arch", "host architecture for ms toolchain", 1, True,
type="choice", choices=msvc_arch_choices)
add_option("msvc-script",
"msvc toolchain setup script, pass no argument to suppress script execution",
1, True)
add_option("msvc-version", "select msvc version", 1, True)
add_option('cache',
"Use an object cache rather than a per-build variant directory (experimental)",
0, False)
add_option('cache-dir',
"Specify the directory to use for caching objects if --cache is in use",
1, False, default="$BUILD_DIR/scons/cache")
variable_parse_mode_choices=['auto', 'posix', 'other']
add_option('variable-parse-mode',
"Select which parsing mode is used to interpret command line variables",
1, False,
type='choice', default=variable_parse_mode_choices[0],
choices=variable_parse_mode_choices)
# Setup the command-line variables
def variable_shlex_converter(val):
parse_mode = get_option('variable-parse-mode')
if parse_mode == 'auto':
parse_mode = 'other' if windows else 'posix'
return shlex.split(val, posix=(parse_mode == 'posix'))
env_vars = Variables()
env_vars.Add('ARFLAGS',
help='Sets flags for the archiver',
converter=variable_shlex_converter)
env_vars.Add('CCFLAGS',
help='Sets flags for the C and C++ compiler',
converter=variable_shlex_converter)
env_vars.Add('CFLAGS',
help='Sets flags for the C compiler',
converter=variable_shlex_converter)
env_vars.Add('CPPDEFINES',
help='Sets pre-processor definitions for C and C++',
converter=variable_shlex_converter)
env_vars.Add('CPPPATH',
help='Adds paths to the preprocessor search path',
converter=variable_shlex_converter)
env_vars.Add('CXXFLAGS',
help='Sets flags for the C++ compiler',
converter=variable_shlex_converter)
env_vars.Add('LIBPATH',
help='Adds paths to the linker search path',
converter=variable_shlex_converter)
env_vars.Add('LIBS',
help='Adds extra libraries to link against',
converter=variable_shlex_converter)
env_vars.Add('LINKFLAGS',
help='Sets flags for the linker',
converter=variable_shlex_converter)
env_vars.Add('RPATH',
help='Set the RPATH for dynamic libraries and executables',
converter=variable_shlex_converter)
env_vars.Add('SHCCFLAGS',
help='Sets flags for the C and C++ compiler when building shared libraries',
converter=variable_shlex_converter)
env_vars.Add('SHCFLAGS',
help='Sets flags for the C compiler when building shared libraries',
converter=variable_shlex_converter)
env_vars.Add('SHCXXFLAGS',
help='Sets flags for the C++ compiler when building shared libraries',
converter=variable_shlex_converter)
env_vars.Add('SHLINKFLAGS',
help='Sets flags for the linker when building shared libraries',
converter=variable_shlex_converter)
# don't run configure if user calls --help
if GetOption('help'):
Return()
# --- environment setup ---
# If the user isn't using the # to indicate top-of-tree or $ to expand a variable, forbid
# relative paths. Relative paths don't really work as expected, because they end up relative to
# the top level SConstruct, not the invokers CWD. We could in theory fix this with
# GetLaunchDir, but that seems a step too far.
buildDir = get_option('build-dir').rstrip('/')
if buildDir[0] not in ['$', '#']:
if not os.path.isabs(buildDir):
print("Do not use relative paths with --build-dir")
Exit(1)
cacheDir = get_option('cache-dir').rstrip('/')
if cacheDir[0] not in ['$', '#']:
if not os.path.isabs(cacheDir):
print("Do not use relative paths with --cache-dir")
Exit(1)
installDir = get_option('prefix').rstrip('/')
if installDir[0] not in ['$', '#']:
if not os.path.isabs(installDir):
print("Do not use relative paths with --prefix")
Exit(1)
sconsDataDir = Dir(buildDir).Dir('scons')
SConsignFile(str(sconsDataDir.File('sconsign')))
def printLocalInfo():
import sys, SCons
print( "scons version: " + SCons.__version__ )
print( "python version: " + " ".join( [ `i` for i in sys.version_info ] ) )
printLocalInfo()
boostLibs = [ "regex", "thread" , "system" ]
linux64 = False
force32 = has_option( "force32" )
force64 = has_option( "force64" )
if not force64 and not force32 and os.getcwd().endswith( "mongo-64" ):
force64 = True
print( "*** assuming you want a 64-bit build b/c of directory *** " )
msarch = None
if force32:
msarch = "x86"
elif force64:
msarch = "amd64"
releaseBuild = has_option("release")
# validate debug and optimization options
dbg_opt_mapping = {
# --dbg, --opt : dbg opt
( None, None ) : ( False, True ),
( None, "on" ) : ( False, True ),
( None, "off" ) : ( False, False ),
( "on", None ) : ( True, False ), # special case interaction
( "on", "on" ) : ( True, True ),
( "on", "off" ) : ( True, False ),
( "off", None ) : ( False, True ),
( "off", "on" ) : ( False, True ),
( "off", "off" ) : ( False, False ),
}
debugBuild, optBuild = dbg_opt_mapping[(get_option('dbg'), get_option('opt'))]
if releaseBuild and (debugBuild or not optBuild):
print("Error: A --release build may not have debugging, and must have optimization")
Exit(1)
mongoclientVersion = "1.1.2"
# We don't keep the -pre in the user testable version identifiers, because
# nobody should be conditioning on the pre-release status.
mongoclientVersionComponents = re.split(r'\.|-rc', mongoclientVersion.partition('-pre')[0])
if len(mongoclientVersionComponents) not in (3,4):
print("Error: client version most be of the form w.x.y[-rcz][-string]")
Exit(1)
# The Scons 'default' tool enables a lot of tools that we don't actually need to enable.
# On platforms like Solaris, it actually does the wrong thing by enabling the sunstudio
# toolchain first. As such it is simpler and more efficient to manually load the precise
# set of tools we need for each platform.
# If we aren't on a platform where we know the minimal set of tools, we fallback to loading
# the 'default' tool.
def decide_platform_tools():
if windows:
# we only support MS toolchain on windows
return ['msvc', 'mslink', 'mslib']
elif linux:
return ['gcc', 'g++', 'gnulink', 'ar']
elif solaris:
return ['gcc', 'g++', 'gnulink', 'ar']
elif darwin:
return ['gcc', 'g++', 'applelink', 'ar']
else:
return ["default"]
tools = decide_platform_tools() + ["unittest", "integration_test", "textfile"]
# We defer building the env until we have determined whether we want certain values. Some values
# in the env actually have semantics for 'None' that differ from being absent, so it is better
# to build it up via a dict, and then construct the Environment in one shot with kwargs.
envDict = dict(BUILD_DIR=buildDir,
VARIANT_DIR=get_variant_dir(),
EXTRAPATH=get_option("extrapath"),
PYTHON=File(buildscripts.utils.find_python()),
tools=tools,
PYSYSPLATFORM=os.sys.platform,
CONFIGUREDIR=sconsDataDir.Dir('sconf_temp'),
CONFIGURELOG=sconsDataDir.File('config.log'),
MONGOCLIENT_VERSION=mongoclientVersion,
MONGOCLIENT_VERSION_MAJOR=mongoclientVersionComponents[0],
MONGOCLIENT_VERSION_MINOR=mongoclientVersionComponents[1],
MONGOCLIENT_VERSION_PATCH=mongoclientVersionComponents[2],
INSTALL_DIR=installDir,
)
if windows:
if msarch:
envDict['TARGET_ARCH'] = msarch
# We can't set this to None without disturbing the autodetection,
# so only set it conditionally.
if has_option('msvc-host-arch'):
envDict['HOST_ARCH'] = get_option('msvc-host-arch')
msvc_version = get_option('msvc-version')
msvc_script = get_option('msvc-script')
if msvc_version:
if msvc_script:
print("Passing --msvc-version with --msvc-script is not meaningful")
Exit(1)
envDict['MSVC_VERSION'] = msvc_version
# The python None value is meaningful to MSVC_USE_SCRIPT; we want to interpret
# --msvc-script= with no argument as meaning 'None', so check explicitly against None so
# that '' is not interpreted as false.
if msvc_script is not None:
if has_option('msvc-host-arch'):
print("Passing --msvc-host-arch with --msvc-script is not meaningful")
Exit(1)
if msarch:
print("Passing --32 or --64 with --msvc-script is not meaningful")
Exit(1)
if msvc_script == "":
msvc_script = None
envDict['MSVC_USE_SCRIPT'] = msvc_script
env = Environment(variables=env_vars, **envDict)
del envDict
def fatal_error(env, msg, *args):
print msg.format(*args)
Exit(1)
def conf_error(env, msg, *args):
print msg.format(*args)
print "See {0} for details".format(env['CONFIGURELOG'].abspath)
Exit(1)
env.AddMethod(fatal_error, 'FatalError')
env.AddMethod(conf_error, 'ConfError')
if has_option('variables-help'):
print env_vars.GenerateHelpText(env)
Exit(0)
unknown_vars = env_vars.UnknownVariables()
if unknown_vars:
env.FatalError("Unknown variables specified: {0}", ", ".join(unknown_vars.keys()))
# Add any scons options that conflict with scons variables here.
# The first item in each tuple is the option name and the second
# is the variable name
variable_conflicts = [
('libpath', 'LIBPATH'),
('cpppath', 'CPPPATH'),
('extrapath', 'CPPPATH'),
('extrapath', 'LIBPATH'),
('extralib', 'LIBS')
]
for (opt_name, var_name) in variable_conflicts:
if has_option(opt_name) and var_name in env:
env.FatalError("Both option \"--{0}\" and variable {1} were specified", opt_name, var_name)
if has_option("cache"):
EnsureSConsVersion( 2, 3, 0 )
if has_option("release"):
env.FatalError(
"Using the experimental --cache option is not permitted for --release builds")
if has_option("gcov"):
env.FatalError("Mixing --cache and --gcov doesn't work correctly yet. See SERVER-11084")
env.CacheDir(str(env.Dir(cacheDir)))
if has_option("propagate-shell-environment"):
env['ENV'] = dict(os.environ);
if has_option('runtime-library-search-path'):
libs = get_option('runtime-library-search-path').split(',')
envVar = None
if windows:
envVar = 'PATH'
elif darwin:
envVar = 'DYLD_LIBRARY_PATH'
else:
envVar = 'LD_LIBRARY_PATH'
for lib in libs:
env.AppendENVPath(envVar, env.Dir(lib), delete_existing=0)
# Ignore fast-and-loose option if the scons cache is enabled (see SERVER-19088)
if has_option('build-fast-and-loose') and not has_option('cache'):
# See http://www.scons.org/wiki/GoFastButton for details
env.Decider('MD5-timestamp')
env.SetOption('max_drift', 1)
env.SourceCode('.', None)
if has_option('mute'):
env.Append( CCCOMSTR = "Compiling $TARGET" )
env.Append( CXXCOMSTR = env["CCCOMSTR"] )
env.Append( SHCCCOMSTR = "Compiling $TARGET" )
env.Append( SHCXXCOMSTR = env["SHCCCOMSTR"] )
env.Append( LINKCOMSTR = "Linking $TARGET" )
env.Append( SHLINKCOMSTR = env["LINKCOMSTR"] )
env.Append( ARCOMSTR = "Generating library $TARGET" )
endian = get_option( "endian" )
if endian == "auto":
endian = sys.byteorder
if endian == "little":
env["MONGO_BYTE_ORDER"] = "1234"
elif endian == "big":
env["MONGO_BYTE_ORDER"] = "4321"
if env['PYSYSPLATFORM'] == 'linux3':
env['PYSYSPLATFORM'] = 'linux2'
if 'freebsd' in env['PYSYSPLATFORM']:
env['PYSYSPLATFORM'] = 'freebsd'
if os.sys.platform == 'win32':
env['OS_FAMILY'] = 'win'
else:
env['OS_FAMILY'] = 'posix'
if has_option( "cc-use-shell-environment" ) and has_option( "cc" ):
env.FatalError("Cannot specify both --cc-use-shell-environment and --cc")
elif has_option( "cxx-use-shell-environment" ) and has_option( "cxx" ):
env.FatalError("Cannot specify both --cxx-use-shell-environment and --cxx")
if has_option( "gtest-filter" ):
env["gtest_filter"] = get_option('gtest-filter')
if has_option( "cxx-use-shell-environment" ):
env["CXX"] = os.getenv("CXX");
env["CC"] = env["CXX"]
if has_option( "cc-use-shell-environment" ):
env["CC"] = os.getenv("CC");
if has_option( "cxx" ):
if not has_option( "cc" ):
env.FatalError("Must specify C compiler when specifying C++ compiler")
env["CXX"] = get_option( "cxx" )
if has_option( "cc" ):
if not has_option( "cxx" ):
env.FatalError("Must specify C++ compiler when specifying C compiler")
env["CC"] = get_option( "cc" )
if has_option( "libpath" ):
env["LIBPATH"] = [get_option( "libpath" )]
if has_option( "cpppath" ):
env["CPPPATH"] = [get_option( "cpppath" )]
env.Prepend(
CPPDEFINES=[
"MONGO_EXPOSE_MACROS" ,
],
CPPPATH=[
'$VARIANT_DIR',
'$VARIANT_DIR/mongo'
]
)
extraLibPlaces = []
env['EXTRACPPPATH'] = []
env['EXTRALIBPATH'] = []
def addExtraLibs( s ):
for x in s.split(","):
env.Append( EXTRACPPPATH=[ x + "/include" ] )
env.Append( EXTRALIBPATH=[ x + "/lib" ] )
extraLibPlaces.append( x + "/lib" )
if has_option( "extrapath" ):
addExtraLibs( GetOption( "extrapath" ) )
if has_option( "extralib" ):
for x in GetOption( "extralib" ).split( "," ):
env.Append( LIBS=[ x ] )
# ---- other build setup -----
if "uname" in dir(os):
processor = os.uname()[4]
else:
processor = "i386"
if force32:
processor = "i386"
if force64:
processor = "x86_64"
env['PROCESSOR_ARCHITECTURE'] = processor
nixLibPrefix = "lib"
if darwin:
pass
elif linux:
env.Append( LIBS=['m'] )
if os.uname()[4] == "x86_64" and not force32:
linux64 = True
nixLibPrefix = "lib64"
env.Append( EXTRALIBPATH=["/usr/lib64" , "/lib64" ] )
env.Append( LIBS=["pthread"] )
force64 = False
if force32:
env.Append( EXTRALIBPATH=["/usr/lib32"] )
elif solaris:
env.Append( CPPDEFINES=[ "__sunos__" ] )
env.Append( LIBS=["socket","resolv"] )
elif freebsd:
env.Append( LIBS=[ "kvm" ] )
env.Append( EXTRACPPPATH=[ "/usr/local/include" ] )
env.Append( EXTRALIBPATH=[ "/usr/local/lib" ] )
env.Append( CPPDEFINES=[ "__freebsd__" ] )
env.Append( CCFLAGS=[ "-fno-omit-frame-pointer" ] )
elif openbsd:
env.Append( EXTRACPPPATH=[ "/usr/local/include" ] )
env.Append( EXTRALIBPATH=[ "/usr/local/lib" ] )
env.Append( CPPDEFINES=[ "__openbsd__" ] )
elif windows:
dynamicCRT = has_option("dynamic-windows")
# Unless otherwise specified, link boost in the same manner as the CRT.
dynamicBoost = get_option("dynamic-boost")
if dynamicBoost == "auto":
dynamicBoost = "on" if dynamicCRT else "off"
if dynamicBoost == "on":
env.Append( CPPDEFINES=[ "BOOST_ALL_DYN_LINK" ] )
if has_option("sharedclient") and not dynamicCRT:
env.FatalError("The shared client must be built with the dynamic runtime library")
# If tools configuration fails to set up 'cl' in the path, fall back to importing the whole
# shell environment and hope for the best. This will work, for instance, if you have loaded
# an SDK shell.
for pathdir in env['ENV']['PATH'].split(os.pathsep):
if os.path.exists(os.path.join(pathdir, 'cl.exe')):
break
else:
print("NOTE: Tool configuration did not find 'cl' compiler, falling back to os environment")
env['ENV'] = dict(os.environ)
env.Append( CPPDEFINES=[ "_UNICODE" ] )
env.Append( CPPDEFINES=[ "UNICODE" ] )
env.Append( CPPDEFINES=[ "NOMINMAX" ] )
# /EHsc exception handling style for visual studio
# /W3 warning level
env.Append(CCFLAGS=["/EHsc","/W3"])
# some warnings we don't like:
env.Append(CCFLAGS=[
# 'conversion' conversion from 'type1' to 'type2', possible loss of data
# An integer type is converted to a smaller integer type.
"/wd4244",
# 'identifier' : class 'type' needs to have dll-interface to be used by clients of class 'type2'
# Typically some STL type isn't dllexport adorned, and we can't do anything about that
"/wd4251",
# 'var' : conversion from 'size_t' to 'type', possible loss of data When compiling with
# /Wp64, or when compiling on a 64-bit operating system, type is 32 bits but size_t is
# 64 bits when compiling for 64-bit targets. To fix this warning, use size_t instead of
# a type
"/wd4267",
# non - DLL-interface classkey 'identifier' used as base for DLL-interface classkey 'identifier'
# Typically some base like noncopyable isn't dllexport adorned; nothing we can do
"/wd4275",
# C++ exception specification ignored except to indicate a function is not
# __declspec(nothrow A function is declared using exception specification, which Visual
# C++ accepts but does not implement
"/wd4290",
# 'this' : used in base member initializer list
# The this pointer is valid only within nonstatic member functions. It cannot be
# used in the initializer list for a base class.
"/wd4355",
# 'type' : forcing value to bool 'true' or 'false' (performance warning)
# This warning is generated when a value that is not bool is assigned or coerced
# into type bool.
"/wd4800",
# unknown pragma -- added so that we can specify unknown pragmas for other compilers
"/wd4068",
# On extremely old versions of MSVC (pre 2k5), default constructing an array member in a
# constructor's initialization list would not zero the array members "in some cases".
# since we don't target MSVC versions that old, this warning is safe to ignore.
"/wd4351",
])
if not has_option("disable-warnings-as-errors"):
env.Append(
CCFLAGS=["/WX"],
LINKFLAGS=["/WX"],
)
env.Append( CPPDEFINES=[
"_CONSOLE",
"_CRT_NONSTDC_NO_WARNINGS",
"_CRT_SECURE_NO_WARNINGS",
"_CRT_SECURE_NO_DEPRECATE",
"_SCL_SECURE_NO_WARNINGS",
"_SCL_SECURE_NO_DEPRECATE",
] )
# this would be for pre-compiled headers, could play with it later
#env.Append( CCFLAGS=['/Yu"pch.h"'] )
# docs say don't use /FD from command line (minimal rebuild)
# /Gy function level linking (implicit when using /Z7)
# /Z7 debug info goes into each individual .obj file -- no .pdb created
env.Append( CCFLAGS= ["/Z7", "/errorReport:none"] )
# /DEBUG will tell the linker to create a .pdb file
# which WinDbg and Visual Studio will use to resolve
# symbols if you want to debug a release-mode image.
# Note that this means we can't do parallel links in the build.
#
# Please also note that this has nothing to do with _DEBUG or optimization.
env.Append( LINKFLAGS=["/DEBUG"] )
# /MD: use the multithreaded, DLL version of the run-time library (MSVCRT.lib/MSVCR###.DLL)
# /MT: use the multithreaded, static version of the run-time library (LIBCMT.lib)
# /MDd: Defines _DEBUG, _MT, _DLL, and uses MSVCRTD.lib/MSVCRD###.DLL
# /MTd: Defines _DEBUG, _MT, and causes your application to use the
# debug multithread version of the run-time library (LIBCMTD.lib)
winRuntimeLibMap = {
#dyn #dbg
( False, False ) : "/MT",
( False, True ) : "/MTd",
( True, False ) : "/MD",
( True, True ) : "/MDd",
}
env.Append(CCFLAGS=[winRuntimeLibMap[(dynamicCRT, debugBuild)]])
# With VS 2012 and later we need to specify 5.01 as the target console
# so that our 32-bit builds run on Windows XP
# See https://software.intel.com/en-us/articles/linking-applications-using-visual-studio-2012-to-run-on-windows-xp
#
if msarch == "x86":
env.Append( LINKFLAGS=["/SUBSYSTEM:CONSOLE,5.01"])
if optBuild:
# /O2: optimize for speed (as opposed to size)
# /Oy-: disable frame pointer optimization (overrides /O2, only affects 32-bit)
# /INCREMENTAL: NO - disable incremental link - avoid the level of indirection for function
# calls
env.Append( CCFLAGS=["/O2", "/Oy-"] )
env.Append( LINKFLAGS=["/INCREMENTAL:NO"])
else:
env.Append( CCFLAGS=["/Od"] )
if debugBuild and not optBuild:
# /RTC1: - Enable Stack Frame Run-Time Error Checking; Reports when a variable is used
# without having been initialized (implies /Od: no optimizations)
env.Append( CCFLAGS=["/RTC1"] )
env.Append(LIBS=[ 'ws2_32.lib', 'DbgHelp.lib' ])
if nix:
# -Winvalid-pch Warn if a precompiled header (see Precompiled Headers) is found in the search path but can't be used.
env.Append( CCFLAGS=["-fPIC",
"-ggdb",
"-pthread",
"-Wall",
"-Wsign-compare",
"-Wno-unknown-pragmas",
"-Winvalid-pch"] )
# env.Append( " -Wconversion" ) TODO: this doesn't really work yet
if linux or darwin:
env.Append( CCFLAGS=["-pipe"] )
if not has_option("disable-warnings-as-errors"):
env.Append( CCFLAGS=["-Werror"] )
env.Append( CPPDEFINES=["_FILE_OFFSET_BITS=64"] )
env.Append( CXXFLAGS=["-Wnon-virtual-dtor", "-Woverloaded-virtual"] )
env.Append( LINKFLAGS=["-fPIC"] )
# SERVER-9761: Ensure early detection of missing symbols in dependent libraries at program
# startup.
#
# TODO: Is it necessary to add to both linkflags and shlinkflags, or are LINKFLAGS
# propagated to SHLINKFLAGS?
if darwin:
env.Append( LINKFLAGS=["-Wl,-bind_at_load"] )
env.Append( SHLINKFLAGS=["-Wl,-bind_at_load"] )
else:
env.Append( LINKFLAGS=["-Wl,-z,now"] )
env.Append( SHLINKFLAGS=["-Wl,-z,now"] )
if not darwin:
env.Append( LINKFLAGS=["-rdynamic"] )
env.Append( LIBS=[] )
# Allow colorized output
env['ENV']['TERM'] = os.environ.get('TERM', None)
if linux and has_option( "gcov" ):
env.Append( CXXFLAGS=" -fprofile-arcs -ftest-coverage " )
env.Append( LINKFLAGS=" -fprofile-arcs -ftest-coverage " )
if optBuild:
env.Append( CCFLAGS=["-O3"] )
else:
env.Append( CCFLAGS=["-O0"] )
if debugBuild:
if not optBuild:
env.Append( CCFLAGS=["-fstack-protector"] )
env.Append( LINKFLAGS=["-fstack-protector"] )
env.Append( SHLINKFLAGS=["-fstack-protector"] )
if force64:
env.Append( CCFLAGS="-m64" )
env.Append( LINKFLAGS="-m64" )
if force32:
env.Append( CCFLAGS="-m32" )
env.Append( LINKFLAGS="-m32" )
if debugBuild:
env.Append( CPPDEFINES=["MONGO_DEBUG_BUILD"] );
try:
umask = os.umask(022)
except OSError:
pass
env.Prepend(CPPPATH=['$VARIANT_DIR/third_party/gtest-1.7.0/include'])
boostSuffixList = ["-mt", ""]
if get_option("boost-lib-search-suffixes") is not None:
boostSuffixList = get_option("boost-lib-search-suffixes")
if boostSuffixList == "":
boostSuffixList = []
else:
boostSuffixList = boostSuffixList.split(',')
env.Append( CPPPATH=['$EXTRACPPPATH'],
LIBPATH=['$EXTRALIBPATH'] )
# --- check system ---
def doConfigure(myenv):
# Check that the compilers work.
#
# TODO: Currently, we have some flags already injected. Eventually, this should test the
# bare compilers, and we should re-check at the very end that TryCompile and TryLink still
# work with the flags we have selected.
conf = Configure(myenv, help=False)
if 'CheckCXX' in dir( conf ):
if not conf.CheckCXX():
conf.env.FatalError("C++ compiler {0} does not work", conf.env["CXX"])
# Only do C checks if CC != CXX
check_c = (myenv["CC"] != myenv["CXX"])
if check_c and 'CheckCC' in dir( conf ):
if not conf.CheckCC():
conf.env.FatalError("C compiler {0} does not work", conf.env["CC"])
myenv = conf.Finish()
# Identify the toolchain in use. We currently support the following:
# TODO: Goes in the env?
toolchain_gcc = "GCC"
toolchain_clang = "clang"
toolchain_msvc = "MSVC"
def CheckForToolchain(context, toolchain, lang_name, compiler_var, source_suffix):
test_bodies = {
toolchain_gcc : (
# Clang also defines __GNUC__
"""
#if !defined(__GNUC__) || defined(__clang__)
#error
#endif
"""),
toolchain_clang : (
"""
#if !defined(__clang__)
#error
#endif
"""),
toolchain_msvc : (
"""
#if !defined(_MSC_VER)
#error
#endif
"""),
}
print_tuple = (lang_name, context.env[compiler_var], toolchain)
context.Message('Checking if %s compiler "%s" is %s... ' % print_tuple)
# Strip indentation from the test body to ensure that the newline at the end of the
# endif is the last character in the file (rather than a line of spaces with no
# newline), and that all of the preprocessor directives start at column zero. Both of
# these issues can trip up older toolchains.
test_body = textwrap.dedent(test_bodies[toolchain])
result = context.TryCompile(test_body, source_suffix)
context.Result(result)
return result
conf = Configure(myenv, help=False, custom_tests = {
'CheckForToolchain' : CheckForToolchain,
})
toolchain = None
have_toolchain = lambda: toolchain != None
using_msvc = lambda: toolchain == toolchain_msvc
using_gcc = lambda: toolchain == toolchain_gcc
using_clang = lambda: toolchain == toolchain_clang
if windows:
toolchain_search_sequence = [toolchain_msvc]
else:
toolchain_search_sequence = [toolchain_gcc, toolchain_clang]
for candidate_toolchain in toolchain_search_sequence:
if conf.CheckForToolchain(candidate_toolchain, "C++", "CXX", ".cpp"):
toolchain = candidate_toolchain
break
if not have_toolchain():
conf.env.FatalError("Couldn't identify the toolchain")
if check_c and not conf.CheckForToolchain(toolchain, "C", "CC", ".c"):
conf.env.FatalError("C toolchain doesn't match identified C++ toolchain")
myenv = conf.Finish()
global use_clang
use_clang = using_clang()
if using_gcc():
myenv.Append(LINKFLAGS=["-pthread"])
# Figure out what our minimum windows version is. If the user has specified, then use
# that. Otherwise, if they have explicitly selected between 32 bit or 64 bit, choose XP or
# Vista respectively. Finally, if they haven't done either of these, try invoking the
# compiler to figure out whether we are doing a 32 or 64 bit build and select as
# appropriate.
if windows:
win_version_min = None
default_32_bit_min = 'xpsp3'
default_64_bit_min = 'ws03sp2'
if has_option('win-version-min'):
win_version_min = get_option('win-version-min')
else:
if force32:
win_version_min = default_32_bit_min
elif force64:
win_version_min = default_64_bit_min
else:
def CheckFor64Bit(context):
win64_test_body = textwrap.dedent(
"""
#if !defined(_WIN64)
#error
#endif
"""
)
context.Message('Checking if toolchain is in 64-bit mode... ')
result = context.TryCompile(win64_test_body, ".c")
context.Result(result)
return result
conf = Configure(myenv, help=False, custom_tests = {
'CheckFor64Bit' : CheckFor64Bit
})
if conf.CheckFor64Bit():
win_version_min = default_64_bit_min
else:
win_version_min = default_32_bit_min
conf.Finish();
env['WIN_VERSION_MIN'] = win_version_min
win_version_min = win_version_min_choices[win_version_min]
env.Append( CPPDEFINES=[("_WIN32_WINNT", "0x" + win_version_min[0])] )
env.Append( CPPDEFINES=[("NTDDI_VERSION", "0x" + win_version_min[0] + win_version_min[1])] )
def AddFlagIfSupported(env, tool, extension, flag, **mutation):
def CheckFlagTest(context, tool, extension, flag):
test_body = ""
context.Message('Checking if %s compiler supports %s... ' % (tool, flag))
ret = context.TryCompile(test_body, extension)
context.Result(ret)
return ret
if using_msvc():
env.FatalError("AddFlagIfSupported is not currently supported with MSVC")
test_mutation = mutation
if using_gcc():
test_mutation = copy.deepcopy(mutation)
# GCC helpfully doesn't issue a diagnostic on unknown flags of the form -Wno-xxx
# unless other diagnostics are triggered. That makes it tough to check for support
# for -Wno-xxx. To work around, if we see that we are testing for a flag of the
# form -Wno-xxx (but not -Wno-error=xxx), we also add -Wxxx to the flags. GCC does
# warn on unknown -Wxxx style flags, so this lets us probe for availablity of
# -Wno-xxx.
for kw in test_mutation.keys():
test_flags = test_mutation[kw]
for test_flag in test_flags:
if test_flag.startswith("-Wno-") and not test_flag.startswith("-Wno-error="):
test_flags.append(re.sub("^-Wno-", "-W", test_flag))
cloned = env.Clone()
cloned.Append(**test_mutation)
# For GCC, we don't need anything since bad flags are already errors, but
# adding -Werror won't hurt. For clang, bad flags are only warnings, so we need -Werror
# to make them real errors.
cloned.Append(CCFLAGS=['-Werror'])
conf = Configure(cloned, help=False, custom_tests = {
'CheckFlag' : lambda(ctx) : CheckFlagTest(ctx, tool, extension, flag)
})
available = conf.CheckFlag()
conf.Finish()
if available:
env.Append(**mutation)
return available
def AddToCFLAGSIfSupported(env, flag):
return AddFlagIfSupported(env, 'C', '.c', flag, CFLAGS=[flag])
def AddToCCFLAGSIfSupported(env, flag):
return AddFlagIfSupported(env, 'C', '.c', flag, CCFLAGS=[flag])
def AddToCXXFLAGSIfSupported(env, flag):
return AddFlagIfSupported(env, 'C++', '.cpp', flag, CXXFLAGS=[flag])
if using_gcc() or using_clang():
# This warning was added in g++-4.8.
AddToCCFLAGSIfSupported(myenv, '-Wno-unused-local-typedefs')
# Clang likes to warn about unused functions, which seems a tad aggressive and breaks
# -Werror, which we want to be able to use.
AddToCCFLAGSIfSupported(myenv, '-Wno-unused-function')
# TODO: Note that the following two flags are added to CCFLAGS even though they are
# really C++ specific. We need to do this because SCons passes CXXFLAGS *before*
# CCFLAGS, but CCFLAGS contains -Wall, which re-enables the warnings we are trying to
# suppress. In the future, we should move all warning flags to CCWARNFLAGS and
# CXXWARNFLAGS and add these to CCOM and CXXCOM as appropriate.
#
# Clang likes to warn about unused private fields, but some of our third_party
# libraries have such things.
AddToCCFLAGSIfSupported(myenv, '-Wno-unused-private-field')
# Prevents warning about using deprecated features (such as auto_ptr in c++11)
# Using -Wno-error=deprecated-declarations does not seem to work on some compilers,
# including at least g++-4.6.
AddToCCFLAGSIfSupported(myenv, "-Wno-deprecated-declarations")
# As of clang-3.4, this warning appears in v8, and gets escalated to an error.
AddToCCFLAGSIfSupported(myenv, "-Wno-tautological-constant-out-of-range-compare")
# New in clang-3.4, trips up things mostly in third_party, but in a few places in the
# primary mongo sources as well.
AddToCCFLAGSIfSupported(myenv, "-Wno-unused-const-variable")
# This has been suppressed in gcc 4.8, due to false positives, but not in clang. So
# we explicitly disable it here.
AddToCCFLAGSIfSupported(myenv, "-Wno-missing-braces")
# Check if we need to disable null-conversion warnings
if using_clang():
def CheckNullConversion(context):
test_body = """
#include
struct TestType { int value; bool boolValue; };
bool foo() {
boost::shared_ptr sp(new TestType);
return NULL != sp;
}
"""
context.Message('Checking if implicit boost::shared_ptr null conversion is supported... ')
ret = context.TryCompile(textwrap.dedent(test_body), ".cpp")
context.Result(ret)
return ret
conf = Configure(myenv, help=False, custom_tests = {
'CheckNullConversion' : CheckNullConversion,
})
if conf.CheckNullConversion() == False:
env.Append( CCFLAGS="-Wno-null-conversion" )
conf.Finish()
# This needs to happen before we check for libc++, since it affects whether libc++ is available.
if darwin and has_option('osx-version-min'):
min_version = get_option('osx-version-min')
min_version_flag = '-mmacosx-version-min=%s' % (min_version)
if not AddToCCFLAGSIfSupported(myenv, min_version_flag):
myenv.ConfError("Can't set minimum OS X version with this compiler")
myenv.AppendUnique(LINKFLAGS=[min_version_flag])
usingLibStdCxx = False
if has_option('libc++'):
if not using_clang():
myenv.ConfError('libc++ is currently only supported for clang')
if darwin and has_option('osx-version-min') and versiontuple(min_version) < versiontuple('10.7'):
print("Warning: You passed option 'libc++'. You probably want to also pass 'osx-version-min=10.7' or higher for libc++ support.")
if AddToCXXFLAGSIfSupported(myenv, '-stdlib=libc++'):
myenv.Append(LINKFLAGS=['-stdlib=libc++'])
else:
myenv.ConfError('libc++ requested, but compiler does not support -stdlib=libc++' )
else:
def CheckLibStdCxx(context):
test_body = """
#include
#if !defined(__GLIBCXX__)
#error
#endif
"""
context.Message('Checking if we are using libstdc++... ')
ret = context.TryCompile(textwrap.dedent(test_body), ".cpp")
context.Result(ret)
return ret
conf = Configure(myenv, help=False, custom_tests = {
'CheckLibStdCxx' : CheckLibStdCxx,
})
usingLibStdCxx = conf.CheckLibStdCxx()
conf.Finish()
# Check to see if we are trying to use an elderly libstdc++, which we arbitrarily define as
# 4.6.0. This is primarly to help people using clang in C++11 mode on OS X but forgetting
# to use --libc++. We also use it to decide if we trust the libstdc++ debug mode. We would,
# ideally, check the __GLIBCXX__ version, but for various reasons this is not
# workable. Instead, we switch on the fact that _GLIBCXX_BEGIN_NAMESPACE_VERSION wasn't
# introduced until libstdc++ 4.6.0.
haveGoodLibStdCxx = False
if usingLibStdCxx:
def CheckModernLibStdCxx(context):
test_body = """
#include
#if !defined(_GLIBCXX_BEGIN_NAMESPACE_VERSION)
#error libstdcxx older than 4.6.0
#endif
"""
context.Message('Checking for libstdc++ 4.6.0 or better... ')
ret = context.TryCompile(textwrap.dedent(test_body), ".cpp")
context.Result(ret)
return ret
conf = Configure(myenv, help=False, custom_tests = {
'CheckModernLibStdCxx' : CheckModernLibStdCxx,
})
haveGoodLibStdCxx = conf.CheckModernLibStdCxx()
conf.Finish()
# Sort out whether we can and should use C++11:
cxx11_mode = get_option("c++11")
if using_msvc():
if cxx11_mode == "off":
print( 'WARNING: Cannot disable C++11 features when using MSVC' )
else:
# If we are using libstdc++, only allow C++11 mode with our line-in-the-sand good
# libstdc++. As always, if in auto mode fall back to disabling if we don't have a good
# libstdc++, otherwise fail the build because we can't honor the explicit request.
if cxx11_mode != "off" and usingLibStdCxx:
if not haveGoodLibStdCxx:
if cxx11_mode == "auto":
cxx11_mode = "off"
else:
cxx11_error = 'Detected libstdc++ is too old to support C++11 mode'
if darwin:
cxx11_error += \
'\nTry building with --libc++ and --osx-version-min=10.7 or higher'
myenv.ConfError(cxx11_error)
# We are going to be adding flags to the environment, but we don't want to persist
# those changes unless we pass all the below checks. Make a copy of the environment
# that we will modify, we will only "commit" the changes to the env if we pass all the
# checks.
cxx11Env = myenv.Clone()
# For our other compilers (gcc and clang) we need to pass -std=c++0x or -std=c++11,
# but we prefer the latter. Try that first, and fall back to c++0x if we don't
# detect that --std=c++11 works. If we can't find a flag and C++11 was explicitly
# requested, error out, otherwise turn off C++11 support in auto mode.
if cxx11_mode != "off":
if not AddToCXXFLAGSIfSupported(cxx11Env, '-std=c++11'):
if not AddToCXXFLAGSIfSupported(cxx11Env, '-std=c++0x'):
if cxx11_mode == "auto":
cxx11_mode = "off"
else:
cxx11Env.ConfError(
'C++11 mode requested, but cannot find a flag to enable it')
# We appear to have C++11, or at least a flag to enable it, which is now set in the
# environment. If we are in auto mode, check if the compiler claims that it strictly
# supports C++11, and disable C++11 if not. If the user has explicitly requested C++11,
# we don't care about what the compiler claims to support, trust the user.
if cxx11_mode == "auto":
def CheckCxx11Official(context):
test_body = """
#if __cplusplus < 201103L
#error
#endif
const int not_an_empty_file = 0;
"""
context.Message('Checking if __cplusplus >= 201103L to auto-enable C++11... ')
ret = context.TryCompile(textwrap.dedent(test_body), ".cpp")
context.Result(ret)
return ret
conf = Configure(cxx11Env, help=False, custom_tests = {
'CheckCxx11Official' : CheckCxx11Official,
})
if cxx11_mode == "auto" and not conf.CheckCxx11Official():
cxx11_mode = "off"
conf.Finish()
# We require c99 mode for C files when C++11 is enabled, so perform the same dance
# as above: if C++11 mode is not off, try the flag, if we are in auto mode and we fail
# then turn off C++11, otherwise C++11 was explicitly requested and we should error out.
if cxx11_mode != "off":
if not AddToCFLAGSIfSupported(cxx11Env, '-std=c99'):
if cxx11_mode == "auto":
cxx11_mode = "off"
else:
cxx11Env.ConfError(
"C++11 mode selected for C++ files, but can't enable C99 for C files")
# If we got here and cxx11_mode hasn't become false, then its true, so swap in the
# modified environment.
if cxx11_mode != "off":
cxx11_mode = "on"
myenv = cxx11Env
# Check if we are on a POSIX system by testing if _POSIX_VERSION is defined.
def CheckPosixSystem(context):
test_body = """
// POSIX requires the existence of unistd.h, so if we can't include unistd.h, we
// are definitely not a POSIX system.
#include
#if !defined(_POSIX_VERSION)
#error not a POSIX system
#endif
"""
context.Message('Checking if we are on a POSIX system... ')
ret = context.TryCompile(textwrap.dedent(test_body), ".c")
context.Result(ret)
return ret
conf = Configure(myenv, help=False, custom_tests = {
'CheckPosixSystem' : CheckPosixSystem,
})
posix_system = conf.CheckPosixSystem()
conf.Finish()
# Check if we are on a system that support the POSIX clock_gettime function
# and the "monotonic" clock.
posix_monotonic_clock = False
if posix_system:
def CheckPosixMonotonicClock(context):
test_body = """
#include
#if !(defined(_POSIX_TIMERS) && _POSIX_TIMERS > 0)
#error POSIX clock_gettime not supported
#elif !(defined(_POSIX_MONOTONIC_CLOCK) && _POSIX_MONOTONIC_CLOCK >= 0)
#error POSIX monotonic clock not supported
#endif
"""
context.Message('Checking if the POSIX monotonic clock is supported... ')
ret = context.TryCompile(textwrap.dedent(test_body), ".c")
context.Result(ret)
return ret
conf = Configure(myenv, help=False, custom_tests = {
'CheckPosixMonotonicClock' : CheckPosixMonotonicClock,
})
posix_monotonic_clock = conf.CheckPosixMonotonicClock()
conf.Finish()
if has_option('sanitize'):
if not (using_clang() or using_gcc()):
myenv.FatalError('sanitize is only supported with clang or gcc')
sanitizer_list = get_option('sanitize').split(',')
using_lsan = 'leak' in sanitizer_list
using_asan = 'address' in sanitizer_list or using_lsan
# If the user asked for leak sanitizer turn on the detect_leaks
# ASAN_OPTION. If they asked for address sanitizer as well, drop
# 'leak', because -fsanitize=leak means no address.
#
# --sanitize=leak: -fsanitize=leak, detect_leaks=1
# --sanitize=address,leak: -fsanitize=address, detect_leaks=1
# --sanitize=address: -fsanitize=address
#
if using_lsan:
if using_asan:
myenv['ENV']['ASAN_OPTIONS'] = "detect_leaks=1"
myenv['ENV']['LSAN_OPTIONS'] = "suppressions=%s" % myenv.File("#etc/lsan.suppressions").abspath
if 'address' in sanitizer_list:
sanitizer_list.remove('leak')
sanitizer_option = '-fsanitize=' + ','.join(sanitizer_list)
if AddToCCFLAGSIfSupported(myenv, sanitizer_option):
myenv.Append(LINKFLAGS=[sanitizer_option])
myenv.Append(CCFLAGS=['-fno-omit-frame-pointer'])
else:
myenv.ConfError('Failed to enable sanitizers with flag: {0}', sanitizer_option )
blackfiles_map = {
"address" : myenv.File("#etc/asan.blacklist"),
"leak" : myenv.File("#etc/asan.blacklist"),
"thread" : myenv.File("#etc/tsan.blacklist"),
"undefined" : myenv.File("#etc/ubsan.blacklist"),
}
blackfiles = set([v for (k, v) in blackfiles_map.iteritems() if k in sanitizer_list])
blacklist_options=["-fsanitize-blacklist=%s" % blackfile for blackfile in blackfiles]
for blacklist_option in blacklist_options:
if AddToCCFLAGSIfSupported(myenv, blacklist_option):
myenv.Append(LINKFLAGS=[blacklist_option])
llvm_symbolizer = get_option('llvm-symbolizer')
if os.path.isabs(llvm_symbolizer):
if not myenv.File(llvm_symbolizer).exists():
print("WARNING: Specified symbolizer '%s' not found" % llvm_symbolizer)
llvm_symbolizer = None
else:
llvm_symbolizer = myenv.WhereIs(llvm_symbolizer)
if llvm_symbolizer:
myenv['ENV']['ASAN_SYMBOLIZER_PATH'] = llvm_symbolizer
myenv['ENV']['LSAN_SYMBOLIZER_PATH'] = llvm_symbolizer
elif using_lsan:
myenv.ConfError("Using the leak sanitizer requires a valid symbolizer")
# When using msvc, check for VS 2013 Update 2+ so we can use new compiler flags
if using_msvc():
haveVS2013Update2OrLater = False
def CheckVS2013Update2(context):
test_body = """
#if _MSC_VER < 1800 || (_MSC_VER == 1800 && _MSC_FULL_VER < 180030501)
#error Old Version
#endif
int main(int argc, char* argv[]) {
return 0;
}
"""
context.Message('Checking for VS 2013 Update 2 or Later... ')
ret = context.TryCompile(textwrap.dedent(test_body), ".cpp")
context.Result(ret)
return ret
conf = Configure(myenv, help=False, custom_tests = {
'CheckVS2013Update2' : CheckVS2013Update2,
})
haveVS2013Update2OrLater = conf.CheckVS2013Update2()
conf.Finish()
if haveVS2013Update2OrLater and optBuild:
# http://blogs.msdn.com/b/vcblog/archive/2013/09/11/introducing-gw-compiler-switch.aspx
#
myenv.Append( CCFLAGS=["/Gw", "/Gy"] )
myenv.Append( LINKFLAGS=["/OPT:REF"])
# http://blogs.msdn.com/b/vcblog/archive/2014/03/25/linker-enhancements-in-visual-studio-2013-update-2-ctp2.aspx
#
myenv.Append( CCFLAGS=["/Zc:inline"])
# Apply any link time optimization settings as selected by the 'lto' option.
if has_option('lto'):
if using_msvc():
# Note that this is actually more aggressive than LTO, it is whole program
# optimization due to /GL. However, this is historically what we have done for
# windows, so we are keeping it.
#
# /GL implies /LTCG, so no need to say it in CCFLAGS, but we do need /LTCG on the
# link flags.
myenv.Append(CCFLAGS=['/GL'])
myenv.Append(LINKFLAGS=['/LTCG'])
myenv.Append(ARFLAGS=['/LTCG'])
elif using_gcc() or using_clang():
# For GCC and clang, the flag is -flto, and we need to pass it both on the compile
# and link lines.
if AddToCCFLAGSIfSupported(myenv, '-flto'):
myenv.Append(LINKFLAGS=['-flto'])
def LinkHelloWorld(context, adornment = None):
test_body = """
#include
int main() {
std::cout << "Hello, World!" << std::endl;
return 0;
}
"""
message = "Trying to link with LTO"
if adornment:
message = message + " " + adornment
message = message + "..."
context.Message(message)
ret = context.TryLink(textwrap.dedent(test_body), ".cpp")
context.Result(ret)
return ret
conf = Configure(myenv, help=False, custom_tests = {
'LinkHelloWorld' : LinkHelloWorld,
})
# Some systems (clang, on a system with the BFD linker by default) may need to
# explicitly request the gold linker for LTO to work. If we can't LTO link a
# simple program, see if -fuse=ld=gold helps.
if not conf.LinkHelloWorld():
conf.env.Append(LINKFLAGS=["-fuse-ld=gold"])
if not conf.LinkHelloWorld("(with -fuse-ld=gold)"):
myenv.ConfError("Error: Couldn't link with LTO")
myenv = conf.Finish()
else:
myenv.ConfError("Link time optimization requested, " +
"but selected compiler does not honor -flto" )
else:
myenv.ConfError("Don't know how to enable --lto on current toolchain")
# When using msvc, check for support for __declspec(thread), unless we have been asked
# explicitly not to use it. For other compilers, see if __thread works.
if using_msvc():
haveDeclSpecThread = False
if not has_option("disable-declspec-thread"):
def CheckDeclspecThread(context):
test_body = """
__declspec( thread ) int tsp_int;
int main(int argc, char* argv[]) {
tsp_int = argc;
return 0;
}
"""
context.Message('Checking for __declspec(thread)... ')
ret = context.TryLink(textwrap.dedent(test_body), ".cpp")
context.Result(ret)
return ret
conf = Configure(myenv, help=False, custom_tests = {
'CheckDeclspecThread' : CheckDeclspecThread,
})
haveDeclSpecThread = conf.CheckDeclspecThread()
conf.Finish()
if haveDeclSpecThread:
myenv.Append(CPPDEFINES=['MONGO_HAVE___DECLSPEC_THREAD'])
else:
def CheckUUThread(context):
test_body = """
__thread int tsp_int;
int main(int argc, char* argv[]) {
tsp_int = argc;
return 0;
}
"""
context.Message('Checking for __thread... ')
ret = context.TryLink(textwrap.dedent(test_body), ".cpp")
context.Result(ret)
return ret
conf = Configure(myenv, help=False, custom_tests = {
'CheckUUThread' : CheckUUThread,
})
haveUUThread = conf.CheckUUThread()
conf.Finish()
if haveUUThread:
myenv.Append(CPPDEFINES=['MONGO_HAVE___THREAD'])
def CheckCXX11Atomics(context):
test_body = """
#include
int main(int argc, char **argv) {
std::atomic a(0);
return a.fetch_add(1);
}
"""
context.Message('Checking for C++11 support... ')
ret = context.TryLink(textwrap.dedent(test_body), '.cpp')
context.Result(ret)
return ret;
def CheckGCCAtomicBuiltins(context):
test_body = """
int main(int argc, char **argv) {
int a = 0;
int b = 0;
int c = 0;
__atomic_compare_exchange(&a, &b, &c, false, __ATOMIC_SEQ_CST, __ATOMIC_SEQ_CST);
return 0;
}
"""
context.Message('Checking for gcc __atomic builtins... ')
ret = context.TryLink(textwrap.dedent(test_body), '.cpp')
context.Result(ret)
return ret
def CheckGCCSyncBuiltins(context):
test_body = """
int main(int argc, char **argv) {
int a = 0;
return __sync_fetch_and_add(&a, 1);
}
//
// Figure out if we are using gcc older than 4.2 to target 32-bit x86. If so, error out
// even if we were able to compile the __sync statement, due to
// https://gcc.gnu.org/bugzilla/show_bug.cgi?id=40693
//
#if defined(__i386__)
#if !defined(__clang__)
#if defined(__GNUC__) && (__GNUC__ == 4) && (__GNUC_MINOR__ < 2)
#error "Refusing to use __sync in 32-bit mode with gcc older than 4.2"
#endif
#endif
#endif
"""
context.Message('Checking for useable __sync builtins... ')
ret = context.TryLink(textwrap.dedent(test_body), '.cpp')
context.Result(ret)
return ret
# not all C++11-enabled gcc versions have type properties
def CheckCXX11IsTriviallyCopyable(context):
test_body = """
#include
int main(int argc, char **argv) {
class Trivial {
int trivial1;
double trivial2;
struct {
float trivial3;
short trivial4;
} trivial_member;
};
class NotTrivial {
int x, y;
NotTrivial(const NotTrivial& o) : x(o.y), y(o.x) {}
};
static_assert(std::is_trivially_copyable::value,
"I should be trivially copyable");
static_assert(!std::is_trivially_copyable::value,
"I should not be trivially copyable");
return 0;
}
"""
context.Message('Checking for C++11 is_trivially_copyable support... ')
ret = context.TryCompile(textwrap.dedent(test_body), '.cpp')
context.Result(ret)
return ret
conf = Configure(myenv, help=False, custom_tests = {
'CheckCXX11Atomics': CheckCXX11Atomics,
'CheckGCCAtomicBuiltins': CheckGCCAtomicBuiltins,
'CheckGCCSyncBuiltins': CheckGCCSyncBuiltins,
'CheckCXX11IsTriviallyCopyable': CheckCXX11IsTriviallyCopyable,
})
# Figure out what atomics mode to use by way of the tests defined above.
#
# Non_windows: > __atomic > __sync
# Windows: > Interlocked functions / intrinsics.
#
# If we are in C++11 mode, try to use . This is unusual for us, as typically we
# only use __cplusplus >= 201103L to decide if we want to enable a feature. We make a
# special case for the atomics and use them on platforms that offer them even if they don't
# advertise full conformance. For MSVC systems, if we don't have then no more
# checks are required. Otherwise, we are on a GCC/clang system, where we may have __atomic
# or __sync, so try those in that order next.
#
# If we don't end up defining a MONGO_HAVE for the atomics, we will end up falling back to
# the Microsoft Interlocked functions/intrinsics when using MSVC, or the gcc_intel
# implementation of hand-rolled assembly if using gcc/clang.
if (using_msvc() or (cxx11_mode == "on")) and conf.CheckCXX11Atomics():
conf.env['MONGO_HAVE_CXX11_ATOMICS'] = True
elif using_gcc() or using_clang():
# Prefer the __atomic builtins. If we don't have those, try for __sync. Otherwise
# atomic_intrinsics.h will try to fall back to the hand-rolled assembly implementations
# in atomic_intrinsics_gcc_intel for x86 platforms.
if conf.CheckGCCAtomicBuiltins():
conf.env["MONGO_HAVE_GCC_ATOMIC_BUILTINS"] = True
else:
if conf.CheckGCCSyncBuiltins():
conf.env["MONGO_HAVE_GCC_SYNC_BUILTINS"] = True
if (cxx11_mode == "on") and conf.CheckCXX11IsTriviallyCopyable():
conf.env['MONGO_HAVE_STD_IS_TRIVIALLY_COPYABLE'] = True
myenv = conf.Finish()
if using_msvc():
# TODO: This is really only needed for MSVC 12, but we have no current way to know
# which MSVC version we have. Presuming that this is harmless on other MSVC
# implementations. Without this, gtest doesn't build. We need to apply universally, not
# just while builing gtest.
myenv.Append(CPPDEFINES=[('_VARIADIC_MAX', 10)])
conf = Configure(myenv)
conf.env["MONGO_SSL"] = bool(has_option("ssl"))
if conf.env["MONGO_SSL"]:
sslLibName = "ssl"
cryptoLibName = "crypto"
if windows:
sslLibName = "ssleay32"
cryptoLibName = "libeay32"
if not conf.CheckLibWithHeader(
sslLibName,
["openssl/ssl.h"],
"C",
"SSL_version(NULL);",
autoadd=True):
conf.env.ConfError("Couldn't find OpenSSL ssl.h header and library")
if not conf.CheckLibWithHeader(
cryptoLibName,
["openssl/crypto.h"],
"C",
"SSLeay_version(0);",
autoadd=True):
conf.env.ConfError("Couldn't find OpenSSL crypto.h header and library")
def CheckLinkSSL(context):
test_body = """
#include
#include
#include
int main() {
SSL_library_init();
SSL_load_error_strings();
ERR_load_crypto_strings();
OpenSSL_add_all_algorithms();
ERR_free_strings();
return EXIT_SUCCESS;
}
"""
context.Message("Checking that linking to OpenSSL works...")
ret = context.TryLink(textwrap.dedent(test_body), ".c")
context.Result(ret)
return ret
conf.AddTest("CheckLinkSSL", CheckLinkSSL)
if not conf.CheckLinkSSL():
conf.env.ConfError("SSL is enabled, but is unavailable")
if conf.CheckDeclaration(
"FIPS_mode_set",
includes="""
#include
#include
"""):
conf.env.Append(CPPDEFINES=["MONGO_HAVE_FIPS_MODE_SET"])
if not conf.CheckCXXHeader( "boost/version.hpp" ):
conf.env.ConfError("Could not find boost headers in include search path")
if (not windows) and boostSuffixList:
# We don't do this for windows because we rely on autolib.
for b in boostLibs:
boostCandidates = ["boost_" + b + suffix for suffix in boostSuffixList]
if not conf.CheckLib(boostCandidates, language="C++"):
conf.env.ConfError("can't find boost")
# We need xtime internally no matter what the local boost thread version may be since we
# cannot require the existence of chrono. It is important that no uses of xtime become part
# of the public interface of the library so that we do not impose this burden on our
# consumers.
conf.env.Append(CPPDEFINES=[("BOOST_THREAD_USES_DATETIME")])
if conf.CheckHeader('unistd.h'):
conf.env['MONGO_HAVE_HEADER_UNISTD_H'] = True
if posix_system:
conf.env.Append(CPPDEFINES=['MONGO_HAVE_HEADER_UNISTD_H'])
conf.CheckLib('rt')
if posix_monotonic_clock:
conf.env.Append(CPPDEFINES=['MONGO_HAVE_POSIX_MONOTONIC_CLOCK'])
if solaris:
conf.CheckLib( "nsl" )
conf.env['MONGO_SASL'] = bool(has_option("use-sasl-client"))
if conf.env['MONGO_SASL'] and not conf.env['MONGO_SSL']:
myenv.FatalError("SASL support requires --ssl")
if conf.env['MONGO_SASL'] and not conf.CheckLibWithHeader(
"sasl2",
["stddef.h","sasl/sasl.h"],
"C",
"sasl_version_info(0, 0, 0, 0, 0, 0);",
autoadd=True ):
myenv.ConfError("Couldn't find SASL header/libraries")
# requires ports devel/libexecinfo to be installed
if freebsd or openbsd:
if not conf.CheckLib("execinfo"):
myenv.ConfError("Cannot find libexecinfo, please install devel/libexecinfo")
# check for presence of timegm(3) and polyfill if needed
conf.env['MONGO_HAVE_TIMEGM'] = conf.CheckDeclaration(
'timegm', includes="#include ", language='C')
if conf.env['MONGO_HAVE_TIMEGM']:
conf.env.Append(CPPDEFINES=['MONGO_HAVE_TIMEGM'])
# check for presence of strnlen(3) and polyfill if needed
if conf.CheckDeclaration('strnlen', includes="#include ", language='C'):
conf.env['MONGO_HAVE_STRNLEN'] = True
return conf.Finish()
env = doConfigure( env )
env['PDB'] = '${TARGET.base}.pdb'
# ---- Docs ----
def build_docs(env, target, source):
buildscripts.docs.main()
env.Alias("docs", [], [build_docs])
env.AlwaysBuild("docs")
# --- lint ----
def doLint( env , target , source ):
import buildscripts.clang_format
if not buildscripts.clang_format.lint(None, []):
raise Exception("clang-format lint errors")
if not buildscripts.lint.run_lint( [ "src/mongo/" ] ):
raise Exception( "lint errors" )
env.Alias( "lint" , [] , [ doLint ] )
env.AlwaysBuild( "lint" )
# --- an uninstall target ---
if len(COMMAND_LINE_TARGETS) > 0 and 'uninstall' in COMMAND_LINE_TARGETS:
SetOption("clean", 1)
# By inspection, changing COMMAND_LINE_TARGETS here doesn't do
# what we want, but changing BUILD_TARGETS does.
BUILD_TARGETS.remove("uninstall")
BUILD_TARGETS.append("install")
# The following symbols are exported for use in subordinate SConscript files.
# Ideally, the SConscript files would be purely declarative. They would only
# import build environment objects, and would contain few or no conditional
# statements or branches.
#
# Currently, however, the SConscript files do need some predicates for
# conditional decision making that hasn't been moved up to this SConstruct file,
# and they are exported here, as well.
Export("env")
Export("get_option")
Export("has_option")
Export("darwin windows solaris linux freebsd nix")
Export("debugBuild optBuild")
Export("use_clang")
env.SConscript('src/SConscript', variant_dir='$VARIANT_DIR', duplicate=False)
# --- Coverage ---
if has_option("gcov"):
env['GCOV_BASE_DIR'] = env.Dir(".").abspath
env['GCOV_BUILD_DIR'] = env.Dir("$VARIANT_DIR").abspath
# Zero out all the counters -- depends on tests being built
env.Alias(
'zero_counters',
['unittests', 'clientTests', 'integration_tests'],
['lcov -z -b $GCOV_BASE_DIR -d $GCOV_BUILD_DIR']
)
env.AlwaysBuild('zero_counters')
# Generates test coverage information -- depends on tests being run
env.Command(
target='$VARIANT_DIR/coverage.info',
source=['zero_counters', 'test', 'smokeClient', 'integration'],
action='lcov --no-external -c -b $GCOV_BASE_DIR -d $GCOV_BUILD_DIR -o $TARGET'
)
env.AlwaysBuild('coverage.info')
# Strip third_party and build related coverage info
stripCmd = env.Command(
target=None,
source='$VARIANT_DIR/coverage.info',
action=[
'lcov -r $SOURCE src/third_party/\* -o $SOURCE',
'lcov -r $SOURCE build/\* -o $SOURCE',
'lcov -r $SOURCE \*_test.cpp -o $SOURCE',
'lcov -r $SOURCE src/mongo/client/examples/\* -o $SOURCE',
'lcov -r $SOURCE src/mongo/dbtests/\* -o $SOURCE',
'lcov -r $SOURCE src/mongo/unittest/\* -o $SOURCE',
'lcov -r $SOURCE src/mongo/bson/bsondemo/\* -o $SOURCE',
],
)
env.AlwaysBuild(stripCmd)
env.Alias('strip_coverage', stripCmd)
# Generates the HTML output in "coverage" directory
coverageCmd = env.Command(
env.Dir('$BUILD_DIR/coverage'),
'strip_coverage',
[
'rm -rf $BUILD_DIR/coverage',
'genhtml --frames --legend -t "MongoDB C++ Driver Coverage" -o $TARGET $VARIANT_DIR/coverage.info'
]
)
env.AlwaysBuild(coverageCmd)
env.Alias('coverage', coverageCmd)
env.Alias('all', ['driver', 'build-unit', 'build-integration', 'build-examples'])
env.Alias('test', ['unit', 'integration', 'examples'])
Default('driver')
mongo-cxx-driver-legacy-1.1.2/THIRD-PARTY-NOTICES 0000664 0000000 0000000 00000024100 12732311114 0020751 0 ustar 00root root 0000000 0000000 MongoDB uses third-party libraries or other resources that may
be distributed under licenses different than the MongoDB software.
In the event that we accidentally failed to list a required notice,
please bring it to our attention through any of the ways detailed here:
https://jira.mongodb.org/browse/CXX
The attached notices are provided for information only.
For any licenses that require disclosure of source, sources are available at
https://github.com/mongodb/mongo-cxx-driver.
1) License Notice for The Loki Library
--------------------------------------
Copyright (c) 2000 Andrei Alexandrescu
Copyright (c) 2000 Petru Marginean
Copyright (c) 2005 Joshua Lehrer
Permission to use, copy, modify, distribute and sell this software for any
purpose is hereby granted without fee, provided that the above copyright
notice appear in all copies and that both that copyright notice and this
permission notice appear in supporting documentation.
The author makes no representations about the suitability of this software
for any purpose. It is provided "as is" without express or implied
warranty.
2) License Notice for MurmurHash
--------------------------------
Copyright (c) 2010-2012 Austin Appleby
Permission is hereby granted, free of charge, to any person obtaining a copy
of this software and associated documentation files (the "Software"), to deal
in the Software without restriction, including without limitation the rights
to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
copies of the Software, and to permit persons to whom the Software is
furnished to do so, subject to the following conditions:
The above copyright notice and this permission notice shall be included in
all copies or substantial portions of the Software.
THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
SOFTWARE.
3) License Notice for The Google C++ Testing Framework (Google Test)
--------------------------------------------------------------------
Copyright 2005, 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.
4) License Notice for JsonCpp
-----------------------------
The JsonCpp library's source code, including accompanying documentation,
tests and demonstration applications, are licensed under the following
conditions...
The author (Baptiste Lepilleur) explicitly disclaims copyright in all
jurisdictions which recognize such a disclaimer. In such jurisdictions,
this software is released into the Public Domain.
In jurisdictions which do not recognize Public Domain property (e.g.
Germany as of 2010), this software is Copyright (c) 2007-2010 by Baptiste
Lepilleur, and is released under the terms of the MIT License (see below).
In jurisdictions which recognize Public Domain property, the user of this
software may choose to accept it either as 1) Public Domain, 2) under the
conditions of the MIT License (see below), or 3) under the terms of dual
Public Domain/MIT License conditions described here, as they choose.
The MIT License is about as close to Public Domain as a license can get, and is
described in clear, concise terms at:
http://en.wikipedia.org/wiki/MIT_License
The full text of the MIT License follows:
========================================================================
Copyright (c) 2007-2010 Baptiste Lepilleur
Permission is hereby granted, free of charge, to any person
obtaining a copy of this software and associated documentation
files (the "Software"), to deal in the Software without
restriction, including without limitation the rights to use, copy,
modify, merge, publish, distribute, sublicense, and/or sell copies
of the Software, and to permit persons to whom the Software is
furnished to do so, subject to the following conditions:
The above copyright notice and this permission notice shall be
included in all copies or substantial portions of the Software.
THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS
BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN
ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
SOFTWARE.
========================================================================
(END LICENSE TEXT)
The MIT license is compatible with both the GPL and commercial
software, affording one all of the rights of Public Domain with the
minor nuisance of being required to keep the above copyright notice
and license text in the source code. Note also that by accepting the
Public Domain "license" you can re-license your copy using whatever
license you like.
5) License Notice for RestClient
--------------------------------
Copyright (c) 2010 Daniel Schauenberg
Permission is hereby granted, free of charge, to any person obtaining
a copy of this software and associated documentation files (the
"Software"), to deal in the Software without restriction, including
without limitation the rights to use, copy, modify, merge, publish,
distribute, sublicense, and/or sell copies of the Software, and to
permit persons to whom the Software is furnished to do so, subject to
the following conditions:
The above copyright notice and this permission notice shall be
included in all copies or substantial portions of the Software.
THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
6) License Notice for the TZ Database
-------------------------------------
The tzcode library is published as part of the TZ Database by IANA at
https://www.iana.org/time-zones
Ownership is described in https://www.rfc-editor.org/bcp/bcp175.txt:
The TZ database itself is not an IETF Contribution or an IETF document.
Rather it is a pre-existing and regularly updated work that is in the
public domain, and is intended to remain in the public domain.
Therefore, BCPs 78 [RFC5378] and 79 [RFC3979] do not apply to the TZ
Database or contributions that individuals make to it. Should any
claims be made and substantiated against the TZ Database, the
organization that is providing the IANA Considerations defined in this
RFC, under the memorandum of understanding with the IETF, currently
ICANN, may act in accordance with all competent court orders. No
ownership claims will be made by ICANN or the IETF Trust on the
database or the code. Any person making a contribution to the database
or code waives all rights to future claims in that contribution or in
the TZ Database.
7) License Notice for Independent implementation of MD5 by Aladdin Enterprises
------------------------------------------------------------------------------
Copyright (C) 1999, 2002 Aladdin Enterprises. All rights reserved.
This software is provided 'as-is', without any express or implied
warranty. In no event will the authors be held liable for any damages
arising from the use of this software.
Permission is granted to anyone to use this software for any purpose,
including commercial applications, and to alter it and redistribute it
freely, subject to the following restrictions:
1. The origin of this software must not be misrepresented; you must not
claim that you wrote the original software. If you use this software in a
product, an acknowledgment in the product documentation would be
appreciated but is not required.
2. Altered source versions must be plainly marked as such, and must not be
misrepresented as being the original software.
3. This notice may not be removed or altered from any source distribution.
L. Peter Deutsch
ghost@aladdin.com
NOTE: Per restriction 2 above, this file has been altered by MongoDB as
follows:
1. The functions md5_init, md5_append, and md5_finish have been moved into
the 'mongo' namespace and given C++ linkage, so that static archives of
this library may be combined with other libraries that expose functions of
the same name.
mongo-cxx-driver-legacy-1.1.2/docs/ 0000775 0000000 0000000 00000000000 12732311114 0017110 5 ustar 00root root 0000000 0000000 mongo-cxx-driver-legacy-1.1.2/docs/.gitkeep 0000664 0000000 0000000 00000000000 12732311114 0020527 0 ustar 00root root 0000000 0000000 mongo-cxx-driver-legacy-1.1.2/etc/ 0000775 0000000 0000000 00000000000 12732311114 0016733 5 ustar 00root root 0000000 0000000 mongo-cxx-driver-legacy-1.1.2/etc/asan.blacklist 0000664 0000000 0000000 00000000000 12732311114 0021535 0 ustar 00root root 0000000 0000000 mongo-cxx-driver-legacy-1.1.2/etc/doxygen/ 0000775 0000000 0000000 00000000000 12732311114 0020410 5 ustar 00root root 0000000 0000000 mongo-cxx-driver-legacy-1.1.2/etc/doxygen/config 0000664 0000000 0000000 00000025315 12732311114 0021606 0 ustar 00root root 0000000 0000000 #---------------------------------------------------------------------------
# Project related configuration options
#---------------------------------------------------------------------------
DOXYFILE_ENCODING = UTF-8
PROJECT_NAME = "MongoDB C++ Driver"
PROJECT_NUMBER = legacy-1.1.2
OUTPUT_DIRECTORY = docs/doxygen
CREATE_SUBDIRS = NO
OUTPUT_LANGUAGE = English
BRIEF_MEMBER_DESC = YES
REPEAT_BRIEF = YES
ABBREVIATE_BRIEF = "The $name class" \
"The $name widget" \
"The $name file" \
is \
provides \
specifies \
contains \
represents \
a \
an \
the
ALWAYS_DETAILED_SEC = NO
INLINE_INHERITED_MEMB = NO
FULL_PATH_NAMES = NO
STRIP_FROM_PATH =
STRIP_FROM_INC_PATH =
SHORT_NAMES = NO
JAVADOC_AUTOBRIEF = YES
QT_AUTOBRIEF = NO
MULTILINE_CPP_IS_BRIEF = NO
INHERIT_DOCS = YES
SEPARATE_MEMBER_PAGES = NO
TAB_SIZE = 4
ALIASES =
OPTIMIZE_OUTPUT_FOR_C = NO
OPTIMIZE_OUTPUT_JAVA = NO
OPTIMIZE_FOR_FORTRAN = NO
OPTIMIZE_OUTPUT_VHDL = NO
EXTENSION_MAPPING =
BUILTIN_STL_SUPPORT = NO
CPP_CLI_SUPPORT = NO
SIP_SUPPORT = NO
IDL_PROPERTY_SUPPORT = YES
DISTRIBUTE_GROUP_DOC = NO
SUBGROUPING = YES
TYPEDEF_HIDES_STRUCT = NO
SYMBOL_CACHE_SIZE = 0
#---------------------------------------------------------------------------
# Build related configuration options
#---------------------------------------------------------------------------
EXTRACT_ALL = NO
EXTRACT_PRIVATE = NO
EXTRACT_STATIC = NO
EXTRACT_LOCAL_CLASSES = NO
EXTRACT_LOCAL_METHODS = NO
EXTRACT_ANON_NSPACES = NO
HIDE_UNDOC_MEMBERS = NO
HIDE_UNDOC_CLASSES = NO
HIDE_FRIEND_COMPOUNDS = NO
HIDE_IN_BODY_DOCS = NO
INTERNAL_DOCS = NO
CASE_SENSE_NAMES = NO
HIDE_SCOPE_NAMES = NO
SHOW_INCLUDE_FILES = YES
INLINE_INFO = YES
SORT_MEMBER_DOCS = YES
SORT_BRIEF_DOCS = NO
SORT_GROUP_NAMES = NO
SORT_BY_SCOPE_NAME = NO
GENERATE_TODOLIST = YES
GENERATE_TESTLIST = YES
GENERATE_BUGLIST = YES
GENERATE_DEPRECATEDLIST= YES
ENABLED_SECTIONS =
MAX_INITIALIZER_LINES = 30
SHOW_USED_FILES = YES
SHOW_DIRECTORIES = NO
SHOW_FILES = YES
SHOW_NAMESPACES = YES
FILE_VERSION_FILTER =
LAYOUT_FILE =
#---------------------------------------------------------------------------
# configuration options related to warning and progress messages
#---------------------------------------------------------------------------
QUIET = NO
WARNINGS = YES
WARN_IF_UNDOCUMENTED = YES
WARN_IF_DOC_ERROR = YES
WARN_NO_PARAMDOC = NO
WARN_FORMAT = "$file:$line: $text"
WARN_LOGFILE =
#---------------------------------------------------------------------------
# configuration options related to the input files
#---------------------------------------------------------------------------
INPUT = src/mongo
INPUT_ENCODING = UTF-8
FILE_PATTERNS = *.c \
*.cc \
*.cxx \
*.cpp \
*.c++ \
*.d \
*.java \
*.ii \
*.ixx \
*.ipp \
*.i++ \
*.inl \
*.h \
*.hh \
*.hxx \
*.hpp \
*.h++ \
*.idl \
*.odl \
*.cs \
*.php \
*.php3 \
*.inc \
*.m \
*.mm \
*.dox \
*.py \
*.f90 \
*.f \
*.vhd \
*.vhdl
RECURSIVE = YES
EXCLUDE = src/mongo/bson/bsondemo \
src/mongo/client/examples \
src/mongo/client/private \
src/mongo/dbtests \
src/mongo/integration \
src/mongo/orchestration \
src/mongo/unittest
EXCLUDE_SYMLINKS = NO
EXCLUDE_PATTERNS =
EXCLUDE_SYMBOLS =
EXAMPLE_PATH =
EXAMPLE_PATTERNS = *
EXAMPLE_RECURSIVE = NO
IMAGE_PATH =
INPUT_FILTER =
FILTER_PATTERNS =
FILTER_SOURCE_FILES = NO
#---------------------------------------------------------------------------
# configuration options related to source browsing
#---------------------------------------------------------------------------
SOURCE_BROWSER = NO
INLINE_SOURCES = NO
STRIP_CODE_COMMENTS = YES
REFERENCED_BY_RELATION = NO
REFERENCES_RELATION = NO
REFERENCES_LINK_SOURCE = YES
USE_HTAGS = NO
VERBATIM_HEADERS = YES
#---------------------------------------------------------------------------
# configuration options related to the alphabetical class index
#---------------------------------------------------------------------------
ALPHABETICAL_INDEX = NO
COLS_IN_ALPHA_INDEX = 5
IGNORE_PREFIX =
#---------------------------------------------------------------------------
# configuration options related to the HTML output
#---------------------------------------------------------------------------
GENERATE_HTML = YES
HTML_OUTPUT = html
HTML_FILE_EXTENSION = .html
HTML_HEADER =
HTML_FOOTER =
HTML_STYLESHEET =
HTML_ALIGN_MEMBERS = YES
HTML_DYNAMIC_SECTIONS = NO
GENERATE_DOCSET = NO
DOCSET_FEEDNAME = "Doxygen generated docs"
DOCSET_BUNDLE_ID = org.doxygen.Project
GENERATE_HTMLHELP = NO
CHM_FILE =
HHC_LOCATION =
GENERATE_CHI = NO
CHM_INDEX_ENCODING =
BINARY_TOC = NO
TOC_EXPAND = NO
GENERATE_QHP = NO
QCH_FILE =
QHP_NAMESPACE =
QHP_VIRTUAL_FOLDER = doc
QHP_CUST_FILTER_NAME =
QHP_CUST_FILTER_ATTRS =
QHP_SECT_FILTER_ATTRS =
QHG_LOCATION =
DISABLE_INDEX = NO
ENUM_VALUES_PER_LINE = 4
GENERATE_TREEVIEW = NONE
TREEVIEW_WIDTH = 250
FORMULA_FONTSIZE = 10
#---------------------------------------------------------------------------
# configuration options related to the LaTeX output
#---------------------------------------------------------------------------
GENERATE_LATEX = YES
LATEX_OUTPUT = latex
LATEX_CMD_NAME = latex
MAKEINDEX_CMD_NAME = makeindex
COMPACT_LATEX = NO
PAPER_TYPE = a4wide
EXTRA_PACKAGES =
LATEX_HEADER =
PDF_HYPERLINKS = YES
USE_PDFLATEX = YES
LATEX_BATCHMODE = NO
LATEX_HIDE_INDICES = NO
#---------------------------------------------------------------------------
# configuration options related to the RTF output
#---------------------------------------------------------------------------
GENERATE_RTF = NO
RTF_OUTPUT = rtf
COMPACT_RTF = NO
RTF_HYPERLINKS = NO
RTF_STYLESHEET_FILE =
RTF_EXTENSIONS_FILE =
#---------------------------------------------------------------------------
# configuration options related to the man page output
#---------------------------------------------------------------------------
GENERATE_MAN = NO
MAN_OUTPUT = man
MAN_EXTENSION = .3
MAN_LINKS = NO
#---------------------------------------------------------------------------
# configuration options related to the XML output
#---------------------------------------------------------------------------
GENERATE_XML = NO
XML_OUTPUT = xml
XML_SCHEMA =
XML_DTD =
XML_PROGRAMLISTING = YES
#---------------------------------------------------------------------------
# configuration options for the AutoGen Definitions output
#---------------------------------------------------------------------------
GENERATE_AUTOGEN_DEF = NO
#---------------------------------------------------------------------------
# configuration options related to the Perl module output
#---------------------------------------------------------------------------
GENERATE_PERLMOD = NO
PERLMOD_LATEX = NO
PERLMOD_PRETTY = YES
PERLMOD_MAKEVAR_PREFIX =
#---------------------------------------------------------------------------
# Configuration options related to the preprocessor
#---------------------------------------------------------------------------
ENABLE_PREPROCESSING = YES
MACRO_EXPANSION = NO
EXPAND_ONLY_PREDEF = NO
SEARCH_INCLUDES = YES
INCLUDE_PATH =
INCLUDE_FILE_PATTERNS =
PREDEFINED =
EXPAND_AS_DEFINED =
SKIP_FUNCTION_MACROS = YES
#---------------------------------------------------------------------------
# Configuration::additions related to external references
#---------------------------------------------------------------------------
TAGFILES =
GENERATE_TAGFILE =
ALLEXTERNALS = NO
EXTERNAL_GROUPS = YES
PERL_PATH = /usr/bin/perl
#---------------------------------------------------------------------------
# Configuration options related to the dot tool
#---------------------------------------------------------------------------
CLASS_DIAGRAMS = YES
MSCGEN_PATH =
HIDE_UNDOC_RELATIONS = YES
HAVE_DOT = NO
DOT_FONTNAME =
DOT_FONTSIZE = 10
DOT_FONTPATH =
CLASS_GRAPH = YES
COLLABORATION_GRAPH = YES
GROUP_GRAPHS = YES
UML_LOOK = NO
TEMPLATE_RELATIONS = NO
INCLUDE_GRAPH = YES
INCLUDED_BY_GRAPH = YES
CALL_GRAPH = NO
CALLER_GRAPH = NO
GRAPHICAL_HIERARCHY = YES
DIRECTORY_GRAPH = YES
DOT_IMAGE_FORMAT = png
DOT_PATH =
DOTFILE_DIRS =
DOT_GRAPH_MAX_NODES = 50
MAX_DOT_GRAPH_DEPTH = 0
DOT_TRANSPARENT = NO
DOT_MULTI_TARGETS = NO
GENERATE_LEGEND = YES
DOT_CLEANUP = YES
#---------------------------------------------------------------------------
# Options related to the search engine
#---------------------------------------------------------------------------
SEARCHENGINE = YES
mongo-cxx-driver-legacy-1.1.2/etc/lsan.suppressions 0000664 0000000 0000000 00000000000 12732311114 0022355 0 ustar 00root root 0000000 0000000 mongo-cxx-driver-legacy-1.1.2/etc/pick_from_log.pl 0000775 0000000 0000000 00000014227 12732311114 0022113 0 ustar 00root root 0000000 0000000 #!/usr/bin/perl -w
use strict;
use Term::ANSIColor;
use Term::ReadKey;
use List::Util qw( min max );
use Getopt::Long;
my $cxx;
my $mongo;
GetOptions(
'cxx=s' => \$cxx,
'mongo=s' => \$mongo,
'help' => sub { HELP(0); },
) or HELP(1);
$cxx or print "Please enter a path to the mongodb cxx driver repository\n" and HELP(1);
$mongo or print "Please enter a path to the mongodb mongo repository\n" and HELP(1);
my @kept;
my $sha;
my @lines;
my $has_file = 0;
my @decisions;
open FILE, "cd $mongo; git log --stat --oneline --reverse @ARGV |" or die "Couldn't execute git log: $!";
my $total_shas = 0;
while (my $line = ) {
if ($line =~ /^\s/) {
if ($line =~ /^ \d+ files? changed/) {
push @lines, $line;
} else {
my ($path) = ($line =~ /^ (\S+)\s*\|/);
if (! $path) {
die $line;
}
if (-f "$cxx/$path") {
$has_file = 1;
push @lines, color('bold green') . $line . color('reset');
} else {
push @lines, color('bold red') . $line . color('reset');
}
}
} else {
if ($has_file) {
$total_shas++;
$has_file = 0;
push @decisions, [$sha, [@lines]];
}
@lines = ();
($sha) = ($line =~ /^(\S+)/);
push @lines, color('bold yellow') . $line . color('reset');
}
}
close FILE;
if ($has_file) {
$total_shas++;
$has_file = 0;
push @decisions, [$sha, [@lines]];
}
@kept = map { "" } @decisions;
ReadMode 4;
my $seen_shas;
for (my $i = 0; $i < scalar(@decisions); $i++) {
$seen_shas = $i + 1;
eval {
if (! decision($i, @{$decisions[$i]})) {
$i = max(-1, $i - 2);
}
};
if ($@) {
ReadMode 0;
die $@;
}
}
ReadMode 0;
print join('', map { "$_\n" } @kept);
exit 0;
sub debug {
warn @_;
sleep 1;
}
sub decision {
my ($index, $sha, $lines) = @_;
my $offset = 0;
my $y = $kept[$index] ? color('bold green') . 'Y' . color('reset') : 'y';
my $n = $kept[$index] ? 'n' : color('bold red') . 'N' . color('reset');
my $options = < sub {
$kept[$index] = $sha;
return 1;
},
'n' => sub {
$kept[$index] = "";
return 1;
},
'b' => sub {
return 2;
},
's' => sub {
system("cd $mongo; git show $sha");
return 0;
},
'q' => sub {
ReadMode 0;
exit 0;
},
chr(10) => sub {
return 1;
},
chr(32) => sub {
return 1;
},
chr(27) => sub {
my $key = ord(ReadKey(0));
if ($key == 91) {
$key = ord(ReadKey(0));
if ($key == 65) {
$offset--;
} elsif ($key == 66) {
$offset++;
} elsif ($key == 49) {
$key = ord(ReadKey(0));
if ($key == 126) {
$offset = 0;
} else {
debug "pressed 27.91.49." . $key . "\n";
}
} elsif ($key == 52) {
$key = ord(ReadKey(0));
if ($key == 126) {
$offset = scalar(@$lines);
} else {
debug "pressed 27.91.52." . $key . "\n";
}
} elsif ($key == 53) {
$key = ord(ReadKey(0));
if ($key == 126) {
$offset = max(0, $offset - 10);
} else {
debug "pressed 27.91.53." . $key . "\n";
}
} elsif ($key == 54) {
$key = ord(ReadKey(0));
if ($key == 126) {
$offset = min(scalar(@$lines), $offset + 10);
} else {
debug "pressed 27.91.54." . $key . "\n";
}
} else {
debug "pressed 27.91." . $key . "\n";
}
} else {
debug "pressed 27." . $key . "\n";
}
return 0;
},
);
if ($table{$key}) {
my $x = $table{$key}->();
if ($x == 1) {
last;
} elsif ($x == 2) {
return 0;
}
} else {
debug "pressed " . ord($key) . "\n";
}
display($lines, \$offset, $options);
}
return 1;
}
sub display {
my ($lines, $offset, $options) = @_;
print `clear`;
my ($width, $height) = GetTerminalSize();
my $window = $height - (scalar(split /\n/, $options) + 10);
$$offset = max($$offset, 0);
$$offset = min($$offset, max(scalar(@$lines) - $window - 1, 0));
my $min = $$offset;
my $max = min($window + $$offset, scalar(@$lines)-1);
printf("%d% (%d/%d)\n", (100 * $seen_shas / $total_shas), $seen_shas, $total_shas);
print map {
if (length($_) <= $width) {
$_;
} else {
substr($_, 0, $width - 3) . "...\n";
}
} @$lines[$min..$max];
print "\n", $options;
}
sub HELP {
my ($exit) = @_;
my $usage = <>> check_output(["ls", "-l", "/dev/null"])
'crw-rw-rw- 1 root root 1, 3 Oct 18 2007 /dev/null\n'
The stdout argument is not allowed as it is used internally.
To capture standard error in the result, use stderr=STDOUT.
>>> check_output(["/bin/sh", "-c",
... "ls -l non_existent_file ; exit 0"],
... stderr=STDOUT)
'ls: non_existent_file: No such file or directory\n'
"""
if 'stdout' in kwargs:
raise ValueError('stdout argument not allowed, it will be overridden.')
process = subprocess.Popen(stdout=subprocess.PIPE, *popenargs, **kwargs)
output, unused_err = process.communicate()
retcode = process.poll()
if retcode:
cmd = kwargs.get("args")
if cmd is None:
cmd = popenargs[0]
raise CalledProcessError(retcode, cmd, output)
return output
def callo(args):
"""Call a program, and capture its output
"""
return check_output(args)
def get_llvm_url(version, llvm_distro):
"""Get the url to download clang-format from llvm.org
"""
return CLANG_FORMAT_SOURCE_URL_BASE.substitute(
version=version,
llvm_distro=llvm_distro)
def get_tar_path(version, tar_path):
""" Get the path to clang-format in the llvm tarball
"""
return CLANG_FORMAT_SOURCE_TAR_BASE.substitute(
version=version,
tar_path=tar_path)
def extract_clang_format(tar_path):
# Extract just the clang-format binary
# On OSX, we shell out to tar because tarfile doesn't support xz compression
if sys.platform == 'darwin':
subprocess.call(['tar', '-xzf', tar_path, '*clang-format*'])
# Otherwise we use tarfile because some versions of tar don't support wildcards without
# a special flag
else:
tarfp = tarfile.open(tar_path)
for name in tarfp.getnames():
if name.endswith('clang-format'):
tarfp.extract(name)
tarfp.close()
def get_clang_format_from_llvm(llvm_distro, tar_path, dest_file):
"""Download clang-format from llvm.org, unpack the tarball,
and put clang-format in the specified place
"""
# Build URL
url = get_llvm_url(CLANG_FORMAT_VERSION, llvm_distro)
dest_dir = tempfile.gettempdir()
temp_tar_file = os.path.join(dest_dir, "temp.tar.xz")
# Download from LLVM
print("Downloading clang-format %s from %s, saving to %s" % (CLANG_FORMAT_VERSION,
url, temp_tar_file))
urllib.urlretrieve(url, temp_tar_file)
extract_clang_format(temp_tar_file)
# Destination Path
shutil.move(get_tar_path(CLANG_FORMAT_VERSION, tar_path), dest_file)
def get_clang_format_from_linux_cache(dest_file):
"""Get clang-format from mongodb's cache
"""
# Get URL
url = CLANG_FORMAT_HTTP_LINUX_CACHE
dest_dir = tempfile.gettempdir()
temp_tar_file = os.path.join(dest_dir, "temp.tar.xz")
# Download the file
print("Downloading clang-format %s from %s, saving to %s" % (CLANG_FORMAT_VERSION,
url, temp_tar_file))
urllib.urlretrieve(url, temp_tar_file)
extract_clang_format(temp_tar_file)
# Destination Path
shutil.move("llvm/Release/bin/clang-format", dest_file)
class ClangFormat(object):
"""Class encapsulates finding a suitable copy of clang-format,
and linting/formating an individual file
"""
def __init__(self, path, cache_dir):
if os.path.exists('/usr/bin/clang-format-3.6'):
clang_format_progname = 'clang-format-3.6'
else:
clang_format_progname = CLANG_FORMAT_PROGNAME
# Initialize clang-format configuration information
if sys.platform.startswith("linux"):
#"3.6.0/clang+llvm-3.6.0-x86_64-linux-gnu-ubuntu-14.04.tar.xz
self.platform = "linux_x64"
self.llvm_distro = "x86_64-linux-gnu-ubuntu"
self.tar_path = "x86_64-linux-gnu"
elif sys.platform == "win32":
self.platform = "windows_x64"
self.llvm_distro = "windows_x64"
self.tar_path = None
clang_format_progname += ".exe"
elif sys.platform == "darwin":
#"3.6.0/clang+llvm-3.6.0-x86_64-apple-darwin.tar.xz
self.platform = "darwin_x64"
self.llvm_distro = "x86_64-apple-darwin"
self.tar_path = "x86_64-apple-darwin"
self.path = None
# Find Clang-Format now
if path is not None:
if os.path.isfile(path):
self.path = path
else:
print("WARNING: Could not find clang-format %s" % (path))
# Check the envionrment variable
if "MONGO_CLANG_FORMAT" in os.environ:
self.path = os.environ["MONGO_CLANG_FORMAT"]
if self.path and not self._validate_version(warn=True):
self.path = None
# Check the users' PATH environment variable now
if self.path is None:
self.path = spawn.find_executable(clang_format_progname)
if self.path and not self._validate_version(warn=True):
self.path = None
# If Windows, try to grab it from Program Files
if sys.platform == "win32":
win32bin = os.path.join(os.environ["ProgramFiles(x86)"], "LLVM\\bin\\clang-format.exe")
if os.path.exists(win32bin):
self.path = win32bin
# Have not found it yet, download it from the web
if self.path is None:
if not os.path.isdir(cache_dir):
os.makedirs(cache_dir)
self.path = os.path.join(cache_dir, clang_format_progname)
if not os.path.isfile(self.path):
if sys.platform.startswith("linux"):
get_clang_format_from_linux_cache(self.path)
elif sys.platform == "darwin":
get_clang_format_from_llvm(self.llvm_distro, self.tar_path, self.path)
else:
print("ERROR: clang-format.py does not support downloading clang-format " +
" on this platform, please install clang-format " + CLANG_FORMAT_VERSION)
# Validate we have the correct version
self._validate_version()
self.print_lock = threading.Lock()
def _validate_version(self, warn=False):
"""Validate clang-format is the expected version
"""
try:
cf_version = callo([self.path, "--version"])
except CalledProcessError:
cf_version = "clang-format call failed."
if CLANG_FORMAT_VERSION in cf_version:
return True
if warn:
print("WARNING: clang-format found in path, but incorrect version found at " +
self.path + " with version: " + cf_version)
return False
def lint(self, file_name):
"""Check the specified file has the correct format
"""
with open(file_name, 'r') as original_text:
original_file = original_text.read()
# Get formatted file as clang-format would format the file
formatted_file = callo([self.path, "--style=file", file_name])
if original_file != formatted_file:
original_lines = original_file.splitlines()
formatted_lines = formatted_file.splitlines()
result = difflib.unified_diff(original_lines, formatted_lines)
# Take a lock to ensure diffs do not get mixed
with self.print_lock:
print("ERROR: Found diff for " + file_name)
print("To fix formatting errors, run %s --style=file -i %s" %
(self.path, file_name))
for line in result:
print(line.rstrip())
return False
return True
def format(self, file_name):
"""Update the format of the specified file
"""
# Update the file with clang-format
return not subprocess.call([self.path, "--style=file", "-i", file_name])
def parallel_process(items, func):
"""Run a set of work items to completion
"""
try:
cpus = cpu_count()
except NotImplementedError:
cpus = 1
# print("Running across %d cpus" % (cpus))
task_queue = Queue.Queue()
# Use a list so that worker function will capture this variable
pp_event = threading.Event()
pp_result = [True]
pp_lock = threading.Lock()
def worker():
"""Worker thread to process work items in parallel
"""
while not pp_event.is_set():
try:
item = task_queue.get_nowait()
except Queue.Empty:
# if the queue is empty, exit the worker thread
pp_event.set()
return
try:
ret = func(item)
finally:
# Tell the queue we finished with the item
task_queue.task_done()
# Return early if we fail, and signal we are done
if not ret:
with pp_lock:
pp_result[0] = False
pp_event.set()
return
# Enqueue all the work we want to process
for item in items:
task_queue.put(item)
# Process all the work
threads = []
for cpu in range(cpus):
thread = threading.Thread(target=worker)
thread.daemon = True
thread.start()
threads.append(thread)
# Wait for the threads to finish
# Loop with a timeout so that we can process Ctrl-C interrupts
# Note: On Python 2.6 wait always returns None so we check is_set also,
# This works because we only set the event once, and never reset it
while not pp_event.wait(1) and not pp_event.is_set():
time.sleep(1)
for thread in threads:
thread.join()
return pp_result[0]
def get_base_dir():
"""Get the base directory for mongo repo.
This script assumes that it is running in site_scons/buildscripts/, and uses
that to find the base directory.
"""
try:
return subprocess.check_output(['git', 'rev-parse', '--show-toplevel']).rstrip()
except:
# We are not in a valid git directory. Use the script path instead.
return os.path.dirname(os.path.dirname(os.path.dirname(os.path.realpath(__file__))))
def get_repos():
"""Get a list of Repos to check clang-format for
"""
base_dir = get_base_dir()
paths = [base_dir]
return [Repo(p) for p in paths]
class Repo(object):
"""Class encapsulates all knowledge about a git repository, and its metadata
to run clang-format.
"""
def __init__(self, path):
self.path = path
# Get candidate files
self.candidate_files = self._get_candidate_files()
self.root = self._get_root()
def _callgito(self, args):
"""Call git for this repository
"""
# These two flags are the equivalent of -C in newer versions of Git
# but we use these to support versions back to ~1.8
return callo(['git', '--git-dir', os.path.join(self.path, ".git"),
'--work-tree', self.path] + args)
def _get_local_dir(self, path):
"""Get a directory path relative to the git root directory
"""
if os.path.isabs(path):
return os.path.relpath(path, self.root)
return path
def get_candidates(self, candidates):
"""Get the set of candidate files to check by doing an intersection
between the input list, and the list of candidates in the repository
Returns the full path to the file for clang-format to consume.
"""
# NOTE: Files may have an absolute root (i.e. leading /)
if candidates is not None and len(candidates) > 0:
candidates = [self._get_local_dir(f) for f in candidates]
valid_files = list(set(candidates).intersection(self.get_candidate_files()))
else:
valid_files = list(self.get_candidate_files())
# Get the full file name here
valid_files = [os.path.normpath(os.path.join(self.root, f)) for f in valid_files]
return valid_files
def get_root(self):
"""Get the root directory for this repository
"""
return self.root
def _get_root(self):
"""Gets the root directory for this repository from git
"""
gito = self._callgito(['rev-parse', '--show-toplevel'])
return gito.rstrip()
def get_candidate_files(self):
"""Get a list of candidate files
"""
return self._get_candidate_files()
def _get_candidate_files(self):
"""Query git to get a list of all files in the repo to consider for analysis
"""
gito = self._callgito(["ls-files"])
# This allows us to pick all the interesting files
# in the mongo and mongo-enterprise repos
file_list = [line.rstrip()
for line in gito.splitlines() if "src" in line and not "src/third_party" in line]
files_match = re.compile('\\.(h|cpp)$')
file_list = [a for a in file_list if files_match.search(a)]
return file_list
def expand_file_string(glob_pattern):
"""Expand a string that represents a set of files
"""
return [os.path.abspath(f) for f in globstar.iglob(glob_pattern)]
def get_files_to_check(files):
"""Filter the specified list of files to check down to the actual
list of files that need to be checked."""
candidates = []
# Get a list of candidate_files
candidates = [expand_file_string(f) for f in files]
candidates = list(itertools.chain.from_iterable(candidates))
repos = get_repos()
valid_files = list(itertools.chain.from_iterable([r.get_candidates(candidates) for r in repos]))
return valid_files
def get_files_to_check_from_patch(patches):
"""Take a patch file generated by git diff, and scan the patch for a list of files to check.
"""
candidates = []
# Get a list of candidate_files
check = re.compile(r"^diff --git a\/([a-z\/\.\-_0-9]+) b\/[a-z\/\.\-_0-9]+")
lines = []
for patch in patches:
with open(patch, "rb") as infile:
lines += infile.readlines()
candidates = [check.match(line).group(1) for line in lines if check.match(line)]
repos = get_repos()
valid_files = list(itertools.chain.from_iterable([r.get_candidates(candidates) for r in repos]))
return valid_files
def _get_build_dir():
"""Get the location of the scons' build directory in case we need to download clang-format
"""
return os.path.join(get_base_dir(), "build")
def _lint_files(clang_format, files):
"""Lint a list of files with clang-format
"""
clang_format = ClangFormat(clang_format, _get_build_dir())
lint_clean = parallel_process([os.path.abspath(f) for f in files], clang_format.lint)
if not lint_clean:
print("ERROR: Code Style does not match coding style")
sys.exit(1)
def lint_patch(clang_format, infile):
"""Lint patch command entry point
"""
files = get_files_to_check_from_patch(infile)
# Patch may have files that we do not want to check which is fine
if files:
_lint_files(clang_format, files)
def lint(clang_format, glob):
"""Lint files command entry point
"""
files = get_files_to_check(glob)
_lint_files(clang_format, files)
return True
def _format_files(clang_format, files):
"""Format a list of files with clang-format
"""
clang_format = ClangFormat(clang_format, _get_build_dir())
format_clean = parallel_process([os.path.abspath(f) for f in files], clang_format.format)
if not format_clean:
print("ERROR: failed to format files")
sys.exit(1)
def format_func(clang_format, glob):
"""Format files command entry point
"""
files = get_files_to_check(glob)
_format_files(clang_format, files)
def usage():
"""Print usage
"""
print("clang-format.py supports 3 commands [ lint, lint-patch, format ]. Run "
" -? for more information")
def main():
"""Main entry point
"""
if len(sys.argv) > 1:
command = sys.argv[1]
parser = OptionParser()
parser.add_option("-c", "--clang-format", type="string", dest="clang_format")
if command == "lint":
(options, args) = parser.parse_args(args=sys.argv[2:])
lint(options.clang_format, args)
elif command == "lint-patch":
(options, args) = parser.parse_args(args=sys.argv[2:])
lint_patch(options.clang_format, args)
elif command == "format":
(options, args) = parser.parse_args(args=sys.argv[2:])
format_func(options.clang_format, args)
else:
usage()
else:
usage()
if __name__ == "__main__":
main()
mongo-cxx-driver-legacy-1.1.2/site_scons/buildscripts/cpplint.py 0000664 0000000 0000000 00000405365 12732311114 0025100 0 ustar 00root root 0000000 0000000 #!/usr/bin/python
#
# Copyright (c) 2009 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.
# Here are some issues that I've had people identify in my code during reviews,
# that I think are possible to flag automatically in a lint tool. If these were
# caught by lint, it would save time both for myself and that of my reviewers.
# Most likely, some of these are beyond the scope of the current lint framework,
# but I think it is valuable to retain these wish-list items even if they cannot
# be immediately implemented.
#
# Suggestions
# -----------
# - Check for no 'explicit' for multi-arg ctor
# - Check for boolean assign RHS in parens
# - Check for ctor initializer-list colon position and spacing
# - Check that if there's a ctor, there should be a dtor
# - Check accessors that return non-pointer member variables are
# declared const
# - Check accessors that return non-const pointer member vars are
# *not* declared const
# - Check for using public includes for testing
# - Check for spaces between brackets in one-line inline method
# - Check for no assert()
# - Check for spaces surrounding operators
# - Check for 0 in pointer context (should be NULL)
# - Check for 0 in char context (should be '\0')
# - Check for camel-case method name conventions for methods
# that are not simple inline getters and setters
# - Check that base classes have virtual destructors
# put " // namespace" after } that closes a namespace, with
# namespace's name after 'namespace' if it is named.
# - Do not indent namespace contents
# - Avoid inlining non-trivial constructors in header files
# include base/basictypes.h if DISALLOW_EVIL_CONSTRUCTORS is used
# - Check for old-school (void) cast for call-sites of functions
# ignored return value
# - Check gUnit usage of anonymous namespace
# - Check for class declaration order (typedefs, consts, enums,
# ctor(s?), dtor, friend declarations, methods, member vars)
#
"""Does google-lint on c++ files.
The goal of this script is to identify places in the code that *may*
be in non-compliance with google style. It does not attempt to fix
up these problems -- the point is to educate. It does also not
attempt to find all problems, or to ensure that everything it does
find is legitimately a problem.
In particular, we can get very confused by /* and // inside strings!
We do a small hack, which is to ignore //'s with "'s after them on the
same line, but it is far from perfect (in either direction).
"""
import codecs
import getopt
import math # for log
import os
import re
import sre_compile
import string
import sys
import unicodedata
_USAGE = """
Syntax: cpplint.py [--verbose=#] [--output=vs7] [--filter=-x,+y,...]
[--counting=total|toplevel|detailed]
[file] ...
The style guidelines this tries to follow are those in
http://google-styleguide.googlecode.com/svn/trunk/cppguide.xml
Every problem is given a confidence score from 1-5, with 5 meaning we are
certain of the problem, and 1 meaning it could be a legitimate construct.
This will miss some errors, and is not a substitute for a code review.
To suppress false-positive errors of a certain category, add a
'NOLINT(category)' comment to the line. NOLINT or NOLINT(*)
suppresses errors of all categories on that line.
The files passed in will be linted; at least one file must be provided.
Linted extensions are .cc, .cpp, and .h. Other file types will be ignored.
Flags:
output=vs7
By default, the output is formatted to ease emacs parsing. Visual Studio
compatible output (vs7) may also be used. Other formats are unsupported.
verbose=#
Specify a number 0-5 to restrict errors to certain verbosity levels.
filter=-x,+y,...
Specify a comma-separated list of category-filters to apply: only
error messages whose category names pass the filters will be printed.
(Category names are printed with the message and look like
"[whitespace/indent]".) Filters are evaluated left to right.
"-FOO" and "FOO" means "do not print categories that start with FOO".
"+FOO" means "do print categories that start with FOO".
Examples: --filter=-whitespace,+whitespace/braces
--filter=whitespace,runtime/printf,+runtime/printf_format
--filter=-,+build/include_what_you_use
To see a list of all the categories used in cpplint, pass no arg:
--filter=
counting=total|toplevel|detailed
The total number of errors found is always printed. If
'toplevel' is provided, then the count of errors in each of
the top-level categories like 'build' and 'whitespace' will
also be printed. If 'detailed' is provided, then a count
is provided for each category like 'build/class'.
"""
# We categorize each error message we print. Here are the categories.
# We want an explicit list so we can list them all in cpplint --filter=.
# If you add a new error message with a new category, add it to the list
# here! cpplint_unittest.py should tell you if you forget to do this.
# \ used for clearer layout -- pylint: disable-msg=C6013
_ERROR_CATEGORIES = [
'build/class',
'build/deprecated',
'build/endif_comment',
'build/explicit_make_pair',
'build/forward_decl',
'build/header_guard',
'build/include',
'build/include_alpha',
'build/include_order',
'build/include_what_you_use',
'build/namespaces',
'build/printf_format',
'build/storage_class',
'legal/copyright',
'readability/braces',
'readability/casting',
'readability/check',
'readability/constructors',
'readability/fn_size',
'readability/function',
'readability/multiline_comment',
'readability/multiline_string',
'readability/nolint',
'readability/streams',
'readability/todo',
'readability/utf8',
'runtime/arrays',
'runtime/casting',
'runtime/explicit',
'runtime/int',
'runtime/init',
'runtime/invalid_increment',
'runtime/member_string_references',
'runtime/memset',
'runtime/operator',
'runtime/printf',
'runtime/printf_format',
'runtime/references',
'runtime/rtti',
'runtime/sizeof',
'runtime/string',
'runtime/threadsafe_fn',
'runtime/virtual',
'whitespace/blank_line',
'whitespace/braces',
'whitespace/comma',
'whitespace/comments',
'whitespace/end_of_line',
'whitespace/ending_newline',
'whitespace/indent',
'whitespace/labels',
'whitespace/line_length',
'whitespace/newline',
'whitespace/operators',
'whitespace/parens',
'whitespace/semicolon',
'whitespace/tab',
'whitespace/todo'
]
# The default state of the category filter. This is overrided by the --filter=
# flag. By default all errors are on, so only add here categories that should be
# off by default (i.e., categories that must be enabled by the --filter= flags).
# All entries here should start with a '-' or '+', as in the --filter= flag.
_DEFAULT_FILTERS = ['-build/include_alpha']
# We used to check for high-bit characters, but after much discussion we
# decided those were OK, as long as they were in UTF-8 and didn't represent
# hard-coded international strings, which belong in a separate i18n file.
# Headers that we consider STL headers.
_STL_HEADERS = frozenset([
'algobase.h', 'algorithm', 'alloc.h', 'bitset', 'deque', 'exception',
'function.h', 'functional', 'hash_map', 'hash_map.h', 'hash_set',
'hash_set.h', 'iterator', 'list', 'list.h', 'map', 'memory', 'new',
'pair.h', 'pthread_alloc', 'queue', 'set', 'set.h', 'sstream', 'stack',
'stl_alloc.h', 'stl_relops.h', 'type_traits.h',
'utility', 'vector', 'vector.h',
])
# Non-STL C++ system headers.
_CPP_HEADERS = frozenset([
'algo.h', 'builtinbuf.h', 'bvector.h', 'cassert', 'cctype',
'cerrno', 'cfloat', 'ciso646', 'climits', 'clocale', 'cmath',
'complex', 'complex.h', 'csetjmp', 'csignal', 'cstdarg', 'cstddef',
'cstdio', 'cstdlib', 'cstring', 'ctime', 'cwchar', 'cwctype',
'defalloc.h', 'deque.h', 'editbuf.h', 'exception', 'fstream',
'fstream.h', 'hashtable.h', 'heap.h', 'indstream.h', 'iomanip',
'iomanip.h', 'ios', 'iosfwd', 'iostream', 'iostream.h', 'istream',
'istream.h', 'iterator.h', 'limits', 'map.h', 'multimap.h', 'multiset.h',
'numeric', 'ostream', 'ostream.h', 'parsestream.h', 'pfstream.h',
'PlotFile.h', 'procbuf.h', 'pthread_alloc.h', 'rope', 'rope.h',
'ropeimpl.h', 'SFile.h', 'slist', 'slist.h', 'stack.h', 'stdexcept',
'stdiostream.h', 'streambuf.h', 'stream.h', 'strfile.h', 'string',
'strstream', 'strstream.h', 'tempbuf.h', 'tree.h', 'typeinfo', 'valarray',
])
# Assertion macros. These are defined in base/logging.h and
# testing/base/gunit.h. Note that the _M versions need to come first
# for substring matching to work.
_CHECK_MACROS = [
'DCHECK', 'CHECK',
'EXPECT_TRUE_M', 'EXPECT_TRUE',
'ASSERT_TRUE_M', 'ASSERT_TRUE',
'EXPECT_FALSE_M', 'EXPECT_FALSE',
'ASSERT_FALSE_M', 'ASSERT_FALSE',
]
# Replacement macros for CHECK/DCHECK/EXPECT_TRUE/EXPECT_FALSE
_CHECK_REPLACEMENT = dict([(m, {}) for m in _CHECK_MACROS])
for op, replacement in [('==', 'EQ'), ('!=', 'NE'),
('>=', 'GE'), ('>', 'GT'),
('<=', 'LE'), ('<', 'LT')]:
_CHECK_REPLACEMENT['DCHECK'][op] = 'DCHECK_%s' % replacement
_CHECK_REPLACEMENT['CHECK'][op] = 'CHECK_%s' % replacement
_CHECK_REPLACEMENT['EXPECT_TRUE'][op] = 'EXPECT_%s' % replacement
_CHECK_REPLACEMENT['ASSERT_TRUE'][op] = 'ASSERT_%s' % replacement
_CHECK_REPLACEMENT['EXPECT_TRUE_M'][op] = 'EXPECT_%s_M' % replacement
_CHECK_REPLACEMENT['ASSERT_TRUE_M'][op] = 'ASSERT_%s_M' % replacement
for op, inv_replacement in [('==', 'NE'), ('!=', 'EQ'),
('>=', 'LT'), ('>', 'LE'),
('<=', 'GT'), ('<', 'GE')]:
_CHECK_REPLACEMENT['EXPECT_FALSE'][op] = 'EXPECT_%s' % inv_replacement
_CHECK_REPLACEMENT['ASSERT_FALSE'][op] = 'ASSERT_%s' % inv_replacement
_CHECK_REPLACEMENT['EXPECT_FALSE_M'][op] = 'EXPECT_%s_M' % inv_replacement
_CHECK_REPLACEMENT['ASSERT_FALSE_M'][op] = 'ASSERT_%s_M' % inv_replacement
# These constants define types of headers for use with
# _IncludeState.CheckNextIncludeOrder().
_C_SYS_HEADER = 1
_CPP_SYS_HEADER = 2
_LIKELY_MY_HEADER = 3
_POSSIBLE_MY_HEADER = 4
_OTHER_HEADER = 5
_regexp_compile_cache = {}
# Finds occurrences of NOLINT or NOLINT(...).
_RE_SUPPRESSION = re.compile(r'\bNOLINT\b(\([^)]*\))?')
# {str, set(int)}: a map from error categories to sets of linenumbers
# on which those errors are expected and should be suppressed.
_error_suppressions = {}
def ParseNolintSuppressions(filename, raw_line, linenum, error):
"""Updates the global list of error-suppressions.
Parses any NOLINT comments on the current line, updating the global
error_suppressions store. Reports an error if the NOLINT comment
was malformed.
Args:
filename: str, the name of the input file.
raw_line: str, the line of input text, with comments.
linenum: int, the number of the current line.
error: function, an error handler.
"""
# FIXME(adonovan): "NOLINT(" is misparsed as NOLINT(*).
matched = _RE_SUPPRESSION.search(raw_line)
if matched:
category = matched.group(1)
if category in (None, '(*)'): # => "suppress all"
_error_suppressions.setdefault(None, set()).add(linenum)
else:
if category.startswith('(') and category.endswith(')'):
category = category[1:-1]
if category in _ERROR_CATEGORIES:
_error_suppressions.setdefault(category, set()).add(linenum)
else:
error(filename, linenum, 'readability/nolint', 5,
'Unknown NOLINT error category: %s' % category)
def ResetNolintSuppressions():
"Resets the set of NOLINT suppressions to empty."
_error_suppressions.clear()
def IsErrorSuppressedByNolint(category, linenum):
"""Returns true if the specified error category is suppressed on this line.
Consults the global error_suppressions map populated by
ParseNolintSuppressions/ResetNolintSuppressions.
Args:
category: str, the category of the error.
linenum: int, the current line number.
Returns:
bool, True iff the error should be suppressed due to a NOLINT comment.
"""
return (linenum in _error_suppressions.get(category, set()) or
linenum in _error_suppressions.get(None, set()))
def Match(pattern, s):
"""Matches the string with the pattern, caching the compiled regexp."""
# The regexp compilation caching is inlined in both Match and Search for
# performance reasons; factoring it out into a separate function turns out
# to be noticeably expensive.
if not pattern in _regexp_compile_cache:
_regexp_compile_cache[pattern] = sre_compile.compile(pattern)
return _regexp_compile_cache[pattern].match(s)
def Search(pattern, s):
"""Searches the string for the pattern, caching the compiled regexp."""
if not pattern in _regexp_compile_cache:
_regexp_compile_cache[pattern] = sre_compile.compile(pattern)
return _regexp_compile_cache[pattern].search(s)
class _IncludeState(dict):
"""Tracks line numbers for includes, and the order in which includes appear.
As a dict, an _IncludeState object serves as a mapping between include
filename and line number on which that file was included.
Call CheckNextIncludeOrder() once for each header in the file, passing
in the type constants defined above. Calls in an illegal order will
raise an _IncludeError with an appropriate error message.
"""
# self._section will move monotonically through this set. If it ever
# needs to move backwards, CheckNextIncludeOrder will raise an error.
_INITIAL_SECTION = 0
_MY_H_SECTION = 1
_C_SECTION = 2
_CPP_SECTION = 3
_OTHER_H_SECTION = 4
_TYPE_NAMES = {
_C_SYS_HEADER: 'C system header',
_CPP_SYS_HEADER: 'C++ system header',
_LIKELY_MY_HEADER: 'header this file implements',
_POSSIBLE_MY_HEADER: 'header this file may implement',
_OTHER_HEADER: 'other header',
}
_SECTION_NAMES = {
_INITIAL_SECTION: "... nothing. (This can't be an error.)",
_MY_H_SECTION: 'a header this file implements',
_C_SECTION: 'C system header',
_CPP_SECTION: 'C++ system header',
_OTHER_H_SECTION: 'other header',
}
def __init__(self):
dict.__init__(self)
# The name of the current section.
self._section = self._INITIAL_SECTION
# The path of last found header.
self._last_header = ''
def CanonicalizeAlphabeticalOrder(self, header_path):
"""Returns a path canonicalized for alphabetical comparison.
- replaces "-" with "_" so they both cmp the same.
- removes '-inl' since we don't require them to be after the main header.
- lowercase everything, just in case.
Args:
header_path: Path to be canonicalized.
Returns:
Canonicalized path.
"""
return header_path.replace('-inl.h', '.h').replace('-', '_').lower()
def IsInAlphabeticalOrder(self, header_path):
"""Check if a header is in alphabetical order with the previous header.
Args:
header_path: Header to be checked.
Returns:
Returns true if the header is in alphabetical order.
"""
canonical_header = self.CanonicalizeAlphabeticalOrder(header_path)
if self._last_header > canonical_header:
return False
self._last_header = canonical_header
return True
def CheckNextIncludeOrder(self, header_type):
"""Returns a non-empty error message if the next header is out of order.
This function also updates the internal state to be ready to check
the next include.
Args:
header_type: One of the _XXX_HEADER constants defined above.
Returns:
The empty string if the header is in the right order, or an
error message describing what's wrong.
"""
error_message = ('Found %s after %s' %
(self._TYPE_NAMES[header_type],
self._SECTION_NAMES[self._section]))
last_section = self._section
if header_type == _C_SYS_HEADER:
if self._section <= self._C_SECTION:
self._section = self._C_SECTION
else:
self._last_header = ''
return error_message
elif header_type == _CPP_SYS_HEADER:
if self._section <= self._CPP_SECTION:
self._section = self._CPP_SECTION
else:
self._last_header = ''
return error_message
elif header_type == _LIKELY_MY_HEADER:
if self._section <= self._MY_H_SECTION:
self._section = self._MY_H_SECTION
else:
self._section = self._OTHER_H_SECTION
elif header_type == _POSSIBLE_MY_HEADER:
if self._section <= self._MY_H_SECTION:
self._section = self._MY_H_SECTION
else:
# This will always be the fallback because we're not sure
# enough that the header is associated with this file.
self._section = self._OTHER_H_SECTION
else:
assert header_type == _OTHER_HEADER
self._section = self._OTHER_H_SECTION
if last_section != self._section:
self._last_header = ''
return ''
class _CppLintState(object):
"""Maintains module-wide state.."""
def __init__(self):
self.verbose_level = 1 # global setting.
self.error_count = 0 # global count of reported errors
# filters to apply when emitting error messages
self.filters = _DEFAULT_FILTERS[:]
self.counting = 'total' # In what way are we counting errors?
self.errors_by_category = {} # string to int dict storing error counts
# output format:
# "emacs" - format that emacs can parse (default)
# "vs7" - format that Microsoft Visual Studio 7 can parse
self.output_format = 'emacs'
def SetOutputFormat(self, output_format):
"""Sets the output format for errors."""
self.output_format = output_format
def SetVerboseLevel(self, level):
"""Sets the module's verbosity, and returns the previous setting."""
last_verbose_level = self.verbose_level
self.verbose_level = level
return last_verbose_level
def SetCountingStyle(self, counting_style):
"""Sets the module's counting options."""
self.counting = counting_style
def SetFilters(self, filters):
"""Sets the error-message filters.
These filters are applied when deciding whether to emit a given
error message.
Args:
filters: A string of comma-separated filters (eg "+whitespace/indent").
Each filter should start with + or -; else we die.
Raises:
ValueError: The comma-separated filters did not all start with '+' or '-'.
E.g. "-,+whitespace,-whitespace/indent,whitespace/badfilter"
"""
# Default filters always have less priority than the flag ones.
self.filters = _DEFAULT_FILTERS[:]
for filt in filters.split(','):
clean_filt = filt.strip()
if clean_filt:
self.filters.append(clean_filt)
for filt in self.filters:
if not (filt.startswith('+') or filt.startswith('-')):
raise ValueError('Every filter in --filters must start with + or -'
' (%s does not)' % filt)
def ResetErrorCounts(self):
"""Sets the module's error statistic back to zero."""
self.error_count = 0
self.errors_by_category = {}
def IncrementErrorCount(self, category):
"""Bumps the module's error statistic."""
self.error_count += 1
if self.counting in ('toplevel', 'detailed'):
if self.counting != 'detailed':
category = category.split('/')[0]
if category not in self.errors_by_category:
self.errors_by_category[category] = 0
self.errors_by_category[category] += 1
def PrintErrorCounts(self):
"""Print a summary of errors by category, and the total."""
for category, count in self.errors_by_category.iteritems():
sys.stderr.write('Category \'%s\' errors found: %d\n' %
(category, count))
sys.stderr.write('Total errors found: %d\n' % self.error_count)
_cpplint_state = _CppLintState()
def _OutputFormat():
"""Gets the module's output format."""
return _cpplint_state.output_format
def _SetOutputFormat(output_format):
"""Sets the module's output format."""
_cpplint_state.SetOutputFormat(output_format)
def _VerboseLevel():
"""Returns the module's verbosity setting."""
return _cpplint_state.verbose_level
def _SetVerboseLevel(level):
"""Sets the module's verbosity, and returns the previous setting."""
return _cpplint_state.SetVerboseLevel(level)
def _SetCountingStyle(level):
"""Sets the module's counting options."""
_cpplint_state.SetCountingStyle(level)
def _Filters():
"""Returns the module's list of output filters, as a list."""
return _cpplint_state.filters
def _SetFilters(filters):
"""Sets the module's error-message filters.
These filters are applied when deciding whether to emit a given
error message.
Args:
filters: A string of comma-separated filters (eg "whitespace/indent").
Each filter should start with + or -; else we die.
"""
_cpplint_state.SetFilters(filters)
class _FunctionState(object):
"""Tracks current function name and the number of lines in its body."""
_NORMAL_TRIGGER = 250 # for --v=0, 500 for --v=1, etc.
_TEST_TRIGGER = 400 # about 50% more than _NORMAL_TRIGGER.
def __init__(self):
self.in_a_function = False
self.lines_in_function = 0
self.current_function = ''
def Begin(self, function_name):
"""Start analyzing function body.
Args:
function_name: The name of the function being tracked.
"""
self.in_a_function = True
self.lines_in_function = 0
self.current_function = function_name
def Count(self):
"""Count line in current function body."""
if self.in_a_function:
self.lines_in_function += 1
def Check(self, error, filename, linenum):
"""Report if too many lines in function body.
Args:
error: The function to call with any errors found.
filename: The name of the current file.
linenum: The number of the line to check.
"""
if Match(r'T(EST|est)', self.current_function):
base_trigger = self._TEST_TRIGGER
else:
base_trigger = self._NORMAL_TRIGGER
trigger = base_trigger * 2**_VerboseLevel()
if self.lines_in_function > trigger:
error_level = int(math.log(self.lines_in_function / base_trigger, 2))
# 50 => 0, 100 => 1, 200 => 2, 400 => 3, 800 => 4, 1600 => 5, ...
if error_level > 5:
error_level = 5
error(filename, linenum, 'readability/fn_size', error_level,
'Small and focused functions are preferred:'
' %s has %d non-comment lines'
' (error triggered by exceeding %d lines).' % (
self.current_function, self.lines_in_function, trigger))
def End(self):
"""Stop analyzing function body."""
self.in_a_function = False
class _IncludeError(Exception):
"""Indicates a problem with the include order in a file."""
pass
class FileInfo:
"""Provides utility functions for filenames.
FileInfo provides easy access to the components of a file's path
relative to the project root.
"""
def __init__(self, filename):
self._filename = filename
def FullName(self):
"""Make Windows paths like Unix."""
return os.path.abspath(self._filename).replace('\\', '/')
def RepositoryName(self):
"""FullName after removing the local path to the repository.
If we have a real absolute path name here we can try to do something smart:
detecting the root of the checkout and truncating /path/to/checkout from
the name so that we get header guards that don't include things like
"C:\Documents and Settings\..." or "/home/username/..." in them and thus
people on different computers who have checked the source out to different
locations won't see bogus errors.
"""
fullname = self.FullName()
if os.path.exists(fullname):
project_dir = os.path.dirname(fullname)
if os.path.exists(os.path.join(project_dir, ".svn")):
# If there's a .svn file in the current directory, we recursively look
# up the directory tree for the top of the SVN checkout
root_dir = project_dir
one_up_dir = os.path.dirname(root_dir)
while os.path.exists(os.path.join(one_up_dir, ".svn")):
root_dir = os.path.dirname(root_dir)
one_up_dir = os.path.dirname(one_up_dir)
prefix = os.path.commonprefix([root_dir, project_dir])
return fullname[len(prefix) + 1:]
# Not SVN <= 1.6? Try to find a git, hg, or svn top level directory by
# searching up from the current path.
root_dir = os.path.dirname(fullname)
while (root_dir != os.path.dirname(root_dir) and
not os.path.exists(os.path.join(root_dir, ".git")) and
not os.path.exists(os.path.join(root_dir, ".hg")) and
not os.path.exists(os.path.join(root_dir, ".svn"))):
root_dir = os.path.dirname(root_dir)
if (os.path.exists(os.path.join(root_dir, ".git")) or
os.path.exists(os.path.join(root_dir, ".hg")) or
os.path.exists(os.path.join(root_dir, ".svn"))):
prefix = os.path.commonprefix([root_dir, project_dir])
return fullname[len(prefix) + 1:]
# Don't know what to do; header guard warnings may be wrong...
return fullname
def Split(self):
"""Splits the file into the directory, basename, and extension.
For 'chrome/browser/browser.cc', Split() would
return ('chrome/browser', 'browser', '.cc')
Returns:
A tuple of (directory, basename, extension).
"""
googlename = self.RepositoryName()
project, rest = os.path.split(googlename)
return (project,) + os.path.splitext(rest)
def BaseName(self):
"""File base name - text after the final slash, before the final period."""
return self.Split()[1]
def Extension(self):
"""File extension - text following the final period."""
return self.Split()[2]
def NoExtension(self):
"""File has no source file extension."""
return '/'.join(self.Split()[0:2])
def IsSource(self):
"""File has a source file extension."""
return self.Extension()[1:] in ('c', 'cc', 'cpp', 'cxx')
def _ShouldPrintError(category, confidence, linenum):
"""If confidence >= verbose, category passes filter and is not suppressed."""
# There are three ways we might decide not to print an error message:
# a "NOLINT(category)" comment appears in the source,
# the verbosity level isn't high enough, or the filters filter it out.
if IsErrorSuppressedByNolint(category, linenum):
return False
if confidence < _cpplint_state.verbose_level:
return False
is_filtered = False
for one_filter in _Filters():
if one_filter.startswith('-'):
if category.startswith(one_filter[1:]):
is_filtered = True
elif one_filter.startswith('+'):
if category.startswith(one_filter[1:]):
is_filtered = False
else:
assert False # should have been checked for in SetFilter.
if is_filtered:
return False
return True
def Error(filename, linenum, category, confidence, message):
"""Logs the fact we've found a lint error.
We log where the error was found, and also our confidence in the error,
that is, how certain we are this is a legitimate style regression, and
not a misidentification or a use that's sometimes justified.
False positives can be suppressed by the use of
"cpplint(category)" comments on the offending line. These are
parsed into _error_suppressions.
Args:
filename: The name of the file containing the error.
linenum: The number of the line containing the error.
category: A string used to describe the "category" this bug
falls under: "whitespace", say, or "runtime". Categories
may have a hierarchy separated by slashes: "whitespace/indent".
confidence: A number from 1-5 representing a confidence score for
the error, with 5 meaning that we are certain of the problem,
and 1 meaning that it could be a legitimate construct.
message: The error message.
"""
if _ShouldPrintError(category, confidence, linenum):
_cpplint_state.IncrementErrorCount(category)
if _cpplint_state.output_format == 'vs7':
sys.stderr.write('%s(%s): %s [%s] [%d]\n' % (
filename, linenum, message, category, confidence))
else:
sys.stderr.write('%s:%s: %s [%s] [%d]\n' % (
filename, linenum, message, category, confidence))
# Matches standard C++ escape esequences per 2.13.2.3 of the C++ standard.
_RE_PATTERN_CLEANSE_LINE_ESCAPES = re.compile(
r'\\([abfnrtv?"\\\']|\d+|x[0-9a-fA-F]+)')
# Matches strings. Escape codes should already be removed by ESCAPES.
_RE_PATTERN_CLEANSE_LINE_DOUBLE_QUOTES = re.compile(r'"[^"]*"')
# Matches characters. Escape codes should already be removed by ESCAPES.
_RE_PATTERN_CLEANSE_LINE_SINGLE_QUOTES = re.compile(r"'.'")
# Matches multi-line C++ comments.
# This RE is a little bit more complicated than one might expect, because we
# have to take care of space removals tools so we can handle comments inside
# statements better.
# The current rule is: We only clear spaces from both sides when we're at the
# end of the line. Otherwise, we try to remove spaces from the right side,
# if this doesn't work we try on left side but only if there's a non-character
# on the right.
_RE_PATTERN_CLEANSE_LINE_C_COMMENTS = re.compile(
r"""(\s*/\*.*\*/\s*$|
/\*.*\*/\s+|
\s+/\*.*\*/(?=\W)|
/\*.*\*/)""", re.VERBOSE)
def IsCppString(line):
"""Does line terminate so, that the next symbol is in string constant.
This function does not consider single-line nor multi-line comments.
Args:
line: is a partial line of code starting from the 0..n.
Returns:
True, if next character appended to 'line' is inside a
string constant.
"""
line = line.replace(r'\\', 'XX') # after this, \\" does not match to \"
return ((line.count('"') - line.count(r'\"') - line.count("'\"'")) & 1) == 1
def FindNextMultiLineCommentStart(lines, lineix):
"""Find the beginning marker for a multiline comment."""
while lineix < len(lines):
if lines[lineix].strip().startswith('/*'):
# Only return this marker if the comment goes beyond this line
if lines[lineix].strip().find('*/', 2) < 0:
return lineix
lineix += 1
return len(lines)
def FindNextMultiLineCommentEnd(lines, lineix):
"""We are inside a comment, find the end marker."""
while lineix < len(lines):
if lines[lineix].strip().endswith('*/'):
return lineix
lineix += 1
return len(lines)
def RemoveMultiLineCommentsFromRange(lines, begin, end):
"""Clears a range of lines for multi-line comments."""
# Having // dummy comments makes the lines non-empty, so we will not get
# unnecessary blank line warnings later in the code.
for i in range(begin, end):
lines[i] = '// dummy'
def RemoveMultiLineComments(filename, lines, error):
"""Removes multiline (c-style) comments from lines."""
lineix = 0
while lineix < len(lines):
lineix_begin = FindNextMultiLineCommentStart(lines, lineix)
if lineix_begin >= len(lines):
return
lineix_end = FindNextMultiLineCommentEnd(lines, lineix_begin)
if lineix_end >= len(lines):
error(filename, lineix_begin + 1, 'readability/multiline_comment', 5,
'Could not find end of multi-line comment')
return
RemoveMultiLineCommentsFromRange(lines, lineix_begin, lineix_end + 1)
lineix = lineix_end + 1
def CleanseComments(line):
"""Removes //-comments and single-line C-style /* */ comments.
Args:
line: A line of C++ source.
Returns:
The line with single-line comments removed.
"""
commentpos = line.find('//')
if commentpos != -1 and not IsCppString(line[:commentpos]):
line = line[:commentpos].rstrip()
# get rid of /* ... */
return _RE_PATTERN_CLEANSE_LINE_C_COMMENTS.sub('', line)
class CleansedLines(object):
"""Holds 3 copies of all lines with different preprocessing applied to them.
1) elided member contains lines without strings and comments,
2) lines member contains lines without comments, and
3) raw member contains all the lines without processing.
All these three members are of , and of the same length.
"""
def __init__(self, lines):
self.elided = []
self.lines = []
self.raw_lines = lines
self.num_lines = len(lines)
for linenum in range(len(lines)):
self.lines.append(CleanseComments(lines[linenum]))
elided = self._CollapseStrings(lines[linenum])
self.elided.append(CleanseComments(elided))
def NumLines(self):
"""Returns the number of lines represented."""
return self.num_lines
@staticmethod
def _CollapseStrings(elided):
"""Collapses strings and chars on a line to simple "" or '' blocks.
We nix strings first so we're not fooled by text like '"http://"'
Args:
elided: The line being processed.
Returns:
The line with collapsed strings.
"""
if not _RE_PATTERN_INCLUDE.match(elided):
# Remove escaped characters first to make quote/single quote collapsing
# basic. Things that look like escaped characters shouldn't occur
# outside of strings and chars.
elided = _RE_PATTERN_CLEANSE_LINE_ESCAPES.sub('', elided)
elided = _RE_PATTERN_CLEANSE_LINE_SINGLE_QUOTES.sub("''", elided)
elided = _RE_PATTERN_CLEANSE_LINE_DOUBLE_QUOTES.sub('""', elided)
return elided
def CloseExpression(clean_lines, linenum, pos):
"""If input points to ( or { or [, finds the position that closes it.
If lines[linenum][pos] points to a '(' or '{' or '[', finds the
linenum/pos that correspond to the closing of the expression.
Args:
clean_lines: A CleansedLines instance containing the file.
linenum: The number of the line to check.
pos: A position on the line.
Returns:
A tuple (line, linenum, pos) pointer *past* the closing brace, or
(line, len(lines), -1) if we never find a close. Note we ignore
strings and comments when matching; and the line we return is the
'cleansed' line at linenum.
"""
line = clean_lines.elided[linenum]
startchar = line[pos]
if startchar not in '({[':
return (line, clean_lines.NumLines(), -1)
if startchar == '(': endchar = ')'
if startchar == '[': endchar = ']'
if startchar == '{': endchar = '}'
num_open = line.count(startchar) - line.count(endchar)
while linenum < clean_lines.NumLines() and num_open > 0:
linenum += 1
line = clean_lines.elided[linenum]
num_open += line.count(startchar) - line.count(endchar)
# OK, now find the endchar that actually got us back to even
endpos = len(line)
while num_open >= 0:
endpos = line.rfind(')', 0, endpos)
num_open -= 1 # chopped off another )
return (line, linenum, endpos + 1)
def CheckForCopyright(filename, lines, error):
"""Logs an error if no Copyright message appears at the top of the file."""
# We'll say it should occur by line 10. Don't forget there's a
# dummy line at the front.
for line in xrange(1, min(len(lines), 11)):
if re.search(r'Copyright', lines[line], re.I): break
else: # means no copyright line was found
error(filename, 0, 'legal/copyright', 5,
'No copyright message found. '
'You should have a line: "Copyright [year] "')
def GetHeaderGuardCPPVariable(filename):
"""Returns the CPP variable that should be used as a header guard.
Args:
filename: The name of a C++ header file.
Returns:
The CPP variable that should be used as a header guard in the
named file.
"""
# Restores original filename in case that cpplint is invoked from Emacs's
# flymake.
filename = re.sub(r'_flymake\.h$', '.h', filename)
fileinfo = FileInfo(filename)
return re.sub(r'[-./\s]', '_', fileinfo.RepositoryName()).upper() + '_'
def CheckForHeaderGuard(filename, lines, error):
"""Checks that the file contains a header guard.
Logs an error if no #ifndef header guard is present. For other
headers, checks that the full pathname is used.
Args:
filename: The name of the C++ header file.
lines: An array of strings, each representing a line of the file.
error: The function to call with any errors found.
"""
cppvar = GetHeaderGuardCPPVariable(filename)
ifndef = None
ifndef_linenum = 0
define = None
endif = None
endif_linenum = 0
for linenum, line in enumerate(lines):
linesplit = line.split()
if len(linesplit) >= 2:
# find the first occurrence of #ifndef and #define, save arg
if not ifndef and linesplit[0] == '#ifndef':
# set ifndef to the header guard presented on the #ifndef line.
ifndef = linesplit[1]
ifndef_linenum = linenum
if not define and linesplit[0] == '#define':
define = linesplit[1]
# find the last occurrence of #endif, save entire line
if line.startswith('#endif'):
endif = line
endif_linenum = linenum
if not ifndef:
error(filename, 0, 'build/header_guard', 5,
'No #ifndef header guard found, suggested CPP variable is: %s' %
cppvar)
return
if not define:
error(filename, 0, 'build/header_guard', 5,
'No #define header guard found, suggested CPP variable is: %s' %
cppvar)
return
# The guard should be PATH_FILE_H_, but we also allow PATH_FILE_H__
# for backward compatibility.
if ifndef != cppvar:
error_level = 0
if ifndef != cppvar + '_':
error_level = 5
ParseNolintSuppressions(filename, lines[ifndef_linenum], ifndef_linenum,
error)
error(filename, ifndef_linenum, 'build/header_guard', error_level,
'#ifndef header guard has wrong style, please use: %s' % cppvar)
if define != ifndef:
error(filename, 0, 'build/header_guard', 5,
'#ifndef and #define don\'t match, suggested CPP variable is: %s' %
cppvar)
return
if endif != ('#endif // %s' % cppvar):
error_level = 0
if endif != ('#endif // %s' % (cppvar + '_')):
error_level = 5
ParseNolintSuppressions(filename, lines[endif_linenum], endif_linenum,
error)
error(filename, endif_linenum, 'build/header_guard', error_level,
'#endif line should be "#endif // %s"' % cppvar)
def CheckForUnicodeReplacementCharacters(filename, lines, error):
"""Logs an error for each line containing Unicode replacement characters.
These indicate that either the file contained invalid UTF-8 (likely)
or Unicode replacement characters (which it shouldn't). Note that
it's possible for this to throw off line numbering if the invalid
UTF-8 occurred adjacent to a newline.
Args:
filename: The name of the current file.
lines: An array of strings, each representing a line of the file.
error: The function to call with any errors found.
"""
for linenum, line in enumerate(lines):
if u'\ufffd' in line:
error(filename, linenum, 'readability/utf8', 5,
'Line contains invalid UTF-8 (or Unicode replacement character).')
def CheckForNewlineAtEOF(filename, lines, error):
"""Logs an error if there is no newline char at the end of the file.
Args:
filename: The name of the current file.
lines: An array of strings, each representing a line of the file.
error: The function to call with any errors found.
"""
# The array lines() was created by adding two newlines to the
# original file (go figure), then splitting on \n.
# To verify that the file ends in \n, we just have to make sure the
# last-but-two element of lines() exists and is empty.
if len(lines) < 3 or lines[-2]:
error(filename, len(lines) - 2, 'whitespace/ending_newline', 5,
'Could not find a newline character at the end of the file.')
def CheckForMultilineCommentsAndStrings(filename, clean_lines, linenum, error):
"""Logs an error if we see /* ... */ or "..." that extend past one line.
/* ... */ comments are legit inside macros, for one line.
Otherwise, we prefer // comments, so it's ok to warn about the
other. Likewise, it's ok for strings to extend across multiple
lines, as long as a line continuation character (backslash)
terminates each line. Although not currently prohibited by the C++
style guide, it's ugly and unnecessary. We don't do well with either
in this lint program, so we warn about both.
Args:
filename: The name of the current file.
clean_lines: A CleansedLines instance containing the file.
linenum: The number of the line to check.
error: The function to call with any errors found.
"""
line = clean_lines.elided[linenum]
# Remove all \\ (escaped backslashes) from the line. They are OK, and the
# second (escaped) slash may trigger later \" detection erroneously.
line = line.replace('\\\\', '')
if line.count('/*') > line.count('*/'):
error(filename, linenum, 'readability/multiline_comment', 5,
'Complex multi-line /*...*/-style comment found. '
'Lint may give bogus warnings. '
'Consider replacing these with //-style comments, '
'with #if 0...#endif, '
'or with more clearly structured multi-line comments.')
if (line.count('"') - line.count('\\"')) % 2:
error(filename, linenum, 'readability/multiline_string', 5,
'Multi-line string ("...") found. This lint script doesn\'t '
'do well with such strings, and may give bogus warnings. They\'re '
'ugly and unnecessary, and you should use concatenation instead".')
threading_list = (
('asctime(', 'asctime_r('),
('ctime(', 'ctime_r('),
('getgrgid(', 'getgrgid_r('),
('getgrnam(', 'getgrnam_r('),
('getlogin(', 'getlogin_r('),
('getpwnam(', 'getpwnam_r('),
('getpwuid(', 'getpwuid_r('),
('gmtime(', 'gmtime_r('),
('localtime(', 'localtime_r('),
('rand(', 'rand_r('),
('readdir(', 'readdir_r('),
('strtok(', 'strtok_r('),
('ttyname(', 'ttyname_r('),
)
def CheckPosixThreading(filename, clean_lines, linenum, error):
"""Checks for calls to thread-unsafe functions.
Much code has been originally written without consideration of
multi-threading. Also, engineers are relying on their old experience;
they have learned posix before threading extensions were added. These
tests guide the engineers to use thread-safe functions (when using
posix directly).
Args:
filename: The name of the current file.
clean_lines: A CleansedLines instance containing the file.
linenum: The number of the line to check.
error: The function to call with any errors found.
"""
line = clean_lines.elided[linenum]
for single_thread_function, multithread_safe_function in threading_list:
ix = line.find(single_thread_function)
# Comparisons made explicit for clarity -- pylint: disable-msg=C6403
if ix >= 0 and (ix == 0 or (not line[ix - 1].isalnum() and
line[ix - 1] not in ('_', '.', '>'))):
error(filename, linenum, 'runtime/threadsafe_fn', 2,
'Consider using ' + multithread_safe_function +
'...) instead of ' + single_thread_function +
'...) for improved thread safety.')
# Matches invalid increment: *count++, which moves pointer instead of
# incrementing a value.
_RE_PATTERN_INVALID_INCREMENT = re.compile(
r'^\s*\*\w+(\+\+|--);')
def CheckInvalidIncrement(filename, clean_lines, linenum, error):
"""Checks for invalid increment *count++.
For example following function:
void increment_counter(int* count) {
*count++;
}
is invalid, because it effectively does count++, moving pointer, and should
be replaced with ++*count, (*count)++ or *count += 1.
Args:
filename: The name of the current file.
clean_lines: A CleansedLines instance containing the file.
linenum: The number of the line to check.
error: The function to call with any errors found.
"""
line = clean_lines.elided[linenum]
if _RE_PATTERN_INVALID_INCREMENT.match(line):
error(filename, linenum, 'runtime/invalid_increment', 5,
'Changing pointer instead of value (or unused value of operator*).')
class _ClassInfo(object):
"""Stores information about a class."""
def __init__(self, name, clean_lines, linenum):
self.name = name
self.linenum = linenum
self.seen_open_brace = False
self.is_derived = False
self.virtual_method_linenumber = None
self.has_virtual_destructor = False
self.brace_depth = 0
# Try to find the end of the class. This will be confused by things like:
# class A {
# } *x = { ...
#
# But it's still good enough for CheckSectionSpacing.
self.last_line = 0
depth = 0
for i in range(linenum, clean_lines.NumLines()):
line = clean_lines.lines[i]
depth += line.count('{') - line.count('}')
if not depth:
self.last_line = i
break
class _ClassState(object):
"""Holds the current state of the parse relating to class declarations.
It maintains a stack of _ClassInfos representing the parser's guess
as to the current nesting of class declarations. The innermost class
is at the top (back) of the stack. Typically, the stack will either
be empty or have exactly one entry.
"""
def __init__(self):
self.classinfo_stack = []
def CheckFinished(self, filename, error):
"""Checks that all classes have been completely parsed.
Call this when all lines in a file have been processed.
Args:
filename: The name of the current file.
error: The function to call with any errors found.
"""
if self.classinfo_stack:
# Note: This test can result in false positives if #ifdef constructs
# get in the way of brace matching. See the testBuildClass test in
# cpplint_unittest.py for an example of this.
error(filename, self.classinfo_stack[0].linenum, 'build/class', 5,
'Failed to find complete declaration of class %s' %
self.classinfo_stack[0].name)
def CheckForNonStandardConstructs(filename, clean_lines, linenum,
class_state, error):
"""Logs an error if we see certain non-ANSI constructs ignored by gcc-2.
Complain about several constructs which gcc-2 accepts, but which are
not standard C++. Warning about these in lint is one way to ease the
transition to new compilers.
- put storage class first (e.g. "static const" instead of "const static").
- "%lld" instead of %qd" in printf-type functions.
- "%1$d" is non-standard in printf-type functions.
- "\%" is an undefined character escape sequence.
- text after #endif is not allowed.
- invalid inner-style forward declaration.
- >? and ?= and )\?=?\s*(\w+|[+-]?\d+)(\.\d*)?',
line):
error(filename, linenum, 'build/deprecated', 3,
'>? and ))?'
# r'\s*const\s*' + type_name + '\s*&\s*\w+\s*;'
error(filename, linenum, 'runtime/member_string_references', 2,
'const string& members are dangerous. It is much better to use '
'alternatives, such as pointers or simple constants.')
# Track class entry and exit, and attempt to find cases within the
# class declaration that don't meet the C++ style
# guidelines. Tracking is very dependent on the code matching Google
# style guidelines, but it seems to perform well enough in testing
# to be a worthwhile addition to the checks.
classinfo_stack = class_state.classinfo_stack
# Look for a class declaration. The regexp accounts for decorated classes
# such as in:
# class LOCKABLE API Object {
# };
class_decl_match = Match(
r'\s*(template\s*<[\w\s<>,:]*>\s*)?'
'(class|struct)\s+([A-Z_]+\s+)*(\w+(::\w+)*)', line)
if class_decl_match:
classinfo_stack.append(_ClassInfo(
class_decl_match.group(4), clean_lines, linenum))
# Everything else in this function uses the top of the stack if it's
# not empty.
if not classinfo_stack:
return
classinfo = classinfo_stack[-1]
# If the opening brace hasn't been seen look for it and also
# parent class declarations.
if not classinfo.seen_open_brace:
# If the line has a ';' in it, assume it's a forward declaration or
# a single-line class declaration, which we won't process.
if line.find(';') != -1:
classinfo_stack.pop()
return
classinfo.seen_open_brace = (line.find('{') != -1)
# Look for a bare ':'
if Search('(^|[^:]):($|[^:])', line):
classinfo.is_derived = True
if not classinfo.seen_open_brace:
return # Everything else in this function is for after open brace
# The class may have been declared with namespace or classname qualifiers.
# The constructor and destructor will not have those qualifiers.
base_classname = classinfo.name.split('::')[-1]
# Look for single-argument constructors that aren't marked explicit.
# Technically a valid construct, but against style.
args = Match(r'\s+(?:inline\s+)?%s\s*\(([^,()]+)\)'
% re.escape(base_classname),
line)
if (args and
args.group(1) != 'void' and
not Match(r'(const\s+)?%s\s*(?:<\w+>\s*)?&' % re.escape(base_classname),
args.group(1).strip())):
error(filename, linenum, 'runtime/explicit', 5,
'Single-argument constructors should be marked explicit.')
# Look for methods declared virtual.
if Search(r'\bvirtual\b', line):
classinfo.virtual_method_linenumber = linenum
# Only look for a destructor declaration on the same line. It would
# be extremely unlikely for the destructor declaration to occupy
# more than one line.
if Search(r'~%s\s*\(' % base_classname, line):
classinfo.has_virtual_destructor = True
# Look for class end.
brace_depth = classinfo.brace_depth
brace_depth = brace_depth + line.count('{') - line.count('}')
if brace_depth <= 0:
classinfo = classinfo_stack.pop()
# Try to detect missing virtual destructor declarations.
# For now, only warn if a non-derived class with virtual methods lacks
# a virtual destructor. This is to make it less likely that people will
# declare derived virtual destructors without declaring the base
# destructor virtual.
if ((classinfo.virtual_method_linenumber is not None) and
(not classinfo.has_virtual_destructor) and
(not classinfo.is_derived)): # Only warn for base classes
error(filename, classinfo.linenum, 'runtime/virtual', 4,
'The class %s probably needs a virtual destructor due to '
'having virtual method(s), one declared at line %d.'
% (classinfo.name, classinfo.virtual_method_linenumber))
else:
classinfo.brace_depth = brace_depth
def CheckSpacingForFunctionCall(filename, line, linenum, error):
"""Checks for the correctness of various spacing around function calls.
Args:
filename: The name of the current file.
line: The text of the line to check.
linenum: The number of the line to check.
error: The function to call with any errors found.
"""
# Since function calls often occur inside if/for/while/switch
# expressions - which have their own, more liberal conventions - we
# first see if we should be looking inside such an expression for a
# function call, to which we can apply more strict standards.
fncall = line # if there's no control flow construct, look at whole line
for pattern in (r'\bif\s*\((.*)\)\s*{',
r'\bfor\s*\((.*)\)\s*{',
r'\bwhile\s*\((.*)\)\s*[{;]',
r'\bswitch\s*\((.*)\)\s*{'):
match = Search(pattern, line)
if match:
fncall = match.group(1) # look inside the parens for function calls
break
# Except in if/for/while/switch, there should never be space
# immediately inside parens (eg "f( 3, 4 )"). We make an exception
# for nested parens ( (a+b) + c ). Likewise, there should never be
# a space before a ( when it's a function argument. I assume it's a
# function argument when the char before the whitespace is legal in
# a function name (alnum + _) and we're not starting a macro. Also ignore
# pointers and references to arrays and functions coz they're too tricky:
# we use a very simple way to recognize these:
# " (something)(maybe-something)" or
# " (something)(maybe-something," or
# " (something)[something]"
# Note that we assume the contents of [] to be short enough that
# they'll never need to wrap.
if ( # Ignore control structures.
not Search(r'\b(if|for|while|switch|return|delete)\b', fncall) and
# Ignore pointers/references to functions.
not Search(r' \([^)]+\)\([^)]*(\)|,$)', fncall) and
# Ignore pointers/references to arrays.
not Search(r' \([^)]+\)\[[^\]]+\]', fncall)):
if Search(r'\w\s*\(\s(?!\s*\\$)', fncall): # a ( used for a fn call
error(filename, linenum, 'whitespace/parens', 4,
'Extra space after ( in function call')
elif Search(r'\(\s+(?!(\s*\\)|\()', fncall):
error(filename, linenum, 'whitespace/parens', 2,
'Extra space after (')
if (Search(r'\w\s+\(', fncall) and
not Search(r'#\s*define|typedef', fncall)):
error(filename, linenum, 'whitespace/parens', 4,
'Extra space before ( in function call')
# If the ) is followed only by a newline or a { + newline, assume it's
# part of a control statement (if/while/etc), and don't complain
if Search(r'[^)]\s+\)\s*[^{\s]', fncall):
# If the closing parenthesis is preceded by only whitespaces,
# try to give a more descriptive error message.
if Search(r'^\s+\)', fncall):
error(filename, linenum, 'whitespace/parens', 2,
'Closing ) should be moved to the previous line')
else:
error(filename, linenum, 'whitespace/parens', 2,
'Extra space before )')
def IsBlankLine(line):
"""Returns true if the given line is blank.
We consider a line to be blank if the line is empty or consists of
only white spaces.
Args:
line: A line of a string.
Returns:
True, if the given line is blank.
"""
return not line or line.isspace()
def CheckForFunctionLengths(filename, clean_lines, linenum,
function_state, error):
"""Reports for long function bodies.
For an overview why this is done, see:
http://google-styleguide.googlecode.com/svn/trunk/cppguide.xml#Write_Short_Functions
Uses a simplistic algorithm assuming other style guidelines
(especially spacing) are followed.
Only checks unindented functions, so class members are unchecked.
Trivial bodies are unchecked, so constructors with huge initializer lists
may be missed.
Blank/comment lines are not counted so as to avoid encouraging the removal
of vertical space and comments just to get through a lint check.
NOLINT *on the last line of a function* disables this check.
Args:
filename: The name of the current file.
clean_lines: A CleansedLines instance containing the file.
linenum: The number of the line to check.
function_state: Current function name and lines in body so far.
error: The function to call with any errors found.
"""
lines = clean_lines.lines
line = lines[linenum]
raw = clean_lines.raw_lines
raw_line = raw[linenum]
joined_line = ''
starting_func = False
regexp = r'(\w(\w|::|\*|\&|\s)*)\(' # decls * & space::name( ...
match_result = Match(regexp, line)
if match_result:
# If the name is all caps and underscores, figure it's a macro and
# ignore it, unless it's TEST or TEST_F.
function_name = match_result.group(1).split()[-1]
if function_name == 'TEST' or function_name == 'TEST_F' or (
not Match(r'[A-Z_]+$', function_name)):
starting_func = True
if starting_func:
body_found = False
for start_linenum in xrange(linenum, clean_lines.NumLines()):
start_line = lines[start_linenum]
joined_line += ' ' + start_line.lstrip()
if Search(r'(;|})', start_line): # Declarations and trivial functions
body_found = True
break # ... ignore
elif Search(r'{', start_line):
body_found = True
function = Search(r'((\w|:)*)\(', line).group(1)
if Match(r'TEST', function): # Handle TEST... macros
parameter_regexp = Search(r'(\(.*\))', joined_line)
if parameter_regexp: # Ignore bad syntax
function += parameter_regexp.group(1)
else:
function += '()'
function_state.Begin(function)
break
if not body_found:
# No body for the function (or evidence of a non-function) was found.
error(filename, linenum, 'readability/fn_size', 5,
'Lint failed to find start of function body.')
elif Match(r'^\}\s*$', line): # function end
function_state.Check(error, filename, linenum)
function_state.End()
elif not Match(r'^\s*$', line):
function_state.Count() # Count non-blank/non-comment lines.
_RE_PATTERN_TODO = re.compile(r'^//(\s*)TODO(\(.+?\))?:?(\s|$)?')
def CheckComment(comment, filename, linenum, error):
"""Checks for common mistakes in TODO comments.
Args:
comment: The text of the comment from the line in question.
filename: The name of the current file.
linenum: The number of the line to check.
error: The function to call with any errors found.
"""
match = _RE_PATTERN_TODO.match(comment)
if match:
# One whitespace is correct; zero whitespace is handled elsewhere.
leading_whitespace = match.group(1)
if len(leading_whitespace) > 1:
error(filename, linenum, 'whitespace/todo', 2,
'Too many spaces before TODO')
username = match.group(2)
if not username:
error(filename, linenum, 'readability/todo', 2,
'Missing username in TODO; it should look like '
'"// TODO(my_username): Stuff."')
middle_whitespace = match.group(3)
# Comparisons made explicit for correctness -- pylint: disable-msg=C6403
if middle_whitespace != ' ' and middle_whitespace != '':
error(filename, linenum, 'whitespace/todo', 2,
'TODO(my_username) should be followed by a space')
def CheckSpacing(filename, clean_lines, linenum, error):
"""Checks for the correctness of various spacing issues in the code.
Things we check for: spaces around operators, spaces after
if/for/while/switch, no spaces around parens in function calls, two
spaces between code and comment, don't start a block with a blank
line, don't end a function with a blank line, don't add a blank line
after public/protected/private, don't have too many blank lines in a row.
Args:
filename: The name of the current file.
clean_lines: A CleansedLines instance containing the file.
linenum: The number of the line to check.
error: The function to call with any errors found.
"""
raw = clean_lines.raw_lines
line = raw[linenum]
# Before nixing comments, check if the line is blank for no good
# reason. This includes the first line after a block is opened, and
# blank lines at the end of a function (ie, right before a line like '}'
if IsBlankLine(line):
elided = clean_lines.elided
prev_line = elided[linenum - 1]
prevbrace = prev_line.rfind('{')
# TODO(unknown): Don't complain if line before blank line, and line after,
# both start with alnums and are indented the same amount.
# This ignores whitespace at the start of a namespace block
# because those are not usually indented.
if (prevbrace != -1 and prev_line[prevbrace:].find('}') == -1
and prev_line[:prevbrace].find('namespace') == -1):
# OK, we have a blank line at the start of a code block. Before we
# complain, we check if it is an exception to the rule: The previous
# non-empty line has the parameters of a function header that are indented
# 4 spaces (because they did not fit in a 80 column line when placed on
# the same line as the function name). We also check for the case where
# the previous line is indented 6 spaces, which may happen when the
# initializers of a constructor do not fit into a 80 column line.
exception = False
if Match(r' {6}\w', prev_line): # Initializer list?
# We are looking for the opening column of initializer list, which
# should be indented 4 spaces to cause 6 space indentation afterwards.
search_position = linenum-2
while (search_position >= 0
and Match(r' {6}\w', elided[search_position])):
search_position -= 1
exception = (search_position >= 0
and elided[search_position][:5] == ' :')
else:
# Search for the function arguments or an initializer list. We use a
# simple heuristic here: If the line is indented 4 spaces; and we have a
# closing paren, without the opening paren, followed by an opening brace
# or colon (for initializer lists) we assume that it is the last line of
# a function header. If we have a colon indented 4 spaces, it is an
# initializer list.
exception = (Match(r' {4}\w[^\(]*\)\s*(const\s*)?(\{\s*$|:)',
prev_line)
or Match(r' {4}:', prev_line))
if not exception:
error(filename, linenum, 'whitespace/blank_line', 2,
'Blank line at the start of a code block. Is this needed?')
# This doesn't ignore whitespace at the end of a namespace block
# because that is too hard without pairing open/close braces;
# however, a special exception is made for namespace closing
# brackets which have a comment containing "namespace".
#
# Also, ignore blank lines at the end of a block in a long if-else
# chain, like this:
# if (condition1) {
# // Something followed by a blank line
#
# } else if (condition2) {
# // Something else
# }
if linenum + 1 < clean_lines.NumLines():
next_line = raw[linenum + 1]
if (next_line
and Match(r'\s*}', next_line)
and next_line.find('namespace') == -1
and next_line.find('} else ') == -1):
error(filename, linenum, 'whitespace/blank_line', 3,
'Blank line at the end of a code block. Is this needed?')
matched = Match(r'\s*(public|protected|private):', prev_line)
if matched:
error(filename, linenum, 'whitespace/blank_line', 3,
'Do not leave a blank line after "%s:"' % matched.group(1))
# Next, we complain if there's a comment too near the text
commentpos = line.find('//')
if commentpos != -1:
# Check if the // may be in quotes. If so, ignore it
# Comparisons made explicit for clarity -- pylint: disable-msg=C6403
if (line.count('"', 0, commentpos) -
line.count('\\"', 0, commentpos)) % 2 == 0: # not in quotes
# Allow one space for new scopes, two spaces otherwise:
if (not Match(r'^\s*{ //', line) and
((commentpos >= 1 and
line[commentpos-1] not in string.whitespace) or
(commentpos >= 2 and
line[commentpos-2] not in string.whitespace))):
error(filename, linenum, 'whitespace/comments', 2,
'At least two spaces is best between code and comments')
# There should always be a space between the // and the comment
commentend = commentpos + 2
if commentend < len(line) and not line[commentend] == ' ':
# but some lines are exceptions -- e.g. if they're big
# comment delimiters like:
# //----------------------------------------------------------
# or are an empty C++ style Doxygen comment, like:
# ///
# or they begin with multiple slashes followed by a space:
# //////// Header comment
match = (Search(r'[=/-]{4,}\s*$', line[commentend:]) or
Search(r'^/$', line[commentend:]) or
Search(r'^/+ ', line[commentend:]))
if not match:
error(filename, linenum, 'whitespace/comments', 4,
'Should have a space between // and comment')
CheckComment(line[commentpos:], filename, linenum, error)
line = clean_lines.elided[linenum] # get rid of comments and strings
# Don't try to do spacing checks for operator methods
line = re.sub(r'operator(==|!=|<|<<|<=|>=|>>|>)\(', 'operator\(', line)
# We allow no-spaces around = within an if: "if ( (a=Foo()) == 0 )".
# Otherwise not. Note we only check for non-spaces on *both* sides;
# sometimes people put non-spaces on one side when aligning ='s among
# many lines (not that this is behavior that I approve of...)
if Search(r'[\w.]=[\w.]', line) and not Search(r'\b(if|while) ', line):
error(filename, linenum, 'whitespace/operators', 4,
'Missing spaces around =')
# It's ok not to have spaces around binary operators like + - * /, but if
# there's too little whitespace, we get concerned. It's hard to tell,
# though, so we punt on this one for now. TODO.
# You should always have whitespace around binary operators.
# Alas, we can't test < or > because they're legitimately used sans spaces
# (a->b, vector a). The only time we can tell is a < with no >, and
# only if it's not template params list spilling into the next line.
match = Search(r'[^<>=!\s](==|!=|<=|>=)[^<>=!\s]', line)
if not match:
# Note that while it seems that the '<[^<]*' term in the following
# regexp could be simplified to '<.*', which would indeed match
# the same class of strings, the [^<] means that searching for the
# regexp takes linear rather than quadratic time.
if not Search(r'<[^<]*,\s*$', line): # template params spill
match = Search(r'[^<>=!\s](<)[^<>=!\s]([^>]|->)*$', line)
if match:
error(filename, linenum, 'whitespace/operators', 3,
'Missing spaces around %s' % match.group(1))
# We allow no-spaces around << and >> when used like this: 10<<20, but
# not otherwise (particularly, not when used as streams)
match = Search(r'[^0-9\s](<<|>>)[^0-9\s]', line)
if match:
error(filename, linenum, 'whitespace/operators', 3,
'Missing spaces around %s' % match.group(1))
# There shouldn't be space around unary operators
match = Search(r'(!\s|~\s|[\s]--[\s;]|[\s]\+\+[\s;])', line)
if match:
error(filename, linenum, 'whitespace/operators', 4,
'Extra space for operator %s' % match.group(1))
# A pet peeve of mine: no spaces after an if, while, switch, or for
match = Search(r' (if\(|for\(|while\(|switch\()', line)
if match:
error(filename, linenum, 'whitespace/parens', 5,
'Missing space before ( in %s' % match.group(1))
# For if/for/while/switch, the left and right parens should be
# consistent about how many spaces are inside the parens, and
# there should either be zero or one spaces inside the parens.
# We don't want: "if ( foo)" or "if ( foo )".
# Exception: "for ( ; foo; bar)" and "for (foo; bar; )" are allowed.
match = Search(r'\b(if|for|while|switch)\s*'
r'\(([ ]*)(.).*[^ ]+([ ]*)\)\s*{\s*$',
line)
if match:
if len(match.group(2)) != len(match.group(4)):
if not (match.group(3) == ';' and
len(match.group(2)) == 1 + len(match.group(4)) or
not match.group(2) and Search(r'\bfor\s*\(.*; \)', line)):
error(filename, linenum, 'whitespace/parens', 5,
'Mismatching spaces inside () in %s' % match.group(1))
if not len(match.group(2)) in [0, 1]:
error(filename, linenum, 'whitespace/parens', 5,
'Should have zero or one spaces inside ( and ) in %s' %
match.group(1))
# You should always have a space after a comma (either as fn arg or operator)
if Search(r',[^\s]', line):
error(filename, linenum, 'whitespace/comma', 3,
'Missing space after ,')
# You should always have a space after a semicolon
# except for few corner cases
# TODO(unknown): clarify if 'if (1) { return 1;}' is requires one more
# space after ;
if Search(r';[^\s};\\)/]', line):
error(filename, linenum, 'whitespace/semicolon', 3,
'Missing space after ;')
# Next we will look for issues with function calls.
CheckSpacingForFunctionCall(filename, line, linenum, error)
# Except after an opening paren, or after another opening brace (in case of
# an initializer list, for instance), you should have spaces before your
# braces. And since you should never have braces at the beginning of a line,
# this is an easy test.
if Search(r'[^ ({]{', line):
error(filename, linenum, 'whitespace/braces', 5,
'Missing space before {')
# Make sure '} else {' has spaces.
if Search(r'}else', line):
error(filename, linenum, 'whitespace/braces', 5,
'Missing space before else')
# You shouldn't have spaces before your brackets, except maybe after
# 'delete []' or 'new char * []'.
if Search(r'\w\s+\[', line) and not Search(r'delete\s+\[', line):
error(filename, linenum, 'whitespace/braces', 5,
'Extra space before [')
# You shouldn't have a space before a semicolon at the end of the line.
# There's a special case for "for" since the style guide allows space before
# the semicolon there.
if Search(r':\s*;\s*$', line):
error(filename, linenum, 'whitespace/semicolon', 5,
'Semicolon defining empty statement. Use { } instead.')
elif Search(r'^\s*;\s*$', line):
error(filename, linenum, 'whitespace/semicolon', 5,
'Line contains only semicolon. If this should be an empty statement, '
'use { } instead.')
elif (Search(r'\s+;\s*$', line) and
not Search(r'\bfor\b', line)):
error(filename, linenum, 'whitespace/semicolon', 5,
'Extra space before last semicolon. If this should be an empty '
'statement, use { } instead.')
def CheckSectionSpacing(filename, clean_lines, class_info, linenum, error):
"""Checks for additional blank line issues related to sections.
Currently the only thing checked here is blank line before protected/private.
Args:
filename: The name of the current file.
clean_lines: A CleansedLines instance containing the file.
class_info: A _ClassInfo objects.
linenum: The number of the line to check.
error: The function to call with any errors found.
"""
# Skip checks if the class is small, where small means 25 lines or less.
# 25 lines seems like a good cutoff since that's the usual height of
# terminals, and any class that can't fit in one screen can't really
# be considered "small".
#
# Also skip checks if we are on the first line. This accounts for
# classes that look like
# class Foo { public: ... };
#
# If we didn't find the end of the class, last_line would be zero,
# and the check will be skipped by the first condition.
if (class_info.last_line - class_info.linenum <= 24 or
linenum <= class_info.linenum):
return
matched = Match(r'\s*(public|protected|private):', clean_lines.lines[linenum])
if matched:
# Issue warning if the line before public/protected/private was
# not a blank line, but don't do this if the previous line contains
# "class" or "struct". This can happen two ways:
# - We are at the beginning of the class.
# - We are forward-declaring an inner class that is semantically
# private, but needed to be public for implementation reasons.
prev_line = clean_lines.lines[linenum - 1]
if (not IsBlankLine(prev_line) and
not Search(r'\b(class|struct)\b', prev_line)):
# Try a bit harder to find the beginning of the class. This is to
# account for multi-line base-specifier lists, e.g.:
# class Derived
# : public Base {
end_class_head = class_info.linenum
for i in range(class_info.linenum, linenum):
if Search(r'\{\s*$', clean_lines.lines[i]):
end_class_head = i
break
if end_class_head < linenum - 1:
error(filename, linenum, 'whitespace/blank_line', 3,
'"%s:" should be preceded by a blank line' % matched.group(1))
def GetPreviousNonBlankLine(clean_lines, linenum):
"""Return the most recent non-blank line and its line number.
Args:
clean_lines: A CleansedLines instance containing the file contents.
linenum: The number of the line to check.
Returns:
A tuple with two elements. The first element is the contents of the last
non-blank line before the current line, or the empty string if this is the
first non-blank line. The second is the line number of that line, or -1
if this is the first non-blank line.
"""
prevlinenum = linenum - 1
while prevlinenum >= 0:
prevline = clean_lines.elided[prevlinenum]
if not IsBlankLine(prevline): # if not a blank line...
return (prevline, prevlinenum)
prevlinenum -= 1
return ('', -1)
def CheckBraces(filename, clean_lines, linenum, error):
"""Looks for misplaced braces (e.g. at the end of line).
Args:
filename: The name of the current file.
clean_lines: A CleansedLines instance containing the file.
linenum: The number of the line to check.
error: The function to call with any errors found.
"""
line = clean_lines.elided[linenum] # get rid of comments and strings
if Match(r'\s*{\s*$', line):
# We allow an open brace to start a line in the case where someone
# is using braces in a block to explicitly create a new scope,
# which is commonly used to control the lifetime of
# stack-allocated variables. We don't detect this perfectly: we
# just don't complain if the last non-whitespace character on the
# previous non-blank line is ';', ':', '{', or '}'.
prevline = GetPreviousNonBlankLine(clean_lines, linenum)[0]
if not Search(r'[;:}{]\s*$', prevline):
error(filename, linenum, 'whitespace/braces', 4,
'{ should almost always be at the end of the previous line')
# An else clause should be on the same line as the preceding closing brace.
if Match(r'\s*else\s*', line):
prevline = GetPreviousNonBlankLine(clean_lines, linenum)[0]
if Match(r'\s*}\s*$', prevline):
error(filename, linenum, 'whitespace/newline', 4,
'An else should appear on the same line as the preceding }')
# If braces come on one side of an else, they should be on both.
# However, we have to worry about "else if" that spans multiple lines!
if Search(r'}\s*else[^{]*$', line) or Match(r'[^}]*else\s*{', line):
if Search(r'}\s*else if([^{]*)$', line): # could be multi-line if
# find the ( after the if
pos = line.find('else if')
pos = line.find('(', pos)
if pos > 0:
(endline, _, endpos) = CloseExpression(clean_lines, linenum, pos)
if endline[endpos:].find('{') == -1: # must be brace after if
error(filename, linenum, 'readability/braces', 5,
'If an else has a brace on one side, it should have it on both')
else: # common case: else not followed by a multi-line if
error(filename, linenum, 'readability/braces', 5,
'If an else has a brace on one side, it should have it on both')
# Likewise, an else should never have the else clause on the same line
if Search(r'\belse [^\s{]', line) and not Search(r'\belse if\b', line):
error(filename, linenum, 'whitespace/newline', 4,
'Else clause should never be on same line as else (use 2 lines)')
# In the same way, a do/while should never be on one line
if Match(r'\s*do [^\s{]', line):
error(filename, linenum, 'whitespace/newline', 4,
'do/while clauses should not be on a single line')
# Braces shouldn't be followed by a ; unless they're defining a struct
# or initializing an array.
# We can't tell in general, but we can for some common cases.
prevlinenum = linenum
while True:
(prevline, prevlinenum) = GetPreviousNonBlankLine(clean_lines, prevlinenum)
if Match(r'\s+{.*}\s*;', line) and not prevline.count(';'):
line = prevline + line
else:
break
if (Search(r'{.*}\s*;', line) and
line.count('{') == line.count('}') and
not Search(r'struct|class|enum|\s*=\s*{', line)):
error(filename, linenum, 'readability/braces', 4,
"You don't need a ; after a }")
def ReplaceableCheck(operator, macro, line):
"""Determine whether a basic CHECK can be replaced with a more specific one.
For example suggest using CHECK_EQ instead of CHECK(a == b) and
similarly for CHECK_GE, CHECK_GT, CHECK_LE, CHECK_LT, CHECK_NE.
Args:
operator: The C++ operator used in the CHECK.
macro: The CHECK or EXPECT macro being called.
line: The current source line.
Returns:
True if the CHECK can be replaced with a more specific one.
"""
# This matches decimal and hex integers, strings, and chars (in that order).
match_constant = r'([-+]?(\d+|0[xX][0-9a-fA-F]+)[lLuU]{0,3}|".*"|\'.*\')'
# Expression to match two sides of the operator with something that
# looks like a literal, since CHECK(x == iterator) won't compile.
# This means we can't catch all the cases where a more specific
# CHECK is possible, but it's less annoying than dealing with
# extraneous warnings.
match_this = (r'\s*' + macro + r'\((\s*' +
match_constant + r'\s*' + operator + r'[^<>].*|'
r'.*[^<>]' + operator + r'\s*' + match_constant +
r'\s*\))')
# Don't complain about CHECK(x == NULL) or similar because
# CHECK_EQ(x, NULL) won't compile (requires a cast).
# Also, don't complain about more complex boolean expressions
# involving && or || such as CHECK(a == b || c == d).
return Match(match_this, line) and not Search(r'NULL|&&|\|\|', line)
def CheckCheck(filename, clean_lines, linenum, error):
"""Checks the use of CHECK and EXPECT macros.
Args:
filename: The name of the current file.
clean_lines: A CleansedLines instance containing the file.
linenum: The number of the line to check.
error: The function to call with any errors found.
"""
# Decide the set of replacement macros that should be suggested
raw_lines = clean_lines.raw_lines
current_macro = ''
for macro in _CHECK_MACROS:
if raw_lines[linenum].find(macro) >= 0:
current_macro = macro
break
if not current_macro:
# Don't waste time here if line doesn't contain 'CHECK' or 'EXPECT'
return
line = clean_lines.elided[linenum] # get rid of comments and strings
# Encourage replacing plain CHECKs with CHECK_EQ/CHECK_NE/etc.
for operator in ['==', '!=', '>=', '>', '<=', '<']:
if ReplaceableCheck(operator, current_macro, line):
error(filename, linenum, 'readability/check', 2,
'Consider using %s instead of %s(a %s b)' % (
_CHECK_REPLACEMENT[current_macro][operator],
current_macro, operator))
break
def GetLineWidth(line):
"""Determines the width of the line in column positions.
Args:
line: A string, which may be a Unicode string.
Returns:
The width of the line in column positions, accounting for Unicode
combining characters and wide characters.
"""
if isinstance(line, unicode):
width = 0
for uc in unicodedata.normalize('NFC', line):
if unicodedata.east_asian_width(uc) in ('W', 'F'):
width += 2
elif not unicodedata.combining(uc):
width += 1
return width
else:
return len(line)
def CheckStyle(filename, clean_lines, linenum, file_extension, class_state,
error):
"""Checks rules from the 'C++ style rules' section of cppguide.html.
Most of these rules are hard to test (naming, comment style), but we
do what we can. In particular we check for 2-space indents, line lengths,
tab usage, spaces inside code, etc.
Args:
filename: The name of the current file.
clean_lines: A CleansedLines instance containing the file.
linenum: The number of the line to check.
file_extension: The extension (without the dot) of the filename.
error: The function to call with any errors found.
"""
raw_lines = clean_lines.raw_lines
line = raw_lines[linenum]
if line.find('\t') != -1:
error(filename, linenum, 'whitespace/tab', 1,
'Tab found; better to use spaces')
# One or three blank spaces at the beginning of the line is weird; it's
# hard to reconcile that with 2-space indents.
# NOTE: here are the conditions rob pike used for his tests. Mine aren't
# as sophisticated, but it may be worth becoming so: RLENGTH==initial_spaces
# if(RLENGTH > 20) complain = 0;
# if(match($0, " +(error|private|public|protected):")) complain = 0;
# if(match(prev, "&& *$")) complain = 0;
# if(match(prev, "\\|\\| *$")) complain = 0;
# if(match(prev, "[\",=><] *$")) complain = 0;
# if(match($0, " <<")) complain = 0;
# if(match(prev, " +for \\(")) complain = 0;
# if(prevodd && match(prevprev, " +for \\(")) complain = 0;
initial_spaces = 0
cleansed_line = clean_lines.elided[linenum]
while initial_spaces < len(line) and line[initial_spaces] == ' ':
initial_spaces += 1
if line and line[-1].isspace():
error(filename, linenum, 'whitespace/end_of_line', 4,
'Line ends in whitespace. Consider deleting these extra spaces.')
# There are certain situations we allow one space, notably for labels
elif ((initial_spaces == 1 or initial_spaces == 3) and
not Match(r'\s*\w+\s*:\s*$', cleansed_line)):
error(filename, linenum, 'whitespace/indent', 3,
'Weird number of spaces at line-start. '
'Are you using a 2-space indent?')
# Labels should always be indented at least one space.
elif not initial_spaces and line[:2] != '//' and Search(r'[^:]:\s*$',
line):
error(filename, linenum, 'whitespace/labels', 4,
'Labels should always be indented at least one space. '
'If this is a member-initializer list in a constructor or '
'the base class list in a class definition, the colon should '
'be on the following line.')
# Check if the line is a header guard.
is_header_guard = False
if file_extension == 'h':
cppvar = GetHeaderGuardCPPVariable(filename)
if (line.startswith('#ifndef %s' % cppvar) or
line.startswith('#define %s' % cppvar) or
line.startswith('#endif // %s' % cppvar)):
is_header_guard = True
# #include lines and header guards can be long, since there's no clean way to
# split them.
#
# URLs can be long too. It's possible to split these, but it makes them
# harder to cut&paste.
#
# The "$Id:...$" comment may also get very long without it being the
# developers fault.
if (not line.startswith('#include') and not is_header_guard and
not Match(r'^\s*//.*http(s?)://\S*$', line) and
not Match(r'^// \$Id:.*#[0-9]+ \$$', line)):
line_width = GetLineWidth(line)
if line_width > 100:
error(filename, linenum, 'whitespace/line_length', 4,
'Lines should very rarely be longer than 100 characters')
elif line_width > 80:
error(filename, linenum, 'whitespace/line_length', 2,
'Lines should be <= 80 characters long')
if (cleansed_line.count(';') > 1 and
# for loops are allowed two ;'s (and may run over two lines).
cleansed_line.find('for') == -1 and
(GetPreviousNonBlankLine(clean_lines, linenum)[0].find('for') == -1 or
GetPreviousNonBlankLine(clean_lines, linenum)[0].find(';') != -1) and
# It's ok to have many commands in a switch case that fits in 1 line
not ((cleansed_line.find('case ') != -1 or
cleansed_line.find('default:') != -1) and
cleansed_line.find('break;') != -1)):
error(filename, linenum, 'whitespace/newline', 4,
'More than one command on the same line')
# Some more style checks
CheckBraces(filename, clean_lines, linenum, error)
CheckSpacing(filename, clean_lines, linenum, error)
CheckCheck(filename, clean_lines, linenum, error)
if class_state and class_state.classinfo_stack:
CheckSectionSpacing(filename, clean_lines,
class_state.classinfo_stack[-1], linenum, error)
_RE_PATTERN_INCLUDE_NEW_STYLE = re.compile(r'#include +"[^/]+\.h"')
_RE_PATTERN_INCLUDE = re.compile(r'^\s*#\s*include\s*([<"])([^>"]*)[>"].*$')
# Matches the first component of a filename delimited by -s and _s. That is:
# _RE_FIRST_COMPONENT.match('foo').group(0) == 'foo'
# _RE_FIRST_COMPONENT.match('foo.cc').group(0) == 'foo'
# _RE_FIRST_COMPONENT.match('foo-bar_baz.cc').group(0) == 'foo'
# _RE_FIRST_COMPONENT.match('foo_bar-baz.cc').group(0) == 'foo'
_RE_FIRST_COMPONENT = re.compile(r'^[^-_.]+')
def _DropCommonSuffixes(filename):
"""Drops common suffixes like _test.cc or -inl.h from filename.
For example:
>>> _DropCommonSuffixes('foo/foo-inl.h')
'foo/foo'
>>> _DropCommonSuffixes('foo/bar/foo.cc')
'foo/bar/foo'
>>> _DropCommonSuffixes('foo/foo_internal.h')
'foo/foo'
>>> _DropCommonSuffixes('foo/foo_unusualinternal.h')
'foo/foo_unusualinternal'
Args:
filename: The input filename.
Returns:
The filename with the common suffix removed.
"""
for suffix in ('test.cc', 'regtest.cc', 'unittest.cc',
'inl.h', 'impl.h', 'internal.h'):
if (filename.endswith(suffix) and len(filename) > len(suffix) and
filename[-len(suffix) - 1] in ('-', '_')):
return filename[:-len(suffix) - 1]
return os.path.splitext(filename)[0]
def _IsTestFilename(filename):
"""Determines if the given filename has a suffix that identifies it as a test.
Args:
filename: The input filename.
Returns:
True if 'filename' looks like a test, False otherwise.
"""
if (filename.endswith('_test.cc') or
filename.endswith('_unittest.cc') or
filename.endswith('_regtest.cc')):
return True
else:
return False
def _ClassifyInclude(fileinfo, include, is_system):
"""Figures out what kind of header 'include' is.
Args:
fileinfo: The current file cpplint is running over. A FileInfo instance.
include: The path to a #included file.
is_system: True if the #include used <> rather than "".
Returns:
One of the _XXX_HEADER constants.
For example:
>>> _ClassifyInclude(FileInfo('foo/foo.cc'), 'stdio.h', True)
_C_SYS_HEADER
>>> _ClassifyInclude(FileInfo('foo/foo.cc'), 'string', True)
_CPP_SYS_HEADER
>>> _ClassifyInclude(FileInfo('foo/foo.cc'), 'foo/foo.h', False)
_LIKELY_MY_HEADER
>>> _ClassifyInclude(FileInfo('foo/foo_unknown_extension.cc'),
... 'bar/foo_other_ext.h', False)
_POSSIBLE_MY_HEADER
>>> _ClassifyInclude(FileInfo('foo/foo.cc'), 'foo/bar.h', False)
_OTHER_HEADER
"""
# This is a list of all standard c++ header files, except
# those already checked for above.
is_stl_h = include in _STL_HEADERS
is_cpp_h = is_stl_h or include in _CPP_HEADERS
if is_system:
if is_cpp_h:
return _CPP_SYS_HEADER
else:
return _C_SYS_HEADER
# If the target file and the include we're checking share a
# basename when we drop common extensions, and the include
# lives in . , then it's likely to be owned by the target file.
target_dir, target_base = (
os.path.split(_DropCommonSuffixes(fileinfo.RepositoryName())))
include_dir, include_base = os.path.split(_DropCommonSuffixes(include))
if target_base == include_base and (
include_dir == target_dir or
include_dir == os.path.normpath(target_dir + '/../public')):
return _LIKELY_MY_HEADER
# If the target and include share some initial basename
# component, it's possible the target is implementing the
# include, so it's allowed to be first, but we'll never
# complain if it's not there.
target_first_component = _RE_FIRST_COMPONENT.match(target_base)
include_first_component = _RE_FIRST_COMPONENT.match(include_base)
if (target_first_component and include_first_component and
target_first_component.group(0) ==
include_first_component.group(0)):
return _POSSIBLE_MY_HEADER
return _OTHER_HEADER
def CheckIncludeLine(filename, clean_lines, linenum, include_state, error):
"""Check rules that are applicable to #include lines.
Strings on #include lines are NOT removed from elided line, to make
certain tasks easier. However, to prevent false positives, checks
applicable to #include lines in CheckLanguage must be put here.
Args:
filename: The name of the current file.
clean_lines: A CleansedLines instance containing the file.
linenum: The number of the line to check.
include_state: An _IncludeState instance in which the headers are inserted.
error: The function to call with any errors found.
"""
fileinfo = FileInfo(filename)
line = clean_lines.lines[linenum]
# "include" should use the new style "foo/bar.h" instead of just "bar.h"
if _RE_PATTERN_INCLUDE_NEW_STYLE.search(line):
error(filename, linenum, 'build/include', 4,
'Include the directory when naming .h files')
# we shouldn't include a file more than once. actually, there are a
# handful of instances where doing so is okay, but in general it's
# not.
match = _RE_PATTERN_INCLUDE.search(line)
if match:
include = match.group(2)
is_system = (match.group(1) == '<')
if include in include_state:
error(filename, linenum, 'build/include', 4,
'"%s" already included at %s:%s' %
(include, filename, include_state[include]))
else:
include_state[include] = linenum
# We want to ensure that headers appear in the right order:
# 1) for foo.cc, foo.h (preferred location)
# 2) c system files
# 3) cpp system files
# 4) for foo.cc, foo.h (deprecated location)
# 5) other google headers
#
# We classify each include statement as one of those 5 types
# using a number of techniques. The include_state object keeps
# track of the highest type seen, and complains if we see a
# lower type after that.
error_message = include_state.CheckNextIncludeOrder(
_ClassifyInclude(fileinfo, include, is_system))
if error_message:
error(filename, linenum, 'build/include_order', 4,
'%s. Should be: %s.h, c system, c++ system, other.' %
(error_message, fileinfo.BaseName()))
if not include_state.IsInAlphabeticalOrder(include):
error(filename, linenum, 'build/include_alpha', 4,
'Include "%s" not in alphabetical order' % include)
# Look for any of the stream classes that are part of standard C++.
match = _RE_PATTERN_INCLUDE.match(line)
if match:
include = match.group(2)
if Match(r'(f|ind|io|i|o|parse|pf|stdio|str|)?stream$', include):
# Many unit tests use cout, so we exempt them.
if not _IsTestFilename(filename):
error(filename, linenum, 'readability/streams', 3,
'Streams are highly discouraged.')
def _GetTextInside(text, start_pattern):
"""Retrieves all the text between matching open and close parentheses.
Given a string of lines and a regular expression string, retrieve all the text
following the expression and between opening punctuation symbols like
(, [, or {, and the matching close-punctuation symbol. This properly nested
occurrences of the punctuations, so for the text like
printf(a(), b(c()));
a call to _GetTextInside(text, r'printf\(') will return 'a(), b(c())'.
start_pattern must match string having an open punctuation symbol at the end.
Args:
text: The lines to extract text. Its comments and strings must be elided.
It can be single line and can span multiple lines.
start_pattern: The regexp string indicating where to start extracting
the text.
Returns:
The extracted text.
None if either the opening string or ending punctuation could not be found.
"""
# TODO(sugawarayu): Audit cpplint.py to see what places could be profitably
# rewritten to use _GetTextInside (and use inferior regexp matching today).
# Give opening punctuations to get the matching close-punctuations.
matching_punctuation = {'(': ')', '{': '}', '[': ']'}
closing_punctuation = set(matching_punctuation.itervalues())
# Find the position to start extracting text.
match = re.search(start_pattern, text, re.M)
if not match: # start_pattern not found in text.
return None
start_position = match.end(0)
assert start_position > 0, (
'start_pattern must ends with an opening punctuation.')
assert text[start_position - 1] in matching_punctuation, (
'start_pattern must ends with an opening punctuation.')
# Stack of closing punctuations we expect to have in text after position.
punctuation_stack = [matching_punctuation[text[start_position - 1]]]
position = start_position
while punctuation_stack and position < len(text):
if text[position] == punctuation_stack[-1]:
punctuation_stack.pop()
elif text[position] in closing_punctuation:
# A closing punctuation without matching opening punctuations.
return None
elif text[position] in matching_punctuation:
punctuation_stack.append(matching_punctuation[text[position]])
position += 1
if punctuation_stack:
# Opening punctuations left without matching close-punctuations.
return None
# punctuations match.
return text[start_position:position - 1]
def CheckLanguage(filename, clean_lines, linenum, file_extension, include_state,
error):
"""Checks rules from the 'C++ language rules' section of cppguide.html.
Some of these rules are hard to test (function overloading, using
uint32 inappropriately), but we do the best we can.
Args:
filename: The name of the current file.
clean_lines: A CleansedLines instance containing the file.
linenum: The number of the line to check.
file_extension: The extension (without the dot) of the filename.
include_state: An _IncludeState instance in which the headers are inserted.
error: The function to call with any errors found.
"""
# If the line is empty or consists of entirely a comment, no need to
# check it.
line = clean_lines.elided[linenum]
if not line:
return
match = _RE_PATTERN_INCLUDE.search(line)
if match:
CheckIncludeLine(filename, clean_lines, linenum, include_state, error)
return
# Create an extended_line, which is the concatenation of the current and
# next lines, for more effective checking of code that may span more than one
# line.
if linenum + 1 < clean_lines.NumLines():
extended_line = line + clean_lines.elided[linenum + 1]
else:
extended_line = line
# Make Windows paths like Unix.
fullname = os.path.abspath(filename).replace('\\', '/')
# TODO(unknown): figure out if they're using default arguments in fn proto.
# Check for non-const references in functions. This is tricky because &
# is also used to take the address of something. We allow <> for templates,
# (ignoring whatever is between the braces) and : for classes.
# These are complicated re's. They try to capture the following:
# paren (for fn-prototype start), typename, &, varname. For the const
# version, we're willing for const to be before typename or after
# Don't check the implementation on same line.
fnline = line.split('{', 1)[0]
if (len(re.findall(r'\([^()]*\b(?:[\w:]|<[^()]*>)+(\s?&|&\s?)\w+', fnline)) >
len(re.findall(r'\([^()]*\bconst\s+(?:typename\s+)?(?:struct\s+)?'
r'(?:[\w:]|<[^()]*>)+(\s?&|&\s?)\w+', fnline)) +
len(re.findall(r'\([^()]*\b(?:[\w:]|<[^()]*>)+\s+const(\s?&|&\s?)[\w]+',
fnline))):
# We allow non-const references in a few standard places, like functions
# called "swap()" or iostream operators like "<<" or ">>".
if not Search(
r'(swap|Swap|operator[<>][<>])\s*\(\s*(?:[\w:]|<.*>)+\s*&',
fnline):
error(filename, linenum, 'runtime/references', 2,
'Is this a non-const reference? '
'If so, make const or use a pointer.')
# Check to see if they're using an conversion function cast.
# I just try to capture the most common basic types, though there are more.
# Parameterless conversion functions, such as bool(), are allowed as they are
# probably a member operator declaration or default constructor.
match = Search(
r'(\bnew\s+)?\b' # Grab 'new' operator, if it's there
r'(int|float|double|bool|char|int32|uint32|int64|uint64)\([^)]', line)
if match:
# gMock methods are defined using some variant of MOCK_METHODx(name, type)
# where type may be float(), int(string), etc. Without context they are
# virtually indistinguishable from int(x) casts. Likewise, gMock's
# MockCallback takes a template parameter of the form return_type(arg_type),
# which looks much like the cast we're trying to detect.
if (match.group(1) is None and # If new operator, then this isn't a cast
not (Match(r'^\s*MOCK_(CONST_)?METHOD\d+(_T)?\(', line) or
Match(r'^\s*MockCallback<.*>', line))):
error(filename, linenum, 'readability/casting', 4,
'Using deprecated casting style. '
'Use static_cast<%s>(...) instead' %
match.group(2))
CheckCStyleCast(filename, linenum, line, clean_lines.raw_lines[linenum],
'static_cast',
r'\((int|float|double|bool|char|u?int(16|32|64))\)', error)
# This doesn't catch all cases. Consider (const char * const)"hello".
#
# (char *) "foo" should always be a const_cast (reinterpret_cast won't
# compile).
if CheckCStyleCast(filename, linenum, line, clean_lines.raw_lines[linenum],
'const_cast', r'\((char\s?\*+\s?)\)\s*"', error):
pass
else:
# Check pointer casts for other than string constants
CheckCStyleCast(filename, linenum, line, clean_lines.raw_lines[linenum],
'reinterpret_cast', r'\((\w+\s?\*+\s?)\)', error)
# In addition, we look for people taking the address of a cast. This
# is dangerous -- casts can assign to temporaries, so the pointer doesn't
# point where you think.
if Search(
r'(&\([^)]+\)[\w(])|(&(static|dynamic|reinterpret)_cast\b)', line):
error(filename, linenum, 'runtime/casting', 4,
('Are you taking an address of a cast? '
'This is dangerous: could be a temp var. '
'Take the address before doing the cast, rather than after'))
# Check for people declaring static/global STL strings at the top level.
# This is dangerous because the C++ language does not guarantee that
# globals with constructors are initialized before the first access.
match = Match(
r'((?:|static +)(?:|const +))string +([a-zA-Z0-9_:]+)\b(.*)',
line)
# Make sure it's not a function.
# Function template specialization looks like: "string foo(...".
# Class template definitions look like: "string Foo::Method(...".
if match and not Match(r'\s*(<.*>)?(::[a-zA-Z0-9_]+)?\s*\(([^"]|$)',
match.group(3)):
error(filename, linenum, 'runtime/string', 4,
'For a static/global string constant, use a C style string instead: '
'"%schar %s[]".' %
(match.group(1), match.group(2)))
# Check that we're not using RTTI outside of testing code.
if Search(r'\bdynamic_cast<', line) and not _IsTestFilename(filename):
error(filename, linenum, 'runtime/rtti', 5,
'Do not use dynamic_cast<>. If you need to cast within a class '
"hierarchy, use static_cast<> to upcast. Google doesn't support "
'RTTI.')
if Search(r'\b([A-Za-z0-9_]*_)\(\1\)', line):
error(filename, linenum, 'runtime/init', 4,
'You seem to be initializing a member variable with itself.')
if file_extension == 'h':
# TODO(unknown): check that 1-arg constructors are explicit.
# How to tell it's a constructor?
# (handled in CheckForNonStandardConstructs for now)
# TODO(unknown): check that classes have DISALLOW_EVIL_CONSTRUCTORS
# (level 1 error)
pass
# Check if people are using the verboten C basic types. The only exception
# we regularly allow is "unsigned short port" for port.
if Search(r'\bshort port\b', line):
if not Search(r'\bunsigned short port\b', line):
error(filename, linenum, 'runtime/int', 4,
'Use "unsigned short" for ports, not "short"')
else:
match = Search(r'\b(short|long(?! +double)|long long)\b', line)
if match:
error(filename, linenum, 'runtime/int', 4,
'Use int16/int64/etc, rather than the C type %s' % match.group(1))
# When snprintf is used, the second argument shouldn't be a literal.
match = Search(r'snprintf\s*\(([^,]*),\s*([0-9]*)\s*,', line)
if match and match.group(2) != '0':
# If 2nd arg is zero, snprintf is used to calculate size.
error(filename, linenum, 'runtime/printf', 3,
'If you can, use sizeof(%s) instead of %s as the 2nd arg '
'to snprintf.' % (match.group(1), match.group(2)))
# Check if some verboten C functions are being used.
if Search(r'\bsprintf\b', line):
error(filename, linenum, 'runtime/printf', 5,
'Never use sprintf. Use snprintf instead.')
match = Search(r'\b(strcpy|strcat)\b', line)
if match:
error(filename, linenum, 'runtime/printf', 4,
'Almost always, snprintf is better than %s' % match.group(1))
if Search(r'\bsscanf\b', line):
error(filename, linenum, 'runtime/printf', 1,
'sscanf can be ok, but is slow and can overflow buffers.')
# Check if some verboten operator overloading is going on
# TODO(unknown): catch out-of-line unary operator&:
# class X {};
# int operator&(const X& x) { return 42; } // unary operator&
# The trick is it's hard to tell apart from binary operator&:
# class Y { int operator&(const Y& x) { return 23; } }; // binary operator&
if Search(r'\boperator\s*&\s*\(\s*\)', line):
error(filename, linenum, 'runtime/operator', 4,
'Unary operator& is dangerous. Do not use it.')
# Check for suspicious usage of "if" like
# } if (a == b) {
if Search(r'\}\s*if\s*\(', line):
error(filename, linenum, 'readability/braces', 4,
'Did you mean "else if"? If not, start a new line for "if".')
# Check for potential format string bugs like printf(foo).
# We constrain the pattern not to pick things like DocidForPrintf(foo).
# Not perfect but it can catch printf(foo.c_str()) and printf(foo->c_str())
# TODO(sugawarayu): Catch the following case. Need to change the calling
# convention of the whole function to process multiple line to handle it.
# printf(
# boy_this_is_a_really_long_variable_that_cannot_fit_on_the_prev_line);
printf_args = _GetTextInside(line, r'(?i)\b(string)?printf\s*\(')
if printf_args:
match = Match(r'([\w.\->()]+)$', printf_args)
if match:
function_name = re.search(r'\b((?:string)?printf)\s*\(',
line, re.I).group(1)
error(filename, linenum, 'runtime/printf', 4,
'Potential format string bug. Do %s("%%s", %s) instead.'
% (function_name, match.group(1)))
# Check for potential memset bugs like memset(buf, sizeof(buf), 0).
match = Search(r'memset\s*\(([^,]*),\s*([^,]*),\s*0\s*\)', line)
if match and not Match(r"^''|-?[0-9]+|0x[0-9A-Fa-f]$", match.group(2)):
error(filename, linenum, 'runtime/memset', 4,
'Did you mean "memset(%s, 0, %s)"?'
% (match.group(1), match.group(2)))
if Search(r'\busing namespace\b', line):
error(filename, linenum, 'build/namespaces', 5,
'Do not use namespace using-directives. '
'Use using-declarations instead.')
# Detect variable-length arrays.
match = Match(r'\s*(.+::)?(\w+) [a-z]\w*\[(.+)];', line)
if (match and match.group(2) != 'return' and match.group(2) != 'delete' and
match.group(3).find(']') == -1):
# Split the size using space and arithmetic operators as delimiters.
# If any of the resulting tokens are not compile time constants then
# report the error.
tokens = re.split(r'\s|\+|\-|\*|\/|<<|>>]', match.group(3))
is_const = True
skip_next = False
for tok in tokens:
if skip_next:
skip_next = False
continue
if Search(r'sizeof\(.+\)', tok): continue
if Search(r'arraysize\(\w+\)', tok): continue
tok = tok.lstrip('(')
tok = tok.rstrip(')')
if not tok: continue
if Match(r'\d+', tok): continue
if Match(r'0[xX][0-9a-fA-F]+', tok): continue
if Match(r'k[A-Z0-9]\w*', tok): continue
if Match(r'(.+::)?k[A-Z0-9]\w*', tok): continue
if Match(r'(.+::)?[A-Z][A-Z0-9_]*', tok): continue
# A catch all for tricky sizeof cases, including 'sizeof expression',
# 'sizeof(*type)', 'sizeof(const type)', 'sizeof(struct StructName)'
# requires skipping the next token because we split on ' ' and '*'.
if tok.startswith('sizeof'):
skip_next = True
continue
is_const = False
break
if not is_const:
error(filename, linenum, 'runtime/arrays', 1,
'Do not use variable-length arrays. Use an appropriately named '
"('k' followed by CamelCase) compile-time constant for the size.")
# If DISALLOW_EVIL_CONSTRUCTORS, DISALLOW_COPY_AND_ASSIGN, or
# DISALLOW_IMPLICIT_CONSTRUCTORS is present, then it should be the last thing
# in the class declaration.
match = Match(
(r'\s*'
r'(DISALLOW_(EVIL_CONSTRUCTORS|COPY_AND_ASSIGN|IMPLICIT_CONSTRUCTORS))'
r'\(.*\);$'),
line)
if match and linenum + 1 < clean_lines.NumLines():
next_line = clean_lines.elided[linenum + 1]
# We allow some, but not all, declarations of variables to be present
# in the statement that defines the class. The [\w\*,\s]* fragment of
# the regular expression below allows users to declare instances of
# the class or pointers to instances, but not less common types such
# as function pointers or arrays. It's a tradeoff between allowing
# reasonable code and avoiding trying to parse more C++ using regexps.
if not Search(r'^\s*}[\w\*,\s]*;', next_line):
error(filename, linenum, 'readability/constructors', 3,
match.group(1) + ' should be the last thing in the class')
# Check for use of unnamed namespaces in header files. Registration
# macros are typically OK, so we allow use of "namespace {" on lines
# that end with backslashes.
if (file_extension == 'h'
and Search(r'\bnamespace\s*{', line)
and line[-1] != '\\'):
error(filename, linenum, 'build/namespaces', 4,
'Do not use unnamed namespaces in header files. See '
'http://google-styleguide.googlecode.com/svn/trunk/cppguide.xml#Namespaces'
' for more information.')
def CheckCStyleCast(filename, linenum, line, raw_line, cast_type, pattern,
error):
"""Checks for a C-style cast by looking for the pattern.
This also handles sizeof(type) warnings, due to similarity of content.
Args:
filename: The name of the current file.
linenum: The number of the line to check.
line: The line of code to check.
raw_line: The raw line of code to check, with comments.
cast_type: The string for the C++ cast to recommend. This is either
reinterpret_cast, static_cast, or const_cast, depending.
pattern: The regular expression used to find C-style casts.
error: The function to call with any errors found.
Returns:
True if an error was emitted.
False otherwise.
"""
match = Search(pattern, line)
if not match:
return False
# e.g., sizeof(int)
sizeof_match = Match(r'.*sizeof\s*$', line[0:match.start(1) - 1])
if sizeof_match:
error(filename, linenum, 'runtime/sizeof', 1,
'Using sizeof(type). Use sizeof(varname) instead if possible')
return True
remainder = line[match.end(0):]
# The close paren is for function pointers as arguments to a function.
# eg, void foo(void (*bar)(int));
# The semicolon check is a more basic function check; also possibly a
# function pointer typedef.
# eg, void foo(int); or void foo(int) const;
# The equals check is for function pointer assignment.
# eg, void *(*foo)(int) = ...
# The > is for MockCallback<...> ...
#
# Right now, this will only catch cases where there's a single argument, and
# it's unnamed. It should probably be expanded to check for multiple
# arguments with some unnamed.
function_match = Match(r'\s*(\)|=|(const)?\s*(;|\{|throw\(\)|>))', remainder)
if function_match:
if (not function_match.group(3) or
function_match.group(3) == ';' or
('MockCallback<' not in raw_line and
'/*' not in raw_line)):
error(filename, linenum, 'readability/function', 3,
'All parameters should be named in a function')
return True
# At this point, all that should be left is actual casts.
error(filename, linenum, 'readability/casting', 4,
'Using C-style cast. Use %s<%s>(...) instead' %
(cast_type, match.group(1)))
return True
_HEADERS_CONTAINING_TEMPLATES = (
('', ('deque',)),
('', ('unary_function', 'binary_function',
'plus', 'minus', 'multiplies', 'divides', 'modulus',
'negate',
'equal_to', 'not_equal_to', 'greater', 'less',
'greater_equal', 'less_equal',
'logical_and', 'logical_or', 'logical_not',
'unary_negate', 'not1', 'binary_negate', 'not2',
'bind1st', 'bind2nd',
'pointer_to_unary_function',
'pointer_to_binary_function',
'ptr_fun',
'mem_fun_t', 'mem_fun', 'mem_fun1_t', 'mem_fun1_ref_t',
'mem_fun_ref_t',
'const_mem_fun_t', 'const_mem_fun1_t',
'const_mem_fun_ref_t', 'const_mem_fun1_ref_t',
'mem_fun_ref',
)),
('', ('numeric_limits',)),
('', ('list',)),
('