pax_global_header00006660000000000000000000000064144711243250014515gustar00rootroot0000000000000052 comment=ea0178e97d5b69a87a8b9c35210c8be4674e60e6 osm2pgsql-1.9.1/000077500000000000000000000000001447112432500134545ustar00rootroot00000000000000osm2pgsql-1.9.1/.clang-format000066400000000000000000000003251447112432500160270ustar00rootroot00000000000000--- Language: Cpp BasedOnStyle: LLVM AccessModifierOffset: -4 BreakBeforeBraces: Mozilla IndentWidth: 4 ConstructorInitializerIndentWidth: 0 ReflowComments: false AlwaysBreakTemplateDeclarations: true osm2pgsql-1.9.1/.clang-tidy000066400000000000000000000067421447112432500155210ustar00rootroot00000000000000--- Checks: '*,-abseil-*,-altera-*,-android-cloexec-*,-bugprone-easily-swappable-parameters,-cert-err58-cpp,-cppcoreguidelines-avoid-magic-numbers,-cppcoreguidelines-avoid-non-const-global-variables,-cppcoreguidelines-owning-memory,-cppcoreguidelines-pro-bounds-array-to-pointer-decay,-cppcoreguidelines-pro-bounds-pointer-arithmetic,-cppcoreguidelines-pro-type-cstyle-cast,-cppcoreguidelines-pro-type-reinterpret-cast,-cppcoreguidelines-pro-type-static-cast-downcast,-cppcoreguidelines-pro-type-vararg,-fuchsia-*,-google-readability-casting,-google-readability-todo,-hicpp-named-parameter,-hicpp-no-array-decay,-hicpp-vararg,-llvm-include-order,-llvm-header-guard,-llvmlibc-*,-misc-no-recursion,-modernize-use-nodiscard,-modernize-use-trailing-return-type,-readability-identifier-length,-readability-implicit-bool-conversion,-readability-named-parameter,-readability-magic-numbers' # # cppcoreguidelines-pro-type-cstyle-cast # google-build-using-namespace # google-readability-casting # llvm-header-guard # llvm-include-order # hicpp-named-parameter # readability-named-parameter # Differ from our style guidelines # # abseil-* # Not applicable. # # altera-* # Not applicable. # # android-cloexec-* # O_CLOEXEC isn't available on Windows # # bugprone-easily-swappable-parameters # Can't always be avoided. # # cert-err58-cpp # There are many of these in the test code, most of them from the Catch # framework. Difficult to avoid. # # cppcoreguidelines-avoid-magic-numbers # readability-magic-numbers # We have a lot of these and should probably at least fix some. But remove # it for the time being because with it we can't see the forest for the # trees. (TODO) # # cppcoreguidelines-avoid-non-const-global-variables # Not wrong to avoid those, but we have a few that are hard to avoid. # Also this warning is triggered many times by constructs in the Catch test # framework. # # cppcoreguidelines-owning-memory # cppcoreguidelines-pro-bounds-array-to-pointer-decay # cppcoreguidelines-pro-bounds-pointer-arithmetic # cppcoreguidelines-pro-type-static-cast-downcast # cppcoreguidelines-pro-type-vararg # hicpp-no-array-decay # hicpp-vararg # When you need them, you need them # # fuchsia-* # Very specific and way too strict # # google-readability-todo # We are not that organized # # llvmlibc-* # Not applicable # # misc-no-recursion # Nothing wrong with recursion # # modernize-use-nodiscard # We have a lot of these. Remove it for the time being because there are # too many to fix quickly. (TODO) # # modernize-use-trailing-return-type # We are not that modern... # # readability-identifier-length # Generally not a bad idea, but there are many cases where short names # for (local) vars are okay. # # readability-implicit-bool-conversion # Readability is a matter of opinion here # #WarningsAsErrors: '*' HeaderFilterRegex: '\/src\/' CheckOptions: - key: cppcoreguidelines-special-member-functions.AllowSoleDefaultDtor value: true - key: hicpp-special-member-functions.AllowSoleDefaultDtor value: true - key: misc-non-private-member-variables-in-classes.IgnoreClassesWithAllMemberVariablesBeingPublic value: true - key: cppcoreguidelines-non-private-member-variables-in-classes.IgnoreClassesWithAllMemberVariablesBeingPublic value: true - key: readability-function-cognitive-complexity.Threshold value: 100 - key: readability-function-cognitive-complexity.IgnoreMacros value: true ... osm2pgsql-1.9.1/.github/000077500000000000000000000000001447112432500150145ustar00rootroot00000000000000osm2pgsql-1.9.1/.github/FUNDING.yml000066400000000000000000000000521447112432500166260ustar00rootroot00000000000000custom: "https://osm2pgsql.org/sponsors/" osm2pgsql-1.9.1/.github/ISSUE_TEMPLATE/000077500000000000000000000000001447112432500171775ustar00rootroot00000000000000osm2pgsql-1.9.1/.github/ISSUE_TEMPLATE/bug-report.md000066400000000000000000000023371447112432500216140ustar00rootroot00000000000000--- name: Report problems with the software about: You found a (possible) bug in osm2pgsql title: '' labels: '' assignees: '' --- ## What version of osm2pgsql are you using? ## What operating system and PostgreSQL/PostGIS version are you using? ## Tell us something about your system ## What did you do exactly? ## What did you expect to happen? ## What did happen instead? ## What did you do to try analyzing the problem? osm2pgsql-1.9.1/.github/ISSUE_TEMPLATE/config.yml000066400000000000000000000003061447112432500211660ustar00rootroot00000000000000contact_links: - name: osm2pgsql Discussions url: https://github.com/openstreetmap/osm2pgsql/discussions about: Ask questions, get support, share ideas and discuss with community members. osm2pgsql-1.9.1/.github/actions/000077500000000000000000000000001447112432500164545ustar00rootroot00000000000000osm2pgsql-1.9.1/.github/actions/build-and-test/000077500000000000000000000000001447112432500212705ustar00rootroot00000000000000osm2pgsql-1.9.1/.github/actions/build-and-test/action.yml000066400000000000000000000030421447112432500232670ustar00rootroot00000000000000name: Build and test osm2pgsql inputs: test-wrapper: description: 'Wrapper to use around tests' required: false default: pg_virtualenv runs: using: composite steps: - name: create build directory run: mkdir build shell: bash - name: configure run: | CMAKE_OPTIONS="-LA -DBUILD_TESTS=ON" if [ -z "${LUA_VERSION}" ]; then CMAKE_OPTIONS="$CMAKE_OPTIONS -DWITH_LUA=OFF" else CMAKE_OPTIONS="$CMAKE_OPTIONS -DWITH_LUAJIT=${LUAJIT_OPTION}" fi if [ -n "$USE_PROJ_LIB" ]; then CMAKE_OPTIONS="$CMAKE_OPTIONS -DUSE_PROJ_LIB=$USE_PROJ_LIB" fi if [ -n "$CPP_VERSION" ]; then CMAKE_OPTIONS="$CMAKE_OPTIONS -DCMAKE_CXX_STANDARD=$CPP_VERSION" fi if [ -n "$BUILD_TYPE" ]; then CMAKE_OPTIONS="$CMAKE_OPTIONS -DCMAKE_BUILD_TYPE=$BUILD_TYPE" fi cmake $CMAKE_OPTIONS .. shell: bash working-directory: build env: CXXFLAGS: -pedantic -Wextra ${{ env.EXTRA_FLAGS }} -Werror - name: build run: make -j3 all man shell: bash working-directory: build - name: test run: | if [ "$WRAPPER" = "pg_virtualenv" ]; then pg_virtualenv -v $POSTGRESQL_VERSION ctest --output-on-failure else $WRAPPER ctest --output-on-failure fi shell: bash working-directory: build env: WRAPPER: ${{ inputs.test-wrapper }} osm2pgsql-1.9.1/.github/actions/ubuntu-prerequisites/000077500000000000000000000000001447112432500227005ustar00rootroot00000000000000osm2pgsql-1.9.1/.github/actions/ubuntu-prerequisites/action.yml000066400000000000000000000050471447112432500247060ustar00rootroot00000000000000name: Install Prerequisites on Ubuntu runs: using: composite steps: - name: Remove preinstalled PostgreSQL run: | sudo apt-get remove -yq postgresql* sudo apt-get install curl ca-certificates gnupg curl https://www.postgresql.org/media/keys/ACCC4CF8.asc | gpg --dearmor | sudo tee /etc/apt/trusted.gpg.d/apt.postgresql.org.gpg >/dev/null sudo sh -c 'echo "deb https://apt.postgresql.org/pub/repos/apt $(lsb_release -cs)-pgdg main" > /etc/apt/sources.list.d/pgdg.list' sudo apt-get update -qq shell: bash - name: Install software run: | sudo apt-get install -yq --no-install-suggests --no-install-recommends \ cimg-dev \ libboost-filesystem-dev \ libboost-system-dev \ libbz2-dev \ libexpat1-dev \ libpotrace-dev \ libpq-dev \ libproj-dev \ nlohmann-json3-dev \ pandoc \ postgresql-${POSTGRESQL_VERSION} \ postgresql-${POSTGRESQL_VERSION}-postgis-${POSTGIS_VERSION} \ postgresql-${POSTGRESQL_VERSION}-postgis-${POSTGIS_VERSION}-scripts \ postgresql-client postgresql-contrib-${POSTGRESQL_VERSION} \ python3-setuptools \ zlib1g-dev pip3 install behave osmium if [ "$CC" = clang-8 ]; then sudo apt-get install -yq --no-install-suggests --no-install-recommends clang-8; fi if [ "$PSYCOPG" = "2"]; then sudo apt-get install -yq --no-install-suggests --no-install-recommends python3-psycopg2 else pip3 install psycopg fi shell: bash - name: Install Lua run: | if [ -n "${LUA_VERSION}" ]; then sudo apt-get install -yq --no-install-suggests --no-install-recommends liblua${LUA_VERSION}-dev lua${LUA_VERSION} fi shell: bash - name: Install LuaJIT run: | if [ "${LUAJIT_OPTION}" = "ON" ]; then sudo apt-get install -yq --no-install-suggests --no-install-recommends libluajit-5.1-dev fi shell: bash - name: Adapt PostgreSQL configuration run: | echo 'fsync = off' | sudo tee /etc/postgresql/${POSTGRESQL_VERSION}/main/conf.d/local.conf echo 'synchronous_commit = off' | sudo tee -a /etc/postgresql/${POSTGRESQL_VERSION}/main/conf.d/local.conf echo 'full_page_writes = off' | sudo tee -a /etc/postgresql/${POSTGRESQL_VERSION}/main/conf.d/local.conf echo 'shared_buffers = 1GB' | sudo tee -a /etc/postgresql/${POSTGRESQL_VERSION}/main/conf.d/local.conf shell: bash osm2pgsql-1.9.1/.github/actions/win-build/000077500000000000000000000000001447112432500203465ustar00rootroot00000000000000osm2pgsql-1.9.1/.github/actions/win-build/action.yml000066400000000000000000000002621447112432500223460ustar00rootroot00000000000000name: Windows build runs: using: composite steps: - name: Build run: cmake --build . --config Release --verbose shell: bash working-directory: build osm2pgsql-1.9.1/.github/actions/win-cmake/000077500000000000000000000000001447112432500203275ustar00rootroot00000000000000osm2pgsql-1.9.1/.github/actions/win-cmake/action.yml000066400000000000000000000006341447112432500223320ustar00rootroot00000000000000name: Windows CMake runs: using: composite steps: - name: Create build directory run: mkdir build shell: bash - name: Configure run: cmake -LA .. -DCMAKE_TOOLCHAIN_FILE=C:/vcpkg/scripts/buildsystems/vcpkg.cmake -DBUILD_TESTS=ON -DGETOPT_INCLUDE_DIR=$GETOPT_INCLUDE_DIR -DGETOPT_LIBRARY=$GETOPT_LIBRARY -DBoost_USE_STATIC_LIBS=ON shell: bash working-directory: build osm2pgsql-1.9.1/.github/actions/win-getopt/000077500000000000000000000000001447112432500205515ustar00rootroot00000000000000osm2pgsql-1.9.1/.github/actions/win-getopt/action.yml000066400000000000000000000010301447112432500225430ustar00rootroot00000000000000name: Windows getopt runs: using: composite steps: - name: Install wingetopt env: WINGETOPT_VER: v0.95 run: | git clone --quiet --depth 1 https://github.com/alex85k/wingetopt -b $WINGETOPT_VER ../wingetopt mkdir ../wingetopt/build shell: bash - name: Build wingetopt run: | cmake -LA .. -DCMAKE_TOOLCHAIN_FILE=C:/vcpkg/scripts/buildsystems/vcpkg.cmake cmake --build . --config Release --verbose working-directory: ../wingetopt/build shell: bash osm2pgsql-1.9.1/.github/actions/win-install/000077500000000000000000000000001447112432500207155ustar00rootroot00000000000000osm2pgsql-1.9.1/.github/actions/win-install/action.yml000066400000000000000000000012231447112432500227130ustar00rootroot00000000000000name: Windows install runs: using: composite steps: - name: Install packages run: | vcpkg install \ boost-filesystem:x64-windows \ boost-geometry:x64-windows \ boost-property-tree:x64-windows \ boost-system:x64-windows \ bzip2:x64-windows \ cimg:x64-windows \ expat:x64-windows \ libpq:x64-windows \ lua:x64-windows \ nlohmann-json:x64-windows \ proj4:x64-windows \ zlib:x64-windows shell: bash - name: Install psycopg2 and behave run: python -m pip install psycopg2 behave osmium shell: bash osm2pgsql-1.9.1/.github/actions/win-postgres/000077500000000000000000000000001447112432500211155ustar00rootroot00000000000000osm2pgsql-1.9.1/.github/actions/win-postgres/action.yml000066400000000000000000000017211447112432500231160ustar00rootroot00000000000000name: Set up PostgreSQL on Windows runs: using: composite steps: - name: Download postgis run: | if (!(Test-Path "C:\postgis.zip")){(new-object net.webclient).DownloadFile("https://osm2pgsql.org/ci/winbuild/postgis-bundle-pg14-3.2.0x64.zip", "c:\postgis.zip")} 7z x c:\postgis.zip -oc:\postgis_archive shell: pwsh - name: Install postgis run: | echo "Root: $PGROOT, Bin: $PGBIN" cp -r c:/postgis_archive/postgis-bundle-*/* "$PGROOT" shell: bash - name: Start PostgreSQL on Windows run: | $pgService = Get-Service -Name postgresql* Set-Service -InputObject $pgService -Status running -StartupType automatic Start-Process -FilePath "$env:PGBIN\pg_isready" -Wait -PassThru shell: pwsh - name: Create test tablespace run: | mkdir c:\tablespace & $env:PGBIN\psql -c "CREATE TABLESPACE tablespacetest LOCATION 'c:/tablespace'" shell: pwsh osm2pgsql-1.9.1/.github/actions/win-test/000077500000000000000000000000001447112432500202265ustar00rootroot00000000000000osm2pgsql-1.9.1/.github/actions/win-test/action.yml000066400000000000000000000003131447112432500222230ustar00rootroot00000000000000name: Windows test runs: using: composite steps: - name: Test run: ctest --output-on-failure -C Release env: PYTHONUTF8: 1 shell: bash working-directory: build osm2pgsql-1.9.1/.github/workflows/000077500000000000000000000000001447112432500170515ustar00rootroot00000000000000osm2pgsql-1.9.1/.github/workflows/ci.yml000066400000000000000000000267641447112432500202060ustar00rootroot00000000000000name: CI on: [ push, pull_request ] jobs: macos: strategy: fail-fast: false matrix: os: - "macos-11" - "macos-12" # latest - "macos-13" runs-on: ${{ matrix.os }} env: LUA_VERSION: 5.4 steps: - uses: actions/checkout@v3 - name: Install prerequisites run: | brew install lua boost postgis pandoc cimg potrace nlohmann-json pip3 install psycopg2 behave osmium pg_ctl -D /usr/local/var/postgres init pg_ctl -D /usr/local/var/postgres start # Work around homebrew postgresql installation screw-up, see # https://github.com/actions/runner-images/issues/6176 ln -s $(pg_config --libdir)/* /usr/local/lib/ || true ln -s $(pg_config --includedir)/* /usr/local/include/ shell: bash - name: Setup database run: | psql -d postgres -c 'CREATE EXTENSION postgis' psql -d postgres -c 'CREATE EXTENSION hstore' psql -d postgres -c 'SELECT PostGIS_Full_Version()' mkdir -m 700 $GITHUB_WORKSPACE/tablespacetest psql -d postgres -c "CREATE TABLESPACE tablespacetest LOCATION '$GITHUB_WORKSPACE/tablespacetest'" shell: bash - uses: ./.github/actions/build-and-test with: test-wrapper: '' env: PGHOST: /tmp ubuntu20-pg96-gcc10-jit: runs-on: ubuntu-20.04 env: CC: gcc-10 CXX: g++-10 EXTRA_FLAGS: -Wno-unused-but-set-parameter # workaround for GCC bug LUA_VERSION: 5.3 LUAJIT_OPTION: ON POSTGRESQL_VERSION: 9.6 POSTGIS_VERSION: 2.5 BUILD_TYPE: Release PSYCOPG: 2 steps: - uses: actions/checkout@v3 - uses: ./.github/actions/ubuntu-prerequisites - uses: ./.github/actions/build-and-test ubuntu20-pg96-clang10-jit: runs-on: ubuntu-20.04 env: CC: clang-10 CXX: clang++-10 LUA_VERSION: 5.3 LUAJIT_OPTION: ON POSTGRESQL_VERSION: 9.6 POSTGIS_VERSION: 2.5 BUILD_TYPE: Release PSYCOPG: 2 steps: - uses: actions/checkout@v3 - uses: ./.github/actions/ubuntu-prerequisites - uses: ./.github/actions/build-and-test ubuntu20-pg10-gcc10: runs-on: ubuntu-20.04 env: CC: gcc-10 CXX: g++-10 EXTRA_FLAGS: -Wno-unused-but-set-parameter # workaround for GCC bug LUA_VERSION: 5.3 LUAJIT_OPTION: OFF POSTGRESQL_VERSION: 10 POSTGIS_VERSION: 3 BUILD_TYPE: Debug PSYCOPG: 2 steps: - uses: actions/checkout@v3 - uses: ./.github/actions/ubuntu-prerequisites - uses: ./.github/actions/build-and-test ubuntu20-pg11-clang10: runs-on: ubuntu-20.04 env: CC: clang-10 CXX: clang++-10 LUA_VERSION: 5.3 LUAJIT_OPTION: OFF POSTGRESQL_VERSION: 11 POSTGIS_VERSION: 2.5 BUILD_TYPE: Debug PSYCOPG: 2 steps: - uses: actions/checkout@v3 - uses: ./.github/actions/ubuntu-prerequisites - uses: ./.github/actions/build-and-test ubuntu20-pg12-gcc10-jit: runs-on: ubuntu-20.04 env: CC: gcc-10 CXX: g++-10 LUA_VERSION: 5.3 LUAJIT_OPTION: ON POSTGRESQL_VERSION: 12 POSTGIS_VERSION: 2.5 BUILD_TYPE: Debug PSYCOPG: 2 steps: - uses: actions/checkout@v3 - uses: ./.github/actions/ubuntu-prerequisites - uses: ./.github/actions/build-and-test ubuntu20-pg13-clang10-jit: runs-on: ubuntu-20.04 env: CC: clang-10 CXX: clang++-10 LUA_VERSION: 5.3 LUAJIT_OPTION: ON POSTGRESQL_VERSION: 13 POSTGIS_VERSION: 3 BUILD_TYPE: Debug PSYCOPG: 2 steps: - uses: actions/checkout@v3 - uses: ./.github/actions/ubuntu-prerequisites - uses: ./.github/actions/build-and-test ubuntu20-pg13-clang10-proj6: runs-on: ubuntu-20.04 env: CC: clang-10 CXX: clang++-10 LUA_VERSION: 5.3 LUAJIT_OPTION: OFF POSTGRESQL_VERSION: 13 POSTGIS_VERSION: 3 USE_PROJ_LIB: 6 BUILD_TYPE: Debug PSYCOPG: 2 steps: - uses: actions/checkout@v3 - uses: ./.github/actions/ubuntu-prerequisites - uses: ./.github/actions/build-and-test ubuntu20-pg13-clang10-noproj: runs-on: ubuntu-20.04 env: CC: clang-10 CXX: clang++-10 LUA_VERSION: 5.3 LUAJIT_OPTION: OFF POSTGRESQL_VERSION: 13 POSTGIS_VERSION: 3 USE_PROJ_LIB: off BUILD_TYPE: Debug PSYCOPG: 2 steps: - uses: actions/checkout@v3 - uses: ./.github/actions/ubuntu-prerequisites - uses: ./.github/actions/build-and-test ubuntu20-pg13-clang10-cpp17: runs-on: ubuntu-20.04 env: CC: clang-10 CXX: clang++-10 LUA_VERSION: 5.3 LUAJIT_OPTION: OFF POSTGRESQL_VERSION: 14 POSTGIS_VERSION: 3 USE_PROJ_LIB: 6 BUILD_TYPE: Debug PSYCOPG: 2 steps: - uses: actions/checkout@v3 - uses: ./.github/actions/ubuntu-prerequisites - uses: ./.github/actions/build-and-test ubuntu20-pg13-gcc10-release: runs-on: ubuntu-20.04 env: CC: gcc-10 CXX: g++-10 LUA_VERSION: 5.3 LUAJIT_OPTION: ON POSTGRESQL_VERSION: 13 POSTGIS_VERSION: 2.5 BUILD_TYPE: Release PSYCOPG: 2 steps: - uses: actions/checkout@v3 - uses: ./.github/actions/ubuntu-prerequisites - uses: ./.github/actions/build-and-test ubuntu20-pg13-gcc10-release-nolua: runs-on: ubuntu-20.04 env: CC: gcc-10 CXX: g++-10 POSTGRESQL_VERSION: 13 POSTGIS_VERSION: 2.5 BUILD_TYPE: Release PSYCOPG: 2 steps: - uses: actions/checkout@v3 - uses: ./.github/actions/ubuntu-prerequisites - uses: ./.github/actions/build-and-test ubuntu22-pg14-clang14-jit: runs-on: ubuntu-22.04 env: CC: clang-14 CXX: clang++-14 LUA_VERSION: 5.4 LUAJIT_OPTION: ON POSTGRESQL_VERSION: 14 POSTGIS_VERSION: 3 BUILD_TYPE: Debug PSYCOPG: 2 steps: - uses: actions/checkout@v3 - uses: ./.github/actions/ubuntu-prerequisites - uses: ./.github/actions/build-and-test ubuntu22-pg14-clang14-proj6: runs-on: ubuntu-22.04 env: CC: clang-14 CXX: clang++-14 LUA_VERSION: 5.4 LUAJIT_OPTION: OFF POSTGRESQL_VERSION: 14 POSTGIS_VERSION: 3 USE_PROJ_LIB: 6 BUILD_TYPE: Debug PSYCOPG: 2 steps: - uses: actions/checkout@v3 - uses: ./.github/actions/ubuntu-prerequisites - uses: ./.github/actions/build-and-test ubuntu22-pg14-clang14-noproj: runs-on: ubuntu-22.04 env: CC: clang-14 CXX: clang++-14 LUA_VERSION: 5.3 LUAJIT_OPTION: OFF POSTGRESQL_VERSION: 14 POSTGIS_VERSION: 3 USE_PROJ_LIB: off BUILD_TYPE: Debug PSYCOPG: 2 steps: - uses: actions/checkout@v3 - uses: ./.github/actions/ubuntu-prerequisites - uses: ./.github/actions/build-and-test ubuntu22-pg14-clang14-cpp17: runs-on: ubuntu-22.04 env: CC: clang-14 CXX: clang++-14 LUA_VERSION: 5.4 LUAJIT_OPTION: OFF POSTGRESQL_VERSION: 14 POSTGIS_VERSION: 3 USE_PROJ_LIB: 6 BUILD_TYPE: Debug PSYCOPG: 2 steps: - uses: actions/checkout@v3 - uses: ./.github/actions/ubuntu-prerequisites - uses: ./.github/actions/build-and-test ubuntu22-pg14-gcc12-release: runs-on: ubuntu-22.04 env: CC: gcc-12 CXX: g++-12 EXTRA_FLAGS: -Wno-stringop-overread LUA_VERSION: 5.4 LUAJIT_OPTION: ON POSTGRESQL_VERSION: 14 POSTGIS_VERSION: 3 BUILD_TYPE: Release PSYCOPG: 2 steps: - uses: actions/checkout@v3 - uses: ./.github/actions/ubuntu-prerequisites - uses: ./.github/actions/build-and-test ubuntu22-pg14-gcc12-release-nolua: runs-on: ubuntu-22.04 env: CC: gcc-12 CXX: g++-12 EXTRA_FLAGS: -Wno-stringop-overread POSTGRESQL_VERSION: 14 POSTGIS_VERSION: 3 BUILD_TYPE: Release PSYCOPG: 2 steps: - uses: actions/checkout@v3 - uses: ./.github/actions/ubuntu-prerequisites - uses: ./.github/actions/build-and-test ubuntu22-pg14-clang14-cpp20: runs-on: ubuntu-22.04 env: CC: clang-14 CXX: clang++-14 LUA_VERSION: 5.3 LUAJIT_OPTION: OFF POSTGRESQL_VERSION: 14 POSTGIS_VERSION: 3 CPP_VERSION: 20 BUILD_TYPE: Debug PSYCOPG: 3 steps: - uses: actions/checkout@v3 - uses: ./.github/actions/ubuntu-prerequisites - uses: ./.github/actions/build-and-test ubuntu22-pg14-gcc12-cpp20: runs-on: ubuntu-22.04 env: CC: gcc-12 CXX: g++-12 LUA_VERSION: 5.3 LUAJIT_OPTION: OFF POSTGRESQL_VERSION: 14 POSTGIS_VERSION: 3 CPP_VERSION: 20 BUILD_TYPE: Debug PSYCOPG: 3 steps: - uses: actions/checkout@v3 - uses: ./.github/actions/ubuntu-prerequisites - uses: ./.github/actions/build-and-test windows: strategy: fail-fast: false matrix: os: [windows-2019, windows-2022] runs-on: ${{ matrix.os }} env: GETOPT_INCLUDE_DIR: ${{ github.workspace }}/../wingetopt/src GETOPT_LIBRARY: ${{ github.workspace }}/../wingetopt/build/Release/wingetopt.lib VCPKG_DEFAULT_BINARY_CACHE: C:/vcpkg_binary_cache steps: - uses: actions/checkout@v3 - uses: actions/cache@v3 with: path: | C:/vcpkg_binary_cache key: vcpkg-binary-cache-${{ matrix.os }}-${{ github.run_id }} restore-keys: | vcpkg-binary-cache-${{ matrix.os }} - uses: actions/cache@v3 with: path: | C:/postgis.zip key: postgis-cache - name: Prepare cache run: if [ ! -d C:/vcpkg_binary_cache ]; then mkdir C:/vcpkg_binary_cache; fi shell: bash - uses: ./.github/actions/win-postgres - uses: ./.github/actions/win-install - uses: ./.github/actions/win-getopt - uses: ./.github/actions/win-cmake - uses: ./.github/actions/win-build - uses: ./.github/actions/win-test - name: Package osm2pgsql run: | mkdir c:/artifact/ mkdir c:/artifact/osm2pgsql-bin cp -r Release/* ../README.md ../COPYING ../*.style ../scripts ../flex-config c:/artifact/osm2pgsql-bin/ shell: bash working-directory: build if: matrix.os == 'windows-2022' - name: 'Upload Artifact' uses: actions/upload-artifact@v3 with: name: osm2pgsql-win64 path: c:/artifact if: matrix.os == 'windows-2022' windows-package: needs: windows runs-on: windows-2022 env: OSMURL: https://download.geofabrik.de/europe/monaco-latest.osm.bz2 steps: - uses: actions/checkout@v3 - uses: actions/cache@v3 with: path: | C:/postgis.zip key: postgis-cache - uses: actions/download-artifact@v3 with: name: osm2pgsql-win64 - uses: ./.github/actions/win-postgres - name: Set up database run: | & $env:PGBIN\createdb osm & $env:PGBIN\psql -d osm -c "CREATE EXTENSION hstore; CREATE EXTENSION postgis;" shell: pwsh - name: Get test data run: (new-object net.webclient).DownloadFile($env:OSMURL, "testfile.osm.bz2") - name: Execute osm2pgsql run: ./osm2pgsql-bin/osm2pgsql --slim -d osm testfile.osm.bz2 shell: bash osm2pgsql-1.9.1/.github/workflows/luacheck.yml000066400000000000000000000007171447112432500213600ustar00rootroot00000000000000name: Check Lua scripts with luacheck on: [ push, pull_request ] jobs: luacheck: runs-on: ubuntu-latest steps: - uses: actions/checkout@v3 - name: Install prerequisites run: | sudo apt-get update -qq sudo apt-get install -yq --no-install-suggests --no-install-recommends lua-check - name: Run luacheck run: luacheck flex-config/*.lua flex-config/gen/*.lua tests/data/*.lua tests/lua/tests.lua osm2pgsql-1.9.1/.github/workflows/test-install.yml000066400000000000000000000103411447112432500222160ustar00rootroot00000000000000name: Test install on: [ push, pull_request ] jobs: ubuntu-test-install: runs-on: ubuntu-22.04 strategy: matrix: flavour: [public, middle_schema] include: - flavour: public options: "" schema: "" - flavour: middle_schema options: "--middle-schema=myschema" schema: "myschema" env: LUA_VERSION: 5.3 POSTGRESQL_VERSION: 14 POSTGIS_VERSION: 3 BUILD_TYPE: Release CXXFLAGS: -pedantic -Wextra -Wno-stringop-overread -Werror PREFIX: /usr/local OSMURL: https://download.geofabrik.de/europe/monaco-latest.osm.pbf OSMFILE: monaco-latest.osm.pbf steps: - uses: actions/checkout@v3 - name: Show installed PostgreSQL packages run: apt-cache search postgresql | sort - name: Install prerequisites run: | sudo apt-get purge -yq postgresql* sudo apt-get update -qq sudo apt-get install -yq --no-install-suggests --no-install-recommends \ cimg-dev \ libboost-filesystem-dev \ libboost-system-dev \ libbz2-dev \ libexpat1-dev \ liblua${LUA_VERSION}-dev \ libluajit-5.1-dev \ libpotrace-dev \ libpq-dev \ libproj-dev \ nlohmann-json3-dev \ lua${LUA_VERSION} \ pandoc \ postgresql-${POSTGRESQL_VERSION} \ postgresql-${POSTGRESQL_VERSION}-postgis-${POSTGIS_VERSION} \ postgresql-${POSTGRESQL_VERSION}-postgis-${POSTGIS_VERSION}-scripts \ postgresql-client-${POSTGRESQL_VERSION} \ python3-pyosmium \ python3-psycopg2 \ zlib1g-dev - name: Run CMake run: | mkdir build cd build cmake .. -DCMAKE_BUILD_TYPE=$BUILD_TYPE - name: Build osm2pgsql working-directory: build run: make -j3 all man - name: Install osm2pgsql working-directory: build run: sudo make install - name: Check osm2pgsql install run: | test -d $PREFIX/bin test -e $PREFIX/bin/osm2pgsql test -e $PREFIX/bin/osm2pgsql-replication test -d $PREFIX/share/man/man1 test -f $PREFIX/share/man/man1/osm2pgsql.1 test -f $PREFIX/share/man/man1/osm2pgsql-replication.1 test -d $PREFIX/share/osm2pgsql test -f $PREFIX/share/osm2pgsql/default.style test -f $PREFIX/share/osm2pgsql/empty.style - name: Set up test databases run: | sudo systemctl start postgresql sudo -u postgres createuser runner sudo -u postgres createdb -O runner o2ptest sudo -u postgres psql o2ptest -c "CREATE EXTENSION postgis" sudo -u postgres psql o2ptest -c "CREATE EXTENSION hstore" - name: Set up schema run: | sudo -u postgres psql o2ptest -c "CREATE SCHEMA $SCHEMANAME" sudo -u postgres psql o2ptest -c "GRANT ALL ON SCHEMA $SCHEMANAME TO runner" if: ${{ matrix.schema }} env: SCHEMANAME: ${{ matrix.schema }} - name: Remove repository # Remove contents of workspace to be sure the install runs independently working-directory: / run: rm -fr "${{github.workspace}}"/* - name: Show man pages run: | man -P cat osm2pgsql man -P cat osm2pgsql-replication - name: Download test file run: wget --quiet $OSMURL working-directory: /tmp - name: Test run of osm2pgsql (no schema) run: $PREFIX/bin/osm2pgsql $EXTRAOPTS -d o2ptest --slim $OSMFILE working-directory: /tmp env: EXTRAOPTS: ${{ matrix.options }} - name: Test run osm2pgsql-replication (no schema) run: | $PREFIX/bin/osm2pgsql-replication init $EXTRAOPTS -v -d o2ptest $PREFIX/bin/osm2pgsql-replication status $EXTRAOPTS -v -d o2ptest $PREFIX/bin/osm2pgsql-replication update $EXTRAOPTS -v -d o2ptest --once --max-diff-size=1 $PREFIX/bin/osm2pgsql-replication status $EXTRAOPTS -v -d o2ptest --json working-directory: /tmp env: EXTRAOPTS: ${{ matrix.options }} osm2pgsql-1.9.1/.gitignore000066400000000000000000000000511447112432500154400ustar00rootroot00000000000000build docs/html docs/latex __pycache__ osm2pgsql-1.9.1/.luacheckrc000066400000000000000000000015651447112432500155700ustar00rootroot00000000000000-- -- Configuration for luacheck -- -- To check Lua files call like this: -- luacheck flex-config/*.lua flex-config/gen/*.lua tests/data/*.lua tests/lua/tests.lua -- unused_args = false stds.osm2pgsql = { read_globals = { osm2pgsql = { fields = { process_node = { read_only = false }, process_way = { read_only = false }, process_relation = { read_only = false }, select_relation_members = { read_only = false }, process_gen = { read_only = false }, }, other_fields = true, } } } std = 'min+osm2pgsql' files['tests/lua/tests.lua'].globals = { 'osm2pgsql' } osm2pgsql-1.9.1/AUTHORS000066400000000000000000000003441447112432500145250ustar00rootroot00000000000000osm2pgsql was written by Jon Burgess, Artem Pavlenko, Martijn van Oosterhout Sarah Hoffmann, Kai Krueger, Frederik Ramm, Brian Quinion, Matt Amos, Kevin Kreiser, Paul Norman, Jochen Topf and other OpenStreetMap project members. osm2pgsql-1.9.1/CMakeLists.txt000066400000000000000000000310551447112432500162200ustar00rootroot00000000000000 cmake_minimum_required(VERSION 3.8.0) project(osm2pgsql VERSION 1.9.1 LANGUAGES CXX C) set(CMAKE_EXPORT_COMPILE_COMMANDS ON) list(APPEND CMAKE_MODULE_PATH "${CMAKE_CURRENT_SOURCE_DIR}/cmake") # Do not create install targets when run as a subproject. # Currently used by Nominatim which cannot yet rely on installed versions # of osm2pgsql. if (${PROJECT_NAME} STREQUAL ${CMAKE_PROJECT_NAME}) set(ENABLE_INSTALL ON) else() set(ENABLE_INSTALL OFF) endif() if (WIN32) set(DEFAULT_STYLE "default.style" CACHE STRING "Default style used unless one is given on the command line") else() set(DEFAULT_STYLE "${CMAKE_INSTALL_PREFIX}/share/osm2pgsql/default.style" CACHE STRING "Default style used unless one is given on the command line") endif() option(BUILD_TESTS "Build test suite" OFF) option(BUILD_COVERAGE "Build with coverage" OFF) option(WITH_LUA "Build with Lua support" ON) option(WITH_LUAJIT "Build with LuaJIT support" OFF) if (PROJECT_SOURCE_DIR STREQUAL PROJECT_BINARY_DIR) message(FATAL_ERROR "In-source builds are not allowed, please use a separate build directory like `mkdir build && cd build && cmake ..`") endif() message(STATUS "Building osm2pgsql ${PROJECT_VERSION}") if (NOT CMAKE_BUILD_TYPE) set(CMAKE_BUILD_TYPE RelWithDebInfo) endif() # We don't want to use special compiler extensions because we want portability set(CMAKE_CXX_EXTENSIONS OFF) if (MSVC) add_definitions(-D_CRT_SECURE_NO_WARNINGS -DNOMINMAX) add_compile_options(-wd4996) set(CMAKE_EXE_LINKER_FLAGS "${CMAKE_EXE_LINKER_FLAGS} /ignore:4099 /STACK:30000000") else() add_compile_options(-Wall) endif() option(EXTERNAL_LIBOSMIUM "Do not use the bundled libosmium" OFF) option(EXTERNAL_PROTOZERO "Do not use the bundled protozero" OFF) option(EXTERNAL_FMT "Do not use the bundled fmt" OFF) set(USE_PROJ_LIB "auto" CACHE STRING "Which version of PROJ API to use: ('4', '6', 'off', or 'auto')") if (NOT WIN32 AND NOT APPLE) # No need for this path, just a workaround to make cmake work on all systems. # Without this we need the PostgreSQL server libraries installed. # https://stackoverflow.com/questions/13920383/findpostgresql-cmake-wont-work-on-ubuntu set(PostgreSQL_TYPE_INCLUDE_DIR /usr/include) endif() set(MINIMUM_POSTGRESQL_SERVER_VERSION "9.6") set(MINIMUM_POSTGRESQL_SERVER_VERSION_NUM "90600") set(PostgreSQL_ADDITIONAL_VERSIONS "15" "14" "13" "12" "11" "10" "9.6") ############################################################# # Version ############################################################# find_package(Git) if (GIT_FOUND) execute_process(COMMAND "${GIT_EXECUTABLE}" describe --tags --dirty=-changed WORKING_DIRECTORY "${PROJECT_SOURCE_DIR}" OUTPUT_VARIABLE VERSION_FROM_GIT ERROR_QUIET OUTPUT_STRIP_TRAILING_WHITESPACE) if (VERSION_FROM_GIT) set(VERSION_FROM_GIT " (${VERSION_FROM_GIT})") endif() endif() configure_file( ${PROJECT_SOURCE_DIR}/src/version.cpp.in ${PROJECT_BINARY_DIR}/src/version.cpp ) ############################################################# # Coverage ############################################################# if (BUILD_COVERAGE) if (NOT BUILD_TESTS) message(WARNING "Coverage build enabled, but tests not enabled!") endif() if (CMAKE_CXX_COMPILER_ID STREQUAL "Clang") string(REGEX REPLACE "^([0-9]+).*$" "llvm-cov-\\1" gcov_ ${CMAKE_CXX_COMPILER_VERSION}) set(gcov_param_ " gcov") else() set(gcov_ "gcov") set(gcov_param_ "") endif() message(STATUS "Looking for coverage tool: ${gcov_}") find_program(GCOV ${gcov_} DOC "Coverage tool") if (GCOV STREQUAL "GCOV-NOTFOUND") message(STATUS " coverage tool not found - coverage disabled") else() message(STATUS " found") message(STATUS "Looking von gcovr") find_program(GCOVR "gcovr" DOC "Coverage report tool") if (GCOVR STREQUAL "GCOVR-NOTFOUND") message(WARNING " gcovr not found - coverage will not work") else() message(STATUS " found") endif() add_compile_options(-g -O0 -fno-inline-functions -fno-inline --coverage) set(CMAKE_EXE_LINKER_FLAGS "${CMAKE_EXE_LINKER_FLAGS} --coverage" CACHE STRING "Flags used by the linker during all build types." FORCE) set(coverage_report_dir "${CMAKE_BINARY_DIR}/coverage") file(MAKE_DIRECTORY ${coverage_report_dir}) add_custom_target(coverage ${GCOVR} ${CMAKE_BINARY_DIR} --root=${CMAKE_SOURCE_DIR} --html-details --html-title "osm2pgsql coverage report" #--verbose #--keep --delete '--exclude=.*contrib.*' --sort-percentage --gcov-executable=${GCOV}${gcov_param_} --output=${coverage_report_dir}/index.html) endif() endif() ############################################################# # Detect available headers and set global compiler options ############################################################# include(CheckIncludeFiles) add_definitions(-DDEFAULT_STYLE=\"${DEFAULT_STYLE}\") ############################################################# # Find necessary libraries ############################################################# if (NOT EXTERNAL_LIBOSMIUM) set(OSMIUM_INCLUDE_DIR "${CMAKE_CURRENT_SOURCE_DIR}/contrib/libosmium/include") endif() if (NOT EXTERNAL_PROTOZERO) set(PROTOZERO_INCLUDE_DIR "${CMAKE_CURRENT_SOURCE_DIR}/contrib/protozero/include") endif() if (NOT EXTERNAL_FMT) set(FMT_INCLUDE_DIR "${CMAKE_CURRENT_SOURCE_DIR}/contrib/fmt/include") endif() include_directories(${CMAKE_CURRENT_SOURCE_DIR}/src ${CMAKE_CURRENT_BINARY_DIR}) find_package(Osmium 2.17.3 REQUIRED COMPONENTS io) include_directories(SYSTEM ${OSMIUM_INCLUDE_DIRS} ${PROTOZERO_INCLUDE_DIR} ${FMT_INCLUDE_DIR}) if (WITH_LUA) if (WITH_LUAJIT) message(STATUS "Building with LuaJIT support") find_package(LuaJIT REQUIRED) include_directories(SYSTEM ${LUAJIT_INCLUDE_DIR}) add_definitions(-DHAVE_LUAJIT=1) else() message(STATUS "Building with Lua support") find_package(Lua REQUIRED) include_directories(SYSTEM ${LUA_INCLUDE_DIR}) endif() add_definitions(-DHAVE_LUA=1) find_program(LUA_EXE NAMES lua lua5.4 lua5.3 lua5.2 lua5.1) else() message(STATUS "Building without Lua support") endif() find_package(Boost 1.50 REQUIRED COMPONENTS system filesystem) include_directories(SYSTEM ${Boost_INCLUDE_DIR}) find_package(PostgreSQL REQUIRED) include_directories(SYSTEM ${PostgreSQL_INCLUDE_DIRS}) find_package(Threads) find_path(NLOHMANN_INCLUDE_DIR nlohmann/json.hpp) include_directories(SYSTEM ${NLOHMANN_INCLUDE_DIR}) find_path(POTRACE_INCLUDE_DIR potracelib.h) find_library(POTRACE_LIBRARY NAMES potrace) find_path(CIMG_INCLUDE_DIR CImg.h) ############### Libraries are found now ######################## set(LIBS ${Boost_LIBRARIES} ${PostgreSQL_LIBRARY} ${OSMIUM_LIBRARIES}) if (USE_PROJ_LIB STREQUAL "off") message(STATUS "Proj library disabled (because USE_PROJ_LIB is set to 'off').") else() find_path(PROJ4_INCLUDE_DIR proj_api.h) if (PROJ4_INCLUDE_DIR AND NOT USE_PROJ_LIB STREQUAL "6") message(STATUS "Found proj_api.h") find_library(PROJ_LIBRARY NAMES proj) message(STATUS "Found Proj [API 4] ${PROJ_LIBRARY}") add_definitions(-DHAVE_GENERIC_PROJ=4) set(HAVE_PROJ4 1) list(APPEND LIBS ${PROJ_LIBRARY}) include_directories(SYSTEM ${PROJ4_INCLUDE_DIR}) elseif (NOT USE_PROJ_LIB STREQUAL "4") find_path(PROJ6_INCLUDE_DIR proj.h) find_library(PROJ_LIBRARY NAMES proj) if (PROJ_LIBRARY) message(STATUS "Found Proj [API 6] ${PROJ_LIBRARY}") add_definitions(-DHAVE_GENERIC_PROJ=6) set(HAVE_PROJ6 1) list(APPEND LIBS ${PROJ_LIBRARY}) include_directories(SYSTEM ${PROJ6_INCLUDE_DIR}) else() message(STATUS "Proj library not found.") message(STATUS " Only Mercartor and WGS84 projections will be available.") endif() endif() endif() if (USE_PROJ_LIB STREQUAL "4" AND NOT HAVE_PROJ4) message(FATAL_ERROR "USE_PROJ_LIB was set to '4', but PROJ version 4 API not found") endif() if (USE_PROJ_LIB STREQUAL "6" AND NOT HAVE_PROJ6) message(FATAL_ERROR "USE_PROJ_LIB was set to '6', but PROJ version 6 API not found") endif() if (LUAJIT_FOUND) list(APPEND LIBS ${LUAJIT_LIBRARIES}) elseif (LUA_FOUND) list(APPEND LIBS ${LUA_LIBRARIES}) endif() if (WIN32) list(APPEND LIBS ws2_32) if (MSVC) find_path(GETOPT_INCLUDE_DIR getopt.h) find_library(GETOPT_LIBRARY NAMES wingetopt getopt) if (GETOPT_INCLUDE_DIR AND GETOPT_LIBRARY) include_directories(SYSTEM ${GETOPT_INCLUDE_DIR}) list(APPEND LIBS ${GETOPT_LIBRARY}) else() message(FATAL_ERROR "Can not find getopt library for Windows. Please get it from https://github.com/alex85k/wingetopt or alternative source.") endif() endif() endif() message(STATUS "Libraries used to build: ${LIBS}") ############################################################# # Build the library and executable file ############################################################# add_subdirectory(src) add_executable(osm2pgsql src/osm2pgsql.cpp) target_link_libraries(osm2pgsql osm2pgsql_lib ${LIBS}) if (${POTRACE_LIBRARY} STREQUAL "POTRACE_LIBRARY-NOTFOUND" OR ${CIMG_INCLUDE_DIR} STREQUAL "CIMG_INCLUDE_DIR-NOTFOUND") message(STATUS "Did not find cimg and/or potrace library. Not building osm2pgsql-gen.") else() if (WITH_LUA) message(STATUS "Found cimg and potrace library. Building osm2pgsql-gen.") set(BUILD_GEN 1) include_directories(SYSTEM ${CIMG_INCLUDE_DIR}) include_directories(SYSTEM ${POTRACE_INCLUDE_DIR}) add_executable(osm2pgsql-gen src/gen/osm2pgsql-gen.cpp src/gen/canvas.cpp src/gen/gen-base.cpp src/gen/gen-create.cpp src/gen/gen-discrete-isolation.cpp src/gen/gen-rivers.cpp src/gen/gen-tile-builtup.cpp src/gen/gen-tile-raster.cpp src/gen/gen-tile-vector.cpp src/gen/gen-tile.cpp src/gen/params.cpp src/gen/raster.cpp src/gen/tracer.cpp) target_link_libraries(osm2pgsql-gen osm2pgsql_lib ${LIBS} ${POTRACE_LIBRARY}) else() message(STATUS "No Lua. Not building osm2pgsql-gen.") endif() endif() ############################################################# # Optional "clang-tidy" target ############################################################# message(STATUS "Looking for clang-tidy") find_program(CLANG_TIDY NAMES clang-tidy clang-tidy-16 clang-tidy-15 clang-tidy-14 clang-tidy-13 clang-tidy-12 clang-tidy-11) if (CLANG_TIDY) message(STATUS "Looking for clang-tidy - found ${CLANG_TIDY}") file(GLOB CT_CHECK_FILES src/*.cpp src/*/*.cpp tests/*cpp) add_custom_target(clang-tidy ${CLANG_TIDY} -p ${CMAKE_BINARY_DIR} ${CT_CHECK_FILES} ) else() message(STATUS "Looking for clang-tidy - not found") message(STATUS " Build target 'clang-tidy' will not be available.") endif() ############################################################# # Build tests ############################################################# if (BUILD_TESTS) enable_testing() if (NOT TESTING_TIMEOUT) set(TESTING_TIMEOUT 1200) endif() add_subdirectory(tests) configure_file( ${PROJECT_SOURCE_DIR}/tests/run-behave.in ${PROJECT_BINARY_DIR}/run-behave ) else() message(STATUS "Tests disabled. Set BUILD_TESTS=ON to enable tests.") endif() ############################################################# # Man page ############################################################# add_subdirectory(docs) ############################################################# # Install ############################################################# include(GNUInstallDirs) if (ENABLE_INSTALL) install(TARGETS osm2pgsql DESTINATION bin) install(FILES default.style empty.style DESTINATION share/osm2pgsql) install(PROGRAMS scripts/osm2pgsql-replication DESTINATION bin) if (BUILD_GEN) install(TARGETS osm2pgsql-gen COMPONENT gen EXCLUDE_FROM_ALL DESTINATION bin) add_custom_target(install-gen cmake --install ${CMAKE_BINARY_DIR} --component gen) endif() endif() osm2pgsql-1.9.1/CONTRIBUTING.md000066400000000000000000000200761447112432500157120ustar00rootroot00000000000000# Osm2pgsql contribution guidelines ## Workflow We operate the "Fork & Pull" model explained at https://help.github.com/articles/using-pull-requests You should fork the project into your own repo, create a topic branch there and then make one or more pull requests back to the OpenStreetMap repository. Your pull requests will then be reviewed and discussed. ## History To understand the osm2pgsql code, it helps to know some history on it. Osm2pgsql was written in C in 2007 as a port of an older Python utility. In 2014 it was ported to C++ by MapQuest and the last C version was released as 0.86.0. In it's time, it has had varying contribution activity, including times with no maintainer or active developers. Parts of the codebase still clearly show their C origin and could use rewriting in modern C++, making use of data structures in the standard library. ## Versioning Osm2pgsql uses [semantic versioning](https://semver.org/). Bugs and known issues are fixed on the main branch only. Exceptions may be made for severe bugs. ## Code style Code must be written in the [K&R 1TBS style](https://en.wikipedia.org/wiki/Indent_style#Variant:_1TBS) with 4 spaces indentation. Tabs should never be used in the C++ code. Braces must always be used for code blocks, even one-liners. Names should use underscores, not camel case, with class/struct names ending in `_t`. Template parameters must use all upper case. Headers should be included in the order C++ standard library headers, C library headers, Boost headers, and last osm2pgsql files. There is a .clang-format configuration available and all code must be run through clang-format before submitting. You can use git-clang-format after staging all your changes: git-clang-format src/*pp tests/*pp clang-format 7 or later is required. Comments in code should follow the [Doxygen convention](https://www.doxygen.nl/manual/docblocks.html) using backslashes (not @-signs) for commands. ## Documentation User documentation is available on [the website](https://osm2pgsql.org/), some is stored in `docs/`. Pages on the OpenStreetMap wiki are known to be unreliable and outdated. The man pages for [osm2pgsql](docs/osm2pgsql.1) and [osm2pgsql-replication](docs/osm2pgsql-replication.1) can be built from source with `make man`. They need pandoc and argparse-manpage for the conversion. These tools can be installed with: ```sh sudo apt-get install pandoc python3-argparse-manpage ``` Results should be checked into the repository. ## Platforms targeted Ideally osm2pgsql should compile on Linux, OS X, FreeBSD and Windows. It is actively tested on Debian, Ubuntu and FreeBSD by the maintainers. ## Testing osm2pgsql is tested with two types of tests: Classic tests written in C++ and BDD (Behavior Driven Development) tests written in Python. ### Classic Tests The code comes with a suite of tests. They are only compiled and run when `BUILD_TESTS=ON` is set in the CMake config. Tests are executed by calling `ctest`. You can call `ctest` with `-L NoDB` to only run tests that don't need a database. Most of these tests depend on being able to set up a database and run osm2pgsql against it. This is most easily done using `pg_virtualenv`. Just run ```sh pg_virtualenv ctest ``` `pg_virtualenv` creates a separate postgres server instance. The test databases are created in this instance and the complete server is destroyed after the tests are finished. ctest also calls appropriate fixtures that create the separate tablespace required for some tests. When running without `pg_virtualenv`, you need to ensure that PostgreSQL is running and that your user is a superuser of that system. You also need to create an appropriate test tablespace manually. To do that, run: ```sh sudo -u postgres createuser -s $USER sudo mkdir -p /tmp/psql-tablespace sudo chown postgres.postgres /tmp/psql-tablespace psql -c "CREATE TABLESPACE tablespacetest LOCATION '/tmp/psql-tablespace'" postgres ``` Once this is all set up, all the tests should run (no SKIPs), and pass (no FAILs). If you find something which seems to be a bug, please check to see if it is a known issue at https://github.com/openstreetmap/osm2pgsql/issues and, if it's not already known, report it there. If you have failing tests and want to look at the test database to figure out what's happening, you can set the environment variable `OSM2PGSQL_KEEP_TEST_DB` to anything. This will disable the database cleanup at the end of the test. This will often be used together with the `-s` option of `pg_virtualenv` which drops you into a shell after a failed test where you can still access the database created by `pg_virtualenv`. ### BDD Tests Tests in the `tests/bdd` directory use [behave](https://github.com/behave/behave), a Python implementation of a behaviour-driven test framework. To run the BDD tests you need to have behave and psycopg2 installed. On Ubuntu run: ```sh sudo apt-get install python3-psycopg2 python3-behave ``` There are ctest directives to run the tests. If you want to run the tests manually, for example to run single tests during development, you can switch to the bdd test directory and run behave directly from there: ```sh cd osm2pgsql/tests/bdd behave -DBINARY=/osm2pgsql ``` Per default, behave assumes that the build directory is under `osm2pgsql/build`. If your setup works like that, you can leave out the `-D` parameter. To make this a bit easier a shell script `run-behave` is provided in your build directory which sets those correct paths and calls `behave`. If run with `-p` as first option it will wrap the call to `behave` in a call to `pg_virtualenv` for your convenience. All other command line parameters of `run-behave` will be passed through to behave. To run a single test, simply add the name of the test file, followed by a column and the line number of the test: ```sh behave flex/area.feature:71 ``` If you need to inspect the database that a test produces, you can add `-DKEEP_TEST_DB` and behave won't remove the database after the test is finished. This makes of course only sense, when running a single test. When running under pg_virtualenv, don't forget to keep the virtual environment as well. You can use the handy `-s` switch: ```sh pg_virtualenv -s behave -DKEEP_TEST_DB flex/area.feature:71 ``` It drops you into a shell when the behave test fails, where you can use psql to look at the database. Or start a shell in the virtual environment with `pg_virtualenv bash` and run behave from there. The BDDs automatically detect if osm2pgsql was compiled with Lua and proj support and skip tests accordingly. They also check for the test tablespace `tablespacetest` for tests that need tablespaces. BDD tests hide print statements by default. For development purposes they can be shown by adding these lines to `tests/bdd/.behaverc`: ``` color=False stdout_capture=False stderr_capture=False log_capture=False ``` ### Performance testing If performance testing with a full planet import is required, indicate what needs testing in a pull request. ## Coverage reports To create coverage reports, set `BUILD_COVERAGE` in the CMake config to `ON`, compile and run the tests. Then run `make coverage`. This will generate a coverage report in `coverage/index.html` in the build directory. For this to work you need a coverage tool installed. For GCC this is `gcov`, for Clang this is `llvm-cov` in the right version. CMake will automatically try to find the correct tool. In any case the tool `gcovr` is used to create the report. ## Releasing a new version * Decide on a new version. (See [semantic versioning](https://semver.org/).) * Update version in [CMakeLists.txt](CMakeLists.txt), look for `project` function. * Build man page (`make man`) and copy it to `docs/osm2pgsql.1`. * Tag release with release notes in commit message and upload the tag to Github. * Fill out release notes on Github. * Copy Windows binaries and source tarball to osm2pgsql.org. * Add release info to osm2pgsql.org. * Publish release notes as News article on osm2pgsql.org. ## Maintainers The current maintainers of osm2pgsql are [Sarah Hoffmann](https://github.com/lonvia/) and [Paul Norman](https://github.com/pnorman/). osm2pgsql-1.9.1/COPYING000066400000000000000000000431031447112432500145100ustar00rootroot00000000000000 GNU GENERAL PUBLIC LICENSE Version 2, June 1991 Copyright (C) 1989, 1991 Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA Everyone is permitted to copy and distribute verbatim copies of this license document, but changing it is not allowed. Preamble The licenses for most software are designed to take away your freedom to share and change it. By contrast, the GNU General Public License is intended to guarantee your freedom to share and change free software--to make sure the software is free for all its users. This General Public License applies to most of the Free Software Foundation's software and to any other program whose authors commit to using it. (Some other Free Software Foundation software is covered by the GNU Lesser General Public License instead.) You can apply it to your programs, too. When we speak of free software, we are referring to freedom, not price. Our General Public Licenses are designed to make sure that you have the freedom to distribute copies of free software (and charge for this service if you wish), that you receive source code or can get it if you want it, that you can change the software or use pieces of it in new free programs; and that you know you can do these things. To protect your rights, we need to make restrictions that forbid anyone to deny you these rights or to ask you to surrender the rights. These restrictions translate to certain responsibilities for you if you distribute copies of the software, or if you modify it. For example, if you distribute copies of such a program, whether gratis or for a fee, you must give the recipients all the rights that you have. You must make sure that they, too, receive or can get the source code. And you must show them these terms so they know their rights. We protect your rights with two steps: (1) copyright the software, and (2) offer you this license which gives you legal permission to copy, distribute and/or modify the software. Also, for each author's protection and ours, we want to make certain that everyone understands that there is no warranty for this free software. If the software is modified by someone else and passed on, we want its recipients to know that what they have is not the original, so that any problems introduced by others will not reflect on the original authors' reputations. Finally, any free program is threatened constantly by software patents. We wish to avoid the danger that redistributors of a free program will individually obtain patent licenses, in effect making the program proprietary. To prevent this, we have made it clear that any patent must be licensed for everyone's free use or not licensed at all. The precise terms and conditions for copying, distribution and modification follow. GNU GENERAL PUBLIC LICENSE TERMS AND CONDITIONS FOR COPYING, DISTRIBUTION AND MODIFICATION 0. This License applies to any program or other work which contains a notice placed by the copyright holder saying it may be distributed under the terms of this General Public License. The "Program", below, refers to any such program or work, and a "work based on the Program" means either the Program or any derivative work under copyright law: that is to say, a work containing the Program or a portion of it, either verbatim or with modifications and/or translated into another language. (Hereinafter, translation is included without limitation in the term "modification".) Each licensee is addressed as "you". Activities other than copying, distribution and modification are not covered by this License; they are outside its scope. The act of running the Program is not restricted, and the output from the Program is covered only if its contents constitute a work based on the Program (independent of having been made by running the Program). Whether that is true depends on what the Program does. 1. You may copy and distribute verbatim copies of the Program's source code as you receive it, in any medium, provided that you conspicuously and appropriately publish on each copy an appropriate copyright notice and disclaimer of warranty; keep intact all the notices that refer to this License and to the absence of any warranty; and give any other recipients of the Program a copy of this License along with the Program. You may charge a fee for the physical act of transferring a copy, and you may at your option offer warranty protection in exchange for a fee. 2. You may modify your copy or copies of the Program or any portion of it, thus forming a work based on the Program, and copy and distribute such modifications or work under the terms of Section 1 above, provided that you also meet all of these conditions: a) You must cause the modified files to carry prominent notices stating that you changed the files and the date of any change. b) You must cause any work that you distribute or publish, that in whole or in part contains or is derived from the Program or any part thereof, to be licensed as a whole at no charge to all third parties under the terms of this License. c) If the modified program normally reads commands interactively when run, you must cause it, when started running for such interactive use in the most ordinary way, to print or display an announcement including an appropriate copyright notice and a notice that there is no warranty (or else, saying that you provide a warranty) and that users may redistribute the program under these conditions, and telling the user how to view a copy of this License. (Exception: if the Program itself is interactive but does not normally print such an announcement, your work based on the Program is not required to print an announcement.) These requirements apply to the modified work as a whole. If identifiable sections of that work are not derived from the Program, and can be reasonably considered independent and separate works in themselves, then this License, and its terms, do not apply to those sections when you distribute them as separate works. But when you distribute the same sections as part of a whole which is a work based on the Program, the distribution of the whole must be on the terms of this License, whose permissions for other licensees extend to the entire whole, and thus to each and every part regardless of who wrote it. Thus, it is not the intent of this section to claim rights or contest your rights to work written entirely by you; rather, the intent is to exercise the right to control the distribution of derivative or collective works based on the Program. In addition, mere aggregation of another work not based on the Program with the Program (or with a work based on the Program) on a volume of a storage or distribution medium does not bring the other work under the scope of this License. 3. You may copy and distribute the Program (or a work based on it, under Section 2) in object code or executable form under the terms of Sections 1 and 2 above provided that you also do one of the following: a) Accompany it with the complete corresponding machine-readable source code, which must be distributed under the terms of Sections 1 and 2 above on a medium customarily used for software interchange; or, b) Accompany it with a written offer, valid for at least three years, to give any third party, for a charge no more than your cost of physically performing source distribution, a complete machine-readable copy of the corresponding source code, to be distributed under the terms of Sections 1 and 2 above on a medium customarily used for software interchange; or, c) Accompany it with the information you received as to the offer to distribute corresponding source code. (This alternative is allowed only for noncommercial distribution and only if you received the program in object code or executable form with such an offer, in accord with Subsection b above.) The source code for a work means the preferred form of the work for making modifications to it. For an executable work, complete source code means all the source code for all modules it contains, plus any associated interface definition files, plus the scripts used to control compilation and installation of the executable. However, as a special exception, the source code distributed need not include anything that is normally distributed (in either source or binary form) with the major components (compiler, kernel, and so on) of the operating system on which the executable runs, unless that component itself accompanies the executable. If distribution of executable or object code is made by offering access to copy from a designated place, then offering equivalent access to copy the source code from the same place counts as distribution of the source code, even though third parties are not compelled to copy the source along with the object code. 4. You may not copy, modify, sublicense, or distribute the Program except as expressly provided under this License. Any attempt otherwise to copy, modify, sublicense or distribute the Program is void, and will automatically terminate your rights under this License. However, parties who have received copies, or rights, from you under this License will not have their licenses terminated so long as such parties remain in full compliance. 5. You are not required to accept this License, since you have not signed it. However, nothing else grants you permission to modify or distribute the Program or its derivative works. These actions are prohibited by law if you do not accept this License. Therefore, by modifying or distributing the Program (or any work based on the Program), you indicate your acceptance of this License to do so, and all its terms and conditions for copying, distributing or modifying the Program or works based on it. 6. Each time you redistribute the Program (or any work based on the Program), the recipient automatically receives a license from the original licensor to copy, distribute or modify the Program subject to these terms and conditions. You may not impose any further restrictions on the recipients' exercise of the rights granted herein. You are not responsible for enforcing compliance by third parties to this License. 7. If, as a consequence of a court judgment or allegation of patent infringement or for any other reason (not limited to patent issues), conditions are imposed on you (whether by court order, agreement or otherwise) that contradict the conditions of this License, they do not excuse you from the conditions of this License. If you cannot distribute so as to satisfy simultaneously your obligations under this License and any other pertinent obligations, then as a consequence you may not distribute the Program at all. For example, if a patent license would not permit royalty-free redistribution of the Program by all those who receive copies directly or indirectly through you, then the only way you could satisfy both it and this License would be to refrain entirely from distribution of the Program. If any portion of this section is held invalid or unenforceable under any particular circumstance, the balance of the section is intended to apply and the section as a whole is intended to apply in other circumstances. It is not the purpose of this section to induce you to infringe any patents or other property right claims or to contest validity of any such claims; this section has the sole purpose of protecting the integrity of the free software distribution system, which is implemented by public license practices. Many people have made generous contributions to the wide range of software distributed through that system in reliance on consistent application of that system; it is up to the author/donor to decide if he or she is willing to distribute software through any other system and a licensee cannot impose that choice. This section is intended to make thoroughly clear what is believed to be a consequence of the rest of this License. 8. If the distribution and/or use of the Program is restricted in certain countries either by patents or by copyrighted interfaces, the original copyright holder who places the Program under this License may add an explicit geographical distribution limitation excluding those countries, so that distribution is permitted only in or among countries not thus excluded. In such case, this License incorporates the limitation as if written in the body of this License. 9. The Free Software Foundation may publish revised and/or new versions of the General Public License from time to time. Such new versions will be similar in spirit to the present version, but may differ in detail to address new problems or concerns. Each version is given a distinguishing version number. If the Program specifies a version number of this License which applies to it and "any later version", you have the option of following the terms and conditions either of that version or of any later version published by the Free Software Foundation. If the Program does not specify a version number of this License, you may choose any version ever published by the Free Software Foundation. 10. If you wish to incorporate parts of the Program into other free programs whose distribution conditions are different, write to the author to ask for permission. For software which is copyrighted by the Free Software Foundation, write to the Free Software Foundation; we sometimes make exceptions for this. Our decision will be guided by the two goals of preserving the free status of all derivatives of our free software and of promoting the sharing and reuse of software generally. NO WARRANTY 11. BECAUSE THE PROGRAM IS LICENSED FREE OF CHARGE, THERE IS NO WARRANTY FOR THE PROGRAM, TO THE EXTENT PERMITTED BY APPLICABLE LAW. EXCEPT WHEN OTHERWISE STATED IN WRITING THE COPYRIGHT HOLDERS AND/OR OTHER PARTIES PROVIDE THE PROGRAM "AS IS" WITHOUT WARRANTY OF ANY KIND, EITHER EXPRESSED OR IMPLIED, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. THE ENTIRE RISK AS TO THE QUALITY AND PERFORMANCE OF THE PROGRAM IS WITH YOU. SHOULD THE PROGRAM PROVE DEFECTIVE, YOU ASSUME THE COST OF ALL NECESSARY SERVICING, REPAIR OR CORRECTION. 12. IN NO EVENT UNLESS REQUIRED BY APPLICABLE LAW OR AGREED TO IN WRITING WILL ANY COPYRIGHT HOLDER, OR ANY OTHER PARTY WHO MAY MODIFY AND/OR REDISTRIBUTE THE PROGRAM AS PERMITTED ABOVE, BE LIABLE TO YOU FOR DAMAGES, INCLUDING ANY GENERAL, SPECIAL, INCIDENTAL OR CONSEQUENTIAL DAMAGES ARISING OUT OF THE USE OR INABILITY TO USE THE PROGRAM (INCLUDING BUT NOT LIMITED TO LOSS OF DATA OR DATA BEING RENDERED INACCURATE OR LOSSES SUSTAINED BY YOU OR THIRD PARTIES OR A FAILURE OF THE PROGRAM TO OPERATE WITH ANY OTHER PROGRAMS), EVEN IF SUCH HOLDER OR OTHER PARTY HAS BEEN ADVISED OF THE POSSIBILITY OF SUCH DAMAGES. END OF TERMS AND CONDITIONS How to Apply These Terms to Your New Programs If you develop a new program, and you want it to be of the greatest possible use to the public, the best way to achieve this is to make it free software which everyone can redistribute and change under these terms. To do so, attach the following notices to the program. It is safest to attach them to the start of each source file to most effectively convey the exclusion of warranty; and each file should have at least the "copyright" line and a pointer to where the full notice is found. Copyright (C) This program is free software; you can redistribute it and/or modify it under the terms of the GNU General Public License as published by the Free Software Foundation; either version 2 of the License, or (at your option) any later version. This program is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for more details. You should have received a copy of the GNU General Public License along with this program; if not, write to the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA. Also add information on how to contact you by electronic and paper mail. If the program is interactive, make it output a short notice like this when it starts in an interactive mode: Gnomovision version 69, Copyright (C) year name of author Gnomovision comes with ABSOLUTELY NO WARRANTY; for details type `show w'. This is free software, and you are welcome to redistribute it under certain conditions; type `show c' for details. The hypothetical commands `show w' and `show c' should show the appropriate parts of the General Public License. Of course, the commands you use may be called something other than `show w' and `show c'; they could even be mouse-clicks or menu items--whatever suits your program. You should also get your employer (if you work as a programmer) or your school, if any, to sign a "copyright disclaimer" for the program, if necessary. Here is a sample; alter the names: Yoyodyne, Inc., hereby disclaims all copyright interest in the program `Gnomovision' (which makes passes at compilers) written by James Hacker. , 1 April 1989 Ty Coon, President of Vice This General Public License does not permit incorporating your program into proprietary programs. If your program is a subroutine library, you may consider it more useful to permit linking proprietary applications with the library. If this is what you want to do, use the GNU Lesser General Public License instead of this License. osm2pgsql-1.9.1/README.md000066400000000000000000000166521447112432500147450ustar00rootroot00000000000000# osm2pgsql https://osm2pgsql.org osm2pgsql is a tool for loading OpenStreetMap data into a PostgreSQL / PostGIS database suitable for applications like rendering into a map, geocoding with Nominatim, or general analysis. See the [documentation](https://osm2pgsql.org/doc/) for instructions on how to install and run osm2pgsql. [![Github Actions Build Status](https://github.com/openstreetmap/osm2pgsql/workflows/CI/badge.svg?branch=master)](https://github.com/openstreetmap/osm2pgsql/actions) [![Packaging Status](https://repology.org/badge/tiny-repos/osm2pgsql.svg)](https://repology.org/project/osm2pgsql/versions) ## Features * Converts OSM files to a PostgreSQL DB * Conversion of tags to columns is configurable in the style file * Able to read .gz, .bz2, .pbf and .o5m files directly * Can apply diffs to keep the database up to date * Support the choice of output projection * Configurable table names * Support for hstore field type to store the complete set of tags in one database field if desired ## Installing Most Linux distributions include osm2pgsql. It is available on macOS with [Homebrew](https://brew.sh/) and Windows builds are also available. See https://osm2pgsql.org/doc/install.html for details. ## Building The latest source code is available in the osm2pgsql git repository on GitHub and can be downloaded as follows: ```sh git clone https://github.com/openstreetmap/osm2pgsql.git ``` Osm2pgsql uses the cross-platform [CMake build system](https://cmake.org/) to configure and build itself. Required libraries are * [expat](https://libexpat.github.io/) * [proj](https://proj.org/) * [bzip2](http://www.bzip.org/) * [zlib](https://www.zlib.net/) * [Boost libraries](https://www.boost.org/), including geometry, system and filesystem * [nlohmann/json](https://json.nlohmann.me/) * [CImg](https://cimg.eu/) (Optional, for generalization only) * [potrace](https://potrace.sourceforge.net/) (Optional, for generalization only) * [PostgreSQL](https://www.postgresql.org/) client libraries * [Lua](https://www.lua.org/) (Optional, used for Lua tag transforms and the flex output) * [Python](https://python.org/) (only for running tests) * [Psycopg](https://www.psycopg.org/) (only for running tests) The following libraries are included in the `contrib` directory. You can build with other versions of those libraries (set the `EXTERNAL_*libname*` option to `ON`) but make sure you are using a compatible version: * [fmt](https://fmt.dev/) (>= 7.1.3) * [libosmium](https://osmcode.org/libosmium/) (>= 2.17.0) * [protozero](https://github.com/mapbox/protozero) (>= 1.6.3) It also requires access to a database server running [PostgreSQL](https://www.postgresql.org/) 9.6+ and [PostGIS](https://www.postgis.net/) 2.2+. Make sure you have installed the development packages for the libraries mentioned in the requirements section and a C++ compiler which supports C++17. We officially support gcc >= 7.0 and clang >= 8. To rebuild the included man page you'll need the [pandoc](https://pandoc.org/) tool. First install the dependencies. On a Debian or Ubuntu system, this can be done with: ```sh sudo apt-get install make cmake g++ libboost-dev libboost-system-dev \ libboost-filesystem-dev libexpat1-dev zlib1g-dev libpotrace-dev cimg-dev \ libbz2-dev libpq-dev libproj-dev lua5.3 liblua5.3-dev pandoc \ nlohmann-json3-dev pyosmium ``` On a Fedora system, use ```sh sudo dnf install cmake make gcc-c++ boost-devel expat-devel zlib-devel \ potrace-devel cimg-devel json-devel python3-osmium \ bzip2-devel postgresql-devel proj-devel proj-epsg lua-devel pandoc ``` On RedHat / CentOS first run `sudo yum install epel-release` then install dependencies with: ```sh sudo yum install cmake make gcc-c++ boost-devel expat-devel zlib-devel \ potrace-devel cimg-devel json-devel python3-osmium \ bzip2-devel postgresql-devel proj-devel proj-epsg lua-devel pandoc ``` On a FreeBSD system, use ```sh pkg install devel/cmake devel/boost-libs textproc/expat2 \ databases/postgresql94-client graphics/proj lang/lua52 ``` On Alpine, use ```sh apk --update-cache add cmake make g++ boost-dev expat-dev \ bzip2-dev zlib-dev libpq proj-dev lua5.3-dev postgresql-dev ``` Once dependencies are installed, use CMake to build the Makefiles in a separate folder: ```sh mkdir build && cd build cmake .. ``` If some installed dependencies are not found by CMake, more options may need to be set. Typically, setting `CMAKE_PREFIX_PATH` to a list of appropriate paths is sufficient. When the Makefiles have been successfully built, compile with ```sh make ``` The man page can be rebuilt with: ```sh make man ``` The compiled files can be installed with ```sh sudo make install ``` To install the experimental `osm2pgsql-gen` binary use ```sh sudo make install-gen ``` By default, the Release build with debug info is created and no tests are compiled. You can change that behavior by using additional options like following: ```sh cmake .. -G "Unix Makefiles" -DCMAKE_BUILD_TYPE=Debug -DBUILD_TESTS=ON ``` Note that `Debug` builds will be much slower than release build. For production `Release` or `RelWithDebInfo` builds are recommended. ### Using the PROJ library Osm2pgsql has builtin support for the Latlong (WGS84, EPSG:4326) and the WebMercator (EPSG:3857) projection. If you need other projections you have to compile with the PROJ library. Both the older API (PROJ version 4) and the newer API (PROJ version 6.1 and above) are supported. Usually the CMake configuration will find a suitable version and use it automatically, but you can set the `USE_PROJ_LIB` CMake cache variable to choose between the following behaviours: * `4`: Look for PROJ library with API version 4. If it is not found, stop with error. * `6`: Look for PROJ library with API version 6. If it is not found, stop with error. * `off`: Build without PROJ library. * `auto`: Choose API 4 if available, otherwise API 6. If both are not available build without PROJ library. (This is the default.) ## Using LuaJIT To speed up Lua tag transformations, [LuaJIT](https://luajit.org/) can be optionally enabled on supported platforms. This can speed up processing considerably. On a Debian or Ubuntu system install the LuaJIT library: ```sh sudo apt-get install libluajit-5.1-dev ``` Configuration parameter `WITH_LUAJIT=ON` needs to be added to enable LuaJIT. Otherwise make and installation steps are identical to the description above. ```sh cmake -D WITH_LUAJIT=ON .. ``` Use `osm2pgsql --version` to verify that the build includes LuaJIT support. The output should show something like ``` Lua 5.1.4 (LuaJIT 2.1.0-beta3) ``` ## Generalization There is some experimental support for data generalization. See https://osm2pgsql.org/generalization/ for details. ## Help/Support If you have problems with osm2pgsql or want to report a bug, go to https://osm2pgsql.org/support/ . ## License This program is free software; you can redistribute it and/or modify it under the terms of the GNU General Public License as published by the Free Software Foundation; either version 2 of the License, or (at your option) any later version. This program is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for more details. ## Contributing We welcome contributions to osm2pgsql. See [CONTRIBUTING.md](CONTRIBUTING.md) and https://osm2pgsql.org/contribute/ for information on how to contribute. osm2pgsql-1.9.1/cmake/000077500000000000000000000000001447112432500145345ustar00rootroot00000000000000osm2pgsql-1.9.1/cmake/FindLua.cmake000066400000000000000000000141141447112432500170610ustar00rootroot00000000000000#.rst: # FindLua # ------- # # # # Locate Lua library This module defines # # :: # # LUA_FOUND - if false, do not try to link to Lua # LUA_LIBRARIES - both lua and lualib # LUA_INCLUDE_DIR - where to find lua.h # LUA_VERSION_STRING - the version of Lua found # LUA_VERSION_MAJOR - the major version of Lua # LUA_VERSION_MINOR - the minor version of Lua # LUA_VERSION_PATCH - the patch version of Lua # # # # Note that the expected include convention is # # :: # # #include "lua.h" # # and not # # :: # # #include # # This is because, the lua location is not standardized and may exist in # locations other than lua/ #============================================================================= # Copyright 2007-2009 Kitware, Inc. # Copyright 2013 Rolf Eike Beer # # Distributed under the OSI-approved BSD License (the "License"); # see accompanying file Copyright.txt for details. # # This software is distributed WITHOUT ANY WARRANTY; without even the # implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. # See the License for more information. #============================================================================= # (To distribute this file outside of CMake, substitute the full # License text for the above reference.) unset(_lua_include_subdirs) unset(_lua_library_names) # this is a function only to have all the variables inside go away automatically function(set_lua_version_vars) set(LUA_VERSIONS5 5.4 5.3 5.2 5.1 5.0) if (Lua_FIND_VERSION_EXACT) if (Lua_FIND_VERSION_COUNT GREATER 1) set(lua_append_versions ${Lua_FIND_VERSION_MAJOR}.${Lua_FIND_VERSION_MINOR}) endif () elseif (Lua_FIND_VERSION) # once there is a different major version supported this should become a loop if (NOT Lua_FIND_VERSION_MAJOR GREATER 5) if (Lua_FIND_VERSION_COUNT EQUAL 1) set(lua_append_versions ${LUA_VERSIONS5}) else () foreach (subver IN LISTS LUA_VERSIONS5) if (NOT subver VERSION_LESS ${Lua_FIND_VERSION}) list(APPEND lua_append_versions ${subver}) endif () endforeach () endif () endif () else () # once there is a different major version supported this should become a loop set(lua_append_versions ${LUA_VERSIONS5}) endif () foreach (ver IN LISTS lua_append_versions) string(REGEX MATCH "^([0-9]+)\\.([0-9]+)$" _ver "${ver}") list(APPEND _lua_include_subdirs include/lua${CMAKE_MATCH_1}${CMAKE_MATCH_2} include/lua${CMAKE_MATCH_1}.${CMAKE_MATCH_2} include/lua-${CMAKE_MATCH_1}.${CMAKE_MATCH_2} ) list(APPEND _lua_library_names lua${CMAKE_MATCH_1}${CMAKE_MATCH_2} lua${CMAKE_MATCH_1}.${CMAKE_MATCH_2} lua-${CMAKE_MATCH_1}.${CMAKE_MATCH_2} ) endforeach () set(_lua_include_subdirs "${_lua_include_subdirs}" PARENT_SCOPE) set(_lua_library_names "${_lua_library_names}" PARENT_SCOPE) endfunction(set_lua_version_vars) set_lua_version_vars() find_path(LUA_INCLUDE_DIR lua.h HINTS ENV LUA_DIR PATH_SUFFIXES ${_lua_include_subdirs} include/lua include PATHS ~/Library/Frameworks /Library/Frameworks /sw # Fink /opt/local # DarwinPorts /opt/csw # Blastwave /opt ) unset(_lua_include_subdirs) find_library(LUA_LIBRARY NAMES ${_lua_library_names} lua HINTS ENV LUA_DIR PATH_SUFFIXES lib ${_lua_library_names} PATHS ~/Library/Frameworks /Library/Frameworks /sw /opt/local /opt/csw /opt ) unset(_lua_library_names) if (LUA_LIBRARY) # include the math library for Unix if (UNIX AND NOT APPLE AND NOT BEOS) find_library(LUA_MATH_LIBRARY m) set(LUA_LIBRARIES "${LUA_LIBRARY};${LUA_MATH_LIBRARY}") # For Windows and Mac, don't need to explicitly include the math library else () set(LUA_LIBRARIES "${LUA_LIBRARY}") endif () endif () if (LUA_INCLUDE_DIR AND EXISTS "${LUA_INCLUDE_DIR}/lua.h") # At least 5.[012] have different ways to express the version # so all of them need to be tested. Lua 5.2 defines LUA_VERSION # and LUA_RELEASE as joined by the C preprocessor, so avoid those. file(STRINGS "${LUA_INCLUDE_DIR}/lua.h" lua_version_strings REGEX "^#define[ \t]+LUA_(RELEASE[ \t]+\"Lua [0-9]|VERSION([ \t]+\"Lua [0-9]|_[MR])).*") string(REGEX REPLACE ".*;#define[ \t]+LUA_VERSION_MAJOR[ \t]+\"([0-9])\"[ \t]*;.*" "\\1" LUA_VERSION_MAJOR ";${lua_version_strings};") if (LUA_VERSION_MAJOR MATCHES "^[0-9]+$") string(REGEX REPLACE ".*;#define[ \t]+LUA_VERSION_MINOR[ \t]+\"([0-9])\"[ \t]*;.*" "\\1" LUA_VERSION_MINOR ";${lua_version_strings};") string(REGEX REPLACE ".*;#define[ \t]+LUA_VERSION_RELEASE[ \t]+\"([0-9])\"[ \t]*;.*" "\\1" LUA_VERSION_PATCH ";${lua_version_strings};") set(LUA_VERSION_STRING "${LUA_VERSION_MAJOR}.${LUA_VERSION_MINOR}.${LUA_VERSION_PATCH}") else () string(REGEX REPLACE ".*;#define[ \t]+LUA_RELEASE[ \t]+\"Lua ([0-9.]+)\"[ \t]*;.*" "\\1" LUA_VERSION_STRING ";${lua_version_strings};") if (NOT LUA_VERSION_STRING MATCHES "^[0-9.]+$") string(REGEX REPLACE ".*;#define[ \t]+LUA_VERSION[ \t]+\"Lua ([0-9.]+)\"[ \t]*;.*" "\\1" LUA_VERSION_STRING ";${lua_version_strings};") endif () string(REGEX REPLACE "^([0-9]+)\\.[0-9.]*$" "\\1" LUA_VERSION_MAJOR "${LUA_VERSION_STRING}") string(REGEX REPLACE "^[0-9]+\\.([0-9]+)[0-9.]*$" "\\1" LUA_VERSION_MINOR "${LUA_VERSION_STRING}") string(REGEX REPLACE "^[0-9]+\\.[0-9]+\\.([0-9]).*" "\\1" LUA_VERSION_PATCH "${LUA_VERSION_STRING}") endif () unset(lua_version_strings) endif() include(FindPackageHandleStandardArgs) # handle the QUIETLY and REQUIRED arguments and set LUA_FOUND to TRUE if # all listed variables are TRUE FIND_PACKAGE_HANDLE_STANDARD_ARGS(Lua REQUIRED_VARS LUA_LIBRARIES LUA_INCLUDE_DIR VERSION_VAR LUA_VERSION_STRING) mark_as_advanced(LUA_INCLUDE_DIR LUA_LIBRARY LUA_MATH_LIBRARY) osm2pgsql-1.9.1/cmake/FindLuaJIT.cmake000066400000000000000000000035651447112432500174400ustar00rootroot00000000000000# Locate LuaJIT library # This module defines # LUAJIT_FOUND, if false, do not try to link to Lua # LUAJIT_LIBRARIES # LUAJIT_INCLUDE_DIR, where to find luajit.h # LUAJIT_VERSION_STRING, the version of Lua found (since CMake 2.8.8) ## Copied from default CMake FindLua51.cmake find_path(LUAJIT_INCLUDE_DIR luajit.h HINTS ENV LUA_DIR PATH_SUFFIXES include/luajit-2.0 include/luajit-2.1 include PATHS ~/Library/Frameworks /Library/Frameworks /sw # Fink /opt/local # DarwinPorts /opt/csw # Blastwave /opt ) find_library(LUAJIT_LIBRARY NAMES luajit-5.1 HINTS ENV LUA_DIR PATH_SUFFIXES lib PATHS ~/Library/Frameworks /Library/Frameworks /sw /opt/local /opt/csw /opt ) if(LUAJIT_LIBRARY) # include the math library for Unix if(UNIX AND NOT APPLE) find_library(LUA_MATH_LIBRARY m) set( LUAJIT_LIBRARIES "${LUAJIT_LIBRARY};${LUA_MATH_LIBRARY}" CACHE STRING "LuaJIT Libraries") # For Windows and Mac, don't need to explicitly include the math library else() set( LUAJIT_LIBRARIES "${LUAJIT_LIBRARY}" CACHE STRING "LuaJIT Libraries") endif() endif() if(LUAJIT_INCLUDE_DIR AND EXISTS "${LUAJIT_INCLUDE_DIR}/luajit.h") file(STRINGS "${LUAJIT_INCLUDE_DIR}/luajit.h" luajit_version_str REGEX "^#define[ \t]+LUAJIT_VERSION[ \t]+\"LuaJIT .+\"") string(REGEX REPLACE "^#define[ \t]+LUAJIT_VERSION[ \t]+\"LuaJIT ([^\"]+)\".*" "\\1" LUAJIT_VERSION_STRING "${luajit_version_str}") unset(luajit_version_str) endif() include(FindPackageHandleStandardArgs) # handle the QUIETLY and REQUIRED arguments and set LUAJIT_FOUND to TRUE if # all listed variables are TRUE FIND_PACKAGE_HANDLE_STANDARD_ARGS(LuaJIT REQUIRED_VARS LUAJIT_LIBRARIES LUAJIT_INCLUDE_DIR VERSION_VAR LUAJIT_VERSION_STRING) mark_as_advanced(LUAJIT_INCLUDE_DIR LUAJIT_LIBRARIES LUAJIT_LIBRARY LUA_MATH_LIBRARY) osm2pgsql-1.9.1/cmake/FindOsmium.cmake000066400000000000000000000325061447112432500176160ustar00rootroot00000000000000#---------------------------------------------------------------------- # # FindOsmium.cmake # # Find the Libosmium headers and, optionally, several components needed # for different Libosmium functions. # #---------------------------------------------------------------------- # # Usage: # # Copy this file somewhere into your project directory, where cmake can # find it. Usually this will be a directory called "cmake" which you can # add to the CMake module search path with the following line in your # CMakeLists.txt: # # list(APPEND CMAKE_MODULE_PATH "${CMAKE_SOURCE_DIR}/cmake") # # Then add the following in your CMakeLists.txt: # # find_package(Osmium [version] REQUIRED COMPONENTS ) # include_directories(SYSTEM ${OSMIUM_INCLUDE_DIRS}) # # The version number is optional. If it is not set, any version of # libosmium will do. # # For the substitute a space separated list of one or more of the # following components: # # pbf - include libraries needed for PBF input and output # xml - include libraries needed for XML input and output # io - include libraries needed for any type of input/output # geos - include if you want to use any of the GEOS functions # gdal - include if you want to use any of the OGR functions # proj - include if you want to use any of the Proj.4 functions # sparsehash - include if you use the sparsehash index (deprecated!) # lz4 - include support for LZ4 compression of PBF files # # You can check for success with something like this: # # if(NOT OSMIUM_FOUND) # message(WARNING "Libosmium not found!\n") # endif() # #---------------------------------------------------------------------- # # Variables: # # OSMIUM_FOUND - True if Osmium found. # OSMIUM_INCLUDE_DIRS - Where to find include files. # OSMIUM_XML_LIBRARIES - Libraries needed for XML I/O. # OSMIUM_PBF_LIBRARIES - Libraries needed for PBF I/O. # OSMIUM_IO_LIBRARIES - Libraries needed for XML or PBF I/O. # OSMIUM_LIBRARIES - All libraries Osmium uses somewhere. # #---------------------------------------------------------------------- # This is the list of directories where we look for osmium includes. set(_osmium_include_path ../libosmium ~/Library/Frameworks /Library/Frameworks /opt/local # DarwinPorts /opt ) # Look for the header file. find_path(OSMIUM_INCLUDE_DIR osmium/version.hpp PATH_SUFFIXES include PATHS ${_osmium_include_path} ) # Check libosmium version number if(Osmium_FIND_VERSION) if(NOT EXISTS "${OSMIUM_INCLUDE_DIR}/osmium/version.hpp") message(FATAL_ERROR "Missing ${OSMIUM_INCLUDE_DIR}/osmium/version.hpp. Either your libosmium version is too old, or libosmium wasn't found in the place you said.") endif() file(STRINGS "${OSMIUM_INCLUDE_DIR}/osmium/version.hpp" _libosmium_version_define REGEX "#define LIBOSMIUM_VERSION_STRING") if("${_libosmium_version_define}" MATCHES "#define LIBOSMIUM_VERSION_STRING \"([0-9.]+)\"") set(_libosmium_version "${CMAKE_MATCH_1}") else() set(_libosmium_version "unknown") endif() endif() set(OSMIUM_INCLUDE_DIRS "${OSMIUM_INCLUDE_DIR}") #---------------------------------------------------------------------- # # Check for optional components # #---------------------------------------------------------------------- if(Osmium_FIND_COMPONENTS) foreach(_component ${Osmium_FIND_COMPONENTS}) string(TOUPPER ${_component} _component_uppercase) set(Osmium_USE_${_component_uppercase} TRUE) endforeach() endif() #---------------------------------------------------------------------- # Component 'io' is an alias for 'pbf' and 'xml' if(Osmium_USE_IO) set(Osmium_USE_PBF TRUE) set(Osmium_USE_XML TRUE) endif() #---------------------------------------------------------------------- # Component 'ogr' is an alias for 'gdal' if(Osmium_USE_OGR) set(Osmium_USE_GDAL TRUE) endif() #---------------------------------------------------------------------- # Component 'pbf' if(Osmium_USE_PBF) find_package(ZLIB) find_package(Threads) find_package(Protozero 1.6.3) if(Osmium_USE_LZ4) find_package(LZ4 REQUIRED) add_definitions(-DOSMIUM_WITH_LZ4) endif() list(APPEND OSMIUM_EXTRA_FIND_VARS ZLIB_FOUND Threads_FOUND PROTOZERO_INCLUDE_DIR) if(ZLIB_FOUND AND Threads_FOUND AND PROTOZERO_FOUND) list(APPEND OSMIUM_PBF_LIBRARIES ${ZLIB_LIBRARIES} ${LZ4_LIBRARIES} ${CMAKE_THREAD_LIBS_INIT} ) list(APPEND OSMIUM_INCLUDE_DIRS ${ZLIB_INCLUDE_DIR} ${LZ4_INCLUDE_DIRS} ${PROTOZERO_INCLUDE_DIR} ) else() message(WARNING "Osmium: Can not find some libraries for PBF input/output, please install them or configure the paths.") endif() endif() #---------------------------------------------------------------------- # Component 'xml' if(Osmium_USE_XML) find_package(EXPAT) find_package(BZip2) find_package(ZLIB) find_package(Threads) list(APPEND OSMIUM_EXTRA_FIND_VARS EXPAT_FOUND BZIP2_FOUND ZLIB_FOUND Threads_FOUND) if(EXPAT_FOUND AND BZIP2_FOUND AND ZLIB_FOUND AND Threads_FOUND) list(APPEND OSMIUM_XML_LIBRARIES ${EXPAT_LIBRARIES} ${BZIP2_LIBRARIES} ${ZLIB_LIBRARIES} ${CMAKE_THREAD_LIBS_INIT} ) list(APPEND OSMIUM_INCLUDE_DIRS ${EXPAT_INCLUDE_DIR} ${BZIP2_INCLUDE_DIR} ${ZLIB_INCLUDE_DIR} ) else() message(WARNING "Osmium: Can not find some libraries for XML input/output, please install them or configure the paths.") endif() endif() #---------------------------------------------------------------------- list(APPEND OSMIUM_IO_LIBRARIES ${OSMIUM_PBF_LIBRARIES} ${OSMIUM_XML_LIBRARIES} ) list(APPEND OSMIUM_LIBRARIES ${OSMIUM_IO_LIBRARIES} ) #---------------------------------------------------------------------- # Component 'geos' if(Osmium_USE_GEOS) find_path(GEOS_INCLUDE_DIR geos/geom.h) find_library(GEOS_LIBRARY NAMES geos) list(APPEND OSMIUM_EXTRA_FIND_VARS GEOS_INCLUDE_DIR GEOS_LIBRARY) if(GEOS_INCLUDE_DIR AND GEOS_LIBRARY) SET(GEOS_FOUND 1) list(APPEND OSMIUM_LIBRARIES ${GEOS_LIBRARY}) list(APPEND OSMIUM_INCLUDE_DIRS ${GEOS_INCLUDE_DIR}) else() message(WARNING "Osmium: GEOS library is required but not found, please install it or configure the paths.") endif() endif() #---------------------------------------------------------------------- # Component 'gdal' (alias 'ogr') if(Osmium_USE_GDAL) find_package(GDAL) list(APPEND OSMIUM_EXTRA_FIND_VARS GDAL_FOUND) if(GDAL_FOUND) list(APPEND OSMIUM_LIBRARIES ${GDAL_LIBRARIES}) list(APPEND OSMIUM_INCLUDE_DIRS ${GDAL_INCLUDE_DIRS}) else() message(WARNING "Osmium: GDAL library is required but not found, please install it or configure the paths.") endif() endif() #---------------------------------------------------------------------- # Component 'proj' if(Osmium_USE_PROJ) find_path(PROJ_INCLUDE_DIR proj_api.h) find_library(PROJ_LIBRARY NAMES proj) list(APPEND OSMIUM_EXTRA_FIND_VARS PROJ_INCLUDE_DIR PROJ_LIBRARY) if(PROJ_INCLUDE_DIR AND PROJ_LIBRARY) set(PROJ_FOUND 1) list(APPEND OSMIUM_LIBRARIES ${PROJ_LIBRARY}) list(APPEND OSMIUM_INCLUDE_DIRS ${PROJ_INCLUDE_DIR}) else() message(WARNING "Osmium: PROJ.4 library is required but not found, please install it or configure the paths.") endif() endif() #---------------------------------------------------------------------- # Component 'sparsehash' if(Osmium_USE_SPARSEHASH) message(WARNING "Osmium: Use of Google SparseHash is deprecated. Please switch to a different index type.") find_path(SPARSEHASH_INCLUDE_DIR google/sparsetable) list(APPEND OSMIUM_EXTRA_FIND_VARS SPARSEHASH_INCLUDE_DIR) if(SPARSEHASH_INCLUDE_DIR) # Find size of sparsetable::size_type. This does not work on older # CMake versions because they can do this check only in C, not in C++. if(NOT CMAKE_VERSION VERSION_LESS 3.0) include(CheckTypeSize) set(CMAKE_REQUIRED_INCLUDES ${SPARSEHASH_INCLUDE_DIR}) set(CMAKE_EXTRA_INCLUDE_FILES "google/sparsetable") check_type_size("google::sparsetable::size_type" SPARSETABLE_SIZE_TYPE LANGUAGE CXX) set(CMAKE_EXTRA_INCLUDE_FILES) set(CMAKE_REQUIRED_INCLUDES) else() set(SPARSETABLE_SIZE_TYPE ${CMAKE_SIZEOF_VOID_P}) endif() # Sparsetable::size_type must be at least 8 bytes (64bit), otherwise # OSM object IDs will not fit. if(SPARSETABLE_SIZE_TYPE GREATER 7) set(SPARSEHASH_FOUND 1) add_definitions(-DOSMIUM_WITH_SPARSEHASH=${SPARSEHASH_FOUND}) list(APPEND OSMIUM_INCLUDE_DIRS ${SPARSEHASH_INCLUDE_DIR}) else() message(WARNING "Osmium: Disabled Google SparseHash library on 32bit system (size_type=${SPARSETABLE_SIZE_TYPE}).") endif() else() message(WARNING "Osmium: Google SparseHash library is required but not found, please install it or configure the paths.") endif() endif() #---------------------------------------------------------------------- list(REMOVE_DUPLICATES OSMIUM_INCLUDE_DIRS) if(OSMIUM_XML_LIBRARIES) list(REMOVE_DUPLICATES OSMIUM_XML_LIBRARIES) endif() if(OSMIUM_PBF_LIBRARIES) list(REMOVE_DUPLICATES OSMIUM_PBF_LIBRARIES) endif() if(OSMIUM_IO_LIBRARIES) list(REMOVE_DUPLICATES OSMIUM_IO_LIBRARIES) endif() if(OSMIUM_LIBRARIES) list(REMOVE_DUPLICATES OSMIUM_LIBRARIES) endif() #---------------------------------------------------------------------- # # Check that all required libraries are available # #---------------------------------------------------------------------- if(OSMIUM_EXTRA_FIND_VARS) list(REMOVE_DUPLICATES OSMIUM_EXTRA_FIND_VARS) endif() # Handle the QUIETLY and REQUIRED arguments and the optional version check # and set OSMIUM_FOUND to TRUE if all listed variables are TRUE. include(FindPackageHandleStandardArgs) find_package_handle_standard_args(Osmium REQUIRED_VARS OSMIUM_INCLUDE_DIR ${OSMIUM_EXTRA_FIND_VARS} VERSION_VAR _libosmium_version) unset(OSMIUM_EXTRA_FIND_VARS) #---------------------------------------------------------------------- # # A function for setting the -pthread option in compilers/linkers # #---------------------------------------------------------------------- function(set_pthread_on_target _target) if(NOT MSVC) set_target_properties(${_target} PROPERTIES COMPILE_FLAGS "-pthread") if(NOT APPLE) set_target_properties(${_target} PROPERTIES LINK_FLAGS "-pthread") endif() endif() endfunction() #---------------------------------------------------------------------- # # Add compiler flags # #---------------------------------------------------------------------- add_definitions(-D_LARGEFILE_SOURCE -D_FILE_OFFSET_BITS=64) if(MSVC) add_definitions(-wd4996) # Disable warning C4068: "unknown pragma" because we want it to ignore # pragmas for other compilers. add_definitions(-wd4068) # Disable warning C4715: "not all control paths return a value" because # it generates too many false positives. add_definitions(-wd4715) # Disable warning C4351: new behavior: elements of array '...' will be # default initialized. The new behaviour is correct and we don't support # old compilers anyway. add_definitions(-wd4351) # Disable warning C4503: "decorated name length exceeded, name was truncated" # there are more than 150 of generated names in libosmium longer than 4096 symbols supported in MSVC add_definitions(-wd4503) add_definitions(-DNOMINMAX -DWIN32_LEAN_AND_MEAN -D_CRT_SECURE_NO_WARNINGS) endif() if(APPLE AND "${CMAKE_CXX_COMPILER_ID}" STREQUAL "Clang") # following only available from cmake 2.8.12: # add_compile_options(-stdlib=libc++) # so using this instead: add_definitions(-stdlib=libc++) set(LDFLAGS ${LDFLAGS} -stdlib=libc++) endif() #---------------------------------------------------------------------- # This is a set of recommended warning options that can be added when compiling # libosmium code. if(MSVC) set(OSMIUM_WARNING_OPTIONS "/W3 /wd4514" CACHE STRING "Recommended warning options for libosmium") else() set(OSMIUM_WARNING_OPTIONS "-Wall -Wextra -pedantic -Wredundant-decls -Wdisabled-optimization -Wctor-dtor-privacy -Wnon-virtual-dtor -Woverloaded-virtual -Wsign-promo -Wold-style-cast" CACHE STRING "Recommended warning options for libosmium") endif() set(OSMIUM_DRACONIC_CLANG_OPTIONS "-Wdocumentation -Wunused-exception-parameter -Wmissing-declarations -Weverything -Wno-c++98-compat -Wno-c++98-compat-pedantic -Wno-unused-macros -Wno-exit-time-destructors -Wno-global-constructors -Wno-padded -Wno-switch-enum -Wno-missing-prototypes -Wno-weak-vtables -Wno-cast-align -Wno-float-equal") if(Osmium_DEBUG) message(STATUS "OSMIUM_XML_LIBRARIES=${OSMIUM_XML_LIBRARIES}") message(STATUS "OSMIUM_PBF_LIBRARIES=${OSMIUM_PBF_LIBRARIES}") message(STATUS "OSMIUM_IO_LIBRARIES=${OSMIUM_IO_LIBRARIES}") message(STATUS "OSMIUM_LIBRARIES=${OSMIUM_LIBRARIES}") message(STATUS "OSMIUM_INCLUDE_DIRS=${OSMIUM_INCLUDE_DIRS}") endif() osm2pgsql-1.9.1/cmake/FindProtozero.cmake000066400000000000000000000037601447112432500203500ustar00rootroot00000000000000#---------------------------------------------------------------------- # # FindProtozero.cmake # # Find the protozero headers. # #---------------------------------------------------------------------- # # Usage: # # Copy this file somewhere into your project directory, where cmake can # find it. Usually this will be a directory called "cmake" which you can # add to the CMake module search path with the following line in your # CMakeLists.txt: # # list(APPEND CMAKE_MODULE_PATH "${CMAKE_SOURCE_DIR}/cmake") # # Then add the following in your CMakeLists.txt: # # find_package(Protozero [version] [REQUIRED]) # include_directories(SYSTEM ${PROTOZERO_INCLUDE_DIR}) # # The version number is optional. If it is not set, any version of # protozero will do. # # if(NOT PROTOZERO_FOUND) # message(WARNING "Protozero not found!\n") # endif() # #---------------------------------------------------------------------- # # Variables: # # PROTOZERO_FOUND - True if Protozero was found. # PROTOZERO_INCLUDE_DIR - Where to find include files. # #---------------------------------------------------------------------- # find include path find_path(PROTOZERO_INCLUDE_DIR protozero/version.hpp PATH_SUFFIXES include PATHS ${CMAKE_SOURCE_DIR}/../protozero ) # Check version number if(Protozero_FIND_VERSION) file(STRINGS "${PROTOZERO_INCLUDE_DIR}/protozero/version.hpp" _version_define REGEX "#define PROTOZERO_VERSION_STRING") if("${_version_define}" MATCHES "#define PROTOZERO_VERSION_STRING \"([0-9.]+)\"") set(_version "${CMAKE_MATCH_1}") else() set(_version "unknown") endif() endif() #set(PROTOZERO_INCLUDE_DIRS "${PROTOZERO_INCLUDE_DIR}") include(FindPackageHandleStandardArgs) find_package_handle_standard_args(Protozero REQUIRED_VARS PROTOZERO_INCLUDE_DIR VERSION_VAR _version) #---------------------------------------------------------------------- osm2pgsql-1.9.1/contrib/000077500000000000000000000000001447112432500151145ustar00rootroot00000000000000osm2pgsql-1.9.1/contrib/catch2/000077500000000000000000000000001447112432500162605ustar00rootroot00000000000000osm2pgsql-1.9.1/contrib/catch2/LICENSE.txt000066400000000000000000000024721447112432500201100ustar00rootroot00000000000000Boost Software License - Version 1.0 - August 17th, 2003 Permission is hereby granted, free of charge, to any person or organization obtaining a copy of the software and accompanying documentation covered by this license (the "Software") to use, reproduce, display, distribute, execute, and transmit the Software, and to prepare derivative works of the Software, and to permit third-parties to whom the Software is furnished to do so, all subject to the following: The copyright notices in the Software and this entire statement, including the above license grant, this restriction and the following disclaimer, must be included in all copies of the Software, in whole or in part, and all derivative works of the Software, unless such copies or derivative works are solely in the form of machine-executable object code generated by a source language processor. 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, TITLE AND NON-INFRINGEMENT. IN NO EVENT SHALL THE COPYRIGHT HOLDERS OR ANYONE DISTRIBUTING THE SOFTWARE BE LIABLE FOR ANY DAMAGES OR OTHER LIABILITY, WHETHER IN CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. osm2pgsql-1.9.1/contrib/catch2/README.contrib000066400000000000000000000000761447112432500206020ustar00rootroot00000000000000Source: https://github.com/catchorg/Catch2 Revision: v2.13.10 osm2pgsql-1.9.1/contrib/catch2/README.md000066400000000000000000000042121447112432500175360ustar00rootroot00000000000000 ![catch logo](artwork/catch2-logo-small.png) [![Github Releases](https://img.shields.io/github/release/catchorg/catch2.svg)](https://github.com/catchorg/catch2/releases) [![Build Status](https://travis-ci.org/catchorg/Catch2.svg?branch=v2.x)](https://travis-ci.org/catchorg/Catch2) [![Build status](https://ci.appveyor.com/api/projects/status/github/catchorg/Catch2?svg=true)](https://ci.appveyor.com/project/catchorg/catch2) [![codecov](https://codecov.io/gh/catchorg/Catch2/branch/v2.x/graph/badge.svg)](https://codecov.io/gh/catchorg/Catch2) [![Try online](https://img.shields.io/badge/try-online-blue.svg)](https://wandbox.org/permlink/6JUH8Eybx4CtvkJS) [![Join the chat in Discord: https://discord.gg/4CWS9zD](https://img.shields.io/badge/Discord-Chat!-brightgreen.svg)](https://discord.gg/4CWS9zD) The latest version of the single header can be downloaded directly using this link ## Catch2 is released! If you've been using an earlier version of Catch, please see the Breaking Changes section of [the release notes](https://github.com/catchorg/Catch2/releases/tag/v2.0.1) before moving to Catch2. You might also like to read [this blog post](https://levelofindirection.com/blog/catch2-released.html) for more details. ## What's the Catch? Catch2 is a multi-paradigm test framework for C++. which also supports Objective-C (and maybe C). It is primarily distributed as a single header file, although certain extensions may require additional headers. ## How to use it This documentation comprises these three parts: * [Why do we need yet another C++ Test Framework?](docs/why-catch.md#top) * [Tutorial](docs/tutorial.md#top) - getting started * [Reference section](docs/Readme.md#top) - all the details ## More * Issues and bugs can be raised on the [Issue tracker on GitHub](https://github.com/catchorg/Catch2/issues) * For discussion or questions please use [the dedicated Google Groups forum](https://groups.google.com/forum/?fromgroups#!forum/catch-forum) or our [Discord](https://discord.gg/4CWS9zD) * See [who else is using Catch2](docs/opensource-users.md#top) osm2pgsql-1.9.1/contrib/catch2/include/000077500000000000000000000000001447112432500177035ustar00rootroot00000000000000osm2pgsql-1.9.1/contrib/catch2/include/catch.hpp000066400000000000000000024040031447112432500215010ustar00rootroot00000000000000/* * Catch v2.13.10 * Generated: 2022-10-16 11:01:23.452308 * ---------------------------------------------------------- * This file has been merged from multiple headers. Please don't edit it directly * Copyright (c) 2022 Two Blue Cubes Ltd. All rights reserved. * * Distributed under the Boost Software License, Version 1.0. (See accompanying * file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt) */ #ifndef TWOBLUECUBES_SINGLE_INCLUDE_CATCH_HPP_INCLUDED #define TWOBLUECUBES_SINGLE_INCLUDE_CATCH_HPP_INCLUDED // start catch.hpp #define CATCH_VERSION_MAJOR 2 #define CATCH_VERSION_MINOR 13 #define CATCH_VERSION_PATCH 10 #ifdef __clang__ # pragma clang system_header #elif defined __GNUC__ # pragma GCC system_header #endif // start catch_suppress_warnings.h #ifdef __clang__ # ifdef __ICC // icpc defines the __clang__ macro # pragma warning(push) # pragma warning(disable: 161 1682) # else // __ICC # pragma clang diagnostic push # pragma clang diagnostic ignored "-Wpadded" # pragma clang diagnostic ignored "-Wswitch-enum" # pragma clang diagnostic ignored "-Wcovered-switch-default" # endif #elif defined __GNUC__ // Because REQUIREs trigger GCC's -Wparentheses, and because still // supported version of g++ have only buggy support for _Pragmas, // Wparentheses have to be suppressed globally. # pragma GCC diagnostic ignored "-Wparentheses" // See #674 for details # pragma GCC diagnostic push # pragma GCC diagnostic ignored "-Wunused-variable" # pragma GCC diagnostic ignored "-Wpadded" #endif // end catch_suppress_warnings.h #if defined(CATCH_CONFIG_MAIN) || defined(CATCH_CONFIG_RUNNER) # define CATCH_IMPL # define CATCH_CONFIG_ALL_PARTS #endif // In the impl file, we want to have access to all parts of the headers // Can also be used to sanely support PCHs #if defined(CATCH_CONFIG_ALL_PARTS) # define CATCH_CONFIG_EXTERNAL_INTERFACES # if defined(CATCH_CONFIG_DISABLE_MATCHERS) # undef CATCH_CONFIG_DISABLE_MATCHERS # endif # if !defined(CATCH_CONFIG_ENABLE_CHRONO_STRINGMAKER) # define CATCH_CONFIG_ENABLE_CHRONO_STRINGMAKER # endif #endif #if !defined(CATCH_CONFIG_IMPL_ONLY) // start catch_platform.h // See e.g.: // https://opensource.apple.com/source/CarbonHeaders/CarbonHeaders-18.1/TargetConditionals.h.auto.html #ifdef __APPLE__ # include # if (defined(TARGET_OS_OSX) && TARGET_OS_OSX == 1) || \ (defined(TARGET_OS_MAC) && TARGET_OS_MAC == 1) # define CATCH_PLATFORM_MAC # elif (defined(TARGET_OS_IPHONE) && TARGET_OS_IPHONE == 1) # define CATCH_PLATFORM_IPHONE # endif #elif defined(linux) || defined(__linux) || defined(__linux__) # define CATCH_PLATFORM_LINUX #elif defined(WIN32) || defined(__WIN32__) || defined(_WIN32) || defined(_MSC_VER) || defined(__MINGW32__) # define CATCH_PLATFORM_WINDOWS #endif // end catch_platform.h #ifdef CATCH_IMPL # ifndef CLARA_CONFIG_MAIN # define CLARA_CONFIG_MAIN_NOT_DEFINED # define CLARA_CONFIG_MAIN # endif #endif // start catch_user_interfaces.h namespace Catch { unsigned int rngSeed(); } // end catch_user_interfaces.h // start catch_tag_alias_autoregistrar.h // start catch_common.h // start catch_compiler_capabilities.h // Detect a number of compiler features - by compiler // The following features are defined: // // CATCH_CONFIG_COUNTER : is the __COUNTER__ macro supported? // CATCH_CONFIG_WINDOWS_SEH : is Windows SEH supported? // CATCH_CONFIG_POSIX_SIGNALS : are POSIX signals supported? // CATCH_CONFIG_DISABLE_EXCEPTIONS : Are exceptions enabled? // **************** // Note to maintainers: if new toggles are added please document them // in configuration.md, too // **************** // In general each macro has a _NO_ form // (e.g. CATCH_CONFIG_NO_POSIX_SIGNALS) which disables the feature. // Many features, at point of detection, define an _INTERNAL_ macro, so they // can be combined, en-mass, with the _NO_ forms later. #ifdef __cplusplus # if (__cplusplus >= 201402L) || (defined(_MSVC_LANG) && _MSVC_LANG >= 201402L) # define CATCH_CPP14_OR_GREATER # endif # if (__cplusplus >= 201703L) || (defined(_MSVC_LANG) && _MSVC_LANG >= 201703L) # define CATCH_CPP17_OR_GREATER # endif #endif // Only GCC compiler should be used in this block, so other compilers trying to // mask themselves as GCC should be ignored. #if defined(__GNUC__) && !defined(__clang__) && !defined(__ICC) && !defined(__CUDACC__) && !defined(__LCC__) # define CATCH_INTERNAL_START_WARNINGS_SUPPRESSION _Pragma( "GCC diagnostic push" ) # define CATCH_INTERNAL_STOP_WARNINGS_SUPPRESSION _Pragma( "GCC diagnostic pop" ) # define CATCH_INTERNAL_IGNORE_BUT_WARN(...) (void)__builtin_constant_p(__VA_ARGS__) #endif #if defined(__clang__) # define CATCH_INTERNAL_START_WARNINGS_SUPPRESSION _Pragma( "clang diagnostic push" ) # define CATCH_INTERNAL_STOP_WARNINGS_SUPPRESSION _Pragma( "clang diagnostic pop" ) // As of this writing, IBM XL's implementation of __builtin_constant_p has a bug // which results in calls to destructors being emitted for each temporary, // without a matching initialization. In practice, this can result in something // like `std::string::~string` being called on an uninitialized value. // // For example, this code will likely segfault under IBM XL: // ``` // REQUIRE(std::string("12") + "34" == "1234") // ``` // // Therefore, `CATCH_INTERNAL_IGNORE_BUT_WARN` is not implemented. # if !defined(__ibmxl__) && !defined(__CUDACC__) # define CATCH_INTERNAL_IGNORE_BUT_WARN(...) (void)__builtin_constant_p(__VA_ARGS__) /* NOLINT(cppcoreguidelines-pro-type-vararg, hicpp-vararg) */ # endif # define CATCH_INTERNAL_SUPPRESS_GLOBALS_WARNINGS \ _Pragma( "clang diagnostic ignored \"-Wexit-time-destructors\"" ) \ _Pragma( "clang diagnostic ignored \"-Wglobal-constructors\"") # define CATCH_INTERNAL_SUPPRESS_PARENTHESES_WARNINGS \ _Pragma( "clang diagnostic ignored \"-Wparentheses\"" ) # define CATCH_INTERNAL_SUPPRESS_UNUSED_WARNINGS \ _Pragma( "clang diagnostic ignored \"-Wunused-variable\"" ) # define CATCH_INTERNAL_SUPPRESS_ZERO_VARIADIC_WARNINGS \ _Pragma( "clang diagnostic ignored \"-Wgnu-zero-variadic-macro-arguments\"" ) # define CATCH_INTERNAL_SUPPRESS_UNUSED_TEMPLATE_WARNINGS \ _Pragma( "clang diagnostic ignored \"-Wunused-template\"" ) #endif // __clang__ //////////////////////////////////////////////////////////////////////////////// // Assume that non-Windows platforms support posix signals by default #if !defined(CATCH_PLATFORM_WINDOWS) #define CATCH_INTERNAL_CONFIG_POSIX_SIGNALS #endif //////////////////////////////////////////////////////////////////////////////// // We know some environments not to support full POSIX signals #if defined(__CYGWIN__) || defined(__QNX__) || defined(__EMSCRIPTEN__) || defined(__DJGPP__) #define CATCH_INTERNAL_CONFIG_NO_POSIX_SIGNALS #endif #ifdef __OS400__ # define CATCH_INTERNAL_CONFIG_NO_POSIX_SIGNALS # define CATCH_CONFIG_COLOUR_NONE #endif //////////////////////////////////////////////////////////////////////////////// // Android somehow still does not support std::to_string #if defined(__ANDROID__) # define CATCH_INTERNAL_CONFIG_NO_CPP11_TO_STRING # define CATCH_INTERNAL_CONFIG_ANDROID_LOGWRITE #endif //////////////////////////////////////////////////////////////////////////////// // Not all Windows environments support SEH properly #if defined(__MINGW32__) # define CATCH_INTERNAL_CONFIG_NO_WINDOWS_SEH #endif //////////////////////////////////////////////////////////////////////////////// // PS4 #if defined(__ORBIS__) # define CATCH_INTERNAL_CONFIG_NO_NEW_CAPTURE #endif //////////////////////////////////////////////////////////////////////////////// // Cygwin #ifdef __CYGWIN__ // Required for some versions of Cygwin to declare gettimeofday // see: http://stackoverflow.com/questions/36901803/gettimeofday-not-declared-in-this-scope-cygwin # define _BSD_SOURCE // some versions of cygwin (most) do not support std::to_string. Use the libstd check. // https://gcc.gnu.org/onlinedocs/gcc-4.8.2/libstdc++/api/a01053_source.html line 2812-2813 # if !((__cplusplus >= 201103L) && defined(_GLIBCXX_USE_C99) \ && !defined(_GLIBCXX_HAVE_BROKEN_VSWPRINTF)) # define CATCH_INTERNAL_CONFIG_NO_CPP11_TO_STRING # endif #endif // __CYGWIN__ //////////////////////////////////////////////////////////////////////////////// // Visual C++ #if defined(_MSC_VER) // Universal Windows platform does not support SEH // Or console colours (or console at all...) # if defined(WINAPI_FAMILY) && (WINAPI_FAMILY == WINAPI_FAMILY_APP) # define CATCH_CONFIG_COLOUR_NONE # else # define CATCH_INTERNAL_CONFIG_WINDOWS_SEH # endif # if !defined(__clang__) // Handle Clang masquerading for msvc // MSVC traditional preprocessor needs some workaround for __VA_ARGS__ // _MSVC_TRADITIONAL == 0 means new conformant preprocessor // _MSVC_TRADITIONAL == 1 means old traditional non-conformant preprocessor # if !defined(_MSVC_TRADITIONAL) || (defined(_MSVC_TRADITIONAL) && _MSVC_TRADITIONAL) # define CATCH_INTERNAL_CONFIG_TRADITIONAL_MSVC_PREPROCESSOR # endif // MSVC_TRADITIONAL // Only do this if we're not using clang on Windows, which uses `diagnostic push` & `diagnostic pop` # define CATCH_INTERNAL_START_WARNINGS_SUPPRESSION __pragma( warning(push) ) # define CATCH_INTERNAL_STOP_WARNINGS_SUPPRESSION __pragma( warning(pop) ) # endif // __clang__ #endif // _MSC_VER #if defined(_REENTRANT) || defined(_MSC_VER) // Enable async processing, as -pthread is specified or no additional linking is required # define CATCH_INTERNAL_CONFIG_USE_ASYNC #endif // _MSC_VER //////////////////////////////////////////////////////////////////////////////// // Check if we are compiled with -fno-exceptions or equivalent #if defined(__EXCEPTIONS) || defined(__cpp_exceptions) || defined(_CPPUNWIND) # define CATCH_INTERNAL_CONFIG_EXCEPTIONS_ENABLED #endif //////////////////////////////////////////////////////////////////////////////// // DJGPP #ifdef __DJGPP__ # define CATCH_INTERNAL_CONFIG_NO_WCHAR #endif // __DJGPP__ //////////////////////////////////////////////////////////////////////////////// // Embarcadero C++Build #if defined(__BORLANDC__) #define CATCH_INTERNAL_CONFIG_POLYFILL_ISNAN #endif //////////////////////////////////////////////////////////////////////////////// // Use of __COUNTER__ is suppressed during code analysis in // CLion/AppCode 2017.2.x and former, because __COUNTER__ is not properly // handled by it. // Otherwise all supported compilers support COUNTER macro, // but user still might want to turn it off #if ( !defined(__JETBRAINS_IDE__) || __JETBRAINS_IDE__ >= 20170300L ) #define CATCH_INTERNAL_CONFIG_COUNTER #endif //////////////////////////////////////////////////////////////////////////////// // RTX is a special version of Windows that is real time. // This means that it is detected as Windows, but does not provide // the same set of capabilities as real Windows does. #if defined(UNDER_RTSS) || defined(RTX64_BUILD) #define CATCH_INTERNAL_CONFIG_NO_WINDOWS_SEH #define CATCH_INTERNAL_CONFIG_NO_ASYNC #define CATCH_CONFIG_COLOUR_NONE #endif #if !defined(_GLIBCXX_USE_C99_MATH_TR1) #define CATCH_INTERNAL_CONFIG_GLOBAL_NEXTAFTER #endif // Various stdlib support checks that require __has_include #if defined(__has_include) // Check if string_view is available and usable #if __has_include() && defined(CATCH_CPP17_OR_GREATER) # define CATCH_INTERNAL_CONFIG_CPP17_STRING_VIEW #endif // Check if optional is available and usable # if __has_include() && defined(CATCH_CPP17_OR_GREATER) # define CATCH_INTERNAL_CONFIG_CPP17_OPTIONAL # endif // __has_include() && defined(CATCH_CPP17_OR_GREATER) // Check if byte is available and usable # if __has_include() && defined(CATCH_CPP17_OR_GREATER) # include # if defined(__cpp_lib_byte) && (__cpp_lib_byte > 0) # define CATCH_INTERNAL_CONFIG_CPP17_BYTE # endif # endif // __has_include() && defined(CATCH_CPP17_OR_GREATER) // Check if variant is available and usable # if __has_include() && defined(CATCH_CPP17_OR_GREATER) # if defined(__clang__) && (__clang_major__ < 8) // work around clang bug with libstdc++ https://bugs.llvm.org/show_bug.cgi?id=31852 // fix should be in clang 8, workaround in libstdc++ 8.2 # include # if defined(__GLIBCXX__) && defined(_GLIBCXX_RELEASE) && (_GLIBCXX_RELEASE < 9) # define CATCH_CONFIG_NO_CPP17_VARIANT # else # define CATCH_INTERNAL_CONFIG_CPP17_VARIANT # endif // defined(__GLIBCXX__) && defined(_GLIBCXX_RELEASE) && (_GLIBCXX_RELEASE < 9) # else # define CATCH_INTERNAL_CONFIG_CPP17_VARIANT # endif // defined(__clang__) && (__clang_major__ < 8) # endif // __has_include() && defined(CATCH_CPP17_OR_GREATER) #endif // defined(__has_include) #if defined(CATCH_INTERNAL_CONFIG_COUNTER) && !defined(CATCH_CONFIG_NO_COUNTER) && !defined(CATCH_CONFIG_COUNTER) # define CATCH_CONFIG_COUNTER #endif #if defined(CATCH_INTERNAL_CONFIG_WINDOWS_SEH) && !defined(CATCH_CONFIG_NO_WINDOWS_SEH) && !defined(CATCH_CONFIG_WINDOWS_SEH) && !defined(CATCH_INTERNAL_CONFIG_NO_WINDOWS_SEH) # define CATCH_CONFIG_WINDOWS_SEH #endif // This is set by default, because we assume that unix compilers are posix-signal-compatible by default. #if defined(CATCH_INTERNAL_CONFIG_POSIX_SIGNALS) && !defined(CATCH_INTERNAL_CONFIG_NO_POSIX_SIGNALS) && !defined(CATCH_CONFIG_NO_POSIX_SIGNALS) && !defined(CATCH_CONFIG_POSIX_SIGNALS) # define CATCH_CONFIG_POSIX_SIGNALS #endif // This is set by default, because we assume that compilers with no wchar_t support are just rare exceptions. #if !defined(CATCH_INTERNAL_CONFIG_NO_WCHAR) && !defined(CATCH_CONFIG_NO_WCHAR) && !defined(CATCH_CONFIG_WCHAR) # define CATCH_CONFIG_WCHAR #endif #if !defined(CATCH_INTERNAL_CONFIG_NO_CPP11_TO_STRING) && !defined(CATCH_CONFIG_NO_CPP11_TO_STRING) && !defined(CATCH_CONFIG_CPP11_TO_STRING) # define CATCH_CONFIG_CPP11_TO_STRING #endif #if defined(CATCH_INTERNAL_CONFIG_CPP17_OPTIONAL) && !defined(CATCH_CONFIG_NO_CPP17_OPTIONAL) && !defined(CATCH_CONFIG_CPP17_OPTIONAL) # define CATCH_CONFIG_CPP17_OPTIONAL #endif #if defined(CATCH_INTERNAL_CONFIG_CPP17_STRING_VIEW) && !defined(CATCH_CONFIG_NO_CPP17_STRING_VIEW) && !defined(CATCH_CONFIG_CPP17_STRING_VIEW) # define CATCH_CONFIG_CPP17_STRING_VIEW #endif #if defined(CATCH_INTERNAL_CONFIG_CPP17_VARIANT) && !defined(CATCH_CONFIG_NO_CPP17_VARIANT) && !defined(CATCH_CONFIG_CPP17_VARIANT) # define CATCH_CONFIG_CPP17_VARIANT #endif #if defined(CATCH_INTERNAL_CONFIG_CPP17_BYTE) && !defined(CATCH_CONFIG_NO_CPP17_BYTE) && !defined(CATCH_CONFIG_CPP17_BYTE) # define CATCH_CONFIG_CPP17_BYTE #endif #if defined(CATCH_CONFIG_EXPERIMENTAL_REDIRECT) # define CATCH_INTERNAL_CONFIG_NEW_CAPTURE #endif #if defined(CATCH_INTERNAL_CONFIG_NEW_CAPTURE) && !defined(CATCH_INTERNAL_CONFIG_NO_NEW_CAPTURE) && !defined(CATCH_CONFIG_NO_NEW_CAPTURE) && !defined(CATCH_CONFIG_NEW_CAPTURE) # define CATCH_CONFIG_NEW_CAPTURE #endif #if !defined(CATCH_INTERNAL_CONFIG_EXCEPTIONS_ENABLED) && !defined(CATCH_CONFIG_DISABLE_EXCEPTIONS) # define CATCH_CONFIG_DISABLE_EXCEPTIONS #endif #if defined(CATCH_INTERNAL_CONFIG_POLYFILL_ISNAN) && !defined(CATCH_CONFIG_NO_POLYFILL_ISNAN) && !defined(CATCH_CONFIG_POLYFILL_ISNAN) # define CATCH_CONFIG_POLYFILL_ISNAN #endif #if defined(CATCH_INTERNAL_CONFIG_USE_ASYNC) && !defined(CATCH_INTERNAL_CONFIG_NO_ASYNC) && !defined(CATCH_CONFIG_NO_USE_ASYNC) && !defined(CATCH_CONFIG_USE_ASYNC) # define CATCH_CONFIG_USE_ASYNC #endif #if defined(CATCH_INTERNAL_CONFIG_ANDROID_LOGWRITE) && !defined(CATCH_CONFIG_NO_ANDROID_LOGWRITE) && !defined(CATCH_CONFIG_ANDROID_LOGWRITE) # define CATCH_CONFIG_ANDROID_LOGWRITE #endif #if defined(CATCH_INTERNAL_CONFIG_GLOBAL_NEXTAFTER) && !defined(CATCH_CONFIG_NO_GLOBAL_NEXTAFTER) && !defined(CATCH_CONFIG_GLOBAL_NEXTAFTER) # define CATCH_CONFIG_GLOBAL_NEXTAFTER #endif // Even if we do not think the compiler has that warning, we still have // to provide a macro that can be used by the code. #if !defined(CATCH_INTERNAL_START_WARNINGS_SUPPRESSION) # define CATCH_INTERNAL_START_WARNINGS_SUPPRESSION #endif #if !defined(CATCH_INTERNAL_STOP_WARNINGS_SUPPRESSION) # define CATCH_INTERNAL_STOP_WARNINGS_SUPPRESSION #endif #if !defined(CATCH_INTERNAL_SUPPRESS_PARENTHESES_WARNINGS) # define CATCH_INTERNAL_SUPPRESS_PARENTHESES_WARNINGS #endif #if !defined(CATCH_INTERNAL_SUPPRESS_GLOBALS_WARNINGS) # define CATCH_INTERNAL_SUPPRESS_GLOBALS_WARNINGS #endif #if !defined(CATCH_INTERNAL_SUPPRESS_UNUSED_WARNINGS) # define CATCH_INTERNAL_SUPPRESS_UNUSED_WARNINGS #endif #if !defined(CATCH_INTERNAL_SUPPRESS_ZERO_VARIADIC_WARNINGS) # define CATCH_INTERNAL_SUPPRESS_ZERO_VARIADIC_WARNINGS #endif // The goal of this macro is to avoid evaluation of the arguments, but // still have the compiler warn on problems inside... #if !defined(CATCH_INTERNAL_IGNORE_BUT_WARN) # define CATCH_INTERNAL_IGNORE_BUT_WARN(...) #endif #if defined(__APPLE__) && defined(__apple_build_version__) && (__clang_major__ < 10) # undef CATCH_INTERNAL_SUPPRESS_UNUSED_TEMPLATE_WARNINGS #elif defined(__clang__) && (__clang_major__ < 5) # undef CATCH_INTERNAL_SUPPRESS_UNUSED_TEMPLATE_WARNINGS #endif #if !defined(CATCH_INTERNAL_SUPPRESS_UNUSED_TEMPLATE_WARNINGS) # define CATCH_INTERNAL_SUPPRESS_UNUSED_TEMPLATE_WARNINGS #endif #if defined(CATCH_CONFIG_DISABLE_EXCEPTIONS) #define CATCH_TRY if ((true)) #define CATCH_CATCH_ALL if ((false)) #define CATCH_CATCH_ANON(type) if ((false)) #else #define CATCH_TRY try #define CATCH_CATCH_ALL catch (...) #define CATCH_CATCH_ANON(type) catch (type) #endif #if defined(CATCH_INTERNAL_CONFIG_TRADITIONAL_MSVC_PREPROCESSOR) && !defined(CATCH_CONFIG_NO_TRADITIONAL_MSVC_PREPROCESSOR) && !defined(CATCH_CONFIG_TRADITIONAL_MSVC_PREPROCESSOR) #define CATCH_CONFIG_TRADITIONAL_MSVC_PREPROCESSOR #endif // end catch_compiler_capabilities.h #define INTERNAL_CATCH_UNIQUE_NAME_LINE2( name, line ) name##line #define INTERNAL_CATCH_UNIQUE_NAME_LINE( name, line ) INTERNAL_CATCH_UNIQUE_NAME_LINE2( name, line ) #ifdef CATCH_CONFIG_COUNTER # define INTERNAL_CATCH_UNIQUE_NAME( name ) INTERNAL_CATCH_UNIQUE_NAME_LINE( name, __COUNTER__ ) #else # define INTERNAL_CATCH_UNIQUE_NAME( name ) INTERNAL_CATCH_UNIQUE_NAME_LINE( name, __LINE__ ) #endif #include #include #include // We need a dummy global operator<< so we can bring it into Catch namespace later struct Catch_global_namespace_dummy {}; std::ostream& operator<<(std::ostream&, Catch_global_namespace_dummy); namespace Catch { struct CaseSensitive { enum Choice { Yes, No }; }; class NonCopyable { NonCopyable( NonCopyable const& ) = delete; NonCopyable( NonCopyable && ) = delete; NonCopyable& operator = ( NonCopyable const& ) = delete; NonCopyable& operator = ( NonCopyable && ) = delete; protected: NonCopyable(); virtual ~NonCopyable(); }; struct SourceLineInfo { SourceLineInfo() = delete; SourceLineInfo( char const* _file, std::size_t _line ) noexcept : file( _file ), line( _line ) {} SourceLineInfo( SourceLineInfo const& other ) = default; SourceLineInfo& operator = ( SourceLineInfo const& ) = default; SourceLineInfo( SourceLineInfo&& ) noexcept = default; SourceLineInfo& operator = ( SourceLineInfo&& ) noexcept = default; bool empty() const noexcept { return file[0] == '\0'; } bool operator == ( SourceLineInfo const& other ) const noexcept; bool operator < ( SourceLineInfo const& other ) const noexcept; char const* file; std::size_t line; }; std::ostream& operator << ( std::ostream& os, SourceLineInfo const& info ); // Bring in operator<< from global namespace into Catch namespace // This is necessary because the overload of operator<< above makes // lookup stop at namespace Catch using ::operator<<; // Use this in variadic streaming macros to allow // >> +StreamEndStop // as well as // >> stuff +StreamEndStop struct StreamEndStop { std::string operator+() const; }; template T const& operator + ( T const& value, StreamEndStop ) { return value; } } #define CATCH_INTERNAL_LINEINFO \ ::Catch::SourceLineInfo( __FILE__, static_cast( __LINE__ ) ) // end catch_common.h namespace Catch { struct RegistrarForTagAliases { RegistrarForTagAliases( char const* alias, char const* tag, SourceLineInfo const& lineInfo ); }; } // end namespace Catch #define CATCH_REGISTER_TAG_ALIAS( alias, spec ) \ CATCH_INTERNAL_START_WARNINGS_SUPPRESSION \ CATCH_INTERNAL_SUPPRESS_GLOBALS_WARNINGS \ namespace{ Catch::RegistrarForTagAliases INTERNAL_CATCH_UNIQUE_NAME( AutoRegisterTagAlias )( alias, spec, CATCH_INTERNAL_LINEINFO ); } \ CATCH_INTERNAL_STOP_WARNINGS_SUPPRESSION // end catch_tag_alias_autoregistrar.h // start catch_test_registry.h // start catch_interfaces_testcase.h #include namespace Catch { class TestSpec; struct ITestInvoker { virtual void invoke () const = 0; virtual ~ITestInvoker(); }; class TestCase; struct IConfig; struct ITestCaseRegistry { virtual ~ITestCaseRegistry(); virtual std::vector const& getAllTests() const = 0; virtual std::vector const& getAllTestsSorted( IConfig const& config ) const = 0; }; bool isThrowSafe( TestCase const& testCase, IConfig const& config ); bool matchTest( TestCase const& testCase, TestSpec const& testSpec, IConfig const& config ); std::vector filterTests( std::vector const& testCases, TestSpec const& testSpec, IConfig const& config ); std::vector const& getAllTestCasesSorted( IConfig const& config ); } // end catch_interfaces_testcase.h // start catch_stringref.h #include #include #include #include namespace Catch { /// A non-owning string class (similar to the forthcoming std::string_view) /// Note that, because a StringRef may be a substring of another string, /// it may not be null terminated. class StringRef { public: using size_type = std::size_t; using const_iterator = const char*; private: static constexpr char const* const s_empty = ""; char const* m_start = s_empty; size_type m_size = 0; public: // construction constexpr StringRef() noexcept = default; StringRef( char const* rawChars ) noexcept; constexpr StringRef( char const* rawChars, size_type size ) noexcept : m_start( rawChars ), m_size( size ) {} StringRef( std::string const& stdString ) noexcept : m_start( stdString.c_str() ), m_size( stdString.size() ) {} explicit operator std::string() const { return std::string(m_start, m_size); } public: // operators auto operator == ( StringRef const& other ) const noexcept -> bool; auto operator != (StringRef const& other) const noexcept -> bool { return !(*this == other); } auto operator[] ( size_type index ) const noexcept -> char { assert(index < m_size); return m_start[index]; } public: // named queries constexpr auto empty() const noexcept -> bool { return m_size == 0; } constexpr auto size() const noexcept -> size_type { return m_size; } // Returns the current start pointer. If the StringRef is not // null-terminated, throws std::domain_exception auto c_str() const -> char const*; public: // substrings and searches // Returns a substring of [start, start + length). // If start + length > size(), then the substring is [start, size()). // If start > size(), then the substring is empty. auto substr( size_type start, size_type length ) const noexcept -> StringRef; // Returns the current start pointer. May not be null-terminated. auto data() const noexcept -> char const*; constexpr auto isNullTerminated() const noexcept -> bool { return m_start[m_size] == '\0'; } public: // iterators constexpr const_iterator begin() const { return m_start; } constexpr const_iterator end() const { return m_start + m_size; } }; auto operator += ( std::string& lhs, StringRef const& sr ) -> std::string&; auto operator << ( std::ostream& os, StringRef const& sr ) -> std::ostream&; constexpr auto operator "" _sr( char const* rawChars, std::size_t size ) noexcept -> StringRef { return StringRef( rawChars, size ); } } // namespace Catch constexpr auto operator "" _catch_sr( char const* rawChars, std::size_t size ) noexcept -> Catch::StringRef { return Catch::StringRef( rawChars, size ); } // end catch_stringref.h // start catch_preprocessor.hpp #define CATCH_RECURSION_LEVEL0(...) __VA_ARGS__ #define CATCH_RECURSION_LEVEL1(...) CATCH_RECURSION_LEVEL0(CATCH_RECURSION_LEVEL0(CATCH_RECURSION_LEVEL0(__VA_ARGS__))) #define CATCH_RECURSION_LEVEL2(...) CATCH_RECURSION_LEVEL1(CATCH_RECURSION_LEVEL1(CATCH_RECURSION_LEVEL1(__VA_ARGS__))) #define CATCH_RECURSION_LEVEL3(...) CATCH_RECURSION_LEVEL2(CATCH_RECURSION_LEVEL2(CATCH_RECURSION_LEVEL2(__VA_ARGS__))) #define CATCH_RECURSION_LEVEL4(...) CATCH_RECURSION_LEVEL3(CATCH_RECURSION_LEVEL3(CATCH_RECURSION_LEVEL3(__VA_ARGS__))) #define CATCH_RECURSION_LEVEL5(...) CATCH_RECURSION_LEVEL4(CATCH_RECURSION_LEVEL4(CATCH_RECURSION_LEVEL4(__VA_ARGS__))) #ifdef CATCH_CONFIG_TRADITIONAL_MSVC_PREPROCESSOR #define INTERNAL_CATCH_EXPAND_VARGS(...) __VA_ARGS__ // MSVC needs more evaluations #define CATCH_RECURSION_LEVEL6(...) CATCH_RECURSION_LEVEL5(CATCH_RECURSION_LEVEL5(CATCH_RECURSION_LEVEL5(__VA_ARGS__))) #define CATCH_RECURSE(...) CATCH_RECURSION_LEVEL6(CATCH_RECURSION_LEVEL6(__VA_ARGS__)) #else #define CATCH_RECURSE(...) CATCH_RECURSION_LEVEL5(__VA_ARGS__) #endif #define CATCH_REC_END(...) #define CATCH_REC_OUT #define CATCH_EMPTY() #define CATCH_DEFER(id) id CATCH_EMPTY() #define CATCH_REC_GET_END2() 0, CATCH_REC_END #define CATCH_REC_GET_END1(...) CATCH_REC_GET_END2 #define CATCH_REC_GET_END(...) CATCH_REC_GET_END1 #define CATCH_REC_NEXT0(test, next, ...) next CATCH_REC_OUT #define CATCH_REC_NEXT1(test, next) CATCH_DEFER ( CATCH_REC_NEXT0 ) ( test, next, 0) #define CATCH_REC_NEXT(test, next) CATCH_REC_NEXT1(CATCH_REC_GET_END test, next) #define CATCH_REC_LIST0(f, x, peek, ...) , f(x) CATCH_DEFER ( CATCH_REC_NEXT(peek, CATCH_REC_LIST1) ) ( f, peek, __VA_ARGS__ ) #define CATCH_REC_LIST1(f, x, peek, ...) , f(x) CATCH_DEFER ( CATCH_REC_NEXT(peek, CATCH_REC_LIST0) ) ( f, peek, __VA_ARGS__ ) #define CATCH_REC_LIST2(f, x, peek, ...) f(x) CATCH_DEFER ( CATCH_REC_NEXT(peek, CATCH_REC_LIST1) ) ( f, peek, __VA_ARGS__ ) #define CATCH_REC_LIST0_UD(f, userdata, x, peek, ...) , f(userdata, x) CATCH_DEFER ( CATCH_REC_NEXT(peek, CATCH_REC_LIST1_UD) ) ( f, userdata, peek, __VA_ARGS__ ) #define CATCH_REC_LIST1_UD(f, userdata, x, peek, ...) , f(userdata, x) CATCH_DEFER ( CATCH_REC_NEXT(peek, CATCH_REC_LIST0_UD) ) ( f, userdata, peek, __VA_ARGS__ ) #define CATCH_REC_LIST2_UD(f, userdata, x, peek, ...) f(userdata, x) CATCH_DEFER ( CATCH_REC_NEXT(peek, CATCH_REC_LIST1_UD) ) ( f, userdata, peek, __VA_ARGS__ ) // Applies the function macro `f` to each of the remaining parameters, inserts commas between the results, // and passes userdata as the first parameter to each invocation, // e.g. CATCH_REC_LIST_UD(f, x, a, b, c) evaluates to f(x, a), f(x, b), f(x, c) #define CATCH_REC_LIST_UD(f, userdata, ...) CATCH_RECURSE(CATCH_REC_LIST2_UD(f, userdata, __VA_ARGS__, ()()(), ()()(), ()()(), 0)) #define CATCH_REC_LIST(f, ...) CATCH_RECURSE(CATCH_REC_LIST2(f, __VA_ARGS__, ()()(), ()()(), ()()(), 0)) #define INTERNAL_CATCH_EXPAND1(param) INTERNAL_CATCH_EXPAND2(param) #define INTERNAL_CATCH_EXPAND2(...) INTERNAL_CATCH_NO## __VA_ARGS__ #define INTERNAL_CATCH_DEF(...) INTERNAL_CATCH_DEF __VA_ARGS__ #define INTERNAL_CATCH_NOINTERNAL_CATCH_DEF #define INTERNAL_CATCH_STRINGIZE(...) INTERNAL_CATCH_STRINGIZE2(__VA_ARGS__) #ifndef CATCH_CONFIG_TRADITIONAL_MSVC_PREPROCESSOR #define INTERNAL_CATCH_STRINGIZE2(...) #__VA_ARGS__ #define INTERNAL_CATCH_STRINGIZE_WITHOUT_PARENS(param) INTERNAL_CATCH_STRINGIZE(INTERNAL_CATCH_REMOVE_PARENS(param)) #else // MSVC is adding extra space and needs another indirection to expand INTERNAL_CATCH_NOINTERNAL_CATCH_DEF #define INTERNAL_CATCH_STRINGIZE2(...) INTERNAL_CATCH_STRINGIZE3(__VA_ARGS__) #define INTERNAL_CATCH_STRINGIZE3(...) #__VA_ARGS__ #define INTERNAL_CATCH_STRINGIZE_WITHOUT_PARENS(param) (INTERNAL_CATCH_STRINGIZE(INTERNAL_CATCH_REMOVE_PARENS(param)) + 1) #endif #define INTERNAL_CATCH_MAKE_NAMESPACE2(...) ns_##__VA_ARGS__ #define INTERNAL_CATCH_MAKE_NAMESPACE(name) INTERNAL_CATCH_MAKE_NAMESPACE2(name) #define INTERNAL_CATCH_REMOVE_PARENS(...) INTERNAL_CATCH_EXPAND1(INTERNAL_CATCH_DEF __VA_ARGS__) #ifndef CATCH_CONFIG_TRADITIONAL_MSVC_PREPROCESSOR #define INTERNAL_CATCH_MAKE_TYPE_LIST2(...) decltype(get_wrapper()) #define INTERNAL_CATCH_MAKE_TYPE_LIST(...) INTERNAL_CATCH_MAKE_TYPE_LIST2(INTERNAL_CATCH_REMOVE_PARENS(__VA_ARGS__)) #else #define INTERNAL_CATCH_MAKE_TYPE_LIST2(...) INTERNAL_CATCH_EXPAND_VARGS(decltype(get_wrapper())) #define INTERNAL_CATCH_MAKE_TYPE_LIST(...) INTERNAL_CATCH_EXPAND_VARGS(INTERNAL_CATCH_MAKE_TYPE_LIST2(INTERNAL_CATCH_REMOVE_PARENS(__VA_ARGS__))) #endif #define INTERNAL_CATCH_MAKE_TYPE_LISTS_FROM_TYPES(...)\ CATCH_REC_LIST(INTERNAL_CATCH_MAKE_TYPE_LIST,__VA_ARGS__) #define INTERNAL_CATCH_REMOVE_PARENS_1_ARG(_0) INTERNAL_CATCH_REMOVE_PARENS(_0) #define INTERNAL_CATCH_REMOVE_PARENS_2_ARG(_0, _1) INTERNAL_CATCH_REMOVE_PARENS(_0), INTERNAL_CATCH_REMOVE_PARENS_1_ARG(_1) #define INTERNAL_CATCH_REMOVE_PARENS_3_ARG(_0, _1, _2) INTERNAL_CATCH_REMOVE_PARENS(_0), INTERNAL_CATCH_REMOVE_PARENS_2_ARG(_1, _2) #define INTERNAL_CATCH_REMOVE_PARENS_4_ARG(_0, _1, _2, _3) INTERNAL_CATCH_REMOVE_PARENS(_0), INTERNAL_CATCH_REMOVE_PARENS_3_ARG(_1, _2, _3) #define INTERNAL_CATCH_REMOVE_PARENS_5_ARG(_0, _1, _2, _3, _4) INTERNAL_CATCH_REMOVE_PARENS(_0), INTERNAL_CATCH_REMOVE_PARENS_4_ARG(_1, _2, _3, _4) #define INTERNAL_CATCH_REMOVE_PARENS_6_ARG(_0, _1, _2, _3, _4, _5) INTERNAL_CATCH_REMOVE_PARENS(_0), INTERNAL_CATCH_REMOVE_PARENS_5_ARG(_1, _2, _3, _4, _5) #define INTERNAL_CATCH_REMOVE_PARENS_7_ARG(_0, _1, _2, _3, _4, _5, _6) INTERNAL_CATCH_REMOVE_PARENS(_0), INTERNAL_CATCH_REMOVE_PARENS_6_ARG(_1, _2, _3, _4, _5, _6) #define INTERNAL_CATCH_REMOVE_PARENS_8_ARG(_0, _1, _2, _3, _4, _5, _6, _7) INTERNAL_CATCH_REMOVE_PARENS(_0), INTERNAL_CATCH_REMOVE_PARENS_7_ARG(_1, _2, _3, _4, _5, _6, _7) #define INTERNAL_CATCH_REMOVE_PARENS_9_ARG(_0, _1, _2, _3, _4, _5, _6, _7, _8) INTERNAL_CATCH_REMOVE_PARENS(_0), INTERNAL_CATCH_REMOVE_PARENS_8_ARG(_1, _2, _3, _4, _5, _6, _7, _8) #define INTERNAL_CATCH_REMOVE_PARENS_10_ARG(_0, _1, _2, _3, _4, _5, _6, _7, _8, _9) INTERNAL_CATCH_REMOVE_PARENS(_0), INTERNAL_CATCH_REMOVE_PARENS_9_ARG(_1, _2, _3, _4, _5, _6, _7, _8, _9) #define INTERNAL_CATCH_REMOVE_PARENS_11_ARG(_0, _1, _2, _3, _4, _5, _6, _7, _8, _9, _10) INTERNAL_CATCH_REMOVE_PARENS(_0), INTERNAL_CATCH_REMOVE_PARENS_10_ARG(_1, _2, _3, _4, _5, _6, _7, _8, _9, _10) #define INTERNAL_CATCH_VA_NARGS_IMPL(_0, _1, _2, _3, _4, _5, _6, _7, _8, _9, _10, N, ...) N #define INTERNAL_CATCH_TYPE_GEN\ template struct TypeList {};\ template\ constexpr auto get_wrapper() noexcept -> TypeList { return {}; }\ template class...> struct TemplateTypeList{};\ template class...Cs>\ constexpr auto get_wrapper() noexcept -> TemplateTypeList { return {}; }\ template\ struct append;\ template\ struct rewrap;\ template class, typename...>\ struct create;\ template class, typename>\ struct convert;\ \ template \ struct append { using type = T; };\ template< template class L1, typename...E1, template class L2, typename...E2, typename...Rest>\ struct append, L2, Rest...> { using type = typename append, Rest...>::type; };\ template< template class L1, typename...E1, typename...Rest>\ struct append, TypeList, Rest...> { using type = L1; };\ \ template< template class Container, template class List, typename...elems>\ struct rewrap, List> { using type = TypeList>; };\ template< template class Container, template class List, class...Elems, typename...Elements>\ struct rewrap, List, Elements...> { using type = typename append>, typename rewrap, Elements...>::type>::type; };\ \ template