Close fuchsia-rfc-0153 branch.
Since all development has been moved to the `main`
branch, remove all files from the current branch,
and add a new README.md one explaining the situation
and listing the corresponding `main` commit that
replicates the last known state of this one.
Fixed: 301120237
Change-Id: Ifd3f4ffe22d5d4c547bbcace517e088df6c76f2b
Reviewed-on: https://fuchsia-review.googlesource.com/c/third_party/github.com/ninja-build/ninja/+/987832
Reviewed-by: Tyler Mandry <tmandry@google.com>
Reviewed-by: David Turner <digit@google.com>
diff --git a/.clang-format b/.clang-format
deleted file mode 100644
index b8e9225..0000000
--- a/.clang-format
+++ /dev/null
@@ -1,26 +0,0 @@
-# Copyright 2014 Google Inc. All Rights Reserved.
-#
-# Licensed under the Apache License, Version 2.0 (the "License");
-# you may not use this file except in compliance with the License.
-# You may obtain a copy of the License at
-#
-# http://www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing, software
-# distributed under the License is distributed on an "AS IS" BASIS,
-# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-# See the License for the specific language governing permissions and
-# limitations under the License.
-
-# This isn't meant to be authoritative, but it's good enough to be useful.
-# Still use your best judgement for formatting decisions: clang-format
-# sometimes makes strange choices.
-
-BasedOnStyle: Google
-AllowShortFunctionsOnASingleLine: Inline
-AllowShortIfStatementsOnASingleLine: false
-AllowShortLoopsOnASingleLine: false
-ConstructorInitializerAllOnOneLineOrOnePerLine: false
-Cpp11BracedListStyle: false
-IndentCaseLabels: false
-DerivePointerBinding: false
diff --git a/.clang-tidy b/.clang-tidy
deleted file mode 100644
index e0afd47..0000000
--- a/.clang-tidy
+++ /dev/null
@@ -1,17 +0,0 @@
----
-Checks: '
- ,readability-avoid-const-params-in-decls,
- ,readability-inconsistent-declaration-parameter-name,
- ,readability-non-const-parameter,
- ,readability-redundant-string-cstr,
- ,readability-redundant-string-init,
- ,readability-simplify-boolean-expr,
-'
-WarningsAsErrors: '
- ,readability-avoid-const-params-in-decls,
- ,readability-inconsistent-declaration-parameter-name,
- ,readability-non-const-parameter,
- ,readability-redundant-string-cstr,
- ,readability-redundant-string-init,
- ,readability-simplify-boolean-expr,
-'
diff --git a/.editorconfig b/.editorconfig
deleted file mode 100644
index 0cc68d6..0000000
--- a/.editorconfig
+++ /dev/null
@@ -1,11 +0,0 @@
-root = true
-
-[*]
-charset = utf-8
-indent_style = space
-indent_size = 2
-insert_final_newline = true
-end_of_line = lf
-
-[CMakeLists.txt]
-indent_style = tab
diff --git a/.github/workflows/linux.yml b/.github/workflows/linux.yml
deleted file mode 100644
index 57a569e..0000000
--- a/.github/workflows/linux.yml
+++ /dev/null
@@ -1,209 +0,0 @@
-name: Linux
-
-on:
- pull_request:
- push:
- release:
- types: published
-
-jobs:
- build:
- runs-on: [ubuntu-latest]
- container:
- image: centos:7
- steps:
- - uses: actions/checkout@v2
- - uses: codespell-project/actions-codespell@master
- with:
- ignore_words_list: fo,wee
- - name: Install dependencies
- run: |
- curl -L -O https://github.com/Kitware/CMake/releases/download/v3.16.4/cmake-3.16.4-Linux-x86_64.sh
- chmod +x cmake-3.16.4-Linux-x86_64.sh
- ./cmake-3.16.4-Linux-x86_64.sh --skip-license --prefix=/usr/local
- curl -L -O https://www.mirrorservice.org/sites/dl.fedoraproject.org/pub/epel/7/x86_64/Packages/p/p7zip-16.02-20.el7.x86_64.rpm
- curl -L -O https://www.mirrorservice.org/sites/dl.fedoraproject.org/pub/epel/7/x86_64/Packages/p/p7zip-plugins-16.02-20.el7.x86_64.rpm
- rpm -U --quiet p7zip-16.02-20.el7.x86_64.rpm
- rpm -U --quiet p7zip-plugins-16.02-20.el7.x86_64.rpm
- yum install -y make gcc-c++ libasan clang-analyzer
-
- - name: Build debug ninja
- shell: bash
- env:
- CFLAGS: -fstack-protector-all -fsanitize=address
- CXXFLAGS: -fstack-protector-all -fsanitize=address
- run: |
- scan-build -o scanlogs cmake -DCMAKE_BUILD_TYPE=Debug -B debug-build
- scan-build -o scanlogs cmake --build debug-build --parallel --config Debug
-
- - name: Test debug ninja
- run: ./ninja_test
- working-directory: debug-build
-
- - name: Build release ninja
- shell: bash
- run: |
- cmake -DCMAKE_BUILD_TYPE=Release -B release-build
- cmake --build release-build --parallel --config Release
- strip release-build/ninja
-
- - name: Test release ninja
- run: ./ninja_test
- working-directory: release-build
-
- - name: Create ninja archive
- run: |
- mkdir artifact
- 7z a artifact/ninja-linux.zip ./release-build/ninja
-
- # Upload ninja binary archive as an artifact
- - name: Upload artifact
- uses: actions/upload-artifact@v1
- with:
- name: ninja-binary-archives
- path: artifact
-
- - name: Upload release asset
- if: github.event.action == 'published'
- uses: actions/upload-release-asset@v1.0.1
- env:
- GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
- with:
- upload_url: ${{ github.event.release.upload_url }}
- asset_path: ./artifact/ninja-linux.zip
- asset_name: ninja-linux.zip
- asset_content_type: application/zip
-
- test:
- runs-on: [ubuntu-latest]
- container:
- image: ubuntu:20.04
- steps:
- - uses: actions/checkout@v2
- - name: Install dependencies
- run: |
- apt update
- apt install -y python3-pytest ninja-build clang-tidy python3-pip clang
- pip3 install cmake==3.17.*
- - name: Configure (GCC)
- run: cmake -Bbuild-gcc -DCMAKE_BUILD_TYPE=Debug -G'Ninja Multi-Config'
-
- - name: Build (GCC, Debug)
- run: cmake --build build-gcc --config Debug
- - name: Unit tests (GCC, Debug)
- run: ./build-gcc/Debug/ninja_test
- - name: Python tests (GCC, Debug)
- run: pytest-3 --color=yes ../..
- working-directory: build-gcc/Debug
-
- - name: Build (GCC, Release)
- run: cmake --build build-gcc --config Release
- - name: Unit tests (GCC, Release)
- run: ./build-gcc/Release/ninja_test
- - name: Python tests (GCC, Release)
- run: pytest-3 --color=yes ../..
- working-directory: build-gcc/Release
-
- - name: Configure (Clang)
- run: CC=clang CXX=clang++ cmake -Bbuild-clang -DCMAKE_BUILD_TYPE=Debug -G'Ninja Multi-Config' -DCMAKE_EXPORT_COMPILE_COMMANDS=1
-
- - name: Build (Clang, Debug)
- run: cmake --build build-clang --config Debug
- - name: Unit tests (Clang, Debug)
- run: ./build-clang/Debug/ninja_test
- - name: Python tests (Clang, Debug)
- run: pytest-3 --color=yes ../..
- working-directory: build-clang/Debug
-
- - name: Build (Clang, Release)
- run: cmake --build build-clang --config Release
- - name: Unit tests (Clang, Release)
- run: ./build-clang/Release/ninja_test
- - name: Python tests (Clang, Release)
- run: pytest-3 --color=yes ../..
- working-directory: build-clang/Release
-
- - name: clang-tidy
- run: /usr/lib/llvm-10/share/clang/run-clang-tidy.py -header-filter=src
- working-directory: build-clang
-
- build-with-python:
- runs-on: [ubuntu-latest]
- container:
- image: ${{ matrix.image }}
- strategy:
- matrix:
- image: ['ubuntu:14.04', 'ubuntu:16.04', 'ubuntu:18.04']
- steps:
- - uses: actions/checkout@v2
- - name: Install dependencies
- run: |
- apt update
- apt install -y g++ python3
- - name: ${{ matrix.image }}
- run: |
- python3 configure.py --bootstrap
- ./ninja all
- ./ninja_test --gtest_filter=-SubprocessTest.SetWithLots
- python3 misc/ninja_syntax_test.py
- ./misc/output_test.py
-
- build-aarch64:
- name: Build Linux ARM64
- runs-on: [ubuntu-latest]
- steps:
- - uses: actions/checkout@v3
-
- - name: Build
- uses: uraimo/run-on-arch-action@v2
- with:
- arch: aarch64
- distro: ubuntu18.04
- githubToken: ${{ github.token }}
- dockerRunArgs: |
- --volume "${PWD}:/ninja"
- install: |
- apt-get update -q -y
- apt-get install -q -y make gcc g++ libasan5 clang-tools curl p7zip-full file
- run: |
- set -x
- cd /ninja
-
- # INSTALL CMAKE
- CMAKE_VERSION=3.23.4
- curl -L -O https://github.com/Kitware/CMake/releases/download/v${CMAKE_VERSION}/cmake-${CMAKE_VERSION}-Linux-aarch64.sh
- chmod +x cmake-${CMAKE_VERSION}-Linux-aarch64.sh
- ./cmake-${CMAKE_VERSION}-Linux-aarch64.sh --skip-license --prefix=/usr/local
-
- # BUILD
- cmake -DCMAKE_BUILD_TYPE=Release -B release-build
- cmake --build release-build --parallel --config Release
- strip release-build/ninja
- file release-build/ninja
-
- # TEST
- pushd release-build
- ./ninja_test
- popd
-
- # CREATE ARCHIVE
- mkdir artifact
- 7z a artifact/ninja-linux-aarch64.zip ./release-build/ninja
-
- # Upload ninja binary archive as an artifact
- - name: Upload artifact
- uses: actions/upload-artifact@v1
- with:
- name: ninja-binary-archives
- path: artifact
-
- - name: Upload release asset
- if: github.event.action == 'published'
- uses: actions/upload-release-asset@v1.0.1
- env:
- GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
- with:
- upload_url: ${{ github.event.release.upload_url }}
- asset_path: ./artifact/ninja-linux-aarch64.zip
- asset_name: ninja-linux-aarch64.zip
- asset_content_type: application/zip
diff --git a/.github/workflows/macos.yml b/.github/workflows/macos.yml
deleted file mode 100644
index 96b7cf1..0000000
--- a/.github/workflows/macos.yml
+++ /dev/null
@@ -1,53 +0,0 @@
-name: macOS
-
-on:
- pull_request:
- push:
- release:
- types: published
-
-jobs:
- build:
- runs-on: macos-12
-
- steps:
- - uses: actions/checkout@v2
-
- - name: Install dependencies
- run: brew install re2c p7zip cmake
-
- - name: Build ninja
- shell: bash
- env:
- MACOSX_DEPLOYMENT_TARGET: 10.15
- run: |
- cmake -Bbuild -GXcode '-DCMAKE_OSX_ARCHITECTURES=arm64;x86_64'
- cmake --build build --config Release
-
- - name: Test ninja
- run: ctest -C Release -vv
- working-directory: build
-
- - name: Create ninja archive
- shell: bash
- run: |
- mkdir artifact
- 7z a artifact/ninja-mac.zip ./build/Release/ninja
-
- # Upload ninja binary archive as an artifact
- - name: Upload artifact
- uses: actions/upload-artifact@v1
- with:
- name: ninja-binary-archives
- path: artifact
-
- - name: Upload release asset
- if: github.event.action == 'published'
- uses: actions/upload-release-asset@v1.0.1
- env:
- GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
- with:
- upload_url: ${{ github.event.release.upload_url }}
- asset_path: ./artifact/ninja-mac.zip
- asset_name: ninja-mac.zip
- asset_content_type: application/zip
diff --git a/.github/workflows/windows.yml b/.github/workflows/windows.yml
deleted file mode 100644
index b6ec2ac..0000000
--- a/.github/workflows/windows.yml
+++ /dev/null
@@ -1,67 +0,0 @@
-name: Windows
-
-on:
- pull_request:
- push:
- release:
- types: published
-
-jobs:
- build:
- runs-on: windows-latest
-
- strategy:
- fail-fast: false
- matrix:
- include:
- - arch: 'x64'
- suffix: ''
- - arch: 'arm64'
- suffix: 'arm64'
-
- steps:
- - uses: actions/checkout@v2
-
- - name: Install dependencies
- run: choco install re2c
-
- - name: Build ninja
- shell: bash
- run: |
- cmake -Bbuild -A ${{ matrix.arch }}
- cmake --build build --parallel --config Debug
- cmake --build build --parallel --config Release
-
- - name: Test ninja (Debug)
- if: matrix.arch != 'arm64'
- run: .\ninja_test.exe
- working-directory: build/Debug
-
- - name: Test ninja (Release)
- if: matrix.arch != 'arm64'
- run: .\ninja_test.exe
- working-directory: build/Release
-
- - name: Create ninja archive
- shell: bash
- run: |
- mkdir artifact
- 7z a artifact/ninja-win${{ matrix.suffix }}.zip ./build/Release/ninja.exe
-
- # Upload ninja binary archive as an artifact
- - name: Upload artifact
- uses: actions/upload-artifact@v1
- with:
- name: ninja-binary-archives
- path: artifact
-
- - name: Upload release asset
- if: github.event.action == 'published'
- uses: actions/upload-release-asset@v1.0.1
- env:
- GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
- with:
- upload_url: ${{ github.event.release.upload_url }}
- asset_path: ./artifact/ninja-win${{ matrix.suffix }}.zip
- asset_name: ninja-win${{ matrix.suffix }}.zip
- asset_content_type: application/zip
diff --git a/.gitignore b/.gitignore
deleted file mode 100644
index ca36ec8..0000000
--- a/.gitignore
+++ /dev/null
@@ -1,49 +0,0 @@
-*.pyc
-*.obj
-*.exe
-*.pdb
-*.ilk
-/build*/
-/build.ninja
-/ninja
-/ninja.bootstrap
-/build_log_perftest
-/canon_perftest
-/clparser_perftest
-/depfile_parser_perftest
-/hash_collision_bench
-/ninja_test
-/manifest_parser_perftest
-/graph.png
-/doc/manual.html
-/doc/doxygen
-*.patch
-.DS_Store
-
-# Eclipse project files
-.project
-.cproject
-
-# SublimeText project files
-*.sublime-project
-*.sublime-workspace
-
-# Ninja output
-.ninja_deps
-.ninja_log
-
-# Visual Studio Code project files
-/.vscode/
-/.ccls-cache/
-
-# Qt Creator project files
-/CMakeLists.txt.user
-
-# clangd
-/.clangd/
-/compile_commands.json
-/.cache/
-
-# Visual Studio files
-/.vs/
-/out/
diff --git a/CMakeLists.txt b/CMakeLists.txt
deleted file mode 100644
index b901d7c..0000000
--- a/CMakeLists.txt
+++ /dev/null
@@ -1,313 +0,0 @@
-cmake_minimum_required(VERSION 3.15)
-
-include(CheckSymbolExists)
-include(CheckIPOSupported)
-
-option(NINJA_BUILD_BINARY "Build ninja binary" ON)
-option(NINJA_FORCE_PSELECT "Use pselect() even on platforms that provide ppoll()" OFF)
-
-project(ninja CXX)
-
-# --- optional link-time optimization
-check_ipo_supported(RESULT lto_supported OUTPUT error)
-
-if(lto_supported)
- message(STATUS "IPO / LTO enabled")
- set(CMAKE_INTERPROCEDURAL_OPTIMIZATION_RELEASE TRUE)
-else()
- message(STATUS "IPO / LTO not supported: <${error}>")
-endif()
-
-# --- compiler flags
-if(MSVC)
- set(CMAKE_MSVC_RUNTIME_LIBRARY "MultiThreaded$<$<CONFIG:Debug>:Debug>")
- string(REPLACE "/GR" "" CMAKE_CXX_FLAGS ${CMAKE_CXX_FLAGS})
- # Note that these settings are separately specified in configure.py, and
- # these lists should be kept in sync.
- add_compile_options(/W4 /wd4100 /wd4267 /wd4706 /wd4702 /wd4244 /GR- /Zc:__cplusplus)
- add_compile_definitions(_CRT_SECURE_NO_WARNINGS)
-else()
- include(CheckCXXCompilerFlag)
- check_cxx_compiler_flag(-Wno-deprecated flag_no_deprecated)
- if(flag_no_deprecated)
- add_compile_options(-Wno-deprecated)
- endif()
- check_cxx_compiler_flag(-fdiagnostics-color flag_color_diag)
- if(flag_color_diag)
- add_compile_options(-fdiagnostics-color)
- endif()
-
- if(NOT NINJA_FORCE_PSELECT)
- # Check whether ppoll() is usable on the target platform.
- # Set -DUSE_PPOLL=1 if this is the case.
- #
- # NOTE: Use check_cxx_symbol_exists() instead of check_symbol_exists()
- # because on Linux, <poll.h> only exposes the symbol when _GNU_SOURCE
- # is defined.
- #
- # Both g++ and clang++ define the symbol by default, because the C++
- # standard library headers require it, but *not* gcc and clang, which
- # are used by check_symbol_exists().
- include(CheckCXXSymbolExists)
- check_cxx_symbol_exists(ppoll poll.h HAVE_PPOLL)
- check_cxx_symbol_exists(kqueue sys/event.h HAVE_KQUEUE)
- if (HAVE_KQUEUE)
- add_compile_definitions(USE_KQUEUE=1)
- elseif (HAVE_PPOLL)
- add_compile_definitions(USE_PPOLL=1)
- endif()
- endif()
-endif()
-
-# --- optional re2c
-find_program(RE2C re2c)
-if(RE2C)
- # the depfile parser and ninja lexers are generated using re2c.
- function(re2c IN OUT)
- add_custom_command(DEPENDS ${IN} OUTPUT ${OUT}
- COMMAND ${RE2C} -b -i --no-generation-date --no-version -o ${OUT} ${IN}
- )
- endfunction()
- re2c(${PROJECT_SOURCE_DIR}/src/depfile_parser.in.cc ${PROJECT_BINARY_DIR}/depfile_parser.cc)
- re2c(${PROJECT_SOURCE_DIR}/src/lexer.in.cc ${PROJECT_BINARY_DIR}/lexer.cc)
- add_library(libninja-re2c OBJECT ${PROJECT_BINARY_DIR}/depfile_parser.cc ${PROJECT_BINARY_DIR}/lexer.cc)
-else()
- message(WARNING "re2c was not found; changes to src/*.in.cc will not affect your build.")
- add_library(libninja-re2c OBJECT src/depfile_parser.cc src/lexer.cc)
-endif()
-target_include_directories(libninja-re2c PRIVATE src)
-
-# --- Check for 'browse' mode support
-function(check_platform_supports_browse_mode RESULT)
- # Make sure the inline.sh script works on this platform.
- # It uses the shell commands such as 'od', which may not be available.
-
- execute_process(
- COMMAND sh -c "echo 'TEST' | src/inline.sh var"
- WORKING_DIRECTORY ${PROJECT_SOURCE_DIR}
- RESULT_VARIABLE inline_result
- OUTPUT_QUIET
- ERROR_QUIET
- )
- if(NOT inline_result EQUAL "0")
- # The inline script failed, so browse mode is not supported.
- set(${RESULT} "0" PARENT_SCOPE)
- if(NOT WIN32)
- message(WARNING "browse feature omitted due to inline script failure")
- endif()
- return()
- endif()
-
- # Now check availability of the unistd header
- check_symbol_exists(fork "unistd.h" HAVE_FORK)
- check_symbol_exists(pipe "unistd.h" HAVE_PIPE)
- set(browse_supported 0)
- if (HAVE_FORK AND HAVE_PIPE)
- set(browse_supported 1)
- endif ()
- set(${RESULT} "${browse_supported}" PARENT_SCOPE)
- if(NOT browse_supported)
- message(WARNING "browse feature omitted due to missing `fork` and `pipe` functions")
- endif()
-
-endfunction()
-
-set(NINJA_PYTHON "python" CACHE STRING "Python interpreter to use for the browse tool")
-
-check_platform_supports_browse_mode(platform_supports_ninja_browse)
-
-# Core source files all build into ninja library.
-add_library(libninja OBJECT
- src/async_loop.cc
- src/build_config.cc
- src/build_log.cc
- src/build.cc
- src/clean.cc
- src/clparser.cc
- src/dyndep.cc
- src/dyndep_parser.cc
- src/debug_flags.cc
- src/deps_log.cc
- src/disk_interface.cc
- src/edit_distance.cc
- src/eval_env.cc
- src/graph.cc
- src/graphviz.cc
- src/ipc_utils.cc
- src/json.cc
- src/line_printer.cc
- src/manifest_parser.cc
- src/metrics.cc
- src/missing_deps.cc
- src/parser.cc
- src/persistent_mode.cc
- src/persistent_service.cc
- src/process_utils.cc
- src/state.cc
- src/status.cc
- src/stdio_redirection.cc
- src/string_piece_util.cc
- src/util.cc
- src/version.cc
-)
-if(WIN32)
- target_sources(libninja PRIVATE
- src/subprocess-win32.cc
- src/includes_normalize-win32.cc
- src/interrupt_handling-win32.cc
- src/ipc_handle-win32.cc
- src/msvc_helper-win32.cc
- src/msvc_helper_main-win32.cc
- src/getopt.c
- src/minidump-win32.cc
- )
- # Build getopt.c, which can be compiled as either C or C++, as C++
- # so that build environments which lack a C compiler, but have a C++
- # compiler may build ninja.
- set_source_files_properties(src/getopt.c PROPERTIES LANGUAGE CXX)
-else()
- target_sources(libninja PRIVATE
- src/interrupt_handling-posix.cc
- src/ipc_handle-posix.cc
- src/subprocess-posix.cc
- )
- if(CMAKE_SYSTEM_NAME STREQUAL "OS400" OR CMAKE_SYSTEM_NAME STREQUAL "AIX")
- target_sources(libninja PRIVATE src/getopt.c)
- # Build getopt.c, which can be compiled as either C or C++, as C++
- # so that build environments which lack a C compiler, but have a C++
- # compiler may build ninja.
- set_source_files_properties(src/getopt.c PROPERTIES LANGUAGE CXX)
- endif()
-
- # Needed for perfstat_cpu_total
- if(CMAKE_SYSTEM_NAME STREQUAL "AIX")
- target_link_libraries(libninja PUBLIC "-lperfstat")
- endif()
-endif()
-
-if(WIN32)
- target_sources(libninja PRIVATE
- src/stat_cache-win32.cc
- )
-else()
- target_sources(libninja PRIVATE
- src/stat_cache-posix.cc
- )
-endif()
-
-target_compile_features(libninja PUBLIC cxx_std_11)
-
-#Fixes GetActiveProcessorCount on MinGW
-if(MINGW)
-target_compile_definitions(libninja PRIVATE _WIN32_WINNT=0x0601 __USE_MINGW_ANSI_STDIO=1)
-endif()
-
-# On IBM i (identified as "OS400" for compatibility reasons) and AIX, this fixes missing
-# PRId64 (and others) at compile time in C++ sources
-if(CMAKE_SYSTEM_NAME STREQUAL "OS400" OR CMAKE_SYSTEM_NAME STREQUAL "AIX")
- add_compile_definitions(__STDC_FORMAT_MACROS)
-endif()
-
-# Main executable is library plus main() function.
-if(NINJA_BUILD_BINARY)
- add_executable(ninja src/ninja.cc)
- target_link_libraries(ninja PRIVATE libninja libninja-re2c)
-
- if(WIN32)
- target_sources(ninja PRIVATE windows/ninja.manifest)
- endif()
-endif()
-
-# Adds browse mode into the ninja binary if it's supported by the host platform.
-if(platform_supports_ninja_browse)
- # Inlines src/browse.py into the browse_py.h header, so that it can be included
- # by src/browse.cc
- add_custom_command(
- OUTPUT build/browse_py.h
- MAIN_DEPENDENCY src/browse.py
- DEPENDS src/inline.sh
- COMMAND ${CMAKE_COMMAND} -E make_directory ${PROJECT_BINARY_DIR}/build
- COMMAND src/inline.sh kBrowsePy
- < src/browse.py
- > ${PROJECT_BINARY_DIR}/build/browse_py.h
- WORKING_DIRECTORY ${PROJECT_SOURCE_DIR}
- VERBATIM
- )
-
- if(NINJA_BUILD_BINARY)
- target_compile_definitions(ninja PRIVATE NINJA_HAVE_BROWSE)
- target_sources(ninja PRIVATE src/browse.cc)
- endif()
- set_source_files_properties(src/browse.cc
- PROPERTIES
- OBJECT_DEPENDS "${PROJECT_BINARY_DIR}/build/browse_py.h"
- INCLUDE_DIRECTORIES "${PROJECT_BINARY_DIR}"
- COMPILE_DEFINITIONS NINJA_PYTHON="${NINJA_PYTHON}"
- )
-endif()
-
-include(CTest)
-if(BUILD_TESTING)
- # Tests all build into ninja_test executable.
- add_executable(ninja_test
- src/async_loop_test.cc
- src/build_log_test.cc
- src/build_test.cc
- src/clean_test.cc
- src/clparser_test.cc
- src/depfile_parser_test.cc
- src/deps_log_test.cc
- src/disk_interface_test.cc
- src/dyndep_parser_test.cc
- src/edit_distance_test.cc
- src/graph_test.cc
- src/interrupt_handling_test.cc
- src/ipc_handle_test.cc
- src/ipc_utils_test.cc
- src/json_test.cc
- src/lexer_test.cc
- src/manifest_parser_test.cc
- src/missing_deps_test.cc
- src/ninja_test.cc
- src/persistent_mode_test.cc
- src/persistent_service_test.cc
- src/process_utils_test.cc
- src/stat_cache_test.cc
- src/state_test.cc
- src/stdio_redirection_test.cc
- src/string_piece_util_test.cc
- src/subprocess_test.cc
- src/test.cc
- src/util_test.cc
- )
- if(WIN32)
- target_sources(ninja_test PRIVATE src/includes_normalize_test.cc src/msvc_helper_test.cc)
- endif()
- target_link_libraries(ninja_test PRIVATE libninja libninja-re2c)
-
- foreach(perftest
- build_log_perftest
- canon_perftest
- clparser_perftest
- depfile_parser_perftest
- hash_collision_bench
- manifest_parser_perftest
- persistent_mode_test_helper
- persistent_service_test_helper
- )
- add_executable(${perftest} src/${perftest}.cc)
- target_link_libraries(${perftest} PRIVATE libninja libninja-re2c)
- endforeach()
-
- if(CMAKE_SYSTEM_NAME STREQUAL "AIX" AND CMAKE_SIZEOF_VOID_P EQUAL 4)
- # These tests require more memory than will fit in the standard AIX shared stack/heap (256M)
- target_link_options(hash_collision_bench PRIVATE "-Wl,-bmaxdata:0x80000000")
- target_link_options(manifest_parser_perftest PRIVATE "-Wl,-bmaxdata:0x80000000")
- endif()
-
- add_test(NAME NinjaTest COMMAND ninja_test)
-endif()
-
-if(NINJA_BUILD_BINARY)
- install(TARGETS ninja)
-endif()
diff --git a/CONTRIBUTING.md b/CONTRIBUTING.md
deleted file mode 100644
index 37f6ebc..0000000
--- a/CONTRIBUTING.md
+++ /dev/null
@@ -1,30 +0,0 @@
-# How to successfully make changes to Ninja
-
-We're very wary of changes that increase the complexity of Ninja (in particular,
-new build file syntax or command-line flags) or increase the maintenance burden
-of Ninja. Ninja is already successfully used by hundreds of developers for large
-projects and it already achieves (most of) the goals we set out for it to do.
-It's probably best to discuss new feature ideas on the
-[mailing list](https://groups.google.com/forum/#!forum/ninja-build) or in an
-issue before creating a PR.
-
-## Coding guidelines
-
-Generally it's the
-[Google C++ Style Guide](https://google.github.io/styleguide/cppguide.html) with
-a few additions:
-
-* We have used `using namespace std;` a lot in the past. For new contributions,
- please try to avoid relying on it and instead whenever possible use `std::`.
- However, please do not change existing code simply to add `std::` unless your
- contribution already needs to change that line of code anyway.
-* Use `///` for [Doxygen](http://www.doxygen.nl/) (use `\a` to refer to
- arguments).
-* It's not necessary to document each argument, especially when they're
- relatively self-evident (e.g. in
- `CanonicalizePath(string* path, string* err)`, the arguments are hopefully
- obvious).
-
-If you're unsure about code formatting, please use
-[clang-format](https://clang.llvm.org/docs/ClangFormat.html). However, please do
-not format code that is not otherwise part of your contribution.
diff --git a/COPYING b/COPYING
deleted file mode 100644
index 131cb1d..0000000
--- a/COPYING
+++ /dev/null
@@ -1,202 +0,0 @@
-
- Apache License
- Version 2.0, January 2010
- http://www.apache.org/licenses/
-
- TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
-
- 1. Definitions.
-
- "License" shall mean the terms and conditions for use, reproduction,
- and distribution as defined by Sections 1 through 9 of this document.
-
- "Licensor" shall mean the copyright owner or entity authorized by
- the copyright owner that is granting the License.
-
- "Legal Entity" shall mean the union of the acting entity and all
- other entities that control, are controlled by, or are under common
- control with that entity. For the purposes of this definition,
- "control" means (i) the power, direct or indirect, to cause the
- direction or management of such entity, whether by contract or
- otherwise, or (ii) ownership of fifty percent (50%) or more of the
- outstanding shares, or (iii) beneficial ownership of such entity.
-
- "You" (or "Your") shall mean an individual or Legal Entity
- exercising permissions granted by this License.
-
- "Source" form shall mean the preferred form for making modifications,
- including but not limited to software source code, documentation
- source, and configuration files.
-
- "Object" form shall mean any form resulting from mechanical
- transformation or translation of a Source form, including but
- not limited to compiled object code, generated documentation,
- and conversions to other media types.
-
- "Work" shall mean the work of authorship, whether in Source or
- Object form, made available under the License, as indicated by a
- copyright notice that is included in or attached to the work
- (an example is provided in the Appendix below).
-
- "Derivative Works" shall mean any work, whether in Source or Object
- form, that is based on (or derived from) the Work and for which the
- editorial revisions, annotations, elaborations, or other modifications
- represent, as a whole, an original work of authorship. For the purposes
- of this License, Derivative Works shall not include works that remain
- separable from, or merely link (or bind by name) to the interfaces of,
- the Work and Derivative Works thereof.
-
- "Contribution" shall mean any work of authorship, including
- the original version of the Work and any modifications or additions
- to that Work or Derivative Works thereof, that is intentionally
- submitted to Licensor for inclusion in the Work by the copyright owner
- or by an individual or Legal Entity authorized to submit on behalf of
- the copyright owner. For the purposes of this definition, "submitted"
- means any form of electronic, verbal, or written communication sent
- to the Licensor or its representatives, including but not limited to
- communication on electronic mailing lists, source code control systems,
- and issue tracking systems that are managed by, or on behalf of, the
- Licensor for the purpose of discussing and improving the Work, but
- excluding communication that is conspicuously marked or otherwise
- designated in writing by the copyright owner as "Not a Contribution."
-
- "Contributor" shall mean Licensor and any individual or Legal Entity
- on behalf of whom a Contribution has been received by Licensor and
- subsequently incorporated within the Work.
-
- 2. Grant of Copyright License. Subject to the terms and conditions of
- this License, each Contributor hereby grants to You a perpetual,
- worldwide, non-exclusive, no-charge, royalty-free, irrevocable
- copyright license to reproduce, prepare Derivative Works of,
- publicly display, publicly perform, sublicense, and distribute the
- Work and such Derivative Works in Source or Object form.
-
- 3. Grant of Patent License. Subject to the terms and conditions of
- this License, each Contributor hereby grants to You a perpetual,
- worldwide, non-exclusive, no-charge, royalty-free, irrevocable
- (except as stated in this section) patent license to make, have made,
- use, offer to sell, sell, import, and otherwise transfer the Work,
- where such license applies only to those patent claims licensable
- by such Contributor that are necessarily infringed by their
- Contribution(s) alone or by combination of their Contribution(s)
- with the Work to which such Contribution(s) was submitted. If You
- institute patent litigation against any entity (including a
- cross-claim or counterclaim in a lawsuit) alleging that the Work
- or a Contribution incorporated within the Work constitutes direct
- or contributory patent infringement, then any patent licenses
- granted to You under this License for that Work shall terminate
- as of the date such litigation is filed.
-
- 4. Redistribution. You may reproduce and distribute copies of the
- Work or Derivative Works thereof in any medium, with or without
- modifications, and in Source or Object form, provided that You
- meet the following conditions:
-
- (a) You must give any other recipients of the Work or
- Derivative Works a copy of this License; and
-
- (b) You must cause any modified files to carry prominent notices
- stating that You changed the files; and
-
- (c) You must retain, in the Source form of any Derivative Works
- that You distribute, all copyright, patent, trademark, and
- attribution notices from the Source form of the Work,
- excluding those notices that do not pertain to any part of
- the Derivative Works; and
-
- (d) If the Work includes a "NOTICE" text file as part of its
- distribution, then any Derivative Works that You distribute must
- include a readable copy of the attribution notices contained
- within such NOTICE file, excluding those notices that do not
- pertain to any part of the Derivative Works, in at least one
- of the following places: within a NOTICE text file distributed
- as part of the Derivative Works; within the Source form or
- documentation, if provided along with the Derivative Works; or,
- within a display generated by the Derivative Works, if and
- wherever such third-party notices normally appear. The contents
- of the NOTICE file are for informational purposes only and
- do not modify the License. You may add Your own attribution
- notices within Derivative Works that You distribute, alongside
- or as an addendum to the NOTICE text from the Work, provided
- that such additional attribution notices cannot be construed
- as modifying the License.
-
- You may add Your own copyright statement to Your modifications and
- may provide additional or different license terms and conditions
- for use, reproduction, or distribution of Your modifications, or
- for any such Derivative Works as a whole, provided Your use,
- reproduction, and distribution of the Work otherwise complies with
- the conditions stated in this License.
-
- 5. Submission of Contributions. Unless You explicitly state otherwise,
- any Contribution intentionally submitted for inclusion in the Work
- by You to the Licensor shall be under the terms and conditions of
- this License, without any additional terms or conditions.
- Notwithstanding the above, nothing herein shall supersede or modify
- the terms of any separate license agreement you may have executed
- with Licensor regarding such Contributions.
-
- 6. Trademarks. This License does not grant permission to use the trade
- names, trademarks, service marks, or product names of the Licensor,
- except as required for reasonable and customary use in describing the
- origin of the Work and reproducing the content of the NOTICE file.
-
- 7. Disclaimer of Warranty. Unless required by applicable law or
- agreed to in writing, Licensor provides the Work (and each
- Contributor provides its Contributions) on an "AS IS" BASIS,
- WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
- implied, including, without limitation, any warranties or conditions
- of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
- PARTICULAR PURPOSE. You are solely responsible for determining the
- appropriateness of using or redistributing the Work and assume any
- risks associated with Your exercise of permissions under this License.
-
- 8. Limitation of Liability. In no event and under no legal theory,
- whether in tort (including negligence), contract, or otherwise,
- unless required by applicable law (such as deliberate and grossly
- negligent acts) or agreed to in writing, shall any Contributor be
- liable to You for damages, including any direct, indirect, special,
- incidental, or consequential damages of any character arising as a
- result of this License or out of the use or inability to use the
- Work (including but not limited to damages for loss of goodwill,
- work stoppage, computer failure or malfunction, or any and all
- other commercial damages or losses), even if such Contributor
- has been advised of the possibility of such damages.
-
- 9. Accepting Warranty or Additional Liability. While redistributing
- the Work or Derivative Works thereof, You may choose to offer,
- and charge a fee for, acceptance of support, warranty, indemnity,
- or other liability obligations and/or rights consistent with this
- License. However, in accepting such obligations, You may act only
- on Your own behalf and on Your sole responsibility, not on behalf
- of any other Contributor, and only if You agree to indemnify,
- defend, and hold each Contributor harmless for any liability
- incurred by, or claims asserted against, such Contributor by reason
- of your accepting any such warranty or additional liability.
-
- END OF TERMS AND CONDITIONS
-
- APPENDIX: How to apply the Apache License to your work.
-
- To apply the Apache License to your work, attach the following
- boilerplate notice, with the fields enclosed by brackets "[]"
- replaced with your own identifying information. (Don't include
- the brackets!) The text should be enclosed in the appropriate
- comment syntax for the file format. We also recommend that a
- file or class name and description of purpose be included on the
- same "printed page" as the copyright notice for easier
- identification within third-party archives.
-
- Copyright [yyyy] [name of copyright owner]
-
- Licensed under the Apache License, Version 2.0 (the "License");
- you may not use this file except in compliance with the License.
- You may obtain a copy of the License at
-
- http://www.apache.org/licenses/LICENSE-2.0
-
- Unless required by applicable law or agreed to in writing, software
- distributed under the License is distributed on an "AS IS" BASIS,
- WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- See the License for the specific language governing permissions and
- limitations under the License.
diff --git a/README.fuchsia b/README.fuchsia
deleted file mode 100644
index 6251197..0000000
--- a/README.fuchsia
+++ /dev/null
@@ -1,87 +0,0 @@
-Name: Ninja
-URL: https://ninja-build.org
-Gerrit Git: https://fuchsia.googlesource.com/third_party/github.com/ninja-build/ninja
-Upstream Git: https://github.com/ninja-build/ninja
-Fuchsia RFC: https://fuchsia.dev/fuchsia-src/contribute/governance/rfcs/0153_ninja_customization?hl=en
-License: Apache 2.0
-License File: COPYING
-Fuchsia Bug: https://fxbug.dev/91545
-Description:
-
-Ninja is a small build system with a focus on speed. As explained in the
-Fuchsia RFC-0153 document, this is a temporary custom branch of the upstream
-Ninja sources to provide various improvements for the Fuchsia build. All
-changes should be expressed as a set of small commits on top of the upstream
-main branch, periodically rebased according to the strategy described in the
-RFC document. Due to this, local modifications are not listed explictly here
-to reduce unnecessary merge conflicts in this file.
-
-Note that:
-
-- Development happens in the `fuchsia-rfc-0153` branch of
- `https://fuchsia.googlesource.com/third_party/github.com/ninja-build/ninja`
-
-- All patches need to be uploaded to Gerrit for review approval.
-
-- Sync branches can only be created on Gerrit, and require filing
- a ticket, see associated bug for details.
-
-Use `git log origin/upstream/master..fuchsia-rfc-0153` to see the detail log
-of changes instead.
-
-To facilite sync branch creation and management, the commit message of
-patches should following these conventions:
-
-- Patches that were cherry-picked from upstream should have a line that
- starts with `Upstream-Cherry-Pick: <COMMIT>` added to their original
- commit message.
-
-- Patches that were cherry-picked from the upstream GitHub pull requests
- should have a line that starts with `Upstream-GitHub-PR: <URL>`
- pointing to the corresponding pull request.
-
-- Patches that should not be sent upstream should have a line that
- starts with `Fuchsia-Only: <REASON>`. These should only matter for
- Fuchsia specific documentation (such as this file), or development
- scripts.
-
-- Non-trivial changes that address a specific feature should be provided
- as a series of small patches whose commit messages all include a line
- that starts with `Fuchsia-Topic: <name>`, where `<name>` is a small
- identifier describing the common feature (e.g. `faster-manifest-parser`)
- described by the list in the next section of this README.fuchsia file.
-
- This will allow collecting the commits to send them as upstream pull
- requests (after removing these lines from the commit message), or to
- re-order them during sync-branch rebase operations.
-
-Fuchsia-specific scripts or data files should go under `misc/fuchsia/`.
-
-List of Fuchsia-Topic items:
-
-multi-line-status
- Improve the status display in smart terminals to include a list of
- the oldest pending commands that are still running. This feature is
- controlled by setting NINJA_STATUS_MAX_COMMANDS in the
- environment to a decimal value that is >= 1.
-
-advanced-ipc
- Provide support for advanced inter-process communication using
- named pipes (on Win32) or unix domain sockets (on Posix). This
- will be used to implement both the `persistent-mode` feature
- and the `jobserver-support` feature.
-
-persistent-mode
- Allow the Ninja process to run in daemon mode after parsing the
- Ninja build plan, until a .ninja file is changed or some fixed
- expiration time, in order to start future `ninja` invocations
- immediately (instead of spending several seconds to re-load the
- build plan every time).
- Requires: advanced-ipc
-
-jobserver-support
- Allow Ninja to act as both a GNU Make jobserver client
- (when invoking from other build systems), and a server
- (when invoking sub-commands).
- Requires: advanced-ipc
-
diff --git a/README.md b/README.md
index 1ca56c5..629c892 100644
--- a/README.md
+++ b/README.md
@@ -1,51 +1,10 @@
-# Ninja
+Development of the Fuchsia-specific Ninja fork
+described by Fuchsia RFC-0153 has moved from the
+`fuchsia-rfc-0153` branch to the `main` one on
+this git repository. For more details, see
-Ninja is a small build system with a focus on speed.
-https://ninja-build.org/
+ https://fxbug.dev/301120237
-See [the manual](https://ninja-build.org/manual.html) or
-`doc/manual.asciidoc` included in the distribution for background
-and more details.
-
-Binaries for Linux, Mac and Windows are available on
- [GitHub](https://github.com/ninja-build/ninja/releases).
-Run `./ninja -h` for Ninja help.
-
-Installation is not necessary because the only required file is the
-resulting ninja binary. However, to enable features like Bash
-completion and Emacs and Vim editing modes, some files in misc/ must be
-copied to appropriate locations.
-
-If you're interested in making changes to Ninja, read
-[CONTRIBUTING.md](CONTRIBUTING.md) first.
-
-## Building Ninja itself
-
-You can either build Ninja via the custom generator script written in Python or
-via CMake. For more details see
-[the wiki](https://github.com/ninja-build/ninja/wiki).
-
-### Python
-
-```
-./configure.py --bootstrap
-```
-
-This will generate the `ninja` binary and a `build.ninja` file you can now use
-to build Ninja with itself.
-
-### CMake
-
-```
-cmake -Bbuild-cmake
-cmake --build build-cmake
-```
-
-The `ninja` binary will now be inside the `build-cmake` directory (you can
-choose any other name you like).
-
-To run the unit tests:
-
-```
-./build-cmake/ninja_test
-```
+The previous state of this branch is reflected
+in commit dba41a7f80dc426364ae9238746f37ff7d06febf
+belonging to the main branch.
diff --git a/RELEASING.md b/RELEASING.md
deleted file mode 100644
index 4e3a4bd..0000000
--- a/RELEASING.md
+++ /dev/null
@@ -1,41 +0,0 @@
-Notes to myself on all the steps to make for a Ninja release.
-
-### Push new release branch:
-1. Run afl-fuzz for a day or so and run ninja_test
-2. Consider sending a heads-up to the ninja-build mailing list first
-3. Make sure branches 'master' and 'release' are synced up locally
-4. Update src/version.cc with new version (with ".git"), then
- ```
- git commit -am 'mark this 1.5.0.git'
- ```
-5. git checkout release; git merge master
-6. Fix version number in src/version.cc (it will likely conflict in the above)
-7. Fix version in doc/manual.asciidoc (exists only on release branch)
-8. commit, tag, push (don't forget to push --tags)
- ```
- git commit -am v1.5.0; git push origin release
- git tag v1.5.0; git push --tags
- # Push the 1.5.0.git change on master too:
- git checkout master; git push origin master
- ```
-9. Construct release notes from prior notes
-
- credits: `git shortlog -s --no-merges REV..`
-
-
-### Release on GitHub:
-1. Go to [Tags](https://github.com/ninja-build/ninja/tags)
-2. Open the newly created tag and select "Create release from tag"
-3. Create the release which will trigger a build which automatically attaches
- the binaries
-
-### Make announcement on mailing list:
-1. copy old mail
-
-### Update website:
-1. Make sure your ninja checkout is on the v1.5.0 tag
-2. Clone https://github.com/ninja-build/ninja-build.github.io
-3. In that repo, `./update-docs.sh`
-4. Update index.html with newest version and link to release notes
-5. `git commit -m 'run update-docs.sh, 1.5.0 release'`
-6. `git push origin master`
diff --git a/appveyor.yml b/appveyor.yml
deleted file mode 100644
index f0b92b8..0000000
--- a/appveyor.yml
+++ /dev/null
@@ -1,61 +0,0 @@
-version: 1.0.{build}
-image:
- - Visual Studio 2017
- - Ubuntu1804
-
-environment:
- CLICOLOR_FORCE: 1
- CHERE_INVOKING: 1 # Tell Bash to inherit the current working directory
- matrix:
- - MSYSTEM: MINGW64
- - MSYSTEM: MSVC
- - MSYSTEM: LINUX
-
-matrix:
- exclude:
- - image: Visual Studio 2017
- MSYSTEM: LINUX
- - image: Ubuntu1804
- MSYSTEM: MINGW64
- - image: Ubuntu1804
- MSYSTEM: MSVC
-
-for:
- -
- matrix:
- only:
- - MSYSTEM: MINGW64
- build_script:
- ps: "C:\\msys64\\usr\\bin\\bash -lc @\"\n
- pacman -S --quiet --noconfirm --needed re2c 2>&1\n
- ./configure.py --bootstrap --platform mingw 2>&1\n
- ./ninja all\n
- ./ninja_test 2>&1\n
- ./misc/ninja_syntax_test.py 2>&1\n\"@"
- -
- matrix:
- only:
- - MSYSTEM: MSVC
- build_script:
- - cmd: >-
- call "C:\Program Files (x86)\Microsoft Visual Studio\2017\Community\VC\Auxiliary\Build\vcvars64.bat"
-
- python configure.py --bootstrap
-
- ninja.bootstrap.exe all
-
- ninja_test
-
- python misc/ninja_syntax_test.py
-
- - matrix:
- only:
- - image: Ubuntu1804
- build_script:
- - ./configure.py --bootstrap
- - ./ninja all
- - ./ninja_test
- - misc/ninja_syntax_test.py
- - misc/output_test.py
-
-test: off
diff --git a/configure.py b/configure.py
deleted file mode 100755
index 4a3c67c..0000000
--- a/configure.py
+++ /dev/null
@@ -1,774 +0,0 @@
-#!/usr/bin/env python3
-#
-# Copyright 2001 Google Inc. All Rights Reserved.
-#
-# Licensed under the Apache License, Version 2.0 (the "License");
-# you may not use this file except in compliance with the License.
-# You may obtain a copy of the License at
-#
-# http://www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing, software
-# distributed under the License is distributed on an "AS IS" BASIS,
-# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-# See the License for the specific language governing permissions and
-# limitations under the License.
-
-"""Script that generates the build.ninja for ninja itself.
-
-Projects that use ninja themselves should either write a similar script
-or use a meta-build system that supports Ninja output."""
-
-from optparse import OptionParser
-import os
-import pipes
-import string
-import subprocess
-import sys
-
-sourcedir = os.path.dirname(os.path.realpath(__file__))
-sys.path.insert(0, os.path.join(sourcedir, 'misc'))
-import ninja_syntax
-
-
-class Platform(object):
- """Represents a host/target platform and its specific build attributes."""
- def __init__(self, platform):
- self._platform = platform
- if self._platform is not None:
- return
- self._platform = sys.platform
- if self._platform.startswith('linux'):
- self._platform = 'linux'
- elif self._platform.startswith('freebsd'):
- self._platform = 'freebsd'
- elif self._platform.startswith('gnukfreebsd'):
- self._platform = 'freebsd'
- elif self._platform.startswith('openbsd'):
- self._platform = 'openbsd'
- elif self._platform.startswith('solaris') or self._platform == 'sunos5':
- self._platform = 'solaris'
- elif self._platform.startswith('mingw'):
- self._platform = 'mingw'
- elif self._platform.startswith('win'):
- self._platform = 'msvc'
- elif self._platform.startswith('bitrig'):
- self._platform = 'bitrig'
- elif self._platform.startswith('netbsd'):
- self._platform = 'netbsd'
- elif self._platform.startswith('aix'):
- self._platform = 'aix'
- elif self._platform.startswith('os400'):
- self._platform = 'os400'
- elif self._platform.startswith('dragonfly'):
- self._platform = 'dragonfly'
-
- @staticmethod
- def known_platforms():
- return ['linux', 'darwin', 'freebsd', 'openbsd', 'solaris', 'sunos5',
- 'mingw', 'msvc', 'gnukfreebsd', 'bitrig', 'netbsd', 'aix',
- 'dragonfly']
-
- def platform(self):
- return self._platform
-
- def is_linux(self):
- return self._platform == 'linux'
-
- def is_mingw(self):
- return self._platform == 'mingw'
-
- def is_msvc(self):
- return self._platform == 'msvc'
-
- def msvc_needs_fs(self):
- popen = subprocess.Popen(['cl', '/nologo', '/help'],
- stdout=subprocess.PIPE,
- stderr=subprocess.PIPE)
- out, err = popen.communicate()
- return b'/FS' in out
-
- def is_windows(self):
- return self.is_mingw() or self.is_msvc()
-
- def is_solaris(self):
- return self._platform == 'solaris'
-
- def is_aix(self):
- return self._platform == 'aix'
-
- def is_os400_pase(self):
- return self._platform == 'os400' or os.uname().sysname.startswith('OS400')
-
- def uses_usr_local(self):
- return self._platform in ('freebsd', 'openbsd', 'bitrig', 'dragonfly', 'netbsd')
-
- def supports_ppoll(self):
- return self._platform in ('freebsd', 'linux', 'openbsd', 'bitrig',
- 'dragonfly')
- def supports_kqueue(self):
- return self._platform in ('freebsd', 'openbsd', 'dragonfly', 'darwin')
-
- def supports_ninja_browse(self):
- return (not self.is_windows()
- and not self.is_solaris()
- and not self.is_aix())
-
- def can_rebuild_in_place(self):
- return not (self.is_windows() or self.is_aix())
-
-class Bootstrap:
- """API shim for ninja_syntax.Writer that instead runs the commands.
-
- Used to bootstrap Ninja from scratch. In --bootstrap mode this
- class is used to execute all the commands to build an executable.
- It also proxies all calls to an underlying ninja_syntax.Writer, to
- behave like non-bootstrap mode.
- """
- def __init__(self, writer, verbose=False):
- self.writer = writer
- self.verbose = verbose
- # Map of variable name => expanded variable value.
- self.vars = {}
- # Map of rule name => dict of rule attributes.
- self.rules = {
- 'phony': {}
- }
-
- def comment(self, text):
- return self.writer.comment(text)
-
- def newline(self):
- return self.writer.newline()
-
- def variable(self, key, val):
- # In bootstrap mode, we have no ninja process to catch /showIncludes
- # output.
- self.vars[key] = self._expand(val).replace('/showIncludes', '')
- return self.writer.variable(key, val)
-
- def rule(self, name, **kwargs):
- self.rules[name] = kwargs
- return self.writer.rule(name, **kwargs)
-
- def build(self, outputs, rule, inputs=None, **kwargs):
- ruleattr = self.rules[rule]
- cmd = ruleattr.get('command')
- if cmd is None: # A phony rule, for example.
- return
-
- # Implement just enough of Ninja variable expansion etc. to
- # make the bootstrap build work.
- local_vars = {
- 'in': self._expand_paths(inputs),
- 'out': self._expand_paths(outputs)
- }
- for key, val in kwargs.get('variables', []):
- local_vars[key] = ' '.join(ninja_syntax.as_list(val))
-
- self._run_command(self._expand(cmd, local_vars))
-
- return self.writer.build(outputs, rule, inputs, **kwargs)
-
- def default(self, paths):
- return self.writer.default(paths)
-
- def _expand_paths(self, paths):
- """Expand $vars in an array of paths, e.g. from a 'build' block."""
- paths = ninja_syntax.as_list(paths)
- return ' '.join(map(self._shell_escape, (map(self._expand, paths))))
-
- def _expand(self, str, local_vars={}):
- """Expand $vars in a string."""
- return ninja_syntax.expand(str, self.vars, local_vars)
-
- def _shell_escape(self, path):
- """Quote paths containing spaces."""
- return '"%s"' % path if ' ' in path else path
-
- def _run_command(self, cmdline):
- """Run a subcommand, quietly. Prints the full command on error."""
- try:
- if self.verbose:
- print(cmdline)
- subprocess.check_call(cmdline, shell=True)
- except subprocess.CalledProcessError:
- print('when running: ', cmdline)
- raise
-
-
-parser = OptionParser()
-profilers = ['gmon', 'pprof']
-parser.add_option('--bootstrap', action='store_true',
- help='bootstrap a ninja binary from nothing')
-parser.add_option('--verbose', action='store_true',
- help='enable verbose build')
-parser.add_option('--platform',
- help='target platform (' +
- '/'.join(Platform.known_platforms()) + ')',
- choices=Platform.known_platforms())
-parser.add_option('--host',
- help='host platform (' +
- '/'.join(Platform.known_platforms()) + ')',
- choices=Platform.known_platforms())
-parser.add_option('--debug', action='store_true',
- help='enable debugging extras',)
-parser.add_option('--profile', metavar='TYPE',
- choices=profilers,
- help='enable profiling (' + '/'.join(profilers) + ')',)
-parser.add_option('--with-gtest', metavar='PATH', help='ignored')
-parser.add_option('--with-python', metavar='EXE',
- help='use EXE as the Python interpreter',
- default=os.path.basename(sys.executable))
-parser.add_option('--force-pselect', action='store_true',
- help='ppoll() is used by default where available, '
- 'but some platforms may need to use pselect instead',)
-(options, args) = parser.parse_args()
-if args:
- print('ERROR: extra unparsed command-line arguments:', args)
- sys.exit(1)
-
-platform = Platform(options.platform)
-if options.host:
- host = Platform(options.host)
-else:
- host = platform
-
-BUILD_FILENAME = 'build.ninja'
-ninja_writer = ninja_syntax.Writer(open(BUILD_FILENAME, 'w'))
-n = ninja_writer
-
-if options.bootstrap:
- # Make the build directory.
- try:
- os.mkdir('build')
- except OSError:
- pass
- # Wrap ninja_writer with the Bootstrapper, which also executes the
- # commands.
- print('bootstrapping ninja...')
- n = Bootstrap(n, verbose=options.verbose)
-
-n.comment('This file is used to build ninja itself.')
-n.comment('It is generated by ' + os.path.basename(__file__) + '.')
-n.newline()
-
-n.variable('ninja_required_version', '1.3')
-n.newline()
-
-n.comment('The arguments passed to configure.py, for rerunning it.')
-configure_args = sys.argv[1:]
-if '--bootstrap' in configure_args:
- configure_args.remove('--bootstrap')
-n.variable('configure_args', ' '.join(configure_args))
-env_keys = set(['CXX', 'AR', 'CFLAGS', 'CXXFLAGS', 'LDFLAGS'])
-configure_env = dict((k, os.environ[k]) for k in os.environ if k in env_keys)
-if configure_env:
- config_str = ' '.join([k + '=' + pipes.quote(configure_env[k])
- for k in configure_env])
- n.variable('configure_env', config_str + '$ ')
-n.newline()
-
-CXX = configure_env.get('CXX', 'c++')
-objext = '.o'
-if platform.is_msvc():
- CXX = 'cl'
- objext = '.obj'
-
-def src(filename):
- return os.path.join('$root', 'src', filename)
-def built(filename):
- return os.path.join('$builddir', filename)
-def doc(filename):
- return os.path.join('$root', 'doc', filename)
-def cc(name, **kwargs):
- return n.build(built(name + objext), 'cxx', src(name + '.c'), **kwargs)
-def cxx(name, **kwargs):
- return n.build(built(name + objext), 'cxx', src(name + '.cc'), **kwargs)
-def binary(name):
- if platform.is_windows():
- exe = name + '.exe'
- n.build(name, 'phony', exe)
- return exe
- return name
-
-root = sourcedir
-if root == os.getcwd():
- # In the common case where we're building directly in the source
- # tree, simplify all the paths to just be cwd-relative.
- root = '.'
-n.variable('root', root)
-n.variable('builddir', 'build')
-n.variable('cxx', CXX)
-if platform.is_msvc():
- n.variable('ar', 'link')
-else:
- n.variable('ar', configure_env.get('AR', 'ar'))
-
-def search_system_path(file_name):
- """Find a file in the system path."""
- for dir in os.environ['path'].split(';'):
- path = os.path.join(dir, file_name)
- if os.path.exists(path):
- return path
-
-# Note that build settings are separately specified in CMakeLists.txt and
-# these lists should be kept in sync.
-if platform.is_msvc():
- if not search_system_path('cl.exe'):
- raise Exception('cl.exe not found. Run again from the Developer Command Prompt for VS')
- cflags = ['/showIncludes',
- '/nologo', # Don't print startup banner.
- '/Zi', # Create pdb with debug info.
- '/W4', # Highest warning level.
- '/WX', # Warnings as errors.
- '/wd4530', '/wd4100', '/wd4706', '/wd4244',
- '/wd4512', '/wd4800', '/wd4702', '/wd4819',
- # Disable warnings about constant conditional expressions.
- '/wd4127',
- # Disable warnings about passing "this" during initialization.
- '/wd4355',
- # Disable warnings about ignored typedef in DbgHelp.h
- '/wd4091',
- '/GR-', # Disable RTTI.
- '/Zc:__cplusplus',
- # Disable size_t -> int truncation warning.
- # We never have strings or arrays larger than 2**31.
- '/wd4267',
- '/DNOMINMAX', '/D_CRT_SECURE_NO_WARNINGS',
- '/D_HAS_EXCEPTIONS=0',
- '/DNINJA_PYTHON="%s"' % options.with_python]
- if platform.msvc_needs_fs():
- cflags.append('/FS')
- ldflags = ['/DEBUG', '/libpath:$builddir']
- if not options.debug:
- cflags += ['/Ox', '/DNDEBUG', '/GL']
- ldflags += ['/LTCG', '/OPT:REF', '/OPT:ICF']
-else:
- cflags = ['-g', '-Wall', '-Wextra',
- '-Wno-deprecated',
- '-Wno-missing-field-initializers',
- '-Wno-unused-parameter',
- '-fno-rtti',
- '-fno-exceptions',
- '-std=c++11',
- '-fvisibility=hidden', '-pipe',
- '-DNINJA_PYTHON="%s"' % options.with_python]
- if options.debug:
- cflags += ['-D_GLIBCXX_DEBUG', '-D_GLIBCXX_DEBUG_PEDANTIC']
- cflags.remove('-fno-rtti') # Needed for above pedanticness.
- else:
- cflags += ['-O2', '-DNDEBUG']
- try:
- proc = subprocess.Popen(
- [CXX, '-fdiagnostics-color', '-c', '-x', 'c++', '/dev/null',
- '-o', '/dev/null'],
- stdout=open(os.devnull, 'wb'), stderr=subprocess.STDOUT)
- if proc.wait() == 0:
- cflags += ['-fdiagnostics-color']
- except:
- pass
- if platform.is_mingw():
- cflags += ['-D_WIN32_WINNT=0x0601', '-D__USE_MINGW_ANSI_STDIO=1']
- ldflags = ['-L$builddir']
- if platform.uses_usr_local():
- cflags.append('-I/usr/local/include')
- ldflags.append('-L/usr/local/lib')
- if platform.is_aix():
- # printf formats for int64_t, uint64_t; large file support
- cflags.append('-D__STDC_FORMAT_MACROS')
- cflags.append('-D_LARGE_FILES')
-
-
-libs = []
-
-if platform.is_mingw():
- cflags.remove('-fvisibility=hidden');
- ldflags.append('-static')
-elif platform.is_solaris():
- cflags.remove('-fvisibility=hidden')
-elif platform.is_aix():
- cflags.remove('-fvisibility=hidden')
-elif platform.is_msvc():
- pass
-else:
- if options.profile == 'gmon':
- cflags.append('-pg')
- ldflags.append('-pg')
- elif options.profile == 'pprof':
- cflags.append('-fno-omit-frame-pointer')
- libs.extend(['-Wl,--no-as-needed', '-lprofiler'])
-
-if platform.supports_kqueue() and not options.force_pselect:
- cflags.append('-DUSE_KQUEUE')
-elif platform.supports_ppoll() and not options.force_pselect:
- cflags.append('-DUSE_PPOLL')
-if platform.supports_ninja_browse():
- cflags.append('-DNINJA_HAVE_BROWSE')
-
-# Search for generated headers relative to build dir.
-cflags.append('-I.')
-
-def shell_escape(str):
- """Escape str such that it's interpreted as a single argument by
- the shell."""
-
- # This isn't complete, but it's just enough to make NINJA_PYTHON work.
- if platform.is_windows():
- return str
- if '"' in str:
- return "'%s'" % str.replace("'", "\\'")
- return str
-
-if 'CFLAGS' in configure_env:
- cflags.append(configure_env['CFLAGS'])
- ldflags.append(configure_env['CFLAGS'])
-if 'CXXFLAGS' in configure_env:
- cflags.append(configure_env['CXXFLAGS'])
- ldflags.append(configure_env['CXXFLAGS'])
-n.variable('cflags', ' '.join(shell_escape(flag) for flag in cflags))
-if 'LDFLAGS' in configure_env:
- ldflags.append(configure_env['LDFLAGS'])
-n.variable('ldflags', ' '.join(shell_escape(flag) for flag in ldflags))
-n.newline()
-
-if platform.is_msvc():
- n.rule('cxx',
- command='$cxx $cflags -c $in /Fo$out /Fd' + built('$pdb'),
- description='CXX $out',
- deps='msvc' # /showIncludes is included in $cflags.
- )
-else:
- n.rule('cxx',
- command='$cxx -MMD -MT $out -MF $out.d $cflags -c $in -o $out',
- depfile='$out.d',
- deps='gcc',
- description='CXX $out')
-n.newline()
-
-if host.is_msvc():
- n.rule('ar',
- command='lib /nologo /ltcg /out:$out $in',
- description='LIB $out')
-elif host.is_mingw():
- n.rule('ar',
- command='$ar crs $out $in',
- description='AR $out')
-else:
- n.rule('ar',
- command='rm -f $out && $ar crs $out $in',
- description='AR $out')
-n.newline()
-
-if platform.is_msvc():
- n.rule('link',
- command='$cxx $in $libs /nologo /link $ldflags /out:$out',
- description='LINK $out')
-else:
- n.rule('link',
- command='$cxx $ldflags -o $out $in $libs',
- description='LINK $out')
-n.newline()
-
-objs = []
-
-if platform.supports_ninja_browse():
- n.comment('browse_py.h is used to inline browse.py.')
- n.rule('inline',
- command='"%s"' % src('inline.sh') + ' $varname < $in > $out',
- description='INLINE $out')
- n.build(built('browse_py.h'), 'inline', src('browse.py'),
- implicit=src('inline.sh'),
- variables=[('varname', 'kBrowsePy')])
- n.newline()
-
- objs += cxx('browse', order_only=built('browse_py.h'))
- n.newline()
-
-n.comment('the depfile parser and ninja lexers are generated using re2c.')
-def has_re2c():
- try:
- proc = subprocess.Popen(['re2c', '-V'], stdout=subprocess.PIPE)
- return int(proc.communicate()[0], 10) >= 1503
- except OSError:
- return False
-if has_re2c():
- n.rule('re2c',
- command='re2c -b -i --no-generation-date --no-version -o $out $in',
- description='RE2C $out')
- # Generate the .cc files in the source directory so we can check them in.
- n.build(src('depfile_parser.cc'), 're2c', src('depfile_parser.in.cc'))
- n.build(src('lexer.cc'), 're2c', src('lexer.in.cc'))
-else:
- print("warning: A compatible version of re2c (>= 0.15.3) was not found; "
- "changes to src/*.in.cc will not affect your build.")
-n.newline()
-
-cxxvariables = []
-if platform.is_msvc():
- cxxvariables = [('pdb', 'ninja.pdb')]
-
-n.comment('Generate a library for `ninja-re2c`.')
-re2c_objs = []
-for name in ['depfile_parser', 'lexer']:
- re2c_objs += cxx(name, variables=cxxvariables)
-if platform.is_msvc():
- n.build(built('ninja-re2c.lib'), 'ar', re2c_objs)
-else:
- n.build(built('libninja-re2c.a'), 'ar', re2c_objs)
-n.newline()
-
-n.comment('Core source files all build into ninja library.')
-objs.extend(re2c_objs)
-for name in ['async_loop',
- 'build',
- 'build_config',
- 'build_log',
- 'clean',
- 'clparser',
- 'debug_flags',
- 'deps_log',
- 'disk_interface',
- 'dyndep',
- 'dyndep_parser',
- 'edit_distance',
- 'eval_env',
- 'graph',
- 'graphviz',
- 'ipc_utils',
- 'json',
- 'line_printer',
- 'manifest_parser',
- 'metrics',
- 'missing_deps',
- 'parser',
- 'persistent_mode',
- 'persistent_service',
- 'process_utils',
- 'state',
- 'status',
- 'stdio_redirection',
- 'string_piece_util',
- 'util',
- 'version']:
- objs += cxx(name, variables=cxxvariables)
-if platform.is_windows():
- for name in ['includes_normalize-win32',
- 'interrupt_handling-win32',
- 'ipc_handle-win32',
- 'msvc_helper-win32',
- 'msvc_helper_main-win32',
- 'subprocess-win32']:
- objs += cxx(name, variables=cxxvariables)
- if platform.is_msvc():
- objs += cxx('minidump-win32', variables=cxxvariables)
- objs += cc('getopt')
-else:
- for name in ['interrupt_handling-posix',
- 'ipc_handle-posix',
- 'subprocess-posix']:
- objs += cxx(name, variables=cxxvariables)
-
-if platform.is_windows():
- objs += cxx('stat_cache-win32', variables=cxxvariables)
-else:
- objs += cxx('stat_cache-posix', variables=cxxvariables)
-
-if platform.is_aix():
- objs += cc('getopt')
-if platform.is_msvc():
- ninja_lib = n.build(built('ninja.lib'), 'ar', objs)
-else:
- ninja_lib = n.build(built('libninja.a'), 'ar', objs)
-n.newline()
-
-if platform.is_msvc():
- libs.append('ninja.lib')
-else:
- libs.append('-lninja')
-
-if platform.is_aix() and not platform.is_os400_pase():
- libs.append('-lperfstat')
-
-all_targets = []
-
-n.comment('Main executable is library plus main() function.')
-objs = cxx('ninja', variables=cxxvariables)
-ninja = n.build(binary('ninja'), 'link', objs, implicit=ninja_lib,
- variables=[('libs', libs)])
-n.newline()
-all_targets += ninja
-
-if options.bootstrap:
- # We've built the ninja binary. Don't run any more commands
- # through the bootstrap executor, but continue writing the
- # build.ninja file.
- n = ninja_writer
-
-n.comment('Tests all build into ninja_test executable.')
-
-objs = []
-if platform.is_msvc():
- cxxvariables = [('pdb', 'ninja_test.pdb')]
-
-for name in ['async_loop_test',
- 'build_log_test',
- 'build_test',
- 'clean_test',
- 'clparser_test',
- 'depfile_parser_test',
- 'deps_log_test',
- 'dyndep_parser_test',
- 'disk_interface_test',
- 'edit_distance_test',
- 'graph_test',
- 'interrupt_handling_test',
- 'ipc_handle_test',
- 'ipc_utils_test',
- 'json_test',
- 'lexer_test',
- 'manifest_parser_test',
- 'missing_deps_test',
- 'ninja_test',
- 'persistent_mode_test',
- 'persistent_service_test',
- 'process_utils_test',
- 'stat_cache_test',
- 'state_test',
- 'status_test',
- 'stdio_redirection_test',
- 'string_piece_util_test',
- 'subprocess_test',
- 'test',
- 'util_test']:
- objs += cxx(name, variables=cxxvariables)
-if platform.is_windows():
- for name in ['includes_normalize_test', 'msvc_helper_test']:
- objs += cxx(name, variables=cxxvariables)
-
-ninja_test = n.build(binary('ninja_test'), 'link', objs, implicit=ninja_lib,
- variables=[('libs', libs)])
-n.newline()
-all_targets += ninja_test
-
-
-n.comment('Ancillary executables.')
-
-if platform.is_aix() and '-maix64' not in ldflags:
- # Both hash_collision_bench and manifest_parser_perftest require more
- # memory than will fit in the standard 32-bit AIX shared stack/heap (256M)
- libs.append('-Wl,-bmaxdata:0x80000000')
-
-for name in ['build_log_perftest',
- 'canon_perftest',
- 'depfile_parser_perftest',
- 'hash_collision_bench',
- 'manifest_parser_perftest',
- 'persistent_mode_test_helper',
- 'persistent_service_test_helper',
- 'clparser_perftest']:
- if platform.is_msvc():
- cxxvariables = [('pdb', name + '.pdb')]
- objs = cxx(name, variables=cxxvariables)
- all_targets += n.build(binary(name), 'link', objs,
- implicit=ninja_lib, variables=[('libs', libs)])
-
-n.newline()
-
-n.comment('Generate a graph using the "graph" tool.')
-n.rule('gendot',
- command='./ninja -t graph all > $out')
-n.rule('gengraph',
- command='dot -Tpng $in > $out')
-dot = n.build(built('graph.dot'), 'gendot', ['ninja', 'build.ninja'])
-n.build('graph.png', 'gengraph', dot)
-n.newline()
-
-n.comment('Generate the manual using asciidoc.')
-n.rule('asciidoc',
- command='asciidoc -b docbook -d book -o $out $in',
- description='ASCIIDOC $out')
-n.rule('xsltproc',
- command='xsltproc --nonet doc/docbook.xsl $in > $out',
- description='XSLTPROC $out')
-docbookxml = n.build(built('manual.xml'), 'asciidoc', doc('manual.asciidoc'))
-manual = n.build(doc('manual.html'), 'xsltproc', docbookxml,
- implicit=[doc('style.css'), doc('docbook.xsl')])
-n.build('manual', 'phony',
- order_only=manual)
-n.newline()
-
-n.rule('dblatex',
- command='dblatex -q -o $out -p doc/dblatex.xsl $in',
- description='DBLATEX $out')
-n.build(doc('manual.pdf'), 'dblatex', docbookxml,
- implicit=[doc('dblatex.xsl')])
-
-n.comment('Generate Doxygen.')
-n.rule('doxygen',
- command='doxygen $in',
- description='DOXYGEN $in')
-n.variable('doxygen_mainpage_generator',
- src('gen_doxygen_mainpage.sh'))
-n.rule('doxygen_mainpage',
- command='$doxygen_mainpage_generator $in > $out',
- description='DOXYGEN_MAINPAGE $out')
-mainpage = n.build(built('doxygen_mainpage'), 'doxygen_mainpage',
- ['README.md', 'COPYING'],
- implicit=['$doxygen_mainpage_generator'])
-n.build('doxygen', 'doxygen', doc('doxygen.config'),
- implicit=mainpage)
-n.newline()
-
-if not host.is_mingw():
- n.comment('Regenerate build files if build script changes.')
- n.rule('configure',
- command='${configure_env}%s $root/configure.py $configure_args' %
- options.with_python,
- generator=True)
- n.build('build.ninja', 'configure',
- implicit=['$root/configure.py',
- os.path.normpath('$root/misc/ninja_syntax.py')])
- n.newline()
-
-n.default(ninja)
-n.newline()
-
-if host.is_linux():
- n.comment('Packaging')
- n.rule('rpmbuild',
- command="misc/packaging/rpmbuild.sh",
- description='Building rpms..')
- n.build('rpm', 'rpmbuild')
- n.newline()
-
-n.build('all', 'phony', all_targets)
-
-n.close()
-print('wrote %s.' % BUILD_FILENAME)
-
-if options.bootstrap:
- print('bootstrap complete. rebuilding...')
-
- rebuild_args = []
-
- if platform.can_rebuild_in_place():
- rebuild_args.append('./ninja')
- else:
- if platform.is_windows():
- bootstrap_exe = 'ninja.bootstrap.exe'
- final_exe = 'ninja.exe'
- else:
- bootstrap_exe = './ninja.bootstrap'
- final_exe = './ninja'
-
- if os.path.exists(bootstrap_exe):
- os.unlink(bootstrap_exe)
- os.rename(final_exe, bootstrap_exe)
-
- rebuild_args.append(bootstrap_exe)
-
- if options.verbose:
- rebuild_args.append('-v')
-
- subprocess.check_call(rebuild_args)
diff --git a/doc/README.md b/doc/README.md
deleted file mode 100644
index 6afe5d4..0000000
--- a/doc/README.md
+++ /dev/null
@@ -1,11 +0,0 @@
-This directory contains the Ninja manual and support files used in
-building it. Here's a brief overview of how it works.
-
-The source text, `manual.asciidoc`, is written in the AsciiDoc format.
-AsciiDoc can generate HTML but it doesn't look great; instead, we use
-AsciiDoc to generate the Docbook XML format and then provide our own
-Docbook XSL tweaks to produce HTML from that.
-
-In theory using AsciiDoc and DocBook allows us to produce nice PDF
-documentation etc. In reality it's not clear anyone wants that, but the
-build rules are in place to generate it if you install dblatex.
diff --git a/doc/dblatex.xsl b/doc/dblatex.xsl
deleted file mode 100644
index c0da212..0000000
--- a/doc/dblatex.xsl
+++ /dev/null
@@ -1,7 +0,0 @@
-<!-- This custom XSL tweaks the dblatex XML settings. -->
-<xsl:stylesheet xmlns:xsl='http://www.w3.org/1999/XSL/Transform' version='1.0'>
- <!-- These parameters disable the list of collaborators and revisions.
- Together remove a useless page from the front matter. -->
- <xsl:param name='doc.collab.show'>0</xsl:param>
- <xsl:param name='latex.output.revhistory'>0</xsl:param>
-</xsl:stylesheet>
diff --git a/doc/docbook.xsl b/doc/docbook.xsl
deleted file mode 100644
index 2235be2..0000000
--- a/doc/docbook.xsl
+++ /dev/null
@@ -1,34 +0,0 @@
-<!-- This custom XSL tweaks the DocBook XML -> HTML settings to produce
- an OK-looking manual. -->
-<!DOCTYPE xsl:stylesheet [
-<!ENTITY css SYSTEM "style.css">
-]>
-<xsl:stylesheet xmlns:xsl="http://www.w3.org/1999/XSL/Transform"
- version='1.0'>
- <xsl:import href="http://docbook.sourceforge.net/release/xsl/current/html/docbook.xsl"/>
-
- <!-- Embed our stylesheet as the user-provided <head> content. -->
- <xsl:template name="user.head.content"><style>&css;</style></xsl:template>
-
- <!-- Remove the body.attributes block, which specifies a bunch of
- useless bgcolor etc. attrs on the <body> tag. -->
- <xsl:template name="body.attributes"></xsl:template>
-
- <!-- Specify that in "book" form (which we're using), we only want a
- single table of contents at the beginning of the document. -->
- <xsl:param name="generate.toc">book toc</xsl:param>
-
- <!-- Don't put the "Chapter 1." prefix on the "chapters". -->
- <xsl:param name="chapter.autolabel">0</xsl:param>
-
- <!-- Make builds reproducible by generating the same IDs from the same inputs -->
- <xsl:param name="generate.consistent.ids">1</xsl:param>
-
- <!-- Use <ul> for the table of contents. By default DocBook uses a
- <dl>, which makes no semantic sense. I imagine they just did
- it because it looks nice? -->
- <xsl:param name="toc.list.type">ul</xsl:param>
-
- <xsl:output method="html" encoding="utf-8" indent="no"
- doctype-public=""/>
-</xsl:stylesheet>
diff --git a/doc/doxygen.config b/doc/doxygen.config
deleted file mode 100644
index d933021..0000000
--- a/doc/doxygen.config
+++ /dev/null
@@ -1,1250 +0,0 @@
-# Doxyfile 1.4.5
-
-# This file describes the settings to be used by the documentation system
-# doxygen (www.doxygen.org) for a project
-#
-# All text after a hash (#) is considered a comment and will be ignored
-# The format is:
-# TAG = value [value, ...]
-# For lists items can also be appended using:
-# TAG += value [value, ...]
-# Values that contain spaces should be placed between quotes (" ")
-
-#---------------------------------------------------------------------------
-# Project related configuration options
-#---------------------------------------------------------------------------
-
-# The PROJECT_NAME tag is a single word (or a sequence of words surrounded
-# by quotes) that should identify the project.
-
-PROJECT_NAME = "Ninja"
-
-# The PROJECT_NUMBER tag can be used to enter a project or revision number.
-# This could be handy for archiving the generated documentation or
-# if some version control system is used.
-
-# PROJECT_NUMBER = "0"
-
-# The OUTPUT_DIRECTORY tag is used to specify the (relative or absolute)
-# base path where the generated documentation will be put.
-# If a relative path is entered, it will be relative to the location
-# where doxygen was started. If left blank the current directory will be used.
-
-OUTPUT_DIRECTORY = "doc/doxygen/"
-
-# If the CREATE_SUBDIRS tag is set to YES, then doxygen will create
-# 4096 sub-directories (in 2 levels) under the output directory of each output
-# format and will distribute the generated files over these directories.
-# Enabling this option can be useful when feeding doxygen a huge amount of
-# source files, where putting all generated files in the same directory would
-# otherwise cause performance problems for the file system.
-
-CREATE_SUBDIRS = NO
-
-# The OUTPUT_LANGUAGE tag is used to specify the language in which all
-# documentation generated by doxygen is written. Doxygen will use this
-# information to generate all constant output in the proper language.
-# The default language is English, other supported languages are:
-# Brazilian, Catalan, Chinese, Chinese-Traditional, Croatian, Czech, Danish,
-# Dutch, Finnish, French, German, Greek, Hungarian, Italian, Japanese,
-# Japanese-en (Japanese with English messages), Korean, Korean-en, Norwegian,
-# Polish, Portuguese, Romanian, Russian, Serbian, Slovak, Slovene, Spanish,
-# Swedish, and Ukrainian.
-
-OUTPUT_LANGUAGE = English
-
-# This tag can be used to specify the encoding used in the generated output.
-# The encoding is not always determined by the language that is chosen,
-# but also whether or not the output is meant for Windows or non-Windows users.
-# In case there is a difference, setting the USE_WINDOWS_ENCODING tag to YES
-# forces the Windows encoding (this is the default for the Windows binary),
-# whereas setting the tag to NO uses a Unix-style encoding (the default for
-# all platforms other than Windows).
-
-# Obsolet option.
-#USE_WINDOWS_ENCODING = YES
-
-# If the BRIEF_MEMBER_DESC tag is set to YES (the default) Doxygen will
-# include brief member descriptions after the members that are listed in
-# the file and class documentation (similar to JavaDoc).
-# Set to NO to disable this.
-
-BRIEF_MEMBER_DESC = YES
-
-# If the REPEAT_BRIEF tag is set to YES (the default) Doxygen will prepend
-# the brief description of a member or function before the detailed description.
-# Note: if both HIDE_UNDOC_MEMBERS and BRIEF_MEMBER_DESC are set to NO, the
-# brief descriptions will be completely suppressed.
-
-REPEAT_BRIEF = YES
-
-# This tag implements a quasi-intelligent brief description abbreviator
-# that is used to form the text in various listings. Each string
-# in this list, if found as the leading text of the brief description, will be
-# stripped from the text and the result after processing the whole list, is
-# used as the annotated text. Otherwise, the brief description is used as-is.
-# If left blank, the following values are used ("$name" is automatically
-# replaced with the name of the entity): "The $name class" "The $name widget"
-# "The $name file" "is" "provides" "specifies" "contains"
-# "represents" "a" "an" "the"
-
-ABBREVIATE_BRIEF =
-
-# If the ALWAYS_DETAILED_SEC and REPEAT_BRIEF tags are both set to YES then
-# Doxygen will generate a detailed section even if there is only a brief
-# description.
-
-ALWAYS_DETAILED_SEC = NO
-
-# If the INLINE_INHERITED_MEMB tag is set to YES, doxygen will show all
-# inherited members of a class in the documentation of that class as if those
-# members were ordinary class members. Constructors, destructors and assignment
-# operators of the base classes will not be shown.
-
-INLINE_INHERITED_MEMB = YES
-
-# If the FULL_PATH_NAMES tag is set to YES then Doxygen will prepend the full
-# path before files name in the file list and in the header files. If set
-# to NO the shortest path that makes the file name unique will be used.
-
-FULL_PATH_NAMES = YES
-
-# If the FULL_PATH_NAMES tag is set to YES then the STRIP_FROM_PATH tag
-# can be used to strip a user-defined part of the path. Stripping is
-# only done if one of the specified strings matches the left-hand part of
-# the path. The tag can be used to show relative paths in the file list.
-# If left blank the directory from which doxygen is run is used as the
-# path to strip.
-
-STRIP_FROM_PATH = src
-
-# The STRIP_FROM_INC_PATH tag can be used to strip a user-defined part of
-# the path mentioned in the documentation of a class, which tells
-# the reader which header file to include in order to use a class.
-# If left blank only the name of the header file containing the class
-# definition is used. Otherwise one should specify the include paths that
-# are normally passed to the compiler using the -I flag.
-
-STRIP_FROM_INC_PATH = src/
-
-# If the SHORT_NAMES tag is set to YES, doxygen will generate much shorter
-# (but less readable) file names. This can be useful is your file systems
-# doesn't support long names like on DOS, Mac, or CD-ROM.
-
-SHORT_NAMES = NO
-
-# If the JAVADOC_AUTOBRIEF tag is set to YES then Doxygen
-# will interpret the first line (until the first dot) of a JavaDoc-style
-# comment as the brief description. If set to NO, the JavaDoc
-# comments will behave just like the Qt-style comments (thus requiring an
-# explicit @brief command for a brief description.
-
-JAVADOC_AUTOBRIEF = YES
-
-# The MULTILINE_CPP_IS_BRIEF tag can be set to YES to make Doxygen
-# treat a multi-line C++ special comment block (i.e. a block of //! or ///
-# comments) as a brief description. This used to be the default behaviour.
-# The new default is to treat a multi-line C++ comment block as a detailed
-# description. Set this tag to YES if you prefer the old behaviour instead.
-
-MULTILINE_CPP_IS_BRIEF = NO
-
-# If the DETAILS_AT_TOP tag is set to YES then Doxygen
-# will output the detailed description near the top, like JavaDoc.
-# If set to NO, the detailed description appears after the member
-# documentation.
-
-# Has become obsolete.
-#DETAILS_AT_TOP = NO
-
-# If the INHERIT_DOCS tag is set to YES (the default) then an undocumented
-# member inherits the documentation from any documented member that it
-# re-implements.
-
-INHERIT_DOCS = YES
-
-# If the SEPARATE_MEMBER_PAGES tag is set to YES, then doxygen will produce
-# a new page for each member. If set to NO, the documentation of a member will
-# be part of the file/class/namespace that contains it.
-
-SEPARATE_MEMBER_PAGES = NO
-
-# The TAB_SIZE tag can be used to set the number of spaces in a tab.
-# Doxygen uses this value to replace tabs by spaces in code fragments.
-
-TAB_SIZE = 2
-
-# This tag can be used to specify a number of aliases that acts
-# as commands in the documentation. An alias has the form "name=value".
-# For example adding "sideeffect=\par Side Effects:\n" will allow you to
-# put the command \sideeffect (or @sideeffect) in the documentation, which
-# will result in a user-defined paragraph with heading "Side Effects:".
-# You can put \n's in the value part of an alias to insert newlines.
-
-ALIASES =
-
-# Set the OPTIMIZE_OUTPUT_FOR_C tag to YES if your project consists of C
-# sources only. Doxygen will then generate output that is more tailored for C.
-# For instance, some of the names that are used will be different. The list
-# of all members will be omitted, etc.
-
-OPTIMIZE_OUTPUT_FOR_C = NO
-
-# Set the OPTIMIZE_OUTPUT_JAVA tag to YES if your project consists of Java
-# sources only. Doxygen will then generate output that is more tailored for Java.
-# For instance, namespaces will be presented as packages, qualified scopes
-# will look different, etc.
-
-OPTIMIZE_OUTPUT_JAVA = NO
-
-# If you use STL classes (i.e. std::string, std::vector, etc.) but do not want to
-# include (a tag file for) the STL sources as input, then you should
-# set this tag to YES in order to let doxygen match functions declarations and
-# definitions whose arguments contain STL classes (e.g. func(std::string); v.s.
-# func(std::string) {}). This also make the inheritance and collaboration
-# diagrams that involve STL classes more complete and accurate.
-
-# BUILTIN_STL_SUPPORT = NO
-
-# If member grouping is used in the documentation and the DISTRIBUTE_GROUP_DOC
-# tag is set to YES, then doxygen will reuse the documentation of the first
-# member in the group (if any) for the other members of the group. By default
-# all members of a group must be documented explicitly.
-
-DISTRIBUTE_GROUP_DOC = NO
-
-# Set the SUBGROUPING tag to YES (the default) to allow class member groups of
-# the same type (for instance a group of public functions) to be put as a
-# subgroup of that type (e.g. under the Public Functions section). Set it to
-# NO to prevent subgrouping. Alternatively, this can be done per class using
-# the \nosubgrouping command.
-
-SUBGROUPING = YES
-
-#---------------------------------------------------------------------------
-# Build related configuration options
-#---------------------------------------------------------------------------
-
-# If the EXTRACT_ALL tag is set to YES doxygen will assume all entities in
-# documentation are documented, even if no documentation was available.
-# Private class members and static file members will be hidden unless
-# the EXTRACT_PRIVATE and EXTRACT_STATIC tags are set to YES
-
-EXTRACT_ALL = YES
-
-# If the EXTRACT_PRIVATE tag is set to YES all private members of a class
-# will be included in the documentation.
-
-EXTRACT_PRIVATE = YES
-
-# If the EXTRACT_STATIC tag is set to YES all static members of a file
-# will be included in the documentation.
-
-EXTRACT_STATIC = YES
-
-# If the EXTRACT_LOCAL_CLASSES tag is set to YES classes (and structs)
-# defined locally in source files will be included in the documentation.
-# If set to NO only classes defined in header files are included.
-
-EXTRACT_LOCAL_CLASSES = YES
-
-# This flag is only useful for Objective-C code. When set to YES local
-# methods, which are defined in the implementation section but not in
-# the interface are included in the documentation.
-# If set to NO (the default) only methods in the interface are included.
-
-EXTRACT_LOCAL_METHODS = NO
-
-# If the HIDE_UNDOC_MEMBERS tag is set to YES, Doxygen will hide all
-# undocumented members of documented classes, files or namespaces.
-# If set to NO (the default) these members will be included in the
-# various overviews, but no documentation section is generated.
-# This option has no effect if EXTRACT_ALL is enabled.
-
-HIDE_UNDOC_MEMBERS = NO
-
-# If the HIDE_UNDOC_CLASSES tag is set to YES, Doxygen will hide all
-# undocumented classes that are normally visible in the class hierarchy.
-# If set to NO (the default) these classes will be included in the various
-# overviews. This option has no effect if EXTRACT_ALL is enabled.
-
-HIDE_UNDOC_CLASSES = NO
-
-# If the HIDE_FRIEND_COMPOUNDS tag is set to YES, Doxygen will hide all
-# friend (class|struct|union) declarations.
-# If set to NO (the default) these declarations will be included in the
-# documentation.
-
-HIDE_FRIEND_COMPOUNDS = NO
-
-# If the HIDE_IN_BODY_DOCS tag is set to YES, Doxygen will hide any
-# documentation blocks found inside the body of a function.
-# If set to NO (the default) these blocks will be appended to the
-# function's detailed documentation block.
-
-HIDE_IN_BODY_DOCS = NO
-
-# The INTERNAL_DOCS tag determines if documentation
-# that is typed after a \internal command is included. If the tag is set
-# to NO (the default) then the documentation will be excluded.
-# Set it to YES to include the internal documentation.
-
-INTERNAL_DOCS = NO
-
-# If the CASE_SENSE_NAMES tag is set to NO then Doxygen will only generate
-# file names in lower-case letters. If set to YES upper-case letters are also
-# allowed. This is useful if you have classes or files whose names only differ
-# in case and if your file system supports case sensitive file names. Windows
-# and Mac users are advised to set this option to NO.
-
-CASE_SENSE_NAMES = YES
-
-# If the HIDE_SCOPE_NAMES tag is set to NO (the default) then Doxygen
-# will show members with their full class and namespace scopes in the
-# documentation. If set to YES the scope will be hidden.
-
-HIDE_SCOPE_NAMES = NO
-
-# If the SHOW_INCLUDE_FILES tag is set to YES (the default) then Doxygen
-# will put a list of the files that are included by a file in the documentation
-# of that file.
-
-SHOW_INCLUDE_FILES = YES
-
-# If the INLINE_INFO tag is set to YES (the default) then a tag [inline]
-# is inserted in the documentation for inline members.
-
-INLINE_INFO = YES
-
-# If the SORT_MEMBER_DOCS tag is set to YES (the default) then doxygen
-# will sort the (detailed) documentation of file and class members
-# alphabetically by member name. If set to NO the members will appear in
-# declaration order.
-
-SORT_MEMBER_DOCS = YES
-
-# If the SORT_BRIEF_DOCS tag is set to YES then doxygen will sort the
-# brief documentation of file, namespace and class members alphabetically
-# by member name. If set to NO (the default) the members will appear in
-# declaration order.
-
-SORT_BRIEF_DOCS = YES
-
-# If the SORT_BY_SCOPE_NAME tag is set to YES, the class list will be
-# sorted by fully-qualified names, including namespaces. If set to
-# NO (the default), the class list will be sorted only by class name,
-# not including the namespace part.
-# Note: This option is not very useful if HIDE_SCOPE_NAMES is set to YES.
-# Note: This option applies only to the class list, not to the
-# alphabetical list.
-
-SORT_BY_SCOPE_NAME = NO
-
-# The GENERATE_TODOLIST tag can be used to enable (YES) or
-# disable (NO) the todo list. This list is created by putting \todo
-# commands in the documentation.
-
-GENERATE_TODOLIST = YES
-
-# The GENERATE_TESTLIST tag can be used to enable (YES) or
-# disable (NO) the test list. This list is created by putting \test
-# commands in the documentation.
-
-GENERATE_TESTLIST = YES
-
-# The GENERATE_BUGLIST tag can be used to enable (YES) or
-# disable (NO) the bug list. This list is created by putting \bug
-# commands in the documentation.
-
-GENERATE_BUGLIST = YES
-
-# The GENERATE_DEPRECATEDLIST tag can be used to enable (YES) or
-# disable (NO) the deprecated list. This list is created by putting
-# \deprecated commands in the documentation.
-
-GENERATE_DEPRECATEDLIST= YES
-
-# The ENABLED_SECTIONS tag can be used to enable conditional
-# documentation sections, marked by \if sectionname ... \endif.
-
-ENABLED_SECTIONS =
-
-# The MAX_INITIALIZER_LINES tag determines the maximum number of lines
-# the initial value of a variable or define consists of for it to appear in
-# the documentation. If the initializer consists of more lines than specified
-# here it will be hidden. Use a value of 0 to hide initializers completely.
-# The appearance of the initializer of individual variables and defines in the
-# documentation can be controlled using \showinitializer or \hideinitializer
-# command in the documentation regardless of this setting.
-
-MAX_INITIALIZER_LINES = 30
-
-# Set the SHOW_USED_FILES tag to NO to disable the list of files generated
-# at the bottom of the documentation of classes and structs. If set to YES the
-# list will mention the files that were used to generate the documentation.
-
-SHOW_USED_FILES = YES
-
-# If the sources in your project are distributed over multiple directories
-# then setting the SHOW_DIRECTORIES tag to YES will show the directory hierarchy
-# in the documentation. The default is YES.
-
-SHOW_DIRECTORIES = YES
-
-# The FILE_VERSION_FILTER tag can be used to specify a program or script that
-# doxygen should invoke to get the current version for each file (typically from the
-# version control system). Doxygen will invoke the program by executing (via
-# popen()) the command <command> <input-file>, where <command> is the value of
-# the FILE_VERSION_FILTER tag, and <input-file> is the name of an input file
-# provided by doxygen. Whatever the program writes to standard output
-# is used as the file version. See the manual for examples.
-
-FILE_VERSION_FILTER =
-
-#---------------------------------------------------------------------------
-# configuration options related to warning and progress messages
-#---------------------------------------------------------------------------
-
-# The QUIET tag can be used to turn on/off the messages that are generated
-# by doxygen. Possible values are YES and NO. If left blank NO is used.
-
-QUIET = NO
-
-# The WARNINGS tag can be used to turn on/off the warning messages that are
-# generated by doxygen. Possible values are YES and NO. If left blank
-# NO is used.
-
-WARNINGS = YES
-
-# If WARN_IF_UNDOCUMENTED is set to YES, then doxygen will generate warnings
-# for undocumented members. If EXTRACT_ALL is set to YES then this flag will
-# automatically be disabled.
-
-WARN_IF_UNDOCUMENTED = YES
-
-# If WARN_IF_DOC_ERROR is set to YES, doxygen will generate warnings for
-# potential errors in the documentation, such as not documenting some
-# parameters in a documented function, or documenting parameters that
-# don't exist or using markup commands wrongly.
-
-WARN_IF_DOC_ERROR = YES
-
-# This WARN_NO_PARAMDOC option can be abled to get warnings for
-# functions that are documented, but have no documentation for their parameters
-# or return value. If set to NO (the default) doxygen will only warn about
-# wrong or incomplete parameter documentation, but not about the absence of
-# documentation.
-
-WARN_NO_PARAMDOC = NO
-
-# The WARN_FORMAT tag determines the format of the warning messages that
-# doxygen can produce. The string should contain the $file, $line, and $text
-# tags, which will be replaced by the file and line number from which the
-# warning originated and the warning text. Optionally the format may contain
-# $version, which will be replaced by the version of the file (if it could
-# be obtained via FILE_VERSION_FILTER)
-
-WARN_FORMAT = "$file:$line: $text "
-
-# The WARN_LOGFILE tag can be used to specify a file to which warning
-# and error messages should be written. If left blank the output is written
-# to stderr.
-
-WARN_LOGFILE =
-
-#---------------------------------------------------------------------------
-# configuration options related to the input files
-#---------------------------------------------------------------------------
-
-# The INPUT tag can be used to specify the files and/or directories that contain
-# documented source files. You may enter file names like "myfile.cpp" or
-# directories like "/usr/src/myproject". Separate the files or directories
-# with spaces.
-
-INPUT = src \
- build/doxygen_mainpage
-
-# If the value of the INPUT tag contains directories, you can use the
-# FILE_PATTERNS tag to specify one or more wildcard pattern (like *.cpp
-# and *.h) to filter out the source-files in the directories. If left
-# blank the following patterns are tested:
-# *.c *.cc *.cxx *.cpp *.c++ *.java *.ii *.ixx *.ipp *.i++ *.inl *.h *.hh *.hxx
-# *.hpp *.h++ *.idl *.odl *.cs *.php *.php3 *.inc *.m *.mm *.py
-
-FILE_PATTERNS = *.cc \
- *.h
-
-# The RECURSIVE tag can be used to turn specify whether or not subdirectories
-# should be searched for input files as well. Possible values are YES and NO.
-# If left blank NO is used.
-
-RECURSIVE = YES
-
-# The EXCLUDE tag can be used to specify files and/or directories that should
-# excluded from the INPUT source files. This way you can easily exclude a
-# subdirectory from a directory tree whose root is specified with the INPUT tag.
-
-EXCLUDE =
-
-# The EXCLUDE_SYMLINKS tag can be used select whether or not files or
-# directories that are symbolic links (a Unix filesystem feature) are excluded
-# from the input.
-
-EXCLUDE_SYMLINKS = NO
-
-# If the value of the INPUT tag contains directories, you can use the
-# EXCLUDE_PATTERNS tag to specify one or more wildcard patterns to exclude
-# certain files from those directories. Note that the wildcards are matched
-# against the file with absolute path, so to exclude all test directories
-# for example use the pattern */test/*
-
-EXCLUDE_PATTERNS =
-
-# The EXAMPLE_PATH tag can be used to specify one or more files or
-# directories that contain example code fragments that are included (see
-# the \include command).
-
-EXAMPLE_PATH = src
-
-# If the value of the EXAMPLE_PATH tag contains directories, you can use the
-# EXAMPLE_PATTERNS tag to specify one or more wildcard pattern (like *.cpp
-# and *.h) to filter out the source-files in the directories. If left
-# blank all files are included.
-
-EXAMPLE_PATTERNS = *.cpp \
- *.cc \
- *.h \
- *.hh \
- INSTALL DEPENDENCIES CHANGELOG LICENSE LGPL
-
-# If the EXAMPLE_RECURSIVE tag is set to YES then subdirectories will be
-# searched for input files to be used with the \include or \dontinclude
-# commands irrespective of the value of the RECURSIVE tag.
-# Possible values are YES and NO. If left blank NO is used.
-
-EXAMPLE_RECURSIVE = YES
-
-# The IMAGE_PATH tag can be used to specify one or more files or
-# directories that contain image that are included in the documentation (see
-# the \image command).
-
-IMAGE_PATH = src
-
-# The INPUT_FILTER tag can be used to specify a program that doxygen should
-# invoke to filter for each input file. Doxygen will invoke the filter program
-# by executing (via popen()) the command <filter> <input-file>, where <filter>
-# is the value of the INPUT_FILTER tag, and <input-file> is the name of an
-# input file. Doxygen will then use the output that the filter program writes
-# to standard output. If FILTER_PATTERNS is specified, this tag will be
-# ignored.
-
-INPUT_FILTER =
-
-# The FILTER_PATTERNS tag can be used to specify filters on a per file pattern
-# basis. Doxygen will compare the file name with each pattern and apply the
-# filter if there is a match. The filters are a list of the form:
-# pattern=filter (like *.cpp=my_cpp_filter). See INPUT_FILTER for further
-# info on how filters are used. If FILTER_PATTERNS is empty, INPUT_FILTER
-# is applied to all files.
-
-FILTER_PATTERNS =
-
-# If the FILTER_SOURCE_FILES tag is set to YES, the input filter (if set using
-# INPUT_FILTER) will be used to filter the input files when producing source
-# files to browse (i.e. when SOURCE_BROWSER is set to YES).
-
-FILTER_SOURCE_FILES = NO
-
-#---------------------------------------------------------------------------
-# configuration options related to source browsing
-#---------------------------------------------------------------------------
-
-# If the SOURCE_BROWSER tag is set to YES then a list of source files will
-# be generated. Documented entities will be cross-referenced with these sources.
-# Note: To get rid of all source code in the generated output, make sure also
-# VERBATIM_HEADERS is set to NO.
-
-SOURCE_BROWSER = YES
-
-# Setting the INLINE_SOURCES tag to YES will include the body
-# of functions and classes directly in the documentation.
-
-INLINE_SOURCES = NO
-
-# Setting the STRIP_CODE_COMMENTS tag to YES (the default) will instruct
-# doxygen to hide any special comment blocks from generated source code
-# fragments. Normal C and C++ comments will always remain visible.
-
-STRIP_CODE_COMMENTS = NO
-
-# If the REFERENCED_BY_RELATION tag is set to YES (the default)
-# then for each documented function all documented
-# functions referencing it will be listed.
-
-REFERENCED_BY_RELATION = YES
-
-# If the REFERENCES_RELATION tag is set to YES (the default)
-# then for each documented function all documented entities
-# called/used by that function will be listed.
-
-REFERENCES_RELATION = YES
-
-# If the USE_HTAGS tag is set to YES then the references to source code
-# will point to the HTML generated by the htags(1) tool instead of doxygen
-# built-in source browser. The htags tool is part of GNU's global source
-# tagging system (see http://www.gnu.org/software/global/global.html). You
-# will need version 4.8.6 or higher.
-
-USE_HTAGS = NO
-
-# If the VERBATIM_HEADERS tag is set to YES (the default) then Doxygen
-# will generate a verbatim copy of the header file for each class for
-# which an include is specified. Set to NO to disable this.
-
-VERBATIM_HEADERS = YES
-
-#---------------------------------------------------------------------------
-# configuration options related to the alphabetical class index
-#---------------------------------------------------------------------------
-
-# If the ALPHABETICAL_INDEX tag is set to YES, an alphabetical index
-# of all compounds will be generated. Enable this if the project
-# contains a lot of classes, structs, unions or interfaces.
-
-ALPHABETICAL_INDEX = YES
-
-# If the alphabetical index is enabled (see ALPHABETICAL_INDEX) then
-# the COLS_IN_ALPHA_INDEX tag can be used to specify the number of columns
-# in which this list will be split (can be a number in the range [1..20])
-
-COLS_IN_ALPHA_INDEX = 2
-
-# In case all classes in a project start with a common prefix, all
-# classes will be put under the same header in the alphabetical index.
-# The IGNORE_PREFIX tag can be used to specify one or more prefixes that
-# should be ignored while generating the index headers.
-
-IGNORE_PREFIX =
-
-#---------------------------------------------------------------------------
-# configuration options related to the HTML output
-#---------------------------------------------------------------------------
-
-# If the GENERATE_HTML tag is set to YES (the default) Doxygen will
-# generate HTML output.
-
-GENERATE_HTML = YES
-
-# The HTML_OUTPUT tag is used to specify where the HTML docs will be put.
-# If a relative path is entered the value of OUTPUT_DIRECTORY will be
-# put in front of it. If left blank `html' will be used as the default path.
-
-HTML_OUTPUT = html
-
-# The HTML_FILE_EXTENSION tag can be used to specify the file extension for
-# each generated HTML page (for example: .htm,.php,.asp). If it is left blank
-# doxygen will generate files with .html extension.
-
-HTML_FILE_EXTENSION = .html
-
-# The HTML_HEADER tag can be used to specify a personal HTML header for
-# each generated HTML page. If it is left blank doxygen will generate a
-# standard header.
-HTML_HEADER =
-
-
-# The HTML_FOOTER tag can be used to specify a personal HTML footer for
-# each generated HTML page. If it is left blank doxygen will generate a
-# standard footer.
-
-HTML_FOOTER =
-
-# The HTML_STYLESHEET tag can be used to specify a user-defined cascading
-# style sheet that is used by each HTML page. It can be used to
-# fine-tune the look of the HTML output. If the tag is left blank doxygen
-# will generate a default style sheet. Note that doxygen will try to copy
-# the style sheet file to the HTML output directory, so don't put your own
-# stylesheet in the HTML output directory as well, or it will be erased!
-
-HTML_STYLESHEET =
-
-# If the HTML_ALIGN_MEMBERS tag is set to YES, the members of classes,
-# files or namespaces will be aligned in HTML using tables. If set to
-# NO a bullet list will be used.
-
-HTML_ALIGN_MEMBERS = YES
-
-# If the GENERATE_HTMLHELP tag is set to YES, additional index files
-# will be generated that can be used as input for tools like the
-# Microsoft HTML help workshop to generate a compressed HTML help file (.chm)
-# of the generated HTML documentation.
-
-GENERATE_HTMLHELP = YES
-
-# If the GENERATE_HTMLHELP tag is set to YES, the CHM_FILE tag can
-# be used to specify the file name of the resulting .chm file. You
-# can add a path in front of the file if the result should not be
-# written to the html output directory.
-
-CHM_FILE =
-
-# If the GENERATE_HTMLHELP tag is set to YES, the HHC_LOCATION tag can
-# be used to specify the location (absolute path including file name) of
-# the HTML help compiler (hhc.exe). If non-empty doxygen will try to run
-# the HTML help compiler on the generated index.hhp.
-
-HHC_LOCATION =
-
-# If the GENERATE_HTMLHELP tag is set to YES, the GENERATE_CHI flag
-# controls if a separate .chi index file is generated (YES) or that
-# it should be included in the master .chm file (NO).
-
-GENERATE_CHI = NO
-
-# If the GENERATE_HTMLHELP tag is set to YES, the BINARY_TOC flag
-# controls whether a binary table of contents is generated (YES) or a
-# normal table of contents (NO) in the .chm file.
-
-BINARY_TOC = NO
-
-# The TOC_EXPAND flag can be set to YES to add extra items for group members
-# to the contents of the HTML help documentation and to the tree view.
-
-TOC_EXPAND = NO
-
-# The DISABLE_INDEX tag can be used to turn on/off the condensed index at
-# top of each HTML page. The value NO (the default) enables the index and
-# the value YES disables it.
-
-DISABLE_INDEX = NO
-
-# This tag can be used to set the number of enum values (range [1..20])
-# that doxygen will group on one line in the generated HTML documentation.
-
-ENUM_VALUES_PER_LINE = 4
-
-# If the GENERATE_TREEVIEW tag is set to YES, a side panel will be
-# generated containing a tree-like index structure (just like the one that
-# is generated for HTML Help). For this to work a browser that supports
-# JavaScript, DHTML, CSS and frames is required (for instance Mozilla 1.0+,
-# Netscape 6.0+, Internet explorer 5.0+, or Konqueror). Windows users are
-# probably better off using the HTML help feature.
-
-GENERATE_TREEVIEW = YES
-
-# If the treeview is enabled (see GENERATE_TREEVIEW) then this tag can be
-# used to set the initial width (in pixels) of the frame in which the tree
-# is shown.
-
-TREEVIEW_WIDTH = 250
-
-#---------------------------------------------------------------------------
-# configuration options related to the LaTeX output
-#---------------------------------------------------------------------------
-
-# If the GENERATE_LATEX tag is set to YES (the default) Doxygen will
-# generate Latex output.
-
-GENERATE_LATEX = NO
-
-# The LATEX_OUTPUT tag is used to specify where the LaTeX docs will be put.
-# If a relative path is entered the value of OUTPUT_DIRECTORY will be
-# put in front of it. If left blank `latex' will be used as the default path.
-
-LATEX_OUTPUT = latex
-
-# The LATEX_CMD_NAME tag can be used to specify the LaTeX command name to be
-# invoked. If left blank `latex' will be used as the default command name.
-
-LATEX_CMD_NAME =
-
-# The MAKEINDEX_CMD_NAME tag can be used to specify the command name to
-# generate index for LaTeX. If left blank `makeindex' will be used as the
-# default command name.
-
-MAKEINDEX_CMD_NAME =
-
-# If the COMPACT_LATEX tag is set to YES Doxygen generates more compact
-# LaTeX documents. This may be useful for small projects and may help to
-# save some trees in general.
-
-COMPACT_LATEX = NO
-
-# The PAPER_TYPE tag can be used to set the paper type that is used
-# by the printer. Possible values are: a4, a4wide, letter, legal and
-# executive. If left blank a4wide will be used.
-
-PAPER_TYPE = a4
-
-# The EXTRA_PACKAGES tag can be to specify one or more names of LaTeX
-# packages that should be included in the LaTeX output.
-
-EXTRA_PACKAGES =
-
-# The LATEX_HEADER tag can be used to specify a personal LaTeX header for
-# the generated latex document. The header should contain everything until
-# the first chapter. If it is left blank doxygen will generate a
-# standard header. Notice: only use this tag if you know what you are doing!
-
-LATEX_HEADER =
-
-# If the PDF_HYPERLINKS tag is set to YES, the LaTeX that is generated
-# is prepared for conversion to pdf (using ps2pdf). The pdf file will
-# contain links (just like the HTML output) instead of page references
-# This makes the output suitable for online browsing using a pdf viewer.
-
-PDF_HYPERLINKS = YES
-
-# If the USE_PDFLATEX tag is set to YES, pdflatex will be used instead of
-# plain latex in the generated Makefile. Set this option to YES to get a
-# higher quality PDF documentation.
-
-USE_PDFLATEX = YES
-
-# If the LATEX_BATCHMODE tag is set to YES, doxygen will add the \\batchmode.
-# command to the generated LaTeX files. This will instruct LaTeX to keep
-# running if errors occur, instead of asking the user for help.
-# This option is also used when generating formulas in HTML.
-
-LATEX_BATCHMODE = YES
-
-# If LATEX_HIDE_INDICES is set to YES then doxygen will not
-# include the index chapters (such as File Index, Compound Index, etc.)
-# in the output.
-
-LATEX_HIDE_INDICES = NO
-
-#---------------------------------------------------------------------------
-# configuration options related to the RTF output
-#---------------------------------------------------------------------------
-
-# If the GENERATE_RTF tag is set to YES Doxygen will generate RTF output
-# The RTF output is optimized for Word 97 and may not look very pretty with
-# other RTF readers or editors.
-
-GENERATE_RTF = NO
-
-# The RTF_OUTPUT tag is used to specify where the RTF docs will be put.
-# If a relative path is entered the value of OUTPUT_DIRECTORY will be
-# put in front of it. If left blank `rtf' will be used as the default path.
-
-RTF_OUTPUT = rtf
-
-# If the COMPACT_RTF tag is set to YES Doxygen generates more compact
-# RTF documents. This may be useful for small projects and may help to
-# save some trees in general.
-
-COMPACT_RTF = NO
-
-# If the RTF_HYPERLINKS tag is set to YES, the RTF that is generated
-# will contain hyperlink fields. The RTF file will
-# contain links (just like the HTML output) instead of page references.
-# This makes the output suitable for online browsing using WORD or other
-# programs which support those fields.
-# Note: wordpad (write) and others do not support links.
-
-RTF_HYPERLINKS = NO
-
-# Load stylesheet definitions from file. Syntax is similar to doxygen's
-# config file, i.e. a series of assignments. You only have to provide
-# replacements, missing definitions are set to their default value.
-
-RTF_STYLESHEET_FILE =
-
-# Set optional variables used in the generation of an rtf document.
-# Syntax is similar to doxygen's config file.
-
-RTF_EXTENSIONS_FILE =
-
-#---------------------------------------------------------------------------
-# configuration options related to the man page output
-#---------------------------------------------------------------------------
-
-# If the GENERATE_MAN tag is set to YES (the default) Doxygen will
-# generate man pages
-
-GENERATE_MAN = NO
-
-# The MAN_OUTPUT tag is used to specify where the man pages will be put.
-# If a relative path is entered the value of OUTPUT_DIRECTORY will be
-# put in front of it. If left blank `man' will be used as the default path.
-
-MAN_OUTPUT = man
-
-# The MAN_EXTENSION tag determines the extension that is added to
-# the generated man pages (default is the subroutine's section .3)
-
-MAN_EXTENSION = .3
-
-# If the MAN_LINKS tag is set to YES and Doxygen generates man output,
-# then it will generate one additional man file for each entity
-# documented in the real man page(s). These additional files
-# only source the real man page, but without them the man command
-# would be unable to find the correct page. The default is NO.
-
-MAN_LINKS = NO
-
-#---------------------------------------------------------------------------
-# configuration options related to the XML output
-#---------------------------------------------------------------------------
-
-# If the GENERATE_XML tag is set to YES Doxygen will
-# generate an XML file that captures the structure of
-# the code including all documentation.
-
-GENERATE_XML = NO
-
-# The XML_OUTPUT tag is used to specify where the XML pages will be put.
-# If a relative path is entered the value of OUTPUT_DIRECTORY will be
-# put in front of it. If left blank `xml' will be used as the default path.
-
-XML_OUTPUT = xml
-
-# The XML_SCHEMA tag can be used to specify an XML schema,
-# which can be used by a validating XML parser to check the
-# syntax of the XML files.
-
-XML_SCHEMA =
-
-# The XML_DTD tag can be used to specify an XML DTD,
-# which can be used by a validating XML parser to check the
-# syntax of the XML files.
-
-XML_DTD =
-
-# If the XML_PROGRAMLISTING tag is set to YES Doxygen will
-# dump the program listings (including syntax highlighting
-# and cross-referencing information) to the XML output. Note that
-# enabling this will significantly increase the size of the XML output.
-
-XML_PROGRAMLISTING = YES
-
-#---------------------------------------------------------------------------
-# configuration options for the AutoGen Definitions output
-#---------------------------------------------------------------------------
-
-# If the GENERATE_AUTOGEN_DEF tag is set to YES Doxygen will
-# generate an AutoGen Definitions (see autogen.sf.net) file
-# that captures the structure of the code including all
-# documentation. Note that this feature is still experimental
-# and incomplete at the moment.
-
-GENERATE_AUTOGEN_DEF = NO
-
-#---------------------------------------------------------------------------
-# configuration options related to the Perl module output
-#---------------------------------------------------------------------------
-
-# If the GENERATE_PERLMOD tag is set to YES Doxygen will
-# generate a Perl module file that captures the structure of
-# the code including all documentation. Note that this
-# feature is still experimental and incomplete at the
-# moment.
-
-GENERATE_PERLMOD = NO
-
-# If the PERLMOD_LATEX tag is set to YES Doxygen will generate
-# the necessary Makefile rules, Perl scripts and LaTeX code to be able
-# to generate PDF and DVI output from the Perl module output.
-
-PERLMOD_LATEX = NO
-
-# If the PERLMOD_PRETTY tag is set to YES the Perl module output will be
-# nicely formatted so it can be parsed by a human reader. This is useful
-# if you want to understand what is going on. On the other hand, if this
-# tag is set to NO the size of the Perl module output will be much smaller
-# and Perl will parse it just the same.
-
-PERLMOD_PRETTY = YES
-
-# The names of the make variables in the generated doxyrules.make file
-# are prefixed with the string contained in PERLMOD_MAKEVAR_PREFIX.
-# This is useful so different doxyrules.make files included by the same
-# Makefile don't overwrite each other's variables.
-
-PERLMOD_MAKEVAR_PREFIX =
-
-#---------------------------------------------------------------------------
-# Configuration options related to the preprocessor
-#---------------------------------------------------------------------------
-
-# If the ENABLE_PREPROCESSING tag is set to YES (the default) Doxygen will
-# evaluate all C-preprocessor directives found in the sources and include
-# files.
-
-ENABLE_PREPROCESSING = YES
-
-# If the MACRO_EXPANSION tag is set to YES Doxygen will expand all macro
-# names in the source code. If set to NO (the default) only conditional
-# compilation will be performed. Macro expansion can be done in a controlled
-# way by setting EXPAND_ONLY_PREDEF to YES.
-
-MACRO_EXPANSION = YES
-
-# If the EXPAND_ONLY_PREDEF and MACRO_EXPANSION tags are both set to YES
-# then the macro expansion is limited to the macros specified with the
-# PREDEFINED and EXPAND_AS_DEFINED tags.
-
-EXPAND_ONLY_PREDEF = YES
-
-# If the SEARCH_INCLUDES tag is set to YES (the default) the includes files
-# in the INCLUDE_PATH (see below) will be search if a #include is found.
-
-SEARCH_INCLUDES = YES
-
-# The INCLUDE_PATH tag can be used to specify one or more directories that
-# contain include files that are not input files but should be processed by
-# the preprocessor.
-
-INCLUDE_PATH =
-
-# You can use the INCLUDE_FILE_PATTERNS tag to specify one or more wildcard
-# patterns (like *.h and *.hpp) to filter out the header-files in the
-# directories. If left blank, the patterns specified with FILE_PATTERNS will
-# be used.
-
-INCLUDE_FILE_PATTERNS =
-
-# The PREDEFINED tag can be used to specify one or more macro names that
-# are defined before the preprocessor is started (similar to the -D option of
-# gcc). The argument of the tag is a list of macros of the form: name
-# or name=definition (no spaces). If the definition and the = are
-# omitted =1 is assumed. To prevent a macro definition from being
-# undefined via #undef or recursively expanded use the := operator
-# instead of the = operator.
-
-PREDEFINED =
-
-# If the MACRO_EXPANSION and EXPAND_ONLY_PREDEF tags are set to YES then
-# this tag can be used to specify a list of macro names that should be expanded.
-# The macro definition that is found in the sources will be used.
-# Use the PREDEFINED tag if you want to use a different macro definition.
-
-EXPAND_AS_DEFINED =
-
-# If the SKIP_FUNCTION_MACROS tag is set to YES (the default) then
-# doxygen's preprocessor will remove all function-like macros that are alone
-# on a line, have an all uppercase name, and do not end with a semicolon. Such
-# function macros are typically used for boiler-plate code, and will confuse
-# the parser if not removed.
-
-SKIP_FUNCTION_MACROS = YES
-
-#---------------------------------------------------------------------------
-# Configuration::additions related to external references
-#---------------------------------------------------------------------------
-
-# The TAGFILES option can be used to specify one or more tagfiles.
-# Optionally an initial location of the external documentation
-# can be added for each tagfile. The format of a tag file without
-# this location is as follows:
-# TAGFILES = file1 file2 ...
-# Adding location for the tag files is done as follows:
-# TAGFILES = file1=loc1 "file2 = loc2" ...
-# where "loc1" and "loc2" can be relative or absolute paths or
-# URLs. If a location is present for each tag, the installdox tool
-# does not have to be run to correct the links.
-# Note that each tag file must have a unique name
-# (where the name does NOT include the path)
-# If a tag file is not located in the directory in which doxygen
-# is run, you must also specify the path to the tagfile here.
-
-TAGFILES =
-
-# When a file name is specified after GENERATE_TAGFILE, doxygen will create
-# a tag file that is based on the input files it reads.
-
-GENERATE_TAGFILE = doc/doxygen/html/Ninja.TAGFILE
-
-# If the ALLEXTERNALS tag is set to YES all external classes will be listed
-# in the class index. If set to NO only the inherited external classes
-# will be listed.
-
-ALLEXTERNALS = YES
-
-# If the EXTERNAL_GROUPS tag is set to YES all external groups will be listed
-# in the modules index. If set to NO, only the current project's groups will
-# be listed.
-
-EXTERNAL_GROUPS = YES
-
-# The PERL_PATH should be the absolute path and name of the perl script
-# interpreter (i.e. the result of `which perl').
-
-PERL_PATH = /usr/bin/perl
-
-#---------------------------------------------------------------------------
-# Configuration options related to the dot tool
-#---------------------------------------------------------------------------
-
-# If the CLASS_DIAGRAMS tag is set to YES (the default) Doxygen will
-# generate a inheritance diagram (in HTML, RTF and LaTeX) for classes with base
-# or super classes. Setting the tag to NO turns the diagrams off. Note that
-# this option is superseded by the HAVE_DOT option below. This is only a
-# fallback. It is recommended to install and use dot, since it yields more
-# powerful graphs.
-
-CLASS_DIAGRAMS = YES
-
-# If set to YES, the inheritance and collaboration graphs will hide
-# inheritance and usage relations if the target is undocumented
-# or is not a class.
-
-HIDE_UNDOC_RELATIONS = YES
-
-# If you set the HAVE_DOT tag to YES then doxygen will assume the dot tool is
-# available from the path. This tool is part of Graphviz, a graph visualization
-# toolkit from AT&T and Lucent Bell Labs. The other options in this section
-# have no effect if this option is set to NO (the default)
-
-HAVE_DOT = YES
-
-# If the CLASS_GRAPH and HAVE_DOT tags are set to YES then doxygen
-# will generate a graph for each documented class showing the direct and
-# indirect inheritance relations. Setting this tag to YES will force the
-# the CLASS_DIAGRAMS tag to NO.
-
-CLASS_GRAPH = YES
-
-# If the COLLABORATION_GRAPH and HAVE_DOT tags are set to YES then doxygen
-# will generate a graph for each documented class showing the direct and
-# indirect implementation dependencies (inheritance, containment, and
-# class references variables) of the class with other documented classes.
-
-COLLABORATION_GRAPH = NO
-
-# If the GROUP_GRAPHS and HAVE_DOT tags are set to YES then doxygen
-# will generate a graph for groups, showing the direct groups dependencies
-
-GROUP_GRAPHS = YES
-
-# If the UML_LOOK tag is set to YES doxygen will generate inheritance and
-# collaboration diagrams in a style similar to the OMG's Unified Modeling
-# Language.
-
-UML_LOOK = NO
-# UML_LOOK = YES
-
-# If set to YES, the inheritance and collaboration graphs will show the
-# relations between templates and their instances.
-
-TEMPLATE_RELATIONS = YES
-
-# If the ENABLE_PREPROCESSING, SEARCH_INCLUDES, INCLUDE_GRAPH, and HAVE_DOT
-# tags are set to YES then doxygen will generate a graph for each documented
-# file showing the direct and indirect include dependencies of the file with
-# other documented files.
-
-INCLUDE_GRAPH = YES
-
-# If the ENABLE_PREPROCESSING, SEARCH_INCLUDES, INCLUDED_BY_GRAPH, and
-# HAVE_DOT tags are set to YES then doxygen will generate a graph for each
-# documented header file showing the documented files that directly or
-# indirectly include this file.
-
-INCLUDED_BY_GRAPH = YES
-
-# If the CALL_GRAPH and HAVE_DOT tags are set to YES then doxygen will
-# generate a call dependency graph for every global function or class method.
-# Note that enabling this option will significantly increase the time of a run.
-# So in most cases it will be better to enable call graphs for selected
-# functions only using the \callgraph command.
-
-CALL_GRAPH = NO
-
-# If the GRAPHICAL_HIERARCHY and HAVE_DOT tags are set to YES then doxygen
-# will graphical hierarchy of all classes instead of a textual one.
-
-GRAPHICAL_HIERARCHY = YES
-
-# If the DIRECTORY_GRAPH, SHOW_DIRECTORIES and HAVE_DOT tags are set to YES
-# then doxygen will show the dependencies a directory has on other directories
-# in a graphical way. The dependency relations are determined by the #include
-# relations between the files in the directories.
-
-DIRECTORY_GRAPH = YES
-
-# The DOT_IMAGE_FORMAT tag can be used to set the image format of the images
-# generated by dot. Possible values are png, jpg, or gif
-# If left blank png will be used.
-
-DOT_IMAGE_FORMAT = png
-
-# The tag DOT_PATH can be used to specify the path where the dot tool can be
-# found. If left blank, it is assumed the dot tool can be found in the path.
-
-DOT_PATH =
-
-# The DOTFILE_DIRS tag can be used to specify one or more directories that
-# contain dot files that are included in the documentation (see the
-# \dotfile command).
-
-DOTFILE_DIRS =
-
-# The MAX_DOT_GRAPH_WIDTH tag can be used to set the maximum allowed width
-# (in pixels) of the graphs generated by dot. If a graph becomes larger than
-# this value, doxygen will try to truncate the graph, so that it fits within
-# the specified constraint. Beware that most browsers cannot cope with very
-# large images.
-
-# Obsolet option.
-#MAX_DOT_GRAPH_WIDTH = 1280
-
-# The MAX_DOT_GRAPH_HEIGHT tag can be used to set the maximum allows height
-# (in pixels) of the graphs generated by dot. If a graph becomes larger than
-# this value, doxygen will try to truncate the graph, so that it fits within
-# the specified constraint. Beware that most browsers cannot cope with very
-# large images.
-
-# Obsolet option.
-#MAX_DOT_GRAPH_HEIGHT = 1024
-
-# The MAX_DOT_GRAPH_DEPTH tag can be used to set the maximum depth of the
-# graphs generated by dot. A depth value of 3 means that only nodes reachable
-# from the root by following a path via at most 3 edges will be shown. Nodes
-# that lay further from the root node will be omitted. Note that setting this
-# option to 1 or 2 may greatly reduce the computation time needed for large
-# code bases. Also note that a graph may be further truncated if the graph's
-# image dimensions are not sufficient to fit the graph (see MAX_DOT_GRAPH_WIDTH
-# and MAX_DOT_GRAPH_HEIGHT). If 0 is used for the depth value (the default),
-# the graph is not depth-constrained.
-
-MAX_DOT_GRAPH_DEPTH = 0
-
-# Set the DOT_TRANSPARENT tag to YES to generate images with a transparent
-# background. This is disabled by default, which results in a white background.
-# Warning: Depending on the platform used, enabling this option may lead to
-# badly anti-aliased labels on the edges of a graph (i.e. they become hard to
-# read).
-
-DOT_TRANSPARENT = NO
-
-# Set the DOT_MULTI_TARGETS tag to YES allow dot to generate multiple output
-# files in one run (i.e. multiple -o and -T options on the command line). This
-# makes dot run faster, but since only newer versions of dot (>1.8.10)
-# support this, this feature is disabled by default.
-# JW
-# DOT_MULTI_TARGETS = NO
-DOT_MULTI_TARGETS = YES
-
-# If the GENERATE_LEGEND tag is set to YES (the default) Doxygen will
-# generate a legend page explaining the meaning of the various boxes and
-# arrows in the dot generated graphs.
-
-GENERATE_LEGEND = YES
-
-# If the DOT_CLEANUP tag is set to YES (the default) Doxygen will
-# remove the intermediate dot files that are used to generate
-# the various graphs.
-
-DOT_CLEANUP = YES
-
-#---------------------------------------------------------------------------
-# Configuration::additions related to the search engine
-#---------------------------------------------------------------------------
-
-# The SEARCHENGINE tag specifies whether or not a search engine should be
-# used. If set to NO the values of all tags below this one will be ignored.
-
-# JW SEARCHENGINE = NO
-SEARCHENGINE = YES
diff --git a/doc/manual.asciidoc b/doc/manual.asciidoc
deleted file mode 100644
index 45db7e2..0000000
--- a/doc/manual.asciidoc
+++ /dev/null
@@ -1,1346 +0,0 @@
-The Ninja build system
-======================
-
-
-Introduction
-------------
-
-Ninja is yet another build system. It takes as input the
-interdependencies of files (typically source code and output
-executables) and orchestrates building them, _quickly_.
-
-Ninja joins a sea of other build systems. Its distinguishing goal is
-to be fast. It is born from
-http://neugierig.org/software/chromium/notes/2011/02/ninja.html[my
-work on the Chromium browser project], which has over 30,000 source
-files and whose other build systems (including one built from custom
-non-recursive Makefiles) would take ten seconds to start building
-after changing one file. Ninja is under a second.
-
-Philosophical overview
-~~~~~~~~~~~~~~~~~~~~~~
-
-Where other build systems are high-level languages, Ninja aims to be
-an assembler.
-
-Build systems get slow when they need to make decisions. When you are
-in an edit-compile cycle you want it to be as fast as possible -- you
-want the build system to do the minimum work necessary to figure out
-what needs to be built immediately.
-
-Ninja contains the barest functionality necessary to describe
-arbitrary dependency graphs. Its lack of syntax makes it impossible
-to express complex decisions.
-
-Instead, Ninja is intended to be used with a separate program
-generating its input files. The generator program (like the
-`./configure` found in autotools projects) can analyze system
-dependencies and make as many decisions as possible up front so that
-incremental builds stay fast. Going beyond autotools, even build-time
-decisions like "which compiler flags should I use?" or "should I
-build a debug or release-mode binary?" belong in the `.ninja` file
-generator.
-
-Design goals
-~~~~~~~~~~~~
-
-Here are the design goals of Ninja:
-
-* very fast (i.e., instant) incremental builds, even for very large
- projects.
-
-* very little policy about how code is built. Different projects and
- higher-level build systems have different opinions about how code
- should be built; for example, should built objects live alongside
- the sources or should all build output go into a separate directory?
- Is there a "package" rule that builds a distributable package of
- the project? Sidestep these decisions by trying to allow either to
- be implemented, rather than choosing, even if that results in
- more verbosity.
-
-* get dependencies correct, and in particular situations that are
- difficult to get right with Makefiles (e.g. outputs need an implicit
- dependency on the command line used to generate them; to build C
- source code you need to use gcc's `-M` flags for header
- dependencies).
-
-* when convenience and speed are in conflict, prefer speed.
-
-Some explicit _non-goals_:
-
-* convenient syntax for writing build files by hand. _You should
- generate your ninja files using another program_. This is how we
- can sidestep many policy decisions.
-
-* built-in rules. _Out of the box, Ninja has no rules for
- e.g. compiling C code._
-
-* build-time customization of the build. _Options belong in
- the program that generates the ninja files_.
-
-* build-time decision-making ability such as conditionals or search
- paths. _Making decisions is slow._
-
-To restate, Ninja is faster than other build systems because it is
-painfully simple. You must tell Ninja exactly what to do when you
-create your project's `.ninja` files.
-
-Comparison to Make
-~~~~~~~~~~~~~~~~~~
-
-Ninja is closest in spirit and functionality to Make, relying on
-simple dependencies between file timestamps.
-
-But fundamentally, make has a lot of _features_: suffix rules,
-functions, built-in rules that e.g. search for RCS files when building
-source. Make's language was designed to be written by humans. Many
-projects find make alone adequate for their build problems.
-
-In contrast, Ninja has almost no features; just those necessary to get
-builds correct while punting most complexity to generation of the
-ninja input files. Ninja by itself is unlikely to be useful for most
-projects.
-
-Here are some of the features Ninja adds to Make. (These sorts of
-features can often be implemented using more complicated Makefiles,
-but they are not part of make itself.)
-
-* Ninja has special support for discovering extra dependencies at build
- time, making it easy to get <<ref_headers,header dependencies>>
- correct for C/C++ code.
-
-* A build edge may have multiple outputs.
-
-* Outputs implicitly depend on the command line that was used to generate
- them, which means that changing e.g. compilation flags will cause
- the outputs to rebuild.
-
-* Output directories are always implicitly created before running the
- command that relies on them.
-
-* Rules can provide shorter descriptions of the command being run, so
- you can print e.g. `CC foo.o` instead of a long command line while
- building.
-
-* Builds are always run in parallel, based by default on the number of
- CPUs your system has. Underspecified build dependencies will result
- in incorrect builds.
-
-* Command output is always buffered. This means commands running in
- parallel don't interleave their output, and when a command fails we
- can print its failure output next to the full command line that
- produced the failure.
-
-
-Using Ninja for your project
-----------------------------
-
-Ninja currently works on Unix-like systems and Windows. It's seen the
-most testing on Linux (and has the best performance there) but it runs
-fine on Mac OS X and FreeBSD.
-
-If your project is small, Ninja's speed impact is likely unnoticeable.
-(However, even for small projects it sometimes turns out that Ninja's
-limited syntax forces simpler build rules that result in faster
-builds.) Another way to say this is that if you're happy with the
-edit-compile cycle time of your project already then Ninja won't help.
-
-There are many other build systems that are more user-friendly or
-featureful than Ninja itself. For some recommendations: the Ninja
-author found http://gittup.org/tup/[the tup build system] influential
-in Ninja's design, and thinks https://github.com/apenwarr/redo[redo]'s
-design is quite clever.
-
-Ninja's benefit comes from using it in conjunction with a smarter
-meta-build system.
-
-https://gn.googlesource.com/gn/[gn]:: The meta-build system used to
-generate build files for Google Chrome and related projects (v8,
-node.js), as well as Google Fuchsia. gn can generate Ninja files for
-all platforms supported by Chrome.
-
-https://cmake.org/[CMake]:: A widely used meta-build system that
-can generate Ninja files on Linux as of CMake version 2.8.8. Newer versions
-of CMake support generating Ninja files on Windows and Mac OS X too.
-
-https://github.com/ninja-build/ninja/wiki/List-of-generators-producing-ninja-build-files[others]:: Ninja ought to fit perfectly into other meta-build software
-like https://premake.github.io/[premake]. If you do this work,
-please let us know!
-
-Running Ninja
-~~~~~~~~~~~~~
-
-Run `ninja`. By default, it looks for a file named `build.ninja` in
-the current directory and builds all out-of-date targets. You can
-specify which targets (files) to build as command line arguments.
-
-There is also a special syntax `target^` for specifying a target
-as the first output of some rule containing the source you put in
-the command line, if one exists. For example, if you specify target as
-`foo.c^` then `foo.o` will get built (assuming you have those targets
-in your build files).
-
-`ninja -h` prints help output. Many of Ninja's flags intentionally
-match those of Make; e.g `ninja -C build -j 20` changes into the
-`build` directory and runs 20 build commands in parallel. (Note that
-Ninja defaults to running commands in parallel anyway, so typically
-you don't need to pass `-j`.)
-
-
-Environment variables
-~~~~~~~~~~~~~~~~~~~~~
-
-Ninja supports a few environment variables to control its behavior:
-
-`NINJA_STATUS`, the progress status printed before the rule being run.
-
-Several placeholders are available:
-
-`%s`:: The number of started edges.
-`%t`:: The total number of edges that must be run to complete the build.
-`%p`:: The percentage of started edges.
-`%r`:: The number of currently running edges.
-`%u`:: The number of remaining edges to start.
-`%f`:: The number of finished edges.
-`%o`:: Overall rate of finished edges per second
-`%c`:: Current rate of finished edges per second (average over builds
-specified by `-j` or its default)
-`%e`:: Elapsed time in seconds. _(Available since Ninja 1.2.)_
-`%%`:: A plain `%` character.
-
-The default progress status is `"[%f/%t] "` (note the trailing space
-to separate from the build rule). Another example of possible progress status
-could be `"[%u/%r/%f] "`.
-
-`NINJA_STATUS_MAX_COMMANDS` can be set to a decimal integer value.
-When it is greater than 0, then Ninja will display, below the status line,
-a list of commands that are still running, with their elapsed times, sorted
-from oldest to newest. The value determines the maximum number of pending
-commands to display.For example, with a value of 4, it can look like:
-
-
----------------------------------
-[2617/70332] STAMP obj/zircon/system/...c_sdk_verify_api.generated_file.stamp
- 1.5s | RUST obj/third_party/rust_cr...ibdata_encoding-182ebdb900ce1527.rlib
- 1.4s | RUST obj/third_party/rust_crates/liblibc-49c4578e69d66647.rlib
- 1.3s | RUST obj/third_party/rust_crates/libnum_traits-eace97eec9f18ef0.rlib
- 1.1s | RUST obj/third_party/rust_cr...libregex_syntax-49dcde6b7db9cfdf.rlib
----------------------------------
-
-The commands list is refreshed every 100ms by default, but this period can be
-changed using `NINJA_STATUS_REFRESH_MILLIS`, whose value must be a period
-in milliseconds that is >= 100 (there is no point in using lower values
-since all elapsed times are printed up to a single decimal digit, so anything
-lower will be ignored).
-
-Note that:
-
-- Pending commands are never displayed when using `-n` (i.e. dry-run)
- or `--verbose`, or on dumb terminals, so it should not affect scripts
- parsing Ninja output.
-
-- The commands list is cleared automatically before Ninja prints
- any command-specific output. This includes the output of edges with
- `pool = console`.
-
-- Finally, the status line itself prints the same thing, i.e. the last
- completed command only.
-
-`NINJA_PERSISTENT_MODE` can be set to `1` or `on` to use Ninja's persistent
-mode, where the first invocation for a given build directory will spawn a
-background server process that will load the build graph in memory, then
-answers multiple queries in succession. For very large build graphs, this
-allows Ninja to restart much faster.
-
-Note that this feature should be transparent to the user, except on Win32
-where it currently does not work(!).
-
-Each server process will shutdown gracefully after 5 minutes of idle time,
-or if any of the input `.ninja` file changed (to ensure correctness). The
-`server` tool can be used to interact with the server (see below).
-
-For debugging, it is possible to launch a server process in the foreground
-by setting `NINJA_PERSISTENT_MODE=server` in the environment. Server logs
-will then be printed directly to the current terminal stdout/stderr.
-
-By default, the server will shutdown gracefully after waiting for client
-connections for 5 minutes. This delay can be changed by setting the
-`NINJA_PERSISTENT_MODE_TIMEOUT_SECONDS` environment variable, which
-should receive a strictly positive timeout in seconds. For example,
-use 3600 for an hour.
-
-`NINJA_PERSISTENT_LOG_FILE` can be set to specify a file where the logs of
-new background server processes are written too, which can be useful for
-debugging.
-
-All environment variables from the client process are passed to the server
-on each incremental build, then used when spawning new commands. Note that
-this does not affect the server, so the `NINJA_PERSISTENT_XXX` variables
-only take effect when a server starts.
-
-Extra tools
-~~~~~~~~~~~
-
-The `-t` flag on the Ninja command line runs some tools that we have
-found useful during Ninja's development. The current tools are:
-
-[horizontal]
-`query`:: dump the inputs and outputs of a given target.
-
-`browse`:: browse the dependency graph in a web browser. Clicking a
-file focuses the view on that file, showing inputs and outputs. This
-feature requires a Python installation. By default, port 8000 is used
-and a web browser will be opened. This can be changed as follows:
-+
-----
-ninja -t browse --port=8000 --no-browser mytarget
-----
-+
-`graph`:: output a file in the syntax used by `graphviz`, an automatic
-graph layout tool. Use it like:
-+
-----
-ninja -t graph mytarget | dot -Tpng -ograph.png
-----
-+
-In the Ninja source tree, `ninja graph.png`
-generates an image for Ninja itself. If no target is given generate a
-graph for all root targets.
-
-`targets`:: output a list of targets either by rule or by depth. If used
-like +ninja -t targets rule _name_+ it prints the list of targets
-using the given rule to be built. If no rule is given, it prints the source
-files (the leaves of the graph). If used like
-+ninja -t targets depth _digit_+ it
-prints the list of targets in a depth-first manner starting by the root
-targets (the ones with no outputs). Indentation is used to mark dependencies.
-If the depth is zero it prints all targets. If no arguments are provided
-+ninja -t targets depth 1+ is assumed. In this mode targets may be listed
-several times. If used like this +ninja -t targets all+ it
-prints all the targets available without indentation and it is faster
-than the _depth_ mode.
-
-`commands`:: given a list of targets, print a list of commands which, if
-executed in order, may be used to rebuild those targets, assuming that all
-output files are out of date.
-
-`inputs`:: given a list of targets, print a list of all inputs used to
-rebuild those targets.
-_Available since Ninja 1.11._
-
-`clean`:: remove built files. By default, it removes all built files
-except for those created by the generator. Adding the `-g` flag also
-removes built files created by the generator (see <<ref_rule,the rule
-reference for the +generator+ attribute>>). Additional arguments are
-targets, which removes the given targets and recursively all files
-built for them.
-+
-If used like +ninja -t clean -r _rules_+ it removes all files built using
-the given rules.
-+
-Files created but not referenced in the graph are not removed. This
-tool takes in account the +-v+ and the +-n+ options (note that +-n+
-implies +-v+).
-
-`cleandead`:: remove files produced by previous builds that are no longer in the
-build file. _Available since Ninja 1.10._
-
-`compdb`:: given a list of rules, each of which is expected to be a
-C family language compiler rule whose first input is the name of the
-source file, prints on standard output a compilation database in the
-http://clang.llvm.org/docs/JSONCompilationDatabase.html[JSON format] expected
-by the Clang tooling interface.
-_Available since Ninja 1.2._
-
-`deps`:: show all dependencies stored in the `.ninja_deps` file. When given a
-target, show just the target's dependencies. _Available since Ninja 1.4._
-
-`missingdeps`:: given a list of targets, look for targets that depend on
-a generated file, but do not have a properly (possibly transitive) dependency
-on the generator. Such targets may cause build flakiness on clean builds.
-+
-The broken targets can be found assuming deps log / depfile dependency
-information is correct. Any target that depends on a generated file (output
-of a generator-target) implicitly, but does not have an explicit or order-only
-dependency path to the generator-target, is considered broken.
-+
-The tool's findings can be verified by trying to build the listed targets in
-a clean outdir without building any other targets. The build should fail for
-each of them with a missing include error or equivalent pointing to the
-generated file.
-_Available since Ninja 1.11._
-
-`recompact`:: recompact the `.ninja_deps` file. _Available since Ninja 1.4._
-
-`restat`:: updates all recorded file modification timestamps in the `.ninja_log`
-file. _Available since Ninja 1.10._
-
-`rules`:: output the list of all rules. It can be used to know which rule name
-to pass to +ninja -t targets rule _name_+ or +ninja -t compdb+. Adding the `-d`
-flag also prints the description of the rules.
-
-`msvc`:: Available on Windows hosts only.
-Helper tool to invoke the `cl.exe` compiler with a pre-defined set of
-environment variables, as in:
-+
-----
-ninja -t msvc -e ENVFILE -- cl.exe <arguments>
-----
-+
-Where `ENVFILE` is a binary file that contains an environment block suitable
-for CreateProcessA() on Windows (i.e. a series of zero-terminated strings that
-look like NAME=VALUE, followed by an extra zero terminator). Note that this uses
-the local codepage encoding.
-
-This tool also supports a deprecated way of parsing the compiler's output when
-the `/showIncludes` flag is used, and generating a GCC-compatible depfile from it.
-+
----
-ninja -t msvc -o DEPFILE [-p STRING] -- cl.exe /showIncludes <arguments>
----
-+
-
-When using this option, `-p STRING` can be used to pass the localized line prefix
-that `cl.exe` uses to output dependency information. For English-speaking regions
-this is `"Note: including file: "` without the double quotes, but will be different
-for other regions.
-
-Note that Ninja supports this natively now, with the use of `deps = msvc` and
-`msvc_deps_prefix` in Ninja files. Native support also avoids launching an extra
-tool process each time the compiler must be called, which can speed up builds
-noticeably on Windows.
-
-`wincodepage`:: Available on Windows hosts (_since Ninja 1.11_).
-Prints the Windows code page whose encoding is expected in the build file.
-The output has the form:
-+
-----
-Build file encoding: <codepage>
-----
-+
-Additional lines may be added in future versions of Ninja.
-+
-The `<codepage>` is one of:
-
-`UTF-8`::: Encode as UTF-8.
-
-`ANSI`::: Encode to the system-wide ANSI code page.
-
-
-`server`:: interact with a persistent server instance if there is one. Use
-+ninja -t server status+ to retrieve the status of the server, and use
-+ninja -t server stop+ to stop any existing server instance.
-
-Writing your own Ninja files
-----------------------------
-
-The remainder of this manual is only useful if you are constructing
-Ninja files yourself: for example, if you're writing a meta-build
-system or supporting a new language.
-
-Conceptual overview
-~~~~~~~~~~~~~~~~~~~
-
-Ninja evaluates a graph of dependencies between files, and runs
-whichever commands are necessary to make your build target up to date
-as determined by file modification times. If you are familiar with
-Make, Ninja is very similar.
-
-A build file (default name: `build.ninja`) provides a list of _rules_
--- short names for longer commands, like how to run the compiler --
-along with a list of _build_ statements saying how to build files
-using the rules -- which rule to apply to which inputs to produce
-which outputs.
-
-Conceptually, `build` statements describe the dependency graph of your
-project, while `rule` statements describe how to generate the files
-along a given edge of the graph.
-
-Syntax example
-~~~~~~~~~~~~~~
-
-Here's a basic `.ninja` file that demonstrates most of the syntax.
-It will be used as an example for the following sections.
-
----------------------------------
-cflags = -Wall
-
-rule cc
- command = gcc $cflags -c $in -o $out
-
-build foo.o: cc foo.c
----------------------------------
-
-Variables
-~~~~~~~~~
-Despite the non-goal of being convenient to write by hand, to keep
-build files readable (debuggable), Ninja supports declaring shorter
-reusable names for strings. A declaration like the following
-
-----------------
-cflags = -g
-----------------
-
-can be used on the right side of an equals sign, dereferencing it with
-a dollar sign, like this:
-
-----------------
-rule cc
- command = gcc $cflags -c $in -o $out
-----------------
-
-Variables can also be referenced using curly braces like `${in}`.
-
-Variables might better be called "bindings", in that a given variable
-cannot be changed, only shadowed. There is more on how shadowing works
-later in this document.
-
-Rules
-~~~~~
-
-Rules declare a short name for a command line. They begin with a line
-consisting of the `rule` keyword and a name for the rule. Then
-follows an indented set of `variable = value` lines.
-
-The basic example above declares a new rule named `cc`, along with the
-command to run. In the context of a rule, the `command` variable
-defines the command to run, `$in` expands to the list of
-input files (`foo.c`), and `$out` to the output files (`foo.o`) for the
-command. A full list of special variables is provided in
-<<ref_rule,the reference>>.
-
-Build statements
-~~~~~~~~~~~~~~~~
-
-Build statements declare a relationship between input and output
-files. They begin with the `build` keyword, and have the format
-+build _outputs_: _rulename_ _inputs_+. Such a declaration says that
-all of the output files are derived from the input files. When the
-output files are missing or when the inputs change, Ninja will run the
-rule to regenerate the outputs.
-
-The basic example above describes how to build `foo.o`, using the `cc`
-rule.
-
-In the scope of a `build` block (including in the evaluation of its
-associated `rule`), the variable `$in` is the list of inputs and the
-variable `$out` is the list of outputs.
-
-A build statement may be followed by an indented set of `key = value`
-pairs, much like a rule. These variables will shadow any variables
-when evaluating the variables in the command. For example:
-
-----------------
-cflags = -Wall -Werror
-rule cc
- command = gcc $cflags -c $in -o $out
-
-# If left unspecified, builds get the outer $cflags.
-build foo.o: cc foo.c
-
-# But you can shadow variables like cflags for a particular build.
-build special.o: cc special.c
- cflags = -Wall
-
-# The variable was only shadowed for the scope of special.o;
-# Subsequent build lines get the outer (original) cflags.
-build bar.o: cc bar.c
-
-----------------
-
-For more discussion of how scoping works, consult <<ref_scope,the
-reference>>.
-
-If you need more complicated information passed from the build
-statement to the rule (for example, if the rule needs "the file
-extension of the first input"), pass that through as an extra
-variable, like how `cflags` is passed above.
-
-If the top-level Ninja file is specified as an output of any build
-statement and it is out of date, Ninja will rebuild and reload it
-before building the targets requested by the user.
-
-Generating Ninja files from code
-~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
-
-`misc/ninja_syntax.py` in the Ninja distribution is a tiny Python
-module to facilitate generating Ninja files. It allows you to make
-Python calls like `ninja.rule(name='foo', command='bar',
-depfile='$out.d')` and it will generate the appropriate syntax. Feel
-free to just inline it into your project's build system if it's
-useful.
-
-
-More details
-------------
-
-The `phony` rule
-~~~~~~~~~~~~~~~~
-
-The special rule name `phony` can be used to create aliases for other
-targets. For example:
-
-----------------
-build foo: phony some/file/in/a/faraway/subdir/foo
-----------------
-
-This makes `ninja foo` build the longer path. Semantically, the
-`phony` rule is equivalent to a plain rule where the `command` does
-nothing, but phony rules are handled specially in that they aren't
-printed when run, logged (see below), nor do they contribute to the
-command count printed as part of the build process.
-
-When a `phony` target is used as an input to another build rule, the
-other build rule will, semantically, consider the inputs of the
-`phony` rule as its own. Therefore, `phony` rules can be used to group
-inputs, e.g. header files.
-
-`phony` can also be used to create dummy targets for files which
-may not exist at build time. If a phony build statement is written
-without any dependencies, the target will be considered out of date if
-it does not exist. Without a phony build statement, Ninja will report
-an error if the file does not exist and is required by the build.
-
-To create a rule that never rebuilds, use a build rule without any input:
-----------------
-rule touch
- command = touch $out
-build file_that_always_exists.dummy: touch
-build dummy_target_to_follow_a_pattern: phony file_that_always_exists.dummy
-----------------
-
-
-Default target statements
-~~~~~~~~~~~~~~~~~~~~~~~~~
-
-By default, if no targets are specified on the command line, Ninja
-will build every output that is not named as an input elsewhere.
-You can override this behavior using a default target statement.
-A default target statement causes Ninja to build only a given subset
-of output files if none are specified on the command line.
-
-Default target statements begin with the `default` keyword, and have
-the format +default _targets_+. A default target statement must appear
-after the build statement that declares the target as an output file.
-They are cumulative, so multiple statements may be used to extend
-the list of default targets. For example:
-
-----------------
-default foo bar
-default baz
-----------------
-
-This causes Ninja to build the `foo`, `bar` and `baz` targets by
-default.
-
-
-[[ref_log]]
-The Ninja log
-~~~~~~~~~~~~~
-
-For each built file, Ninja keeps a log of the command used to build
-it. Using this log Ninja can know when an existing output was built
-with a different command line than the build files specify (i.e., the
-command line changed) and knows to rebuild the file.
-
-The log file is kept in the build root in a file called `.ninja_log`.
-If you provide a variable named `builddir` in the outermost scope,
-`.ninja_log` will be kept in that directory instead.
-
-
-[[ref_versioning]]
-Version compatibility
-~~~~~~~~~~~~~~~~~~~~~
-
-_Available since Ninja 1.2._
-
-Ninja version labels follow the standard major.minor.patch format,
-where the major version is increased on backwards-incompatible
-syntax/behavioral changes and the minor version is increased on new
-behaviors. Your `build.ninja` may declare a variable named
-`ninja_required_version` that asserts the minimum Ninja version
-required to use the generated file. For example,
-
------
-ninja_required_version = 1.1
------
-
-declares that the build file relies on some feature that was
-introduced in Ninja 1.1 (perhaps the `pool` syntax), and that
-Ninja 1.1 or greater must be used to build. Unlike other Ninja
-variables, this version requirement is checked immediately when
-the variable is encountered in parsing, so it's best to put it
-at the top of the build file.
-
-Ninja always warns if the major versions of Ninja and the
-`ninja_required_version` don't match; a major version change hasn't
-come up yet so it's difficult to predict what behavior might be
-required.
-
-[[ref_headers]]
-C/C++ header dependencies
-~~~~~~~~~~~~~~~~~~~~~~~~~
-
-To get C/C++ header dependencies (or any other build dependency that
-works in a similar way) correct Ninja has some extra functionality.
-
-The problem with headers is that the full list of files that a given
-source file depends on can only be discovered by the compiler:
-different preprocessor defines and include paths cause different files
-to be used. Some compilers can emit this information while building,
-and Ninja can use that to get its dependencies perfect.
-
-Consider: if the file has never been compiled, it must be built anyway,
-generating the header dependencies as a side effect. If any file is
-later modified (even in a way that changes which headers it depends
-on) the modification will cause a rebuild as well, keeping the
-dependencies up to date.
-
-When loading these special dependencies, Ninja implicitly adds extra
-build edges such that it is not an error if the listed dependency is
-missing. This allows you to delete a header file and rebuild without
-the build aborting due to a missing input.
-
-depfile
-^^^^^^^
-
-`gcc` (and other compilers like `clang`) support emitting dependency
-information in the syntax of a Makefile. (Any command that can write
-dependencies in this form can be used, not just `gcc`.)
-
-To bring this information into Ninja requires cooperation. On the
-Ninja side, the `depfile` attribute on the `build` must point to a
-path where this data is written. (Ninja only supports the limited
-subset of the Makefile syntax emitted by compilers.) Then the command
-must know to write dependencies into the `depfile` path.
-Use it like in the following example:
-
-----
-rule cc
- depfile = $out.d
- command = gcc -MD -MF $out.d [other gcc flags here]
-----
-
-The `-MD` flag to `gcc` tells it to output header dependencies, and
-the `-MF` flag tells it where to write them.
-
-deps
-^^^^
-
-_(Available since Ninja 1.3.)_
-
-It turns out that for large projects (and particularly on Windows,
-where the file system is slow) loading these dependency files on
-startup is slow.
-
-Ninja 1.3 can instead process dependencies just after they're generated
-and save a compacted form of the same information in a Ninja-internal
-database.
-
-Ninja supports this processing in two forms.
-
-1. `deps = gcc` specifies that the tool outputs `gcc`-style dependencies
- in the form of Makefiles. Adding this to the above example will
- cause Ninja to process the `depfile` immediately after the
- compilation finishes, then delete the `.d` file (which is only used
- as a temporary).
-
-2. `deps = msvc` specifies that the tool outputs header dependencies
- in the form produced by the Visual Studio compiler's
- http://msdn.microsoft.com/en-us/library/hdkef6tk(v=vs.90).aspx[`/showIncludes`
- flag]. Briefly, this means the tool outputs specially-formatted lines
- to its stdout. Ninja then filters these lines from the displayed
- output. No `depfile` attribute is necessary, but the localized string
- in front of the header file path should be globally defined. For instance,
- `msvc_deps_prefix = Note: including file:`
- for an English Visual Studio (the default).
-+
-----
-msvc_deps_prefix = Note: including file:
-rule cc
- deps = msvc
- command = cl /showIncludes -c $in /Fo$out
-----
-
-If the include directory directives are using absolute paths, your depfile
-may result in a mixture of relative and absolute paths. Paths used by other
-build rules need to match exactly. Therefore, it is recommended to use
-relative paths in these cases.
-
-[[ref_pool]]
-Pools
-~~~~~
-
-_Available since Ninja 1.1._
-
-Pools allow you to allocate one or more rules or edges a finite number
-of concurrent jobs which is more tightly restricted than the default
-parallelism.
-
-This can be useful, for example, to restrict a particular expensive rule
-(like link steps for huge executables), or to restrict particular build
-statements which you know perform poorly when run concurrently.
-
-Each pool has a `depth` variable which is specified in the build file.
-The pool is then referred to with the `pool` variable on either a rule
-or a build statement.
-
-No matter what pools you specify, ninja will never run more concurrent jobs
-than the default parallelism, or the number of jobs specified on the command
-line (with `-j`).
-
-----------------
-# No more than 4 links at a time.
-pool link_pool
- depth = 4
-
-# No more than 1 heavy object at a time.
-pool heavy_object_pool
- depth = 1
-
-rule link
- ...
- pool = link_pool
-
-rule cc
- ...
-
-# The link_pool is used here. Only 4 links will run concurrently.
-build foo.exe: link input.obj
-
-# A build statement can be exempted from its rule's pool by setting an
-# empty pool. This effectively puts the build statement back into the default
-# pool, which has infinite depth.
-build other.exe: link input.obj
- pool =
-
-# A build statement can specify a pool directly.
-# Only one of these builds will run at a time.
-build heavy_object1.obj: cc heavy_obj1.cc
- pool = heavy_object_pool
-build heavy_object2.obj: cc heavy_obj2.cc
- pool = heavy_object_pool
-
-----------------
-
-The `console` pool
-^^^^^^^^^^^^^^^^^^
-
-_Available since Ninja 1.5._
-
-There exists a pre-defined pool named `console` with a depth of 1. It has
-the special property that any task in the pool has direct access to the
-standard input, output and error streams provided to Ninja, which are
-normally connected to the user's console (hence the name) but could be
-redirected. This can be useful for interactive tasks or long-running tasks
-which produce status updates on the console (such as test suites).
-
-While a task in the `console` pool is running, Ninja's regular output (such
-as progress status and output from concurrent tasks) is buffered until
-it completes.
-
-[[ref_ninja_file]]
-Ninja file reference
---------------------
-
-A file is a series of declarations. A declaration can be one of:
-
-1. A rule declaration, which begins with +rule _rulename_+, and
- then has a series of indented lines defining variables.
-
-2. A build edge, which looks like +build _output1_ _output2_:
- _rulename_ _input1_ _input2_+. +
- Implicit dependencies may be tacked on the end with +|
- _dependency1_ _dependency2_+. +
- Order-only dependencies may be tacked on the end with +||
- _dependency1_ _dependency2_+. (See <<ref_dependencies,the reference on
- dependency types>>.)
- Validations may be taked on the end with +|@ _validation1_ _validation2_+.
- (See <<validations,the reference on validations>>.)
-+
-Implicit outputs _(available since Ninja 1.7)_ may be added before
-the `:` with +| _output1_ _output2_+ and do not appear in `$out`.
-(See <<ref_outputs,the reference on output types>>.)
-
-3. Variable declarations, which look like +_variable_ = _value_+.
-
-4. Default target statements, which look like +default _target1_ _target2_+.
-
-5. References to more files, which look like +subninja _path_+ or
- +include _path_+. The difference between these is explained below
- <<ref_scope,in the discussion about scoping>>.
-
-6. A pool declaration, which looks like +pool _poolname_+. Pools are explained
- <<ref_pool, in the section on pools>>.
-
-[[ref_lexer]]
-Lexical syntax
-~~~~~~~~~~~~~~
-
-Ninja is mostly encoding agnostic, as long as the bytes Ninja cares
-about (like slashes in paths) are ASCII. This means e.g. UTF-8 or
-ISO-8859-1 input files ought to work.
-
-Comments begin with `#` and extend to the end of the line.
-
-Newlines are significant. Statements like `build foo bar` are a set
-of space-separated tokens that end at the newline. Newlines and
-spaces within a token must be escaped.
-
-There is only one escape character, `$`, and it has the following
-behaviors:
-
-`$` followed by a newline:: escape the newline (continue the current line
-across a line break).
-
-`$` followed by text:: a variable reference.
-
-`${varname}`:: alternate syntax for `$varname`.
-
-`$` followed by space:: a space. (This is only necessary in lists of
-paths, where a space would otherwise separate filenames. See below.)
-
-`$:` :: a colon. (This is only necessary in `build` lines, where a colon
-would otherwise terminate the list of outputs.)
-
-`$$`:: a literal `$`.
-
-A `build` or `default` statement is first parsed as a space-separated
-list of filenames and then each name is expanded. This means that
-spaces within a variable will result in spaces in the expanded
-filename.
-
-----
-spaced = foo bar
-build $spaced/baz other$ file: ...
-# The above build line has two outputs: "foo bar/baz" and "other file".
-----
-
-In a `name = value` statement, whitespace at the beginning of a value
-is always stripped. Whitespace at the beginning of a line after a
-line continuation is also stripped.
-
-----
-two_words_with_one_space = foo $
- bar
-one_word_with_no_space = foo$
- bar
-----
-
-Other whitespace is only significant if it's at the beginning of a
-line. If a line is indented more than the previous one, it's
-considered part of its parent's scope; if it is indented less than the
-previous one, it closes the previous scope.
-
-[[ref_toplevel]]
-Top-level variables
-~~~~~~~~~~~~~~~~~~~
-
-Two variables are significant when declared in the outermost file scope.
-
-`builddir`:: a directory for some Ninja output files. See <<ref_log,the
- discussion of the build log>>. (You can also store other build output
- in this directory.)
-
-`ninja_required_version`:: the minimum version of Ninja required to process
- the build correctly. See <<ref_versioning,the discussion of versioning>>.
-
-
-[[ref_rule]]
-Rule variables
-~~~~~~~~~~~~~~
-
-A `rule` block contains a list of `key = value` declarations that
-affect the processing of the rule. Here is a full list of special
-keys.
-
-`command` (_required_):: the command line to run. Each `rule` may
- have only one `command` declaration. See <<ref_rule_command,the next
- section>> for more details on quoting and executing multiple commands.
-
-`depfile`:: path to an optional `Makefile` that contains extra
- _implicit dependencies_ (see <<ref_dependencies,the reference on
- dependency types>>). This is explicitly to support C/C++ header
- dependencies; see <<ref_headers,the full discussion>>.
-
-`deps`:: _(Available since Ninja 1.3.)_ if present, must be one of
- `gcc` or `msvc` to specify special dependency processing. See
- <<ref_headers,the full discussion>>. The generated database is
- stored as `.ninja_deps` in the `builddir`, see <<ref_toplevel,the
- discussion of `builddir`>>.
-
-`msvc_deps_prefix`:: _(Available since Ninja 1.5.)_ defines the string
- which should be stripped from msvc's /showIncludes output. Only
- needed when `deps = msvc` and no English Visual Studio version is used.
-
-`description`:: a short description of the command, used to pretty-print
- the command as it's running. The `-v` flag controls whether to print
- the full command or its description; if a command fails, the full command
- line will always be printed before the command's output.
-
-`dyndep`:: _(Available since Ninja 1.10.)_ Used only on build statements.
- If present, must name one of the build statement inputs. Dynamically
- discovered dependency information will be loaded from the file.
- See the <<ref_dyndep,dynamic dependencies>> section for details.
-
-`generator`:: if present, specifies that this rule is used to
- re-invoke the generator program. Files built using `generator`
- rules are treated specially in two ways: firstly, they will not be
- rebuilt if the command line changes; and secondly, they are not
- cleaned by default.
-
-`in`:: the space-separated list of files provided as inputs to the build line
- referencing this `rule`, shell-quoted if it appears in commands. (`$in` is
- provided solely for convenience; if you need some subset or variant of this
- list of files, just construct a new variable with that list and use
- that instead.)
-
-`in_newline`:: the same as `$in` except that multiple inputs are
- separated by newlines rather than spaces. (For use with
- `$rspfile_content`; this works around a bug in the MSVC linker where
- it uses a fixed-size buffer for processing input.)
-
-`out`:: the space-separated list of files provided as outputs to the build line
- referencing this `rule`, shell-quoted if it appears in commands.
-
-`restat`:: if present, causes Ninja to re-stat the command's outputs
- after execution of the command. Each output whose modification time
- the command did not change will be treated as though it had never
- needed to be built. This may cause the output's reverse
- dependencies to be removed from the list of pending build actions.
-
-`rspfile`, `rspfile_content`:: if present (both), Ninja will use a
- response file for the given command, i.e. write the selected string
- (`rspfile_content`) to the given file (`rspfile`) before calling the
- command and delete the file after successful execution of the
- command.
-+
-This is particularly useful on Windows OS, where the maximal length of
-a command line is limited and response files must be used instead.
-+
-Use it like in the following example:
-+
-----
-rule link
- command = link.exe /OUT$out [usual link flags here] @$out.rsp
- rspfile = $out.rsp
- rspfile_content = $in
-
-build myapp.exe: link a.obj b.obj [possibly many other .obj files]
-----
-
-[[ref_rule_command]]
-Interpretation of the `command` variable
-^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
-Fundamentally, command lines behave differently on Unixes and Windows.
-
-On Unixes, commands are arrays of arguments. The Ninja `command`
-variable is passed directly to `sh -c`, which is then responsible for
-interpreting that string into an argv array. Therefore, the quoting
-rules are those of the shell, and you can use all the normal shell
-operators, like `&&` to chain multiple commands, or `VAR=value cmd` to
-set environment variables.
-
-On Windows, commands are strings, so Ninja passes the `command` string
-directly to `CreateProcess`. (In the common case of simply executing
-a compiler this means there is less overhead.) Consequently, the
-quoting rules are determined by the called program, which on Windows
-are usually provided by the C library. If you need shell
-interpretation of the command (such as the use of `&&` to chain
-multiple commands), make the command execute the Windows shell by
-prefixing the command with `cmd /c`. Ninja may error with "invalid parameter"
-which usually indicates that the command line length has been exceeded.
-
-[[ref_outputs]]
-Build outputs
-~~~~~~~~~~~~~
-
-There are two types of build outputs which are subtly different.
-
-1. _Explicit outputs_, as listed in a build line. These are
- available as the `$out` variable in the rule.
-+
-This is the standard form of output to be used for e.g. the
-object file of a compile command.
-
-2. _Implicit outputs_, as listed in a build line with the syntax +|
- _out1_ _out2_+ + before the `:` of a build line _(available since
- Ninja 1.7)_. The semantics are identical to explicit outputs,
- the only difference is that implicit outputs don't show up in the
- `$out` variable.
-+
-This is for expressing outputs that don't show up on the
-command line of the command.
-
-[[ref_dependencies]]
-Build dependencies
-~~~~~~~~~~~~~~~~~~
-
-There are three types of build dependencies which are subtly different.
-
-1. _Explicit dependencies_, as listed in a build line. These are
- available as the `$in` variable in the rule. Changes in these files
- cause the output to be rebuilt; if these files are missing and
- Ninja doesn't know how to build them, the build is aborted.
-+
-This is the standard form of dependency to be used e.g. for the
-source file of a compile command.
-
-2. _Implicit dependencies_, either as picked up from
- a `depfile` attribute on a rule or from the syntax +| _dep1_
- _dep2_+ on the end of a build line. The semantics are identical to
- explicit dependencies, the only difference is that implicit dependencies
- don't show up in the `$in` variable.
-+
-This is for expressing dependencies that don't show up on the
-command line of the command; for example, for a rule that runs a
-script that reads a hardcoded file, the hardcoded file should
-be an implicit dependency, as changes to the file should cause
-the output to rebuild, even though it doesn't show up in the arguments.
-+
-Note that dependencies as loaded through depfiles have slightly different
-semantics, as described in the <<ref_rule,rule reference>>.
-
-3. _Order-only dependencies_, expressed with the syntax +|| _dep1_
- _dep2_+ on the end of a build line. When these are out of date, the
- output is not rebuilt until they are built, but changes in order-only
- dependencies alone do not cause the output to be rebuilt.
-+
-Order-only dependencies can be useful for bootstrapping dependencies
-that are only discovered during build time: for example, to generate a
-header file before starting a subsequent compilation step. (Once the
-header is used in compilation, a generated dependency file will then
-express the implicit dependency.)
-
-File paths are compared as is, which means that an absolute path and a
-relative path, pointing to the same file, are considered different by Ninja.
-
-[[validations]]
-Validations
-~~~~~~~~~~~
-
-_Available since Ninja 1.11._
-
-Validations listed on the build line cause the specified files to be
-added to the top level of the build graph (as if they were specified
-on the Ninja command line) whenever the build line is a transitive
-dependency of one of the targets specified on the command line or a
-default target.
-
-Validations are added to the build graph regardless of whether the output
-files of the build statement are dirty are not, and the dirty state of
-the build statement that outputs the file being used as a validation
-has no effect on the dirty state of the build statement that requested it.
-
-A build edge can list another build edge as a validation even if the second
-edge depends on the first.
-
-Validations are designed to handle rules that perform error checking but
-don't produce any artifacts needed by the build, for example, static
-analysis tools. Marking the static analysis rule as an implicit input
-of the main build rule of the source files or of the rules that depend
-on the main build rule would slow down the critical path of the build,
-but using a validation would allow the build to proceed in parallel with
-the static analysis rule once the main build rule is complete.
-
-Variable expansion
-~~~~~~~~~~~~~~~~~~
-
-Variables are expanded in paths (in a `build` or `default` statement)
-and on the right side of a `name = value` statement.
-
-When a `name = value` statement is evaluated, its right-hand side is
-expanded immediately (according to the below scoping rules), and
-from then on `$name` expands to the static string as the result of the
-expansion. It is never the case that you'll need to "double-escape" a
-value to prevent it from getting expanded twice.
-
-All variables are expanded immediately as they're encountered in parsing,
-with one important exception: variables in `rule` blocks are expanded
-when the rule is _used_, not when it is declared. In the following
-example, the `demo` rule prints "this is a demo of bar".
-
-----
-rule demo
- command = echo "this is a demo of $foo"
-
-build out: demo
- foo = bar
-----
-
-[[ref_scope]]
-Evaluation and scoping
-~~~~~~~~~~~~~~~~~~~~~~
-
-Top-level variable declarations are scoped to the file they occur in.
-
-Rule declarations are also scoped to the file they occur in.
-_(Available since Ninja 1.6)_
-
-The `subninja` keyword, used to include another `.ninja` file,
-introduces a new scope. The included `subninja` file may use the
-variables and rules from the parent file, and shadow their values for the file's
-scope, but it won't affect values of the variables in the parent.
-
-To include another `.ninja` file in the current scope, much like a C
-`#include` statement, use `include` instead of `subninja`.
-
-Variable declarations indented in a `build` block are scoped to the
-`build` block. The full lookup order for a variable expanded in a
-`build` block (or the `rule` is uses) is:
-
-1. Special built-in variables (`$in`, `$out`).
-
-2. Build-level variables from the `build` block.
-
-3. Rule-level variables from the `rule` block (i.e. `$command`).
- (Note from the above discussion on expansion that these are
- expanded "late", and may make use of in-scope bindings like `$in`.)
-
-4. File-level variables from the file that the `build` line was in.
-
-5. Variables from the file that included that file using the
- `subninja` keyword.
-
-[[ref_dyndep]]
-Dynamic Dependencies
---------------------
-
-_Available since Ninja 1.10._
-
-Some use cases require implicit dependency information to be dynamically
-discovered from source file content _during the build_ in order to build
-correctly on the first run (e.g. Fortran module dependencies). This is
-unlike <<ref_headers,header dependencies>> which are only needed on the
-second run and later to rebuild correctly. A build statement may have a
-`dyndep` binding naming one of its inputs to specify that dynamic
-dependency information must be loaded from the file. For example:
-
-----
-build out: ... || foo
- dyndep = foo
-build foo: ...
-----
-
-This specifies that file `foo` is a dyndep file. Since it is an input,
-the build statement for `out` can never be executed before `foo` is built.
-As soon as `foo` is finished Ninja will read it to load dynamically
-discovered dependency information for `out`. This may include additional
-implicit inputs and/or outputs. Ninja will update the build graph
-accordingly and the build will proceed as if the information was known
-originally.
-
-Dyndep file reference
-~~~~~~~~~~~~~~~~~~~~~
-
-Files specified by `dyndep` bindings use the same <<ref_lexer,lexical syntax>>
-as <<ref_ninja_file,ninja build files>> and have the following layout.
-
-1. A version number in the form `<major>[.<minor>][<suffix>]`:
-+
-----
-ninja_dyndep_version = 1
-----
-+
-Currently the version number must always be `1` or `1.0` but may have
-an arbitrary suffix.
-
-2. One or more build statements of the form:
-+
-----
-build out | imp-outs... : dyndep | imp-ins...
-----
-+
-Every statement must specify exactly one explicit output and must use
-the rule name `dyndep`. The `| imp-outs...` and `| imp-ins...` portions
-are optional.
-
-3. An optional `restat` <<ref_rule,variable binding>> on each build statement.
-
-The build statements in a dyndep file must have a one-to-one correspondence
-to build statements in the <<ref_ninja_file,ninja build file>> that name the
-dyndep file in a `dyndep` binding. No dyndep build statement may be omitted
-and no extra build statements may be specified.
-
-Dyndep Examples
-~~~~~~~~~~~~~~~
-
-Fortran Modules
-^^^^^^^^^^^^^^^
-
-Consider a Fortran source file `foo.f90` that provides a module
-`foo.mod` (an implicit output of compilation) and another source file
-`bar.f90` that uses the module (an implicit input of compilation). This
-implicit dependency must be discovered before we compile either source
-in order to ensure that `bar.f90` never compiles before `foo.f90`, and
-that `bar.f90` recompiles when `foo.mod` changes. We can achieve this
-as follows:
-
-----
-rule f95
- command = f95 -o $out -c $in
-rule fscan
- command = fscan -o $out $in
-
-build foobar.dd: fscan foo.f90 bar.f90
-
-build foo.o: f95 foo.f90 || foobar.dd
- dyndep = foobar.dd
-build bar.o: f95 bar.f90 || foobar.dd
- dyndep = foobar.dd
-----
-
-In this example the order-only dependencies ensure that `foobar.dd` is
-generated before either source compiles. The hypothetical `fscan` tool
-scans the source files, assumes each will be compiled to a `.o` of the
-same name, and writes `foobar.dd` with content such as:
-
-----
-ninja_dyndep_version = 1
-build foo.o | foo.mod: dyndep
-build bar.o: dyndep | foo.mod
-----
-
-Ninja will load this file to add `foo.mod` as an implicit output of
-`foo.o` and implicit input of `bar.o`. This ensures that the Fortran
-sources are always compiled in the proper order and recompiled when
-needed.
-
-Tarball Extraction
-^^^^^^^^^^^^^^^^^^
-
-Consider a tarball `foo.tar` that we want to extract. The extraction time
-can be recorded with a `foo.tar.stamp` file so that extraction repeats if
-the tarball changes, but we also would like to re-extract if any of the
-outputs is missing. However, the list of outputs depends on the content
-of the tarball and cannot be spelled out explicitly in the ninja build file.
-We can achieve this as follows:
-
-----
-rule untar
- command = tar xf $in && touch $out
-rule scantar
- command = scantar --stamp=$stamp --dd=$out $in
-build foo.tar.dd: scantar foo.tar
- stamp = foo.tar.stamp
-build foo.tar.stamp: untar foo.tar || foo.tar.dd
- dyndep = foo.tar.dd
-----
-
-In this example the order-only dependency ensures that `foo.tar.dd` is
-built before the tarball extracts. The hypothetical `scantar` tool
-will read the tarball (e.g. via `tar tf`) and write `foo.tar.dd` with
-content such as:
-
-----
-ninja_dyndep_version = 1
-build foo.tar.stamp | file1.txt file2.txt : dyndep
- restat = 1
-----
-
-Ninja will load this file to add `file1.txt` and `file2.txt` as implicit
-outputs of `foo.tar.stamp`, and to mark the build statement for `restat`.
-On future builds, if any implicit output is missing the tarball will be
-extracted again. The `restat` binding tells Ninja to tolerate the fact
-that the implicit outputs may not have modification times newer than
-the tarball itself (avoiding re-extraction on every build).
diff --git a/doc/style.css b/doc/style.css
deleted file mode 100644
index 9976c03..0000000
--- a/doc/style.css
+++ /dev/null
@@ -1,29 +0,0 @@
-body {
- margin: 5ex 10ex;
- max-width: 80ex;
- line-height: 1.5;
- font-family: sans-serif;
-}
-h1, h2, h3 {
- font-weight: normal;
-}
-pre, code {
- font-family: x, monospace;
-}
-pre {
- padding: 1ex;
- background: #eee;
- border: solid 1px #ddd;
- min-width: 0;
- font-size: 90%;
-}
-code {
- color: #007;
-}
-div.chapter {
- margin-top: 4em;
- border-top: solid 2px black;
-}
-p {
- margin-top: 0;
-}
diff --git a/misc/afl-fuzz-tokens/kw_build b/misc/afl-fuzz-tokens/kw_build
deleted file mode 100644
index c795b05..0000000
--- a/misc/afl-fuzz-tokens/kw_build
+++ /dev/null
@@ -1 +0,0 @@
-build
\ No newline at end of file
diff --git a/misc/afl-fuzz-tokens/kw_default b/misc/afl-fuzz-tokens/kw_default
deleted file mode 100644
index 331d858..0000000
--- a/misc/afl-fuzz-tokens/kw_default
+++ /dev/null
@@ -1 +0,0 @@
-default
\ No newline at end of file
diff --git a/misc/afl-fuzz-tokens/kw_include b/misc/afl-fuzz-tokens/kw_include
deleted file mode 100644
index 2996fba..0000000
--- a/misc/afl-fuzz-tokens/kw_include
+++ /dev/null
@@ -1 +0,0 @@
-include
\ No newline at end of file
diff --git a/misc/afl-fuzz-tokens/kw_pool b/misc/afl-fuzz-tokens/kw_pool
deleted file mode 100644
index e783591..0000000
--- a/misc/afl-fuzz-tokens/kw_pool
+++ /dev/null
@@ -1 +0,0 @@
-pool
\ No newline at end of file
diff --git a/misc/afl-fuzz-tokens/kw_rule b/misc/afl-fuzz-tokens/kw_rule
deleted file mode 100644
index 841e840..0000000
--- a/misc/afl-fuzz-tokens/kw_rule
+++ /dev/null
@@ -1 +0,0 @@
-rule
\ No newline at end of file
diff --git a/misc/afl-fuzz-tokens/kw_subninja b/misc/afl-fuzz-tokens/kw_subninja
deleted file mode 100644
index c4fe0c7..0000000
--- a/misc/afl-fuzz-tokens/kw_subninja
+++ /dev/null
@@ -1 +0,0 @@
-subninja
\ No newline at end of file
diff --git a/misc/afl-fuzz-tokens/misc_a b/misc/afl-fuzz-tokens/misc_a
deleted file mode 100644
index 2e65efe..0000000
--- a/misc/afl-fuzz-tokens/misc_a
+++ /dev/null
@@ -1 +0,0 @@
-a
\ No newline at end of file
diff --git a/misc/afl-fuzz-tokens/misc_b b/misc/afl-fuzz-tokens/misc_b
deleted file mode 100644
index 63d8dbd..0000000
--- a/misc/afl-fuzz-tokens/misc_b
+++ /dev/null
@@ -1 +0,0 @@
-b
\ No newline at end of file
diff --git a/misc/afl-fuzz-tokens/misc_colon b/misc/afl-fuzz-tokens/misc_colon
deleted file mode 100644
index 22ded55..0000000
--- a/misc/afl-fuzz-tokens/misc_colon
+++ /dev/null
@@ -1 +0,0 @@
-:
\ No newline at end of file
diff --git a/misc/afl-fuzz-tokens/misc_cont b/misc/afl-fuzz-tokens/misc_cont
deleted file mode 100644
index 857f13a..0000000
--- a/misc/afl-fuzz-tokens/misc_cont
+++ /dev/null
@@ -1 +0,0 @@
-$
diff --git a/misc/afl-fuzz-tokens/misc_dollar b/misc/afl-fuzz-tokens/misc_dollar
deleted file mode 100644
index 6f4f765..0000000
--- a/misc/afl-fuzz-tokens/misc_dollar
+++ /dev/null
@@ -1 +0,0 @@
-$
\ No newline at end of file
diff --git a/misc/afl-fuzz-tokens/misc_eq b/misc/afl-fuzz-tokens/misc_eq
deleted file mode 100644
index 851c75c..0000000
--- a/misc/afl-fuzz-tokens/misc_eq
+++ /dev/null
@@ -1 +0,0 @@
-=
\ No newline at end of file
diff --git a/misc/afl-fuzz-tokens/misc_indent b/misc/afl-fuzz-tokens/misc_indent
deleted file mode 100644
index 136d063..0000000
--- a/misc/afl-fuzz-tokens/misc_indent
+++ /dev/null
@@ -1 +0,0 @@
-
\ No newline at end of file
diff --git a/misc/afl-fuzz-tokens/misc_pipe b/misc/afl-fuzz-tokens/misc_pipe
deleted file mode 100644
index a3871d4..0000000
--- a/misc/afl-fuzz-tokens/misc_pipe
+++ /dev/null
@@ -1 +0,0 @@
-|
\ No newline at end of file
diff --git a/misc/afl-fuzz-tokens/misc_pipepipe b/misc/afl-fuzz-tokens/misc_pipepipe
deleted file mode 100644
index 27cc728..0000000
--- a/misc/afl-fuzz-tokens/misc_pipepipe
+++ /dev/null
@@ -1 +0,0 @@
-||
\ No newline at end of file
diff --git a/misc/afl-fuzz-tokens/misc_space b/misc/afl-fuzz-tokens/misc_space
deleted file mode 100644
index 0519ecb..0000000
--- a/misc/afl-fuzz-tokens/misc_space
+++ /dev/null
@@ -1 +0,0 @@
-
\ No newline at end of file
diff --git a/misc/afl-fuzz/build.ninja b/misc/afl-fuzz/build.ninja
deleted file mode 100644
index 52cd2f1..0000000
--- a/misc/afl-fuzz/build.ninja
+++ /dev/null
@@ -1,5 +0,0 @@
-rule b
- command = clang -MMD -MF $out.d -o $out -c $in
- description = building $out
-
-build a.o: b a.c
diff --git a/misc/bash-completion b/misc/bash-completion
deleted file mode 100644
index e604cd4..0000000
--- a/misc/bash-completion
+++ /dev/null
@@ -1,57 +0,0 @@
-# Copyright 2011 Google Inc. All Rights Reserved.
-#
-# Licensed under the Apache License, Version 2.0 (the "License");
-# you may not use this file except in compliance with the License.
-# You may obtain a copy of the License at
-#
-# http://www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing, software
-# distributed under the License is distributed on an "AS IS" BASIS,
-# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-# See the License for the specific language governing permissions and
-# limitations under the License.
-
-# Add the following to your .bashrc to tab-complete ninja targets
-# . path/to/ninja/misc/bash-completion
-
-_ninja_target() {
- local cur prev targets dir line targets_command OPTIND
-
- # When available, use bash_completion to:
- # 1) Complete words when the cursor is in the middle of the word
- # 2) Complete paths with files or directories, as appropriate
- if _get_comp_words_by_ref cur prev &>/dev/null ; then
- case $prev in
- -f)
- _filedir
- return 0
- ;;
- -C)
- _filedir -d
- return 0
- ;;
- esac
- else
- cur="${COMP_WORDS[COMP_CWORD]}"
- fi
-
- if [[ "$cur" == "--"* ]]; then
- # there is currently only one argument that takes --
- COMPREPLY=($(compgen -P '--' -W 'version' -- "${cur:2}"))
- else
- dir="."
- line=$(echo ${COMP_LINE} | cut -d" " -f 2-)
- # filter out all non relevant arguments but keep C for dirs
- while getopts :C:f:j:l:k:nvd:t: opt $line; do
- case $opt in
- # eval for tilde expansion
- C) eval dir="$OPTARG" ;;
- esac
- done;
- targets_command="eval ninja -C \"${dir}\" -t targets all 2>/dev/null | cut -d: -f1"
- COMPREPLY=($(compgen -W '`${targets_command}`' -- "$cur"))
- fi
- return
-}
-complete -F _ninja_target ninja
diff --git a/misc/ci.py b/misc/ci.py
deleted file mode 100755
index 17cbf14..0000000
--- a/misc/ci.py
+++ /dev/null
@@ -1,41 +0,0 @@
-#!/usr/bin/env python3
-
-import os
-
-ignores = [
- '.git/',
- 'misc/afl-fuzz-tokens/',
- 'ninja_deps',
- 'src/depfile_parser.cc',
- 'src/lexer.cc',
-]
-
-error_count = 0
-
-def error(path, msg):
- global error_count
- error_count += 1
- print('\x1b[1;31m{}\x1b[0;31m{}\x1b[0m'.format(path, msg))
-
-for root, directory, filenames in os.walk('.'):
- for filename in filenames:
- path = os.path.join(root, filename)[2:]
- if any([path.startswith(x) for x in ignores]):
- continue
- with open(path, 'rb') as file:
- line_nr = 1
- try:
- for line in [x.decode() for x in file.readlines()]:
- if len(line) == 0 or line[-1] != '\n':
- error(path, ' missing newline at end of file.')
- if len(line) > 1:
- if line[-2] == '\r':
- error(path, ' has Windows line endings.')
- break
- if line[-2] == ' ' or line[-2] == '\t':
- error(path, ':{} has trailing whitespace.'.format(line_nr))
- line_nr += 1
- except UnicodeError:
- pass # binary file
-
-exit(error_count)
diff --git a/misc/fuchsia/build-ninja.sh b/misc/fuchsia/build-ninja.sh
deleted file mode 100755
index 0f5488d..0000000
--- a/misc/fuchsia/build-ninja.sh
+++ /dev/null
@@ -1,619 +0,0 @@
-#!/bin/bash
-# Copyright 2023 Google Inc. All Rights Reserved.
-#
-# Licensed under the Apache License, Version 2.0 (the "License");
-# you may not use this file except in compliance with the License.
-# You may obtain a copy of the License at
-#
-# http:#www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing, software
-# distributed under the License is distributed on an "AS IS" BASIS,
-# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-# See the License for the specific language governing permissions and
-# limitations under the License.
-
-set -e
-
-SCRIPT_DIR="$(dirname "$0")"
-
-die () {
- echo >&2 "ERROR: $*"
- exit 1
-}
-
-_VERBOSE=
-
-run () {
- if [[ -n "${_VERBOSE}" ]]; then
- echo "@COMMAND: $*"
- fi
- "$@"
-}
-
-# Determine Fuchsia host_tag for prebuilt binaries.
-UNAME_OS="$(uname -s)"
-UNAME_ARCH="$(uname -m)"
-
-case "${UNAME_OS}" in
- Linux)
- HOST_OS=linux
- ;;
- Darwin)
- HOST_OS=mac
- ;;
- *)
- die "Unknown host operation system: ${UNAME_OS}"
- ;;
-esac
-
-case "${UNAME_ARCH}" in
- amd64|x86_64)
- HOST_ARCH=x64
- ;;
- arm64|aarch64)
- HOST_ARCH=arm64
- ;;
- *)
- die "Unknown host CPU architecture: ${UNAME_ARCH}"
- ;;
-esac
-
-DEFAULT_JEMALLOC_GIT_URL=https://fuchsia.googlesource.com/third_party/github.com/jemalloc/jemalloc.git
-DEFAULT_JEMALLOC_TAG=5.3.0
-
-HOST_TAG="${HOST_OS}-${HOST_ARCH}"
-
-ALLOCATOR=
-ALLOCATOR_LINK_ONLY=
-BUILD_DIR=
-CLANG_BINPREFIX=
-CMAKE=cmake
-DEBUG=
-HELP=
-INCREMENTAL=
-INSTALL_PATH=
-LTO=
-NINJA=
-NO_LTO=
-NO_CLANG=
-NO_TESTS=
-STATIC=
-SYSROOT=
-TARGET_FLAGS=
-USE_LIBCXX=
-USE_MINGW64=
-USE_WINE=
-WINDOWS_SSH=${NINJA_WINDOWS_SSH:-}
-for OPT; do
- case "${OPT}" in
- --help)
- HELP=true
- ;;
- --cmake=*)
- CMAKE="${OPT#--cmake=}"
- ;;
- --debug)
- DEBUG=true
- ;;
- --static)
- STATIC=true
- ;;
- -v|--verbose)
- _VERBOSE=1
- ;;
- -i|--incremental)
- INCREMENTAL=true
- ;;
- --no-clang)
- NO_CLANG=true
- ;;
- --build-dir=*)
- BUILD_DIR="${OPT#--build-dir=}"
- ;;
- --clang-binprefix=*)
- CLANG_BINPREFIX="${OPT#--clang-binprefix=}"
- ;;
- --sysroot=*)
- SYSROOT="${OPT#--sysroot=}"
- ;;
- --fuchsia-dir=*)
- FUCHSIA_DIR="${OPT#--fuchsia-dir=}"
- CLANG_BINPREFIX="${FUCHSIA_DIR}/prebuilt/third_party/clang/${HOST_TAG}/bin"
- if [[ "${HOST_OS}" == "linux" ]]; then
- SYSROOT="${FUCHSIA_DIR}/prebuilt/third_party/sysroot/linux"
- fi
- if [[ "${HOST_OS}" == "mac" ]]; then
- # NOTE: Required to link binaries properly, otherwise on MacOS
- # the prebuilt toolchain will try to link the system libc++.a
- # which is incompatible with the libc++ headers that come with
- # the prebuilt toolchain.
- USE_LIBCXX=true
- fi
- NINJA="${FUCHSIA_DIR}/prebuilt/third_party/ninja/${HOST_TAG}/ninja"
- CMAKE="${FUCHSIA_DIR}/prebuilt/third_party/cmake/${HOST_TAG}/bin/cmake"
- ;;
- --target=*)
- TARGET_FLAGS="${OPT}"
- ;;
- --ninja=*)
- NINJA="${OPT##--ninja=}"
- ;;
- --no-tests)
- NO_TESTS=true
- ;;
- --no-lto)
- NO_LTO=true
- ;;
- --allocator=*)
- ALLOCATOR="${OPT#--allocator=}"
- ALLOCATOR_LINK_ONLY=
- ;;
- --allocator-link-only=*)
- ALLOCATOR="${OPT#--allocator-link-only=}"
- ALLOCATOR_LINK_ONLY=true
- ;;
- --jemalloc-git-url=*)
- JEMALLOC_GIT_URL="${OPT#--jemalloc-git-url=}"
- ;;
- --jemalloc-tag=*)
- JEMALLOC_TAG="${OPT#--jemalloc-tag=}"
- ;;
- --use-libc++)
- USE_LIBCXX=true
- ;;
- --install-to=*)
- INSTALL_PATH="${OPT#--install-to=}"
- ;;
- --mingw64)
- USE_MINGW64=true
- ;;
- --wine)
- USE_WINE=true
- WINDOWS_SSH=
- ;;
- --windows-ssh=*)
- WINDOWS_SSH=${OPT##--windows-ssh=}
- USE_WINE=
- ;;
- -*)
- die "Unknown option $OPT, see --help."
- ;;
- *)
- die "This script does not take parameters [$OPT]. See --help."
- ;;
- esac
-done
-
-if [[ -n "$HELP" ]]; then
- PROGNAME="$(basename "$0")"
- cat <<EOF
-Usage: ${PROGNAME} [options]
-
-Rebuild an optimized Ninja binary locally, using settings similar to the ones
-use by the Fuchsia LUCI recipe (which generates the prebuilt used by the
-Fuchsia build). This allows better performance comparisons. This means:
-
-- Enabling link-time optimization
- (except if '--no-lto' is used).
-
-- Linking against the rpmalloc or mimalloc library
- (when '--allocator=<name>' or '--allocator-link-only=<name>' is used).
-
-- Use the Fuchsia prebuilt Clang toolchain for compilation
- (when '--fuchsia-dir=FUCHSIA_DIR' is specified).
-
-The script will also rebuild the test suite and run it to validate the
-generated binary. Use '--no-tests'to disable this.
-
-Use '--install-to=PATH' to copy the generated Ninja binary to a specific
-location. It will be under 'build-cmake/ninja/build/ninja' otherwise.
-
-Use '--no-clang' to use the default C++ compiler, otherwise the script will
-use 'clang++' instead, unless '--clang-binprefix=PREFIX' is used.
-
-Use '--ninja=PATH' to use Ninja as the CMake build generator (default is Make,
-which is considerably slower).
-
-Use '--fuchsia-dir=FUCHSIA_DIR' to use the prebuilt Clang toolchain, prebuilt
-sysroot and Ninja tool.
-
-Valid options:
-
- --help Print this message.
- --cmake=PATH Specify CMake executable path to use.
- --ninja=PATH Specify Ninja executable path, to use as a CMake
- generator. This results in faster build than the
- default Make generator.
- --no-lto Disable Link Time Optimization (LTO).
- --no-tests Do not run tests.
- --incremental, -i Perform incremental build.
- --debug Generate debug version.
- --install-to=FILE Copy the resulting binary to FILE.
- --no-clang Do not use Clang, only the system 'c++' and 'ar'.
- --clang-binprefix=DIR Specify directory with Clang toolchain binaries.
- --sysroot=DIR Specify sysroot directory.
- --fuchsia-dir=DIR Specify Fuchsia directory where to find Clang and sysroot prebuilts.
- --target=ARCH Specify clang target triple for cross-compilation..
-
- --build-dir=DIR Specify directory (default is ${BUILD_DIR}).
-
- --static Generate static executable. Note that this can be
- slower due to lack of SIMD-optimized memchr() and
- related functions.
-
- --mingw64 Use mingw64 on Linux to cross-compile Windows binaries,
-
- --wine Use Wine on Linux to run the tests. Requires
- --mingw64.
-
- --windows-ssh=<hostname>
- --windows-ssh=<hostname>:<port>
- Run Windows binaries on a remote Windows machine
- with ssh. Requires --mingw64. Note: setting the
- value in the NINJA_WINDOWS_SSH environment variable
- works too.
- --allocator=rpmalloc
- --allocator=mimalloc
- --allocator=jemalloc
- Build and link an alternative malloc library, which
- in many cases results in a 10% faster binary. Note
- that the allocator static library is cached in
- a user-specific directory to be reused later
- with --allocator-link-only (see below).
-
- --allocator-link-only=<name>
- Same as --allocator=<name> but do not rebuild the
- allocator, and instead reuse a cached version from
- a previous --allocator=<name> call.
-
- --jemalloc-git-url=URL
- jemalloc source git URL
- [$DEFAULT_JEMALLOC_GIT_URL]
- --jemalloc-tag=TAG
- jemalloc git tag [$DEFAULT_JEMALLOC_TAG]
-
-
- --use-libc++ Use libc++ (incompatible with --no-clang).
-EOF
- exit 0
-fi
-
-# Directory where to store cached elements (e.g. allocator libraries, gtest, etc)
-if [[ -z "${XDG_CACHE_HOME}" ]]; then
- XDG_CACHE_HOME=${HOME}/.cache
-fi
-CACHE_DIR="${XDG_CACHE_HOME}/build-ninja-cache"
-# Location of binaries specific to a given build type.
-# For now use a single directory, later, separate based on build options to
-# speed up incremental builds when switching between build types.
-BUILD_CACHE_DIR="${CACHE_DIR}/build"
-
-# Validate --allocator value is any,
-case "${ALLOCATOR}" in
- jemalloc|rpmalloc|mimalloc|"") # Note: "" selects for ALLOCATOR not being set.
- ;;
- *)
- die "Invalid --allocator value ${ALLOCATOR}, must be one of: jemalloc, rpmalloc, mimalloc"
- ;;
-esac
-
-CMAKE_ARGS=()
-if [[ -n "${NINJA}" ]]; then
- CMAKE_ARGS+=(-GNinja -DCMAKE_MAKE_PROGRAM="${NINJA}")
-fi
-
-if [[ -n "${DEBUG}" ]]; then
- CMAKE_ARGS+=("-DCMAKE_BUILD_TYPE=Debug")
-else
- CMAKE_ARGS+=("-DCMAKE_BUILD_TYPE=Release")
-fi
-
-if [[ -n "${USE_MINGW64}" ]]; then
- if [[ -n "${ALLOCATOR}" ]]; then
- die "The --mingw64 option is not compatible with the --allocator option"
- fi
- MINGW64_TOOLCHAIN="${SCRIPT_DIR}/mingw64-toolchain.cmake"
- CMAKE_ARGS+=("-DCMAKE_TOOLCHAIN_FILE=${MINGW64_TOOLCHAIN}")
- if [[ -z "${BUILD_DIR}" ]]; then
- BUILD_DIR=build-mingw64
- fi
- if [[ -z "${USE_WINE}" && -z "${WINDOWS_SSH}" ]]; then
- echo >&2 "WARNING: Disabling tests due to lack of --wine or --windows-ssh option."
- NO_TESTS=true
- fi
-else
- if [[ -n "${USE_WINE}" ]]; then
- echo >&2 "ERROR: --wine requires --mingw64"
- exit 1
- fi
- if [[ -n "${WINDOWS_SSH}" ]]; then
- echo >&2 "ERROR: --windows-ssh requires --mingw64"
- exit 1
- fi
-fi
-
-if [[ -z "${BUILD_DIR}" ]]; then
- BUILD_DIR=build-cmake
-fi
-
-if [[ -n "${CLANG_BINPREFIX}" ]]; then
- # Ensure CLANG_BINPREFIX has a trailing separator to make
- # expressions like "${CLANG_BINPREFIX}clang" work properly.
- CLANG_BINPREFIX="${CLANG_BINPREFIX%/}/"
-fi
-
-if [[ -n "${NO_CLANG}" ]]; then
- CC=$(which cc)
- CXX=$(which c++)
- AR=$(which ar)
-else
- CC="${CLANG_BINPREFIX}clang"
- CXX="${CLANG_BINPREFIX}clang++"
- AR="${CLANG_BINPREFIX}llvm-ar"
-fi
-if [[ ! -f "${AR}" ]]; then
- unset AR
-fi
-CFLAGS="$TARGET_FLAGS"
-CXXFLAGS="$TARGET_FLAGS"
-LDFLAGS="$TARGET_FLAGS"
-
-CXXFLAGS="$CXXFLAGS -fno-exceptions -fno-rtti"
-
-if [[ -n "${STATIC}" ]]; then
- CXXFLAGS="$CXXFLAGS -static"
- LDFLAGS="$LDFLAGS -static"
-fi
-
-LIBCXX_FLAGS="-static-libstdc++"
-if [[ -z "$USE_MINGW64" ]]; then
- LIBCXX_FLAGS="$LIBCXX_FLAGS -pthread"
-fi
-
-if [[ -n "${USE_MINGW64}" && -z "${NO_LTO}" ]]; then
- echo >&2 "WARNING: Disabling LTO for mingw64 toolchain since it produces broken binaries!"
- NO_LTO=true
-fi
-
-if [[ -n "${NO_LTO}" ]]; then
- CFLAGS="$CFLAGS -fno-lto"
- CXXFLAGS="$CXXFLAGS -fno-lto"
- LDFLAGS="$LDFLAGS -fno-lto"
-fi
-
-if [[ -n "${USE_LIBCXX}" ]]; then
- LIBCXX_A="$("${CLANG_BINPREFIX}clang++" --print-file-name=libc++.a)"
- if [[ "${LIBCXX_A}" == "libc++.a" ]]; then
- # NOTE: --print-file-name=libc++.a does not work on MacOS for some reason.
- LIBCXX_A="${CLANG_BINPREFIX}../lib/libc++.a"
- if [[ ! -f "${LIBCXX_A}" ]]; then
- die "Could not find libc++.a with your Clang toolchain!"
- fi
- fi
- CXXFLAGS="$CXXFLAGS -stdlib=libc++"
- LIBCXX_FLAGS="-stdlib=libc++ $LIBCXX_A"
- if [[ -z "$USE_MINGW64" ]]; then
- LIBCXX_FLAGS="$LIBCXX_FLAGS -lpthread -ldl"
- fi
-fi
-
-# Ensure we generate smaller executables on Linux
-if [[ "$OSTYPE" =~ linux* ]]; then
- CFLAGS="$CFLAGS -fPIE"
-fi
-
-export CC CXX CFLAGS CXXFLAGS LDFLAGS
-
-if [[ -n "${SYSROOT}" ]]; then
- CMAKE_ARGS+=("-DCMAKE_SYSROOT=$SYSROOT")
-fi
-
-if [[ "${ALLOCATOR}" == "rpmalloc" ]]; then
- RPMALLOC_LIB="${BUILD_CACHE_DIR}/librpmallocwrap.a"
-
- if [[ -z "${ALLOCATOR_LINK_ONLY}" ]]; then
- if [[ -z "${NINJA}" ]]; then
- die "Ninja is required to build rpmalloc, please use --ninja or --fuchsia-dir!"
- fi
- echo "Rebuilding rpmalloc library from scratch"
- RPMALLOC_GIT_URL="https://fuchsia.googlesource.com/third_party/github.com/mjansson/rpmalloc"
- RPMALLOC_BRANCH='+upstream/develop'
- RPMALLOC_REVISION='b097fd0916500439721a114bb9cd8d14bd998683'
- RPMALLOC_ARCH=x86-64
- RPMALLOC_OS=linux
- if [[ "$RPMALLOC_OS" == "macos" ]]; then
- RPMALLOC_LIBPATH=lib/$RPMALLOC_OS/release/librpmallocwrap.a
- else
- RPMALLOC_LIBPATH=lib/$RPMALLOC_OS/release/$RPMALLOC_ARCH/librpmallocwrap.a
- fi
-
- TMPDIR="$(mktemp -d /tmp/build-rpmalloc.XXXXX)"
- (
- run cd "$TMPDIR"
- run git init
- run git fetch --tags --quiet "$RPMALLOC_GIT_URL" "$RPMALLOC_BRANCH"
- run git checkout "$RPMALLOC_REVISION"
-
- # Clang will now complain when `-funit-at-a-time` is being used.
- run sed -i -e "s|-Wno-disabled-macro-expansion'|-Wno-disabled-macro-expansion', '-Wno-ignored-optimization-argument'|g" build/ninja/clang.py
-
- # Remove -Weverything
- run sed -i -e "s|-Weverything|-Wno-pedantic|g" build/ninja/clang.py
-
- export CC CXX AR CFLAGS CXXFLAGS LDFLAGS
- run ./configure.py -c release -a $RPMALLOC_ARCH --lto
- run ${NINJA} $RPMALLOC_LIBPATH
- )
-
- run mkdir -p "$(dirname "$RPMALLOC_LIB")"
- run cp -f "${TMPDIR}/${RPMALLOC_LIBPATH}" "${RPMALLOC_LIB}"
- else
- if [[ ! -f "$RPMALLOC_LIB" ]]; then
- die "rpmalloc library is missing, use --allocator=rpmalloc instead: $RPMALLOC_LIB"
- fi
- fi
-
- echo "Using rpmalloc library: $RPMALLOC_LIB"
-fi
-
-if [[ "${ALLOCATOR}" == "mimalloc" ]]; then
- MIMALLOC_OBJ="${BUILD_CACHE_DIR}/mimalloc.o"
-
- if [[ -z "${ALLOCATOR_LINK_ONLY}" ]]; then
- echo "Rebuilding mimalloc library from scratch"
- MIMALLOC_GIT_URL="https://github.com/microsoft/mimalloc.git"
- MIMALLOC_BRANCH='master'
- MIMALLOC_REVISION='5ac9e36'
- MIALLOC_CMAKE_OPTIONS=(\
- -DCMAKE_BUILD_TYPE=Release \
- -DMI_OVERRIDE=ON \
- -DMI_BUILD_SHARED=OFF \
- -DMI_BUILD_STATIC=OFF \
- -DMI_BUILD_OBJECT=ON \
- -DMI_BUILD_TESTS=OFF \
- )
- if [[ -n "${NINJA}" ]]; then
- MIALLOC_CMAKE_OPTIONS+=(-GNinja -DCMAKE_MAKE_PROGRAM="${NINJA}")
- fi
-
- TMPDIR=$(mktemp -d /tmp/build-mimalloc.XXXXX)
- (
- run cd "$TMPDIR"
- run git init
- run git fetch --tags --quiet "$MIMALLOC_GIT_URL" "$MIMALLOC_BRANCH"
- run git checkout "$MIMALLOC_REVISION"
-
- run export CC CXX AR CFLAGS CXXFLAGS LDFLAGS
- run cmake -B build-cmake "${MIALLOC_CMAKE_OPTIONS[@]}" .
- run cmake --build build-cmake --parallel
- )
-
- run mkdir -p "$(dirname "$MIMALLOC_OBJ")"
- run cp -f "$TMPDIR/build-cmake/mimalloc.o" "$MIMALLOC_OBJ"
- else
- if [[ ! -f "$MIMALLOC_OBJ" ]]; then
- die "mimalloc library is missing, use --allocator=mimalloc: $MIMALLOC_OBJ"
- fi
- fi
-
- echo "Using mimalloc library: $MIMALLOC_OBJ"
- LDFLAGS="$MIMALLOC_OBJ $LDFLAGS"
-fi
-
-if [[ "${ALLOCATOR}" == "jemalloc" ]]; then
- JEMALLOC_LIB="${BUILD_CACHE_DIR}/libjemalloc.a"
-
- if [[ -z "${ALLOCATOR_LINK_ONLY}" ]]; then
- echo "Rebuilding jemalloc from scratch (this may take a minute or more)."
- JEMALLOC_SRC="$(mktemp -d /tmp/build-jemalloc.XXXXXX)"
- JEMALLOC_LOG="${TMPDIR:-/tmp}/jemalloc-build-$$.log"
- echo "Log file at: ${JEMALLOC_LOG}"
- if [[ -z "${JEMALLOC_TAG}" ]]; then
- JEMALLOC_TAG="${DEFAULT_JEMALLOC_TAG}"
- fi
- if [[ -z "$JEMALLOC_GIT_URL" ]]; then
- JEMALLOC_GIT_URL="${DEFAULT_JEMALLOC_GIT_URL}"
- fi
- JEMALLOC_CFLAGS="$CFLAGS -Wno-error"
- JEMALLOC_LDFLAGS="$LDFLAGS"
- if [[ -n "$LTO" ]]; then
- JEMALLOC_CFLAGS="$JEMALLOC_CFLAGS -flto"
- JEMALLOC_LDFLAGS="$JEMALLOC_LDFLAGS -flto"
- fi
- (
- run cd "${JEMALLOC_SRC}"
- run git init
- run git fetch "${JEMALLOC_GIT_URL}" refs/tags/"${JEMALLOC_TAG}" --depth=1
- run git checkout FETCH_HEAD
- CFLAGS="$JEMALLOC_CFLAGS" \
- CXXFLAGS="$JEMALLOC_CFLAGS" \
- LDFLAGS="$JEMALLOC_LDFLAGS" \
- run ./autogen.sh \
- --disable-shared \
- --enable-static \
- --disable-libdl \
- --disable-syscall \
- --disable-stats
- run make -j"$(nproc)" "lib/libjemalloc.a"
- ) > "${JEMALLOC_LOG}" 2>&1
- if [[ "$?" != 0 ]]; then
- die "jemalloc compilation failed, please look at: $JEMALLOC_LOG"
- fi
- run cp "${JEMALLOC_SRC}/lib/libjemalloc.a" "${JEMALLOC_LIB}"
- else
- if [[ ! -f "$JEMALLOC_LIB" ]]; then
- die "jemalloc library is missing, use --allocator=jemalloc: $JEMALLOC_LIB"
- fi
- fi
- echo "Using jemalloc library: $JEMALLOC_LIB"
- LDFLAGS="$JEMALLOC_LIB $LDFLAGS"
-fi
-
-LIBCXX_LDFLAGS="${LIBCXX_FLAGS}"
-LDFLAGS="$LDFLAGS $LIBCXX_LDFLAGS"
-
-# To link Ninja with rpmalloc, a top-level CMakeLists.txt, that includes the
-# Ninja one and adds a few directives, is needed.
-SRC_DIR=$(pwd 2>/dev/null)
-TEST_DIR="${BUILD_DIR}"
-run mkdir -p "${BUILD_DIR}"
-if [[ -z "${INCREMENTAL}" ]]; then
- run rm -rf "${BUILD_DIR}"/*
-fi
-BUILD_BUILD_DIR="${BUILD_DIR}"
-BUILD_SRC_DIR="${SRC_DIR}"
-if [[ -n "${RPMALLOC_LIB}" ]]; then
- BUILD_BUILD_DIR="${BUILD_DIR}/build"
- BUILD_SRC_DIR="${BUILD_DIR}"
- TEST_DIR="${BUILD_BUILD_DIR}/ninja"
- if [[ -z "${INCREMENTAL}" ]]; then
- cat > "${BUILD_DIR}"/CMakeLists.txt <<EOF
-cmake_minimum_required(VERSION 3.15)
-project(ninja-rpmalloc)
-include(CTest)
-add_subdirectory("${SRC_DIR}" ninja)
-target_link_libraries(ninja PRIVATE "${RPMALLOC_LIB}" -lpthread -ldl)
-EOF
- fi
-fi
-if [[ -z "$INCREMENTAL" ]]; then
- run "${CMAKE}" -S"${BUILD_SRC_DIR}" -B"${BUILD_BUILD_DIR}" "${CMAKE_ARGS[@]}"
-fi
-run "${CMAKE}" --build "${BUILD_BUILD_DIR}" --parallel
-if [[ -z "${NO_TESTS}" ]]; then
- if [[ -n "${USE_WINE}" ]]; then
- run "${SCRIPT_DIR}/mingw64-wine.sh" "${TEST_DIR}"/ninja_test.exe
- elif [[ -n "${WINDOWS_SSH}" ]]; then
- # Copy program binaries to Windows host with scp, then run them
- # with ssh. Print the corresponding command for verification.
- IFS=: read -ra _WINDOWS_ARGS <<< "${WINDOWS_SSH}"
- _WINDOWS_HOST="${_WINDOWS_ARGS[0]}"
- _WINDOWS_PORT="${_WINDOWS_ARGS[1]}"
- _WINDOWS_SSH_ARGS=(-t)
- _WINDOWS_SCP_ARGS=()
- if [[ -n "${_WINDOWS_PORT}" ]]; then
- _WINDOWS_SSH_ARGS+=(-p "${_WINDOWS_PORT}")
- _WINDOWS_SCP_ARGS+=(-P "${_WINDOWS_PORT}")
- fi
- # NOTE: Pass all executables because their names change all the time
- _SRC_FILES=("${BUILD_BUILD_DIR}"/*.exe)
- run scp "${_WINDOWS_SCP_ARGS[@]}" "${_SRC_FILES[@]}" "${_WINDOWS_HOST}":
- run ssh "${_WINDOWS_SSH_ARGS[@]}" "${_WINDOWS_HOST}" .\\ninja_test.exe
- else
- # Run the Ninja tests locally.
- # They are run in the test directory, but Python tests are collected from
- # the source tree, omitting those from CMake dependencies such
- # as ./<build_dir>/_deps/googletest-src/.
- #
- # The main problem with them occurs when there are several build directories
- # in the same top-level dir (e.g. `build-cmake/` and `build-mingw64/`
- # because pytest wouldi, by default, collect tests from both directories on
- # the next build, resulting in a very weird Python module import failure!
- mapfile -t PYTHON_TESTS <<< "$(find "${SRC_DIR}" -name '*_test.py' | grep -v _deps/)"
- (run cd "${TEST_DIR}" && run ./ninja_test && run pytest "${PYTHON_TESTS[@]}")
- fi
-fi
-if [[ -n "${INSTALL_PATH}" ]]; then
- run cp "${TEST_DIR}"/ninja "${INSTALL_PATH}"
-fi
diff --git a/misc/fuchsia/mingw64-toolchain.cmake b/misc/fuchsia/mingw64-toolchain.cmake
deleted file mode 100644
index 43ae329..0000000
--- a/misc/fuchsia/mingw64-toolchain.cmake
+++ /dev/null
@@ -1,27 +0,0 @@
-# Copyright 2023 The Fuchsia Authors. All rights reserved.
-# Use of this source code is governed by a BSD-style license that can be
-# found in the LICENSE file.
-#
-# Sample toolchain file for building for Windows from an Ubuntu Linux system.
-#
-# Typical usage:
-# *) install cross compiler: `sudo apt-get install mingw-w64`
-# *) cd build
-# *) cmake -DCMAKE_TOOLCHAIN_FILE=~/mingw-w64-x86_64.cmake ..
-
-set(CMAKE_SYSTEM_NAME Windows)
-set(TOOLCHAIN_PREFIX x86_64-w64-mingw32)
-
-# cross compilers to use for C, C++ and Fortran
-set(CMAKE_C_COMPILER ${TOOLCHAIN_PREFIX}-gcc-win32)
-set(CMAKE_CXX_COMPILER ${TOOLCHAIN_PREFIX}-g++-win32)
-set(CMAKE_Fortran_COMPILER ${TOOLCHAIN_PREFIX}-gfortran)
-set(CMAKE_RC_COMPILER ${TOOLCHAIN_PREFIX}-windres)
-
-# target environment on the build host system
-set(CMAKE_FIND_ROOT_PATH /usr/${TOOLCHAIN_PREFIX})
-
-# modify default behavior of FIND_XXX() commands
-set(CMAKE_FIND_ROOT_PATH_MODE_PROGRAM NEVER)
-set(CMAKE_FIND_ROOT_PATH_MODE_LIBRARY ONLY)
-set(CMAKE_FIND_ROOT_PATH_MODE_INCLUDE ONLY)
diff --git a/misc/fuchsia/mingw64-wine.sh b/misc/fuchsia/mingw64-wine.sh
deleted file mode 100755
index 26de6b9..0000000
--- a/misc/fuchsia/mingw64-wine.sh
+++ /dev/null
@@ -1,24 +0,0 @@
-#!/bin/bash
-# Copyright 2023 Google Inc. All Rights Reserved.
-#
-# Licensed under the Apache License, Version 2.0 (the "License");
-# you may not use this file except in compliance with the License.
-# You may obtain a copy of the License at
-#
-# http:#www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing, software
-# distributed under the License is distributed on an "AS IS" BASIS,
-# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-# See the License for the specific language governing permissions and
-# limitations under the License.
-
-set -e
-
-# Ensure WINEPATH is set to a value that allows the mingw64-generated
-# binaries to find runtime libraries for libstdc++ and others properly.
-if [[ -z "${WINEPATH}" ]]; then
- export WINEPATH="/usr/x86_64-w64-mingw32/lib/;/usr/lib/gcc/x86_64-w64-mingw32/12-posix"
- echo "Setting WINEPATH=\"${WINEPATH}\""
-fi
-wine "$@"
diff --git a/misc/fuchsia/sync-branch.py b/misc/fuchsia/sync-branch.py
deleted file mode 100755
index f8685bf..0000000
--- a/misc/fuchsia/sync-branch.py
+++ /dev/null
@@ -1,554 +0,0 @@
-#!/usr/bin/env python3
-# Copyright 2023 The Fuchsia Authors. All rights reserved.
-# Use of this source code is governed by a BSD-style license that can be
-# found in the LICENSE file.
-
-"""General tool to manage sync-branches as described in Fuchsia RFC-0153.
-
-This tool provides several commands that simplify creation and management
-of sync branches. A typical use case would be:
-
- 1) Use the `create` command to create a new local sync-branch, with
- the right cherry-picked commits in it.
-
- 2) Optional: resolve any conflicts that happen during the cherry-pick
- operation launched by the `create` command. Alternatively, it is possible
- to rebase the sync branch, for example to re-order commits or update
- documentation.
-
- 3) Use the `rebase` command to rebase the current sync-branch on top of
- the current upstream reference.
-
- 4) Optional: resolve any conflicts that happen during the rebase operation.
-
- 5) Use the `merge` command to merge the sync branch into the
- main development branch.
-
-Use `<command> --help` for command-specific details.
-
-"""
-
-import argparse
-import json
-import shlex
-import shutil
-import subprocess
-import sys
-import time
-from pathlib import Path
-from typing import Any, Iterable, List, Sequence
-
-_DEFAULT_UPSTREAM_REF = "origin/upstream/master"
-_DEFAULT_DEV_BRANCH = "fuchsia-rfc-0153"
-_DEFAULT_SYNC_BRANCH_NAME = "sync-branch-" + time.strftime("%Y-%m-%d", time.gmtime())
-
-
-_VERBOSE = False
-
-
-def log(msg: str):
- if _VERBOSE:
- print("LOG: " + msg, file=sys.stderr)
-
-
-def cmd_args_to_list(cmd_args: Iterable[Any]) -> Sequence[str]:
- return [str(c) for c in cmd_args]
-
-
-def cmd_quote(cmd_args: Iterable[Any]) -> str:
- return " ".join(shlex.quote(str(c)) for c in cmd_args)
-
-
-def run_command(cmd_args: Iterable[Any], **kwargs) -> subprocess.CompletedProcess:
- log("CMD: " + cmd_quote(cmd_args))
- return subprocess.run(cmd_args_to_list(cmd_args), **kwargs)
-
-
-def get_command_output(cmd_args: Iterable[Any], **kwargs) -> str:
- assert "capture_output" not in kwargs
- assert "text" not in kwargs
- kwargs["capture_output"] = True
- kwargs["text"] = True
- ret = run_command(cmd_args, **kwargs)
- ret.check_returncode()
- return ret.stdout.strip()
-
-
-def read_file(path: Path) -> str:
- with open(path) as f:
- return f.read()
-
-
-def write_file(path: Path, content: str):
- path.parent.mkdir(exist_ok=True, parents=True)
- with open(path, "w") as f:
- f.write(content)
-
-
-class CommandError(Exception):
- pass
-
-
-class GitDirectory(object):
- """A Git directory."""
-
- def __init__(self, git_dir: Path):
- assert git_dir.is_dir(), "Not a directory: %s" % git_dir
- assert (git_dir / ".git").is_dir(), (
- "Not a git directory (missing .git/): %s" % git_dir
- )
- self._git_dir = git_dir
- self._cfg_dir = git_dir / ".git" / "sync_branch"
-
- @property
- def git_dir(self) -> Path:
- return self._git_dir
-
- @property
- def cfg_dir(self) -> Path:
- return self._cfg_dir
-
- @property
- def cfg_file_path(self) -> Path:
- return self._cfg_dir / "config.json"
-
- def cmd(self, args: List[Any]):
- ret = run_command(["git", "-C", self._git_dir] + args)
- ret.check_returncode()
-
- def cmd_output(self, args: List) -> str:
- return get_command_output(["git", "-C", self._git_dir] + args)
-
-
-class PrintingGitDirectory(GitDirectory):
- """A GitDirectory subclass that prints commands instead of running them."""
-
- def __init__(self, parent: GitDirectory):
- self._parent = parent
-
- def cmd(self, args: Iterable[Any]) -> None:
- print(
- "git -C %s %s"
- % (self._parent.git_dir, " ".join(shlex.quote(a) for a in args))
- )
-
-
-class SyncBranchConfig(object):
- def __init__(self, git_dir: GitDirectory):
- self.git_dir = git_dir
- self.upstream_ref: str = _DEFAULT_UPSTREAM_REF
- self.dev_branch_name: str = _DEFAULT_DEV_BRANCH
- self.sync_branch_name: str = _DEFAULT_SYNC_BRANCH_NAME
- self.stem_commit: str = ""
- self.upstream_commit: str = ""
- self.src_commits: List[str] = []
-
- def init_from_create_args(self, args: argparse.Namespace) -> None:
- if args.name:
- self.sync_branch_name = args.name
- if args.upstream_ref:
- self.upstream_ref = args.upstream_ref
- if args.dev_branch:
- self.dev_branch_name = args.dev_branch
-
- # Verify that the branch does not exist yet.
- g = self.git_dir
- has_sync_branch = False
- on_sync_branch = False
- current_branch = g.cmd_output(["branch", "--show-current"])
- if current_branch and current_branch == self.sync_branch_name:
- has_sync_branch = True
- on_sync_branch = True
- else:
- has_sync_branch = bool(
- g.cmd_output(["branch", "--list", self.sync_branch_name])
- )
-
- if has_sync_branch:
- if not args.force:
- raise CommandError(
- "Cannot create new sync-branch over current one, use --force to override!"
- )
- if on_sync_branch:
- g.cmd(["checkout", "--force", self.dev_branch_name])
- g.cmd(["branch", "-D", self.sync_branch_name])
-
- self.upstream_commit = self.git_dir.cmd_output(["rev-parse", self.upstream_ref])
-
- # Compute stem commit, this the first common ancestor of
- # the upstream and development branch. For example in:
- #
- # upstream --A1-------A2---A3
- # \ \
- # \ +--B1"--B2"--C2"
- # \ \ \
- # \ B1'--B2' \
- # \ \ \
- # dev -------------B1---B2---------C1--C2--D1--D2
- #
- # The stem commit is A2
- #
- self.stem_commit = g.cmd_output(
- ["merge-base", self.upstream_ref, self.dev_branch_name]
- ).strip()
-
- if self.stem_commit == self.upstream_commit and not args.force:
- raise CommandError(
- "All upstream commits in current branch, no sync branch needed!"
- )
-
- # Compute source commits
- #
- # To do that, use --ancestry-path to limit the result to
- # commits that belong only to the most recent sync branch
- # is required.
- #
- # For example, without --ancestry-path, a command like
- # `git rev-list STEM..dev` would return the following commits
- # from the previous example history, which contains multiple
- # sync branches originating from the same stem:
- #
- # upstream A2
- # \
- # +--B1"--B2"--C2"
- # \ \
- # B1'--B2' \
- # \ \
- # dev C1--C2--D1--D2
- #
- # By using --ancestry-path=C2", the result is
- # limited to only the commits from the most recent sync branch, i.e.:
- #
- # upstream A2
- # \
- # +--B1"--B2"--C2"
- # \
- # \
- # \
- # dev D1--D2
- #
- # The commit to pass to --ancestry-path is the _second_
- # parent of the most recent merge in the dev branch.
- #
- # To find it, the command below uses `rev-list --merges --format=%P`
- # to print two lines per merge commit that is in the common ancestry
- # of the stem and the dev HEAD.
- #
- # In the example above, the stem is A2, the HEAD is D2, and
- # they share two merge commits C1 and D1, and the commands
- # prints the following:
- #
- # commit <D1>
- # <C2> <C2">
- # commit <C1>
- # <B2> <B2'>
- #
- # Taking the last hash of the second line of output gives us
- # the commit value for --ancestry-path.
- merge_commits_lines = g.cmd_output(
- [
- "rev-list",
- "%s..%s" % (self.upstream_ref, self.dev_branch_name),
- "--merges",
- "--format=%P",
- ]
- ).splitlines()
-
- if len(merge_commits_lines) == 0:
- # No merge commit means we never created a sync branch
- # in the past. In that case, do not use --ancestry-path
- ancestry_path_args = []
- else:
- if len(merge_commits_lines) < 2:
- raise CommandError(
- "Invalid git rev-list output!\n% %s\n"
- % " \n".join(merge_commits_lines)
- )
-
- parents = merge_commits_lines[1].split(" ")
- if len(parents) != 2:
- # We really don't know how to handle merges with more
- # than 2 parents. These were not created by the sync-branch tool.
- raise CommandError(
- "Most recent merge has more than 2 parents!\n %s\n"
- % " \n".join(merge_commits_lines)
- )
-
- ancestry_path_args = ["--ancestry-path=" + parents[1]]
-
- # Now list all the source commits.
- self.src_commits = g.cmd_output(
- [
- "rev-list",
- "--reverse",
- "--no-merges",
- "--pretty=oneline",
- "%s..%s" % (self.stem_commit, self.dev_branch_name),
- ]
- + ancestry_path_args
- ).splitlines()
-
- def has_config_file(self) -> bool:
- return self.git_dir.cfg_file_path.exists()
-
- def read_config_file(self):
- c = json.loads(read_file(self.git_dir.cfg_file_path))
- self.upstream_ref = c["upstream_ref"]
- self.dev_branch_name = c["dev_branch_name"]
- self.sync_branch_name = c["sync_branch_name"]
- self.stem_commit = c["stem_commit"]
- self.src_commits = c["src_commits"]
-
- def write_config_file(self) -> None:
- c = {
- "upstream_ref": self.upstream_ref,
- "dev_branch_name": self.dev_branch_name,
- "sync_branch_name": self.sync_branch_name,
- "stem_commit": self.stem_commit,
- "src_commits": self.src_commits,
- }
- write_file(self.git_dir.cfg_file_path, json.dumps(c, sort_keys=True, indent=2))
-
- def clear_config_file(self) -> None:
- cfg_dir = self.git_dir.cfg_dir
- if cfg_dir.exists():
- shutil.rmtree(cfg_dir)
-
-
-def get_git_directory(args: argparse.Namespace) -> GitDirectory:
- # Compute git directory.
- if args.git_dir:
- git_dir = Path(args.git_dir)
- else:
- git_dir = Path.cwd()
-
- if not git_dir.is_dir():
- raise CommandError("Not a directory: %s" % git_dir)
- if not (git_dir / ".git").is_dir():
- raise CommandError("Not a git directory (missing .git): %s" % git_dir)
-
- return GitDirectory(git_dir)
-
-
-def command_create(args: argparse.Namespace) -> None:
- git_dir = get_git_directory(args)
- sbc = SyncBranchConfig(git_dir)
- sbc.init_from_create_args(args)
- sbc.write_config_file()
-
- if args.print_only:
- git_dir = PrintingGitDirectory(git_dir)
-
- # Create a tag pointing to the stem commit, for debugging.
- git_dir.cmd(["tag", "-f", "SYNC_BRANCH_STEM", sbc.stem_commit])
- git_dir.cmd(["checkout", "-b", sbc.sync_branch_name, sbc.stem_commit])
- git_dir.cmd(["cherry-pick"] + [c.split(" ")[0] for c in sbc.src_commits])
-
-
-def command_rebase(args: argparse.Namespace) -> None:
- git_dir = get_git_directory(args)
- sbc = SyncBranchConfig(git_dir)
- if not sbc.has_config_file():
- raise CommandError("No current sync branch, please use `create` command first!")
-
- sbc.read_config_file()
- if args.print_only:
- git_dir = PrintingGitDirectory(git_dir)
-
- cmd_args = [
- "rebase",
- "--onto",
- sbc.upstream_ref,
- sbc.stem_commit,
- sbc.sync_branch_name,
- ]
- git_dir.cmd(cmd_args)
-
-
-def command_merge(args: argparse.Namespace) -> None:
- git_dir = get_git_directory(args)
- sbc = SyncBranchConfig(git_dir)
- if not sbc.has_config_file():
- raise CommandError("No current sync branch, please use `create` command first!")
-
- sbc.read_config_file()
- if args.print_only:
- git_dir = PrintingGitDirectory(git_dir)
-
- git_dir.cmd(["checkout", sbc.dev_branch_name])
-
- merge_cmd = ["merge", "--no-ff", "-X", "theirs", sbc.sync_branch_name]
- if args.no_commit:
- merge_cmd += ["--no-commit"]
-
- git_dir.cmd(merge_cmd)
-
-
-def main():
- parser = argparse.ArgumentParser(
- description=__doc__, formatter_class=argparse.RawTextHelpFormatter
- )
-
- parser.add_argument("--verbose", action="store_true", help="Enable verbose mode")
- parser.add_argument("--git-dir", help="Specify git directory.")
- parser.add_argument(
- "--print-only",
- action="store_true",
- help="Only print the git commands, do not run them.",
- )
-
- subparsers = parser.add_subparsers(required=True, help="Available commands")
-
- parser_create = subparsers.add_parser(
- "create",
- help="Create new local sync-branch",
- formatter_class=argparse.RawTextHelpFormatter,
- description=r"""
-Create a new local sync branch, which will start at the 'stem' commit that
-is common to both the upstream and development branches, and will include
-all commits between them (as cherry picks).
-
-For example, consider the following initial state:
-
- upstream ---A1--A2--A3
- \
- dev - - - - - B1--B2--B3
-
-The command will create a new branch starting from A2 that contains
-cherry picks of B1..B3, as in:
-
- sync-branch B1'--B2'--B3'
- /
- upstream ---A1--A2--A3
- \
- dev - - - - - B1--B2--B3
-
-Note that the cherry-pick command launched by `create` may fail in case of
-rare conflicts. If this happens, just fix the issue manually then use
-`git cherry-pick --continue` to complete the operation,
-
-After the cherry pick has completed, the user is free to rebase the branch,
-for example to reorder commits, or update documentation, before invoking
-the `rebase` command.
-
-Note that `create` will not work if a local sync branch already exists, or
-when upstream commits are already reachable in the developement branch.
-These conditions can be overriden by using the `--force` option.
-
-""",
- )
-
- parser_create.add_argument(
- "--force", action="store_true", help="Discard any existing sync branch."
- )
- parser_create.add_argument(
- "--name",
- default=_DEFAULT_SYNC_BRANCH_NAME,
- help=f"Specify sync branch name (default {_DEFAULT_SYNC_BRANCH_NAME})",
- )
- parser_create.add_argument(
- "--upstream-ref",
- default=_DEFAULT_UPSTREAM_REF,
- help=f"Specify upstream branch reference (default {_DEFAULT_UPSTREAM_REF})",
- )
- parser_create.add_argument(
- "--dev-branch",
- default=_DEFAULT_DEV_BRANCH,
- help=f"Specify development branch (default {_DEFAULT_DEV_BRANCH})",
- )
- parser_create.set_defaults(func=command_create)
-
- parser_rebase = subparsers.add_parser(
- "rebase",
- help="Rebase current sync-branch on top of upstream.",
- formatter_class=argparse.RawTextHelpFormatter,
- description=r"""
-Rebase the current sync branch on top of the current upstream commit.
-This must be called after the completion of a `create` operation.
-
-For example consider the following state resulting from a previous
-`create` operation:
-
- sync-branch B1'--B2'--B3'
- /
- upstream ---A1--A2--A3
- \
- dev - - - - - B1--B2--B3
-
-After the rebase, the sync branch should be something like:
-
- sync-branch B1''--B2''--B3''
- /
- upstream ---A1--A2--A3
- \
- dev - - - - - B1--B2--B3
-
-Where both B3 and B3'' correspond to the new desired sources.
-
-After the rebase, the user is free to inspect the branch, rebase it or do
-any necessary cleanups, and verify that everything still works as expected.
-
-The user will then launch the `merge` command to merge the result into the
-main development branch.
-
-""",
- )
- parser_rebase.set_defaults(func=command_rebase)
-
- parser_merge = subparsers.add_parser(
- "merge",
- help="Merge sync-branch to main development branch.",
- formatter_class=argparse.RawTextHelpFormatter,
- description=r"""
-Merge the current sync branch into the main development branch. This should
-only happen after a successful `rebase` command invocation.
-
-For example consider the following state resulting from a previous
-`rebase` operation:
-
- sync-branch B1''--B2''--B3''
- /
- upstream ---A1--A2--A3
- \
- dev - - - - - B1--B2--B3
-
-The end result will be:
-
- upstream ---A1--A2--A3
- \
- sync-branch B1''--B2''--B3''
- \
- dev - - - - - B1--B2--B3-----------C1
-
-Where C1 is the new merge commit on the main development branch.
-
-Note that A3 will become the stem commit for future 'create'
-operations.
-
-""",
- )
- parser_merge.add_argument(
- "--no-commit", action="store_true", help="Do not commit the merge."
- )
- parser_merge.set_defaults(func=command_merge)
-
- args = parser.parse_args()
-
- if args.verbose:
- global _VERBOSE
- _VERBOSE = True
-
- try:
- args.func(args)
- except CommandError as e:
- print(str(e), file=sys.stderr)
- return 1
- except subprocess.CalledProcessError as e:
- print("%s:\n%s\n" % (e, e.stderr), file=sys.stderr)
- return e.returncode
-
- return 0
-
-
-if __name__ == "__main__":
- sys.exit(main())
diff --git a/misc/inherited-fds.ninja b/misc/inherited-fds.ninja
deleted file mode 100644
index 671155e..0000000
--- a/misc/inherited-fds.ninja
+++ /dev/null
@@ -1,23 +0,0 @@
-# This build file prints out a list of open file descriptors in
-# Ninja subprocesses, to help verify we don't accidentally leak
-# any.
-
-# Because one fd leak was in the code managing multiple subprocesses,
-# this test brings up multiple subprocesses and then dumps the fd
-# table of the last one.
-
-# Use like: ./ninja -f misc/inherited-fds.ninja
-
-rule sleep
- command = sleep 10000
-
-rule dump
- command = sleep 1; ls -l /proc/self/fd; exit 1
-
-build all: phony a b c d e
-
-build a: sleep
-build b: sleep
-build c: sleep
-build d: sleep
-build e: dump
diff --git a/misc/long-slow-build.ninja b/misc/long-slow-build.ninja
deleted file mode 100644
index 46af6ba..0000000
--- a/misc/long-slow-build.ninja
+++ /dev/null
@@ -1,38 +0,0 @@
-# An input file for running a "slow" build.
-# Use like: ninja -f misc/long-slow-build.ninja all
-
-rule sleep
- command = sleep 1
- description = SLEEP $out
-
-build 0: sleep README
-build 1: sleep README
-build 2: sleep README
-build 3: sleep README
-build 4: sleep README
-build 5: sleep README
-build 6: sleep README
-build 7: sleep README
-build 8: sleep README
-build 9: sleep README
-build 10: sleep 0
-build 11: sleep 1
-build 12: sleep 2
-build 13: sleep 3
-build 14: sleep 4
-build 15: sleep 5
-build 16: sleep 6
-build 17: sleep 7
-build 18: sleep 8
-build 19: sleep 9
-build 20: sleep 10
-build 21: sleep 11
-build 22: sleep 12
-build 23: sleep 13
-build 24: sleep 14
-build 25: sleep 15
-build 26: sleep 16
-build 27: sleep 17
-build 28: sleep 18
-build 29: sleep 19
-build all: phony 20 21 22 23 24 25 26 27 28 29
diff --git a/misc/manifest_fuzzer.cc b/misc/manifest_fuzzer.cc
deleted file mode 100644
index 0e1261a..0000000
--- a/misc/manifest_fuzzer.cc
+++ /dev/null
@@ -1,41 +0,0 @@
-// Copyright 2020 Google Inc. All Rights Reserved.
-//
-// Licensed under the Apache License, Version 2.0 (the "License");
-// you may not use this file except in compliance with the License.
-// You may obtain a copy of the License at
-//
-// http://www.apache.org/licenses/LICENSE-2.0
-//
-// Unless required by applicable law or agreed to in writing, software
-// distributed under the License is distributed on an "AS IS" BASIS,
-// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-// See the License for the specific language governing permissions and
-// limitations under the License.
-
-#include "stdint.h"
-#include <string>
-#include "disk_interface.h"
-#include "state.h"
-#include "manifest_parser.h"
-#include <filesystem>
-
-extern "C" int LLVMFuzzerTestOneInput(const uint8_t *data, size_t size)
-{
- char build_file[256];
- sprintf(build_file, "/tmp/build.ninja");
- FILE *fp = fopen(build_file, "wb");
- if (!fp)
- return 0;
- fwrite(data, size, 1, fp);
- fclose(fp);
-
- std::string err;
- RealDiskInterface disk_interface;
- State state;
- ManifestParser parser(&state, &disk_interface);
-
- parser.Load("/tmp/build.ninja", &err);
-
- std::__fs::filesystem::remove_all("/tmp/build.ninja");
- return 0;
-}
diff --git a/misc/measure.py b/misc/measure.py
deleted file mode 100755
index f3825ef..0000000
--- a/misc/measure.py
+++ /dev/null
@@ -1,54 +0,0 @@
-#!/usr/bin/env python3
-
-# Copyright 2011 Google Inc. All Rights Reserved.
-#
-# Licensed under the Apache License, Version 2.0 (the "License");
-# you may not use this file except in compliance with the License.
-# You may obtain a copy of the License at
-#
-# http://www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing, software
-# distributed under the License is distributed on an "AS IS" BASIS,
-# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-# See the License for the specific language governing permissions and
-# limitations under the License.
-
-"""measure the runtime of a command by repeatedly running it.
-"""
-
-import time
-import subprocess
-import sys
-
-devnull = open('/dev/null', 'w')
-
-def run(cmd, repeat=10):
- print('sampling:', end=' ')
- sys.stdout.flush()
-
- samples = []
- for _ in range(repeat):
- start = time.time()
- subprocess.call(cmd, stdout=devnull, stderr=devnull)
- end = time.time()
- dt = (end - start) * 1000
- print('%dms' % int(dt), end=' ')
- sys.stdout.flush()
- samples.append(dt)
- print()
-
- # We're interested in the 'pure' runtime of the code, which is
- # conceptually the smallest time we'd see if we ran it enough times
- # such that it got the perfect time slices / disk cache hits.
- best = min(samples)
- # Also print how varied the outputs were in an attempt to make it
- # more obvious if something has gone terribly wrong.
- err = sum(s - best for s in samples) / float(len(samples))
- print('estimate: %dms (mean err %.1fms)' % (best, err))
-
-if __name__ == '__main__':
- if len(sys.argv) < 2:
- print('usage: measure.py command args...')
- sys.exit(1)
- run(cmd=sys.argv[1:])
diff --git a/misc/ninja-mode.el b/misc/ninja-mode.el
deleted file mode 100644
index 8b975d5..0000000
--- a/misc/ninja-mode.el
+++ /dev/null
@@ -1,85 +0,0 @@
-;;; ninja-mode.el --- Major mode for editing .ninja files -*- lexical-binding: t -*-
-
-;; Package-Requires: ((emacs "24"))
-
-;; Copyright 2011 Google Inc. All Rights Reserved.
-;;
-;; Licensed under the Apache License, Version 2.0 (the "License");
-;; you may not use this file except in compliance with the License.
-;; You may obtain a copy of the License at
-;;
-;; http://www.apache.org/licenses/LICENSE-2.0
-;;
-;; Unless required by applicable law or agreed to in writing, software
-;; distributed under the License is distributed on an "AS IS" BASIS,
-;; WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-;; See the License for the specific language governing permissions and
-;; limitations under the License.
-
-;;; Commentary:
-
-;; Simple emacs mode for editing .ninja files.
-;; Just some syntax highlighting for now.
-
-;;; Code:
-
-(defvar ninja-keywords
- `((,(concat "^" (regexp-opt '("rule" "build" "subninja" "include"
- "pool" "default")
- 'words))
- . font-lock-keyword-face)
- ("\\([[:alnum:]_]+\\) =" 1 font-lock-variable-name-face)
- ;; Variable expansion.
- ("$[[:alnum:]_]+" . font-lock-variable-name-face)
- ("${[[:alnum:]._]+}" . font-lock-variable-name-face)
- ;; Rule names
- ("rule +\\([[:alnum:]_.-]+\\)" 1 font-lock-function-name-face)
- ;; Build Statement - highlight the rule used,
- ;; allow for escaped $,: in outputs.
- ("build +\\(?:[^:$\n]\\|$[:$]\\)+ *: *\\([[:alnum:]_.-]+\\)"
- 1 font-lock-function-name-face)))
-
-(defvar ninja-mode-syntax-table
- (let ((table (make-syntax-table)))
- (modify-syntax-entry ?\" "." table)
- table)
- "Syntax table used in `ninja-mode'.")
-
-(defun ninja-syntax-propertize (start end)
- (save-match-data
- (goto-char start)
- (while (search-forward "#" end t)
- (let ((match-pos (match-beginning 0)))
- (when (and
- ;; Is it the first non-white character on the line?
- (eq match-pos (save-excursion (back-to-indentation) (point)))
- (save-excursion
- (goto-char (line-end-position 0))
- (or
- ;; If we're continuing the previous line, it's not a
- ;; comment.
- (not (eq ?$ (char-before)))
- ;; Except if the previous line is a comment as well, as the
- ;; continuation dollar is ignored then.
- (nth 4 (syntax-ppss)))))
- (put-text-property match-pos (1+ match-pos) 'syntax-table '(11))
- (let ((line-end (line-end-position)))
- ;; Avoid putting properties past the end of the buffer.
- ;; Otherwise we get an `args-out-of-range' error.
- (unless (= line-end (1+ (buffer-size)))
- (put-text-property line-end (1+ line-end) 'syntax-table '(12)))))))))
-
-;;;###autoload
-(define-derived-mode ninja-mode prog-mode "ninja"
- (set (make-local-variable 'comment-start) "#")
- (set (make-local-variable 'parse-sexp-lookup-properties) t)
- (set (make-local-variable 'syntax-propertize-function) #'ninja-syntax-propertize)
- (setq font-lock-defaults '(ninja-keywords)))
-
-;; Run ninja-mode for files ending in .ninja.
-;;;###autoload
-(add-to-list 'auto-mode-alist '("\\.ninja$" . ninja-mode))
-
-(provide 'ninja-mode)
-
-;;; ninja-mode.el ends here
diff --git a/misc/ninja.vim b/misc/ninja.vim
deleted file mode 100644
index c1ffd50..0000000
--- a/misc/ninja.vim
+++ /dev/null
@@ -1,87 +0,0 @@
-" ninja build file syntax.
-" Language: ninja build file as described at
-" http://ninja-build.org/manual.html
-" Version: 1.5
-" Last Change: 2018/04/05
-" Maintainer: Nicolas Weber <nicolasweber@gmx.de>
-" Version 1.4 of this script is in the upstream vim repository and will be
-" included in the next vim release. If you change this, please send your change
-" upstream.
-
-" ninja lexer and parser are at
-" https://github.com/ninja-build/ninja/blob/master/src/lexer.in.cc
-" https://github.com/ninja-build/ninja/blob/master/src/manifest_parser.cc
-
-if exists("b:current_syntax")
- finish
-endif
-
-let s:cpo_save = &cpo
-set cpo&vim
-
-syn case match
-
-" Comments are only matched when the # is at the beginning of the line (with
-" optional whitespace), as long as the prior line didn't end with a $
-" continuation.
-syn match ninjaComment /\(\$\n\)\@<!\_^\s*#.*$/ contains=@Spell
-
-" Toplevel statements are the ones listed here and
-" toplevel variable assignments (ident '=' value).
-" lexer.in.cc, ReadToken() and manifest_parser.cc, Parse()
-syn match ninjaKeyword "^build\>"
-syn match ninjaKeyword "^rule\>"
-syn match ninjaKeyword "^pool\>"
-syn match ninjaKeyword "^default\>"
-syn match ninjaKeyword "^include\>"
-syn match ninjaKeyword "^subninja\>"
-
-" Both 'build' and 'rule' begin a variable scope that ends
-" on the first line without indent. 'rule' allows only a
-" limited set of magic variables, 'build' allows general
-" let assignments.
-" manifest_parser.cc, ParseRule()
-syn region ninjaRule start="^rule" end="^\ze\S" contains=TOP transparent
-syn keyword ninjaRuleCommand contained containedin=ninjaRule command
- \ deps depfile description generator
- \ pool restat rspfile rspfile_content
-
-syn region ninjaPool start="^pool" end="^\ze\S" contains=TOP transparent
-syn keyword ninjaPoolCommand contained containedin=ninjaPool depth
-
-" Strings are parsed as follows:
-" lexer.in.cc, ReadEvalString()
-" simple_varname = [a-zA-Z0-9_-]+;
-" varname = [a-zA-Z0-9_.-]+;
-" $$ -> $
-" $\n -> line continuation
-" '$ ' -> escaped space
-" $simple_varname -> variable
-" ${varname} -> variable
-
-syn match ninjaDollar "\$\$"
-syn match ninjaWrapLineOperator "\$$"
-syn match ninjaSimpleVar "\$[a-zA-Z0-9_-]\+"
-syn match ninjaVar "\${[a-zA-Z0-9_.-]\+}"
-
-" operators are:
-" variable assignment =
-" rule definition :
-" implicit dependency |
-" order-only dependency ||
-syn match ninjaOperator "\(=\|:\||\|||\)\ze\s"
-
-hi def link ninjaComment Comment
-hi def link ninjaKeyword Keyword
-hi def link ninjaRuleCommand Statement
-hi def link ninjaPoolCommand Statement
-hi def link ninjaDollar ninjaOperator
-hi def link ninjaWrapLineOperator ninjaOperator
-hi def link ninjaOperator Operator
-hi def link ninjaSimpleVar ninjaVar
-hi def link ninjaVar Identifier
-
-let b:current_syntax = "ninja"
-
-let &cpo = s:cpo_save
-unlet s:cpo_save
diff --git a/misc/ninja_syntax.py b/misc/ninja_syntax.py
deleted file mode 100644
index ca73b5b..0000000
--- a/misc/ninja_syntax.py
+++ /dev/null
@@ -1,199 +0,0 @@
-#!/usr/bin/python
-
-# Copyright 2011 Google Inc. All Rights Reserved.
-#
-# Licensed under the Apache License, Version 2.0 (the "License");
-# you may not use this file except in compliance with the License.
-# You may obtain a copy of the License at
-#
-# http://www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing, software
-# distributed under the License is distributed on an "AS IS" BASIS,
-# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-# See the License for the specific language governing permissions and
-# limitations under the License.
-
-"""Python module for generating .ninja files.
-
-Note that this is emphatically not a required piece of Ninja; it's
-just a helpful utility for build-file-generation systems that already
-use Python.
-"""
-
-import re
-import textwrap
-
-def escape_path(word):
- return word.replace('$ ', '$$ ').replace(' ', '$ ').replace(':', '$:')
-
-class Writer(object):
- def __init__(self, output, width=78):
- self.output = output
- self.width = width
-
- def newline(self):
- self.output.write('\n')
-
- def comment(self, text):
- for line in textwrap.wrap(text, self.width - 2, break_long_words=False,
- break_on_hyphens=False):
- self.output.write('# ' + line + '\n')
-
- def variable(self, key, value, indent=0):
- if value is None:
- return
- if isinstance(value, list):
- value = ' '.join(filter(None, value)) # Filter out empty strings.
- self._line('%s = %s' % (key, value), indent)
-
- def pool(self, name, depth):
- self._line('pool %s' % name)
- self.variable('depth', depth, indent=1)
-
- def rule(self, name, command, description=None, depfile=None,
- generator=False, pool=None, restat=False, rspfile=None,
- rspfile_content=None, deps=None):
- self._line('rule %s' % name)
- self.variable('command', command, indent=1)
- if description:
- self.variable('description', description, indent=1)
- if depfile:
- self.variable('depfile', depfile, indent=1)
- if generator:
- self.variable('generator', '1', indent=1)
- if pool:
- self.variable('pool', pool, indent=1)
- if restat:
- self.variable('restat', '1', indent=1)
- if rspfile:
- self.variable('rspfile', rspfile, indent=1)
- if rspfile_content:
- self.variable('rspfile_content', rspfile_content, indent=1)
- if deps:
- self.variable('deps', deps, indent=1)
-
- def build(self, outputs, rule, inputs=None, implicit=None, order_only=None,
- variables=None, implicit_outputs=None, pool=None, dyndep=None):
- outputs = as_list(outputs)
- out_outputs = [escape_path(x) for x in outputs]
- all_inputs = [escape_path(x) for x in as_list(inputs)]
-
- if implicit:
- implicit = [escape_path(x) for x in as_list(implicit)]
- all_inputs.append('|')
- all_inputs.extend(implicit)
- if order_only:
- order_only = [escape_path(x) for x in as_list(order_only)]
- all_inputs.append('||')
- all_inputs.extend(order_only)
- if implicit_outputs:
- implicit_outputs = [escape_path(x)
- for x in as_list(implicit_outputs)]
- out_outputs.append('|')
- out_outputs.extend(implicit_outputs)
-
- self._line('build %s: %s' % (' '.join(out_outputs),
- ' '.join([rule] + all_inputs)))
- if pool is not None:
- self._line(' pool = %s' % pool)
- if dyndep is not None:
- self._line(' dyndep = %s' % dyndep)
-
- if variables:
- if isinstance(variables, dict):
- iterator = iter(variables.items())
- else:
- iterator = iter(variables)
-
- for key, val in iterator:
- self.variable(key, val, indent=1)
-
- return outputs
-
- def include(self, path):
- self._line('include %s' % path)
-
- def subninja(self, path):
- self._line('subninja %s' % path)
-
- def default(self, paths):
- self._line('default %s' % ' '.join(as_list(paths)))
-
- def _count_dollars_before_index(self, s, i):
- """Returns the number of '$' characters right in front of s[i]."""
- dollar_count = 0
- dollar_index = i - 1
- while dollar_index > 0 and s[dollar_index] == '$':
- dollar_count += 1
- dollar_index -= 1
- return dollar_count
-
- def _line(self, text, indent=0):
- """Write 'text' word-wrapped at self.width characters."""
- leading_space = ' ' * indent
- while len(leading_space) + len(text) > self.width:
- # The text is too wide; wrap if possible.
-
- # Find the rightmost space that would obey our width constraint and
- # that's not an escaped space.
- available_space = self.width - len(leading_space) - len(' $')
- space = available_space
- while True:
- space = text.rfind(' ', 0, space)
- if (space < 0 or
- self._count_dollars_before_index(text, space) % 2 == 0):
- break
-
- if space < 0:
- # No such space; just use the first unescaped space we can find.
- space = available_space - 1
- while True:
- space = text.find(' ', space + 1)
- if (space < 0 or
- self._count_dollars_before_index(text, space) % 2 == 0):
- break
- if space < 0:
- # Give up on breaking.
- break
-
- self.output.write(leading_space + text[0:space] + ' $\n')
- text = text[space+1:]
-
- # Subsequent lines are continuations, so indent them.
- leading_space = ' ' * (indent+2)
-
- self.output.write(leading_space + text + '\n')
-
- def close(self):
- self.output.close()
-
-
-def as_list(input):
- if input is None:
- return []
- if isinstance(input, list):
- return input
- return [input]
-
-
-def escape(string):
- """Escape a string such that it can be embedded into a Ninja file without
- further interpretation."""
- assert '\n' not in string, 'Ninja syntax does not allow newlines'
- # We only have one special metacharacter: '$'.
- return string.replace('$', '$$')
-
-
-def expand(string, vars, local_vars={}):
- """Expand a string containing $vars as Ninja would.
-
- Note: doesn't handle the full Ninja variable syntax, but it's enough
- to make configure.py's use of it work.
- """
- def exp(m):
- var = m.group(1)
- if var == '$':
- return '$'
- return local_vars.get(var, vars.get(var, ''))
- return re.sub(r'\$(\$|\w*)', exp, string)
diff --git a/misc/ninja_syntax_test.py b/misc/ninja_syntax_test.py
deleted file mode 100755
index 61fb177..0000000
--- a/misc/ninja_syntax_test.py
+++ /dev/null
@@ -1,191 +0,0 @@
-#!/usr/bin/env python3
-
-# Copyright 2011 Google Inc. All Rights Reserved.
-#
-# Licensed under the Apache License, Version 2.0 (the "License");
-# you may not use this file except in compliance with the License.
-# You may obtain a copy of the License at
-#
-# http://www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing, software
-# distributed under the License is distributed on an "AS IS" BASIS,
-# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-# See the License for the specific language governing permissions and
-# limitations under the License.
-
-import unittest
-
-try:
- from StringIO import StringIO
-except ImportError:
- from io import StringIO
-
-import ninja_syntax
-
-LONGWORD = 'a' * 10
-LONGWORDWITHSPACES = 'a'*5 + '$ ' + 'a'*5
-INDENT = ' '
-
-class TestLineWordWrap(unittest.TestCase):
- def setUp(self):
- self.out = StringIO()
- self.n = ninja_syntax.Writer(self.out, width=8)
-
- def test_single_long_word(self):
- # We shouldn't wrap a single long word.
- self.n._line(LONGWORD)
- self.assertEqual(LONGWORD + '\n', self.out.getvalue())
-
- def test_few_long_words(self):
- # We should wrap a line where the second word is overlong.
- self.n._line(' '.join(['x', LONGWORD, 'y']))
- self.assertEqual(' $\n'.join(['x',
- INDENT + LONGWORD,
- INDENT + 'y']) + '\n',
- self.out.getvalue())
-
- def test_comment_wrap(self):
- # Filenames should not be wrapped
- self.n.comment('Hello /usr/local/build-tools/bin')
- self.assertEqual('# Hello\n# /usr/local/build-tools/bin\n',
- self.out.getvalue())
-
- def test_short_words_indented(self):
- # Test that indent is taking into account when breaking subsequent lines.
- # The second line should not be ' to tree', as that's longer than the
- # test layout width of 8.
- self.n._line('line_one to tree')
- self.assertEqual('''\
-line_one $
- to $
- tree
-''',
- self.out.getvalue())
-
- def test_few_long_words_indented(self):
- # Check wrapping in the presence of indenting.
- self.n._line(' '.join(['x', LONGWORD, 'y']), indent=1)
- self.assertEqual(' $\n'.join([' ' + 'x',
- ' ' + INDENT + LONGWORD,
- ' ' + INDENT + 'y']) + '\n',
- self.out.getvalue())
-
- def test_escaped_spaces(self):
- self.n._line(' '.join(['x', LONGWORDWITHSPACES, 'y']))
- self.assertEqual(' $\n'.join(['x',
- INDENT + LONGWORDWITHSPACES,
- INDENT + 'y']) + '\n',
- self.out.getvalue())
-
- def test_fit_many_words(self):
- self.n = ninja_syntax.Writer(self.out, width=78)
- self.n._line('command = cd ../../chrome; python ../tools/grit/grit/format/repack.py ../out/Debug/obj/chrome/chrome_dll.gen/repack/theme_resources_large.pak ../out/Debug/gen/chrome/theme_resources_large.pak', 1)
- self.assertEqual('''\
- command = cd ../../chrome; python ../tools/grit/grit/format/repack.py $
- ../out/Debug/obj/chrome/chrome_dll.gen/repack/theme_resources_large.pak $
- ../out/Debug/gen/chrome/theme_resources_large.pak
-''',
- self.out.getvalue())
-
- def test_leading_space(self):
- self.n = ninja_syntax.Writer(self.out, width=14) # force wrapping
- self.n.variable('foo', ['', '-bar', '-somethinglong'], 0)
- self.assertEqual('''\
-foo = -bar $
- -somethinglong
-''',
- self.out.getvalue())
-
- def test_embedded_dollar_dollar(self):
- self.n = ninja_syntax.Writer(self.out, width=15) # force wrapping
- self.n.variable('foo', ['a$$b', '-somethinglong'], 0)
- self.assertEqual('''\
-foo = a$$b $
- -somethinglong
-''',
- self.out.getvalue())
-
- def test_two_embedded_dollar_dollars(self):
- self.n = ninja_syntax.Writer(self.out, width=17) # force wrapping
- self.n.variable('foo', ['a$$b', '-somethinglong'], 0)
- self.assertEqual('''\
-foo = a$$b $
- -somethinglong
-''',
- self.out.getvalue())
-
- def test_leading_dollar_dollar(self):
- self.n = ninja_syntax.Writer(self.out, width=14) # force wrapping
- self.n.variable('foo', ['$$b', '-somethinglong'], 0)
- self.assertEqual('''\
-foo = $$b $
- -somethinglong
-''',
- self.out.getvalue())
-
- def test_trailing_dollar_dollar(self):
- self.n = ninja_syntax.Writer(self.out, width=14) # force wrapping
- self.n.variable('foo', ['a$$', '-somethinglong'], 0)
- self.assertEqual('''\
-foo = a$$ $
- -somethinglong
-''',
- self.out.getvalue())
-
-class TestBuild(unittest.TestCase):
- def setUp(self):
- self.out = StringIO()
- self.n = ninja_syntax.Writer(self.out)
-
- def test_variables_dict(self):
- self.n.build('out', 'cc', 'in', variables={'name': 'value'})
- self.assertEqual('''\
-build out: cc in
- name = value
-''',
- self.out.getvalue())
-
- def test_variables_list(self):
- self.n.build('out', 'cc', 'in', variables=[('name', 'value')])
- self.assertEqual('''\
-build out: cc in
- name = value
-''',
- self.out.getvalue())
-
- def test_implicit_outputs(self):
- self.n.build('o', 'cc', 'i', implicit_outputs='io')
- self.assertEqual('''\
-build o | io: cc i
-''',
- self.out.getvalue())
-
-class TestExpand(unittest.TestCase):
- def test_basic(self):
- vars = {'x': 'X'}
- self.assertEqual('foo', ninja_syntax.expand('foo', vars))
-
- def test_var(self):
- vars = {'xyz': 'XYZ'}
- self.assertEqual('fooXYZ', ninja_syntax.expand('foo$xyz', vars))
-
- def test_vars(self):
- vars = {'x': 'X', 'y': 'YYY'}
- self.assertEqual('XYYY', ninja_syntax.expand('$x$y', vars))
-
- def test_space(self):
- vars = {}
- self.assertEqual('x y z', ninja_syntax.expand('x$ y$ z', vars))
-
- def test_locals(self):
- vars = {'x': 'a'}
- local_vars = {'x': 'b'}
- self.assertEqual('a', ninja_syntax.expand('$x', vars))
- self.assertEqual('b', ninja_syntax.expand('$x', vars, local_vars))
-
- def test_double(self):
- self.assertEqual('a b$c', ninja_syntax.expand('a$ b$$c', {}))
-
-if __name__ == '__main__':
- unittest.main()
diff --git a/misc/oss-fuzz/build.sh b/misc/oss-fuzz/build.sh
deleted file mode 100644
index 4328feb..0000000
--- a/misc/oss-fuzz/build.sh
+++ /dev/null
@@ -1,29 +0,0 @@
-#!/bin/bash -eu
-# Copyright 2020 Google Inc.
-#
-# Licensed under the Apache License, Version 2.0 (the "License");
-# you may not use this file except in compliance with the License.
-# You may obtain a copy of the License at
-#
-# http://www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing, software
-# distributed under the License is distributed on an "AS IS" BASIS,
-# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-# See the License for the specific language governing permissions and
-# limitations under the License.
-#
-################################################################################
-
-cmake -Bbuild-cmake -H.
-cmake --build build-cmake
-
-cd $SRC/ninja/misc
-
-$CXX $CXXFLAGS -fdiagnostics-color -I/src/ninja/src -o fuzzer.o -c manifest_fuzzer.cc
-
-find .. -name "*.o" -exec ar rcs fuzz_lib.a {} \;
-
-$CXX $CXXFLAGS $LIB_FUZZING_ENGINE fuzzer.o -o $OUT/fuzzer fuzz_lib.a
-
-zip $OUT/fuzzer_seed_corpus.zip $SRC/sample_ninja_build
diff --git a/misc/oss-fuzz/sample_ninja_build b/misc/oss-fuzz/sample_ninja_build
deleted file mode 100644
index 7b513be..0000000
--- a/misc/oss-fuzz/sample_ninja_build
+++ /dev/null
@@ -1,14 +0,0 @@
-# build.ninja
-cc = clang
-cflags = -Weverything
-
-rule compile
- command = $cc $cflags -c $in -o $out
-
-rule link
- command = $cc $in -o $out
-
-build hello.o: compile hello.c
-build hello: link hello.o
-
-default hello
diff --git a/misc/output_test.py b/misc/output_test.py
deleted file mode 100755
index 18c84d9..0000000
--- a/misc/output_test.py
+++ /dev/null
@@ -1,168 +0,0 @@
-#!/usr/bin/env python3
-
-"""Runs ./ninja and checks if the output is correct.
-
-In order to simulate a smart terminal it uses the 'script' command.
-"""
-
-import os
-import platform
-import subprocess
-import sys
-import tempfile
-import unittest
-
-default_env = dict(os.environ)
-for varname in ('NINJA_STATUS', 'NINJA_STATUS_MAX_COMMANDS', 'NINJA_PERSISTENT_MODE', 'CLICOLOR_FORCE'):
- if varname in default_env:
- del default_env[varname]
-
-default_env['TERM'] = ''
-NINJA_PATH = os.path.abspath('./ninja')
-
-def run(build_ninja, flags='', pipe=False, env=default_env):
- with tempfile.TemporaryDirectory() as d:
- with open(os.path.join(d, 'build.ninja'), 'w') as f:
- f.write(build_ninja)
- f.flush()
- ninja_cmd = '{} {}'.format(NINJA_PATH, flags)
- try:
- if pipe:
- output = subprocess.check_output([ninja_cmd], shell=True, cwd=d, env=env)
- elif platform.system() == 'Darwin':
- output = subprocess.check_output(['script', '-q', '/dev/null', 'bash', '-c', ninja_cmd],
- cwd=d, env=env)
- else:
- output = subprocess.check_output(['script', '-qfec', ninja_cmd, '/dev/null'],
- cwd=d, env=env)
- except subprocess.CalledProcessError as err:
- sys.stdout.buffer.write(err.output)
- raise err
- final_output = ''
- for line in output.decode('utf-8').splitlines(True):
- if len(line) > 0 and line[-1] == '\r':
- continue
- final_output += line.replace('\r', '')
- return final_output
-
-@unittest.skipIf(platform.system() == 'Windows', 'These test methods do not work on Windows')
-class Output(unittest.TestCase):
- BUILD_SIMPLE_ECHO = '\n'.join((
- 'rule echo',
- ' command = printf "do thing"',
- ' description = echo $out',
- '',
- 'build a: echo',
- '',
- ))
-
- def test_issue_1418(self):
- self.assertEqual(run(
-'''rule echo
- command = sleep $delay && echo $out
- description = echo $out
-
-build a: echo
- delay = 3
-build b: echo
- delay = 2
-build c: echo
- delay = 1
-''', '-j3'),
-'''[1/3] echo c\x1b[K
-c
-[2/3] echo b\x1b[K
-b
-[3/3] echo a\x1b[K
-a
-''')
-
- def test_issue_1214(self):
- print_red = '''rule echo
- command = printf '\x1b[31mred\x1b[0m'
- description = echo $out
-
-build a: echo
-'''
- # Only strip color when ninja's output is piped.
- self.assertEqual(run(print_red),
-'''[1/1] echo a\x1b[K
-\x1b[31mred\x1b[0m
-''')
- self.assertEqual(run(print_red, pipe=True),
-'''[1/1] echo a
-red
-''')
- # Even in verbose mode, colors should still only be stripped when piped.
- self.assertEqual(run(print_red, flags='-v'),
-'''[1/1] printf '\x1b[31mred\x1b[0m'
-\x1b[31mred\x1b[0m
-''')
- self.assertEqual(run(print_red, flags='-v', pipe=True),
-'''[1/1] printf '\x1b[31mred\x1b[0m'
-red
-''')
-
- # CLICOLOR_FORCE=1 can be used to disable escape code stripping.
- env = default_env.copy()
- env['CLICOLOR_FORCE'] = '1'
- self.assertEqual(run(print_red, pipe=True, env=env),
-'''[1/1] echo a
-\x1b[31mred\x1b[0m
-''')
-
- def test_issue_1966(self):
- self.assertEqual(run(
-'''rule cat
- command = cat $rspfile $rspfile > $out
- rspfile = cat.rsp
- rspfile_content = a b c
-
-build a: cat
-''', '-j3'),
-'''[1/1] cat cat.rsp cat.rsp > a\x1b[K
-''')
-
-
- def test_pr_1685(self):
- # Running those tools without .ninja_deps and .ninja_log shouldn't fail.
- self.assertEqual(run('', flags='-t recompact'), '')
- self.assertEqual(run('', flags='-t restat'), '')
-
- def test_status(self):
- self.assertEqual(run(''), 'ninja: no work to do.\n')
- self.assertEqual(run('', pipe=True), 'ninja: no work to do.\n')
-
- def test_ninja_status_default(self):
- 'Do we show the default status by default?'
- self.assertEqual(run(Output.BUILD_SIMPLE_ECHO), '[1/1] echo a\x1b[K\ndo thing\n')
-
- def test_ninja_status_quiet(self):
- 'Do we suppress the status information when --quiet is specified?'
- output = run(Output.BUILD_SIMPLE_ECHO, flags='--quiet')
- self.assertEqual(output, 'do thing\n')
-
- def test_entering_directory_on_stdout(self):
- output = run(Output.BUILD_SIMPLE_ECHO, flags='-C$PWD', pipe=True)
- self.assertEqual(output.splitlines()[0][:25], "ninja: Entering directory")
-
- def test_tool_inputs(self):
- plan = '''
-rule cat
- command = cat $in $out
-build out1 : cat in1
-build out2 : cat in2 out1
-build out3 : cat out2 out1 | implicit || order_only
-'''
- self.assertEqual(run(plan, flags='-t inputs out3'),
-'''implicit
-in1
-in2
-order_only
-out1
-out2
-''')
-
-
-if __name__ == '__main__':
- unittest.main()
diff --git a/misc/packaging/ninja.spec b/misc/packaging/ninja.spec
deleted file mode 100644
index 36e5181..0000000
--- a/misc/packaging/ninja.spec
+++ /dev/null
@@ -1,42 +0,0 @@
-Summary: Ninja is a small build system with a focus on speed.
-Name: ninja
-Version: %{ver}
-Release: %{rel}%{?dist}
-Group: Development/Tools
-License: Apache 2.0
-URL: https://github.com/ninja-build/ninja
-Source0: %{name}-%{version}-%{rel}.tar.gz
-BuildRoot: %{_tmppath}/%{name}-%{version}-%{rel}
-
-BuildRequires: asciidoc
-
-%description
-Ninja is yet another build system. It takes as input the interdependencies of files (typically source code and output executables) and
-orchestrates building them, quickly.
-
-Ninja joins a sea of other build systems. Its distinguishing goal is to be fast. It is born from my work on the Chromium browser project,
-which has over 30,000 source files and whose other build systems (including one built from custom non-recursive Makefiles) can take ten
-seconds to start building after changing one file. Ninja is under a second.
-
-%prep
-%setup -q -n %{name}-%{version}-%{rel}
-
-%build
-echo Building..
-./configure.py --bootstrap
-./ninja manual
-
-%install
-mkdir -p %{buildroot}%{_bindir} %{buildroot}%{_docdir}
-cp -p ninja %{buildroot}%{_bindir}/
-
-%files
-%defattr(-, root, root)
-%doc COPYING README.md doc/manual.html
-%{_bindir}/*
-
-%clean
-rm -rf %{buildroot}
-
-#The changelog is built automatically from Git history
-%changelog
diff --git a/misc/packaging/rpmbuild.sh b/misc/packaging/rpmbuild.sh
deleted file mode 100755
index 9b74c65..0000000
--- a/misc/packaging/rpmbuild.sh
+++ /dev/null
@@ -1,29 +0,0 @@
-#!/bin/bash
-
-echo Building ninja RPMs..
-GITROOT=$(git rev-parse --show-toplevel)
-cd $GITROOT
-
-VER=1.0
-REL=$(git rev-parse --short HEAD)git
-RPMTOPDIR=$GITROOT/rpm-build
-echo "Ver: $VER, Release: $REL"
-
-# Create tarball
-mkdir -p $RPMTOPDIR/{SOURCES,SPECS}
-git archive --format=tar --prefix=ninja-${VER}-${REL}/ HEAD | gzip -c > $RPMTOPDIR/SOURCES/ninja-${VER}-${REL}.tar.gz
-
-# Convert git log to RPM's ChangeLog format (shown with rpm -qp --changelog <rpm file>)
-sed -e "s/%{ver}/$VER/" -e "s/%{rel}/$REL/" misc/packaging/ninja.spec > $RPMTOPDIR/SPECS/ninja.spec
-git log --format="* %cd %aN%n- (%h) %s%d%n" --date=local | sed -r 's/[0-9]+:[0-9]+:[0-9]+ //' >> $RPMTOPDIR/SPECS/ninja.spec
-
-# Build SRC and binary RPMs
-rpmbuild --quiet \
- --define "_topdir $RPMTOPDIR" \
- --define "_rpmdir $PWD" \
- --define "_srcrpmdir $PWD" \
- --define '_rpmfilename %%{NAME}-%%{VERSION}-%%{RELEASE}.%%{ARCH}.rpm' \
- -ba $RPMTOPDIR/SPECS/ninja.spec &&
-
-rm -rf $RPMTOPDIR &&
-echo Done
diff --git a/misc/persistent_mode_test.py b/misc/persistent_mode_test.py
deleted file mode 100755
index f526d99..0000000
--- a/misc/persistent_mode_test.py
+++ /dev/null
@@ -1,254 +0,0 @@
-#!/usr/bin/env python3
-
-"""Runs ./ninja in persistent mode and checks if the output is correct.
-
-In order to simulate a smart terminal it uses the 'script' command.
-"""
-import os
-import platform
-import subprocess
-import sys
-import tempfile
-import unittest
-
-default_env = dict(os.environ)
-for varname in ("NINJA_STATUS", "NINJA_STATUS_MAX_COMMANDS", "CLICOLOR_FORCE"):
- if varname in default_env:
- del default_env[varname]
-
-default_env["TERM"] = ""
-default_env["NINJA_PERSISTENT_MODE"] = "1"
-default_env["DEBUG_PERSISTENT_SERVICE_LOG_FILE"] = "/tmp/DLOG"
-default_env["NINJA_PERSISTENT_LOG_FILE"] = "/tmp/ELOG"
-NINJA_PATH = os.path.abspath("./ninja")
-
-
-class NinjaPersistentInstance(object):
- def __init__(self, build_ninja: str):
- """Initialize instance.
-
- This creates a temporary directory, cd to it, then writes a build.ninja
- plan in it that will be used by future run() calls.
-
- Args:
- build_ninja: The content of a "build.ninja" file
- """
- self._server_running = False
- self._tempdir = tempfile.TemporaryDirectory(ignore_cleanup_errors=True)
- self._dir = self._tempdir.name
- self.write_build_ninja(build_ninja)
-
- def write_build_ninja(self, build_ninja):
- """Rewrite the build.ninja file with new content."""
- self.write_file("build.ninja", build_ninja)
-
- def write_file(self, path, content):
- with open(os.path.join(self._dir, path), "w") as f:
- f.write(content)
- f.flush()
-
- def close(self):
- """Close the instance, ensuring the persistent server is stopped."""
- if self._server_running:
- self.run(flags="-t server stop")
- self._server_running = False
-
- if self._tempdir:
- self._tempdir.cleanup()
- self._tempdir = None
-
- def server_status(self):
- return self.run(flags="-t server status")
-
- def has_server(self):
- status = self.server_status()
- return status == f"server is running for {self._dir}\n"
-
- def server_pid(self):
- """Return PID of server process, or -1 if there is none."""
- return int(self.run(flags="-t server pid").strip())
-
- def run(self, flags="", pipe=False, env=default_env):
- """Run a Ninja command."""
- self._server_running = True
- ninja_cmd = "{} {}".format(NINJA_PATH, flags).strip()
- try:
- if pipe:
- output = subprocess.check_output(
- ninja_cmd, shell=True, cwd=self._dir, env=env
- )
- elif platform.system() == "Darwin":
- output = subprocess.check_output(
- ["script", "-q", "/dev/null", "bash", "-c", ninja_cmd],
- cwd=self._dir,
- env=env,
- )
- else:
- output = subprocess.check_output(
- ["script", "-qfec", ninja_cmd, "/dev/null"], cwd=self._dir, env=env
- )
- except subprocess.CalledProcessError as err:
- sys.stdout.buffer.write(err.output)
- raise err
-
- final_output = ""
- for line in output.decode("utf-8").splitlines(True):
- if len(line) > 0 and line[-1] == "\r":
- continue
- final_output += line.replace("\r", "")
- return final_output
-
- def __enter__(self):
- return self
-
- def __exit__(self, exc_type, exc_val, exc_tb):
- self.close()
- return False
-
-
-@unittest.skipIf(
- platform.system() == "Windows", "These test methods do not work on Windows"
-)
-class Output(unittest.TestCase):
- BUILD_SIMPLE_ECHO = "\n".join(
- (
- "rule echo",
- ' command = printf "do thing"',
- " description = echo $out",
- "",
- "build a: echo",
- "",
- )
- )
-
- def test_start_persistent_server(self):
- with NinjaPersistentInstance(Output.BUILD_SIMPLE_ECHO) as ninja:
- self.assertFalse(ninja.has_server())
- self.assertEqual(ninja.run(), "[1/1] echo a\x1b[K\ndo thing\n")
- self.assertTrue(ninja.has_server())
- server_pid = ninja.server_pid()
- self.assertNotEqual(server_pid, -1)
- self.assertEqual(ninja.run(), "[1/1] echo a\x1b[K\ndo thing\n")
- self.assertTrue(ninja.has_server())
- self.assertEqual(server_pid, ninja.server_pid())
- self.assertEqual(ninja.run(), "[1/1] echo a\x1b[K\ndo thing\n")
- self.assertTrue(ninja.has_server())
- self.assertEqual(server_pid, ninja.server_pid())
-
- def test_stop_persistent_server(self):
- with NinjaPersistentInstance(Output.BUILD_SIMPLE_ECHO) as ninja:
- self.assertFalse(ninja.has_server())
- self.assertEqual(ninja.run(), "[1/1] echo a\x1b[K\ndo thing\n")
- self.assertTrue(ninja.has_server())
-
- server_pid = ninja.server_pid()
- self.assertNotEqual(server_pid, -1)
-
- ninja.run(flags="-t server stop")
- self.assertFalse(ninja.has_server())
- self.assertEqual(ninja.server_pid(), -1)
-
- self.assertEqual(ninja.run(), "[1/1] echo a\x1b[K\ndo thing\n")
- self.assertTrue(ninja.has_server())
- new_server_pid = ninja.server_pid()
- self.assertNotEqual(new_server_pid, -1)
- self.assertNotEqual(new_server_pid, server_pid)
-
- self.assertEqual(ninja.run(), "[1/1] echo a\x1b[K\ndo thing\n")
- self.assertTrue(ninja.has_server())
- self.assertEqual(new_server_pid, ninja.server_pid())
-
- def test_ninja_status(self):
- env = default_env.copy()
- env["NINJA_STATUS"] = "STATUS [%f/%t] "
- with NinjaPersistentInstance(Output.BUILD_SIMPLE_ECHO) as ninja:
- self.assertFalse(ninja.has_server())
- non_persistent_env = env.copy()
- non_persistent_env["NINJA_PERSISTENT_MODE"] = "0"
- self.assertEqual(
- ninja.run(env=non_persistent_env),
- "STATUS [1/1] echo a\x1b[K\ndo thing\n",
- )
- self.assertFalse(ninja.has_server())
-
- env["NINJA_PERSISTENT_STATUS"] = "1"
- self.assertEqual(
- ninja.run(env=env), "STATUS [1/1] echo a\x1b[K\ndo thing\n"
- )
- self.assertTrue(ninja.has_server())
-
- env["NINJA_STATUS"] = "NOPE"
- self.assertEqual(ninja.run(env=env), "NOPEecho a\x1b[K\ndo thing\n")
- self.assertTrue(ninja.has_server())
-
- def test_environment_variables(self):
- build_ninja = """
-rule print_var
- command = printf "%s=[%s]" $varname $$$varname
- description = print $varname
-
-build foo: print_var
- varname = foo
-"""
- env = default_env.copy()
- if "foo" in env:
- del env["foo"]
-
- with NinjaPersistentInstance(build_ninja) as ninja:
- self.assertFalse(ninja.has_server())
- self.assertEqual(ninja.run(env=env), "[1/1] print foo\x1b[K\nfoo=[]\n")
- self.assertTrue(ninja.has_server())
- self.assertEqual(ninja.run(env=env), "[1/1] print foo\x1b[K\nfoo=[]\n")
- self.assertTrue(ninja.has_server())
- env["foo"] = "FOO"
- self.assertEqual(ninja.run(env=env), "[1/1] print foo\x1b[K\nfoo=[FOO]\n")
- self.assertTrue(ninja.has_server())
- del env["foo"]
- self.assertEqual(ninja.run(env=env), "[1/1] print foo\x1b[K\nfoo=[]\n")
- self.assertTrue(ninja.has_server())
-
- def test_server_restart_on_input_file_change(self):
- with NinjaPersistentInstance(Output.BUILD_SIMPLE_ECHO) as ninja:
- self.assertFalse(ninja.has_server())
- self.assertEqual(ninja.run(), "[1/1] echo a\x1b[K\ndo thing\n")
- self.assertTrue(ninja.has_server())
-
- ninja.write_build_ninja(Output.BUILD_SIMPLE_ECHO)
- server_pid = ninja.server_pid()
-
- self.assertEqual(ninja.run(), "[1/1] echo a\x1b[K\ndo thing\n")
- self.assertTrue(ninja.has_server())
- self.assertNotEqual(server_pid, ninja.server_pid())
-
- def test_server_restart_on_generator_run(self):
- build_ninja = """
-rule echo
- command = printf "do thing"
- description = echo $out
-
-build a: echo
-
-rule regen
- command = cp input.depfile $out.d && touch build.ninja
- depfile = $out.d
- generator = 1
-
-build build.ninja: regen
-"""
- with NinjaPersistentInstance(build_ninja) as ninja:
- # Launch the server.
- ninja.write_file("CMakeLists.txt", "# Fake original config file")
- ninja.write_file("input.depfile", "build.ninja: CMakeLists.txt")
- self.assertFalse(ninja.has_server())
- ninja.run(flags="a")
- self.assertTrue(ninja.has_server())
- server_pid = ninja.server_pid()
-
- ninja.write_file("CMakeLists.txt", "# Fake update to config file")
- ninja.run(flags="a")
- self.assertTrue(ninja.has_server())
- self.assertNotEqual(ninja.server_pid(), server_pid)
-
-
-if __name__ == "__main__":
- unittest.main()
diff --git a/misc/write_fake_manifests.py b/misc/write_fake_manifests.py
deleted file mode 100755
index bf9cf7d..0000000
--- a/misc/write_fake_manifests.py
+++ /dev/null
@@ -1,272 +0,0 @@
-#!/usr/bin/env python3
-
-"""Writes large manifest files, for manifest parser performance testing.
-
-The generated manifest files are (eerily) similar in appearance and size to the
-ones used in the Chromium project.
-
-Usage:
- python misc/write_fake_manifests.py outdir # Will run for about 5s.
-
-The program contains a hardcoded random seed, so it will generate the same
-output every time it runs. By changing the seed, it's easy to generate many
-different sets of manifest files.
-"""
-
-import argparse
-import contextlib
-import os
-import random
-import sys
-
-import ninja_syntax
-
-
-def paretoint(avg, alpha):
- """Returns a random integer that's avg on average, following a power law.
- alpha determines the shape of the power curve. alpha has to be larger
- than 1. The closer alpha is to 1, the higher the variation of the returned
- numbers."""
- return int(random.paretovariate(alpha) * avg / (alpha / (alpha - 1)))
-
-
-# Based on http://neugierig.org/software/chromium/class-name-generator.html
-def moar(avg_options, p_suffix):
- kStart = ['render', 'web', 'browser', 'tab', 'content', 'extension', 'url',
- 'file', 'sync', 'content', 'http', 'profile']
- kOption = ['view', 'host', 'holder', 'container', 'impl', 'ref',
- 'delegate', 'widget', 'proxy', 'stub', 'context',
- 'manager', 'master', 'watcher', 'service', 'file', 'data',
- 'resource', 'device', 'info', 'provider', 'internals', 'tracker',
- 'api', 'layer']
- kOS = ['win', 'mac', 'aura', 'linux', 'android', 'unittest', 'browsertest']
- num_options = min(paretoint(avg_options, alpha=4), 5)
- # The original allows kOption to repeat as long as no consecutive options
- # repeat. This version doesn't allow any option repetition.
- name = [random.choice(kStart)] + random.sample(kOption, num_options)
- if random.random() < p_suffix:
- name.append(random.choice(kOS))
- return '_'.join(name)
-
-
-class GenRandom(object):
- def __init__(self, src_dir):
- self.seen_names = set([None])
- self.seen_defines = set([None])
- self.src_dir = src_dir
-
- def _unique_string(self, seen, avg_options=1.3, p_suffix=0.1):
- s = None
- while s in seen:
- s = moar(avg_options, p_suffix)
- seen.add(s)
- return s
-
- def _n_unique_strings(self, n):
- seen = set([None])
- return [self._unique_string(seen, avg_options=3, p_suffix=0.4)
- for _ in range(n)]
-
- def target_name(self):
- return self._unique_string(p_suffix=0, seen=self.seen_names)
-
- def path(self):
- return os.path.sep.join([
- self._unique_string(self.seen_names, avg_options=1, p_suffix=0)
- for _ in range(1 + paretoint(0.6, alpha=4))])
-
- def src_obj_pairs(self, path, name):
- num_sources = paretoint(55, alpha=2) + 1
- return [(os.path.join(self.src_dir, path, s + '.cc'),
- os.path.join('obj', path, '%s.%s.o' % (name, s)))
- for s in self._n_unique_strings(num_sources)]
-
- def defines(self):
- return [
- '-DENABLE_' + self._unique_string(self.seen_defines).upper()
- for _ in range(paretoint(20, alpha=3))]
-
-
-LIB, EXE = 0, 1
-class Target(object):
- def __init__(self, gen, kind):
- self.name = gen.target_name()
- self.dir_path = gen.path()
- self.ninja_file_path = os.path.join(
- 'obj', self.dir_path, self.name + '.ninja')
- self.src_obj_pairs = gen.src_obj_pairs(self.dir_path, self.name)
- if kind == LIB:
- self.output = os.path.join('lib' + self.name + '.a')
- elif kind == EXE:
- self.output = os.path.join(self.name)
- self.defines = gen.defines()
- self.deps = []
- self.kind = kind
- self.has_compile_depends = random.random() < 0.4
-
-
-def write_target_ninja(ninja, target, src_dir):
- compile_depends = None
- if target.has_compile_depends:
- compile_depends = os.path.join(
- 'obj', target.dir_path, target.name + '.stamp')
- ninja.build(compile_depends, 'stamp', target.src_obj_pairs[0][0])
- ninja.newline()
-
- ninja.variable('defines', target.defines)
- ninja.variable('includes', '-I' + src_dir)
- ninja.variable('cflags', ['-Wall', '-fno-rtti', '-fno-exceptions'])
- ninja.newline()
-
- for src, obj in target.src_obj_pairs:
- ninja.build(obj, 'cxx', src, implicit=compile_depends)
- ninja.newline()
-
- deps = [dep.output for dep in target.deps]
- libs = [dep.output for dep in target.deps if dep.kind == LIB]
- if target.kind == EXE:
- ninja.variable('libs', libs)
- if sys.platform == "darwin":
- ninja.variable('ldflags', '-Wl,-pie')
- link = { LIB: 'alink', EXE: 'link'}[target.kind]
- ninja.build(target.output, link, [obj for _, obj in target.src_obj_pairs],
- implicit=deps)
-
-
-def write_sources(target, root_dir):
- need_main = target.kind == EXE
-
- includes = []
-
- # Include siblings.
- for cc_filename, _ in target.src_obj_pairs:
- h_filename = os.path.basename(os.path.splitext(cc_filename)[0] + '.h')
- includes.append(h_filename)
-
- # Include deps.
- for dep in target.deps:
- for cc_filename, _ in dep.src_obj_pairs:
- h_filename = os.path.basename(
- os.path.splitext(cc_filename)[0] + '.h')
- includes.append("%s/%s" % (dep.dir_path, h_filename))
-
- for cc_filename, _ in target.src_obj_pairs:
- cc_path = os.path.join(root_dir, cc_filename)
- h_path = os.path.splitext(cc_path)[0] + '.h'
- namespace = os.path.basename(target.dir_path)
- class_ = os.path.splitext(os.path.basename(cc_filename))[0]
- try:
- os.makedirs(os.path.dirname(cc_path))
- except OSError:
- pass
-
- with open(h_path, 'w') as f:
- f.write('namespace %s { struct %s { %s(); }; }' % (namespace,
- class_, class_))
- with open(cc_path, 'w') as f:
- for include in includes:
- f.write('#include "%s"\n' % include)
- f.write('\n')
- f.write('namespace %s { %s::%s() {} }' % (namespace,
- class_, class_))
-
- if need_main:
- f.write('int main(int argc, char **argv) {}\n')
- need_main = False
-
-def write_master_ninja(master_ninja, targets):
- """Writes master build.ninja file, referencing all given subninjas."""
- master_ninja.variable('cxx', 'c++')
- master_ninja.variable('ld', '$cxx')
- if sys.platform == 'darwin':
- master_ninja.variable('alink', 'libtool -static')
- else:
- master_ninja.variable('alink', 'ar rcs')
- master_ninja.newline()
-
- master_ninja.pool('link_pool', depth=4)
- master_ninja.newline()
-
- master_ninja.rule('cxx', description='CXX $out',
- command='$cxx -MMD -MF $out.d $defines $includes $cflags -c $in -o $out',
- depfile='$out.d', deps='gcc')
- master_ninja.rule('alink', description='ARCHIVE $out',
- command='rm -f $out && $alink -o $out $in')
- master_ninja.rule('link', description='LINK $out', pool='link_pool',
- command='$ld $ldflags -o $out $in $libs')
- master_ninja.rule('stamp', description='STAMP $out', command='touch $out')
- master_ninja.newline()
-
- for target in targets:
- master_ninja.subninja(target.ninja_file_path)
- master_ninja.newline()
-
- master_ninja.comment('Short names for targets.')
- for target in targets:
- if target.name != target.output:
- master_ninja.build(target.name, 'phony', target.output)
- master_ninja.newline()
-
- master_ninja.build('all', 'phony', [target.output for target in targets])
- master_ninja.default('all')
-
-
-@contextlib.contextmanager
-def FileWriter(path):
- """Context manager for a ninja_syntax object writing to a file."""
- try:
- os.makedirs(os.path.dirname(path))
- except OSError:
- pass
- f = open(path, 'w')
- yield ninja_syntax.Writer(f)
- f.close()
-
-
-def random_targets(num_targets, src_dir):
- gen = GenRandom(src_dir)
-
- # N-1 static libraries, and 1 executable depending on all of them.
- targets = [Target(gen, LIB) for i in range(num_targets - 1)]
- for i in range(len(targets)):
- targets[i].deps = [t for t in targets[0:i] if random.random() < 0.05]
-
- last_target = Target(gen, EXE)
- last_target.deps = targets[:]
- last_target.src_obj_pairs = last_target.src_obj_pairs[0:10] # Trim.
- targets.append(last_target)
- return targets
-
-
-def main():
- parser = argparse.ArgumentParser()
- parser.add_argument('-s', '--sources', nargs="?", const="src",
- help='write sources to directory (relative to output directory)')
- parser.add_argument('-t', '--targets', type=int, default=1500,
- help='number of targets (default: 1500)')
- parser.add_argument('-S', '--seed', type=int, help='random seed',
- default=12345)
- parser.add_argument('outdir', help='output directory')
- args = parser.parse_args()
- root_dir = args.outdir
-
- random.seed(args.seed)
-
- do_write_sources = args.sources is not None
- src_dir = args.sources if do_write_sources else "src"
-
- targets = random_targets(args.targets, src_dir)
- for target in targets:
- with FileWriter(os.path.join(root_dir, target.ninja_file_path)) as n:
- write_target_ninja(n, target, src_dir)
-
- if do_write_sources:
- write_sources(target, root_dir)
-
- with FileWriter(os.path.join(root_dir, 'build.ninja')) as master_ninja:
- master_ninja.width = 120
- write_master_ninja(master_ninja, targets)
-
-
-if __name__ == '__main__':
- sys.exit(main())
diff --git a/misc/zsh-completion b/misc/zsh-completion
deleted file mode 100644
index d439df3..0000000
--- a/misc/zsh-completion
+++ /dev/null
@@ -1,75 +0,0 @@
-#compdef ninja
-# Copyright 2011 Google Inc. All Rights Reserved.
-#
-# Licensed under the Apache License, Version 2.0 (the "License");
-# you may not use this file except in compliance with the License.
-# You may obtain a copy of the License at
-#
-# http://www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing, software
-# distributed under the License is distributed on an "AS IS" BASIS,
-# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-# See the License for the specific language governing permissions and
-# limitations under the License.
-
-# Add the following to your .zshrc to tab-complete ninja targets
-# fpath=(path/to/ninja/misc/zsh-completion $fpath)
-
-(( $+functions[_ninja-get-targets] )) || _ninja-get-targets() {
- dir="."
- if [ -n "${opt_args[-C]}" ];
- then
- eval dir="${opt_args[-C]}"
- fi
- file="build.ninja"
- if [ -n "${opt_args[-f]}" ];
- then
- eval file="${opt_args[-f]}"
- fi
- targets_command="ninja -f \"${file}\" -C \"${dir}\" -t targets all"
- eval ${targets_command} 2>/dev/null | cut -d: -f1
-}
-
-(( $+functions[_ninja-get-tools] )) || _ninja-get-tools() {
- # remove the first line; remove the leading spaces; replace spaces with colon
- ninja -t list 2> /dev/null | sed -e '1d;s/^ *//;s/ \+/:/'
-}
-
-(( $+functions[_ninja-get-modes] )) || _ninja-get-modes() {
- # remove the first line; remove the last line; remove the leading spaces; replace spaces with colon
- ninja -d list 2> /dev/null | sed -e '1d;$d;s/^ *//;s/ \+/:/'
-}
-
-(( $+functions[_ninja-modes] )) || _ninja-modes() {
- local -a modes
- modes=(${(fo)"$(_ninja-get-modes)"})
- _describe 'modes' modes
-}
-
-(( $+functions[_ninja-tools] )) || _ninja-tools() {
- local -a tools
- tools=(${(fo)"$(_ninja-get-tools)"})
- _describe 'tools' tools
-}
-
-(( $+functions[_ninja-targets] )) || _ninja-targets() {
- local -a targets
- targets=(${(fo)"$(_ninja-get-targets)"})
- _describe 'targets' targets
-}
-
-_arguments \
- '(- *)'{-h,--help}'[Show help]' \
- '(- *)--version[Print ninja version]' \
- '-C+[Change to directory before doing anything else]:directories:_directories' \
- '-f+[Specify input build file (default=build.ninja)]:files:_files' \
- '-j+[Run N jobs in parallel (default=number of CPUs available)]:number of jobs' \
- '-l+[Do not start new jobs if the load average is greater than N]:number of jobs' \
- '-k+[Keep going until N jobs fail (default=1)]:number of jobs' \
- '-n[Dry run (do not run commands but act like they succeeded)]' \
- '(-v --verbose --quiet)'{-v,--verbose}'[Show all command lines while building]' \
- "(-v --verbose --quiet)--quiet[Don't show progress status, just command output]" \
- '-d+[Enable debugging (use -d list to list modes)]:modes:_ninja-modes' \
- '-t+[Run a subtool (use -t list to list subtools)]:tools:_ninja-tools' \
- '*::targets:_ninja-targets'
diff --git a/src/async_loop-posix.h b/src/async_loop-posix.h
deleted file mode 100644
index 0bc517e..0000000
--- a/src/async_loop-posix.h
+++ /dev/null
@@ -1,840 +0,0 @@
-// Copyright 2023 Google Inc. All Rights Reserved.
-//
-// Licensed under the Apache License, Version 2.0 (the "License");
-// you may not use this file except in compliance with the License.
-// You may obtain a copy of the License at
-//
-// http://www.apache.org/licenses/LICENSE-2.0
-//
-// Unless required by applicable law or agreed to in writing, software
-// distributed under the License is distributed on an "AS IS" BASIS,
-// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-// See the License for the specific language governing permissions and
-// limitations under the License.
-
-#ifndef NINJA_ASYNC_LOOP_POSIX_H
-#define NINJA_ASYNC_LOOP_POSIX_H
-
-// Posix implementation of the AsyncLoop class.
-// This contains specialized code paths for Linux ppoll() and MacOS kqueue()
-
-#include <assert.h>
-#include <errno.h>
-#include <fcntl.h>
-#include <inttypes.h>
-#include <poll.h>
-#include <signal.h>
-#include <stddef.h>
-#include <string.h>
-#include <sys/select.h>
-#include <sys/socket.h>
-#include <sys/un.h>
-#include <unistd.h>
-
-#ifdef USE_KQUEUE
-#include <sys/event.h>
-#endif
-
-#include <algorithm>
-#include <unordered_map>
-
-#include "async_loop.h"
-#include "async_loop_timers.h"
-#include "interrupt_handling.h"
-#include "metrics.h" // For GetTimeMillis()
-#include "util.h" // For Fatal() and Win32Fatal().
-
-#ifdef USE_KQUEUE
-// The know state of a kqueue read or write filter for a given file descriptor.
-// Unknown means that the kernel queue does not know about this filter yet.
-enum class KqueueFilterState {
- Unknown = 0,
- Disabled,
- Enabled,
-};
-#endif // USE_KQUEUE
-
-class AsyncHandle::State {
- public:
- enum class Kind {
- None = 0,
- Read,
- Write,
- Connect,
- Accept,
- };
-
- // Constructors.
- explicit State(AsyncLoop& async_loop) : async_loop_(async_loop) {}
-
- State(IpcHandle handle, AsyncLoop& async_loop,
- AsyncHandle::Callback&& callback)
- : fd_(std::move(handle)), callback_(std::move(callback)),
- async_loop_(async_loop) {
- if (fd_)
- async_loop_.AttachHandle(this);
- }
-
- // Destructor. Note that this type is unmoveable due to Win32
- // requirements.
- ~State() {
- if (fd_)
- async_loop_.DetachHandle(this);
- }
-
- // Disallow copy operations. Even though this is implied by
- // the use of moveable-only fields like |fd_|.
- State(const State&) = delete;
- State& operator=(const State&) = delete;
-
- // Disallow move operations. The address of these instances are recorded
- // in the |AsyncLoop::Impl::watches_| data structure.
- State(State&&) noexcept = delete;
- State& operator=(State&&) noexcept = delete;
-
- // Return AsyncLoop instance this instance belongs to.
- AsyncLoop& async_loop() const { return async_loop_; }
-
- // Return AsyncLoop implementation instance.
- AsyncLoop::Impl& loop() const { return *async_loop_.impl_; }
-
- // Return file descriptor.
- int fd() const { return fd_.native_handle(); }
- int native_handle() const { return fd(); }
-
- // Return true if the handle for this instnace is valid.
- bool is_valid() const { return !!fd_; }
-
- // Release the native handle for this instance, making it invalid.
- int ReleaseHandle() {
- Reset(Kind::None);
- if (fd_)
- async_loop_.DetachHandle(this);
- return fd_.ReleaseNativeHandle();
- }
-
- // Is an asynchronous operation running?
- bool IsRunning() const { return kind_ != Kind::None && !completed_; }
-
- // Cancel current asynchronous operation, if any.
- void Cancel() {
- if (kind_ != Kind::None) {
- async_loop_.CancelHandle(this);
- Reset(Kind::None);
- }
- }
-
- // Reset the callback.
- void ResetCallback(AsyncHandle::Callback&& cb) { callback_ = std::move(cb); }
-
- void ResetHandle(IpcHandle handle) {
- Reset(Kind::None);
- if (fd_)
- async_loop_.DetachHandle(this);
- fd_ = std::move(handle);
- if (fd_)
- async_loop_.AttachHandle(this);
- }
-
- bool NeedsEvent() const { return !completed_ && kind_ != Kind::None; }
-
- bool NeedsWriteEvent() const {
- return !completed_ && (kind_ == Kind::Write || kind_ == Kind::Connect);
- }
-
- bool NeedsReadEvent() const {
- return !completed_ && (kind_ == Kind::Read || kind_ == Kind::Accept);
- }
-
- short poll_events() const {
- if (completed_)
- return 0;
- if (kind_ == Kind::Write || kind_ == Kind::Connect)
- return POLLOUT;
- if (kind_ == Kind::Read || kind_ == Kind::Accept)
- return POLLIN | POLLPRI;
- return 0;
- }
-
- short poll_revents() const { return poll_events() | POLLERR | POLLHUP; }
-
- // Reset state to start a new asynchronous operation. Cancels current one
- // if any.
- void Reset(Kind kind = Kind::None) {
- kind_ = kind;
- completed_ = false;
- error_ = 0;
- buffer_ = nullptr;
- wanted_size_ = 0;
- actual_size_ = 0;
- accept_handle_.Close();
- }
-
- void StartRead(void* buffer, size_t size) {
- Reset(Kind::Read);
- buffer_ = buffer;
- wanted_size_ = size;
- if (!size)
- completed_ = true;
- else
- async_loop().UpdateHandle(this);
- }
-
- void StartWrite(const void* buffer, size_t size) {
- Reset(Kind::Write);
- buffer_ = const_cast<void*>(buffer);
- wanted_size_ = size;
- if (!size)
- completed_ = true;
- else
- async_loop().UpdateHandle(this);
- }
-
- void StartConnect() {
- Reset(Kind::Connect);
- async_loop().UpdateHandle(this);
- }
-
- void StartAccept() {
- Reset(Kind::Accept);
- async_loop().UpdateHandle(this);
- }
-
- bool OnEvent() {
- error_ = 0;
- actual_size_ = 0;
-
- assert(!completed_);
- completed_ = true;
-
- switch (kind_) {
- case Kind::Read: {
- int ret;
- do {
- ret = ::read(fd_.native_handle(), buffer_, wanted_size_);
- } while (ret < 0 && errno == EINTR);
- if (ret < 0) {
- error_ = errno;
- if (error_ == EAGAIN || error_ == EWOULDBLOCK) {
- // A spurious wakeup happened.
- return false;
- }
- } else {
- actual_size_ = static_cast<size_t>(ret);
- }
- break;
- }
-
- case Kind::Write: {
- int ret;
- do {
- ret = ::write(fd_.native_handle(), buffer_, wanted_size_);
- } while (ret < 0 && errno == EINTR);
- if (ret < 0) {
- error_ = errno;
- if (error_ == EAGAIN || error_ == EWOULDBLOCK) {
- // A spurious wakeup happened.
- return false;
- }
- } else {
- actual_size_ = static_cast<size_t>(ret);
- }
- break;
- }
-
- case Kind::Connect: {
- int so_error =
- IpcHandle::GetNativeAsyncConnectStatus(fd_.native_handle());
- if (so_error != 0) {
- if (so_error == EAGAIN || so_error == EINPROGRESS)
- return false;
-
- error_ = so_error;
- }
- break;
- }
-
- case Kind::Accept: {
- int ret;
- do {
- ret = ::accept(fd_.native_handle(), nullptr, 0);
- } while (ret < 0 && errno == EINTR);
- if (ret < 0) {
- error_ = errno;
- if (error_ == EAGAIN || error_ == EWOULDBLOCK)
- return false;
- } else {
- accept_handle_ = IpcHandle(ret);
- // NOTE: On Linux, client handle does not inherit O_NONBLOCK
- // but it will on BSDs, so portable programs should set the
- // flag explicitly. TODO(digit).
- }
- break;
- }
-
- default:
- assert(false && "Invalid runtime async op type!");
- return false;
- }
- async_loop_.UpdateHandle(this);
- callback_(error_, actual_size_);
- return true;
- }
-
- IpcHandle TakeAcceptedHandle() { return std::move(accept_handle_); }
-
- IpcHandle fd_;
- Kind kind_ = Kind::None;
- bool completed_ = false;
-#ifdef USE_KQUEUE
- // These values are used exclusively by AsyncLoop::Impl::Watches
- KqueueFilterState kqueue_read_filter_ = KqueueFilterState::Unknown;
- KqueueFilterState kqueue_write_filter_ = KqueueFilterState::Unknown;
-#endif // USE_KQUEUE
- int error_ = 0;
- void* buffer_ = nullptr;
- size_t wanted_size_ = 0;
- size_t actual_size_ = 0;
- AsyncHandle::Callback callback_;
- IpcHandle accept_handle_;
- AsyncLoop& async_loop_;
-};
-
-class AsyncLoop::Impl {
- /// The list of pending AsyncHandle::States that have completed but whose
- /// Invoke() method wasn't called yet. Identified by their address.
- struct PendingList : public std::vector<AsyncHandle::State*> {
- // Remove one async state from the list.
- bool Remove(AsyncHandle::State* astate) {
- for (auto it = begin(); it != end(); ++it) {
- if (*it == astate) {
- // Order does not matter for this list, so just move last item
- // to current location to avoid O(n) removal cost.
- auto it_last = end() - 1;
- if (it != it_last)
- *it = *it_last;
- pop_back();
- return true;
- }
- }
- return false;
- }
- };
-
- PendingList pending_ops_;
-
-#ifdef USE_KQUEUE
- class Watches {
- IpcHandle queue_ = -1;
- std::vector<AsyncHandle::State*> states_;
- std::vector<struct kevent> events_;
-
- static constexpr size_t npos = ~size_t(0);
-
- size_t FindState(AsyncHandle::State* state) const {
- size_t result = 0;
- for (auto it = states_.begin(); it != states_.end(); ++it, ++result) {
- if (*it == state)
- return result;
- }
- return npos;
- }
-
- void InsertIntoQueue(AsyncHandle::State* state) {
- // Do not create any filter yet, these will be added on demand
- // during WaitForEvents().
- state->kqueue_read_filter_ = KqueueFilterState::Unknown;
- state->kqueue_write_filter_ = KqueueFilterState::Unknown;
- }
-
- void RemoveFromQueue(AsyncHandle::State* state) {
- // Remove the filters directly, instead of delaying the operation
- // to WaitForEvents().
- struct kevent events[2];
- int count = 0;
- if (state->kqueue_read_filter_ != KqueueFilterState::Unknown) {
- events[count++] = {
- static_cast<uintptr_t>(state->fd()),
- EVFILT_READ,
- EV_DELETE,
- 0,
- 0,
- state,
- };
- }
- if (state->kqueue_write_filter_ != KqueueFilterState::Unknown) {
- events[count++] = {
- static_cast<uintptr_t>(state->fd()),
- EVFILT_WRITE,
- EV_DELETE,
- 0,
- 0,
- state,
- };
- }
- if (count > 0) {
- int ret = kevent(queue_.native_handle(), events, count, NULL, 0, NULL);
- if (ret < 0)
- ErrnoFatal("kevent.Remove");
- }
- }
-
- public:
- Watches() : queue_(kqueue()) {
- if (!queue_)
- ErrnoFatal("kqueue()");
- }
-
- ~Watches() {
- assert(states_.empty() &&
- "Destroying AsyncLoop before child AsyncHandle instances!");
- }
-
- bool HasWaiters() const {
- for (const auto* state : states_) {
- if (state->IsRunning())
- return true;
- }
- return false;
- }
-
- void Insert(AsyncHandle::State* state) {
- assert(FindState(state) == npos && "Async state already in the set!");
- states_.push_back(state);
- InsertIntoQueue(state);
- }
-
- void Remove(AsyncHandle::State* state) {
- size_t state_pos = FindState(state);
- assert(state_pos != npos && "Async state not in the set!");
- RemoveFromQueue(state);
- // Order is not important
- states_[state_pos] = states_.back();
- states_.pop_back();
- }
-
- void Update(AsyncHandle::State* state) {
- assert(FindState(state) != npos && "Updating unknown async state!");
- // Do not do anything, changes will be computed on
- // demand in the next WaitForEvents() call.
- }
-
- int WaitForEvents(const struct timespec* ts, PendingList& pending_ops) {
- events_.resize(2 * states_.size());
-
- // Compute the changes to send to the kernel.
- int num_changes = 0;
- int num_events = 0;
-
- // Helper function to compute the set of flags to apply to
- // a given Kqueue filter. Return 0 if there is no change to apply.
- // Also updates num_events.
- auto check_filter = [&num_events](KqueueFilterState& filter,
- bool event_needed) -> uint16_t {
- uint16_t flags = 0;
- if (event_needed) {
- num_events++;
- if (filter != KqueueFilterState::Enabled) {
- flags = EV_ENABLE | EV_CLEAR |
- ((filter == KqueueFilterState::Unknown) ? EV_ADD : 0);
- filter = KqueueFilterState::Enabled;
- }
- } else if (filter == KqueueFilterState::Enabled) {
- flags = EV_DELETE;
- filter = KqueueFilterState::Disabled;
- }
- return flags;
- };
-
- for (auto* state : states_) {
- uint16_t flags =
- check_filter(state->kqueue_read_filter_, state->NeedsReadEvent());
- if (flags) {
- events_[num_changes++] = {
- static_cast<uintptr_t>(state->fd()),
- EVFILT_READ,
- flags,
- 0,
- 0,
- state,
- };
- }
-
- flags =
- check_filter(state->kqueue_write_filter_, state->NeedsWriteEvent());
- if (flags) {
- events_[num_changes++] = {
- static_cast<uintptr_t>(state->fd()),
- EVFILT_WRITE,
- flags,
- 0,
- 0,
- state,
- };
- }
- }
-
- struct kevent* events = &events_.front();
- int ret = kevent(queue_.native_handle(), events, num_changes, events,
- events_.size(), ts);
- if (ret < 0) {
- if (errno != EINTR)
- ErrnoFatal("kevent.Wait");
- return -1;
- }
-
- // kevent() always returns immediately if the size of the events array
- // is 0, even if there is a timeout so use pselect() instead.
- if (ret == 0 && num_events == 0) {
- int ret = pselect(0, NULL, NULL, NULL, ts, NULL);
- if (ret < 0 && errno != EINTR)
- ErrnoFatal("pselect");
- return ret;
- }
-
- struct kevent* event = &events_.front();
- for (int n = 0; n < ret; ++n, ++event) {
- auto* state = static_cast<AsyncHandle::State*>(event->udata);
- assert(state);
- assert(static_cast<uintptr_t>(state->fd()) == event->ident);
-
- // Do not try to interpret EV_ERROR here, assume that the OnError()
- // method will retry the syscall and get the error from it.
-
- if (event->filter == EVFILT_READ) {
- assert(state->NeedsReadEvent());
- assert(state->kqueue_read_filter_ == KqueueFilterState::Enabled);
- state->kqueue_read_filter_ = KqueueFilterState::Disabled;
- pending_ops.push_back(state);
- } else if (event->filter == EVFILT_WRITE) {
- assert(state->NeedsWriteEvent());
- assert(state->kqueue_write_filter_ == KqueueFilterState::Enabled);
- state->kqueue_write_filter_ = KqueueFilterState::Disabled;
- pending_ops.push_back(state);
- }
- }
- return ret;
- }
- };
-#elif defined(USE_PPOLL)
- class Watches {
- // Use two parallel vectors, where polls_[n] is an entry matching
- // states_[n], since only one async operation can exist for each file
- // descriptor. They must be separate because the address of polls_.front()
- // will be passed to the kernel for ppoll(), which expects a contiguous
- // array of pollfd items in memory.
- std::vector<AsyncHandle::State*> states_;
- std::vector<pollfd> polls_;
-
- size_t FindState(AsyncHandle::State* state) {
- size_t result = 0;
- for (auto* s : states_) {
- if (s == state)
- return result;
- ++result;
- }
- return npos;
- }
-
- public:
- static constexpr size_t npos = ~size_t(0);
-
- ~Watches() {
- assert(states_.empty() &&
- "Destroying AsyncLoop before child AsyncHandle instances!");
- }
-
- bool HasWaiters() const {
- for (const auto& poll : polls_) {
- if (poll.events != 0)
- return true;
- }
- return false;
- }
-
- void Insert(AsyncHandle::State* state) {
- assert(FindState(state) == npos && "Async state already in the set!");
- states_.push_back(state);
- polls_.push_back({ state->fd(), state->poll_events(), 0 });
- }
-
- void Remove(AsyncHandle::State* state) {
- size_t state_pos = FindState(state);
- assert(state_pos != npos && "Async state not in the set!");
- // Order is not important
- size_t last_pos = states_.size() - 1;
- if (state_pos != last_pos) {
- states_[state_pos] = states_[last_pos];
- polls_[state_pos] = polls_[last_pos];
- }
- states_.pop_back();
- polls_.pop_back();
- }
-
- void Update(AsyncHandle::State* state) {
- size_t state_pos = FindState(state);
- assert(state_pos != npos && "Updating unknown async state!");
- polls_[state_pos].events = state->poll_events();
- }
-
- int WaitForEvents(const struct timespec* ts, PendingList& pending_ops) {
- int ret = ppoll(&polls_.front(), static_cast<nfds_t>(polls_.size()), ts,
- nullptr);
- if (ret < 0) {
- if (errno != EINTR)
- ErrnoFatal("ppoll");
- } else if (ret > 0) {
- auto cur_poll = polls_.begin();
- auto cur_state = states_.begin();
- for (; cur_poll != polls_.end(); ++cur_poll, ++cur_state) {
- AsyncHandle::State* state = *cur_state;
- assert(state->fd() == cur_poll->fd);
- if (cur_poll->revents & state->poll_revents())
- pending_ops.push_back(state);
- }
- }
- return ret;
- }
- };
-
-#else // !USE_KQUEUE && !USE_PPOLL
- class Watches {
- static constexpr int kInvalid = -2;
- mutable int max_fds_ = kInvalid;
-
- using ListType = std::vector<AsyncHandle::State*>;
- ListType states_;
- fd_set read_fds_;
- fd_set write_fds_;
- fd_set event_read_fds_;
- fd_set event_write_fds_;
-
- void Invalidate() { max_fds_ = kInvalid; }
-
- int num_fds() const {
- // Recompute max file descriptor if needed.
- if (max_fds_ == kInvalid) {
- max_fds_ = -1;
- for (AsyncHandle::State* state : states_) {
- if (state->NeedsReadEvent() || state->NeedsWriteEvent()) {
- if (state->fd() > max_fds_)
- max_fds_ = state->fd();
- }
- }
- }
- return max_fds_ + 1;
- }
-
- ListType::iterator FindState(AsyncHandle::State* state) {
- return std::find(states_.begin(), states_.end(), state);
- }
-
- public:
- Watches() {
- FD_ZERO(&read_fds_);
- FD_ZERO(&write_fds_);
- }
-
- void Insert(AsyncHandle::State* state) {
- if (state->fd() >= static_cast<int>(FD_SETSIZE))
- Fatal("File descriptor too large for pselect(): %d\n", state->fd());
-
- auto it = FindState(state);
- assert(it == states_.end() && "Async state already in the set!");
- if (it != states_.end())
- return;
- states_.push_back(state);
- if (state->NeedsReadEvent())
- FD_SET(state->fd(), &read_fds_);
- if (state->NeedsWriteEvent())
- FD_SET(state->fd(), &write_fds_);
- Invalidate();
- }
-
- void Remove(AsyncHandle::State* state) {
- auto it = FindState(state);
- assert(it != states_.end() && "Removing unknown Async state!");
- if (it == states_.end())
- return;
- FD_CLR(state->fd(), &read_fds_);
- FD_CLR(state->fd(), &write_fds_);
- Invalidate();
- }
-
- void Update(AsyncHandle::State* state) {
- int fd = state->fd();
- if (state->NeedsReadEvent()) {
- FD_SET(fd, &read_fds_);
- } else {
- FD_CLR(fd, &read_fds_);
- }
- if (state->NeedsWriteEvent()) {
- FD_SET(fd, &write_fds_);
- } else {
- FD_CLR(fd, &write_fds_);
- }
- }
-
- bool HasWaiters() const {
- for (const auto* state : states_) {
- if (state->IsRunning())
- return true;
- }
- return false;
- }
-
- int WaitForEvents(const struct timespec* ts, PendingList& pending_ops) {
- event_read_fds_ = read_fds_;
- event_write_fds_ = write_fds_;
-
- int count = num_fds();
- int ret = pselect(count, &event_read_fds_, &event_write_fds_, nullptr, ts,
- nullptr);
- if (ret < 0) {
- if (errno != EINTR)
- ErrnoFatal("pselect");
- } else if (ret > 0) {
- for (auto* state : states_) {
- int fd = state->fd();
- bool has_event = false;
- has_event |=
- state->NeedsWriteEvent() && FD_ISSET(fd, &event_write_fds_);
- has_event |=
- state->NeedsReadEvent() && FD_ISSET(fd, &event_read_fds_);
- if (has_event)
- pending_ops.emplace_back(state);
- }
- }
- return ret;
- }
- };
-#endif // !USE_KQUEUE && !USE_PPOLL
-
- public:
- ~Impl() {
- assert(!watches_.HasWaiters() &&
- "Destroying AsyncLoop before children AsyncHandle instances!");
- assert(timers_.empty() &&
- "Destroying AsyncLoop before children AsyncTimer instances!");
- }
-
- AsyncLoopTimers& timers() { return timers_; }
-
- void AttachHandle(AsyncHandle::State* state) {
- assert(state->fd_ && "Trying to attach invalid handle");
- watches_.Insert(state);
- }
-
- void DetachHandle(AsyncHandle::State* state) {
- assert(state->fd_ && "Trying to detach invalid handle");
- watches_.Remove(state);
- }
-
- void UpdateHandle(AsyncHandle::State* state) { watches_.Update(state); }
-
- void CancelHandle(AsyncHandle::State* state) {
- pending_ops_.Remove(state);
- watches_.Update(state);
- }
-
- AsyncLoop::ExitStatus RunOnce(int64_t timeout_ms, AsyncLoop& loop) {
- assert(pending_ops_.empty());
-
- /// An interrupt occured outside of this loop, return immediately.
- if (interrupt_catcher_.get() && interrupt_catcher_->interrupted()) {
- return ExitInterrupted;
- }
-
- /// Handle timeout.
- bool has_timers = false;
- int64_t timer_expiration_ms = timers_.ComputeNextExpiration();
- if (timer_expiration_ms >= 0) {
- has_timers = true;
- int64_t now_ms = NowMs();
- int64_t timer_timeout_ms = timer_expiration_ms - now_ms;
- if (timer_timeout_ms < 0) {
- timer_timeout_ms = 0;
- }
-
- if (timeout_ms < 0)
- timeout_ms = timer_timeout_ms;
- else if (timeout_ms > timer_timeout_ms)
- timeout_ms = timer_timeout_ms;
- }
-
- const struct timespec* ts = NULL;
- struct timespec timeout_ts = {};
- if (timeout_ms >= 0) {
- timeout_ts.tv_sec = static_cast<time_t>(timeout_ms / 1000);
- timeout_ts.tv_nsec = static_cast<long>((timeout_ms % 1000) * 1000000LL);
- ts = &timeout_ts;
- }
-
- /// Exit immediately if there is nothing to do and no timeout.
- if (!watches_.HasWaiters() && pending_ops_.empty() && timeout_ms < 0)
- return ExitIdle;
-
- int ret = watches_.WaitForEvents(ts, pending_ops_);
- if (ret == -1) {
- return ExitInterrupted;
- }
-
- if (interrupt_catcher_.get()) {
- interrupt_catcher_->HandlePendingInterrupt();
- if (interrupt_catcher_->interrupted())
- return ExitInterrupted;
- }
-
- ExitStatus result = ExitTimeout;
-
- // Handle all pending operations.
- // Note that OnEvent() may invoke a callback that changes the
- // state of pending_ops_.
- while (!pending_ops_.empty()) {
- AsyncHandle::State* state = pending_ops_.back();
- pending_ops_.pop_back();
- if (state->OnEvent())
- result = ExitSuccess;
- }
-
- if (has_timers && timers_.ProcessExpiration(NowMs()))
- result = ExitSuccess;
-
- return result;
- }
-
- void ClearInterrupt() {
- if (interrupt_catcher_)
- interrupt_catcher_->Clear();
- }
-
- int GetInterruptSignal() const {
- if (!interrupt_catcher_)
- return 0;
- return interrupt_catcher_->interrupted();
- }
-
- sigset_t GetOldSignalMask() const {
- if (!interrupt_catcher_) {
- sigset_t old_mask;
- sigset_t empty;
- sigemptyset(&empty);
- sigprocmask(SIG_BLOCK, &empty, &old_mask);
- return old_mask;
- }
- return interrupt_catcher_->old_mask();
- }
-
- void EnableInterruptCatcher() {
- interrupt_catcher_.reset(new InterruptCatcher());
- }
-
- void DisableInterruptCatcher() { interrupt_catcher_.reset(); }
-
- private:
- std::unique_ptr<InterruptCatcher> interrupt_catcher_;
- AsyncLoopTimers timers_;
- Watches watches_;
-};
-
-#endif // NINJA_ASYNC_LOOP_POSIX_H
diff --git a/src/async_loop-win32.h b/src/async_loop-win32.h
deleted file mode 100644
index fe6f702..0000000
--- a/src/async_loop-win32.h
+++ /dev/null
@@ -1,460 +0,0 @@
-// Copyright 2023 Google Inc. All Rights Reserved.
-//
-// Licensed under the Apache License, Version 2.0 (the "License");
-// you may not use this file except in compliance with the License.
-// You may obtain a copy of the License at
-//
-// http://www.apache.org/licenses/LICENSE-2.0
-//
-// Unless required by applicable law or agreed to in writing, software
-// distributed under the License is distributed on an "AS IS" BASIS,
-// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-// See the License for the specific language governing permissions and
-// limitations under the License.
-
-#ifndef NINJA_ASYNC_LOOP_WIN32_H
-#define NINJA_ASYNC_LOOP_WIN32_H
-
-/// Win32 implementation of the AsyncLoop class.
-
-#include <assert.h>
-
-#include <list>
-#include <unordered_map>
-
-#include "async_loop.h"
-#include "async_loop_timers.h"
-#include "interrupt_handling.h"
-#include "metrics.h" // GetTimeMillis()
-#include "util.h" // Win32Fatal()
-#include "win32port.h" // PRId64
-
-// Set to 1 to add special code paths to add extra debugging checks.
-#define DEBUG 0
-
-#if DEBUG
-#define DEBUG_OVERLAPPED_POINTERS 1
-#else
-#define DEBUG_OVERLAPPED_POINTERS 0
-#endif
-
-// Technical note on Win32 overlapped i/o:
-//
-// - Calling CreateIoCompletionPort() on a handle that
-// was already associated with the same port returns
-// ERROR_INVALID_PARAMETER.
-//
-// This means it is impossible to change the completion_key
-// value for a handle once it has been set.
-//
-// - If a handle is associated with a completion port,
-// calling DuplicateHandle() will create a new handle
-// that is _already_ associated with the same completion port.
-//
-// This means that calling CreateIoCompletionPort(new_handle, ...)
-// will fail with ERROR_INVALID_PARAMETER.
-//
-// But it also means the completion_key for both handles will
-// always be the same. Thus this value becomes useless to
-// distinguish handles in general. The only reliable way is to
-// use the OVERLAPPED* pointer.
-//
-// - Even if an overlapped ReadFile() call succeeds immediately,
-// a completion event will still be sent to the port for it.
-// Same with WriteFile(), ConnectNamedPipe() and other Win32 I/O functions.
-//
-
-// The Win32-specific state of an AsyncHandle instance, without any
-// AsyncLoop reference. Wraps an OVERLAPPED struct
-struct AsyncHandle::State {
- enum class Kind {
- None = 0,
- Read,
- Write,
- Connect,
- Accept,
- };
-
- // Constructors.
- explicit State(AsyncLoop& async_loop) : async_loop_(async_loop) {}
-
- State(IpcHandle handle, AsyncLoop& async_loop, AsyncHandle::Callback&& callback)
- : handle_(std::move(handle)), async_loop_(async_loop), callback_(std::move(callback)) {
- if (handle_)
- async_loop_.AttachHandle(this);
- }
-
- // Destructor.
- ~State() {
- if (!completed_)
- Cancel();
- if (handle_) {
- async_loop_.DetachHandle(this);
- }
- }
-
- // Disallow copy operations. Even though this is implied by
- // the use of moveable-only fields like |handle_|.
- State(const State&) = delete;
- State& operator=(const State&) = delete;
-
- // Disable move operations, since the address of this instance's
- // |overlapped_| field (which should equal the instance's address) is
- // passed to the Windows kernel, and thus cannot change.
- State(State&&) noexcept = delete;
- State& operator=(State&&) noexcept = delete;
-
- // Return AsyncLoop this instance belongs to.
- AsyncLoop& async_loop() const { return async_loop_; }
- AsyncLoop::Impl& loop() const { return *async_loop_.impl_; }
-
- bool is_valid() const { return !!handle_; }
-
- // Is an asynchronous operation running?
- bool IsRunning() const { return !completed_; }
-
- HANDLE native_handle() const { return handle_.native_handle(); }
-
- // Cancel current asynchronous operation, if any.
- void Cancel() {
- if (!completed_ && kind_ != Kind::None) {
- async_loop_.CancelHandle(this);
- ::CancelIoEx(handle_.native_handle(), &overlapped_);
- completed_ = true;
- }
- }
-
- // Reset the callback.
- void ResetCallback(AsyncHandle::Callback&& cb) { callback_ = std::move(cb); }
-
- void ResetHandle(IpcHandle handle) {
- if (handle_) {
- Cancel();
- async_loop_.DetachHandle(this);
- }
- handle_ = std::move(handle);
- if (handle_)
- async_loop_.AttachHandle(this);
- }
-
- HANDLE ReleaseHandle() {
- if (!handle_)
- return INVALID_HANDLE_VALUE;
-
- Cancel();
- async_loop_.DetachHandle(this);
- return handle_.ReleaseNativeHandle();
- }
-
- // Reset state to start a new asynchronous operation. Cancels current one
- // if any.
- void Reset(Kind kind = Kind::None) {
- kind_ = kind;
- if (!completed_) {
- ::CancelIoEx(handle_.native_handle(), &overlapped_);
- completed_ = true;
- }
- error_ = 0;
- actual_bytes_ = 0;
- accept_handle_.Close();
- }
-
- // Start async read operation.
- void StartRead(void* buffer, size_t size) {
- Reset(Kind::Read);
- completed_ = false;
- if (!ReadFile(handle_.native_handle(), buffer, size, &actual_bytes_,
- &overlapped_)) {
- error_ = GetLastError();
- completed_ = (error_ != ERROR_IO_PENDING);
- }
- async_loop_.UpdateHandle(this);
- }
-
- // Start async write operation.
- void StartWrite(const void* buffer, size_t size) {
- Reset(Kind::Write);
- completed_ = false;
- if (!::WriteFile(handle_.native_handle(), buffer, size, &actual_bytes_,
- &overlapped_)) {
- error_ = GetLastError();
- completed_ = (error_ != ERROR_IO_PENDING);
- }
- async_loop_.UpdateHandle(this);
- }
-
- // Start async connect operation.
- void StartConnect() {
- Reset(Kind::Connect);
- // Connection to named pipes is immediate on Win32.
- completed_ = true;
- async_loop_.UpdateHandle(this);
- }
-
- // Start async accept operation.
- void StartAccept() {
- // Note: duplicate the server handle here to be able to pass
- // the result to the final AsyncHandle::TakeAcceptedHandle()
- // call as a separate client connection handle.
- //
- // The duplicate is already associated with the i/o completion port
- // and does not need to be attached to the AsyncLoop instance.
- Reset(Kind::Accept);
- completed_ = false;
- accept_handle_ = handle_.Clone();
-
- if (!ConnectNamedPipe(accept_handle_.native_handle(), &overlapped_)) {
- error_ = GetLastError();
- completed_ = (error_ != ERROR_IO_PENDING);
- }
- async_loop_.UpdateHandle(this);
- }
-
- // Called when a completion event is received. Do not invoke the callback
- // yet though.
- void OnCompletion(AsyncError error, size_t transfer_size) {
- completed_ = true;
- error_ = error;
- actual_bytes_ = transfer_size;
- }
-
- // Invoke the callback.
- void InvokeCallback() { callback_(error_, actual_bytes_); }
-
- // Return accepted handle, if any.
- IpcHandle TakeAcceptedHandle() { return std::move(accept_handle_); }
-
- OVERLAPPED overlapped_ = {}; // Must be first!
- IpcHandle handle_;
- Kind kind_ = Kind::None;
- bool completed_ = false;
- DWORD error_ = 0;
- DWORD actual_bytes_ = 0;
- IpcHandle accept_handle_;
- AsyncLoop& async_loop_;
- AsyncHandle::Callback callback_;
-};
-
-// Win32-specific implementation of the AsyncLoop internal interface.
-class AsyncLoop::Impl {
- /// The list of pending AsyncHandle::States that have completed but whose
- /// Invoke() method wasn't called yet. Identified by their address.
- struct PendingList : public std::vector<AsyncHandle::State*> {
- // Remove one async_id from the list.
- bool Remove(AsyncHandle::State* async_op) {
- for (auto it = begin(); it != end(); ++it) {
- if (*it == async_op) {
- // Order does not matter for this list, so just move last item
- // to current location to avoid O(n) removal cost.
- auto it_last = end() - 1;
- if (it != it_last)
- *it = *it_last;
- pop_back();
- return true;
- }
- }
- return false;
- }
- };
-
- PendingList pending_ops_;
-
- // The number of AsyncHandle instances attached to this loop.
- size_t attached_count_ = 0;
-
- // The number of AsyncHandle instances waiting for an event.
- size_t waiting_count_ = 0;
-
-#if DEBUG_OVERLAPPED_POINTERS
- // A map used to convert OVERLAPPED* pointer values to the address
- // of a known AsyncHandle::State. Used for safety.
- using OverlappedMap = std::unordered_map<OVERLAPPED*, AsyncHandle::State*>;
- OverlappedMap overlapped_map_;
-#endif
-
- public:
- ~Impl() {
-#if DEBUG_OVERLAPPED_POINTERS
- assert(overlapped_map_.empty() &&
- "Destroying AsyncLop before AsyncHandle!");
-#endif
- assert(timers_.empty() &&
- "Destroying AsyncLoop before children AsyncTimer instances!");
- }
-
- AsyncLoopTimers& timers() { return timers_; }
-
- void AttachHandle(AsyncHandle::State* async_op) {
- assert(async_op && "Attaching null async op!");
- assert(async_op->handle_ && "Attaching invalid handle!");
-
- HANDLE handle = async_op->handle_.native_handle();
- if (handle == INVALID_HANDLE_VALUE)
- return;
-
- auto key = reinterpret_cast<ULONG_PTR>(handle);
- if (!CreateIoCompletionPort(handle, ioport_.get(), key, 0)) {
- DWORD error = GetLastError();
- // CreateIoCompletionPort() will return invalid parameter
- // when trying to call it with the duplicate of a handle that
- // was already associated with the port. Ignore it.
- if (error != ERROR_INVALID_PARAMETER)
- Win32Fatal("CreateIoCompletionPortRead");
- }
-
-#if DEBUG_OVERLAPPED_POINTERS
- auto ret = overlapped_map_.emplace(&async_op->overlapped_, async_op);
- assert(ret.second &&
- "Adding AsyncHandle::State for known OVERLAPPED pointer!");
-#endif // DEBUG_OVERLAPPED_POINTERS
-
- attached_count_ += 1;
- }
-
- void DetachHandle(AsyncHandle::State* async_op) {
- assert(async_op->handle_ && "Detaching invalid handle!");
- if (!async_op->handle_)
- return;
-
- assert(attached_count_ > 0 &&
- "Detaching AsyncHandle::State from empty AsyncLoop!");
- attached_count_--;
-
-#if DEBUG_OVERLAPPED_POINTERS
- auto overlapped_it = overlapped_map_.find(&async_op->overlapped_);
- assert(overlapped_it != overlapped_map_.end() &&
- "Releasing AsyncHandle::State for unknown OVERLAPPED pointer!");
- overlapped_map_.erase(overlapped_it);
-#endif // DEBUG_OVERLAPPED_POINTERS
- }
-
- void UpdateHandle(AsyncHandle::State* state) {
- if (state->completed_)
- pending_ops_.push_back(state);
- else
- waiting_count_++;
- }
-
- void CancelHandle(AsyncHandle::State* astate) {
- pending_ops_.Remove(astate);
- assert(waiting_count_ > 0);
- waiting_count_--;
- }
-
- ExitStatus RunOnce(int64_t timeout_ms, AsyncLoop& loop) {
- // Any pending operations (e.g. from StartAsyncConnect()) means
- // no timeout is needed.
- if (!pending_ops_.empty())
- timeout_ms = 0;
-
- // Handle timeout.
- bool has_timers = false;
- int64_t timer_expiration_ms = timers_.ComputeNextExpiration();
- if (timer_expiration_ms >= 0) {
- has_timers = true;
- int64_t timer_timeout_ms = timer_expiration_ms - NowMs();
- if (timer_timeout_ms < 0)
- timer_timeout_ms = 0;
-
- if (timeout_ms < 0)
- timeout_ms = timer_timeout_ms;
- else if (timeout_ms > timer_timeout_ms)
- timeout_ms = timer_timeout_ms;
- }
-
- // Do we have any async operation here?
- if (timeout_ms < 0 && !waiting_count_)
- return ExitIdle;
-
- DWORD error = 0;
- DWORD transfer_size = 0;
- ULONG_PTR completion_key = 0;
- bool received_key = true;
- OVERLAPPED* overlapped_ptr = nullptr;
- DWORD timeout = timeout_ms < 0 ? INFINITE : static_cast<DWORD>(timeout_ms);
- if (!GetQueuedCompletionStatus(ioport_.get(), &transfer_size,
- &completion_key, &overlapped_ptr, timeout)) {
- error = GetLastError();
- if (error == ERROR_BROKEN_PIPE) {
- // Pass the error to the callback.
- } else if (error == WAIT_TIMEOUT) {
- received_key = false;
- if (pending_ops_.empty() && !has_timers)
- return ExitTimeout;
- } else {
- Win32Fatal("GetQueuedCompletionStatus");
- }
- }
-
- if (received_key) {
- // NotifyInterrupted is the only thing that posts a NULL completion key.
- if (!completion_key)
- return ExitInterrupted;
-
-#if DEBUG_OVERLAPPED_POINTERS
- auto overlapped_it = overlapped_map_.find(overlapped_ptr);
- assert(overlapped_it != overlapped_map_.end() &&
- "Received completion for unknown OVERLAPPED pointer!");
- AsyncHandle::State* async_op = overlapped_it->second;
- assert(async_op ==
- reinterpret_cast<AsyncHandle::State*>(overlapped_ptr) &&
- "Inconsistent OVERLAPPED pointer value!");
-#else // !DEBUG_OVERLAPPED_POINTERS
- AsyncHandle::State* async_op =
- reinterpret_cast<AsyncHandle::State*>(overlapped_ptr);
-#endif
- async_op->OnCompletion(error, transfer_size);
- assert(waiting_count_ > 0);
- waiting_count_ -= 1;
- pending_ops_.push_back(async_op);
- }
-
- // Handle all pending operations.
- // Note that InvokeCallback() may invoke a callback that changes the
- // state of pending_ops_.
- while (!pending_ops_.empty()) {
- AsyncHandle::State* async_op = pending_ops_.back();
- pending_ops_.pop_back();
- async_op->InvokeCallback();
- }
-
- if (has_timers && !timers_.ProcessExpiration(NowMs()))
- return ExitTimeout;
-
- return ExitSuccess;
- }
-
- void ClearInterrupt() {
- // Nothing to do here.
- }
-
- void EnableInterruptCatcher() {
- interrupt_handler_.reset(new InterruptCompletionPortHandler(ioport_.get()));
- }
-
- void DisableInterruptCatcher() { interrupt_handler_.reset(); }
-
- private:
- /// Helper class to create and close an I/O completion port handle
- /// in the right order.
- struct ScopedIoPort {
- ScopedIoPort()
- : handle_(::CreateIoCompletionPort(INVALID_HANDLE_VALUE, NULL, 0, 1)) {
- if (!handle_)
- Win32Fatal("CreateIoCompletionPort");
- }
-
- ~ScopedIoPort() { ::CloseHandle(handle_); }
-
- HANDLE get() const { return handle_; }
-
- private:
- HANDLE handle_;
- };
-
- ScopedIoPort ioport_;
- std::unique_ptr<InterruptCompletionPortHandler> interrupt_handler_;
- AsyncLoopTimers timers_;
-};
-
-#endif // NINJA_ASYNC_LOOP_WIN32_H
diff --git a/src/async_loop.cc b/src/async_loop.cc
deleted file mode 100644
index 978a972..0000000
--- a/src/async_loop.cc
+++ /dev/null
@@ -1,340 +0,0 @@
-// Copyright 2023 Google Inc. All Rights Reserved.
-//
-// Licensed under the Apache License, Version 2.0 (the "License");
-// you may not use this file except in compliance with the License.
-// You may obtain a copy of the License at
-//
-// http://www.apache.org/licenses/LICENSE-2.0
-//
-// Unless required by applicable law or agreed to in writing, software
-// distributed under the License is distributed on an "AS IS" BASIS,
-// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-// See the License for the specific language governing permissions and
-// limitations under the License.
-
-#include "async_loop.h"
-
-#include "util.h"
-
-#ifdef _WIN32
-#include "async_loop-win32.h"
-#else
-#include "async_loop-posix.h"
-#endif
-
-// static
-std::string AsyncErrorToString(AsyncError error) {
- return std::string(strerror(error));
-}
-
-// Global instance.
-static std::unique_ptr<AsyncLoop> s_loop;
-
-// static
-AsyncLoop& AsyncLoop::Get() {
- AsyncLoop* loop = s_loop.get();
- if (!loop) {
- loop = new AsyncLoop();
- s_loop.reset(loop);
- }
- return *loop;
-}
-
-// static
-std::unique_ptr<AsyncLoop> AsyncLoop::CreateLocal() {
- return std::unique_ptr<AsyncLoop>(new AsyncLoop());
-}
-
-void AsyncLoop::Reset() {
- impl_.reset(new AsyncLoop::Impl());
- if (interrupt_catcher_count_ > 0)
- impl_->EnableInterruptCatcher();
-}
-
-// static
-void AsyncLoop::ResetForTesting() {
- AsyncLoop* loop = s_loop.get();
- if (loop)
- loop->Reset();
-}
-
-AsyncLoop::AsyncLoop() : impl_(new AsyncLoop::Impl()) {}
-
-AsyncLoop::~AsyncLoop() = default;
-
-// static
-int64_t AsyncLoop::NowMs() {
- static bool init = false;
- static int64_t start_ms = 0;
- int64_t result = GetTimeMillis();
- if (!init) {
- start_ms = result;
- init = true;
- }
- return result - start_ms;
-}
-
-AsyncLoop::ExitStatus AsyncLoop::RunOnce(int64_t timeout_ms) {
- return impl_->RunOnce(timeout_ms, *this);
-}
-
-void AsyncLoop::ClearInterrupt() {
- impl_->ClearInterrupt();
-}
-
-#ifndef _WIN32
-int AsyncLoop::GetInterruptSignal() const {
- return impl_->GetInterruptSignal();
-}
-
-sigset_t AsyncLoop::GetOldSignalMask() const {
- return impl_->GetOldSignalMask();
-}
-#endif // !_WIN32
-
-void AsyncLoop::UpdateHandle(AsyncHandle::State* state) {
- impl_->UpdateHandle(state);
-}
-
-void AsyncLoop::CancelHandle(AsyncHandle::State* state) {
- impl_->CancelHandle(state);
-}
-
-void AsyncLoop::AttachTimer(AsyncTimer::State* state) {
- impl_->timers().AttachTimer(state);
-}
-
-void AsyncLoop::DetachTimer(AsyncTimer::State* state) {
- impl_->timers().DetachTimer(state);
-}
-
-void AsyncLoop::UpdateTimer(AsyncTimer::State* state) {
- impl_->timers().UpdateTimer(state);
-}
-
-AsyncLoop::RunUntilState::RunUntilState(int64_t timeout_ms)
- : timeout_ms_(timeout_ms) {}
-
-bool AsyncLoop::RunUntilState::LoopAgain(AsyncLoop& async_loop) {
- // Initialize expiration_ms_ the first time this method is called.
- int64_t expiration_ms = -1;
- if (timeout_ms_ >= 0)
- expiration_ms = async_loop.NowMs() + timeout_ms_;
-
- status_ = async_loop.RunOnce(timeout_ms_);
- if (status_ != ExitSuccess) {
- // Either an interrupt, timeout or idle exit.
- // This is the end of the loop.
- return false;
- }
-
- if (timeout_ms_ < 0) {
- // Since no timeout was specified, just loop again
- // after an async event.
- return true;
- }
-
- // Adjust the timeout for the next invocation.
- timeout_ms_ = expiration_ms - async_loop.NowMs();
- if (timeout_ms_ >= 0) {
- // There is still time left, so loop again.
- return true;
- }
-
- // There is no time left, stop the loop reporting
- // a real timeout.
- timeout_ms_ = 0;
- status_ = ExitTimeout;
- return false;
-}
-
-void AsyncLoop::ChangeInterruptCatcher(bool increment) {
- if (increment) {
- if (++interrupt_catcher_count_ == 1)
- impl_->EnableInterruptCatcher();
- } else {
- if (interrupt_catcher_count_ <= 0)
- Fatal("Unbalanced ChangeInterruptCatcher() calls");
- if (--interrupt_catcher_count_ == 0)
- impl_->DisableInterruptCatcher();
- }
-}
-
-void AsyncLoop::AttachHandle(AsyncHandle::State* state) {
- impl_->AttachHandle(state);
-}
-
-void AsyncLoop::DetachHandle(AsyncHandle::State* state) {
- impl_->DetachHandle(state);
-}
-
-///////////////////////////////////////////////////////////////////////////
-///
-/// AsyncHandle
-///
-
-AsyncHandle::AsyncHandle() = default;
-AsyncHandle::AsyncHandle(std::unique_ptr<AsyncHandle::State> state)
- : state_(std::move(state)) {}
-
-// static
-AsyncHandle AsyncHandle::Create(IpcHandle handle, AsyncLoop& async_loop,
- AsyncHandle::Callback&& callback) {
- auto state = std::unique_ptr<AsyncHandle::State>(new AsyncHandle::State(
- std::move(handle), async_loop, std::move(callback)));
- return AsyncHandle(std::move(state));
-}
-
-// static
-AsyncHandle AsyncHandle::Create(IpcHandle::HandleType native_handle,
- AsyncLoop& async_loop,
- AsyncHandle::Callback&& callback) {
- return Create(IpcHandle(native_handle), async_loop, std::move(callback));
-}
-
-// static
-AsyncHandle AsyncHandle::CreateClone(IpcHandle::HandleType native_handle,
- AsyncLoop& async_loop,
- AsyncHandle::Callback&& callback) {
- return Create(IpcHandle::CloneNativeHandle(native_handle), async_loop,
- std::move(callback));
-}
-
-AsyncHandle::~AsyncHandle() = default;
-
-AsyncHandle::AsyncHandle(AsyncHandle&&) noexcept = default;
-AsyncHandle& AsyncHandle::operator=(AsyncHandle&&) noexcept = default;
-
-void AsyncHandle::Close() {
- if (is_valid()) {
- state_->Cancel();
- state_.reset();
- }
-}
-
-void AsyncHandle::ResetHandle(IpcHandle handle) {
- assert(state_ && "Reset() on invalid AsyncHandle value");
-#ifndef _WIN32
- handle.SetNonBlocking(true);
-#endif
- state_->ResetHandle(std::move(handle));
-}
-
-IpcHandle::HandleType AsyncHandle::Release() {
- return state_->ReleaseHandle();
-}
-
-bool AsyncHandle::is_valid() const {
- return state_ && state_->is_valid();
-}
-
-IpcHandle::HandleType AsyncHandle::native_handle() const {
- return state_ ? state_->native_handle() : IpcHandle::kInvalid;
-}
-
-bool AsyncHandle::IsRunning() const {
- return state_ && state_->IsRunning();
-}
-
-void AsyncHandle::Cancel() {
- if (state_)
- state_->Cancel();
-}
-
-AsyncHandle& AsyncHandle::ResetCallback(AsyncHandle::Callback&& callback) {
- assert(state_ && "ResetCallback() on invalid AsyncHandle value");
- state_->ResetCallback(std::move(callback));
- return *this;
-}
-
-void AsyncHandle::StartRead(void* buffer, size_t size) {
- assert(state_ && "StartRead() on invalid AsyncHandle value");
- state_->StartRead(buffer, size);
-}
-
-void AsyncHandle::StartWrite(const void* buffer, size_t size) {
- assert(state_ && "StartWrite() on invalid AsyncHandle value");
- state_->StartWrite(buffer, size);
-}
-
-void AsyncHandle::StartConnect() {
- assert(state_ && "StartConnect() on invalid AsyncHandle value");
- state_->StartConnect();
-}
-
-void AsyncHandle::StartAccept() {
- assert(state_ && "StartAccept() on invalid AsyncHandle value");
- state_->StartAccept();
-}
-
-IpcHandle AsyncHandle::TakeAcceptedHandle() {
- assert(state_ && "TakeAcceptedHandle() on invalid AsyncHandle value");
- return state_->TakeAcceptedHandle();
-}
-
-AsyncLoop& AsyncHandle::async_loop() const {
- assert(state_ && "async_loop() on invalid AsyncHandle value");
- return state_->async_loop();
-}
-
-///////////////////////////////////////////////////////////////////////////
-///
-/// AsyncTimer
-///
-
-AsyncTimer::AsyncTimer() = default;
-
-AsyncTimer::AsyncTimer(AsyncLoop& async_loop, AsyncTimer::Callback&& callback)
- : state_(new State(async_loop, std::move(callback))) {}
-
-AsyncTimer::~AsyncTimer() = default;
-
-AsyncTimer::AsyncTimer(AsyncTimer&&) noexcept = default;
-AsyncTimer& AsyncTimer::operator=(AsyncTimer&&) noexcept = default;
-
-void AsyncTimer::ResetCallback(AsyncTimer::Callback&& callback) {
- assert(state_ && "Calling AsyncTimer::ResetCallback() on invalid instance!");
- state_->ResetCallback(std::move(callback));
-}
-void AsyncTimer::SetExpirationMs(int64_t expiration_ms) {
- assert(state_ &&
- "Calling AsyncTimer::SetExpirationMs() on invalid instance!");
- state_->SetExpirationMs(expiration_ms);
-}
-
-void AsyncTimer::SetDurationMs(int64_t duration_ms) {
- assert(state_ && "Calling AsyncTimer::SetDurationMs() on invalid instance!");
- state_->SetDurationMs(duration_ms);
-}
-
-void AsyncTimer::Cancel() {
- assert(state_ && "Calling AsyncTimer::Cancel() on invalid instance!");
- state_->Cancel();
-}
-
-void AsyncTimer::Close() {
- state_.reset();
-}
-
-AsyncLoop& AsyncTimer::async_loop() const {
- assert(state_ && "Calling AsyncTimer::async_loop() on invalid instance!");
- return state_->async_loop();
-}
-
-// static
-AsyncTimer AsyncTimer::CreateWithExpiration(int64_t expiration_ms,
- AsyncLoop& async_loop,
- AsyncTimer::Callback&& callback) {
- AsyncTimer timer(async_loop, std::move(callback));
- timer.SetExpirationMs(expiration_ms);
- return timer;
-}
-
-// static
-AsyncTimer AsyncTimer::CreateWithDuration(int64_t duration_ms,
- AsyncLoop& async_loop,
- AsyncTimer::Callback&& callback) {
- AsyncTimer timer(async_loop, std::move(callback));
- timer.SetDurationMs(duration_ms);
- return timer;
-}
diff --git a/src/async_loop.h b/src/async_loop.h
deleted file mode 100644
index fd83729..0000000
--- a/src/async_loop.h
+++ /dev/null
@@ -1,471 +0,0 @@
-// Copyright 2023 Google Inc. All Rights Reserved.
-//
-// Licensed under the Apache License, Version 2.0 (the "License");
-// you may not use this file except in compliance with the License.
-// You may obtain a copy of the License at
-//
-// http://www.apache.org/licenses/LICENSE-2.0
-//
-// Unless required by applicable law or agreed to in writing, software
-// distributed under the License is distributed on an "AS IS" BASIS,
-// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-// See the License for the specific language governing permissions and
-// limitations under the License.
-
-#ifndef NINJA_ASYNC_LOOP_H
-#define NINJA_ASYNC_LOOP_H
-
-#include "ipc_handle.h"
-
-#ifndef _WIN32
-#include <signal.h>
-#endif
-
-#include <functional>
-#include <memory>
-
-/// AsyncLoop provides an abstraction to perform asynchronous i/o
-/// operations on Posix and Win32. Its API is inspired by Win32
-/// overlapped operations, since this model can be implemented
-/// efficiently on Posix.
-///
-/// AsyncHandle wraps an i/o handle, and a user-provided callback.
-/// It provides methods like StartRead() to initiate an asynchronous operation.
-///
-/// AsyncTimer wraps an expiration date and a user-provided callback.
-/// It provides SetExpirationMs() and SetDurationMs() methods to indicate
-/// when the timer's next expiration should occur.
-///
-/// Each AsyncHandle or AsyncTimer instance is scoped to a parent AsyncLoop
-/// instance.
-///
-/// Example usage:
-///
-/// 1) Obtain a reference to an AsyncLoop instance, e.g. by
-/// calling AsyncLoop::Get() or AsyncLoop::CreateLocal().
-///
-/// 2) Create as many AsyncHandle and AsyncTimer instances from
-/// the parent loop as needed. passing a user-provided callback
-/// when constructing each one of them.
-///
-/// 4) Use AsyncHandle::StartXXX() methods to start an i/o asynchronous
-/// operation, or AsyncTimer::Set{Expiration,Duration}Ms() to set a
-/// timer's expiration time.
-///
-/// 5) Call AsyncLoop::RunOnce() or AsyncLoop::RunUntil() to run the
-/// the loop. This waits for the completion of async i/o events or
-/// expiration of timers, and invokes their callbacks automatically.
-///
-/// Using AsyncLoop::RunOnce(-1) will wait until one of the following
-/// happens:
-///
-/// - There are no more active handles or timers, in which case
-/// the function returns immediately with AsyncLoop::ExitIdle.
-///
-/// - At least one AsyncHandle's i/o operation completes, in which
-/// case their callbacks are invoked before the function returns
-/// AsyncLoop::ExitSuccess.
-///
-/// - At least one AsyncTimer expires, in which case their callbacks
-/// are invoked before the function returns AsyncLoop::ExitSuccess.
-///
-/// - If the AsyncLoop's interrupt catching feature is enabled (see
-/// below), return immediately with AsyncLoop::ExitInterrupted.
-///
-/// It is also possible to pass a timeout in milliseconds, e.g.
-/// calling AsyncLoop::RunOnce(1000) to wait for one second. If the
-/// timeout expires without an i/o completion or timer expiration,
-/// the function returns with AsyncLoop::ExitTimeout.
-///
-/// Calling AsyncLoop::RunUntil() is more convenient as it allows to
-/// wait for specific conditions instead.
-///
-/// Some important points:
-///
-/// - There is a global AsyncLoop instance which can be
-/// retrieved with AsyncLoop::Get(), this is meant to be
-/// used from the main thread only.
-///
-/// - Use AsyncLoop::CreateLocal() to create additionnal
-/// AsyncLoop instances. This can be useful to run them in
-/// background threads.
-///
-/// - It is a runtime error to destroy an AsyncLoop before any of its
-/// children AsyncHandle or AsyncTimer instances (assertion failure on
-/// debug build).
-///
-/// - An AsyncLoop instance can catch interrupts (i.e. Ctrl-C
-/// on Windows, and SIGINT/SIGUP/SIGTERM on Posix) automatically
-/// and report them in AsyncLoop::ExitStatus.
-///
-/// IMPORTANT: At the moment, the global AsyncLoop always catches
-/// interrupts by default. This may change in the future.
-/// TODO(digit): Change this and make all uses explicit.
-///
-/// Only one AsyncLoop instance can catch interrupts at any
-/// given time. Use AsyncLoop::ScopedInterruptCatcher if you
-/// want to force a given AsyncLoop instance to catch
-/// interrupts (see its documentation below for details).
-///
-/// - Once a timer expires, it must be re-armed explicitly, which can
-/// be done by calling its Set{Expiration,Duration}Ms() method directly
-/// from its callback.
-///
-/// - Similarly, it is possible (and actually the most efficient path)
-/// to start another i/o operation right from the completion callback
-/// of an AsyncHandle instance.
-///
-/// - AsyncLoop::RunOnce() and AsyncLoop::RunUntil() are not re-entrant,
-/// meaning one should not call them from completion / expiration callbacks.
-///
-/// On the other hand, creating / deleting AsyncHandle / AsyncTimer instances
-/// within callbacks is supported.
-///
-/// - There is no method to cancel all asynchronous operations
-/// associated with a handle, or to detach all handles. This
-/// is intentional.
-
-/// AsyncError is an error code returned by a failed asynchronous operation.
-/// On Win32, this is a GetLastError() value, while on Posix this is an errno
-/// value. Always 0 to indicate that there is no error.
-#ifdef _WIN32
-using AsyncError = DWORD;
-#else
-using AsyncError = int;
-#endif
-
-/// Forward declaration.
-class AsyncLoop;
-
-/// Convert AsyncError to string.
-std::string AsyncErrorToString(AsyncError error);
-
-/// Scoped AsyncHandle type that only supports one async operation
-/// at a time.
-class AsyncHandle {
- public:
- /// The type of a callable object that will be invoked when an
- /// asynchronous operation completes. The first argument is an error
- /// code and will be 0 in case of success. The second argument is
- /// the transfer size, and will be 0 to connect and accept operations.
- using Callback = std::function<void(AsyncError, size_t)>;
-
- /// Default constructor creates an empty instance.
- AsyncHandle();
-
- /// Destructor, closes the handle automatically.
- ~AsyncHandle();
-
- /// Move operations.
- AsyncHandle(AsyncHandle&&) noexcept;
- AsyncHandle& operator=(AsyncHandle&&) noexcept;
-
- /// Create new instance that takes ownership of |native_handle|.
- static AsyncHandle Create(IpcHandle::HandleType native_handle,
- AsyncLoop& async_loop, Callback&& callback);
-
- /// Create a new instance that duplicates |native_handle| and takes
- /// ownership of the resulting handle. Note that the duplicate is
- /// not inheritable and will be in non-blocking mode on Posix.
- static AsyncHandle CreateClone(IpcHandle::HandleType native_handle,
- AsyncLoop& async_loop, Callback&& callback);
-
- /// Create new instance that takes ownership of the native handle
- /// from |handle|. Note that when |handle| is an IpcServiceHandle instance,
- /// then it should only be destroyed _after_ this instance, in order to
- /// perform proper cleanups on MacOS (i.e. remove a Unix domain socket and
- /// pid file), even though ownership of the native handle itself was passed
- /// to this AsyncHandle instance.
- static AsyncHandle Create(IpcHandle handle, AsyncLoop& async_loop,
- Callback&& callback);
-
- /// Close handle
- void Close();
-
- /// Release native handle ownership to caller.
- /// Note that this cancels any async operation for the handle.
- IpcHandle::HandleType Release();
-
- /// Return true if the native handle is valid, and was not released.
- bool is_valid() const;
-
- /// Return value of native handle, but does not transfer ownership.
- IpcHandle::HandleType native_handle() const;
-
- /// Conversion to bool, equivalent to is_valid().
- operator bool() const { return is_valid(); }
-
- /// Return true if an asynchronous operation was started and
- /// Did not complete yet.
- bool IsRunning() const;
-
- /// Cancel current asynchronous operation, if any.
- void Cancel();
-
- /// Change the callback for this instance.
- AsyncHandle& ResetCallback(Callback&& cb);
-
- /// Reset instance with a new native handle, keeping the same AsyncLoop
- /// reference, and same callback. Calls Cancel() implicitly.
- void ResetHandle(IpcHandle handle);
-
- /// Start an asynchronous read operation. Cancels any previous operation.
- void StartRead(void* buffer, size_t size);
-
- /// Start an asynchronous write operation. Cancels any previous operation.
- void StartWrite(const void* buffer, size_t size);
-
- /// Start an asynchronous connect operation. Cancels any previous operation.
- /// Note that this instance's handle should be the result of an
- /// IpcServiceHandle::AsyncConnectTo() operation.
- void StartConnect();
-
- /// Start an asynchronous accept operation. Note that in case of success,
- /// the client handle should be retrieved with TakeAcceptedHandle();
- /// Cancels any previous operation.
- /// Note that this instance's handle must be the result of an
- /// IpcServiceHandle::BindTo() call.
- void StartAccept();
-
- /// Return the client handle corresponding to the last successful
- /// asynchronous accept operation.
- IpcHandle TakeAcceptedHandle();
-
- /// Return AsyncLoop pointer from this handle. Will be nullptr if
- /// handle is invalid (i.e. after an explicit Close()).
- AsyncLoop& async_loop() const;
-
- /// Opaque type for platform-dependent asynchronous operation.
- class State;
-
- protected:
- /// Private constructor, use AsyncLoop::CreateHandle() to
- /// create a new non-default instance.
- explicit AsyncHandle(std::unique_ptr<State> state);
-
- std::unique_ptr<State> state_;
-};
-
-class AsyncTimer {
- public:
- using Callback = std::function<void(void)>;
-
- // Default constructor.
- AsyncTimer();
-
- // Constructor.
- AsyncTimer(AsyncLoop& async_loop, Callback&& callback);
-
- /// Destructor. Cancels the timer automatically.
- ~AsyncTimer();
-
- /// Move operations are allowed.
- AsyncTimer(AsyncTimer&&) noexcept;
- AsyncTimer& operator=(AsyncTimer&&) noexcept;
-
- /// Return true if this instance is valid (i.e. not default constructed).
- bool is_valid() const { return !!state_; }
- operator bool() const { return is_valid(); }
-
- /// Set the expiration time for this timer. After this the callback
- /// will be invoked once.
- void SetExpirationMs(int64_t expiration_ms);
-
- /// Set a duration after which the timer will expire.
- void SetDurationMs(int64_t duration_ms);
-
- /// Cancel this timer (remove any expiration).
- void Cancel();
-
- /// Close the timer before destruction (makes it invalid).
- void Close();
-
- /// Reset the callback for this instance.
- void ResetCallback(Callback&& callback);
-
- /// Construct a new timer and set its expiration time directly.
- static AsyncTimer CreateWithExpiration(int64_t expiration_ms,
- AsyncLoop& async_loop,
- Callback&& callback);
-
- /// Construct a new timer and set its duration period directly.
- static AsyncTimer CreateWithDuration(int64_t duration_ms,
- AsyncLoop& async_loop,
- Callback&& callback);
-
- /// Retrieve reference to AsyncLoop this timer belongs to.
- /// NOTE: It is a runtime error to call this on an invalid instance.
- AsyncLoop& async_loop() const;
-
- class State;
-
- private:
- std::unique_ptr<State> state_;
-};
-
-/// A class used to create asynchronous operations and wait for their
-/// completion with a possible timeout. This also detect user interruptions
-/// through Ctrl-C / SIGINT / SIGTERM / SIGHUP.
-///
-class AsyncLoop {
- public:
- /// Destructor
- ~AsyncLoop();
-
- /// Retrieve reference to global instance. Created on demand.
- /// This instance always catches interrupts by default.
- static AsyncLoop& Get();
-
- /// Create a new instance independent from the global one. It does _not_
- /// catches interrupts by default. This instance will have its own set of
- /// timer and async IDs.
- static std::unique_ptr<AsyncLoop> CreateLocal();
-
- /// Destroy current global instance. Only use this for testing.
- static void ResetForTesting();
-
-#ifdef _WIN32
- using NativeHandle = HANDLE;
-#else
- using NativeHandle = int;
-#endif
-
- /// Each asynchonous operation is identified by a unique, non-zero, ID.
- using AsyncId = uint32_t;
-
- /// Return current time in milliseconds. Epoch is undetermined
- /// but all values are guaranteed to be non-negative.
- static int64_t NowMs();
-
- /// Possible return values for RunOnce() method.
- enum ExitStatus {
- ExitIdle = 0, // no more async ops or timers to wait for.
- ExitSuccess, // at least one async op completed or timer expired.
- ExitTimeout, // timeout expired.
- ExitInterrupted, // user interruption detected.
- };
-
- /// Run the loop once with a timeout. This function only returns after
- /// a least one async operation / timer has completed, or on expiration,
- /// or a user interrupt. A negative |timeout_ms| value corresponds to no
- /// timeout at all, but the function may return with ExitIdle if there
- /// are no more async operations registered. Note that ExitIdle
- /// _cannot_ be returned if the value of |timeout_ms| is not negative.
- /// Also the function cannot return ExitInterrupted if interrupt catching
- /// is not enabled for this AsyncLoop instance.
- ExitStatus RunOnce(int64_t timeout_ms);
-
- /// Run the loop until a given condition is met, or an interrupt is
- /// detected, or a timeout expires. This will return ExitSuccess,
- /// ExitInterrupted and ExitTimeout respectively.
- ///
- /// Also, if no timeout is specified (i.e. the value of |timeout_ms|
- /// is negative), this will return ExitIdle if there are no more
- /// registered async operations or active timers.
- ///
- /// |condition| is a predicate to check for the condition, whose
- /// value only depends on variables modified by async handlers or
- /// timers.
- ///
- template <typename PREDICATE>
- ExitStatus RunUntil(PREDICATE condition, int64_t timeout_ms = -1) {
- RunUntilState state(timeout_ms);
- do {
- if (condition())
- return ExitSuccess;
- } while (state.LoopAgain(*this));
- return state.status();
- }
-
- /// Clear the interrupt flag after it has been acknowledged by the caller.
- void ClearInterrupt();
-
-#ifndef _WIN32
- /// Return the signal number after RunOnce() returns with ExitInterrupted.
- int GetInterruptSignal() const;
-
- /// Return the process signal mask that was set before this instance was
- /// created (since the constructor blocks all signals).
- sigset_t GetOldSignalMask() const;
-#endif
-
- /// Completely reset the instance, forgetting about all registered
- /// async operations and timers, only the interrupt catcher count is
- /// preserved.
- void Reset();
-
- /// Convenience struct that allows to temporarily redirect interrupts
- /// (i.e. Ctrl-C on Windows, and SIGINT/SIGHUP/SIGTERM on Posix) to
- /// a given AsyncLoop instance. Note that only one AsyncLoop instance can
- /// catch them at any given point in the process.
- ///
- /// Usage is simply:
- ///
- /// {
- /// AsyncLoop::ScopedInterruptCatcher catcher(async_loop);
- ///
- /// ... all interrupts redirect to |async_loop| until the
- /// ... destructor is called.
- /// }
- ///
- /// It is safe to nest multiple catchers, which can even refer to the
- /// same async_loop. Only the most-nested instance will get the interrupts.
- ///
- struct ScopedInterruptCatcher {
- explicit ScopedInterruptCatcher(AsyncLoop& async_loop)
- : async_loop_(async_loop) {
- async_loop_.ChangeInterruptCatcher(true);
- }
-
- ~ScopedInterruptCatcher() { async_loop_.ChangeInterruptCatcher(false); }
-
- AsyncLoop& async_loop_;
- };
-
- private:
- friend class AsyncHandle::State;
- friend class AsyncTimer::State;
- friend class AsyncLoopTimers;
-
- AsyncLoop();
-
- // Used internally to implement AsyncHandles.
- void AttachHandle(AsyncHandle::State* state);
- void DetachHandle(AsyncHandle::State* state);
- void UpdateHandle(AsyncHandle::State* state);
- void CancelHandle(AsyncHandle::State* state);
-
- void AttachTimer(AsyncTimer::State* state);
- void DetachTimer(AsyncTimer::State* state);
- void UpdateTimer(AsyncTimer::State* state);
-
- /// Internal struct used by RunUntil() template instantiations.
- struct RunUntilState {
- /// Constructor sets up the state.
- RunUntilState(int64_t timeout_ms);
-
- /// Call this method to call RunOnce() to drain events or
- /// timers. Returns true to indicate that the function
- /// must be called again, and false in case of exit
- /// condition (reported by status()).
- bool LoopAgain(AsyncLoop& async_loop);
-
- /// Return final status, only valid after LoopAgain()
- /// returns false. Cannot be ExitSuccess.
- ExitStatus status() const { return status_; }
-
- int64_t timeout_ms_;
- int64_t expiration_ms_ = -1;
- ExitStatus status_ = ExitIdle;
- };
-
- /// Used internally by ScopedInterruptCatcher class.
- void ChangeInterruptCatcher(bool increment);
-
- /// Implementation details hidden from this header intentionally.
- class Impl;
- std::unique_ptr<Impl> impl_;
- int interrupt_catcher_count_ = 0;
-};
-
-#endif // NINJA_ASYNC_LOOP_H
diff --git a/src/async_loop_test.cc b/src/async_loop_test.cc
deleted file mode 100644
index c14c08d..0000000
--- a/src/async_loop_test.cc
+++ /dev/null
@@ -1,271 +0,0 @@
-// Copyright 2023 Google Inc. All Rights Reserved.
-//
-// Licensed under the Apache License, Version 2.0 (the "License");
-// you may not use this file except in compliance with the License.
-// You may obtain a copy of the License at
-//
-// http://www.apache.org/licenses/LICENSE-2.0
-//
-// Unless required by applicable law or agreed to in writing, software
-// distributed under the License is distributed on an "AS IS" BASIS,
-// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-// See the License for the specific language governing permissions and
-// limitations under the License.
-
-#include "async_loop.h"
-
-// This file also includes tests for the AsyncLoopTimers class.
-#include "async_loop_timers.h"
-#include "ipc_handle.h"
-#include "test.h"
-
-static AsyncLoop& GetNewLoop() {
- AsyncLoop::ResetForTesting();
- return AsyncLoop::Get();
-}
-
-TEST(AsyncLoop, NowMs) {
- AsyncLoop& loop = GetNewLoop();
- // Ensure the result of NowMs() is always positive, otherwise many
- // things will not work correctly since a negative expiration date is
- // interpreted as infinite.
- EXPECT_GE(loop.NowMs(), 0LL);
-}
-
-// Helper type to store async operation results.
-struct AsyncResult {
- bool completed = false;
- AsyncError error = 0;
- size_t size = 0;
-
- AsyncHandle::Callback callback() {
- return [this](AsyncError error, size_t size) {
- this->completed = true;
- this->error = error;
- this->size = size;
- };
- }
-};
-
-TEST(AsyncLoop, AsyncHandleStartRead) {
- std::string err_msg;
- IpcHandle read_handle, write_handle;
- bool ret = IpcHandle::CreateAsyncPipe(&read_handle, &write_handle, &err_msg);
- if (!ret)
- fprintf(stderr, "CreatePipe() error: %s\n", err_msg.c_str());
- ASSERT_TRUE(ret);
-
- AsyncLoop& loop = GetNewLoop();
- char read_buffer[10] = {};
-
- AsyncResult result;
- auto async_handle =
- AsyncHandle::Create(std::move(read_handle), loop, result.callback());
- async_handle.StartRead(read_buffer, sizeof(read_buffer));
-
- // Nothing should be accepted in the next 50ms
- auto status = loop.RunOnce(50);
- EXPECT_EQ(AsyncLoop::ExitTimeout, status);
- EXPECT_FALSE(result.completed);
-
- // Write to the pipe.
- char buf[1] = { 'x' };
- EXPECT_EQ(1, write_handle.Write(buf, sizeof(buf), &err_msg));
-
- status = loop.RunOnce(50);
- EXPECT_EQ(AsyncLoop::ExitSuccess, status);
- EXPECT_TRUE(result.completed);
- EXPECT_EQ(0u, result.error);
- EXPECT_EQ(1u, result.size);
- EXPECT_EQ('x', read_buffer[0]);
-}
-
-TEST(AsyncLoop, AsyncHandleStartWrite) {
- std::string err_msg;
- IpcHandle read_handle, write_handle;
- bool ret = IpcHandle::CreateAsyncPipe(&read_handle, &write_handle, &err_msg);
- if (!ret)
- fprintf(stderr, "CreatePipe() error: %s\n", err_msg.c_str());
- ASSERT_TRUE(ret);
-
- AsyncLoop& loop = GetNewLoop();
- const char buffer[] = "foo bar";
-
- AsyncResult result;
- auto async_handle =
- AsyncHandle::Create(std::move(write_handle), loop, result.callback());
- async_handle.StartWrite(buffer, sizeof(buffer));
-
- // Writing should work directly.
- auto status = loop.RunOnce(50);
- EXPECT_EQ(AsyncLoop::ExitSuccess, status);
-
- EXPECT_TRUE(result.completed);
- EXPECT_EQ(0u, result.error);
- EXPECT_EQ(sizeof(buffer), result.size);
-
- // Read from pipe synchronously.
- char read_buffer[sizeof(buffer)];
- ssize_t actual_bytes =
- read_handle.Read(read_buffer, sizeof(buffer), &err_msg);
- EXPECT_EQ(sizeof(buffer), static_cast<size_t>(actual_bytes));
-}
-
-TEST(AsyncLoop, AsyncHandleStartAccept) {
- std::string err_msg;
- auto server_handle = IpcServiceHandle::BindTo("test_service", &err_msg);
- if (!server_handle)
- fprintf(stderr, "BindTo() error: %s\n", err_msg.c_str());
- ASSERT_TRUE(server_handle);
-
- AsyncLoop& loop = GetNewLoop();
-
- AsyncResult result;
- auto async_handle =
- AsyncHandle::Create(std::move(server_handle), loop, result.callback());
- async_handle.StartAccept();
-
- // Nothing should be accepted in the next 50ms
- auto status = loop.RunOnce(50);
- EXPECT_EQ(AsyncLoop::ExitTimeout, status);
- EXPECT_FALSE(result.completed);
-
- // Synchronous connect.
- IpcHandle client = IpcServiceHandle::ConnectTo("test_service", &err_msg);
- if (!client)
- fprintf(stderr, "ConnectTo() error: %s\n", err_msg.c_str());
- ASSERT_TRUE(client);
-
- status = loop.RunOnce(50);
- EXPECT_EQ(AsyncLoop::ExitSuccess, status);
- EXPECT_TRUE(result.completed);
- EXPECT_EQ(0, result.error);
-
- IpcHandle accept_handle = async_handle.TakeAcceptedHandle();
- EXPECT_TRUE(accept_handle);
- EXPECT_NE(accept_handle.native_handle(), client.native_handle());
-}
-
-TEST(AsyncLoop, AsyncHandleStartConnect) {
- std::string err_msg;
- auto server_handle = IpcServiceHandle::BindTo("test_service", &err_msg);
- if (!server_handle)
- fprintf(stderr, "BindTo() error: %s\n", err_msg.c_str());
- ASSERT_TRUE(server_handle);
-
- bool did_connect = false;
- IpcHandle client_handle =
- IpcServiceHandle::AsyncConnectTo("test_service", &did_connect, &err_msg);
- if (!client_handle)
- fprintf(stderr, "AsyncClientTo() error: %s\n", err_msg.c_str());
- ASSERT_TRUE(client_handle);
-
- (void)did_connect; // ignored intentionally.
-
- AsyncLoop& loop = GetNewLoop();
-
- AsyncResult result;
- auto async_handle =
- AsyncHandle::Create(std::move(client_handle), loop, result.callback());
- async_handle.StartConnect();
-
- auto status = loop.RunOnce(50);
- EXPECT_EQ(AsyncLoop::ExitSuccess, status);
- EXPECT_TRUE(result.completed);
- EXPECT_EQ(0, result.error);
- EXPECT_EQ(0, result.size);
-}
-
-TEST(AsyncLoop, RunUntil) {
- AsyncLoop& loop = GetNewLoop();
-
- auto always_false = []() { return false; };
-
- auto status = loop.RunUntil(always_false, -1);
- EXPECT_EQ(AsyncLoop::ExitIdle, status);
-
- status = loop.RunUntil(always_false, 10);
- EXPECT_EQ(AsyncLoop::ExitTimeout, status);
-
- bool flag = false;
- auto flag_is_set = [&flag]() { return flag; };
- AsyncTimer timer(loop, [&flag]() { flag = true; });
-
- timer.SetDurationMs(100LL);
- status = loop.RunUntil(flag_is_set, -1);
- EXPECT_EQ(AsyncLoop::ExitSuccess, status);
-
- flag = false;
- timer.SetDurationMs(1000LL);
- status = loop.RunUntil(flag_is_set, 10LL);
- EXPECT_EQ(AsyncLoop::ExitTimeout, status);
-
- status = loop.RunUntil(flag_is_set, -1);
- EXPECT_EQ(AsyncLoop::ExitSuccess, status);
-}
-
-TEST(AsyncLoop, TimerTest) {
- AsyncLoop& loop = GetNewLoop();
- int counter = 0;
- AsyncTimer timer_1(loop, [&counter]() { counter += 1; });
- timer_1.SetDurationMs(100LL);
- EXPECT_EQ(AsyncLoop::ExitTimeout, loop.RunOnce(0));
- EXPECT_EQ(0, counter);
-
- EXPECT_EQ(AsyncLoop::ExitSuccess, loop.RunOnce(200));
- EXPECT_EQ(1, counter);
-}
-
-TEST(AsyncLoopTimers, Test) {
- AsyncLoopTimers timers;
-
- EXPECT_EQ(-1LL, timers.ComputeNextExpiration());
-
- int counter = 0;
-
- // Create local loop, required by AsyncTimer::State construtor
- // but not used by the test though because its RunOnce() method is never
- // called.
- auto loop = AsyncLoop::CreateLocal();
-
- auto timer_1 = std::unique_ptr<AsyncTimer::State>(
- new AsyncTimer::State(*loop, [&counter]() { counter += 1; }));
-
- auto timer_2 = std::unique_ptr<AsyncTimer::State>(
- new AsyncTimer::State(*loop, [&counter]() { counter += 100; }));
-
- timers.AttachTimer(timer_1.get());
- timers.AttachTimer(timer_2.get());
-
- EXPECT_EQ(-1LL, timers.ComputeNextExpiration());
-
- timer_1->SetExpirationMs(100LL);
-
- EXPECT_EQ(100LL, timers.ComputeNextExpiration());
- EXPECT_EQ(0, counter);
-
- timer_2->SetExpirationMs(200LL);
- EXPECT_EQ(100LL, timers.ComputeNextExpiration());
- EXPECT_EQ(0, counter);
-
- EXPECT_FALSE(timers.ProcessExpiration(99LL));
- EXPECT_EQ(100LL, timers.ComputeNextExpiration());
- EXPECT_EQ(0, counter);
-
- EXPECT_TRUE(timers.ProcessExpiration(100LL));
- EXPECT_EQ(1, counter);
- EXPECT_EQ(200LL, timers.ComputeNextExpiration());
-
- EXPECT_TRUE(timers.ProcessExpiration(200LL));
- EXPECT_EQ(101, counter);
- EXPECT_EQ(-1LL, timers.ComputeNextExpiration());
-
- timer_1->SetExpirationMs(200LL);
- timers.DetachTimer(timer_1.get());
- timers.DetachTimer(timer_2.get());
-
- EXPECT_EQ(-1LL, timers.ComputeNextExpiration());
-
- EXPECT_FALSE(timers.ProcessExpiration(300LL));
- EXPECT_EQ(101, counter);
-}
diff --git a/src/async_loop_timers.h b/src/async_loop_timers.h
deleted file mode 100644
index 0b93020..0000000
--- a/src/async_loop_timers.h
+++ /dev/null
@@ -1,135 +0,0 @@
-// Copyright 2023 Google Inc. All Rights Reserved.
-//
-// Licensed under the Apache License, Version 2.0 (the "License");
-// you may not use this file except in compliance with the License.
-// You may obtain a copy of the License at
-//
-// http://www.apache.org/licenses/LICENSE-2.0
-//
-// Unless required by applicable law or agreed to in writing, software
-// distributed under the License is distributed on an "AS IS" BASIS,
-// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-// See the License for the specific language governing permissions and
-// limitations under the License.
-
-#ifndef NINJA_ASYNC_LOOP_TIMERS_H
-#define NINJA_ASYNC_LOOP_TIMERS_H
-
-#include <algorithm>
-#include <vector>
-
-#include "async_loop.h"
-
-class AsyncTimer::State {
- public:
- State(AsyncLoop& async_loop, AsyncTimer::Callback&& callback)
- : async_loop_(async_loop), callback_(std::move(callback)) {
- async_loop_.AttachTimer(this);
- }
-
- ~State() { async_loop_.DetachTimer(this); }
-
- AsyncLoop& async_loop() const { return async_loop_; }
-
- // Return true if this instance is active.
- bool active() const { return expiration_ms_ >= 0; }
-
- int64_t expiration_ms() const { return expiration_ms_; }
-
- void ResetCallback(AsyncTimer::Callback&& callback) {
- callback_ = std::move(callback);
- }
-
- void SetExpirationMs(int64_t expiration_ms) {
- expiration_ms_ = expiration_ms;
- async_loop_.UpdateTimer(this);
- }
-
- void SetDurationMs(int64_t duration_ms) {
- SetExpirationMs(async_loop_.NowMs() + duration_ms);
- }
-
- void Cancel() { SetExpirationMs(-1); }
-
- void Invoke() {
- expiration_ms_ = -1;
- callback_();
- }
-
- private:
- AsyncLoop& async_loop_;
- int64_t expiration_ms_ = -1;
- AsyncTimer::Callback callback_;
-};
-
-/// Common class used by all AsyncLoop implementation to manage timers.
-class AsyncLoopTimers {
- public:
- void AttachTimer(AsyncTimer::State* timer) { timers_.push_back(timer); }
-
- void DetachTimer(AsyncTimer::State* timer) {
- pending_.erase(timer);
- timers_.erase(timer);
- }
-
- void UpdateTimer(AsyncTimer::State* timer) { pending_.erase(timer); }
-
- /// Compute the next expiration time in milliseconds, or return -1 if
- /// not timer is active.
- int64_t ComputeNextExpiration() const {
- int64_t result = -1;
- for (const auto* timer : timers_) {
- if (!timer->active())
- continue;
- if (result < 0)
- result = timer->expiration_ms();
- else if (result > timer->expiration_ms())
- result = timer->expiration_ms();
- }
- return result;
- }
-
- /// Compute the set of pending timers at a given time.
- /// Return true if any timer expired, false otherwise.
- bool ProcessExpiration(int64_t now_ms) {
- // First compute the list of pending timers.
- pending_.clear();
- for (auto* timer : timers_) {
- if (timer->active() && timer->expiration_ms() <= now_ms)
- pending_.push_back(timer);
- }
-
- if (pending_.empty())
- return false;
-
- // Then process it. Each callback can end up calling ResetExpiration()
- // or Destroy() which will remove or deactivate pending timers so do
- // not assume that each id in the list is valid on each iteration.
- do {
- AsyncTimer::State* state = pending_.back();
- pending_.pop_back();
- state->Invoke();
- } while (!pending_.empty());
-
- return true;
- }
-
- // Return true if there are no timers in this set.
- bool empty() const { return timers_.empty(); }
-
- private:
- struct TimerList : public std::vector<AsyncTimer::State*> {
- void erase(AsyncTimer::State* state) {
- auto it = std::find(begin(), end(), state);
- if (it != end()) {
- *it = back();
- pop_back();
- }
- }
- };
-
- TimerList timers_;
- TimerList pending_;
-};
-
-#endif // NINJA_ASYNC_LOOP_TIMERS_H
diff --git a/src/browse.cc b/src/browse.cc
deleted file mode 100644
index 76bee07..0000000
--- a/src/browse.cc
+++ /dev/null
@@ -1,80 +0,0 @@
-// Copyright 2011 Google Inc. All Rights Reserved.
-//
-// Licensed under the Apache License, Version 2.0 (the "License");
-// you may not use this file except in compliance with the License.
-// You may obtain a copy of the License at
-//
-// http://www.apache.org/licenses/LICENSE-2.0
-//
-// Unless required by applicable law or agreed to in writing, software
-// distributed under the License is distributed on an "AS IS" BASIS,
-// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-// See the License for the specific language governing permissions and
-// limitations under the License.
-
-#include "browse.h"
-
-#include <errno.h>
-#include <stdio.h>
-#include <stdlib.h>
-#include <unistd.h>
-#include <vector>
-
-#include "build/browse_py.h"
-
-using namespace std;
-
-void RunBrowsePython(State* state, const char* ninja_command,
- const char* input_file, int argc, char* argv[]) {
- // Fork off a Python process and have it run our code via its stdin.
- // (Actually the Python process becomes the parent.)
- int pipefd[2];
- if (pipe(pipefd) < 0) {
- perror("ninja: pipe");
- return;
- }
-
- pid_t pid = fork();
- if (pid < 0) {
- perror("ninja: fork");
- return;
- }
-
- if (pid > 0) { // Parent.
- close(pipefd[1]);
- do {
- if (dup2(pipefd[0], 0) < 0) {
- perror("ninja: dup2");
- break;
- }
-
- std::vector<const char *> command;
- command.push_back(NINJA_PYTHON);
- command.push_back("-");
- command.push_back("--ninja-command");
- command.push_back(ninja_command);
- command.push_back("-f");
- command.push_back(input_file);
- for (int i = 0; i < argc; i++) {
- command.push_back(argv[i]);
- }
- command.push_back(NULL);
- execvp(command[0], (char**)&command[0]);
- if (errno == ENOENT) {
- printf("ninja: %s is required for the browse tool\n", NINJA_PYTHON);
- } else {
- perror("ninja: execvp");
- }
- } while (false);
- _exit(1);
- } else { // Child.
- close(pipefd[0]);
-
- // Write the script file into the stdin of the Python process.
- ssize_t len = write(pipefd[1], kBrowsePy, sizeof(kBrowsePy));
- if (len < (ssize_t)sizeof(kBrowsePy))
- perror("ninja: write");
- close(pipefd[1]);
- exit(0);
- }
-}
diff --git a/src/browse.h b/src/browse.h
deleted file mode 100644
index 8d6d285..0000000
--- a/src/browse.h
+++ /dev/null
@@ -1,28 +0,0 @@
-// Copyright 2011 Google Inc. All Rights Reserved.
-//
-// Licensed under the Apache License, Version 2.0 (the "License");
-// you may not use this file except in compliance with the License.
-// You may obtain a copy of the License at
-//
-// http://www.apache.org/licenses/LICENSE-2.0
-//
-// Unless required by applicable law or agreed to in writing, software
-// distributed under the License is distributed on an "AS IS" BASIS,
-// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-// See the License for the specific language governing permissions and
-// limitations under the License.
-
-#ifndef NINJA_BROWSE_H_
-#define NINJA_BROWSE_H_
-
-struct State;
-
-/// Run in "browse" mode, which execs a Python webserver.
-/// \a ninja_command is the command used to invoke ninja.
-/// \a args are the number of arguments to be passed to the Python script.
-/// \a argv are arguments to be passed to the Python script.
-/// This function does not return if it runs successfully.
-void RunBrowsePython(State* state, const char* ninja_command,
- const char* input_file, int argc, char* argv[]);
-
-#endif // NINJA_BROWSE_H_
diff --git a/src/browse.py b/src/browse.py
deleted file mode 100755
index b125e80..0000000
--- a/src/browse.py
+++ /dev/null
@@ -1,231 +0,0 @@
-#!/usr/bin/env python3
-#
-# Copyright 2001 Google Inc. All Rights Reserved.
-#
-# Licensed under the Apache License, Version 2.0 (the "License");
-# you may not use this file except in compliance with the License.
-# You may obtain a copy of the License at
-#
-# http://www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing, software
-# distributed under the License is distributed on an "AS IS" BASIS,
-# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-# See the License for the specific language governing permissions and
-# limitations under the License.
-
-"""Simple web server for browsing dependency graph data.
-
-This script is inlined into the final executable and spawned by
-it when needed.
-"""
-
-try:
- import http.server as httpserver
- import socketserver
-except ImportError:
- import BaseHTTPServer as httpserver
- import SocketServer as socketserver
-import argparse
-import os
-import socket
-import subprocess
-import sys
-import webbrowser
-if sys.version_info >= (3, 2):
- from html import escape
-else:
- from cgi import escape
-try:
- from urllib.request import unquote
-except ImportError:
- from urllib2 import unquote
-from collections import namedtuple
-
-Node = namedtuple('Node', ['inputs', 'rule', 'target', 'outputs'])
-
-# Ideally we'd allow you to navigate to a build edge or a build node,
-# with appropriate views for each. But there's no way to *name* a build
-# edge so we can only display nodes.
-#
-# For a given node, it has at most one input edge, which has n
-# different inputs. This becomes node.inputs. (We leave out the
-# outputs of the input edge due to what follows.) The node can have
-# multiple dependent output edges. Rather than attempting to display
-# those, they are summarized by taking the union of all their outputs.
-#
-# This means there's no single view that shows you all inputs and outputs
-# of an edge. But I think it's less confusing than alternatives.
-
-def match_strip(line, prefix):
- if not line.startswith(prefix):
- return (False, line)
- return (True, line[len(prefix):])
-
-def html_escape(text):
- return escape(text, quote=True)
-
-def parse(text):
- lines = iter(text.split('\n'))
-
- target = None
- rule = None
- inputs = []
- outputs = []
-
- try:
- target = next(lines)[:-1] # strip trailing colon
-
- line = next(lines)
- (match, rule) = match_strip(line, ' input: ')
- if match:
- (match, line) = match_strip(next(lines), ' ')
- while match:
- type = None
- (match, line) = match_strip(line, '| ')
- if match:
- type = 'implicit'
- (match, line) = match_strip(line, '|| ')
- if match:
- type = 'order-only'
- inputs.append((line, type))
- (match, line) = match_strip(next(lines), ' ')
-
- match, _ = match_strip(line, ' outputs:')
- if match:
- (match, line) = match_strip(next(lines), ' ')
- while match:
- outputs.append(line)
- (match, line) = match_strip(next(lines), ' ')
- except StopIteration:
- pass
-
- return Node(inputs, rule, target, outputs)
-
-def create_page(body):
- return '''<!DOCTYPE html>
-<style>
-body {
- font-family: sans;
- font-size: 0.8em;
- margin: 4ex;
-}
-h1 {
- font-weight: normal;
- font-size: 140%;
- text-align: center;
- margin: 0;
-}
-h2 {
- font-weight: normal;
- font-size: 120%;
-}
-tt {
- font-family: WebKitHack, monospace;
- white-space: nowrap;
-}
-.filelist {
- -webkit-columns: auto 2;
-}
-</style>
-''' + body
-
-def generate_html(node):
- document = ['<h1><tt>%s</tt></h1>' % html_escape(node.target)]
-
- if node.inputs:
- document.append('<h2>target is built using rule <tt>%s</tt> of</h2>' %
- html_escape(node.rule))
- if len(node.inputs) > 0:
- document.append('<div class=filelist>')
- for input, type in sorted(node.inputs):
- extra = ''
- if type:
- extra = ' (%s)' % html_escape(type)
- document.append('<tt><a href="?%s">%s</a>%s</tt><br>' %
- (html_escape(input), html_escape(input), extra))
- document.append('</div>')
-
- if node.outputs:
- document.append('<h2>dependent edges build:</h2>')
- document.append('<div class=filelist>')
- for output in sorted(node.outputs):
- document.append('<tt><a href="?%s">%s</a></tt><br>' %
- (html_escape(output), html_escape(output)))
- document.append('</div>')
-
- return '\n'.join(document)
-
-def ninja_dump(target):
- cmd = [args.ninja_command, '-f', args.f, '-t', 'query', target]
- proc = subprocess.Popen(cmd, stdout=subprocess.PIPE, stderr=subprocess.PIPE,
- universal_newlines=True)
- return proc.communicate() + (proc.returncode,)
-
-class RequestHandler(httpserver.BaseHTTPRequestHandler):
- def do_GET(self):
- assert self.path[0] == '/'
- target = unquote(self.path[1:])
-
- if target == '':
- self.send_response(302)
- self.send_header('Location', '?' + args.initial_target)
- self.end_headers()
- return
-
- if not target.startswith('?'):
- self.send_response(404)
- self.end_headers()
- return
- target = target[1:]
-
- ninja_output, ninja_error, exit_code = ninja_dump(target)
- if exit_code == 0:
- page_body = generate_html(parse(ninja_output.strip()))
- else:
- # Relay ninja's error message.
- page_body = '<h1><tt>%s</tt></h1>' % html_escape(ninja_error)
-
- self.send_response(200)
- self.end_headers()
- self.wfile.write(create_page(page_body).encode('utf-8'))
-
- def log_message(self, format, *args):
- pass # Swallow console spam.
-
-parser = argparse.ArgumentParser(prog='ninja -t browse')
-parser.add_argument('--port', '-p', default=8000, type=int,
- help='Port number to use (default %(default)d)')
-parser.add_argument('--hostname', '-a', default='localhost', type=str,
- help='Hostname to bind to (default %(default)s)')
-parser.add_argument('--no-browser', action='store_true',
- help='Do not open a webbrowser on startup.')
-
-parser.add_argument('--ninja-command', default='ninja',
- help='Path to ninja binary (default %(default)s)')
-parser.add_argument('-f', default='build.ninja',
- help='Path to build.ninja file (default %(default)s)')
-parser.add_argument('initial_target', default='all', nargs='?',
- help='Initial target to show (default %(default)s)')
-
-class HTTPServer(socketserver.ThreadingMixIn, httpserver.HTTPServer):
- # terminate server immediately when Python exits.
- daemon_threads = True
-
-args = parser.parse_args()
-port = args.port
-hostname = args.hostname
-httpd = HTTPServer((hostname,port), RequestHandler)
-try:
- if hostname == "":
- hostname = socket.gethostname()
- print('Web server running on %s:%d, ctl-C to abort...' % (hostname,port) )
- print('Web server pid %d' % os.getpid(), file=sys.stderr )
- if not args.no_browser:
- webbrowser.open_new('http://%s:%s' % (hostname, port) )
- httpd.serve_forever()
-except KeyboardInterrupt:
- print()
- pass # Swallow console spam.
-
-
diff --git a/src/build.cc b/src/build.cc
deleted file mode 100644
index bca3e8d..0000000
--- a/src/build.cc
+++ /dev/null
@@ -1,964 +0,0 @@
-// Copyright 2011 Google Inc. All Rights Reserved.
-//
-// Licensed under the Apache License, Version 2.0 (the "License");
-// you may not use this file except in compliance with the License.
-// You may obtain a copy of the License at
-//
-// http://www.apache.org/licenses/LICENSE-2.0
-//
-// Unless required by applicable law or agreed to in writing, software
-// distributed under the License is distributed on an "AS IS" BASIS,
-// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-// See the License for the specific language governing permissions and
-// limitations under the License.
-
-#include "build.h"
-
-#include <assert.h>
-#include <errno.h>
-#include <stdio.h>
-#include <stdlib.h>
-#include <functional>
-
-#if defined(__SVR4) && defined(__sun)
-#include <sys/termios.h>
-#endif
-
-#include "async_loop.h"
-#include "build_config.h"
-#include "build_log.h"
-#include "clparser.h"
-#include "debug_flags.h"
-#include "depfile_parser.h"
-#include "deps_log.h"
-#include "disk_interface.h"
-#include "graph.h"
-#include "metrics.h"
-#include "state.h"
-#include "status.h"
-#include "subprocess.h"
-#include "util.h"
-
-using namespace std;
-
-namespace {
-
-/// A CommandRunner that doesn't actually run the commands.
-struct DryRunCommandRunner : public CommandRunner {
- virtual ~DryRunCommandRunner() {}
-
- // Overridden from CommandRunner:
- bool CanRunMore() const override;
- bool StartCommand(Edge* edge) override;
- bool WaitForCommand(Result* result) override;
-
- private:
- queue<Edge*> finished_;
-};
-
-bool DryRunCommandRunner::CanRunMore() const {
- return true;
-}
-
-bool DryRunCommandRunner::StartCommand(Edge* edge) {
- finished_.push(edge);
- return true;
-}
-
-bool DryRunCommandRunner::WaitForCommand(Result* result) {
- if (finished_.empty())
- return false;
-
- result->status = ExitSuccess;
- result->edge = finished_.front();
- finished_.pop();
- return true;
-}
-
-} // namespace
-
-Plan::Plan(Builder* builder)
- : builder_(builder)
- , command_edges_(0)
- , wanted_edges_(0)
-{}
-
-void Plan::Reset() {
- command_edges_ = 0;
- wanted_edges_ = 0;
- ready_.clear();
- want_.clear();
-}
-
-bool Plan::AddTarget(const Node* target, string* err) {
- return AddSubTarget(target, NULL, err, NULL);
-}
-
-bool Plan::AddSubTarget(const Node* node, const Node* dependent, string* err,
- set<Edge*>* dyndep_walk) {
- Edge* edge = node->in_edge();
- if (!edge) {
- // Leaf node, this can be either a regular input from the manifest
- // (e.g. a source file), or an implicit input from a depfile or dyndep
- // file. In the first case, a dirty flag means the file is missing,
- // and the build should stop. In the second, do not do anything here
- // since there is no producing edge to add to the plan.
- if (node->dirty() && !node->generated_by_dep_loader()) {
- string referenced;
- if (dependent)
- referenced = ", needed by '" + dependent->path() + "',";
- *err = "'" + node->path() + "'" + referenced + " missing "
- "and no known rule to make it";
- }
- return false;
- }
-
- if (edge->outputs_ready())
- return false; // Don't need to do anything.
-
- // If an entry in want_ does not already exist for edge, create an entry which
- // maps to kWantNothing, indicating that we do not want to build this entry itself.
- pair<map<Edge*, Want>::iterator, bool> want_ins =
- want_.insert(make_pair(edge, kWantNothing));
- Want& want = want_ins.first->second;
-
- if (dyndep_walk && want == kWantToFinish)
- return false; // Don't need to do anything with already-scheduled edge.
-
- // If we do need to build edge and we haven't already marked it as wanted,
- // mark it now.
- if (node->dirty() && want == kWantNothing) {
- want = kWantToStart;
- EdgeWanted(edge);
- if (!dyndep_walk && edge->AllInputsReady())
- ScheduleWork(want_ins.first);
- }
-
- if (dyndep_walk)
- dyndep_walk->insert(edge);
-
- if (!want_ins.second)
- return true; // We've already processed the inputs.
-
- for (vector<Node*>::iterator i = edge->inputs_.begin();
- i != edge->inputs_.end(); ++i) {
- if (!AddSubTarget(*i, node, err, dyndep_walk) && !err->empty())
- return false;
- }
-
- return true;
-}
-
-void Plan::EdgeWanted(const Edge* edge) {
- ++wanted_edges_;
- if (!edge->is_phony())
- ++command_edges_;
-}
-
-Edge* Plan::FindWork() {
- if (ready_.empty())
- return NULL;
- EdgeSet::iterator e = ready_.begin();
- Edge* edge = *e;
- ready_.erase(e);
- return edge;
-}
-
-void Plan::ScheduleWork(map<Edge*, Want>::iterator want_e) {
- if (want_e->second == kWantToFinish) {
- // This edge has already been scheduled. We can get here again if an edge
- // and one of its dependencies share an order-only input, or if a node
- // duplicates an out edge (see https://github.com/ninja-build/ninja/pull/519).
- // Avoid scheduling the work again.
- return;
- }
- assert(want_e->second == kWantToStart);
- want_e->second = kWantToFinish;
-
- Edge* edge = want_e->first;
- Pool* pool = edge->pool();
- if (pool->ShouldDelayEdge()) {
- pool->DelayEdge(edge);
- pool->RetrieveReadyEdges(&ready_);
- } else {
- pool->EdgeScheduled(*edge);
- ready_.insert(edge);
- }
-}
-
-bool Plan::EdgeFinished(Edge* edge, EdgeResult result, string* err) {
- map<Edge*, Want>::iterator e = want_.find(edge);
- assert(e != want_.end());
- bool directly_wanted = e->second != kWantNothing;
-
- // See if this job frees up any delayed jobs.
- if (directly_wanted)
- edge->pool()->EdgeFinished(*edge);
- edge->pool()->RetrieveReadyEdges(&ready_);
-
- // The rest of this function only applies to successful commands.
- if (result != kEdgeSucceeded)
- return true;
-
- if (directly_wanted)
- --wanted_edges_;
- want_.erase(e);
- edge->outputs_ready_ = true;
-
- // Check off any nodes we were waiting for with this edge.
- for (vector<Node*>::iterator o = edge->outputs_.begin();
- o != edge->outputs_.end(); ++o) {
- if (!NodeFinished(*o, err))
- return false;
- }
- return true;
-}
-
-bool Plan::NodeFinished(Node* node, string* err) {
- // If this node provides dyndep info, load it now.
- if (node->dyndep_pending()) {
- assert(builder_ && "dyndep requires Plan to have a Builder");
- // Load the now-clean dyndep file. This will also update the
- // build plan and schedule any new work that is ready.
- return builder_->LoadDyndeps(node, err);
- }
-
- // See if we we want any edges from this node.
- for (vector<Edge*>::const_iterator oe = node->out_edges().begin();
- oe != node->out_edges().end(); ++oe) {
- map<Edge*, Want>::iterator want_e = want_.find(*oe);
- if (want_e == want_.end())
- continue;
-
- // See if the edge is now ready.
- if (!EdgeMaybeReady(want_e, err))
- return false;
- }
- return true;
-}
-
-bool Plan::EdgeMaybeReady(map<Edge*, Want>::iterator want_e, string* err) {
- Edge* edge = want_e->first;
- if (edge->AllInputsReady()) {
- if (want_e->second != kWantNothing) {
- ScheduleWork(want_e);
- } else {
- // We do not need to build this edge, but we might need to build one of
- // its dependents.
- if (!EdgeFinished(edge, kEdgeSucceeded, err))
- return false;
- }
- }
- return true;
-}
-
-bool Plan::CleanNode(DependencyScan* scan, Node* node, string* err) {
- node->set_dirty(false);
-
- for (vector<Edge*>::const_iterator oe = node->out_edges().begin();
- oe != node->out_edges().end(); ++oe) {
- // Don't process edges that we don't actually want.
- map<Edge*, Want>::iterator want_e = want_.find(*oe);
- if (want_e == want_.end() || want_e->second == kWantNothing)
- continue;
-
- // Don't attempt to clean an edge if it failed to load deps.
- if ((*oe)->deps_missing_)
- continue;
-
- // If all non-order-only inputs for this edge are now clean,
- // we might have changed the dirty state of the outputs.
- vector<Node*>::iterator
- begin = (*oe)->inputs_.begin(),
- end = (*oe)->inputs_.end() - (*oe)->order_only_deps_;
-#if __cplusplus < 201703L
-#define MEM_FN mem_fun
-#else
-#define MEM_FN mem_fn // mem_fun was removed in C++17.
-#endif
- if (find_if(begin, end, MEM_FN(&Node::dirty)) == end) {
- // Recompute most_recent_input.
- Node* most_recent_input = NULL;
- for (vector<Node*>::iterator i = begin; i != end; ++i) {
- if (!most_recent_input || (*i)->mtime() > most_recent_input->mtime())
- most_recent_input = *i;
- }
-
- // Now, this edge is dirty if any of the outputs are dirty.
- // If the edge isn't dirty, clean the outputs and mark the edge as not
- // wanted.
- bool outputs_dirty = false;
- if (!scan->RecomputeOutputsDirty(*oe, most_recent_input,
- &outputs_dirty, err)) {
- return false;
- }
- if (!outputs_dirty) {
- for (vector<Node*>::iterator o = (*oe)->outputs_.begin();
- o != (*oe)->outputs_.end(); ++o) {
- if (!CleanNode(scan, *o, err))
- return false;
- }
-
- want_e->second = kWantNothing;
- --wanted_edges_;
- if (!(*oe)->is_phony())
- --command_edges_;
- }
- }
- }
- return true;
-}
-
-bool Plan::DyndepsLoaded(DependencyScan* scan, const Node* node,
- const DyndepFile& ddf, string* err) {
- // Recompute the dirty state of all our direct and indirect dependents now
- // that our dyndep information has been loaded.
- if (!RefreshDyndepDependents(scan, node, err))
- return false;
-
- // We loaded dyndep information for those out_edges of the dyndep node that
- // specify the node in a dyndep binding, but they may not be in the plan.
- // Starting with those already in the plan, walk newly-reachable portion
- // of the graph through the dyndep-discovered dependencies.
-
- // Find edges in the the build plan for which we have new dyndep info.
- std::vector<DyndepFile::const_iterator> dyndep_roots;
- for (DyndepFile::const_iterator oe = ddf.begin(); oe != ddf.end(); ++oe) {
- Edge* edge = oe->first;
-
- // If the edge outputs are ready we do not need to consider it here.
- if (edge->outputs_ready())
- continue;
-
- map<Edge*, Want>::iterator want_e = want_.find(edge);
-
- // If the edge has not been encountered before then nothing already in the
- // plan depends on it so we do not need to consider the edge yet either.
- if (want_e == want_.end())
- continue;
-
- // This edge is already in the plan so queue it for the walk.
- dyndep_roots.push_back(oe);
- }
-
- // Walk dyndep-discovered portion of the graph to add it to the build plan.
- std::set<Edge*> dyndep_walk;
- for (std::vector<DyndepFile::const_iterator>::iterator
- oei = dyndep_roots.begin(); oei != dyndep_roots.end(); ++oei) {
- DyndepFile::const_iterator oe = *oei;
- for (vector<Node*>::const_iterator i = oe->second.implicit_inputs_.begin();
- i != oe->second.implicit_inputs_.end(); ++i) {
- if (!AddSubTarget(*i, oe->first->outputs_[0], err, &dyndep_walk) &&
- !err->empty())
- return false;
- }
- }
-
- // Add out edges from this node that are in the plan (just as
- // Plan::NodeFinished would have without taking the dyndep code path).
- for (vector<Edge*>::const_iterator oe = node->out_edges().begin();
- oe != node->out_edges().end(); ++oe) {
- map<Edge*, Want>::iterator want_e = want_.find(*oe);
- if (want_e == want_.end())
- continue;
- dyndep_walk.insert(want_e->first);
- }
-
- // See if any encountered edges are now ready.
- for (set<Edge*>::iterator wi = dyndep_walk.begin();
- wi != dyndep_walk.end(); ++wi) {
- map<Edge*, Want>::iterator want_e = want_.find(*wi);
- if (want_e == want_.end())
- continue;
- if (!EdgeMaybeReady(want_e, err))
- return false;
- }
-
- return true;
-}
-
-bool Plan::RefreshDyndepDependents(DependencyScan* scan, const Node* node,
- string* err) {
- // Collect the transitive closure of dependents and mark their edges
- // as not yet visited by RecomputeDirty.
- set<Node*> dependents;
- UnmarkDependents(node, &dependents);
-
- // Update the dirty state of all dependents and check if their edges
- // have become wanted.
- for (set<Node*>::iterator i = dependents.begin();
- i != dependents.end(); ++i) {
- Node* n = *i;
-
- // Check if this dependent node is now dirty. Also checks for new cycles.
- std::vector<Node*> validation_nodes;
- if (!scan->RecomputeDirty(n, &validation_nodes, err))
- return false;
-
- // Add any validation nodes found during RecomputeDirty as new top level
- // targets.
- for (std::vector<Node*>::iterator v = validation_nodes.begin();
- v != validation_nodes.end(); ++v) {
- if (Edge* in_edge = (*v)->in_edge()) {
- if (!in_edge->outputs_ready() &&
- !AddTarget(*v, err)) {
- return false;
- }
- }
- }
- if (!n->dirty())
- continue;
-
- // This edge was encountered before. However, we may not have wanted to
- // build it if the outputs were not known to be dirty. With dyndep
- // information an output is now known to be dirty, so we want the edge.
- Edge* edge = n->in_edge();
- assert(edge && !edge->outputs_ready());
- map<Edge*, Want>::iterator want_e = want_.find(edge);
- assert(want_e != want_.end());
- if (want_e->second == kWantNothing) {
- want_e->second = kWantToStart;
- EdgeWanted(edge);
- }
- }
- return true;
-}
-
-void Plan::UnmarkDependents(const Node* node, set<Node*>* dependents) {
- for (vector<Edge*>::const_iterator oe = node->out_edges().begin();
- oe != node->out_edges().end(); ++oe) {
- Edge* edge = *oe;
-
- map<Edge*, Want>::iterator want_e = want_.find(edge);
- if (want_e == want_.end())
- continue;
-
- if (edge->mark_ != Edge::VisitNone) {
- edge->mark_ = Edge::VisitNone;
- for (vector<Node*>::iterator o = edge->outputs_.begin();
- o != edge->outputs_.end(); ++o) {
- if (dependents->insert(*o).second)
- UnmarkDependents(*o, dependents);
- }
- }
- }
-}
-
-void Plan::Dump() const {
- printf("pending: %d\n", (int)want_.size());
- for (map<Edge*, Want>::const_iterator e = want_.begin(); e != want_.end(); ++e) {
- if (e->second != kWantNothing)
- printf("want ");
- e->first->Dump();
- }
- printf("ready: %d\n", (int)ready_.size());
-}
-
-struct RealCommandRunner : public CommandRunner {
- RealCommandRunner(const BuildConfig& config, DiskInterface& disk_interface)
- : config_(config), subprocs_(config_.environment),
- disk_interface_(disk_interface) {}
- virtual ~RealCommandRunner() {}
- bool CanRunMore() const override;
- bool StartCommand(Edge* edge) override;
- bool WaitForCommand(Result* result) override;
- vector<Edge*> GetActiveEdges() override;
- void Abort() override;
-
- const BuildConfig& config_;
- DiskInterface& disk_interface_;
- SubprocessSet subprocs_;
- map<const Subprocess*, Edge*> subproc_to_edge_;
-};
-
-vector<Edge*> RealCommandRunner::GetActiveEdges() {
- std::vector<Edge*> edges;
- edges.reserve(subproc_to_edge_.size());
- for (const auto& pair : subproc_to_edge_)
- edges.push_back(pair.second);
- return edges;
-}
-
-void RealCommandRunner::Abort() {
- subprocs_.Clear();
-}
-
-bool RealCommandRunner::CanRunMore() const {
- size_t subproc_number =
- subprocs_.running_.size() + subprocs_.finished_.size();
- return (int)subproc_number < config_.parallelism
- && ((subprocs_.running_.empty() || config_.max_load_average <= 0.0f)
- || GetLoadAverage() < config_.max_load_average);
-}
-
-bool RealCommandRunner::StartCommand(Edge* edge) {
- string command = edge->EvaluateCommand();
- const Subprocess* subproc = subprocs_.Add(command, edge->use_console());
- if (!subproc)
- return false;
-
- subproc_to_edge_.insert(std::make_pair(subproc, edge));
- return true;
-}
-
-bool RealCommandRunner::WaitForCommand(Result* result) {
- std::unique_ptr<Subprocess> subproc;
- while (!(subproc = subprocs_.NextFinished())) {
- bool interrupted = subprocs_.DoWork();
-
- // Launched sub-commands may have modified file timestamps.
- disk_interface_.Sync();
-
- if (interrupted) {
- result->status = ExitInterrupted;
- return false;
- }
- }
-
- result->status = subproc->Finish();
- result->output = subproc->GetOutput();
-
- auto e = subproc_to_edge_.find(subproc.get());
- result->edge = e->second;
- subproc_to_edge_.erase(e);
-
- return true;
-}
-
-Builder::Builder(State* state, const BuildConfig& config,
- BuildLog* build_log, DepsLog* deps_log,
- DiskInterface* disk_interface, Status *status,
- int64_t start_time_millis)
- : state_(state), config_(config), plan_(this), status_(status),
- start_time_millis_(start_time_millis), disk_interface_(disk_interface),
- scan_(state, build_log, deps_log, disk_interface,
- &config_.depfile_parser_options) {
- lock_file_path_ = ".ninja_lock";
- string build_dir = state_->bindings().LookupVariable("builddir");
- if (!build_dir.empty())
- lock_file_path_ = build_dir + "/" + lock_file_path_;
-}
-
-Builder::~Builder() {
- Cleanup();
-
- // Remove lock file now.
- string err;
- if (disk_interface_->Stat(lock_file_path_, &err) > 0) {
- disk_interface_->RemoveFile(lock_file_path_);
- }
-}
-
-void Builder::Cleanup() {
- if (command_runner_.get()) {
- vector<Edge*> active_edges = command_runner_->GetActiveEdges();
- command_runner_->Abort();
-
- for (vector<Edge*>::iterator e = active_edges.begin();
- e != active_edges.end(); ++e) {
- string depfile = (*e)->GetUnescapedDepfile();
- for (vector<Node*>::iterator o = (*e)->outputs_.begin();
- o != (*e)->outputs_.end(); ++o) {
- // Only delete this output if it was actually modified. This is
- // important for things like the generator where we don't want to
- // delete the manifest file if we can avoid it. But if the rule
- // uses a depfile, always delete. (Consider the case where we
- // need to rebuild an output because of a modified header file
- // mentioned in a depfile, and the command touches its depfile
- // but is interrupted before it touches its output file.)
- string err;
- TimeStamp new_mtime = disk_interface_->Stat((*o)->path(), &err);
- if (new_mtime == -1) // Log and ignore Stat() errors.
- status_->Error("%s", err.c_str());
- if (!depfile.empty() || (*o)->mtime() != new_mtime)
- disk_interface_->RemoveFile((*o)->path());
- }
- if (!depfile.empty())
- disk_interface_->RemoveFile(depfile);
- }
- }
-}
-
-Node* Builder::AddTarget(const string& name, string* err) {
- Node* node = state_->LookupNode(name);
- if (!node) {
- *err = "unknown target: '" + name + "'";
- return NULL;
- }
- if (!AddTarget(node, err))
- return NULL;
- return node;
-}
-
-bool Builder::AddTarget(Node* target, string* err) {
- std::vector<Node*> validation_nodes;
- if (!scan_.RecomputeDirty(target, &validation_nodes, err))
- return false;
-
- Edge* in_edge = target->in_edge();
- if (!in_edge || !in_edge->outputs_ready()) {
- if (!plan_.AddTarget(target, err)) {
- return false;
- }
- }
-
- // Also add any validation nodes found during RecomputeDirty as top level
- // targets.
- for (std::vector<Node*>::iterator n = validation_nodes.begin();
- n != validation_nodes.end(); ++n) {
- if (Edge* validation_in_edge = (*n)->in_edge()) {
- if (!validation_in_edge->outputs_ready() &&
- !plan_.AddTarget(*n, err)) {
- return false;
- }
- }
- }
-
- return true;
-}
-
-bool Builder::AlreadyUpToDate() const {
- return !plan_.more_to_do();
-}
-
-bool Builder::Build(string* err) {
- assert(!AlreadyUpToDate());
-
- status_->PlanHasTotalEdges(plan_.command_edge_count());
- int pending_commands = 0;
- int failures_allowed = config_.failures_allowed;
-
- // Set up the command runner if we haven't done so already.
- if (!command_runner_.get()) {
- if (config_.dry_run)
- command_runner_.reset(new DryRunCommandRunner);
- else
- command_runner_.reset(new RealCommandRunner(config_, *disk_interface_));
- }
-
- // We are about to start the build process.
- status_->BuildStarted();
-
- // This main loop runs the entire build process.
- // It is structured like this:
- // First, we attempt to start as many commands as allowed by the
- // command runner.
- // Second, we attempt to wait for / reap the next finished command.
- while (plan_.more_to_do()) {
- // See if we can start any more commands.
- if (failures_allowed && command_runner_->CanRunMore()) {
- if (Edge* edge = plan_.FindWork()) {
- if (edge->is_generator()) {
- scan_.build_log()->Close();
- }
-
- if (!StartEdge(edge, err)) {
- Cleanup();
- status_->BuildFinished();
- return false;
- }
-
- if (edge->is_phony()) {
- if (!plan_.EdgeFinished(edge, Plan::kEdgeSucceeded, err)) {
- Cleanup();
- status_->BuildFinished();
- return false;
- }
- } else {
- ++pending_commands;
- }
-
- // We made some progress; go back to the main loop.
- continue;
- }
- }
-
- // See if we can reap any finished commands.
- if (pending_commands) {
- CommandRunner::Result result;
- if (!command_runner_->WaitForCommand(&result) ||
- result.status == ExitInterrupted) {
- Cleanup();
- status_->BuildFinished();
- *err = "interrupted by user";
- return false;
- }
-
- --pending_commands;
- if (!FinishCommand(&result, err)) {
- Cleanup();
- status_->BuildFinished();
- return false;
- }
-
- if (!result.success()) {
- if (failures_allowed)
- failures_allowed--;
- }
-
- // We made some progress; start the main loop over.
- continue;
- }
-
- // If we get here, we cannot make any more progress.
- status_->BuildFinished();
- if (failures_allowed == 0) {
- if (config_.failures_allowed > 1)
- *err = "subcommands failed";
- else
- *err = "subcommand failed";
- } else if (failures_allowed < config_.failures_allowed)
- *err = "cannot make progress due to previous errors";
- else
- *err = "stuck [this is a bug]";
-
- return false;
- }
-
- status_->BuildFinished();
- return true;
-}
-
-bool Builder::StartEdge(Edge* edge, string* err) {
- METRIC_RECORD("StartEdge");
- if (edge->is_phony())
- return true;
-
- int64_t start_time_millis = GetTimeMillis() - start_time_millis_;
- running_edges_.insert(make_pair(edge, start_time_millis));
- status_->BuildEdgeStarted(edge);
-
- TimeStamp build_start = -1;
-
- // Create directories necessary for outputs and remember the current
- // filesystem mtime to record later
- // XXX: this will block; do we care?
- for (vector<Node*>::iterator o = edge->outputs_.begin();
- o != edge->outputs_.end(); ++o) {
- if (!disk_interface_->MakeDirs((*o)->path()))
- return false;
- if (build_start == -1) {
- disk_interface_->WriteFile(lock_file_path_, "");
- build_start = disk_interface_->Stat(lock_file_path_, err);
- if (build_start == -1)
- build_start = 0;
- }
- }
-
- edge->command_start_time_ = build_start;
-
- // Create response file, if needed
- // XXX: this may also block; do we care?
- string rspfile = edge->GetUnescapedRspfile();
- if (!rspfile.empty()) {
- string content = edge->GetBinding("rspfile_content");
- if (!disk_interface_->WriteFile(rspfile, content))
- return false;
- }
-
- // start command computing and run it
- if (!command_runner_->StartCommand(edge)) {
- err->assign("command '" + edge->EvaluateCommand() + "' failed.");
- return false;
- }
-
- return true;
-}
-
-bool Builder::FinishCommand(CommandRunner::Result* result, string* err) {
- METRIC_RECORD("FinishCommand");
-
- Edge* edge = result->edge;
-
- // First try to extract dependencies from the result, if any.
- // This must happen first as it filters the command output (we want
- // to filter /showIncludes output, even on compile failure) and
- // extraction itself can fail, which makes the command fail from a
- // build perspective.
- vector<Node*> deps_nodes;
- string deps_type = edge->GetBinding("deps");
- const string deps_prefix = edge->GetBinding("msvc_deps_prefix");
- if (!deps_type.empty()) {
- string extract_err;
- if (!ExtractDeps(result, deps_type, deps_prefix, &deps_nodes,
- &extract_err) &&
- result->success()) {
- if (!result->output.empty())
- result->output.append("\n");
- result->output.append(extract_err);
- result->status = ExitFailure;
- }
- }
-
- int64_t start_time_millis, end_time_millis;
- RunningEdgeMap::iterator it = running_edges_.find(edge);
- start_time_millis = it->second;
- end_time_millis = GetTimeMillis() - start_time_millis_;
- running_edges_.erase(it);
-
- status_->BuildEdgeFinished(edge, result->success(), result->output);
-
- // The rest of this function only applies to successful commands.
- if (!result->success()) {
- return plan_.EdgeFinished(edge, Plan::kEdgeFailed, err);
- }
-
- // Restat the edge outputs
- TimeStamp record_mtime = 0;
- if (!config_.dry_run) {
- const bool restat = edge->has_restat();
- const bool generator = edge->is_generator();
- bool node_cleaned = false;
- record_mtime = edge->command_start_time_;
-
- // restat and generator rules must restat the outputs after the build
- // has finished. if record_mtime == 0, then there was an error while
- // attempting to touch/stat the temp file when the edge started and
- // we should fall back to recording the outputs' current mtime in the
- // log.
- if (record_mtime == 0 || restat || generator) {
- for (vector<Node*>::iterator o = edge->outputs_.begin();
- o != edge->outputs_.end(); ++o) {
- TimeStamp new_mtime = disk_interface_->Stat((*o)->path(), err);
- if (new_mtime == -1)
- return false;
- if (new_mtime > record_mtime)
- record_mtime = new_mtime;
- if ((*o)->mtime() == new_mtime && restat) {
- // The rule command did not change the output. Propagate the clean
- // state through the build graph.
- // Note that this also applies to nonexistent outputs (mtime == 0).
- if (!plan_.CleanNode(&scan_, *o, err))
- return false;
- node_cleaned = true;
- }
- }
- }
- if (node_cleaned) {
- record_mtime = edge->command_start_time_;
-
- // The total number of edges in the plan may have changed as a result
- // of a restat.
- status_->PlanHasTotalEdges(plan_.command_edge_count());
- }
- }
-
- if (!plan_.EdgeFinished(edge, Plan::kEdgeSucceeded, err))
- return false;
-
- // Delete any left over response file.
- string rspfile = edge->GetUnescapedRspfile();
- if (!rspfile.empty() && !g_keep_rsp)
- disk_interface_->RemoveFile(rspfile);
-
- if (scan_.build_log()) {
- if (!scan_.build_log()->RecordCommand(edge, start_time_millis,
- end_time_millis, record_mtime)) {
- *err = string("Error writing to build log: ") + strerror(errno);
- return false;
- }
- }
-
- if (!deps_type.empty() && !config_.dry_run) {
- assert(!edge->outputs_.empty() && "should have been rejected by parser");
- for (std::vector<Node*>::const_iterator o = edge->outputs_.begin();
- o != edge->outputs_.end(); ++o) {
- TimeStamp deps_mtime = disk_interface_->Stat((*o)->path(), err);
- if (deps_mtime == -1)
- return false;
- if (!scan_.deps_log()->RecordDeps(*o, deps_mtime, deps_nodes)) {
- *err = std::string("Error writing to deps log: ") + strerror(errno);
- return false;
- }
- }
- }
-
- // Ensure that the next dependency scan that touches this edge removes
- // any recorded deps in it since they are now stale.
- edge->deps_loaded_ = false;
- return true;
-}
-
-bool Builder::ExtractDeps(CommandRunner::Result* result,
- const string& deps_type,
- const string& deps_prefix,
- vector<Node*>* deps_nodes,
- string* err) {
- if (deps_type == "msvc") {
- CLParser parser;
- string output;
- if (!parser.Parse(result->output, deps_prefix, &output, err))
- return false;
- result->output = output;
- for (set<string>::iterator i = parser.includes_.begin();
- i != parser.includes_.end(); ++i) {
- // ~0 is assuming that with MSVC-parsed headers, it's ok to always make
- // all backslashes (as some of the slashes will certainly be backslashes
- // anyway). This could be fixed if necessary with some additional
- // complexity in IncludesNormalize::Relativize.
- deps_nodes->push_back(state_->GetNode(*i, ~0u));
- }
- } else if (deps_type == "gcc") {
- string depfile = result->edge->GetUnescapedDepfile();
- if (depfile.empty()) {
- *err = string("edge with deps=gcc but no depfile makes no sense");
- return false;
- }
-
- // Read depfile content. Treat a missing depfile as empty.
- string content;
- switch (disk_interface_->ReadFile(depfile, &content, err)) {
- case DiskInterface::Okay:
- break;
- case DiskInterface::NotFound:
- err->clear();
- break;
- case DiskInterface::OtherError:
- return false;
- }
- if (content.empty())
- return true;
-
- DepfileParser deps(config_.depfile_parser_options);
- if (!deps.Parse(&content, err))
- return false;
-
- // XXX check depfile matches expected output.
- deps_nodes->reserve(deps.ins_.size());
- for (vector<StringPiece>::iterator i = deps.ins_.begin();
- i != deps.ins_.end(); ++i) {
- uint64_t slash_bits;
- CanonicalizePath(const_cast<char*>(i->str_), &i->len_, &slash_bits);
- deps_nodes->push_back(state_->GetNode(*i, slash_bits));
- }
-
- if (!g_keep_depfile) {
- if (disk_interface_->RemoveFile(depfile) < 0) {
- *err = string("deleting depfile: ") + strerror(errno) + string("\n");
- return false;
- }
- }
- } else {
- Fatal("unknown deps type '%s'", deps_type.c_str());
- }
-
- return true;
-}
-
-bool Builder::LoadDyndeps(Node* node, string* err) {
- status_->BuildLoadDyndeps();
-
- // Load the dyndep information provided by this node.
- DyndepFile ddf;
- if (!scan_.LoadDyndeps(node, &ddf, err))
- return false;
-
- // Update the build plan to account for dyndep modifications to the graph.
- if (!plan_.DyndepsLoaded(&scan_, node, ddf, err))
- return false;
-
- // New command edges may have been added to the plan.
- status_->PlanHasTotalEdges(plan_.command_edge_count());
-
- return true;
-}
diff --git a/src/build.h b/src/build.h
deleted file mode 100644
index e2b7eeb..0000000
--- a/src/build.h
+++ /dev/null
@@ -1,223 +0,0 @@
-// Copyright 2011 Google Inc. All Rights Reserved.
-//
-// Licensed under the Apache License, Version 2.0 (the "License");
-// you may not use this file except in compliance with the License.
-// You may obtain a copy of the License at
-//
-// http://www.apache.org/licenses/LICENSE-2.0
-//
-// Unless required by applicable law or agreed to in writing, software
-// distributed under the License is distributed on an "AS IS" BASIS,
-// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-// See the License for the specific language governing permissions and
-// limitations under the License.
-
-#ifndef NINJA_BUILD_H_
-#define NINJA_BUILD_H_
-
-#include <cstdio>
-#include <map>
-#include <memory>
-#include <queue>
-#include <string>
-#include <vector>
-
-#include "exit_status.h"
-#include "graph.h" // XXX needed for DependencyScan; should rearrange.
-#include "util.h" // int64_t
-
-class AsyncLoop;
-
-struct BuildConfig;
-struct BuildLog;
-struct Builder;
-struct DiskInterface;
-struct Edge;
-struct Node;
-struct State;
-struct Status;
-
-/// Plan stores the state of a build plan: what we intend to build,
-/// which steps we're ready to execute.
-struct Plan {
- Plan(Builder* builder = NULL);
-
- /// Add a target to our plan (including all its dependencies).
- /// Returns false if we don't need to build this target; may
- /// fill in |err| with an error message if there's a problem.
- bool AddTarget(const Node* target, std::string* err);
-
- // Pop a ready edge off the queue of edges to build.
- // Returns NULL if there's no work to do.
- Edge* FindWork();
-
- /// Returns true if there's more work to be done.
- bool more_to_do() const { return wanted_edges_ > 0 && command_edges_ > 0; }
-
- /// Dumps the current state of the plan.
- void Dump() const;
-
- enum EdgeResult {
- kEdgeFailed,
- kEdgeSucceeded
- };
-
- /// Mark an edge as done building (whether it succeeded or failed).
- /// If any of the edge's outputs are dyndep bindings of their dependents,
- /// this loads dynamic dependencies from the nodes' paths.
- /// Returns 'false' if loading dyndep info fails and 'true' otherwise.
- bool EdgeFinished(Edge* edge, EdgeResult result, std::string* err);
-
- /// Clean the given node during the build.
- /// Return false on error.
- bool CleanNode(DependencyScan* scan, Node* node, std::string* err);
-
- /// Number of edges with commands to run.
- int command_edge_count() const { return command_edges_; }
-
- /// Reset state. Clears want and ready sets.
- void Reset();
-
- /// Update the build plan to account for modifications made to the graph
- /// by information loaded from a dyndep file.
- bool DyndepsLoaded(DependencyScan* scan, const Node* node,
- const DyndepFile& ddf, std::string* err);
-private:
- bool RefreshDyndepDependents(DependencyScan* scan, const Node* node, std::string* err);
- void UnmarkDependents(const Node* node, std::set<Node*>* dependents);
- bool AddSubTarget(const Node* node, const Node* dependent, std::string* err,
- std::set<Edge*>* dyndep_walk);
-
- /// Update plan with knowledge that the given node is up to date.
- /// If the node is a dyndep binding on any of its dependents, this
- /// loads dynamic dependencies from the node's path.
- /// Returns 'false' if loading dyndep info fails and 'true' otherwise.
- bool NodeFinished(Node* node, std::string* err);
-
- /// Enumerate possible steps we want for an edge.
- enum Want
- {
- /// We do not want to build the edge, but we might want to build one of
- /// its dependents.
- kWantNothing,
- /// We want to build the edge, but have not yet scheduled it.
- kWantToStart,
- /// We want to build the edge, have scheduled it, and are waiting
- /// for it to complete.
- kWantToFinish
- };
-
- void EdgeWanted(const Edge* edge);
- bool EdgeMaybeReady(std::map<Edge*, Want>::iterator want_e, std::string* err);
-
- /// Submits a ready edge as a candidate for execution.
- /// The edge may be delayed from running, for example if it's a member of a
- /// currently-full pool.
- void ScheduleWork(std::map<Edge*, Want>::iterator want_e);
-
- /// Keep track of which edges we want to build in this plan. If this map does
- /// not contain an entry for an edge, we do not want to build the entry or its
- /// dependents. If it does contain an entry, the enumeration indicates what
- /// we want for the edge.
- std::map<Edge*, Want> want_;
-
- EdgeSet ready_;
-
- Builder* builder_;
-
- /// Total number of edges that have commands (not phony).
- int command_edges_;
-
- /// Total remaining number of wanted edges.
- int wanted_edges_;
-};
-
-/// CommandRunner is an interface that wraps running the build
-/// subcommands. This allows tests to abstract out running commands.
-/// RealCommandRunner is an implementation that actually runs commands.
-struct CommandRunner {
- virtual ~CommandRunner() {}
- virtual bool CanRunMore() const = 0;
- virtual bool StartCommand(Edge* edge) = 0;
-
- /// The result of waiting for a command.
- struct Result {
- Result() : edge(NULL) {}
- Edge* edge;
- ExitStatus status;
- std::string output;
- bool success() const { return status == ExitSuccess; }
- };
- /// Wait for a command to complete, or return false if interrupted.
- virtual bool WaitForCommand(Result* result) = 0;
-
- virtual std::vector<Edge*> GetActiveEdges() { return std::vector<Edge*>(); }
- virtual void Abort() {}
-};
-
-/// Builder wraps the build process: starting commands, updating status.
-struct Builder {
- Builder(State* state, const BuildConfig& config,
- BuildLog* build_log, DepsLog* deps_log,
- DiskInterface* disk_interface, Status* status,
- int64_t start_time_millis);
- ~Builder();
-
- /// Clean up after interrupted commands by deleting output files.
- void Cleanup();
-
- Node* AddTarget(const std::string& name, std::string* err);
-
- /// Add a target to the build, scanning dependencies.
- /// @return false on error.
- bool AddTarget(Node* target, std::string* err);
-
- /// Returns true if the build targets are already up to date.
- bool AlreadyUpToDate() const;
-
- /// Run the build. Returns false on error.
- /// It is an error to call this function when AlreadyUpToDate() is true.
- bool Build(std::string* err);
-
- bool StartEdge(Edge* edge, std::string* err);
-
- /// Update status ninja logs following a command termination.
- /// @return false if the build can not proceed further due to a fatal error.
- bool FinishCommand(CommandRunner::Result* result, std::string* err);
-
- /// Used for tests.
- void SetBuildLog(BuildLog* log) {
- scan_.set_build_log(log);
- }
-
- /// Load the dyndep information provided by the given node.
- bool LoadDyndeps(Node* node, std::string* err);
-
- State* state_;
- const BuildConfig& config_;
- Plan plan_;
- std::unique_ptr<CommandRunner> command_runner_;
- Status* status_;
-
- private:
- bool ExtractDeps(CommandRunner::Result* result, const std::string& deps_type,
- const std::string& deps_prefix,
- std::vector<Node*>* deps_nodes, std::string* err);
-
- /// Map of running edge to time the edge started running.
- typedef std::map<const Edge*, int> RunningEdgeMap;
- RunningEdgeMap running_edges_;
-
- /// Time the build started.
- int64_t start_time_millis_;
-
- std::string lock_file_path_;
- DiskInterface* disk_interface_;
- DependencyScan scan_;
-
- // Unimplemented copy ctor and operator= ensure we don't copy the auto_ptr.
- Builder(const Builder &other); // DO NOT IMPLEMENT
- void operator=(const Builder &other); // DO NOT IMPLEMENT
-};
-
-#endif // NINJA_BUILD_H_
diff --git a/src/build_config.cc b/src/build_config.cc
deleted file mode 100644
index 121a9db..0000000
--- a/src/build_config.cc
+++ /dev/null
@@ -1,141 +0,0 @@
-// Copyright 2023 Google Inc. All Rights Reserved.
-//
-// Licensed under the Apache License, Version 2.0 (the "License");
-// you may not use this file except in compliance with the License.
-// You may obtain a copy of the License at
-//
-// http://www.apache.org/licenses/LICENSE-2.0
-//
-// Unless required by applicable law or agreed to in writing, software
-// distributed under the License is distributed on an "AS IS" BASIS,
-// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-// See the License for the specific language governing permissions and
-// limitations under the License.
-
-#include "build_config.h"
-
-#include <inttypes.h>
-
-#include "ipc_utils.h"
-#include "process_utils.h"
-#include "util.h"
-
-std::string BuildConfig::status_format() const {
- std::string result = "[%f/%t] ";
- const char* env = environment.Get("NINJA_STATUS");
- if (env)
- result = env;
- return result;
-}
-
-int BuildConfig::status_max_commands() const {
- int result = 0;
- const char* env = environment.Get("NINJA_STATUS_MAX_COMMANDS");
- if (env) {
- int count = atoi(env);
- if (count < 0)
- count = 0;
- result = count;
- }
- return result;
-}
-
-int64_t BuildConfig::status_refresh_millis() const {
- int64_t result = 100;
- const char* env = environment.Get("NINJA_STATUS_REFRESH_MILLIS");
- if (env) {
- long long val = strtoll(env, NULL, 10);
- result = static_cast<int64_t>(val);
- }
- return result;
-}
-
-bool BuildConfig::operator==(const BuildConfig& o) const {
- return verbosity == o.verbosity && dry_run == o.dry_run &&
- parallelism == o.parallelism &&
- failures_allowed == o.failures_allowed &&
- max_load_average == o.max_load_average &&
- depfile_parser_options == o.depfile_parser_options &&
- input_file == o.input_file && environment == o.environment;
-}
-
-std::string BuildConfig::ToEncodedString() const {
- WireEncoder encoder;
- encoder.Write(verbosity);
- encoder.Write(dry_run);
- encoder.Write(parallelism);
- encoder.Write(failures_allowed);
- encoder.Write(max_load_average);
- // depfile_parser_options is empty!
- encoder.Write(input_file);
- encoder.Write(environment.ToEncodedString());
- return encoder.TakeResult();
-}
-
-// static
-BuildConfig BuildConfig::FromEncodedString(const std::string& str,
- std::string* error) {
- BuildConfig result;
-
- WireDecoder decoder(str);
- error->clear();
- decoder.Read(result.verbosity);
- decoder.Read(result.dry_run);
- decoder.Read(result.parallelism);
- decoder.Read(result.failures_allowed);
- decoder.Read(result.max_load_average);
- // depfile_parser_options is empty!
- decoder.Read(result.input_file);
-
- std::string encoded;
- decoder.Read(encoded);
- if (decoder.has_error()) {
- *error = "Truncated BuildCOnfig encoded string";
- return {};
- }
-
- result.environment = EnvironmentBlock::FromEncodedString(encoded, error);
- if (!error->empty())
- return {};
-
- return result;
-}
-
-std::string BuildConfig::ToString() const {
- std::string result = "verbosity=";
- switch (verbosity) {
- case QUIET:
- result += "quiet";
- break;
- case NO_STATUS_UPDATE:
- result += "no-status-upadte";
- break;
- case NORMAL:
- result += "normal";
- break;
- case VERBOSE:
- result += "verbose";
- break;
- default:
- StringAppendFormat(result, "unknown(%d)", static_cast<int>(verbosity));
- }
-
- StringAppendFormat(
- result,
- " dry_run=%s parallelism=%d failures_allowed=%d max_load_average=%.2f",
- dry_run ? "true" : "false", parallelism, failures_allowed,
- max_load_average);
-
- StringAppendFormat(result, "input_file=%s", input_file.c_str());
-
- StringAppendFormat(
- result,
- " environment=%s", environment.AsString().c_str());
-
- StringAppendFormat(
- result,
- " status_format=%s status_max_commands=%d status_refresh_millis=" PRId64,
- status_format().c_str(), status_max_commands(), status_refresh_millis());
-
- return result;
-}
diff --git a/src/build_config.h b/src/build_config.h
deleted file mode 100644
index b0f0709..0000000
--- a/src/build_config.h
+++ /dev/null
@@ -1,66 +0,0 @@
-// Copyright 2023 Google Inc. All Rights Reserved.
-//
-// Licensed under the Apache License, Version 2.0 (the "License");
-// you may not use this file except in compliance with the License.
-// You may obtain a copy of the License at
-//
-// http://www.apache.org/licenses/LICENSE-2.0
-//
-// Unless required by applicable law or agreed to in writing, software
-// distributed under the License is distributed on an "AS IS" BASIS,
-// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-// See the License for the specific language governing permissions and
-// limitations under the License.
-
-#ifndef NINJA_BUILD_CONFIG_H_
-#define NINJA_BUILD_CONFIG_H_
-
-#include <string>
-
-#include "depfile_parser.h"
-#include "process_utils.h"
-
-/// Options (e.g. verbosity, parallelism) passed to a build.
-/// NOTE: This does not include debug flags, stored in global variables :-/
-struct BuildConfig {
- enum Verbosity {
- QUIET, // No output -- used when testing.
- NO_STATUS_UPDATE, // just regular output but suppress status update
- NORMAL, // regular output and status update
- VERBOSE
- };
- Verbosity verbosity = NORMAL;
- bool dry_run = false;
- int parallelism = 1;
- int failures_allowed = 1;
- /// The maximum load average we must not exceed. A negative value
- /// means that we do not have any limit.
- double max_load_average = -0.0f;
- /// Name of the main manifest input file.
- std::string input_file = "build.ninja";
-
- DepfileParserOptions depfile_parser_options;
-
- /// The set of environment variables to use when spawning commands.
- EnvironmentBlock environment;
-
- /// Retrieve some values from environment variables.
- std::string status_format() const;
- int status_max_commands() const;
- int64_t status_refresh_millis() const;
-
- /// Compare two instances.
- bool operator==(const BuildConfig& o) const;
- bool operator!=(const BuildConfig& o) const { return !(*this == o); }
-
- /// Encoding/decoding support for IPC.
- static BuildConfig FromEncodedString(const std::string& str,
- std::string* error);
-
- std::string ToEncodedString() const;
-
- /// Convert to string for debugging.
- std::string ToString() const;
-};
-
-#endif // NINJA_BUILD_CONFIG_H_
diff --git a/src/build_log.cc b/src/build_log.cc
deleted file mode 100644
index b415025..0000000
--- a/src/build_log.cc
+++ /dev/null
@@ -1,502 +0,0 @@
-// Copyright 2011 Google Inc. All Rights Reserved.
-//
-// Licensed under the Apache License, Version 2.0 (the "License");
-// you may not use this file except in compliance with the License.
-// You may obtain a copy of the License at
-//
-// http://www.apache.org/licenses/LICENSE-2.0
-//
-// Unless required by applicable law or agreed to in writing, software
-// distributed under the License is distributed on an "AS IS" BASIS,
-// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-// See the License for the specific language governing permissions and
-// limitations under the License.
-
-// On AIX, inttypes.h gets indirectly included by build_log.h.
-// It's easiest just to ask for the printf format macros right away.
-#ifndef _WIN32
-#ifndef __STDC_FORMAT_MACROS
-#define __STDC_FORMAT_MACROS
-#endif
-#endif
-
-#include "build_log.h"
-#include "disk_interface.h"
-
-#include <cassert>
-#include <errno.h>
-#include <stdlib.h>
-#include <string.h>
-
-#ifndef _WIN32
-#include <inttypes.h>
-#include <unistd.h>
-#endif
-
-#include "build.h"
-#include "graph.h"
-#include "metrics.h"
-#include "util.h"
-#if defined(_MSC_VER) && (_MSC_VER < 1800)
-#define strtoll _strtoi64
-#endif
-
-using namespace std;
-
-// Implementation details:
-// Each run's log appends to the log file.
-// To load, we run through all log entries in series, throwing away
-// older runs.
-// Once the number of redundant entries exceeds a threshold, we write
-// out a new file and replace the existing one with it.
-
-namespace {
-
-const char kFileSignature[] = "# ninja log v%d\n";
-const int kOldestSupportedVersion = 4;
-const int kCurrentVersion = 5;
-
-// 64bit MurmurHash2, by Austin Appleby
-#if defined(_MSC_VER)
-#define BIG_CONSTANT(x) (x)
-#else // defined(_MSC_VER)
-#define BIG_CONSTANT(x) (x##LLU)
-#endif // !defined(_MSC_VER)
-inline
-uint64_t MurmurHash64A(const void* key, size_t len) {
- static const uint64_t seed = 0xDECAFBADDECAFBADull;
- const uint64_t m = BIG_CONSTANT(0xc6a4a7935bd1e995);
- const int r = 47;
- uint64_t h = seed ^ (len * m);
- const unsigned char* data = (const unsigned char*)key;
- while (len >= 8) {
- uint64_t k;
- memcpy(&k, data, sizeof k);
- k *= m;
- k ^= k >> r;
- k *= m;
- h ^= k;
- h *= m;
- data += 8;
- len -= 8;
- }
- switch (len & 7)
- {
- case 7: h ^= uint64_t(data[6]) << 48;
- NINJA_FALLTHROUGH;
- case 6: h ^= uint64_t(data[5]) << 40;
- NINJA_FALLTHROUGH;
- case 5: h ^= uint64_t(data[4]) << 32;
- NINJA_FALLTHROUGH;
- case 4: h ^= uint64_t(data[3]) << 24;
- NINJA_FALLTHROUGH;
- case 3: h ^= uint64_t(data[2]) << 16;
- NINJA_FALLTHROUGH;
- case 2: h ^= uint64_t(data[1]) << 8;
- NINJA_FALLTHROUGH;
- case 1: h ^= uint64_t(data[0]);
- h *= m;
- };
- h ^= h >> r;
- h *= m;
- h ^= h >> r;
- return h;
-}
-#undef BIG_CONSTANT
-
-
-} // namespace
-
-// static
-uint64_t BuildLog::LogEntry::HashCommand(StringPiece command) {
- return MurmurHash64A(command.str_, command.len_);
-}
-
-BuildLog::LogEntry::LogEntry(const string& output)
- : output(output) {}
-
-BuildLog::LogEntry::LogEntry(const string& output, uint64_t command_hash,
- int start_time, int end_time, TimeStamp mtime)
- : output(output), command_hash(command_hash),
- start_time(start_time), end_time(end_time), mtime(mtime)
-{}
-
-BuildLog::BuildLog()
- : log_file_(NULL), needs_recompaction_(false) {}
-
-BuildLog::~BuildLog() {
- Close();
-
- for (auto& pair : entries_) {
- delete pair.second;
- }
- entries_.clear();
-}
-
-bool BuildLog::OpenForWrite(const string& path, const BuildLogUser& user,
- string* err) {
- if (needs_recompaction_) {
- if (!Recompact(path, user, err))
- return false;
- }
-
- assert(!log_file_);
- log_file_path_ = path; // we don't actually open the file right now, but will
- // do so on the first write attempt
- return true;
-}
-
-bool BuildLog::RecordCommand(Edge* edge, int start_time, int end_time,
- TimeStamp mtime) {
- string command = edge->EvaluateCommand(true);
- uint64_t command_hash = LogEntry::HashCommand(command);
- for (vector<Node*>::iterator out = edge->outputs_.begin();
- out != edge->outputs_.end(); ++out) {
- const string& path = (*out)->path();
- Entries::iterator i = entries_.find(path);
- LogEntry* log_entry;
- if (i != entries_.end()) {
- log_entry = i->second;
- } else {
- log_entry = new LogEntry(path);
- entries_.insert(Entries::value_type(log_entry->output, log_entry));
- }
- log_entry->command_hash = command_hash;
- log_entry->start_time = start_time;
- log_entry->end_time = end_time;
- log_entry->mtime = mtime;
-
- if (!OpenForWriteIfNeeded()) {
- return false;
- }
- if (log_file_) {
- if (!WriteEntry(log_file_, *log_entry))
- return false;
- if (fflush(log_file_) != 0) {
- return false;
- }
- }
- }
- return true;
-}
-
-void BuildLog::Close() {
- OpenForWriteIfNeeded(); // create the file even if nothing has been recorded
- if (log_file_)
- fclose(log_file_);
- log_file_ = NULL;
-}
-
-bool BuildLog::OpenForWriteIfNeeded() {
- if (log_file_ || log_file_path_.empty()) {
- return true;
- }
- log_file_ = fopen(log_file_path_.c_str(), "ab");
- if (!log_file_) {
- return false;
- }
- if (setvbuf(log_file_, NULL, _IOLBF, BUFSIZ) != 0) {
- return false;
- }
- SetCloseOnExec(fileno(log_file_));
-
- // Opening a file in append mode doesn't set the file pointer to the file's
- // end on Windows. Do that explicitly.
- fseek(log_file_, 0, SEEK_END);
-
- if (ftell(log_file_) == 0) {
- if (fprintf(log_file_, kFileSignature, kCurrentVersion) < 0) {
- return false;
- }
- }
- return true;
-}
-
-struct LineReader {
- explicit LineReader(FILE* file)
- : file_(file), buf_end_(buf_), line_start_(buf_), line_end_(NULL) {
- memset(buf_, 0, sizeof(buf_));
- }
-
- // Reads a \n-terminated line from the file passed to the constructor.
- // On return, *line_start points to the beginning of the next line, and
- // *line_end points to the \n at the end of the line. If no newline is seen
- // in a fixed buffer size, *line_end is set to NULL. Returns false on EOF.
- bool ReadLine(char** line_start, char** line_end) {
- if (line_start_ >= buf_end_ || !line_end_) {
- // Buffer empty, refill.
- size_t size_read = fread(buf_, 1, sizeof(buf_), file_);
- if (!size_read)
- return false;
- line_start_ = buf_;
- buf_end_ = buf_ + size_read;
- } else {
- // Advance to next line in buffer.
- line_start_ = line_end_ + 1;
- }
-
- line_end_ = (char*)memchr(line_start_, '\n', buf_end_ - line_start_);
- if (!line_end_) {
- // No newline. Move rest of data to start of buffer, fill rest.
- size_t already_consumed = line_start_ - buf_;
- size_t size_rest = (buf_end_ - buf_) - already_consumed;
- memmove(buf_, line_start_, size_rest);
-
- size_t read = fread(buf_ + size_rest, 1, sizeof(buf_) - size_rest, file_);
- buf_end_ = buf_ + size_rest + read;
- line_start_ = buf_;
- line_end_ = (char*)memchr(line_start_, '\n', buf_end_ - line_start_);
- }
-
- *line_start = line_start_;
- *line_end = line_end_;
- return true;
- }
-
- private:
- FILE* file_;
- char buf_[256 << 10];
- char* buf_end_; // Points one past the last valid byte in |buf_|.
-
- char* line_start_;
- // Points at the next \n in buf_ after line_start, or NULL.
- char* line_end_;
-};
-
-LoadStatus BuildLog::Load(const string& path, string* err) {
- METRIC_RECORD_LOAD(".ninja_log load");
- FILE* file = fopen(path.c_str(), "r");
- if (!file) {
- if (errno == ENOENT)
- return LOAD_NOT_FOUND;
- *err = strerror(errno);
- return LOAD_ERROR;
- }
-
- int log_version = 0;
- int unique_entry_count = 0;
- int total_entry_count = 0;
-
- LineReader reader(file);
- char* line_start = 0;
- char* line_end = 0;
- while (reader.ReadLine(&line_start, &line_end)) {
- if (!log_version) {
- sscanf(line_start, kFileSignature, &log_version);
-
- if (log_version < kOldestSupportedVersion) {
- *err = ("build log version invalid, perhaps due to being too old; "
- "starting over");
- fclose(file);
- unlink(path.c_str());
- // Don't report this as a failure. An empty build log will cause
- // us to rebuild the outputs anyway.
- return LOAD_SUCCESS;
- }
- }
-
- // If no newline was found in this chunk, read the next.
- if (!line_end)
- continue;
-
- const char kFieldSeparator = '\t';
-
- char* start = line_start;
- char* end = (char*)memchr(start, kFieldSeparator, line_end - start);
- if (!end)
- continue;
- *end = 0;
-
- int start_time = 0, end_time = 0;
- TimeStamp mtime = 0;
-
- start_time = atoi(start);
- start = end + 1;
-
- end = (char*)memchr(start, kFieldSeparator, line_end - start);
- if (!end)
- continue;
- *end = 0;
- end_time = atoi(start);
- start = end + 1;
-
- end = (char*)memchr(start, kFieldSeparator, line_end - start);
- if (!end)
- continue;
- *end = 0;
- mtime = strtoll(start, NULL, 10);
- start = end + 1;
-
- end = (char*)memchr(start, kFieldSeparator, line_end - start);
- if (!end)
- continue;
- string output = string(start, end - start);
-
- start = end + 1;
- end = line_end;
-
- LogEntry* entry;
- Entries::iterator i = entries_.find(output);
- if (i != entries_.end()) {
- entry = i->second;
- } else {
- entry = new LogEntry(output);
- entries_.insert(Entries::value_type(entry->output, entry));
- ++unique_entry_count;
- }
- ++total_entry_count;
-
- entry->start_time = start_time;
- entry->end_time = end_time;
- entry->mtime = mtime;
- if (log_version >= 5) {
- char c = *end; *end = '\0';
- entry->command_hash = (uint64_t)strtoull(start, NULL, 16);
- *end = c;
- } else {
- entry->command_hash = LogEntry::HashCommand(StringPiece(start,
- end - start));
- }
- }
- fclose(file);
-
- if (!line_start) {
- return LOAD_SUCCESS; // file was empty
- }
-
- // Decide whether it's time to rebuild the log:
- // - if we're upgrading versions
- // - if it's getting large
- int kMinCompactionEntryCount = 100;
- int kCompactionRatio = 3;
- if (log_version < kCurrentVersion) {
- needs_recompaction_ = true;
- } else if (total_entry_count > kMinCompactionEntryCount &&
- total_entry_count > unique_entry_count * kCompactionRatio) {
- needs_recompaction_ = true;
- }
-
- return LOAD_SUCCESS;
-}
-
-BuildLog::LogEntry* BuildLog::LookupByOutput(const string& path) {
- Entries::iterator i = entries_.find(path);
- if (i != entries_.end())
- return i->second;
- return NULL;
-}
-
-bool BuildLog::WriteEntry(FILE* f, const LogEntry& entry) {
- return fprintf(f, "%d\t%d\t%" PRId64 "\t%s\t%" PRIx64 "\n",
- entry.start_time, entry.end_time, entry.mtime,
- entry.output.c_str(), entry.command_hash) > 0;
-}
-
-bool BuildLog::Recompact(const string& path, const BuildLogUser& user,
- string* err) {
- METRIC_RECORD(".ninja_log recompact");
-
- Close();
- string temp_path = path + ".recompact";
- FILE* f = fopen(temp_path.c_str(), "wb");
- if (!f) {
- *err = strerror(errno);
- return false;
- }
-
- if (fprintf(f, kFileSignature, kCurrentVersion) < 0) {
- *err = strerror(errno);
- fclose(f);
- return false;
- }
-
- vector<StringPiece> dead_outputs;
- for (Entries::iterator i = entries_.begin(); i != entries_.end(); ++i) {
- if (user.IsPathDead(i->first)) {
- dead_outputs.push_back(i->first);
- continue;
- }
-
- if (!WriteEntry(f, *i->second)) {
- *err = strerror(errno);
- fclose(f);
- return false;
- }
- }
-
- for (size_t i = 0; i < dead_outputs.size(); ++i) {
- auto it = entries_.find(dead_outputs[i]);
- delete it->second;
- entries_.erase(it);
- }
-
- fclose(f);
- if (unlink(path.c_str()) < 0) {
- *err = strerror(errno);
- return false;
- }
-
- if (rename(temp_path.c_str(), path.c_str()) < 0) {
- *err = strerror(errno);
- return false;
- }
-
- return true;
-}
-
-bool BuildLog::Restat(const StringPiece path,
- const DiskInterface& disk_interface,
- const int output_count, char** outputs,
- std::string* const err) {
- METRIC_RECORD(".ninja_log restat");
-
- Close();
- std::string temp_path = path.AsString() + ".restat";
- FILE* f = fopen(temp_path.c_str(), "wb");
- if (!f) {
- *err = strerror(errno);
- return false;
- }
-
- if (fprintf(f, kFileSignature, kCurrentVersion) < 0) {
- *err = strerror(errno);
- fclose(f);
- return false;
- }
- for (Entries::iterator i = entries_.begin(); i != entries_.end(); ++i) {
- bool skip = output_count > 0;
- for (int j = 0; j < output_count; ++j) {
- if (i->second->output == outputs[j]) {
- skip = false;
- break;
- }
- }
- if (!skip) {
- const TimeStamp mtime = disk_interface.Stat(i->second->output, err);
- if (mtime == -1) {
- fclose(f);
- return false;
- }
- i->second->mtime = mtime;
- }
-
- if (!WriteEntry(f, *i->second)) {
- *err = strerror(errno);
- fclose(f);
- return false;
- }
- }
-
- fclose(f);
- if (unlink(path.str_) < 0) {
- *err = strerror(errno);
- return false;
- }
-
- if (rename(temp_path.c_str(), path.str_) < 0) {
- *err = strerror(errno);
- return false;
- }
-
- return true;
-}
diff --git a/src/build_log.h b/src/build_log.h
deleted file mode 100644
index c51303c..0000000
--- a/src/build_log.h
+++ /dev/null
@@ -1,110 +0,0 @@
-// Copyright 2011 Google Inc. All Rights Reserved.
-//
-// Licensed under the Apache License, Version 2.0 (the "License");
-// you may not use this file except in compliance with the License.
-// You may obtain a copy of the License at
-//
-// http://www.apache.org/licenses/LICENSE-2.0
-//
-// Unless required by applicable law or agreed to in writing, software
-// distributed under the License is distributed on an "AS IS" BASIS,
-// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-// See the License for the specific language governing permissions and
-// limitations under the License.
-
-#ifndef NINJA_BUILD_LOG_H_
-#define NINJA_BUILD_LOG_H_
-
-#include <string>
-#include <stdio.h>
-
-#include "hash_map.h"
-#include "load_status.h"
-#include "timestamp.h"
-#include "util.h" // uint64_t
-
-struct DiskInterface;
-struct Edge;
-
-/// Can answer questions about the manifest for the BuildLog.
-struct BuildLogUser {
- /// Return if a given output is no longer part of the build manifest.
- /// This is only called during recompaction and doesn't have to be fast.
- virtual bool IsPathDead(StringPiece s) const = 0;
-};
-
-/// Store a log of every command ran for every build.
-/// It has a few uses:
-///
-/// 1) (hashes of) command lines for existing output files, so we know
-/// when we need to rebuild due to the command changing
-/// 2) timing information, perhaps for generating reports
-/// 3) restat information
-struct BuildLog {
- BuildLog();
- ~BuildLog();
-
- /// Prepares writing to the log file without actually opening it - that will
- /// happen when/if it's needed
- bool OpenForWrite(const std::string& path, const BuildLogUser& user,
- std::string* err);
- bool RecordCommand(Edge* edge, int start_time, int end_time,
- TimeStamp mtime = 0);
- void Close();
-
- /// Load the on-disk log.
- LoadStatus Load(const std::string& path, std::string* err);
-
- struct LogEntry {
- std::string output;
- uint64_t command_hash;
- int start_time;
- int end_time;
- TimeStamp mtime;
-
- static uint64_t HashCommand(StringPiece command);
-
- // Used by tests.
- bool operator==(const LogEntry& o) {
- return output == o.output && command_hash == o.command_hash &&
- start_time == o.start_time && end_time == o.end_time &&
- mtime == o.mtime;
- }
-
- explicit LogEntry(const std::string& output);
- LogEntry(const std::string& output, uint64_t command_hash,
- int start_time, int end_time, TimeStamp mtime);
- };
-
- /// Return the number of entries in the log.
- size_t size() const { return entries_.size(); }
-
- /// Lookup a previously-run command by its output path.
- LogEntry* LookupByOutput(const std::string& path);
-
- /// Serialize an entry into a log file.
- bool WriteEntry(FILE* f, const LogEntry& entry);
-
- /// Rewrite the known log entries, throwing away old data.
- bool Recompact(const std::string& path, const BuildLogUser& user,
- std::string* err);
-
- /// Restat all outputs in the log
- bool Restat(StringPiece path, const DiskInterface& disk_interface,
- int output_count, char** outputs, std::string* err);
-
- typedef ExternalStringHashMap<LogEntry*>::Type Entries;
- const Entries& entries() const { return entries_; }
-
- private:
- /// Should be called before using log_file_. When false is returned, errno
- /// will be set.
- bool OpenForWriteIfNeeded();
-
- Entries entries_;
- FILE* log_file_;
- std::string log_file_path_;
- bool needs_recompaction_;
-};
-
-#endif // NINJA_BUILD_LOG_H_
diff --git a/src/build_log_perftest.cc b/src/build_log_perftest.cc
deleted file mode 100644
index 5a93619..0000000
--- a/src/build_log_perftest.cc
+++ /dev/null
@@ -1,150 +0,0 @@
-// Copyright 2012 Google Inc. All Rights Reserved.
-//
-// Licensed under the Apache License, Version 2.0 (the "License");
-// you may not use this file except in compliance with the License.
-// You may obtain a copy of the License at
-//
-// http://www.apache.org/licenses/LICENSE-2.0
-//
-// Unless required by applicable law or agreed to in writing, software
-// distributed under the License is distributed on an "AS IS" BASIS,
-// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-// See the License for the specific language governing permissions and
-// limitations under the License.
-
-#include <stdio.h>
-#include <stdlib.h>
-
-#include "build_log.h"
-#include "graph.h"
-#include "manifest_parser.h"
-#include "state.h"
-#include "util.h"
-#include "metrics.h"
-
-#ifndef _WIN32
-#include <unistd.h>
-#endif
-
-using namespace std;
-
-const char kTestFilename[] = "BuildLogPerfTest-tempfile";
-
-struct NoDeadPaths : public BuildLogUser {
- virtual bool IsPathDead(StringPiece) const { return false; }
-};
-
-bool WriteTestData(string* err) {
- BuildLog log;
-
- NoDeadPaths no_dead_paths;
- if (!log.OpenForWrite(kTestFilename, no_dead_paths, err))
- return false;
-
- /*
- A histogram of command lengths in chromium. For example, 407 builds,
- 1.4% of all builds, had commands longer than 32 bytes but shorter than 64.
- 32 407 1.4%
- 64 183 0.6%
- 128 1461 5.1%
- 256 791 2.8%
- 512 1314 4.6%
- 1024 6114 21.3%
- 2048 11759 41.0%
- 4096 2056 7.2%
- 8192 4567 15.9%
- 16384 13 0.0%
- 32768 4 0.0%
- 65536 5 0.0%
- The average command length is 4.1 kB and there were 28674 commands in total,
- which makes for a total log size of ~120 MB (also counting output filenames).
-
- Based on this, write 30000 many 4 kB long command lines.
- */
-
- // ManifestParser is the only object allowed to create Rules.
- const size_t kRuleSize = 4000;
- string long_rule_command = "gcc ";
- for (int i = 0; long_rule_command.size() < kRuleSize; ++i) {
- char buf[80];
- sprintf(buf, "-I../../and/arbitrary/but/fairly/long/path/suffixed/%d ", i);
- long_rule_command += buf;
- }
- long_rule_command += "$in -o $out\n";
-
- State state;
- ManifestParser parser(&state, NULL);
- if (!parser.ParseTest("rule cxx\n command = " + long_rule_command, err))
- return false;
-
- // Create build edges. Using ManifestParser is as fast as using the State api
- // for edge creation, so just use that.
- const int kNumCommands = 30000;
- string build_rules;
- for (int i = 0; i < kNumCommands; ++i) {
- char buf[80];
- sprintf(buf, "build input%d.o: cxx input%d.cc\n", i, i);
- build_rules += buf;
- }
-
- if (!parser.ParseTest(build_rules, err))
- return false;
-
- for (int i = 0; i < kNumCommands; ++i) {
- log.RecordCommand(state.edges_[i],
- /*start_time=*/100 * i,
- /*end_time=*/100 * i + 1,
- /*mtime=*/0);
- }
-
- return true;
-}
-
-int main() {
- vector<int> times;
- string err;
-
- if (!WriteTestData(&err)) {
- fprintf(stderr, "Failed to write test data: %s\n", err.c_str());
- return 1;
- }
-
- {
- // Read once to warm up disk cache.
- BuildLog log;
- if (log.Load(kTestFilename, &err) == LOAD_ERROR) {
- fprintf(stderr, "Failed to read test data: %s\n", err.c_str());
- return 1;
- }
- }
- const int kNumRepetitions = 5;
- for (int i = 0; i < kNumRepetitions; ++i) {
- int64_t start = GetTimeMillis();
- BuildLog log;
- if (log.Load(kTestFilename, &err) == LOAD_ERROR) {
- fprintf(stderr, "Failed to read test data: %s\n", err.c_str());
- return 1;
- }
- int delta = (int)(GetTimeMillis() - start);
- printf("%dms\n", delta);
- times.push_back(delta);
- }
-
- int min = times[0];
- int max = times[0];
- float total = 0;
- for (size_t i = 0; i < times.size(); ++i) {
- total += times[i];
- if (times[i] < min)
- min = times[i];
- else if (times[i] > max)
- max = times[i];
- }
-
- printf("min %dms max %dms avg %.1fms\n",
- min, max, total / times.size());
-
- unlink(kTestFilename);
-
- return 0;
-}
diff --git a/src/build_log_test.cc b/src/build_log_test.cc
deleted file mode 100644
index 4725377..0000000
--- a/src/build_log_test.cc
+++ /dev/null
@@ -1,362 +0,0 @@
-// Copyright 2011 Google Inc. All Rights Reserved.
-//
-// Licensed under the Apache License, Version 2.0 (the "License");
-// you may not use this file except in compliance with the License.
-// You may obtain a copy of the License at
-//
-// http://www.apache.org/licenses/LICENSE-2.0
-//
-// Unless required by applicable law or agreed to in writing, software
-// distributed under the License is distributed on an "AS IS" BASIS,
-// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-// See the License for the specific language governing permissions and
-// limitations under the License.
-
-#include "build_log.h"
-
-#include "util.h"
-#include "test.h"
-
-#include <sys/stat.h>
-#ifdef _WIN32
-#include <fcntl.h>
-#include <share.h>
-#else
-#include <sys/types.h>
-#include <unistd.h>
-#endif
-#include <cassert>
-
-using namespace std;
-
-namespace {
-
-const char kTestFilename[] = "BuildLogTest-tempfile";
-
-struct BuildLogTest : public StateTestWithBuiltinRules, public BuildLogUser {
- virtual void SetUp() {
- // In case a crashing test left a stale file behind.
- unlink(kTestFilename);
- }
- virtual void TearDown() {
- unlink(kTestFilename);
- }
- virtual bool IsPathDead(StringPiece s) const { return false; }
-};
-
-TEST_F(BuildLogTest, WriteRead) {
- AssertParse(&state_,
-"build out: cat mid\n"
-"build mid: cat in\n");
-
- BuildLog log1;
- string err;
- EXPECT_TRUE(log1.OpenForWrite(kTestFilename, *this, &err));
- ASSERT_EQ("", err);
- log1.RecordCommand(state_.edges_[0], 15, 18);
- log1.RecordCommand(state_.edges_[1], 20, 25);
- log1.Close();
-
- BuildLog log2;
- EXPECT_TRUE(log2.Load(kTestFilename, &err));
- ASSERT_EQ("", err);
-
- ASSERT_EQ(2u, log1.entries().size());
- ASSERT_EQ(2u, log2.entries().size());
- BuildLog::LogEntry* e1 = log1.LookupByOutput("out");
- ASSERT_TRUE(e1);
- BuildLog::LogEntry* e2 = log2.LookupByOutput("out");
- ASSERT_TRUE(e2);
- ASSERT_TRUE(*e1 == *e2);
- ASSERT_EQ(15, e1->start_time);
- ASSERT_EQ("out", e1->output);
-}
-
-TEST_F(BuildLogTest, FirstWriteAddsSignature) {
- const char kExpectedVersion[] = "# ninja log vX\n";
- const size_t kVersionPos = strlen(kExpectedVersion) - 2; // Points at 'X'.
-
- BuildLog log;
- string contents, err;
-
- EXPECT_TRUE(log.OpenForWrite(kTestFilename, *this, &err));
- ASSERT_EQ("", err);
- log.Close();
-
- ASSERT_EQ(0, ReadFile(kTestFilename, &contents, &err));
- ASSERT_EQ("", err);
- if (contents.size() >= kVersionPos)
- contents[kVersionPos] = 'X';
- EXPECT_EQ(kExpectedVersion, contents);
-
- // Opening the file anew shouldn't add a second version string.
- EXPECT_TRUE(log.OpenForWrite(kTestFilename, *this, &err));
- ASSERT_EQ("", err);
- log.Close();
-
- contents.clear();
- ASSERT_EQ(0, ReadFile(kTestFilename, &contents, &err));
- ASSERT_EQ("", err);
- if (contents.size() >= kVersionPos)
- contents[kVersionPos] = 'X';
- EXPECT_EQ(kExpectedVersion, contents);
-}
-
-TEST_F(BuildLogTest, DoubleEntry) {
- FILE* f = fopen(kTestFilename, "wb");
- fprintf(f, "# ninja log v4\n");
- fprintf(f, "0\t1\t2\tout\tcommand abc\n");
- fprintf(f, "3\t4\t5\tout\tcommand def\n");
- fclose(f);
-
- string err;
- BuildLog log;
- EXPECT_TRUE(log.Load(kTestFilename, &err));
- ASSERT_EQ("", err);
-
- BuildLog::LogEntry* e = log.LookupByOutput("out");
- ASSERT_TRUE(e);
- ASSERT_NO_FATAL_FAILURE(AssertHash("command def", e->command_hash));
-}
-
-TEST_F(BuildLogTest, Truncate) {
- AssertParse(&state_,
-"build out: cat mid\n"
-"build mid: cat in\n");
-
- {
- BuildLog log1;
- string err;
- EXPECT_TRUE(log1.OpenForWrite(kTestFilename, *this, &err));
- ASSERT_EQ("", err);
- log1.RecordCommand(state_.edges_[0], 15, 18);
- log1.RecordCommand(state_.edges_[1], 20, 25);
- log1.Close();
- }
-#ifdef __USE_LARGEFILE64
- struct stat64 statbuf;
- ASSERT_EQ(0, stat64(kTestFilename, &statbuf));
-#else
- struct stat statbuf;
- ASSERT_EQ(0, stat(kTestFilename, &statbuf));
-#endif
- ASSERT_GT(statbuf.st_size, 0);
-
- // For all possible truncations of the input file, assert that we don't
- // crash when parsing.
- for (off_t size = statbuf.st_size; size > 0; --size) {
- BuildLog log2;
- string err;
- EXPECT_TRUE(log2.OpenForWrite(kTestFilename, *this, &err));
- ASSERT_EQ("", err);
- log2.RecordCommand(state_.edges_[0], 15, 18);
- log2.RecordCommand(state_.edges_[1], 20, 25);
- log2.Close();
-
- ASSERT_TRUE(Truncate(kTestFilename, size, &err));
-
- BuildLog log3;
- err.clear();
- ASSERT_TRUE(log3.Load(kTestFilename, &err) == LOAD_SUCCESS || !err.empty());
- }
-}
-
-TEST_F(BuildLogTest, ObsoleteOldVersion) {
- FILE* f = fopen(kTestFilename, "wb");
- fprintf(f, "# ninja log v3\n");
- fprintf(f, "123 456 0 out command\n");
- fclose(f);
-
- string err;
- BuildLog log;
- EXPECT_TRUE(log.Load(kTestFilename, &err));
- ASSERT_NE(err.find("version"), string::npos);
-}
-
-TEST_F(BuildLogTest, SpacesInOutputV4) {
- FILE* f = fopen(kTestFilename, "wb");
- fprintf(f, "# ninja log v4\n");
- fprintf(f, "123\t456\t456\tout with space\tcommand\n");
- fclose(f);
-
- string err;
- BuildLog log;
- EXPECT_TRUE(log.Load(kTestFilename, &err));
- ASSERT_EQ("", err);
-
- BuildLog::LogEntry* e = log.LookupByOutput("out with space");
- ASSERT_TRUE(e);
- ASSERT_EQ(123, e->start_time);
- ASSERT_EQ(456, e->end_time);
- ASSERT_EQ(456, e->mtime);
- ASSERT_NO_FATAL_FAILURE(AssertHash("command", e->command_hash));
-}
-
-TEST_F(BuildLogTest, DuplicateVersionHeader) {
- // Old versions of ninja accidentally wrote multiple version headers to the
- // build log on Windows. This shouldn't crash, and the second version header
- // should be ignored.
- FILE* f = fopen(kTestFilename, "wb");
- fprintf(f, "# ninja log v4\n");
- fprintf(f, "123\t456\t456\tout\tcommand\n");
- fprintf(f, "# ninja log v4\n");
- fprintf(f, "456\t789\t789\tout2\tcommand2\n");
- fclose(f);
-
- string err;
- BuildLog log;
- EXPECT_TRUE(log.Load(kTestFilename, &err));
- ASSERT_EQ("", err);
-
- BuildLog::LogEntry* e = log.LookupByOutput("out");
- ASSERT_TRUE(e);
- ASSERT_EQ(123, e->start_time);
- ASSERT_EQ(456, e->end_time);
- ASSERT_EQ(456, e->mtime);
- ASSERT_NO_FATAL_FAILURE(AssertHash("command", e->command_hash));
-
- e = log.LookupByOutput("out2");
- ASSERT_TRUE(e);
- ASSERT_EQ(456, e->start_time);
- ASSERT_EQ(789, e->end_time);
- ASSERT_EQ(789, e->mtime);
- ASSERT_NO_FATAL_FAILURE(AssertHash("command2", e->command_hash));
-}
-
-struct TestDiskInterface : public DiskInterface {
- virtual TimeStamp Stat(const string& path, string* err) const {
- return 4;
- }
- virtual bool WriteFile(const string& path, const string& contents) {
- assert(false);
- return true;
- }
- virtual bool MakeDir(const string& path) {
- assert(false);
- return false;
- }
- virtual Status ReadFile(const string& path, string* contents, string* err) {
- assert(false);
- return NotFound;
- }
- virtual int RemoveFile(const string& path) {
- assert(false);
- return 0;
- }
-};
-
-TEST_F(BuildLogTest, Restat) {
- FILE* f = fopen(kTestFilename, "wb");
- fprintf(f, "# ninja log v4\n"
- "1\t2\t3\tout\tcommand\n");
- fclose(f);
- std::string err;
- BuildLog log;
- EXPECT_TRUE(log.Load(kTestFilename, &err));
- ASSERT_EQ("", err);
- BuildLog::LogEntry* e = log.LookupByOutput("out");
- ASSERT_EQ(3, e->mtime);
-
- TestDiskInterface testDiskInterface;
- char out2[] = { 'o', 'u', 't', '2', 0 };
- char* filter2[] = { out2 };
- EXPECT_TRUE(log.Restat(kTestFilename, testDiskInterface, 1, filter2, &err));
- ASSERT_EQ("", err);
- e = log.LookupByOutput("out");
- ASSERT_EQ(3, e->mtime); // unchanged, since the filter doesn't match
-
- EXPECT_TRUE(log.Restat(kTestFilename, testDiskInterface, 0, NULL, &err));
- ASSERT_EQ("", err);
- e = log.LookupByOutput("out");
- ASSERT_EQ(4, e->mtime);
-}
-
-TEST_F(BuildLogTest, VeryLongInputLine) {
- // Ninja's build log buffer is currently 256kB. Lines longer than that are
- // silently ignored, but don't affect parsing of other lines.
- FILE* f = fopen(kTestFilename, "wb");
- fprintf(f, "# ninja log v4\n");
- fprintf(f, "123\t456\t456\tout\tcommand start");
- for (size_t i = 0; i < (512 << 10) / strlen(" more_command"); ++i)
- fputs(" more_command", f);
- fprintf(f, "\n");
- fprintf(f, "456\t789\t789\tout2\tcommand2\n");
- fclose(f);
-
- string err;
- BuildLog log;
- EXPECT_TRUE(log.Load(kTestFilename, &err));
- ASSERT_EQ("", err);
-
- BuildLog::LogEntry* e = log.LookupByOutput("out");
- ASSERT_NULL(e);
-
- e = log.LookupByOutput("out2");
- ASSERT_TRUE(e);
- ASSERT_EQ(456, e->start_time);
- ASSERT_EQ(789, e->end_time);
- ASSERT_EQ(789, e->mtime);
- ASSERT_NO_FATAL_FAILURE(AssertHash("command2", e->command_hash));
-}
-
-TEST_F(BuildLogTest, MultiTargetEdge) {
- AssertParse(&state_,
-"build out out.d: cat\n");
-
- BuildLog log;
- log.RecordCommand(state_.edges_[0], 21, 22);
-
- ASSERT_EQ(2u, log.entries().size());
- BuildLog::LogEntry* e1 = log.LookupByOutput("out");
- ASSERT_TRUE(e1);
- BuildLog::LogEntry* e2 = log.LookupByOutput("out.d");
- ASSERT_TRUE(e2);
- ASSERT_EQ("out", e1->output);
- ASSERT_EQ("out.d", e2->output);
- ASSERT_EQ(21, e1->start_time);
- ASSERT_EQ(21, e2->start_time);
- ASSERT_EQ(22, e2->end_time);
- ASSERT_EQ(22, e2->end_time);
-}
-
-struct BuildLogRecompactTest : public BuildLogTest {
- virtual bool IsPathDead(StringPiece s) const { return s == "out2"; }
-};
-
-TEST_F(BuildLogRecompactTest, Recompact) {
- AssertParse(&state_,
-"build out: cat in\n"
-"build out2: cat in\n");
-
- BuildLog log1;
- string err;
- EXPECT_TRUE(log1.OpenForWrite(kTestFilename, *this, &err));
- ASSERT_EQ("", err);
- // Record the same edge several times, to trigger recompaction
- // the next time the log is opened.
- for (int i = 0; i < 200; ++i)
- log1.RecordCommand(state_.edges_[0], 15, 18 + i);
- log1.RecordCommand(state_.edges_[1], 21, 22);
- log1.Close();
-
- // Load...
- BuildLog log2;
- EXPECT_TRUE(log2.Load(kTestFilename, &err));
- ASSERT_EQ("", err);
- ASSERT_EQ(2u, log2.entries().size());
- ASSERT_TRUE(log2.LookupByOutput("out"));
- ASSERT_TRUE(log2.LookupByOutput("out2"));
- // ...and force a recompaction.
- EXPECT_TRUE(log2.OpenForWrite(kTestFilename, *this, &err));
- log2.Close();
-
- // "out2" is dead, it should've been removed.
- BuildLog log3;
- EXPECT_TRUE(log2.Load(kTestFilename, &err));
- ASSERT_EQ("", err);
- ASSERT_EQ(1u, log2.entries().size());
- ASSERT_TRUE(log2.LookupByOutput("out"));
- ASSERT_FALSE(log2.LookupByOutput("out2"));
-}
-
-} // anonymous namespace
diff --git a/src/build_test.cc b/src/build_test.cc
deleted file mode 100644
index 47daa09..0000000
--- a/src/build_test.cc
+++ /dev/null
@@ -1,4303 +0,0 @@
-// Copyright 2011 Google Inc. All Rights Reserved.
-//
-// Licensed under the Apache License, Version 2.0 (the "License");
-// you may not use this file except in compliance with the License.
-// You may obtain a copy of the License at
-//
-// http://www.apache.org/licenses/LICENSE-2.0
-//
-// Unless required by applicable law or agreed to in writing, software
-// distributed under the License is distributed on an "AS IS" BASIS,
-// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-// See the License for the specific language governing permissions and
-// limitations under the License.
-
-#include "build.h"
-
-#include <assert.h>
-
-#include "build_config.h"
-#include "build_log.h"
-#include "deps_log.h"
-#include "graph.h"
-#include "status.h"
-#include "test.h"
-
-using namespace std;
-
-struct CompareEdgesByOutput {
- static bool cmp(const Edge* a, const Edge* b) {
- return a->outputs_[0]->path() < b->outputs_[0]->path();
- }
-};
-
-/// Fixture for tests involving Plan.
-// Though Plan doesn't use State, it's useful to have one around
-// to create Nodes and Edges.
-struct PlanTest : public StateTestWithBuiltinRules {
- Plan plan_;
-
- /// Because FindWork does not return Edges in any sort of predictable order,
- // provide a means to get available Edges in order and in a format which is
- // easy to write tests around.
- void FindWorkSorted(deque<Edge*>* ret, int count) {
- for (int i = 0; i < count; ++i) {
- ASSERT_TRUE(plan_.more_to_do());
- Edge* edge = plan_.FindWork();
- ASSERT_TRUE(edge);
- ret->push_back(edge);
- }
- ASSERT_FALSE(plan_.FindWork());
- sort(ret->begin(), ret->end(), CompareEdgesByOutput::cmp);
- }
-
- void TestPoolWithDepthOne(const char *test_case);
-};
-
-TEST_F(PlanTest, Basic) {
- ASSERT_NO_FATAL_FAILURE(AssertParse(&state_,
-"build out: cat mid\n"
-"build mid: cat in\n"));
- GetNode("mid")->MarkDirty();
- GetNode("out")->MarkDirty();
- string err;
- EXPECT_TRUE(plan_.AddTarget(GetNode("out"), &err));
- ASSERT_EQ("", err);
- ASSERT_TRUE(plan_.more_to_do());
-
- Edge* edge = plan_.FindWork();
- ASSERT_TRUE(edge);
- ASSERT_EQ("in", edge->inputs_[0]->path());
- ASSERT_EQ("mid", edge->outputs_[0]->path());
-
- ASSERT_FALSE(plan_.FindWork());
-
- plan_.EdgeFinished(edge, Plan::kEdgeSucceeded, &err);
- ASSERT_EQ("", err);
-
- edge = plan_.FindWork();
- ASSERT_TRUE(edge);
- ASSERT_EQ("mid", edge->inputs_[0]->path());
- ASSERT_EQ("out", edge->outputs_[0]->path());
-
- plan_.EdgeFinished(edge, Plan::kEdgeSucceeded, &err);
- ASSERT_EQ("", err);
-
- ASSERT_FALSE(plan_.more_to_do());
- edge = plan_.FindWork();
- ASSERT_NULL(edge);
-}
-
-// Test that two outputs from one rule can be handled as inputs to the next.
-TEST_F(PlanTest, DoubleOutputDirect) {
- ASSERT_NO_FATAL_FAILURE(AssertParse(&state_,
-"build out: cat mid1 mid2\n"
-"build mid1 mid2: cat in\n"));
- GetNode("mid1")->MarkDirty();
- GetNode("mid2")->MarkDirty();
- GetNode("out")->MarkDirty();
-
- string err;
- EXPECT_TRUE(plan_.AddTarget(GetNode("out"), &err));
- ASSERT_EQ("", err);
- ASSERT_TRUE(plan_.more_to_do());
-
- Edge* edge;
- edge = plan_.FindWork();
- ASSERT_TRUE(edge); // cat in
- plan_.EdgeFinished(edge, Plan::kEdgeSucceeded, &err);
- ASSERT_EQ("", err);
-
- edge = plan_.FindWork();
- ASSERT_TRUE(edge); // cat mid1 mid2
- plan_.EdgeFinished(edge, Plan::kEdgeSucceeded, &err);
- ASSERT_EQ("", err);
-
- edge = plan_.FindWork();
- ASSERT_FALSE(edge); // done
-}
-
-// Test that two outputs from one rule can eventually be routed to another.
-TEST_F(PlanTest, DoubleOutputIndirect) {
- ASSERT_NO_FATAL_FAILURE(AssertParse(&state_,
-"build out: cat b1 b2\n"
-"build b1: cat a1\n"
-"build b2: cat a2\n"
-"build a1 a2: cat in\n"));
- GetNode("a1")->MarkDirty();
- GetNode("a2")->MarkDirty();
- GetNode("b1")->MarkDirty();
- GetNode("b2")->MarkDirty();
- GetNode("out")->MarkDirty();
- string err;
- EXPECT_TRUE(plan_.AddTarget(GetNode("out"), &err));
- ASSERT_EQ("", err);
- ASSERT_TRUE(plan_.more_to_do());
-
- Edge* edge;
- edge = plan_.FindWork();
- ASSERT_TRUE(edge); // cat in
- plan_.EdgeFinished(edge, Plan::kEdgeSucceeded, &err);
- ASSERT_EQ("", err);
-
- edge = plan_.FindWork();
- ASSERT_TRUE(edge); // cat a1
- plan_.EdgeFinished(edge, Plan::kEdgeSucceeded, &err);
- ASSERT_EQ("", err);
-
- edge = plan_.FindWork();
- ASSERT_TRUE(edge); // cat a2
- plan_.EdgeFinished(edge, Plan::kEdgeSucceeded, &err);
- ASSERT_EQ("", err);
-
- edge = plan_.FindWork();
- ASSERT_TRUE(edge); // cat b1 b2
- plan_.EdgeFinished(edge, Plan::kEdgeSucceeded, &err);
- ASSERT_EQ("", err);
-
- edge = plan_.FindWork();
- ASSERT_FALSE(edge); // done
-}
-
-// Test that two edges from one output can both execute.
-TEST_F(PlanTest, DoubleDependent) {
- ASSERT_NO_FATAL_FAILURE(AssertParse(&state_,
-"build out: cat a1 a2\n"
-"build a1: cat mid\n"
-"build a2: cat mid\n"
-"build mid: cat in\n"));
- GetNode("mid")->MarkDirty();
- GetNode("a1")->MarkDirty();
- GetNode("a2")->MarkDirty();
- GetNode("out")->MarkDirty();
-
- string err;
- EXPECT_TRUE(plan_.AddTarget(GetNode("out"), &err));
- ASSERT_EQ("", err);
- ASSERT_TRUE(plan_.more_to_do());
-
- Edge* edge;
- edge = plan_.FindWork();
- ASSERT_TRUE(edge); // cat in
- plan_.EdgeFinished(edge, Plan::kEdgeSucceeded, &err);
- ASSERT_EQ("", err);
-
- edge = plan_.FindWork();
- ASSERT_TRUE(edge); // cat mid
- plan_.EdgeFinished(edge, Plan::kEdgeSucceeded, &err);
- ASSERT_EQ("", err);
-
- edge = plan_.FindWork();
- ASSERT_TRUE(edge); // cat mid
- plan_.EdgeFinished(edge, Plan::kEdgeSucceeded, &err);
- ASSERT_EQ("", err);
-
- edge = plan_.FindWork();
- ASSERT_TRUE(edge); // cat a1 a2
- plan_.EdgeFinished(edge, Plan::kEdgeSucceeded, &err);
- ASSERT_EQ("", err);
-
- edge = plan_.FindWork();
- ASSERT_FALSE(edge); // done
-}
-
-void PlanTest::TestPoolWithDepthOne(const char* test_case) {
- ASSERT_NO_FATAL_FAILURE(AssertParse(&state_, test_case));
- GetNode("out1")->MarkDirty();
- GetNode("out2")->MarkDirty();
- string err;
- EXPECT_TRUE(plan_.AddTarget(GetNode("out1"), &err));
- ASSERT_EQ("", err);
- EXPECT_TRUE(plan_.AddTarget(GetNode("out2"), &err));
- ASSERT_EQ("", err);
- ASSERT_TRUE(plan_.more_to_do());
-
- Edge* edge = plan_.FindWork();
- ASSERT_TRUE(edge);
- ASSERT_EQ("in", edge->inputs_[0]->path());
- ASSERT_EQ("out1", edge->outputs_[0]->path());
-
- // This will be false since poolcat is serialized
- ASSERT_FALSE(plan_.FindWork());
-
- plan_.EdgeFinished(edge, Plan::kEdgeSucceeded, &err);
- ASSERT_EQ("", err);
-
- edge = plan_.FindWork();
- ASSERT_TRUE(edge);
- ASSERT_EQ("in", edge->inputs_[0]->path());
- ASSERT_EQ("out2", edge->outputs_[0]->path());
-
- ASSERT_FALSE(plan_.FindWork());
-
- plan_.EdgeFinished(edge, Plan::kEdgeSucceeded, &err);
- ASSERT_EQ("", err);
-
- ASSERT_FALSE(plan_.more_to_do());
- edge = plan_.FindWork();
- ASSERT_NULL(edge);
-}
-
-TEST_F(PlanTest, PoolWithDepthOne) {
- TestPoolWithDepthOne(
-"pool foobar\n"
-" depth = 1\n"
-"rule poolcat\n"
-" command = cat $in > $out\n"
-" pool = foobar\n"
-"build out1: poolcat in\n"
-"build out2: poolcat in\n");
-}
-
-TEST_F(PlanTest, ConsolePool) {
- TestPoolWithDepthOne(
-"rule poolcat\n"
-" command = cat $in > $out\n"
-" pool = console\n"
-"build out1: poolcat in\n"
-"build out2: poolcat in\n");
-}
-
-TEST_F(PlanTest, PoolsWithDepthTwo) {
- ASSERT_NO_FATAL_FAILURE(AssertParse(&state_,
-"pool foobar\n"
-" depth = 2\n"
-"pool bazbin\n"
-" depth = 2\n"
-"rule foocat\n"
-" command = cat $in > $out\n"
-" pool = foobar\n"
-"rule bazcat\n"
-" command = cat $in > $out\n"
-" pool = bazbin\n"
-"build out1: foocat in\n"
-"build out2: foocat in\n"
-"build out3: foocat in\n"
-"build outb1: bazcat in\n"
-"build outb2: bazcat in\n"
-"build outb3: bazcat in\n"
-" pool =\n"
-"build allTheThings: cat out1 out2 out3 outb1 outb2 outb3\n"
-));
- // Mark all the out* nodes dirty
- for (int i = 0; i < 3; ++i) {
- GetNode("out" + string(1, '1' + static_cast<char>(i)))->MarkDirty();
- GetNode("outb" + string(1, '1' + static_cast<char>(i)))->MarkDirty();
- }
- GetNode("allTheThings")->MarkDirty();
-
- string err;
- EXPECT_TRUE(plan_.AddTarget(GetNode("allTheThings"), &err));
- ASSERT_EQ("", err);
-
- deque<Edge*> edges;
- FindWorkSorted(&edges, 5);
-
- for (int i = 0; i < 4; ++i) {
- Edge *edge = edges[i];
- ASSERT_EQ("in", edge->inputs_[0]->path());
- string base_name(i < 2 ? "out" : "outb");
- ASSERT_EQ(base_name + string(1, '1' + (i % 2)), edge->outputs_[0]->path());
- }
-
- // outb3 is exempt because it has an empty pool
- Edge* edge = edges[4];
- ASSERT_TRUE(edge);
- ASSERT_EQ("in", edge->inputs_[0]->path());
- ASSERT_EQ("outb3", edge->outputs_[0]->path());
-
- // finish out1
- plan_.EdgeFinished(edges.front(), Plan::kEdgeSucceeded, &err);
- ASSERT_EQ("", err);
- edges.pop_front();
-
- // out3 should be available
- Edge* out3 = plan_.FindWork();
- ASSERT_TRUE(out3);
- ASSERT_EQ("in", out3->inputs_[0]->path());
- ASSERT_EQ("out3", out3->outputs_[0]->path());
-
- ASSERT_FALSE(plan_.FindWork());
-
- plan_.EdgeFinished(out3, Plan::kEdgeSucceeded, &err);
- ASSERT_EQ("", err);
-
- ASSERT_FALSE(plan_.FindWork());
-
- for (deque<Edge*>::iterator it = edges.begin(); it != edges.end(); ++it) {
- plan_.EdgeFinished(*it, Plan::kEdgeSucceeded, &err);
- ASSERT_EQ("", err);
- }
-
- Edge* last = plan_.FindWork();
- ASSERT_TRUE(last);
- ASSERT_EQ("allTheThings", last->outputs_[0]->path());
-
- plan_.EdgeFinished(last, Plan::kEdgeSucceeded, &err);
- ASSERT_EQ("", err);
-
- ASSERT_FALSE(plan_.more_to_do());
- ASSERT_FALSE(plan_.FindWork());
-}
-
-TEST_F(PlanTest, PoolWithRedundantEdges) {
- ASSERT_NO_FATAL_FAILURE(AssertParse(&state_,
- "pool compile\n"
- " depth = 1\n"
- "rule gen_foo\n"
- " command = touch foo.cpp\n"
- "rule gen_bar\n"
- " command = touch bar.cpp\n"
- "rule echo\n"
- " command = echo $out > $out\n"
- "build foo.cpp.obj: echo foo.cpp || foo.cpp\n"
- " pool = compile\n"
- "build bar.cpp.obj: echo bar.cpp || bar.cpp\n"
- " pool = compile\n"
- "build libfoo.a: echo foo.cpp.obj bar.cpp.obj\n"
- "build foo.cpp: gen_foo\n"
- "build bar.cpp: gen_bar\n"
- "build all: phony libfoo.a\n"));
- GetNode("foo.cpp")->MarkDirty();
- GetNode("foo.cpp.obj")->MarkDirty();
- GetNode("bar.cpp")->MarkDirty();
- GetNode("bar.cpp.obj")->MarkDirty();
- GetNode("libfoo.a")->MarkDirty();
- GetNode("all")->MarkDirty();
- string err;
- EXPECT_TRUE(plan_.AddTarget(GetNode("all"), &err));
- ASSERT_EQ("", err);
- ASSERT_TRUE(plan_.more_to_do());
-
- Edge* edge = NULL;
-
- deque<Edge*> initial_edges;
- FindWorkSorted(&initial_edges, 2);
-
- edge = initial_edges[1]; // Foo first
- ASSERT_EQ("foo.cpp", edge->outputs_[0]->path());
- plan_.EdgeFinished(edge, Plan::kEdgeSucceeded, &err);
- ASSERT_EQ("", err);
-
- edge = plan_.FindWork();
- ASSERT_TRUE(edge);
- ASSERT_FALSE(plan_.FindWork());
- ASSERT_EQ("foo.cpp", edge->inputs_[0]->path());
- ASSERT_EQ("foo.cpp", edge->inputs_[1]->path());
- ASSERT_EQ("foo.cpp.obj", edge->outputs_[0]->path());
- plan_.EdgeFinished(edge, Plan::kEdgeSucceeded, &err);
- ASSERT_EQ("", err);
-
- edge = initial_edges[0]; // Now for bar
- ASSERT_EQ("bar.cpp", edge->outputs_[0]->path());
- plan_.EdgeFinished(edge, Plan::kEdgeSucceeded, &err);
- ASSERT_EQ("", err);
-
- edge = plan_.FindWork();
- ASSERT_TRUE(edge);
- ASSERT_FALSE(plan_.FindWork());
- ASSERT_EQ("bar.cpp", edge->inputs_[0]->path());
- ASSERT_EQ("bar.cpp", edge->inputs_[1]->path());
- ASSERT_EQ("bar.cpp.obj", edge->outputs_[0]->path());
- plan_.EdgeFinished(edge, Plan::kEdgeSucceeded, &err);
- ASSERT_EQ("", err);
-
- edge = plan_.FindWork();
- ASSERT_TRUE(edge);
- ASSERT_FALSE(plan_.FindWork());
- ASSERT_EQ("foo.cpp.obj", edge->inputs_[0]->path());
- ASSERT_EQ("bar.cpp.obj", edge->inputs_[1]->path());
- ASSERT_EQ("libfoo.a", edge->outputs_[0]->path());
- plan_.EdgeFinished(edge, Plan::kEdgeSucceeded, &err);
- ASSERT_EQ("", err);
-
- edge = plan_.FindWork();
- ASSERT_TRUE(edge);
- ASSERT_FALSE(plan_.FindWork());
- ASSERT_EQ("libfoo.a", edge->inputs_[0]->path());
- ASSERT_EQ("all", edge->outputs_[0]->path());
- plan_.EdgeFinished(edge, Plan::kEdgeSucceeded, &err);
- ASSERT_EQ("", err);
-
- edge = plan_.FindWork();
- ASSERT_FALSE(edge);
- ASSERT_FALSE(plan_.more_to_do());
-}
-
-TEST_F(PlanTest, PoolWithFailingEdge) {
- ASSERT_NO_FATAL_FAILURE(AssertParse(&state_,
- "pool foobar\n"
- " depth = 1\n"
- "rule poolcat\n"
- " command = cat $in > $out\n"
- " pool = foobar\n"
- "build out1: poolcat in\n"
- "build out2: poolcat in\n"));
- GetNode("out1")->MarkDirty();
- GetNode("out2")->MarkDirty();
- string err;
- EXPECT_TRUE(plan_.AddTarget(GetNode("out1"), &err));
- ASSERT_EQ("", err);
- EXPECT_TRUE(plan_.AddTarget(GetNode("out2"), &err));
- ASSERT_EQ("", err);
- ASSERT_TRUE(plan_.more_to_do());
-
- Edge* edge = plan_.FindWork();
- ASSERT_TRUE(edge);
- ASSERT_EQ("in", edge->inputs_[0]->path());
- ASSERT_EQ("out1", edge->outputs_[0]->path());
-
- // This will be false since poolcat is serialized
- ASSERT_FALSE(plan_.FindWork());
-
- plan_.EdgeFinished(edge, Plan::kEdgeFailed, &err);
- ASSERT_EQ("", err);
-
- edge = plan_.FindWork();
- ASSERT_TRUE(edge);
- ASSERT_EQ("in", edge->inputs_[0]->path());
- ASSERT_EQ("out2", edge->outputs_[0]->path());
-
- ASSERT_FALSE(plan_.FindWork());
-
- plan_.EdgeFinished(edge, Plan::kEdgeFailed, &err);
- ASSERT_EQ("", err);
-
- ASSERT_TRUE(plan_.more_to_do()); // Jobs have failed
- edge = plan_.FindWork();
- ASSERT_NULL(edge);
-}
-
-/// Fake implementation of CommandRunner, useful for tests.
-struct FakeCommandRunner : public CommandRunner {
- explicit FakeCommandRunner(VirtualFileSystem* fs) :
- max_active_edges_(1), fs_(fs) {}
-
- // CommandRunner impl
- bool CanRunMore() const override;
- bool StartCommand(Edge* edge) override;
- bool WaitForCommand(Result* result) override;
- vector<Edge*> GetActiveEdges() override;
- void Abort() override;
-
- vector<string> commands_ran_;
- vector<Edge*> active_edges_;
- size_t max_active_edges_;
- VirtualFileSystem* fs_;
-};
-
-struct BuildTest : public StateTestWithBuiltinRules, public BuildLogUser {
- BuildTest() : config_(MakeConfig()), command_runner_(&fs_), status_(config_),
- builder_(&state_, config_, NULL, NULL, &fs_, &status_, 0) {
- }
-
- explicit BuildTest(DepsLog* log)
- : config_(MakeConfig()), command_runner_(&fs_), status_(config_),
- builder_(&state_, config_, NULL, log, &fs_, &status_, 0) {}
-
- virtual void SetUp() {
- StateTestWithBuiltinRules::SetUp();
-
- builder_.command_runner_.reset(&command_runner_);
- AssertParse(&state_,
-"build cat1: cat in1\n"
-"build cat2: cat in1 in2\n"
-"build cat12: cat cat1 cat2\n");
-
- fs_.Create("in1", "");
- fs_.Create("in2", "");
- }
-
- ~BuildTest() {
- builder_.command_runner_.release();
- }
-
- virtual bool IsPathDead(StringPiece s) const { return false; }
-
- /// Rebuild target in the 'working tree' (fs_).
- /// State of command_runner_ and logs contents (if specified) ARE MODIFIED.
- /// Handy to check for NOOP builds, and higher-level rebuild tests.
- void RebuildTarget(const string& target, const char* manifest,
- const char* log_path = NULL, const char* deps_path = NULL,
- State* state = NULL);
-
- // Mark a path dirty.
- void Dirty(const string& path);
-
- BuildConfig MakeConfig() {
- BuildConfig config;
- config.verbosity = BuildConfig::QUIET;
- return config;
- }
-
- BuildConfig config_;
- FakeCommandRunner command_runner_;
- VirtualFileSystem fs_;
- StatusPrinter status_;
- Builder builder_;
-};
-
-void BuildTest::RebuildTarget(const string& target, const char* manifest,
- const char* log_path, const char* deps_path,
- State* state) {
- State local_state, *pstate = &local_state;
- if (state)
- pstate = state;
- ASSERT_NO_FATAL_FAILURE(AddCatRule(pstate));
- AssertParse(pstate, manifest);
-
- string err;
- BuildLog build_log, *pbuild_log = NULL;
- if (log_path) {
- ASSERT_TRUE(build_log.Load(log_path, &err));
- ASSERT_TRUE(build_log.OpenForWrite(log_path, *this, &err));
- ASSERT_EQ("", err);
- pbuild_log = &build_log;
- }
-
- DepsLog deps_log, *pdeps_log = NULL;
- if (deps_path) {
- ASSERT_TRUE(deps_log.Load(deps_path, pstate, &err));
- ASSERT_TRUE(deps_log.OpenForWrite(deps_path, &err));
- ASSERT_EQ("", err);
- pdeps_log = &deps_log;
- }
-
- Builder builder(pstate, config_, pbuild_log, pdeps_log, &fs_, &status_, 0);
- EXPECT_TRUE(builder.AddTarget(target, &err));
-
- command_runner_.commands_ran_.clear();
- builder.command_runner_.reset(&command_runner_);
- if (!builder.AlreadyUpToDate()) {
- bool build_res = builder.Build(&err);
- EXPECT_TRUE(build_res);
- }
- builder.command_runner_.release();
-}
-
-bool FakeCommandRunner::CanRunMore() const {
- return active_edges_.size() < max_active_edges_;
-}
-
-bool FakeCommandRunner::StartCommand(Edge* edge) {
- assert(active_edges_.size() < max_active_edges_);
- assert(find(active_edges_.begin(), active_edges_.end(), edge)
- == active_edges_.end());
- commands_ran_.push_back(edge->EvaluateCommand());
- if (edge->rule().name() == "cat" ||
- edge->rule().name() == "cat_rsp" ||
- edge->rule().name() == "cat_rsp_out" ||
- edge->rule().name() == "cc" ||
- edge->rule().name() == "cp_multi_msvc" ||
- edge->rule().name() == "cp_multi_gcc" ||
- edge->rule().name() == "touch" ||
- edge->rule().name() == "touch-interrupt" ||
- edge->rule().name() == "touch-fail-tick2") {
- for (vector<Node*>::iterator out = edge->outputs_.begin();
- out != edge->outputs_.end(); ++out) {
- fs_->Create((*out)->path(), "");
- }
- } else if (edge->rule().name() == "true" ||
- edge->rule().name() == "fail" ||
- edge->rule().name() == "interrupt" ||
- edge->rule().name() == "console") {
- // Don't do anything.
- } else if (edge->rule().name() == "cp") {
- assert(!edge->inputs_.empty());
- assert(edge->outputs_.size() == 1);
- string content;
- string err;
- if (fs_->ReadFile(edge->inputs_[0]->path(), &content, &err) ==
- DiskInterface::Okay)
- fs_->WriteFile(edge->outputs_[0]->path(), content);
- } else if (edge->rule().name() == "touch-implicit-dep-out") {
- string dep = edge->GetBinding("test_dependency");
- fs_->Tick();
- fs_->Create(dep, "");
- fs_->Tick();
- for (vector<Node*>::iterator out = edge->outputs_.begin();
- out != edge->outputs_.end(); ++out) {
- fs_->Create((*out)->path(), "");
- }
- } else if (edge->rule().name() == "touch-out-implicit-dep") {
- string dep = edge->GetBinding("test_dependency");
- for (vector<Node*>::iterator out = edge->outputs_.begin();
- out != edge->outputs_.end(); ++out) {
- fs_->Create((*out)->path(), "");
- }
- fs_->Tick();
- fs_->Create(dep, "");
- } else if (edge->rule().name() == "generate-depfile") {
- string dep = edge->GetBinding("test_dependency");
- bool touch_dep = edge->GetBindingBool("touch_dependency");
- string depfile = edge->GetUnescapedDepfile();
- if (touch_dep) {
- fs_->Tick();
- fs_->Create(dep, "");
- }
- string contents;
- for (vector<Node*>::iterator out = edge->outputs_.begin();
- out != edge->outputs_.end(); ++out) {
- contents += (*out)->path() + ": " + dep + "\n";
- fs_->Create((*out)->path(), "");
- }
- fs_->Create(depfile, contents);
- } else if (edge->rule().name() == "long-cc") {
- string dep = edge->GetBinding("test_dependency");
- string depfile = edge->GetUnescapedDepfile();
- string contents;
- for (vector<Node*>::iterator out = edge->outputs_.begin();
- out != edge->outputs_.end(); ++out) {
- fs_->Tick();
- fs_->Tick();
- fs_->Tick();
- fs_->Create((*out)->path(), "");
- contents += (*out)->path() + ": " + dep + "\n";
- }
- if (!dep.empty() && !depfile.empty())
- fs_->Create(depfile, contents);
- } else {
- printf("unknown command\n");
- return false;
- }
-
- active_edges_.push_back(edge);
-
- // Allow tests to control the order by the name of the first output.
- sort(active_edges_.begin(), active_edges_.end(),
- CompareEdgesByOutput::cmp);
-
- return true;
-}
-
-bool FakeCommandRunner::WaitForCommand(Result* result) {
- if (active_edges_.empty())
- return false;
-
- // All active edges were already completed immediately when started,
- // so we can pick any edge here. Pick the last edge. Tests can
- // control the order of edges by the name of the first output.
- vector<Edge*>::iterator edge_iter = active_edges_.end() - 1;
-
- Edge* edge = *edge_iter;
- result->edge = edge;
-
- if (edge->rule().name() == "interrupt" ||
- edge->rule().name() == "touch-interrupt") {
- result->status = ExitInterrupted;
- return true;
- }
-
- if (edge->rule().name() == "console") {
- if (edge->use_console())
- result->status = ExitSuccess;
- else
- result->status = ExitFailure;
- active_edges_.erase(edge_iter);
- return true;
- }
-
- if (edge->rule().name() == "cp_multi_msvc") {
- const std::string prefix = edge->GetBinding("msvc_deps_prefix");
- for (std::vector<Node*>::iterator in = edge->inputs_.begin();
- in != edge->inputs_.end(); ++in) {
- result->output += prefix + (*in)->path() + '\n';
- }
- }
-
- if (edge->rule().name() == "fail" ||
- (edge->rule().name() == "touch-fail-tick2" && fs_->now_ == 2))
- result->status = ExitFailure;
- else
- result->status = ExitSuccess;
-
- // This rule simulates an external process modifying files while the build command runs.
- // See TestInputMtimeRaceCondition and TestInputMtimeRaceConditionWithDepFile.
- // Note: only the first and third time the rule is run per test is the file modified, so
- // the test can verify that subsequent runs without the race have no work to do.
- if (edge->rule().name() == "long-cc") {
- string dep = edge->GetBinding("test_dependency");
- if (fs_->now_ == 4)
- fs_->files_[dep].mtime = 3;
- if (fs_->now_ == 10)
- fs_->files_[dep].mtime = 9;
- }
-
- // Provide a way for test cases to verify when an edge finishes that
- // some other edge is still active. This is useful for test cases
- // covering behavior involving multiple active edges.
- const string& verify_active_edge = edge->GetBinding("verify_active_edge");
- if (!verify_active_edge.empty()) {
- bool verify_active_edge_found = false;
- for (vector<Edge*>::iterator i = active_edges_.begin();
- i != active_edges_.end(); ++i) {
- if (!(*i)->outputs_.empty() &&
- (*i)->outputs_[0]->path() == verify_active_edge) {
- verify_active_edge_found = true;
- }
- }
- EXPECT_TRUE(verify_active_edge_found);
- }
-
- active_edges_.erase(edge_iter);
- return true;
-}
-
-vector<Edge*> FakeCommandRunner::GetActiveEdges() {
- return active_edges_;
-}
-
-void FakeCommandRunner::Abort() {
- active_edges_.clear();
-}
-
-void BuildTest::Dirty(const string& path) {
- Node* node = GetNode(path);
- node->MarkDirty();
-
- // If it's an input file, mark that we've already stat()ed it and
- // it's missing.
- if (!node->in_edge())
- node->MarkMissing();
-}
-
-TEST_F(BuildTest, NoWork) {
- string err;
- EXPECT_TRUE(builder_.AlreadyUpToDate());
-}
-
-TEST_F(BuildTest, OneStep) {
- // Given a dirty target with one ready input,
- // we should rebuild the target.
- Dirty("cat1");
- string err;
- EXPECT_TRUE(builder_.AddTarget("cat1", &err));
- ASSERT_EQ("", err);
- EXPECT_TRUE(builder_.Build(&err));
- ASSERT_EQ("", err);
-
- ASSERT_EQ(1u, command_runner_.commands_ran_.size());
- EXPECT_EQ("cat in1 > cat1", command_runner_.commands_ran_[0]);
-}
-
-TEST_F(BuildTest, OneStep2) {
- // Given a target with one dirty input,
- // we should rebuild the target.
- Dirty("cat1");
- string err;
- EXPECT_TRUE(builder_.AddTarget("cat1", &err));
- ASSERT_EQ("", err);
- EXPECT_TRUE(builder_.Build(&err));
- EXPECT_EQ("", err);
-
- ASSERT_EQ(1u, command_runner_.commands_ran_.size());
- EXPECT_EQ("cat in1 > cat1", command_runner_.commands_ran_[0]);
-}
-
-TEST_F(BuildTest, TwoStep) {
- string err;
- EXPECT_TRUE(builder_.AddTarget("cat12", &err));
- ASSERT_EQ("", err);
- EXPECT_TRUE(builder_.Build(&err));
- EXPECT_EQ("", err);
- ASSERT_EQ(3u, command_runner_.commands_ran_.size());
- // Depending on how the pointers work out, we could've ran
- // the first two commands in either order.
- EXPECT_TRUE((command_runner_.commands_ran_[0] == "cat in1 > cat1" &&
- command_runner_.commands_ran_[1] == "cat in1 in2 > cat2") ||
- (command_runner_.commands_ran_[1] == "cat in1 > cat1" &&
- command_runner_.commands_ran_[0] == "cat in1 in2 > cat2"));
-
- EXPECT_EQ("cat cat1 cat2 > cat12", command_runner_.commands_ran_[2]);
-
- fs_.Tick();
-
- // Modifying in2 requires rebuilding one intermediate file
- // and the final file.
- fs_.Create("in2", "");
- state_.Reset();
- EXPECT_TRUE(builder_.AddTarget("cat12", &err));
- ASSERT_EQ("", err);
- EXPECT_TRUE(builder_.Build(&err));
- ASSERT_EQ("", err);
- ASSERT_EQ(5u, command_runner_.commands_ran_.size());
- EXPECT_EQ("cat in1 in2 > cat2", command_runner_.commands_ran_[3]);
- EXPECT_EQ("cat cat1 cat2 > cat12", command_runner_.commands_ran_[4]);
-}
-
-TEST_F(BuildTest, TwoOutputs) {
- ASSERT_NO_FATAL_FAILURE(AssertParse(&state_,
-"rule touch\n"
-" command = touch $out\n"
-"build out1 out2: touch in.txt\n"));
-
- fs_.Create("in.txt", "");
-
- string err;
- EXPECT_TRUE(builder_.AddTarget("out1", &err));
- ASSERT_EQ("", err);
- EXPECT_TRUE(builder_.Build(&err));
- EXPECT_EQ("", err);
- ASSERT_EQ(1u, command_runner_.commands_ran_.size());
- EXPECT_EQ("touch out1 out2", command_runner_.commands_ran_[0]);
-}
-
-TEST_F(BuildTest, ImplicitOutput) {
- ASSERT_NO_FATAL_FAILURE(AssertParse(&state_,
-"rule touch\n"
-" command = touch $out $out.imp\n"
-"build out | out.imp: touch in.txt\n"));
- fs_.Create("in.txt", "");
-
- string err;
- EXPECT_TRUE(builder_.AddTarget("out.imp", &err));
- ASSERT_EQ("", err);
- EXPECT_TRUE(builder_.Build(&err));
- EXPECT_EQ("", err);
- ASSERT_EQ(1u, command_runner_.commands_ran_.size());
- EXPECT_EQ("touch out out.imp", command_runner_.commands_ran_[0]);
-}
-
-// Test case from
-// https://github.com/ninja-build/ninja/issues/148
-TEST_F(BuildTest, MultiOutIn) {
- ASSERT_NO_FATAL_FAILURE(AssertParse(&state_,
-"rule touch\n"
-" command = touch $out\n"
-"build in1 otherfile: touch in\n"
-"build out: touch in | in1\n"));
-
- fs_.Create("in", "");
- fs_.Tick();
- fs_.Create("in1", "");
-
- string err;
- EXPECT_TRUE(builder_.AddTarget("out", &err));
- ASSERT_EQ("", err);
- EXPECT_TRUE(builder_.Build(&err));
- EXPECT_EQ("", err);
-}
-
-TEST_F(BuildTest, Chain) {
- ASSERT_NO_FATAL_FAILURE(AssertParse(&state_,
-"build c2: cat c1\n"
-"build c3: cat c2\n"
-"build c4: cat c3\n"
-"build c5: cat c4\n"));
-
- fs_.Create("c1", "");
-
- string err;
- EXPECT_TRUE(builder_.AddTarget("c5", &err));
- ASSERT_EQ("", err);
- EXPECT_TRUE(builder_.Build(&err));
- EXPECT_EQ("", err);
- ASSERT_EQ(4u, command_runner_.commands_ran_.size());
-
- err.clear();
- command_runner_.commands_ran_.clear();
- state_.Reset();
- EXPECT_TRUE(builder_.AddTarget("c5", &err));
- ASSERT_EQ("", err);
- EXPECT_TRUE(builder_.AlreadyUpToDate());
-
- fs_.Tick();
-
- fs_.Create("c3", "");
- err.clear();
- command_runner_.commands_ran_.clear();
- state_.Reset();
- EXPECT_TRUE(builder_.AddTarget("c5", &err));
- ASSERT_EQ("", err);
- EXPECT_FALSE(builder_.AlreadyUpToDate());
- EXPECT_TRUE(builder_.Build(&err));
- ASSERT_EQ(2u, command_runner_.commands_ran_.size()); // 3->4, 4->5
-}
-
-TEST_F(BuildTest, MissingInput) {
- // Input is referenced by build file, but no rule for it.
- string err;
- Dirty("in1");
- EXPECT_FALSE(builder_.AddTarget("cat1", &err));
- EXPECT_EQ("'in1', needed by 'cat1', missing and no known rule to make it",
- err);
-}
-
-TEST_F(BuildTest, MissingTarget) {
- // Target is not referenced by build file.
- string err;
- EXPECT_FALSE(builder_.AddTarget("meow", &err));
- EXPECT_EQ("unknown target: 'meow'", err);
-}
-
-TEST_F(BuildTest, MissingInputTarget) {
- // Target is a missing input file
- string err;
- Dirty("in1");
- EXPECT_FALSE(builder_.AddTarget("in1", &err));
- EXPECT_EQ("'in1' missing and no known rule to make it", err);
-}
-
-TEST_F(BuildTest, MakeDirs) {
- string err;
-
-#ifdef _WIN32
- ASSERT_NO_FATAL_FAILURE(AssertParse(&state_,
- "build subdir\\dir2\\file: cat in1\n"));
-#else
- ASSERT_NO_FATAL_FAILURE(AssertParse(&state_,
- "build subdir/dir2/file: cat in1\n"));
-#endif
- EXPECT_TRUE(builder_.AddTarget("subdir/dir2/file", &err));
-
- EXPECT_EQ("", err);
- EXPECT_TRUE(builder_.Build(&err));
- ASSERT_EQ("", err);
- ASSERT_EQ(2u, fs_.directories_made_.size());
- EXPECT_EQ("subdir", fs_.directories_made_[0]);
- EXPECT_EQ("subdir/dir2", fs_.directories_made_[1]);
-}
-
-TEST_F(BuildTest, DepFileMissing) {
- string err;
- ASSERT_NO_FATAL_FAILURE(AssertParse(&state_,
-"rule cc\n command = cc $in\n depfile = $out.d\n"
-"build fo$ o.o: cc foo.c\n"));
- fs_.Create("foo.c", "");
-
- EXPECT_TRUE(builder_.AddTarget("fo o.o", &err));
- ASSERT_EQ("", err);
- ASSERT_EQ(1u, fs_.files_read_.size());
- EXPECT_EQ("fo o.o.d", fs_.files_read_[0]);
-}
-
-TEST_F(BuildTest, DepFileOK) {
- string err;
- int orig_edges = state_.edges_.size();
- ASSERT_NO_FATAL_FAILURE(AssertParse(&state_,
-"rule cc\n command = cc $in\n depfile = $out.d\n"
-"build foo.o: cc foo.c\n"));
- Edge* edge = state_.edges_.back();
-
- fs_.Create("foo.c", "");
- GetNode("bar.h")->MarkDirty(); // Mark bar.h as missing.
- fs_.Create("foo.o.d", "foo.o: blah.h bar.h\n");
- EXPECT_TRUE(builder_.AddTarget("foo.o", &err));
- ASSERT_EQ("", err);
- ASSERT_EQ(1u, fs_.files_read_.size());
- EXPECT_EQ("foo.o.d", fs_.files_read_[0]);
-
- // Expect one new edge generating foo.o. Loading the depfile should have
- // added nodes, but not phony edges to the graph.
- ASSERT_EQ(orig_edges + 1, (int)state_.edges_.size());
-
- // Verify that nodes for blah.h and bar.h were added and that they
- // are marked as generated by a dep loader.
- ASSERT_FALSE(state_.LookupNode("foo.o")->generated_by_dep_loader());
- ASSERT_FALSE(state_.LookupNode("foo.c")->generated_by_dep_loader());
- ASSERT_TRUE(state_.LookupNode("blah.h"));
- ASSERT_TRUE(state_.LookupNode("blah.h")->generated_by_dep_loader());
- ASSERT_TRUE(state_.LookupNode("bar.h"));
- ASSERT_TRUE(state_.LookupNode("bar.h")->generated_by_dep_loader());
-
- // Expect our edge to now have three inputs: foo.c and two headers.
- ASSERT_EQ(3u, edge->inputs_.size());
-
- // Expect the command line we generate to only use the original input.
- ASSERT_EQ("cc foo.c", edge->EvaluateCommand());
-}
-
-TEST_F(BuildTest, DepFileParseError) {
- string err;
- ASSERT_NO_FATAL_FAILURE(AssertParse(&state_,
-"rule cc\n command = cc $in\n depfile = $out.d\n"
-"build foo.o: cc foo.c\n"));
- fs_.Create("foo.c", "");
- fs_.Create("foo.o.d", "randomtext\n");
- EXPECT_FALSE(builder_.AddTarget("foo.o", &err));
- EXPECT_EQ("foo.o.d: expected ':' in depfile", err);
-}
-
-TEST_F(BuildTest, EncounterReadyTwice) {
- string err;
- ASSERT_NO_FATAL_FAILURE(AssertParse(&state_,
-"rule touch\n"
-" command = touch $out\n"
-"build c: touch\n"
-"build b: touch || c\n"
-"build a: touch | b || c\n"));
-
- vector<Edge*> c_out = GetNode("c")->out_edges();
- ASSERT_EQ(2u, c_out.size());
- EXPECT_EQ("b", c_out[0]->outputs_[0]->path());
- EXPECT_EQ("a", c_out[1]->outputs_[0]->path());
-
- fs_.Create("b", "");
- EXPECT_TRUE(builder_.AddTarget("a", &err));
- ASSERT_EQ("", err);
-
- EXPECT_TRUE(builder_.Build(&err));
- ASSERT_EQ("", err);
- ASSERT_EQ(2u, command_runner_.commands_ran_.size());
-}
-
-TEST_F(BuildTest, OrderOnlyDeps) {
- string err;
- ASSERT_NO_FATAL_FAILURE(AssertParse(&state_,
-"rule cc\n command = cc $in\n depfile = $out.d\n"
-"build foo.o: cc foo.c || otherfile\n"));
- Edge* edge = state_.edges_.back();
-
- fs_.Create("foo.c", "");
- fs_.Create("otherfile", "");
- fs_.Create("foo.o.d", "foo.o: blah.h bar.h\n");
- EXPECT_TRUE(builder_.AddTarget("foo.o", &err));
- ASSERT_EQ("", err);
-
- // One explicit, two implicit, one order only.
- ASSERT_EQ(4u, edge->inputs_.size());
- EXPECT_EQ(2, edge->implicit_deps_);
- EXPECT_EQ(1, edge->order_only_deps_);
- // Verify the inputs are in the order we expect
- // (explicit then implicit then orderonly).
- EXPECT_EQ("foo.c", edge->inputs_[0]->path());
- EXPECT_EQ("blah.h", edge->inputs_[1]->path());
- EXPECT_EQ("bar.h", edge->inputs_[2]->path());
- EXPECT_EQ("otherfile", edge->inputs_[3]->path());
-
- // Expect the command line we generate to only use the original input.
- ASSERT_EQ("cc foo.c", edge->EvaluateCommand());
-
- // explicit dep dirty, expect a rebuild.
- EXPECT_TRUE(builder_.Build(&err));
- ASSERT_EQ("", err);
- ASSERT_EQ(1u, command_runner_.commands_ran_.size());
-
- fs_.Tick();
-
- // Recreate the depfile, as it should have been deleted by the build.
- fs_.Create("foo.o.d", "foo.o: blah.h bar.h\n");
-
- // implicit dep dirty, expect a rebuild.
- fs_.Create("blah.h", "");
- fs_.Create("bar.h", "");
- command_runner_.commands_ran_.clear();
- state_.Reset();
- EXPECT_TRUE(builder_.AddTarget("foo.o", &err));
- EXPECT_TRUE(builder_.Build(&err));
- ASSERT_EQ("", err);
- ASSERT_EQ(1u, command_runner_.commands_ran_.size());
-
- fs_.Tick();
-
- // Recreate the depfile, as it should have been deleted by the build.
- fs_.Create("foo.o.d", "foo.o: blah.h bar.h\n");
-
- // order only dep dirty, no rebuild.
- fs_.Create("otherfile", "");
- command_runner_.commands_ran_.clear();
- state_.Reset();
- EXPECT_TRUE(builder_.AddTarget("foo.o", &err));
- EXPECT_EQ("", err);
- EXPECT_TRUE(builder_.AlreadyUpToDate());
-
- // implicit dep missing, expect rebuild.
- fs_.RemoveFile("bar.h");
- command_runner_.commands_ran_.clear();
- state_.Reset();
- EXPECT_TRUE(builder_.AddTarget("foo.o", &err));
- EXPECT_TRUE(builder_.Build(&err));
- ASSERT_EQ("", err);
- ASSERT_EQ(1u, command_runner_.commands_ran_.size());
-}
-
-TEST_F(BuildTest, RebuildOrderOnlyDeps) {
- string err;
- ASSERT_NO_FATAL_FAILURE(AssertParse(&state_,
-"rule cc\n command = cc $in\n"
-"rule true\n command = true\n"
-"build oo.h: cc oo.h.in\n"
-"build foo.o: cc foo.c || oo.h\n"));
-
- fs_.Create("foo.c", "");
- fs_.Create("oo.h.in", "");
-
- // foo.o and order-only dep dirty, build both.
- EXPECT_TRUE(builder_.AddTarget("foo.o", &err));
- EXPECT_TRUE(builder_.Build(&err));
- ASSERT_EQ("", err);
- ASSERT_EQ(2u, command_runner_.commands_ran_.size());
-
- // all clean, no rebuild.
- command_runner_.commands_ran_.clear();
- state_.Reset();
- EXPECT_TRUE(builder_.AddTarget("foo.o", &err));
- EXPECT_EQ("", err);
- EXPECT_TRUE(builder_.AlreadyUpToDate());
-
- // order-only dep missing, build it only.
- fs_.RemoveFile("oo.h");
- command_runner_.commands_ran_.clear();
- state_.Reset();
- EXPECT_TRUE(builder_.AddTarget("foo.o", &err));
- EXPECT_TRUE(builder_.Build(&err));
- ASSERT_EQ("", err);
- ASSERT_EQ(1u, command_runner_.commands_ran_.size());
- ASSERT_EQ("cc oo.h.in", command_runner_.commands_ran_[0]);
-
- fs_.Tick();
-
- // order-only dep dirty, build it only.
- fs_.Create("oo.h.in", "");
- command_runner_.commands_ran_.clear();
- state_.Reset();
- EXPECT_TRUE(builder_.AddTarget("foo.o", &err));
- EXPECT_TRUE(builder_.Build(&err));
- ASSERT_EQ("", err);
- ASSERT_EQ(1u, command_runner_.commands_ran_.size());
- ASSERT_EQ("cc oo.h.in", command_runner_.commands_ran_[0]);
-}
-
-#ifdef _WIN32
-TEST_F(BuildTest, DepFileCanonicalize) {
- string err;
- int orig_edges = state_.edges_.size();
- ASSERT_NO_FATAL_FAILURE(AssertParse(&state_,
-"rule cc\n command = cc $in\n depfile = $out.d\n"
-"build gen/stuff\\things/foo.o: cc x\\y/z\\foo.c\n"));
- Edge* edge = state_.edges_.back();
-
- fs_.Create("x/y/z/foo.c", "");
- GetNode("bar.h")->MarkDirty(); // Mark bar.h as missing.
- // Note, different slashes from manifest.
- fs_.Create("gen/stuff\\things/foo.o.d",
- "gen\\stuff\\things\\foo.o: blah.h bar.h\n");
- EXPECT_TRUE(builder_.AddTarget("gen/stuff/things/foo.o", &err));
- ASSERT_EQ("", err);
- ASSERT_EQ(1u, fs_.files_read_.size());
- // The depfile path does not get Canonicalize as it seems unnecessary.
- EXPECT_EQ("gen/stuff\\things/foo.o.d", fs_.files_read_[0]);
-
- // Expect one new edge generating foo.o
- ASSERT_EQ(orig_edges + 1, (int)state_.edges_.size());
- // Expect our edge to now have three inputs: foo.c and two headers.
- ASSERT_EQ(3u, edge->inputs_.size());
-
- // Expect the command line we generate to only use the original input, and
- // using the slashes from the manifest.
- ASSERT_EQ("cc x\\y/z\\foo.c", edge->EvaluateCommand());
-}
-#endif
-
-TEST_F(BuildTest, Phony) {
- string err;
- ASSERT_NO_FATAL_FAILURE(AssertParse(&state_,
-"build out: cat bar.cc\n"
-"build all: phony out\n"));
- fs_.Create("bar.cc", "");
-
- EXPECT_TRUE(builder_.AddTarget("all", &err));
- ASSERT_EQ("", err);
-
- // Only one command to run, because phony runs no command.
- EXPECT_FALSE(builder_.AlreadyUpToDate());
- EXPECT_TRUE(builder_.Build(&err));
- ASSERT_EQ("", err);
- ASSERT_EQ(1u, command_runner_.commands_ran_.size());
-}
-
-TEST_F(BuildTest, PhonyNoWork) {
- string err;
- ASSERT_NO_FATAL_FAILURE(AssertParse(&state_,
-"build out: cat bar.cc\n"
-"build all: phony out\n"));
- fs_.Create("bar.cc", "");
- fs_.Create("out", "");
-
- EXPECT_TRUE(builder_.AddTarget("all", &err));
- ASSERT_EQ("", err);
- EXPECT_TRUE(builder_.AlreadyUpToDate());
-}
-
-// Test a self-referencing phony. Ideally this should not work, but
-// ninja 1.7 and below tolerated and CMake 2.8.12.x and 3.0.x both
-// incorrectly produce it. We tolerate it for compatibility.
-TEST_F(BuildTest, PhonySelfReference) {
- string err;
- ASSERT_NO_FATAL_FAILURE(AssertParse(&state_,
-"build a: phony a\n"));
-
- EXPECT_TRUE(builder_.AddTarget("a", &err));
- ASSERT_EQ("", err);
- EXPECT_TRUE(builder_.AlreadyUpToDate());
-}
-
-// There are 6 different cases for phony rules:
-//
-// 1. output edge does not exist, inputs are not real
-// 2. output edge does not exist, no inputs
-// 3. output edge does not exist, inputs are real, newest mtime is M
-// 4. output edge is real, inputs are not real
-// 5. output edge is real, no inputs
-// 6. output edge is real, inputs are real, newest mtime is M
-//
-// Expected results :
-// 1. Edge is marked as clean, mtime is newest mtime of dependents.
-// Touching inputs will cause dependents to rebuild.
-// 2. Edge is marked as dirty, causing dependent edges to always rebuild
-// 3. Edge is marked as clean, mtime is newest mtime of dependents.
-// Touching inputs will cause dependents to rebuild.
-// 4. Edge is marked as clean, mtime is newest mtime of dependents.
-// Touching inputs will cause dependents to rebuild.
-// 5. Edge is marked as dirty, causing dependent edges to always rebuild
-// 6. Edge is marked as clean, mtime is newest mtime of dependents.
-// Touching inputs will cause dependents to rebuild.
-void TestPhonyUseCase(BuildTest* t, int i) {
- State& state_ = t->state_;
- Builder& builder_ = t->builder_;
- FakeCommandRunner& command_runner_ = t->command_runner_;
- VirtualFileSystem& fs_ = t->fs_;
-
- string err;
- ASSERT_NO_FATAL_FAILURE(AssertParse(&state_,
-"rule touch\n"
-" command = touch $out\n"
-"build notreal: phony blank\n"
-"build phony1: phony notreal\n"
-"build phony2: phony\n"
-"build phony3: phony blank\n"
-"build phony4: phony notreal\n"
-"build phony5: phony\n"
-"build phony6: phony blank\n"
-"\n"
-"build test1: touch phony1\n"
-"build test2: touch phony2\n"
-"build test3: touch phony3\n"
-"build test4: touch phony4\n"
-"build test5: touch phony5\n"
-"build test6: touch phony6\n"
-));
-
- // Set up test.
- builder_.command_runner_.release(); // BuildTest owns the CommandRunner
- builder_.command_runner_.reset(&command_runner_);
-
- fs_.Create("blank", ""); // a "real" file
- EXPECT_TRUE(builder_.AddTarget("test1", &err));
- ASSERT_EQ("", err);
- EXPECT_TRUE(builder_.AddTarget("test2", &err));
- ASSERT_EQ("", err);
- EXPECT_TRUE(builder_.AddTarget("test3", &err));
- ASSERT_EQ("", err);
- EXPECT_TRUE(builder_.AddTarget("test4", &err));
- ASSERT_EQ("", err);
- EXPECT_TRUE(builder_.AddTarget("test5", &err));
- ASSERT_EQ("", err);
- EXPECT_TRUE(builder_.AddTarget("test6", &err));
- ASSERT_EQ("", err);
- EXPECT_TRUE(builder_.Build(&err));
- ASSERT_EQ("", err);
-
- string ci;
- ci += static_cast<char>('0' + i);
-
- // Tests 1, 3, 4, and 6 should rebuild when the input is updated.
- if (i != 2 && i != 5) {
- Node* testNode = t->GetNode("test" + ci);
- Node* phonyNode = t->GetNode("phony" + ci);
- Node* inputNode = t->GetNode("blank");
-
- state_.Reset();
- TimeStamp startTime = fs_.now_;
-
- // Build number 1
- EXPECT_TRUE(builder_.AddTarget("test" + ci, &err));
- ASSERT_EQ("", err);
- if (!builder_.AlreadyUpToDate())
- EXPECT_TRUE(builder_.Build(&err));
- ASSERT_EQ("", err);
-
- // Touch the input file
- state_.Reset();
- command_runner_.commands_ran_.clear();
- fs_.Tick();
- fs_.Create("blank", ""); // a "real" file
- EXPECT_TRUE(builder_.AddTarget("test" + ci, &err));
- ASSERT_EQ("", err);
-
- // Second build, expect testN edge to be rebuilt
- // and phonyN node's mtime to be updated.
- EXPECT_FALSE(builder_.AlreadyUpToDate());
- EXPECT_TRUE(builder_.Build(&err));
- ASSERT_EQ("", err);
- ASSERT_EQ(1u, command_runner_.commands_ran_.size());
- EXPECT_EQ(string("touch test") + ci, command_runner_.commands_ran_[0]);
- EXPECT_TRUE(builder_.AlreadyUpToDate());
-
- TimeStamp inputTime = inputNode->mtime();
-
- EXPECT_FALSE(phonyNode->exists());
- EXPECT_FALSE(phonyNode->dirty());
-
- EXPECT_GT(phonyNode->mtime(), startTime);
- EXPECT_EQ(phonyNode->mtime(), inputTime);
- ASSERT_TRUE(testNode->Stat(&fs_, &err));
- EXPECT_TRUE(testNode->exists());
- EXPECT_GT(testNode->mtime(), startTime);
- } else {
- // Tests 2 and 5: Expect dependents to always rebuild.
-
- state_.Reset();
- command_runner_.commands_ran_.clear();
- fs_.Tick();
- command_runner_.commands_ran_.clear();
- EXPECT_TRUE(builder_.AddTarget("test" + ci, &err));
- ASSERT_EQ("", err);
- EXPECT_FALSE(builder_.AlreadyUpToDate());
- EXPECT_TRUE(builder_.Build(&err));
- ASSERT_EQ("", err);
- ASSERT_EQ(1u, command_runner_.commands_ran_.size());
- EXPECT_EQ("touch test" + ci, command_runner_.commands_ran_[0]);
-
- state_.Reset();
- command_runner_.commands_ran_.clear();
- EXPECT_TRUE(builder_.AddTarget("test" + ci, &err));
- ASSERT_EQ("", err);
- EXPECT_FALSE(builder_.AlreadyUpToDate());
- EXPECT_TRUE(builder_.Build(&err));
- ASSERT_EQ("", err);
- ASSERT_EQ(1u, command_runner_.commands_ran_.size());
- EXPECT_EQ("touch test" + ci, command_runner_.commands_ran_[0]);
- }
-}
-
-TEST_F(BuildTest, PhonyUseCase1) { TestPhonyUseCase(this, 1); }
-TEST_F(BuildTest, PhonyUseCase2) { TestPhonyUseCase(this, 2); }
-TEST_F(BuildTest, PhonyUseCase3) { TestPhonyUseCase(this, 3); }
-TEST_F(BuildTest, PhonyUseCase4) { TestPhonyUseCase(this, 4); }
-TEST_F(BuildTest, PhonyUseCase5) { TestPhonyUseCase(this, 5); }
-TEST_F(BuildTest, PhonyUseCase6) { TestPhonyUseCase(this, 6); }
-
-TEST_F(BuildTest, Fail) {
- ASSERT_NO_FATAL_FAILURE(AssertParse(&state_,
-"rule fail\n"
-" command = fail\n"
-"build out1: fail\n"));
-
- string err;
- EXPECT_TRUE(builder_.AddTarget("out1", &err));
- ASSERT_EQ("", err);
-
- EXPECT_FALSE(builder_.Build(&err));
- ASSERT_EQ(1u, command_runner_.commands_ran_.size());
- ASSERT_EQ("subcommand failed", err);
-}
-
-TEST_F(BuildTest, SwallowFailures) {
- ASSERT_NO_FATAL_FAILURE(AssertParse(&state_,
-"rule fail\n"
-" command = fail\n"
-"build out1: fail\n"
-"build out2: fail\n"
-"build out3: fail\n"
-"build all: phony out1 out2 out3\n"));
-
- // Swallow two failures, die on the third.
- config_.failures_allowed = 3;
-
- string err;
- EXPECT_TRUE(builder_.AddTarget("all", &err));
- ASSERT_EQ("", err);
-
- EXPECT_FALSE(builder_.Build(&err));
- ASSERT_EQ(3u, command_runner_.commands_ran_.size());
- ASSERT_EQ("subcommands failed", err);
-}
-
-TEST_F(BuildTest, SwallowFailuresLimit) {
- ASSERT_NO_FATAL_FAILURE(AssertParse(&state_,
-"rule fail\n"
-" command = fail\n"
-"build out1: fail\n"
-"build out2: fail\n"
-"build out3: fail\n"
-"build final: cat out1 out2 out3\n"));
-
- // Swallow ten failures; we should stop before building final.
- config_.failures_allowed = 11;
-
- string err;
- EXPECT_TRUE(builder_.AddTarget("final", &err));
- ASSERT_EQ("", err);
-
- EXPECT_FALSE(builder_.Build(&err));
- ASSERT_EQ(3u, command_runner_.commands_ran_.size());
- ASSERT_EQ("cannot make progress due to previous errors", err);
-}
-
-TEST_F(BuildTest, SwallowFailuresPool) {
- ASSERT_NO_FATAL_FAILURE(AssertParse(&state_,
-"pool failpool\n"
-" depth = 1\n"
-"rule fail\n"
-" command = fail\n"
-" pool = failpool\n"
-"build out1: fail\n"
-"build out2: fail\n"
-"build out3: fail\n"
-"build final: cat out1 out2 out3\n"));
-
- // Swallow ten failures; we should stop before building final.
- config_.failures_allowed = 11;
-
- string err;
- EXPECT_TRUE(builder_.AddTarget("final", &err));
- ASSERT_EQ("", err);
-
- EXPECT_FALSE(builder_.Build(&err));
- ASSERT_EQ(3u, command_runner_.commands_ran_.size());
- ASSERT_EQ("cannot make progress due to previous errors", err);
-}
-
-TEST_F(BuildTest, PoolEdgesReadyButNotWanted) {
- fs_.Create("x", "");
-
- const char* manifest =
- "pool some_pool\n"
- " depth = 4\n"
- "rule touch\n"
- " command = touch $out\n"
- " pool = some_pool\n"
- "rule cc\n"
- " command = touch grit\n"
- "\n"
- "build B.d.stamp: cc | x\n"
- "build C.stamp: touch B.d.stamp\n"
- "build final.stamp: touch || C.stamp\n";
-
- RebuildTarget("final.stamp", manifest);
-
- fs_.RemoveFile("B.d.stamp");
-
- State save_state;
- RebuildTarget("final.stamp", manifest, NULL, NULL, &save_state);
- EXPECT_GE(save_state.LookupPool("some_pool")->current_use(), 0);
-}
-
-struct BuildWithLogTest : public BuildTest {
- BuildWithLogTest() {
- builder_.SetBuildLog(&build_log_);
- }
-
- BuildLog build_log_;
-};
-
-TEST_F(BuildWithLogTest, ImplicitGeneratedOutOfDate) {
- ASSERT_NO_FATAL_FAILURE(AssertParse(&state_,
-"rule touch\n"
-" command = touch $out\n"
-" generator = 1\n"
-"build out.imp: touch | in\n"));
- fs_.Create("out.imp", "");
- fs_.Tick();
- fs_.Create("in", "");
-
- string err;
-
- EXPECT_TRUE(builder_.AddTarget("out.imp", &err));
- EXPECT_FALSE(builder_.AlreadyUpToDate());
-
- EXPECT_TRUE(GetNode("out.imp")->dirty());
-}
-
-TEST_F(BuildWithLogTest, ImplicitGeneratedOutOfDate2) {
- ASSERT_NO_FATAL_FAILURE(AssertParse(&state_,
-"rule touch-implicit-dep-out\n"
-" command = sleep 1 ; touch $test_dependency ; sleep 1 ; touch $out\n"
-" generator = 1\n"
-"build out.imp: touch-implicit-dep-out | inimp inimp2\n"
-" test_dependency = inimp\n"));
- fs_.Create("inimp", "");
- fs_.Create("out.imp", "");
- fs_.Tick();
- fs_.Create("inimp2", "");
- fs_.Tick();
-
- string err;
-
- EXPECT_TRUE(builder_.AddTarget("out.imp", &err));
- EXPECT_FALSE(builder_.AlreadyUpToDate());
-
- EXPECT_TRUE(builder_.Build(&err));
- EXPECT_TRUE(builder_.AlreadyUpToDate());
-
- command_runner_.commands_ran_.clear();
- state_.Reset();
- builder_.Cleanup();
- builder_.plan_.Reset();
-
- EXPECT_TRUE(builder_.AddTarget("out.imp", &err));
- EXPECT_TRUE(builder_.AlreadyUpToDate());
- EXPECT_FALSE(GetNode("out.imp")->dirty());
-
- command_runner_.commands_ran_.clear();
- state_.Reset();
- builder_.Cleanup();
- builder_.plan_.Reset();
-
- fs_.Tick();
- fs_.Create("inimp", "");
-
- EXPECT_TRUE(builder_.AddTarget("out.imp", &err));
- EXPECT_FALSE(builder_.AlreadyUpToDate());
-
- EXPECT_TRUE(builder_.Build(&err));
- EXPECT_TRUE(builder_.AlreadyUpToDate());
-
- command_runner_.commands_ran_.clear();
- state_.Reset();
- builder_.Cleanup();
- builder_.plan_.Reset();
-
- EXPECT_TRUE(builder_.AddTarget("out.imp", &err));
- EXPECT_TRUE(builder_.AlreadyUpToDate());
- EXPECT_FALSE(GetNode("out.imp")->dirty());
-}
-
-TEST_F(BuildWithLogTest, NotInLogButOnDisk) {
- ASSERT_NO_FATAL_FAILURE(AssertParse(&state_,
-"rule cc\n"
-" command = cc\n"
-"build out1: cc in\n"));
-
- // Create input/output that would be considered up to date when
- // not considering the command line hash.
- fs_.Create("in", "");
- fs_.Create("out1", "");
- string err;
-
- // Because it's not in the log, it should not be up-to-date until
- // we build again.
- EXPECT_TRUE(builder_.AddTarget("out1", &err));
- EXPECT_FALSE(builder_.AlreadyUpToDate());
-
- command_runner_.commands_ran_.clear();
- state_.Reset();
-
- EXPECT_TRUE(builder_.AddTarget("out1", &err));
- EXPECT_TRUE(builder_.Build(&err));
- EXPECT_TRUE(builder_.AlreadyUpToDate());
-}
-
-TEST_F(BuildWithLogTest, RebuildAfterFailure) {
- ASSERT_NO_FATAL_FAILURE(AssertParse(&state_,
-"rule touch-fail-tick2\n"
-" command = touch-fail-tick2\n"
-"build out1: touch-fail-tick2 in\n"));
-
- string err;
-
- fs_.Create("in", "");
-
- // Run once successfully to get out1 in the log
- EXPECT_TRUE(builder_.AddTarget("out1", &err));
- EXPECT_TRUE(builder_.Build(&err));
- EXPECT_EQ("", err);
- EXPECT_EQ(1u, command_runner_.commands_ran_.size());
-
- command_runner_.commands_ran_.clear();
- state_.Reset();
- builder_.Cleanup();
- builder_.plan_.Reset();
-
- fs_.Tick();
- fs_.Create("in", "");
-
- // Run again with a failure that updates the output file timestamp
- EXPECT_TRUE(builder_.AddTarget("out1", &err));
- EXPECT_FALSE(builder_.Build(&err));
- EXPECT_EQ("subcommand failed", err);
- EXPECT_EQ(1u, command_runner_.commands_ran_.size());
-
- command_runner_.commands_ran_.clear();
- state_.Reset();
- builder_.Cleanup();
- builder_.plan_.Reset();
-
- fs_.Tick();
-
- // Run again, should rerun even though the output file is up to date on disk
- EXPECT_TRUE(builder_.AddTarget("out1", &err));
- EXPECT_FALSE(builder_.AlreadyUpToDate());
- EXPECT_TRUE(builder_.Build(&err));
- EXPECT_EQ(1u, command_runner_.commands_ran_.size());
- EXPECT_EQ("", err);
-}
-
-TEST_F(BuildWithLogTest, RebuildWithNoInputs) {
- ASSERT_NO_FATAL_FAILURE(AssertParse(&state_,
-"rule touch\n"
-" command = touch\n"
-"build out1: touch\n"
-"build out2: touch in\n"));
-
- string err;
-
- fs_.Create("in", "");
-
- EXPECT_TRUE(builder_.AddTarget("out1", &err));
- EXPECT_TRUE(builder_.AddTarget("out2", &err));
- EXPECT_TRUE(builder_.Build(&err));
- EXPECT_EQ("", err);
- EXPECT_EQ(2u, command_runner_.commands_ran_.size());
-
- command_runner_.commands_ran_.clear();
- state_.Reset();
-
- fs_.Tick();
-
- fs_.Create("in", "");
-
- EXPECT_TRUE(builder_.AddTarget("out1", &err));
- EXPECT_TRUE(builder_.AddTarget("out2", &err));
- EXPECT_TRUE(builder_.Build(&err));
- EXPECT_EQ("", err);
- EXPECT_EQ(1u, command_runner_.commands_ran_.size());
-}
-
-TEST_F(BuildWithLogTest, RestatTest) {
- ASSERT_NO_FATAL_FAILURE(AssertParse(&state_,
-"rule true\n"
-" command = true\n"
-" restat = 1\n"
-"rule cc\n"
-" command = cc\n"
-" restat = 1\n"
-"build out1: cc in\n"
-"build out2: true out1\n"
-"build out3: cat out2\n"));
-
- fs_.Create("out1", "");
- fs_.Create("out2", "");
- fs_.Create("out3", "");
-
- fs_.Tick();
-
- fs_.Create("in", "");
-
- // Do a pre-build so that there's commands in the log for the outputs,
- // otherwise, the lack of an entry in the build log will cause out3 to rebuild
- // regardless of restat.
- string err;
- EXPECT_TRUE(builder_.AddTarget("out3", &err));
- ASSERT_EQ("", err);
- EXPECT_TRUE(builder_.Build(&err));
- ASSERT_EQ("", err);
- EXPECT_EQ(3u, command_runner_.commands_ran_.size());
- EXPECT_EQ(3u, builder_.plan_.command_edge_count());
- command_runner_.commands_ran_.clear();
- state_.Reset();
-
- fs_.Tick();
-
- fs_.Create("in", "");
- // "cc" touches out1, so we should build out2. But because "true" does not
- // touch out2, we should cancel the build of out3.
- EXPECT_TRUE(builder_.AddTarget("out3", &err));
- ASSERT_EQ("", err);
- EXPECT_TRUE(builder_.Build(&err));
- ASSERT_EQ(2u, command_runner_.commands_ran_.size());
-
- // If we run again, it should be a no-op, because the build log has recorded
- // that we've already built out2 with an input timestamp of 2 (from out1).
- command_runner_.commands_ran_.clear();
- state_.Reset();
- EXPECT_TRUE(builder_.AddTarget("out3", &err));
- ASSERT_EQ("", err);
- EXPECT_TRUE(builder_.AlreadyUpToDate());
-
- fs_.Tick();
-
- fs_.Create("in", "");
-
- // The build log entry should not, however, prevent us from rebuilding out2
- // if out1 changes.
- command_runner_.commands_ran_.clear();
- state_.Reset();
- EXPECT_TRUE(builder_.AddTarget("out3", &err));
- ASSERT_EQ("", err);
- EXPECT_TRUE(builder_.Build(&err));
- ASSERT_EQ(2u, command_runner_.commands_ran_.size());
-}
-
-TEST_F(BuildWithLogTest, RestatMissingFile) {
- // If a restat rule doesn't create its output, and the output didn't
- // exist before the rule was run, consider that behavior equivalent
- // to a rule that doesn't modify its existent output file.
-
- ASSERT_NO_FATAL_FAILURE(AssertParse(&state_,
-"rule true\n"
-" command = true\n"
-" restat = 1\n"
-"rule cc\n"
-" command = cc\n"
-"build out1: true in\n"
-"build out2: cc out1\n"));
-
- fs_.Create("in", "");
- fs_.Create("out2", "");
-
- // Do a pre-build so that there's commands in the log for the outputs,
- // otherwise, the lack of an entry in the build log will cause out2 to rebuild
- // regardless of restat.
- string err;
- EXPECT_TRUE(builder_.AddTarget("out2", &err));
- ASSERT_EQ("", err);
- EXPECT_TRUE(builder_.Build(&err));
- ASSERT_EQ("", err);
- command_runner_.commands_ran_.clear();
- state_.Reset();
-
- fs_.Tick();
- fs_.Create("in", "");
- fs_.Create("out2", "");
-
- // Run a build, expect only the first command to run.
- // It doesn't touch its output (due to being the "true" command), so
- // we shouldn't run the dependent build.
- EXPECT_TRUE(builder_.AddTarget("out2", &err));
- ASSERT_EQ("", err);
- EXPECT_TRUE(builder_.Build(&err));
- ASSERT_EQ(1u, command_runner_.commands_ran_.size());
-}
-
-TEST_F(BuildWithLogTest, RestatSingleDependentOutputDirty) {
- ASSERT_NO_FATAL_FAILURE(AssertParse(&state_,
- "rule true\n"
- " command = true\n"
- " restat = 1\n"
- "rule touch\n"
- " command = touch\n"
- "build out1: true in\n"
- "build out2 out3: touch out1\n"
- "build out4: touch out2\n"
- ));
-
- // Create the necessary files
- fs_.Create("in", "");
-
- string err;
- EXPECT_TRUE(builder_.AddTarget("out4", &err));
- ASSERT_EQ("", err);
- EXPECT_TRUE(builder_.Build(&err));
- ASSERT_EQ("", err);
- ASSERT_EQ(3u, command_runner_.commands_ran_.size());
-
- fs_.Tick();
- fs_.Create("in", "");
- fs_.RemoveFile("out3");
-
- // Since "in" is missing, out1 will be built. Since "out3" is missing,
- // out2 and out3 will be built even though "in" is not touched when built.
- // Then, since out2 is rebuilt, out4 should be rebuilt -- the restat on the
- // "true" rule should not lead to the "touch" edge writing out2 and out3 being
- // cleard.
- command_runner_.commands_ran_.clear();
- state_.Reset();
- EXPECT_TRUE(builder_.AddTarget("out4", &err));
- ASSERT_EQ("", err);
- EXPECT_TRUE(builder_.Build(&err));
- ASSERT_EQ("", err);
- ASSERT_EQ(3u, command_runner_.commands_ran_.size());
-}
-
-// Test scenario, in which an input file is removed, but output isn't changed
-// https://github.com/ninja-build/ninja/issues/295
-TEST_F(BuildWithLogTest, RestatMissingInput) {
- ASSERT_NO_FATAL_FAILURE(AssertParse(&state_,
- "rule true\n"
- " command = true\n"
- " depfile = $out.d\n"
- " restat = 1\n"
- "rule cc\n"
- " command = cc\n"
- "build out1: true in\n"
- "build out2: cc out1\n"));
-
- // Create all necessary files
- fs_.Create("in", "");
-
- // The implicit dependencies and the depfile itself
- // are newer than the output
- TimeStamp restat_mtime = fs_.Tick();
- fs_.Create("out1.d", "out1: will.be.deleted restat.file\n");
- fs_.Create("will.be.deleted", "");
- fs_.Create("restat.file", "");
-
- // Run the build, out1 and out2 get built
- string err;
- EXPECT_TRUE(builder_.AddTarget("out2", &err));
- ASSERT_EQ("", err);
- EXPECT_TRUE(builder_.Build(&err));
- ASSERT_EQ(2u, command_runner_.commands_ran_.size());
-
- // See that an entry in the logfile is created, capturing
- // the right mtime
- BuildLog::LogEntry* log_entry = build_log_.LookupByOutput("out1");
- ASSERT_TRUE(NULL != log_entry);
- ASSERT_EQ(restat_mtime, log_entry->mtime);
-
- // Now remove a file, referenced from depfile, so that target becomes
- // dirty, but the output does not change
- fs_.RemoveFile("will.be.deleted");
-
- // Trigger the build again - only out1 gets built
- command_runner_.commands_ran_.clear();
- state_.Reset();
- EXPECT_TRUE(builder_.AddTarget("out2", &err));
- ASSERT_EQ("", err);
- EXPECT_TRUE(builder_.Build(&err));
- ASSERT_EQ(1u, command_runner_.commands_ran_.size());
-
- // Check that the logfile entry remains correctly set
- log_entry = build_log_.LookupByOutput("out1");
- ASSERT_TRUE(NULL != log_entry);
- ASSERT_EQ(restat_mtime, log_entry->mtime);
-}
-
-TEST_F(BuildWithLogTest, RestatInputChangesDueToRule) {
- ASSERT_NO_FATAL_FAILURE(AssertParse(&state_,
-"rule generate-depfile\n"
-" command = sleep 1 ; touch $touch_dependency; touch $out ; echo \"$out: $test_dependency\" > $depfile\n"
-"build out1: generate-depfile || cat1\n"
-" test_dependency = in2\n"
-" touch_dependency = 1\n"
-" restat = 1\n"
-" depfile = out.d\n"));
-
- // Perform the first build. out1 is a restat rule, so its recorded mtime in the build
- // log should be the time the command completes, not the time the command started. One
- // of out1's discovered dependencies will have a newer mtime than when out1 started
- // running, due to its command touching the dependency itself.
- string err;
- EXPECT_TRUE(builder_.AddTarget("out1", &err));
- ASSERT_EQ("", err);
- EXPECT_TRUE(builder_.Build(&err));
- ASSERT_EQ("", err);
- EXPECT_EQ(2u, command_runner_.commands_ran_.size());
- EXPECT_EQ(2u, builder_.plan_.command_edge_count());
- BuildLog::LogEntry* log_entry = build_log_.LookupByOutput("out1");
- ASSERT_TRUE(NULL != log_entry);
- ASSERT_EQ(2u, log_entry->mtime);
-
- command_runner_.commands_ran_.clear();
- state_.Reset();
- builder_.Cleanup();
- builder_.plan_.Reset();
-
- fs_.Tick();
- fs_.Create("in1", "");
-
- // Touching a dependency of an order-only dependency of out1 should not cause out1 to
- // rebuild. If out1 were not a restat rule, then it would rebuild here because its
- // recorded mtime would have been an earlier mtime than its most recent input's (in2)
- // mtime
- EXPECT_TRUE(builder_.AddTarget("out1", &err));
- ASSERT_EQ("", err);
- EXPECT_TRUE(!state_.GetNode("out1", 0)->dirty());
- EXPECT_TRUE(builder_.Build(&err));
- ASSERT_EQ("", err);
- EXPECT_EQ(1u, command_runner_.commands_ran_.size());
- EXPECT_EQ(1u, builder_.plan_.command_edge_count());
-}
-
-TEST_F(BuildWithLogTest, GeneratedPlainDepfileMtime) {
- ASSERT_NO_FATAL_FAILURE(AssertParse(&state_,
-"rule generate-depfile\n"
-" command = touch $out ; echo \"$out: $test_dependency\" > $depfile\n"
-"build out: generate-depfile\n"
-" test_dependency = inimp\n"
-" depfile = out.d\n"));
- fs_.Create("inimp", "");
- fs_.Tick();
-
- string err;
-
- EXPECT_TRUE(builder_.AddTarget("out", &err));
- EXPECT_FALSE(builder_.AlreadyUpToDate());
-
- EXPECT_TRUE(builder_.Build(&err));
- EXPECT_TRUE(builder_.AlreadyUpToDate());
-
- command_runner_.commands_ran_.clear();
- state_.Reset();
- builder_.Cleanup();
- builder_.plan_.Reset();
-
- EXPECT_TRUE(builder_.AddTarget("out", &err));
- EXPECT_TRUE(builder_.AlreadyUpToDate());
-}
-
-struct BuildDryRun : public BuildWithLogTest {
- BuildDryRun() {
- config_.dry_run = true;
- }
-};
-
-TEST_F(BuildDryRun, AllCommandsShown) {
- ASSERT_NO_FATAL_FAILURE(AssertParse(&state_,
-"rule true\n"
-" command = true\n"
-" restat = 1\n"
-"rule cc\n"
-" command = cc\n"
-" restat = 1\n"
-"build out1: cc in\n"
-"build out2: true out1\n"
-"build out3: cat out2\n"));
-
- fs_.Create("out1", "");
- fs_.Create("out2", "");
- fs_.Create("out3", "");
-
- fs_.Tick();
-
- fs_.Create("in", "");
-
- // "cc" touches out1, so we should build out2. But because "true" does not
- // touch out2, we should cancel the build of out3.
- string err;
- EXPECT_TRUE(builder_.AddTarget("out3", &err));
- ASSERT_EQ("", err);
- EXPECT_TRUE(builder_.Build(&err));
- ASSERT_EQ(3u, command_runner_.commands_ran_.size());
-}
-
-// Test that RSP files are created when & where appropriate and deleted after
-// successful execution.
-TEST_F(BuildTest, RspFileSuccess)
-{
- ASSERT_NO_FATAL_FAILURE(AssertParse(&state_,
- "rule cat_rsp\n"
- " command = cat $rspfile > $out\n"
- " rspfile = $rspfile\n"
- " rspfile_content = $long_command\n"
- "rule cat_rsp_out\n"
- " command = cat $rspfile > $out\n"
- " rspfile = $out.rsp\n"
- " rspfile_content = $long_command\n"
- "build out1: cat in\n"
- "build out2: cat_rsp in\n"
- " rspfile = out 2.rsp\n"
- " long_command = Some very long command\n"
- "build out$ 3: cat_rsp_out in\n"
- " long_command = Some very long command\n"));
-
- fs_.Create("out1", "");
- fs_.Create("out2", "");
- fs_.Create("out 3", "");
-
- fs_.Tick();
-
- fs_.Create("in", "");
-
- string err;
- EXPECT_TRUE(builder_.AddTarget("out1", &err));
- ASSERT_EQ("", err);
- EXPECT_TRUE(builder_.AddTarget("out2", &err));
- ASSERT_EQ("", err);
- EXPECT_TRUE(builder_.AddTarget("out 3", &err));
- ASSERT_EQ("", err);
-
- size_t files_created = fs_.files_created_.size();
- size_t files_removed = fs_.files_removed_.size();
-
- EXPECT_TRUE(builder_.Build(&err));
- ASSERT_EQ(3u, command_runner_.commands_ran_.size());
-
- // The RSP files and temp file to acquire output mtimes were created
- ASSERT_EQ(files_created + 3, fs_.files_created_.size());
- ASSERT_EQ(1u, fs_.files_created_.count("out 2.rsp"));
- ASSERT_EQ(1u, fs_.files_created_.count("out 3.rsp"));
- ASSERT_EQ(1u, fs_.files_created_.count(".ninja_lock"));
-
- // The RSP files were removed
- ASSERT_EQ(files_removed + 2, fs_.files_removed_.size());
- ASSERT_EQ(1u, fs_.files_removed_.count("out 2.rsp"));
- ASSERT_EQ(1u, fs_.files_removed_.count("out 3.rsp"));
-}
-
-// Test that RSP file is created but not removed for commands, which fail
-TEST_F(BuildTest, RspFileFailure) {
- ASSERT_NO_FATAL_FAILURE(AssertParse(&state_,
- "rule fail\n"
- " command = fail\n"
- " rspfile = $rspfile\n"
- " rspfile_content = $long_command\n"
- "build out: fail in\n"
- " rspfile = out.rsp\n"
- " long_command = Another very long command\n"));
-
- fs_.Create("out", "");
- fs_.Tick();
- fs_.Create("in", "");
-
- string err;
- EXPECT_TRUE(builder_.AddTarget("out", &err));
- ASSERT_EQ("", err);
-
- size_t files_created = fs_.files_created_.size();
- size_t files_removed = fs_.files_removed_.size();
-
- EXPECT_FALSE(builder_.Build(&err));
- ASSERT_EQ("subcommand failed", err);
- ASSERT_EQ(1u, command_runner_.commands_ran_.size());
-
- // The RSP file and temp file to acquire output mtimes were created
- ASSERT_EQ(files_created + 2, fs_.files_created_.size());
- ASSERT_EQ(1u, fs_.files_created_.count("out.rsp"));
- ASSERT_EQ(1u, fs_.files_created_.count(".ninja_lock"));
-
- // The RSP file was NOT removed
- ASSERT_EQ(files_removed, fs_.files_removed_.size());
- ASSERT_EQ(0u, fs_.files_removed_.count("out.rsp"));
-
- // The RSP file contains what it should
- ASSERT_EQ("Another very long command", fs_.files_["out.rsp"].contents);
-}
-
-// Test that contents of the RSP file behaves like a regular part of
-// command line, i.e. triggers a rebuild if changed
-TEST_F(BuildWithLogTest, RspFileCmdLineChange) {
- ASSERT_NO_FATAL_FAILURE(AssertParse(&state_,
- "rule cat_rsp\n"
- " command = cat $rspfile > $out\n"
- " rspfile = $rspfile\n"
- " rspfile_content = $long_command\n"
- "build out: cat_rsp in\n"
- " rspfile = out.rsp\n"
- " long_command = Original very long command\n"));
-
- fs_.Create("out", "");
- fs_.Tick();
- fs_.Create("in", "");
-
- string err;
- EXPECT_TRUE(builder_.AddTarget("out", &err));
- ASSERT_EQ("", err);
-
- // 1. Build for the 1st time (-> populate log)
- EXPECT_TRUE(builder_.Build(&err));
- ASSERT_EQ(1u, command_runner_.commands_ran_.size());
-
- // 2. Build again (no change)
- command_runner_.commands_ran_.clear();
- state_.Reset();
- EXPECT_TRUE(builder_.AddTarget("out", &err));
- EXPECT_EQ("", err);
- ASSERT_TRUE(builder_.AlreadyUpToDate());
-
- // 3. Alter the entry in the logfile
- // (to simulate a change in the command line between 2 builds)
- BuildLog::LogEntry* log_entry = build_log_.LookupByOutput("out");
- ASSERT_TRUE(NULL != log_entry);
- ASSERT_NO_FATAL_FAILURE(AssertHash(
- "cat out.rsp > out;rspfile=Original very long command",
- log_entry->command_hash));
- log_entry->command_hash++; // Change the command hash to something else.
- // Now expect the target to be rebuilt
- command_runner_.commands_ran_.clear();
- state_.Reset();
- EXPECT_TRUE(builder_.AddTarget("out", &err));
- EXPECT_EQ("", err);
- EXPECT_TRUE(builder_.Build(&err));
- EXPECT_EQ(1u, command_runner_.commands_ran_.size());
-}
-
-TEST_F(BuildTest, InterruptCleanup) {
- ASSERT_NO_FATAL_FAILURE(AssertParse(&state_,
-"rule interrupt\n"
-" command = interrupt\n"
-"rule touch-interrupt\n"
-" command = touch-interrupt\n"
-"build out1: interrupt in1\n"
-"build out2: touch-interrupt in2\n"));
-
- fs_.Create("out1", "");
- fs_.Create("out2", "");
- fs_.Tick();
- fs_.Create("in1", "");
- fs_.Create("in2", "");
-
- // An untouched output of an interrupted command should be retained.
- string err;
- EXPECT_TRUE(builder_.AddTarget("out1", &err));
- EXPECT_EQ("", err);
- EXPECT_FALSE(builder_.Build(&err));
- EXPECT_EQ("interrupted by user", err);
- builder_.Cleanup();
- EXPECT_GT(fs_.Stat("out1", &err), 0);
- err = "";
-
- // A touched output of an interrupted command should be deleted.
- EXPECT_TRUE(builder_.AddTarget("out2", &err));
- EXPECT_EQ("", err);
- EXPECT_FALSE(builder_.Build(&err));
- EXPECT_EQ("interrupted by user", err);
- builder_.Cleanup();
- EXPECT_EQ(0, fs_.Stat("out2", &err));
-}
-
-TEST_F(BuildTest, StatFailureAbortsBuild) {
- const string kTooLongToStat(400, 'i');
- ASSERT_NO_FATAL_FAILURE(AssertParse(&state_,
-("build " + kTooLongToStat + ": cat in\n").c_str()));
- fs_.Create("in", "");
-
- // This simulates a stat failure:
- fs_.files_[kTooLongToStat].mtime = -1;
- fs_.files_[kTooLongToStat].stat_error = "stat failed";
-
- string err;
- EXPECT_FALSE(builder_.AddTarget(kTooLongToStat, &err));
- EXPECT_EQ("stat failed", err);
-}
-
-TEST_F(BuildTest, PhonyWithNoInputs) {
- ASSERT_NO_FATAL_FAILURE(AssertParse(&state_,
-"build nonexistent: phony\n"
-"build out1: cat || nonexistent\n"
-"build out2: cat nonexistent\n"));
- fs_.Create("out1", "");
- fs_.Create("out2", "");
-
- // out1 should be up to date even though its input is dirty, because its
- // order-only dependency has nothing to do.
- string err;
- EXPECT_TRUE(builder_.AddTarget("out1", &err));
- ASSERT_EQ("", err);
- EXPECT_TRUE(builder_.AlreadyUpToDate());
-
- // out2 should still be out of date though, because its input is dirty.
- err.clear();
- command_runner_.commands_ran_.clear();
- state_.Reset();
- EXPECT_TRUE(builder_.AddTarget("out2", &err));
- ASSERT_EQ("", err);
- EXPECT_TRUE(builder_.Build(&err));
- EXPECT_EQ("", err);
- ASSERT_EQ(1u, command_runner_.commands_ran_.size());
-}
-
-TEST_F(BuildTest, DepsGccWithEmptyDepfileErrorsOut) {
- ASSERT_NO_FATAL_FAILURE(AssertParse(&state_,
-"rule cc\n"
-" command = cc\n"
-" deps = gcc\n"
-"build out: cc\n"));
- Dirty("out");
-
- string err;
- EXPECT_TRUE(builder_.AddTarget("out", &err));
- ASSERT_EQ("", err);
- EXPECT_FALSE(builder_.AlreadyUpToDate());
-
- EXPECT_FALSE(builder_.Build(&err));
- ASSERT_EQ("subcommand failed", err);
- ASSERT_EQ(1u, command_runner_.commands_ran_.size());
-}
-
-TEST_F(BuildTest, StatusFormatElapsed) {
- status_.BuildStarted();
- // Before any task is done, the elapsed time must be zero.
- EXPECT_EQ("[%/e0.000]",
- status_.FormatProgressStatus("[%%/e%e]", 0));
-}
-
-TEST_F(BuildTest, StatusFormatReplacePlaceholder) {
- EXPECT_EQ("[%/s0/t0/r0/u0/f0]",
- status_.FormatProgressStatus("[%%/s%s/t%t/r%r/u%u/f%f]", 0));
-}
-
-TEST_F(BuildTest, FailedDepsParse) {
- ASSERT_NO_FATAL_FAILURE(AssertParse(&state_,
-"build bad_deps.o: cat in1\n"
-" deps = gcc\n"
-" depfile = in1.d\n"));
-
- string err;
- EXPECT_TRUE(builder_.AddTarget("bad_deps.o", &err));
- ASSERT_EQ("", err);
-
- // These deps will fail to parse, as they should only have one
- // path to the left of the colon.
- fs_.Create("in1.d", "AAA BBB");
-
- EXPECT_FALSE(builder_.Build(&err));
- EXPECT_EQ("subcommand failed", err);
-}
-
-struct BuildWithQueryDepsLogTest : public BuildTest {
- BuildWithQueryDepsLogTest() : BuildTest(&log_) {
- }
-
- ~BuildWithQueryDepsLogTest() {
- log_.Close();
- }
-
- virtual void SetUp() {
- BuildTest::SetUp();
-
- temp_dir_.CreateAndEnter("BuildWithQueryDepsLogTest");
-
- std::string err;
- ASSERT_TRUE(log_.OpenForWrite("ninja_deps", &err));
- ASSERT_EQ("", err);
- }
-
- ScopedTempDir temp_dir_;
-
- DepsLog log_;
-};
-
-/// Test a MSVC-style deps log with multiple outputs.
-TEST_F(BuildWithQueryDepsLogTest, TwoOutputsDepFileMSVC) {
- ASSERT_NO_FATAL_FAILURE(AssertParse(&state_,
-"rule cp_multi_msvc\n"
-" command = echo 'using $in' && for file in $out; do cp $in $$file; done\n"
-" deps = msvc\n"
-" msvc_deps_prefix = using \n"
-"build out1 out2: cp_multi_msvc in1\n"));
-
- std::string err;
- EXPECT_TRUE(builder_.AddTarget("out1", &err));
- ASSERT_EQ("", err);
- EXPECT_TRUE(builder_.Build(&err));
- EXPECT_EQ("", err);
- ASSERT_EQ(1u, command_runner_.commands_ran_.size());
- EXPECT_EQ("echo 'using in1' && for file in out1 out2; do cp in1 $file; done", command_runner_.commands_ran_[0]);
-
- Node* out1_node = state_.LookupNode("out1");
- DepsLog::Deps* out1_deps = log_.GetDeps(out1_node);
- EXPECT_EQ(1, out1_deps->node_count);
- EXPECT_EQ("in1", out1_deps->nodes[0]->path());
-
- Node* out2_node = state_.LookupNode("out2");
- DepsLog::Deps* out2_deps = log_.GetDeps(out2_node);
- EXPECT_EQ(1, out2_deps->node_count);
- EXPECT_EQ("in1", out2_deps->nodes[0]->path());
-}
-
-/// Test a GCC-style deps log with multiple outputs.
-TEST_F(BuildWithQueryDepsLogTest, TwoOutputsDepFileGCCOneLine) {
- ASSERT_NO_FATAL_FAILURE(AssertParse(&state_,
-"rule cp_multi_gcc\n"
-" command = echo '$out: $in' > in.d && for file in $out; do cp in1 $$file; done\n"
-" deps = gcc\n"
-" depfile = in.d\n"
-"build out1 out2: cp_multi_gcc in1 in2\n"));
-
- std::string err;
- EXPECT_TRUE(builder_.AddTarget("out1", &err));
- ASSERT_EQ("", err);
- fs_.Create("in.d", "out1 out2: in1 in2");
- EXPECT_TRUE(builder_.Build(&err));
- EXPECT_EQ("", err);
- ASSERT_EQ(1u, command_runner_.commands_ran_.size());
- EXPECT_EQ("echo 'out1 out2: in1 in2' > in.d && for file in out1 out2; do cp in1 $file; done", command_runner_.commands_ran_[0]);
-
- Node* out1_node = state_.LookupNode("out1");
- DepsLog::Deps* out1_deps = log_.GetDeps(out1_node);
- EXPECT_EQ(2, out1_deps->node_count);
- EXPECT_EQ("in1", out1_deps->nodes[0]->path());
- EXPECT_EQ("in2", out1_deps->nodes[1]->path());
-
- Node* out2_node = state_.LookupNode("out2");
- DepsLog::Deps* out2_deps = log_.GetDeps(out2_node);
- EXPECT_EQ(2, out2_deps->node_count);
- EXPECT_EQ("in1", out2_deps->nodes[0]->path());
- EXPECT_EQ("in2", out2_deps->nodes[1]->path());
-}
-
-/// Test a GCC-style deps log with multiple outputs using a line per input.
-TEST_F(BuildWithQueryDepsLogTest, TwoOutputsDepFileGCCMultiLineInput) {
- ASSERT_NO_FATAL_FAILURE(AssertParse(&state_,
-"rule cp_multi_gcc\n"
-" command = echo '$out: in1\\n$out: in2' > in.d && for file in $out; do cp in1 $$file; done\n"
-" deps = gcc\n"
-" depfile = in.d\n"
-"build out1 out2: cp_multi_gcc in1 in2\n"));
-
- std::string err;
- EXPECT_TRUE(builder_.AddTarget("out1", &err));
- ASSERT_EQ("", err);
- fs_.Create("in.d", "out1 out2: in1\nout1 out2: in2");
- EXPECT_TRUE(builder_.Build(&err));
- EXPECT_EQ("", err);
- ASSERT_EQ(1u, command_runner_.commands_ran_.size());
- EXPECT_EQ("echo 'out1 out2: in1\\nout1 out2: in2' > in.d && for file in out1 out2; do cp in1 $file; done", command_runner_.commands_ran_[0]);
-
- Node* out1_node = state_.LookupNode("out1");
- DepsLog::Deps* out1_deps = log_.GetDeps(out1_node);
- EXPECT_EQ(2, out1_deps->node_count);
- EXPECT_EQ("in1", out1_deps->nodes[0]->path());
- EXPECT_EQ("in2", out1_deps->nodes[1]->path());
-
- Node* out2_node = state_.LookupNode("out2");
- DepsLog::Deps* out2_deps = log_.GetDeps(out2_node);
- EXPECT_EQ(2, out2_deps->node_count);
- EXPECT_EQ("in1", out2_deps->nodes[0]->path());
- EXPECT_EQ("in2", out2_deps->nodes[1]->path());
-}
-
-/// Test a GCC-style deps log with multiple outputs using a line per output.
-TEST_F(BuildWithQueryDepsLogTest, TwoOutputsDepFileGCCMultiLineOutput) {
- ASSERT_NO_FATAL_FAILURE(AssertParse(&state_,
-"rule cp_multi_gcc\n"
-" command = echo 'out1: $in\\nout2: $in' > in.d && for file in $out; do cp in1 $$file; done\n"
-" deps = gcc\n"
-" depfile = in.d\n"
-"build out1 out2: cp_multi_gcc in1 in2\n"));
-
- std::string err;
- EXPECT_TRUE(builder_.AddTarget("out1", &err));
- ASSERT_EQ("", err);
- fs_.Create("in.d", "out1: in1 in2\nout2: in1 in2");
- EXPECT_TRUE(builder_.Build(&err));
- EXPECT_EQ("", err);
- ASSERT_EQ(1u, command_runner_.commands_ran_.size());
- EXPECT_EQ("echo 'out1: in1 in2\\nout2: in1 in2' > in.d && for file in out1 out2; do cp in1 $file; done", command_runner_.commands_ran_[0]);
-
- Node* out1_node = state_.LookupNode("out1");
- DepsLog::Deps* out1_deps = log_.GetDeps(out1_node);
- EXPECT_EQ(2, out1_deps->node_count);
- EXPECT_EQ("in1", out1_deps->nodes[0]->path());
- EXPECT_EQ("in2", out1_deps->nodes[1]->path());
-
- Node* out2_node = state_.LookupNode("out2");
- DepsLog::Deps* out2_deps = log_.GetDeps(out2_node);
- EXPECT_EQ(2, out2_deps->node_count);
- EXPECT_EQ("in1", out2_deps->nodes[0]->path());
- EXPECT_EQ("in2", out2_deps->nodes[1]->path());
-}
-
-/// Test a GCC-style deps log with multiple outputs mentioning only the main output.
-TEST_F(BuildWithQueryDepsLogTest, TwoOutputsDepFileGCCOnlyMainOutput) {
- ASSERT_NO_FATAL_FAILURE(AssertParse(&state_,
-"rule cp_multi_gcc\n"
-" command = echo 'out1: $in' > in.d && for file in $out; do cp in1 $$file; done\n"
-" deps = gcc\n"
-" depfile = in.d\n"
-"build out1 out2: cp_multi_gcc in1 in2\n"));
-
- std::string err;
- EXPECT_TRUE(builder_.AddTarget("out1", &err));
- ASSERT_EQ("", err);
- fs_.Create("in.d", "out1: in1 in2");
- EXPECT_TRUE(builder_.Build(&err));
- EXPECT_EQ("", err);
- ASSERT_EQ(1u, command_runner_.commands_ran_.size());
- EXPECT_EQ("echo 'out1: in1 in2' > in.d && for file in out1 out2; do cp in1 $file; done", command_runner_.commands_ran_[0]);
-
- Node* out1_node = state_.LookupNode("out1");
- DepsLog::Deps* out1_deps = log_.GetDeps(out1_node);
- EXPECT_EQ(2, out1_deps->node_count);
- EXPECT_EQ("in1", out1_deps->nodes[0]->path());
- EXPECT_EQ("in2", out1_deps->nodes[1]->path());
-
- Node* out2_node = state_.LookupNode("out2");
- DepsLog::Deps* out2_deps = log_.GetDeps(out2_node);
- EXPECT_EQ(2, out2_deps->node_count);
- EXPECT_EQ("in1", out2_deps->nodes[0]->path());
- EXPECT_EQ("in2", out2_deps->nodes[1]->path());
-}
-
-/// Test a GCC-style deps log with multiple outputs mentioning only the secondary output.
-TEST_F(BuildWithQueryDepsLogTest, TwoOutputsDepFileGCCOnlySecondaryOutput) {
- // Note: This ends up short-circuiting the node creation due to the primary
- // output not being present, but it should still work.
- ASSERT_NO_FATAL_FAILURE(AssertParse(&state_,
-"rule cp_multi_gcc\n"
-" command = echo 'out2: $in' > in.d && for file in $out; do cp in1 $$file; done\n"
-" deps = gcc\n"
-" depfile = in.d\n"
-"build out1 out2: cp_multi_gcc in1 in2\n"));
-
- std::string err;
- EXPECT_TRUE(builder_.AddTarget("out1", &err));
- ASSERT_EQ("", err);
- fs_.Create("in.d", "out2: in1 in2");
- EXPECT_TRUE(builder_.Build(&err));
- EXPECT_EQ("", err);
- ASSERT_EQ(1u, command_runner_.commands_ran_.size());
- EXPECT_EQ("echo 'out2: in1 in2' > in.d && for file in out1 out2; do cp in1 $file; done", command_runner_.commands_ran_[0]);
-
- Node* out1_node = state_.LookupNode("out1");
- DepsLog::Deps* out1_deps = log_.GetDeps(out1_node);
- EXPECT_EQ(2, out1_deps->node_count);
- EXPECT_EQ("in1", out1_deps->nodes[0]->path());
- EXPECT_EQ("in2", out1_deps->nodes[1]->path());
-
- Node* out2_node = state_.LookupNode("out2");
- DepsLog::Deps* out2_deps = log_.GetDeps(out2_node);
- EXPECT_EQ(2, out2_deps->node_count);
- EXPECT_EQ("in1", out2_deps->nodes[0]->path());
- EXPECT_EQ("in2", out2_deps->nodes[1]->path());
-}
-
-/// Tests of builds involving deps logs necessarily must span
-/// multiple builds. We reuse methods on BuildTest but not the
-/// builder_ it sets up, because we want pristine objects for
-/// each build.
-struct BuildWithDepsLogTest : public BuildTest {
- BuildWithDepsLogTest() {}
-
- virtual void SetUp() {
- BuildTest::SetUp();
-
- temp_dir_.CreateAndEnter("BuildWithDepsLogTest");
- }
-
- virtual void TearDown() {
- temp_dir_.Cleanup();
- }
-
- ScopedTempDir temp_dir_;
-
- /// Shadow parent class builder_ so we don't accidentally use it.
- void* builder_;
-};
-
-/// Run a straightforward build where the deps log is used.
-TEST_F(BuildWithDepsLogTest, Straightforward) {
- string err;
- // Note: in1 was created by the superclass SetUp().
- const char* manifest =
- "build out: cat in1\n"
- " deps = gcc\n"
- " depfile = in1.d\n";
- {
- State state;
- ASSERT_NO_FATAL_FAILURE(AddCatRule(&state));
- ASSERT_NO_FATAL_FAILURE(AssertParse(&state, manifest));
-
- // Run the build once, everything should be ok.
- DepsLog deps_log;
- ASSERT_TRUE(deps_log.OpenForWrite("ninja_deps", &err));
- ASSERT_EQ("", err);
-
- Builder builder(&state, config_, NULL, &deps_log, &fs_, &status_, 0);
- builder.command_runner_.reset(&command_runner_);
- EXPECT_TRUE(builder.AddTarget("out", &err));
- ASSERT_EQ("", err);
- fs_.Create("in1.d", "out: in2");
- EXPECT_TRUE(builder.Build(&err));
- EXPECT_EQ("", err);
-
- // The deps file should have been removed.
- EXPECT_EQ(0, fs_.Stat("in1.d", &err));
- // Recreate it for the next step.
- fs_.Create("in1.d", "out: in2");
- deps_log.Close();
- builder.command_runner_.release();
- }
-
- {
- State state;
- ASSERT_NO_FATAL_FAILURE(AddCatRule(&state));
- ASSERT_NO_FATAL_FAILURE(AssertParse(&state, manifest));
-
- // Touch the file only mentioned in the deps.
- fs_.Tick();
- fs_.Create("in2", "");
-
- // Run the build again.
- DepsLog deps_log;
- ASSERT_TRUE(deps_log.Load("ninja_deps", &state, &err));
- ASSERT_TRUE(deps_log.OpenForWrite("ninja_deps", &err));
-
- Builder builder(&state, config_, NULL, &deps_log, &fs_, &status_, 0);
- builder.command_runner_.reset(&command_runner_);
- command_runner_.commands_ran_.clear();
- EXPECT_TRUE(builder.AddTarget("out", &err));
- ASSERT_EQ("", err);
- EXPECT_TRUE(builder.Build(&err));
- EXPECT_EQ("", err);
-
- // We should have rebuilt the output due to in2 being
- // out of date.
- EXPECT_EQ(1u, command_runner_.commands_ran_.size());
-
- builder.command_runner_.release();
- }
-}
-
-/// Verify that obsolete dependency info causes a rebuild.
-/// 1) Run a successful build where everything has time t, record deps.
-/// 2) Move input/output to time t+1 -- despite files in alignment,
-/// should still need to rebuild due to deps at older time.
-TEST_F(BuildWithDepsLogTest, ObsoleteDeps) {
- string err;
- // Note: in1 was created by the superclass SetUp().
- const char* manifest =
- "build out: cat in1\n"
- " deps = gcc\n"
- " depfile = in1.d\n";
- {
- // Run an ordinary build that gathers dependencies.
- fs_.Create("in1", "");
- fs_.Create("in1.d", "out: ");
-
- State state;
- ASSERT_NO_FATAL_FAILURE(AddCatRule(&state));
- ASSERT_NO_FATAL_FAILURE(AssertParse(&state, manifest));
-
- // Run the build once, everything should be ok.
- DepsLog deps_log;
- ASSERT_TRUE(deps_log.OpenForWrite("ninja_deps", &err));
- ASSERT_EQ("", err);
-
- Builder builder(&state, config_, NULL, &deps_log, &fs_, &status_, 0);
- builder.command_runner_.reset(&command_runner_);
- EXPECT_TRUE(builder.AddTarget("out", &err));
- ASSERT_EQ("", err);
- EXPECT_TRUE(builder.Build(&err));
- EXPECT_EQ("", err);
-
- deps_log.Close();
- builder.command_runner_.release();
- }
-
- // Push all files one tick forward so that only the deps are out
- // of date.
- fs_.Tick();
- fs_.Create("in1", "");
- fs_.Create("out", "");
-
- // The deps file should have been removed, so no need to timestamp it.
- EXPECT_EQ(0, fs_.Stat("in1.d", &err));
-
- {
- State state;
- ASSERT_NO_FATAL_FAILURE(AddCatRule(&state));
- ASSERT_NO_FATAL_FAILURE(AssertParse(&state, manifest));
-
- DepsLog deps_log;
- ASSERT_TRUE(deps_log.Load("ninja_deps", &state, &err));
- ASSERT_TRUE(deps_log.OpenForWrite("ninja_deps", &err));
-
- Builder builder(&state, config_, NULL, &deps_log, &fs_, &status_, 0);
- builder.command_runner_.reset(&command_runner_);
- command_runner_.commands_ran_.clear();
- EXPECT_TRUE(builder.AddTarget("out", &err));
- ASSERT_EQ("", err);
-
- // Recreate the deps file here because the build expects them to exist.
- fs_.Create("in1.d", "out: ");
-
- EXPECT_TRUE(builder.Build(&err));
- EXPECT_EQ("", err);
-
- // We should have rebuilt the output due to the deps being
- // out of date.
- EXPECT_EQ(1u, command_runner_.commands_ran_.size());
-
- builder.command_runner_.release();
- }
-}
-
-TEST_F(BuildWithDepsLogTest, DepsIgnoredInDryRun) {
- const char* manifest =
- "build out: cat in1\n"
- " deps = gcc\n"
- " depfile = in1.d\n";
-
- fs_.Create("out", "");
- fs_.Tick();
- fs_.Create("in1", "");
-
- State state;
- ASSERT_NO_FATAL_FAILURE(AddCatRule(&state));
- ASSERT_NO_FATAL_FAILURE(AssertParse(&state, manifest));
-
- // The deps log is NULL in dry runs.
- config_.dry_run = true;
- Builder builder(&state, config_, NULL, NULL, &fs_, &status_, 0);
- builder.command_runner_.reset(&command_runner_);
- command_runner_.commands_ran_.clear();
-
- string err;
- EXPECT_TRUE(builder.AddTarget("out", &err));
- ASSERT_EQ("", err);
- EXPECT_TRUE(builder.Build(&err));
- ASSERT_EQ(1u, command_runner_.commands_ran_.size());
-
- builder.command_runner_.release();
-}
-
-TEST_F(BuildWithDepsLogTest, TestInputMtimeRaceCondition) {
- string err;
- const char* manifest =
- "rule long-cc\n"
- " command = long-cc\n"
- "build out: long-cc in1\n"
- " test_dependency = in1\n";
-
- State state;
- ASSERT_NO_FATAL_FAILURE(AddCatRule(&state));
- ASSERT_NO_FATAL_FAILURE(AssertParse(&state, manifest));
-
- BuildLog build_log;
- ASSERT_TRUE(build_log.Load("build_log", &err));
- ASSERT_TRUE(build_log.OpenForWrite("build_log", *this, &err));
-
- DepsLog deps_log;
- ASSERT_TRUE(deps_log.Load("ninja_deps", &state, &err));
- ASSERT_TRUE(deps_log.OpenForWrite("ninja_deps", &err));
-
- BuildLog::LogEntry* log_entry = NULL;
- {
- Builder builder(&state, config_, &build_log, &deps_log, &fs_, &status_, 0);
- builder.command_runner_.reset(&command_runner_);
- command_runner_.commands_ran_.clear();
-
- // Run the build, out gets built, dep file is created
- EXPECT_TRUE(builder.AddTarget("out", &err));
- ASSERT_EQ("", err);
- EXPECT_TRUE(builder.Build(&err));
- ASSERT_EQ(1u, command_runner_.commands_ran_.size());
-
- // See that an entry in the logfile is created. the input_mtime is 1 since that was
- // the mtime of in1 when the command was started
- log_entry = build_log.LookupByOutput("out");
- ASSERT_TRUE(NULL != log_entry);
- ASSERT_EQ(1u, log_entry->mtime);
-
- builder.command_runner_.release();
- }
-
- {
- Builder builder(&state, config_, &build_log, &deps_log, &fs_, &status_, 0);
- builder.command_runner_.reset(&command_runner_);
- command_runner_.commands_ran_.clear();
-
- // Trigger the build again - "out" should rebuild despite having a newer mtime than
- // "in1", since "in1" was touched during the build of out (simulated by changing its
- // mtime in the the test builder's WaitForCommand() which runs before FinishCommand()
- command_runner_.commands_ran_.clear();
- state.Reset();
- EXPECT_TRUE(builder.AddTarget("out", &err));
- ASSERT_EQ("", err);
- EXPECT_TRUE(builder.Build(&err));
- ASSERT_EQ(1u, command_runner_.commands_ran_.size());
-
- // Check that the logfile entry is still correct
- log_entry = build_log.LookupByOutput("out");
- ASSERT_TRUE(NULL != log_entry);
- ASSERT_TRUE(fs_.files_["in1"].mtime < log_entry->mtime);
- builder.command_runner_.release();
- }
-
- {
- Builder builder(&state, config_, &build_log, &deps_log, &fs_, &status_, 0);
- builder.command_runner_.reset(&command_runner_);
- command_runner_.commands_ran_.clear();
-
- // And a subsequent run should not have any work to do
- command_runner_.commands_ran_.clear();
- state.Reset();
- EXPECT_TRUE(builder.AddTarget("out", &err));
- ASSERT_EQ("", err);
- EXPECT_TRUE(builder.AlreadyUpToDate());
-
- builder.command_runner_.release();
- }
-}
-
-TEST_F(BuildWithDepsLogTest, TestInputMtimeRaceConditionWithDepFile) {
- string err;
- const char* manifest =
- "rule long-cc\n"
- " command = long-cc\n"
- "build out: long-cc\n"
- " deps = gcc\n"
- " depfile = out.d\n"
- " test_dependency = header.h\n";
-
- fs_.Create("header.h", "");
-
- State state;
- ASSERT_NO_FATAL_FAILURE(AssertParse(&state, manifest));
-
- BuildLog build_log;
- ASSERT_TRUE(build_log.Load("build_log", &err));
- ASSERT_TRUE(build_log.OpenForWrite("build_log", *this, &err));
-
- DepsLog deps_log;
- ASSERT_TRUE(deps_log.Load("ninja_deps", &state, &err));
- ASSERT_TRUE(deps_log.OpenForWrite("ninja_deps", &err));
-
- {
- Builder builder(&state, config_, &build_log, &deps_log, &fs_, &status_, 0);
- builder.command_runner_.reset(&command_runner_);
-
- // Run the build, out gets built, dep file is created
- EXPECT_TRUE(builder.AddTarget("out", &err));
- ASSERT_EQ("", err);
- EXPECT_TRUE(builder.Build(&err));
- ASSERT_EQ(1u, command_runner_.commands_ran_.size());
-
- // See that an entry in the logfile is created. the mtime is 1 due to the command
- // starting when the file system's mtime was 1.
- BuildLog::LogEntry* log_entry = build_log.LookupByOutput("out");
- ASSERT_TRUE(NULL != log_entry);
- ASSERT_EQ(1u, log_entry->mtime);
-
- builder.command_runner_.release();
- }
-
- {
- // Trigger the build again - "out" will rebuild since its newest input mtime (header.h)
- // is newer than the recorded mtime of out in the build log
- Builder builder(&state, config_, &build_log, &deps_log, &fs_, &status_, 0);
- builder.command_runner_.reset(&command_runner_);
- command_runner_.commands_ran_.clear();
-
- state.Reset();
- EXPECT_TRUE(builder.AddTarget("out", &err));
- ASSERT_EQ("", err);
- EXPECT_TRUE(builder.Build(&err));
- ASSERT_EQ(1u, command_runner_.commands_ran_.size());
-
- builder.command_runner_.release();
- }
-
- {
- // Trigger the build again - "out" won't rebuild since the file wasn't updated during
- // the previous build
- Builder builder(&state, config_, &build_log, &deps_log, &fs_, &status_, 0);
- builder.command_runner_.reset(&command_runner_);
- command_runner_.commands_ran_.clear();
-
- state.Reset();
- EXPECT_TRUE(builder.AddTarget("out", &err));
- ASSERT_EQ("", err);
- ASSERT_TRUE(builder.AlreadyUpToDate());
-
- builder.command_runner_.release();
- }
-
- // touch the header to trigger a rebuild
- fs_.Create("header.h", "");
- ASSERT_EQ(fs_.now_, 7);
-
- {
- // Rebuild. This time, long-cc will cause header.h to be updated while the build is
- // in progress
- Builder builder(&state, config_, &build_log, &deps_log, &fs_, &status_, 0);
- builder.command_runner_.reset(&command_runner_);
- command_runner_.commands_ran_.clear();
-
- state.Reset();
- EXPECT_TRUE(builder.AddTarget("out", &err));
- ASSERT_EQ("", err);
- EXPECT_TRUE(builder.Build(&err));
- ASSERT_EQ(1u, command_runner_.commands_ran_.size());
-
- builder.command_runner_.release();
- }
-
- {
- // Rebuild. Because header.h is now in the deplog for out, it should be detectable as
- // a change-while-in-progress and should cause a rebuild of out.
- Builder builder(&state, config_, &build_log, &deps_log, &fs_, &status_, 0);
- builder.command_runner_.reset(&command_runner_);
- command_runner_.commands_ran_.clear();
-
- state.Reset();
- EXPECT_TRUE(builder.AddTarget("out", &err));
- ASSERT_EQ("", err);
- EXPECT_TRUE(builder.Build(&err));
- ASSERT_EQ(1u, command_runner_.commands_ran_.size());
-
- builder.command_runner_.release();
- }
-
- {
- // This time, the header.h file was not updated during the build, so the target should
- // not be considered dirty.
- Builder builder(&state, config_, &build_log, &deps_log, &fs_, &status_, 0);
- builder.command_runner_.reset(&command_runner_);
- command_runner_.commands_ran_.clear();
-
- state.Reset();
- EXPECT_TRUE(builder.AddTarget("out", &err));
- ASSERT_EQ("", err);
- EXPECT_TRUE(builder.AlreadyUpToDate());
-
- builder.command_runner_.release();
- }
-}
-
-/// Check that a restat rule generating a header cancels compilations correctly.
-TEST_F(BuildTest, RestatDepfileDependency) {
- ASSERT_NO_FATAL_FAILURE(AssertParse(&state_,
-"rule true\n"
-" command = true\n" // Would be "write if out-of-date" in reality.
-" restat = 1\n"
-"build header.h: true header.in\n"
-"build out: cat in1\n"
-" depfile = in1.d\n"));
-
- fs_.Create("header.h", "");
- fs_.Create("in1.d", "out: header.h");
- fs_.Tick();
- fs_.Create("header.in", "");
-
- string err;
- EXPECT_TRUE(builder_.AddTarget("out", &err));
- ASSERT_EQ("", err);
- EXPECT_TRUE(builder_.Build(&err));
- EXPECT_EQ("", err);
-}
-
-/// Check that a restat rule generating a header cancels compilations correctly,
-/// depslog case.
-TEST_F(BuildWithDepsLogTest, RestatDepfileDependencyDepsLog) {
- string err;
- // Note: in1 was created by the superclass SetUp().
- const char* manifest =
- "rule true\n"
- " command = true\n" // Would be "write if out-of-date" in reality.
- " restat = 1\n"
- "build header.h: true header.in\n"
- "build out: cat in1\n"
- " deps = gcc\n"
- " depfile = in1.d\n";
- {
- State state;
- ASSERT_NO_FATAL_FAILURE(AddCatRule(&state));
- ASSERT_NO_FATAL_FAILURE(AssertParse(&state, manifest));
-
- // Run the build once, everything should be ok.
- DepsLog deps_log;
- ASSERT_TRUE(deps_log.OpenForWrite("ninja_deps", &err));
- ASSERT_EQ("", err);
-
- Builder builder(&state, config_, NULL, &deps_log, &fs_, &status_, 0);
- builder.command_runner_.reset(&command_runner_);
- EXPECT_TRUE(builder.AddTarget("out", &err));
- ASSERT_EQ("", err);
- fs_.Create("in1.d", "out: header.h");
- EXPECT_TRUE(builder.Build(&err));
- EXPECT_EQ("", err);
-
- deps_log.Close();
- builder.command_runner_.release();
- }
-
- {
- State state;
- ASSERT_NO_FATAL_FAILURE(AddCatRule(&state));
- ASSERT_NO_FATAL_FAILURE(AssertParse(&state, manifest));
-
- // Touch the input of the restat rule.
- fs_.Tick();
- fs_.Create("header.in", "");
-
- // Run the build again.
- DepsLog deps_log;
- ASSERT_TRUE(deps_log.Load("ninja_deps", &state, &err));
- ASSERT_TRUE(deps_log.OpenForWrite("ninja_deps", &err));
-
- Builder builder(&state, config_, NULL, &deps_log, &fs_, &status_, 0);
- builder.command_runner_.reset(&command_runner_);
- command_runner_.commands_ran_.clear();
- EXPECT_TRUE(builder.AddTarget("out", &err));
- ASSERT_EQ("", err);
- EXPECT_TRUE(builder.Build(&err));
- EXPECT_EQ("", err);
-
- // Rule "true" should have run again, but the build of "out" should have
- // been cancelled due to restat propagating through the depfile header.
- EXPECT_EQ(1u, command_runner_.commands_ran_.size());
-
- builder.command_runner_.release();
- }
-}
-
-TEST_F(BuildWithDepsLogTest, DepFileOKDepsLog) {
- string err;
- const char* manifest =
- "rule cc\n command = cc $in\n depfile = $out.d\n deps = gcc\n"
- "build fo$ o.o: cc foo.c\n";
-
- fs_.Create("foo.c", "");
-
- {
- State state;
- ASSERT_NO_FATAL_FAILURE(AssertParse(&state, manifest));
-
- // Run the build once, everything should be ok.
- DepsLog deps_log;
- ASSERT_TRUE(deps_log.OpenForWrite("ninja_deps", &err));
- ASSERT_EQ("", err);
-
- Builder builder(&state, config_, NULL, &deps_log, &fs_, &status_, 0);
- builder.command_runner_.reset(&command_runner_);
- EXPECT_TRUE(builder.AddTarget("fo o.o", &err));
- ASSERT_EQ("", err);
- fs_.Create("fo o.o.d", "fo\\ o.o: blah.h bar.h\n");
- EXPECT_TRUE(builder.Build(&err));
- EXPECT_EQ("", err);
-
- deps_log.Close();
- builder.command_runner_.release();
- }
-
- {
- State state;
- ASSERT_NO_FATAL_FAILURE(AssertParse(&state, manifest));
-
- DepsLog deps_log;
- ASSERT_TRUE(deps_log.Load("ninja_deps", &state, &err));
- ASSERT_TRUE(deps_log.OpenForWrite("ninja_deps", &err));
- ASSERT_EQ("", err);
-
- Builder builder(&state, config_, NULL, &deps_log, &fs_, &status_, 0);
- builder.command_runner_.reset(&command_runner_);
-
- Edge* edge = state.edges_.back();
-
- state.GetNode("bar.h", 0)->MarkDirty(); // Mark bar.h as missing.
- EXPECT_TRUE(builder.AddTarget("fo o.o", &err));
- ASSERT_EQ("", err);
-
- // Expect one new edge generating fo o.o, loading the depfile should
- // note generate new edges.
- ASSERT_EQ(1u, state.edges_.size());
- // Expect our edge to now have three inputs: foo.c and two headers.
- ASSERT_EQ(3u, edge->inputs_.size());
-
- // Expect the command line we generate to only use the original input.
- ASSERT_EQ("cc foo.c", edge->EvaluateCommand());
-
- deps_log.Close();
- builder.command_runner_.release();
- }
-}
-
-TEST_F(BuildWithDepsLogTest, DiscoveredDepDuringBuildChanged) {
- string err;
- const char* manifest =
- "rule touch-out-implicit-dep\n"
- " command = touch $out ; sleep 1 ; touch $test_dependency\n"
- "rule generate-depfile\n"
- " command = touch $out ; echo \"$out: $test_dependency\" > $depfile\n"
- "build out1: touch-out-implicit-dep in1\n"
- " test_dependency = inimp\n"
- "build out2: generate-depfile in1 || out1\n"
- " test_dependency = inimp\n"
- " depfile = out2.d\n"
- " deps = gcc\n";
-
- fs_.Create("in1", "");
- fs_.Tick();
-
- BuildLog build_log;
-
- {
- State state;
- ASSERT_NO_FATAL_FAILURE(AssertParse(&state, manifest));
-
- DepsLog deps_log;
- ASSERT_TRUE(deps_log.OpenForWrite("ninja_deps", &err));
- ASSERT_EQ("", err);
-
- Builder builder(&state, config_, &build_log, &deps_log, &fs_, &status_, 0);
- builder.command_runner_.reset(&command_runner_);
- EXPECT_TRUE(builder.AddTarget("out2", &err));
- EXPECT_FALSE(builder.AlreadyUpToDate());
-
- EXPECT_TRUE(builder.Build(&err));
- EXPECT_TRUE(builder.AlreadyUpToDate());
-
- deps_log.Close();
- builder.command_runner_.release();
- }
-
- fs_.Tick();
- fs_.Create("in1", "");
-
- {
- State state;
- ASSERT_NO_FATAL_FAILURE(AssertParse(&state, manifest));
-
- DepsLog deps_log;
- ASSERT_TRUE(deps_log.Load("ninja_deps", &state, &err));
- ASSERT_TRUE(deps_log.OpenForWrite("ninja_deps", &err));
- ASSERT_EQ("", err);
-
- Builder builder(&state, config_, &build_log, &deps_log, &fs_, &status_, 0);
- builder.command_runner_.reset(&command_runner_);
- EXPECT_TRUE(builder.AddTarget("out2", &err));
- EXPECT_FALSE(builder.AlreadyUpToDate());
-
- EXPECT_TRUE(builder.Build(&err));
- EXPECT_TRUE(builder.AlreadyUpToDate());
-
- deps_log.Close();
- builder.command_runner_.release();
- }
-
- fs_.Tick();
-
- {
- State state;
- ASSERT_NO_FATAL_FAILURE(AssertParse(&state, manifest));
-
- DepsLog deps_log;
- ASSERT_TRUE(deps_log.Load("ninja_deps", &state, &err));
- ASSERT_TRUE(deps_log.OpenForWrite("ninja_deps", &err));
- ASSERT_EQ("", err);
-
- Builder builder(&state, config_, &build_log, &deps_log, &fs_, &status_, 0);
- builder.command_runner_.reset(&command_runner_);
- EXPECT_TRUE(builder.AddTarget("out2", &err));
- EXPECT_TRUE(builder.AlreadyUpToDate());
-
- deps_log.Close();
- builder.command_runner_.release();
- }
-}
-
-#ifdef _WIN32
-TEST_F(BuildWithDepsLogTest, DepFileDepsLogCanonicalize) {
- string err;
- const char* manifest =
- "rule cc\n command = cc $in\n depfile = $out.d\n deps = gcc\n"
- "build a/b\\c\\d/e/fo$ o.o: cc x\\y/z\\foo.c\n";
-
- fs_.Create("x/y/z/foo.c", "");
-
- {
- State state;
- ASSERT_NO_FATAL_FAILURE(AssertParse(&state, manifest));
-
- // Run the build once, everything should be ok.
- DepsLog deps_log;
- ASSERT_TRUE(deps_log.OpenForWrite("ninja_deps", &err));
- ASSERT_EQ("", err);
-
- Builder builder(&state, config_, NULL, &deps_log, &fs_, &status_, 0);
- builder.command_runner_.reset(&command_runner_);
- EXPECT_TRUE(builder.AddTarget("a/b/c/d/e/fo o.o", &err));
- ASSERT_EQ("", err);
- // Note, different slashes from manifest.
- fs_.Create("a/b\\c\\d/e/fo o.o.d",
- "a\\b\\c\\d\\e\\fo\\ o.o: blah.h bar.h\n");
- EXPECT_TRUE(builder.Build(&err));
- EXPECT_EQ("", err);
-
- deps_log.Close();
- builder.command_runner_.release();
- }
-
- {
- State state;
- ASSERT_NO_FATAL_FAILURE(AssertParse(&state, manifest));
-
- DepsLog deps_log;
- ASSERT_TRUE(deps_log.Load("ninja_deps", &state, &err));
- ASSERT_TRUE(deps_log.OpenForWrite("ninja_deps", &err));
- ASSERT_EQ("", err);
-
- Builder builder(&state, config_, NULL, &deps_log, &fs_, &status_, 0);
- builder.command_runner_.reset(&command_runner_);
-
- state.GetNode("bar.h", 0)->MarkDirty(); // Mark bar.h as missing.
- EXPECT_TRUE(builder.AddTarget("a/b/c/d/e/fo o.o", &err));
- ASSERT_EQ("", err);
-
- // Expect one new edge generating fo o.o.
- ASSERT_EQ(1u, state.edges_.size());
- // Expect our edge to now have three inputs: foo.c and two headers.
- Edge* edge = state.edges_.back();
- ASSERT_EQ(3u, edge->inputs_.size());
-
- // Expect the command line we generate to only use the original input.
- // Note, slashes from manifest, not .d.
- ASSERT_EQ("cc x\\y/z\\foo.c", edge->EvaluateCommand());
-
- deps_log.Close();
- builder.command_runner_.release();
- }
-}
-#endif
-
-/// Check that a restat rule doesn't clear an edge if the depfile is missing.
-/// Follows from: https://github.com/ninja-build/ninja/issues/603
-TEST_F(BuildTest, RestatMissingDepfile) {
-const char* manifest =
-"rule true\n"
-" command = true\n" // Would be "write if out-of-date" in reality.
-" restat = 1\n"
-"build header.h: true header.in\n"
-"build out: cat header.h\n"
-" depfile = out.d\n";
-
- fs_.Create("header.h", "");
- fs_.Tick();
- fs_.Create("out", "");
- fs_.Create("header.in", "");
-
- // Normally, only 'header.h' would be rebuilt, as
- // its rule doesn't touch the output and has 'restat=1' set.
- // But we are also missing the depfile for 'out',
- // which should force its command to run anyway!
- RebuildTarget("out", manifest);
- ASSERT_EQ(2u, command_runner_.commands_ran_.size());
-}
-
-/// Check that a restat rule doesn't clear an edge if the deps are missing.
-/// https://github.com/ninja-build/ninja/issues/603
-TEST_F(BuildWithDepsLogTest, RestatMissingDepfileDepslog) {
- string err;
- const char* manifest =
-"rule true\n"
-" command = true\n" // Would be "write if out-of-date" in reality.
-" restat = 1\n"
-"build header.h: true header.in\n"
-"build out: cat header.h\n"
-" deps = gcc\n"
-" depfile = out.d\n";
-
- // Build once to populate ninja deps logs from out.d
- fs_.Create("header.in", "");
- fs_.Create("out.d", "out: header.h");
- fs_.Create("header.h", "");
-
- RebuildTarget("out", manifest, "build_log", "ninja_deps");
- ASSERT_EQ(2u, command_runner_.commands_ran_.size());
-
- // Sanity: this rebuild should be NOOP
- RebuildTarget("out", manifest, "build_log", "ninja_deps");
- ASSERT_EQ(0u, command_runner_.commands_ran_.size());
-
- // Touch 'header.in', blank dependencies log (create a different one).
- // Building header.h triggers 'restat' outputs cleanup.
- // Validate that out is rebuilt netherless, as deps are missing.
- fs_.Tick();
- fs_.Create("header.in", "");
-
- // (switch to a new blank deps_log "ninja_deps2")
- RebuildTarget("out", manifest, "build_log", "ninja_deps2");
- ASSERT_EQ(2u, command_runner_.commands_ran_.size());
-
- // Sanity: this build should be NOOP
- RebuildTarget("out", manifest, "build_log", "ninja_deps2");
- ASSERT_EQ(0u, command_runner_.commands_ran_.size());
-
- // Check that invalidating deps by target timestamp also works here
- // Repeat the test but touch target instead of blanking the log.
- fs_.Tick();
- fs_.Create("header.in", "");
- fs_.Create("out", "");
- RebuildTarget("out", manifest, "build_log", "ninja_deps2");
- ASSERT_EQ(2u, command_runner_.commands_ran_.size());
-
- // And this build should be NOOP again
- RebuildTarget("out", manifest, "build_log", "ninja_deps2");
- ASSERT_EQ(0u, command_runner_.commands_ran_.size());
-}
-
-TEST_F(BuildTest, WrongOutputInDepfileCausesRebuild) {
- string err;
- const char* manifest =
-"rule cc\n"
-" command = cc $in\n"
-" depfile = $out.d\n"
-"build foo.o: cc foo.c\n";
-
- fs_.Create("foo.c", "");
- fs_.Create("foo.o", "");
- fs_.Create("header.h", "");
- fs_.Create("foo.o.d", "bar.o.d: header.h\n");
-
- RebuildTarget("foo.o", manifest, "build_log", "ninja_deps");
- ASSERT_EQ(1u, command_runner_.commands_ran_.size());
-}
-
-TEST_F(BuildTest, Console) {
- ASSERT_NO_FATAL_FAILURE(AssertParse(&state_,
-"rule console\n"
-" command = console\n"
-" pool = console\n"
-"build cons: console in.txt\n"));
-
- fs_.Create("in.txt", "");
-
- string err;
- EXPECT_TRUE(builder_.AddTarget("cons", &err));
- ASSERT_EQ("", err);
- EXPECT_TRUE(builder_.Build(&err));
- EXPECT_EQ("", err);
- ASSERT_EQ(1u, command_runner_.commands_ran_.size());
-}
-
-TEST_F(BuildTest, DyndepMissingAndNoRule) {
- // Verify that we can diagnose when a dyndep file is missing and
- // has no rule to build it.
- ASSERT_NO_FATAL_FAILURE(AssertParse(&state_,
-"rule touch\n"
-" command = touch $out\n"
-"build out: touch || dd\n"
-" dyndep = dd\n"
-));
-
- string err;
- EXPECT_FALSE(builder_.AddTarget("out", &err));
- EXPECT_EQ("loading 'dd': No such file or directory", err);
-}
-
-TEST_F(BuildTest, DyndepReadyImplicitConnection) {
- // Verify that a dyndep file can be loaded immediately to discover
- // that one edge has an implicit output that is also an implicit
- // input of another edge.
- ASSERT_NO_FATAL_FAILURE(AssertParse(&state_,
-"rule touch\n"
-" command = touch $out $out.imp\n"
-"build tmp: touch || dd\n"
-" dyndep = dd\n"
-"build out: touch || dd\n"
-" dyndep = dd\n"
-));
- fs_.Create("dd",
-"ninja_dyndep_version = 1\n"
-"build out | out.imp: dyndep | tmp.imp\n"
-"build tmp | tmp.imp: dyndep\n"
-);
-
- string err;
- EXPECT_TRUE(builder_.AddTarget("out", &err));
- ASSERT_EQ("", err);
- EXPECT_TRUE(builder_.Build(&err));
- EXPECT_EQ("", err);
- ASSERT_EQ(2u, command_runner_.commands_ran_.size());
- EXPECT_EQ("touch tmp tmp.imp", command_runner_.commands_ran_[0]);
- EXPECT_EQ("touch out out.imp", command_runner_.commands_ran_[1]);
-}
-
-TEST_F(BuildTest, DyndepReadySyntaxError) {
- // Verify that a dyndep file can be loaded immediately to discover
- // and reject a syntax error in it.
- ASSERT_NO_FATAL_FAILURE(AssertParse(&state_,
-"rule touch\n"
-" command = touch $out\n"
-"build out: touch || dd\n"
-" dyndep = dd\n"
-));
- fs_.Create("dd",
-"build out: dyndep\n"
-);
-
- string err;
- EXPECT_FALSE(builder_.AddTarget("out", &err));
- EXPECT_EQ("dd:1: expected 'ninja_dyndep_version = ...'\n", err);
-}
-
-TEST_F(BuildTest, DyndepReadyCircular) {
- // Verify that a dyndep file can be loaded immediately to discover
- // and reject a circular dependency.
- ASSERT_NO_FATAL_FAILURE(AssertParse(&state_,
-"rule r\n"
-" command = unused\n"
-"build out: r in || dd\n"
-" dyndep = dd\n"
-"build in: r circ\n"
- ));
- fs_.Create("dd",
-"ninja_dyndep_version = 1\n"
-"build out | circ: dyndep\n"
- );
- fs_.Create("out", "");
-
- string err;
- EXPECT_FALSE(builder_.AddTarget("out", &err));
- EXPECT_EQ("dependency cycle: circ -> in -> circ", err);
-}
-
-TEST_F(BuildTest, DyndepBuild) {
- // Verify that a dyndep file can be built and loaded to discover nothing.
- ASSERT_NO_FATAL_FAILURE(AssertParse(&state_,
-"rule touch\n"
-" command = touch $out\n"
-"rule cp\n"
-" command = cp $in $out\n"
-"build dd: cp dd-in\n"
-"build out: touch || dd\n"
-" dyndep = dd\n"
-));
- fs_.Create("dd-in",
-"ninja_dyndep_version = 1\n"
-"build out: dyndep\n"
-);
-
- string err;
- EXPECT_TRUE(builder_.AddTarget("out", &err));
- EXPECT_EQ("", err);
-
- size_t files_created = fs_.files_created_.size();
- EXPECT_TRUE(builder_.Build(&err));
- EXPECT_EQ("", err);
-
- ASSERT_EQ(2u, command_runner_.commands_ran_.size());
- EXPECT_EQ("cp dd-in dd", command_runner_.commands_ran_[0]);
- EXPECT_EQ("touch out", command_runner_.commands_ran_[1]);
- ASSERT_EQ(2u, fs_.files_read_.size());
- EXPECT_EQ("dd-in", fs_.files_read_[0]);
- EXPECT_EQ("dd", fs_.files_read_[1]);
- ASSERT_EQ(3u + files_created, fs_.files_created_.size());
- EXPECT_EQ(1u, fs_.files_created_.count("dd"));
- EXPECT_EQ(1u, fs_.files_created_.count("out"));
- EXPECT_EQ(1u, fs_.files_created_.count(".ninja_lock"));
-}
-
-TEST_F(BuildTest, DyndepBuildSyntaxError) {
- // Verify that a dyndep file can be built and loaded to discover
- // and reject a syntax error in it.
- ASSERT_NO_FATAL_FAILURE(AssertParse(&state_,
-"rule touch\n"
-" command = touch $out\n"
-"rule cp\n"
-" command = cp $in $out\n"
-"build dd: cp dd-in\n"
-"build out: touch || dd\n"
-" dyndep = dd\n"
-));
- fs_.Create("dd-in",
-"build out: dyndep\n"
-);
-
- string err;
- EXPECT_TRUE(builder_.AddTarget("out", &err));
- EXPECT_EQ("", err);
-
- EXPECT_FALSE(builder_.Build(&err));
- EXPECT_EQ("dd:1: expected 'ninja_dyndep_version = ...'\n", err);
-}
-
-TEST_F(BuildTest, DyndepBuildUnrelatedOutput) {
- // Verify that a dyndep file can have dependents that do not specify
- // it as their dyndep binding.
- ASSERT_NO_FATAL_FAILURE(AssertParse(&state_,
-"rule touch\n"
-" command = touch $out\n"
-"rule cp\n"
-" command = cp $in $out\n"
-"build dd: cp dd-in\n"
-"build unrelated: touch || dd\n"
-"build out: touch unrelated || dd\n"
-" dyndep = dd\n"
- ));
- fs_.Create("dd-in",
-"ninja_dyndep_version = 1\n"
-"build out: dyndep\n"
-);
- fs_.Tick();
- fs_.Create("out", "");
-
- string err;
- EXPECT_TRUE(builder_.AddTarget("out", &err));
- EXPECT_EQ("", err);
-
- EXPECT_TRUE(builder_.Build(&err));
- EXPECT_EQ("", err);
- ASSERT_EQ(3u, command_runner_.commands_ran_.size());
- EXPECT_EQ("cp dd-in dd", command_runner_.commands_ran_[0]);
- EXPECT_EQ("touch unrelated", command_runner_.commands_ran_[1]);
- EXPECT_EQ("touch out", command_runner_.commands_ran_[2]);
-}
-
-TEST_F(BuildTest, DyndepBuildDiscoverNewOutput) {
- // Verify that a dyndep file can be built and loaded to discover
- // a new output of an edge.
- ASSERT_NO_FATAL_FAILURE(AssertParse(&state_,
-"rule touch\n"
-" command = touch $out $out.imp\n"
-"rule cp\n"
-" command = cp $in $out\n"
-"build dd: cp dd-in\n"
-"build out: touch in || dd\n"
-" dyndep = dd\n"
- ));
- fs_.Create("in", "");
- fs_.Create("dd-in",
-"ninja_dyndep_version = 1\n"
-"build out | out.imp: dyndep\n"
-);
- fs_.Tick();
- fs_.Create("out", "");
-
- string err;
- EXPECT_TRUE(builder_.AddTarget("out", &err));
- EXPECT_EQ("", err);
-
- EXPECT_TRUE(builder_.Build(&err));
- EXPECT_EQ("", err);
- ASSERT_EQ(2u, command_runner_.commands_ran_.size());
- EXPECT_EQ("cp dd-in dd", command_runner_.commands_ran_[0]);
- EXPECT_EQ("touch out out.imp", command_runner_.commands_ran_[1]);
-}
-
-TEST_F(BuildTest, DyndepBuildDiscoverNewOutputWithMultipleRules1) {
- // Verify that a dyndep file can be built and loaded to discover
- // a new output of an edge that is already the output of another edge.
- ASSERT_NO_FATAL_FAILURE(AssertParse(&state_,
-"rule touch\n"
-" command = touch $out $out.imp\n"
-"rule cp\n"
-" command = cp $in $out\n"
-"build dd: cp dd-in\n"
-"build out1 | out-twice.imp: touch in\n"
-"build out2: touch in || dd\n"
-" dyndep = dd\n"
- ));
- fs_.Create("in", "");
- fs_.Create("dd-in",
-"ninja_dyndep_version = 1\n"
-"build out2 | out-twice.imp: dyndep\n"
-);
- fs_.Tick();
- fs_.Create("out1", "");
- fs_.Create("out2", "");
-
- string err;
- EXPECT_TRUE(builder_.AddTarget("out1", &err));
- EXPECT_TRUE(builder_.AddTarget("out2", &err));
- EXPECT_EQ("", err);
-
- EXPECT_FALSE(builder_.Build(&err));
- EXPECT_EQ("multiple rules generate out-twice.imp", err);
-}
-
-TEST_F(BuildTest, DyndepBuildDiscoverNewOutputWithMultipleRules2) {
- // Verify that a dyndep file can be built and loaded to discover
- // a new output of an edge that is already the output of another
- // edge also discovered by dyndep.
- ASSERT_NO_FATAL_FAILURE(AssertParse(&state_,
-"rule touch\n"
-" command = touch $out $out.imp\n"
-"rule cp\n"
-" command = cp $in $out\n"
-"build dd1: cp dd1-in\n"
-"build out1: touch || dd1\n"
-" dyndep = dd1\n"
-"build dd2: cp dd2-in || dd1\n" // make order predictable for test
-"build out2: touch || dd2\n"
-" dyndep = dd2\n"
-));
- fs_.Create("out1", "");
- fs_.Create("out2", "");
- fs_.Create("dd1-in",
-"ninja_dyndep_version = 1\n"
-"build out1 | out-twice.imp: dyndep\n"
-);
- fs_.Create("dd2-in", "");
- fs_.Create("dd2",
-"ninja_dyndep_version = 1\n"
-"build out2 | out-twice.imp: dyndep\n"
-);
- fs_.Tick();
- fs_.Create("out1", "");
- fs_.Create("out2", "");
-
- string err;
- EXPECT_TRUE(builder_.AddTarget("out1", &err));
- EXPECT_TRUE(builder_.AddTarget("out2", &err));
- EXPECT_EQ("", err);
-
- EXPECT_FALSE(builder_.Build(&err));
- EXPECT_EQ("multiple rules generate out-twice.imp", err);
-}
-
-TEST_F(BuildTest, DyndepBuildDiscoverNewInput) {
- // Verify that a dyndep file can be built and loaded to discover
- // a new input to an edge.
- ASSERT_NO_FATAL_FAILURE(AssertParse(&state_,
-"rule touch\n"
-" command = touch $out\n"
-"rule cp\n"
-" command = cp $in $out\n"
-"build dd: cp dd-in\n"
-"build in: touch\n"
-"build out: touch || dd\n"
-" dyndep = dd\n"
- ));
- fs_.Create("dd-in",
-"ninja_dyndep_version = 1\n"
-"build out: dyndep | in\n"
-);
- fs_.Tick();
- fs_.Create("out", "");
-
- string err;
- EXPECT_TRUE(builder_.AddTarget("out", &err));
- EXPECT_EQ("", err);
-
- EXPECT_TRUE(builder_.Build(&err));
- EXPECT_EQ("", err);
- ASSERT_EQ(3u, command_runner_.commands_ran_.size());
- EXPECT_EQ("cp dd-in dd", command_runner_.commands_ran_[0]);
- EXPECT_EQ("touch in", command_runner_.commands_ran_[1]);
- EXPECT_EQ("touch out", command_runner_.commands_ran_[2]);
-}
-
-TEST_F(BuildTest, DyndepBuildDiscoverNewInputWithValidation) {
- // Verify that a dyndep file cannot contain the |@ validation
- // syntax.
- ASSERT_NO_FATAL_FAILURE(AssertParse(&state_,
-"rule touch\n"
-" command = touch $out\n"
-"rule cp\n"
-" command = cp $in $out\n"
-"build dd: cp dd-in\n"
-"build out: touch || dd\n"
-" dyndep = dd\n"
-));
- fs_.Create("dd-in",
-"ninja_dyndep_version = 1\n"
-"build out: dyndep |@ validation\n"
-);
-
- string err;
- EXPECT_TRUE(builder_.AddTarget("out", &err));
- EXPECT_EQ("", err);
-
- EXPECT_FALSE(builder_.Build(&err));
-
- string err_first_line = err.substr(0, err.find("\n"));
- EXPECT_EQ("dd:2: expected newline, got '|@'", err_first_line);
-}
-
-TEST_F(BuildTest, DyndepBuildDiscoverNewInputWithTransitiveValidation) {
- // Verify that a dyndep file can be built and loaded to discover
- // a new input to an edge that has a validation edge.
- ASSERT_NO_FATAL_FAILURE(AssertParse(&state_,
-"rule touch\n"
-" command = touch $out\n"
-"rule cp\n"
-" command = cp $in $out\n"
-"build dd: cp dd-in\n"
-"build in: touch |@ validation\n"
-"build validation: touch in out\n"
-"build out: touch || dd\n"
-" dyndep = dd\n"
- ));
- fs_.Create("dd-in",
-"ninja_dyndep_version = 1\n"
-"build out: dyndep | in\n"
-);
- fs_.Tick();
- fs_.Create("out", "");
-
- string err;
- EXPECT_TRUE(builder_.AddTarget("out", &err));
- EXPECT_EQ("", err);
-
- EXPECT_TRUE(builder_.Build(&err));
- EXPECT_EQ("", err);
- ASSERT_EQ(4u, command_runner_.commands_ran_.size());
- EXPECT_EQ("cp dd-in dd", command_runner_.commands_ran_[0]);
- EXPECT_EQ("touch in", command_runner_.commands_ran_[1]);
- EXPECT_EQ("touch out", command_runner_.commands_ran_[2]);
- EXPECT_EQ("touch validation", command_runner_.commands_ran_[3]);
-}
-
-TEST_F(BuildTest, DyndepBuildDiscoverImplicitConnection) {
- // Verify that a dyndep file can be built and loaded to discover
- // that one edge has an implicit output that is also an implicit
- // input of another edge.
- ASSERT_NO_FATAL_FAILURE(AssertParse(&state_,
-"rule touch\n"
-" command = touch $out $out.imp\n"
-"rule cp\n"
-" command = cp $in $out\n"
-"build dd: cp dd-in\n"
-"build tmp: touch || dd\n"
-" dyndep = dd\n"
-"build out: touch || dd\n"
-" dyndep = dd\n"
-));
- fs_.Create("dd-in",
-"ninja_dyndep_version = 1\n"
-"build out | out.imp: dyndep | tmp.imp\n"
-"build tmp | tmp.imp: dyndep\n"
-);
-
- string err;
- EXPECT_TRUE(builder_.AddTarget("out", &err));
- ASSERT_EQ("", err);
- EXPECT_TRUE(builder_.Build(&err));
- EXPECT_EQ("", err);
- ASSERT_EQ(3u, command_runner_.commands_ran_.size());
- EXPECT_EQ("cp dd-in dd", command_runner_.commands_ran_[0]);
- EXPECT_EQ("touch tmp tmp.imp", command_runner_.commands_ran_[1]);
- EXPECT_EQ("touch out out.imp", command_runner_.commands_ran_[2]);
-}
-
-TEST_F(BuildTest, DyndepBuildDiscoverOutputAndDepfileInput) {
- // Verify that a dyndep file can be built and loaded to discover
- // that one edge has an implicit output that is also reported by
- // a depfile as an input of another edge.
- ASSERT_NO_FATAL_FAILURE(AssertParse(&state_,
-"rule touch\n"
-" command = touch $out $out.imp\n"
-"rule cp\n"
-" command = cp $in $out\n"
-"build dd: cp dd-in\n"
-"build tmp: touch || dd\n"
-" dyndep = dd\n"
-"build out: cp tmp\n"
-" depfile = out.d\n"
-));
- fs_.Create("out.d", "out: tmp.imp\n");
- fs_.Create("dd-in",
-"ninja_dyndep_version = 1\n"
-"build tmp | tmp.imp: dyndep\n"
-);
-
- string err;
- EXPECT_TRUE(builder_.AddTarget("out", &err));
- ASSERT_EQ("", err);
-
- // Loading the depfile did not give tmp.imp a phony input edge.
- ASSERT_FALSE(GetNode("tmp.imp")->in_edge());
-
- EXPECT_TRUE(builder_.Build(&err));
- EXPECT_EQ("", err);
-
- // Loading the dyndep file gave tmp.imp a real input edge.
- ASSERT_FALSE(GetNode("tmp.imp")->in_edge()->is_phony());
-
- ASSERT_EQ(3u, command_runner_.commands_ran_.size());
- EXPECT_EQ("cp dd-in dd", command_runner_.commands_ran_[0]);
- EXPECT_EQ("touch tmp tmp.imp", command_runner_.commands_ran_[1]);
- EXPECT_EQ("cp tmp out", command_runner_.commands_ran_[2]);
- EXPECT_EQ(1u, fs_.files_created_.count("tmp.imp"));
- EXPECT_TRUE(builder_.AlreadyUpToDate());
-}
-
-TEST_F(BuildTest, DyndepBuildDiscoverNowWantEdge) {
- // Verify that a dyndep file can be built and loaded to discover
- // that an edge is actually wanted due to a missing implicit output.
- ASSERT_NO_FATAL_FAILURE(AssertParse(&state_,
-"rule touch\n"
-" command = touch $out $out.imp\n"
-"rule cp\n"
-" command = cp $in $out\n"
-"build dd: cp dd-in\n"
-"build tmp: touch || dd\n"
-" dyndep = dd\n"
-"build out: touch tmp || dd\n"
-" dyndep = dd\n"
-));
- fs_.Create("tmp", "");
- fs_.Create("out", "");
- fs_.Create("dd-in",
-"ninja_dyndep_version = 1\n"
-"build out: dyndep\n"
-"build tmp | tmp.imp: dyndep\n"
-);
-
- string err;
- EXPECT_TRUE(builder_.AddTarget("out", &err));
- ASSERT_EQ("", err);
- EXPECT_TRUE(builder_.Build(&err));
- EXPECT_EQ("", err);
- ASSERT_EQ(3u, command_runner_.commands_ran_.size());
- EXPECT_EQ("cp dd-in dd", command_runner_.commands_ran_[0]);
- EXPECT_EQ("touch tmp tmp.imp", command_runner_.commands_ran_[1]);
- EXPECT_EQ("touch out out.imp", command_runner_.commands_ran_[2]);
-}
-
-TEST_F(BuildTest, DyndepBuildDiscoverNowWantEdgeAndDependent) {
- // Verify that a dyndep file can be built and loaded to discover
- // that an edge and a dependent are actually wanted.
- ASSERT_NO_FATAL_FAILURE(AssertParse(&state_,
-"rule touch\n"
-" command = touch $out $out.imp\n"
-"rule cp\n"
-" command = cp $in $out\n"
-"build dd: cp dd-in\n"
-"build tmp: touch || dd\n"
-" dyndep = dd\n"
-"build out: touch tmp\n"
-));
- fs_.Create("tmp", "");
- fs_.Create("out", "");
- fs_.Create("dd-in",
-"ninja_dyndep_version = 1\n"
-"build tmp | tmp.imp: dyndep\n"
-);
-
- string err;
- EXPECT_TRUE(builder_.AddTarget("out", &err));
- ASSERT_EQ("", err);
- EXPECT_TRUE(builder_.Build(&err));
- EXPECT_EQ("", err);
- ASSERT_EQ(3u, command_runner_.commands_ran_.size());
- EXPECT_EQ("cp dd-in dd", command_runner_.commands_ran_[0]);
- EXPECT_EQ("touch tmp tmp.imp", command_runner_.commands_ran_[1]);
- EXPECT_EQ("touch out out.imp", command_runner_.commands_ran_[2]);
-}
-
-TEST_F(BuildTest, DyndepBuildDiscoverCircular) {
- // Verify that a dyndep file can be built and loaded to discover
- // and reject a circular dependency.
- ASSERT_NO_FATAL_FAILURE(AssertParse(&state_,
-"rule r\n"
-" command = unused\n"
-"rule cp\n"
-" command = cp $in $out\n"
-"build dd: cp dd-in\n"
-"build out: r in || dd\n"
-" depfile = out.d\n"
-" dyndep = dd\n"
-"build in: r || dd\n"
-" dyndep = dd\n"
- ));
- fs_.Create("out.d", "out: inimp\n");
- fs_.Create("dd-in",
-"ninja_dyndep_version = 1\n"
-"build out | circ: dyndep\n"
-"build in: dyndep | circ\n"
- );
- fs_.Create("out", "");
-
- string err;
- EXPECT_TRUE(builder_.AddTarget("out", &err));
- EXPECT_EQ("", err);
-
- EXPECT_FALSE(builder_.Build(&err));
- // Depending on how the pointers in Plan::ready_ work out, we could have
- // discovered the cycle from either starting point.
- EXPECT_TRUE(err == "dependency cycle: circ -> in -> circ" ||
- err == "dependency cycle: in -> circ -> in");
-}
-
-TEST_F(BuildWithLogTest, DyndepBuildDiscoverRestat) {
- // Verify that a dyndep file can be built and loaded to discover
- // that an edge has a restat binding.
- ASSERT_NO_FATAL_FAILURE(AssertParse(&state_,
-"rule true\n"
-" command = true\n"
-"rule cp\n"
-" command = cp $in $out\n"
-"build dd: cp dd-in\n"
-"build out1: true in || dd\n"
-" dyndep = dd\n"
-"build out2: cat out1\n"));
-
- fs_.Create("out1", "");
- fs_.Create("out2", "");
- fs_.Create("dd-in",
-"ninja_dyndep_version = 1\n"
-"build out1: dyndep\n"
-" restat = 1\n"
-);
- fs_.Tick();
- fs_.Create("in", "");
-
- // Do a pre-build so that there's commands in the log for the outputs,
- // otherwise, the lack of an entry in the build log will cause "out2" to
- // rebuild regardless of restat.
- string err;
- EXPECT_TRUE(builder_.AddTarget("out2", &err));
- ASSERT_EQ("", err);
- EXPECT_TRUE(builder_.Build(&err));
- ASSERT_EQ("", err);
- ASSERT_EQ(3u, command_runner_.commands_ran_.size());
- EXPECT_EQ("cp dd-in dd", command_runner_.commands_ran_[0]);
- EXPECT_EQ("true", command_runner_.commands_ran_[1]);
- EXPECT_EQ("cat out1 > out2", command_runner_.commands_ran_[2]);
-
- command_runner_.commands_ran_.clear();
- state_.Reset();
- fs_.Tick();
- fs_.Create("in", "");
-
- // We touched "in", so we should build "out1". But because "true" does not
- // touch "out1", we should cancel the build of "out2".
- EXPECT_TRUE(builder_.AddTarget("out2", &err));
- ASSERT_EQ("", err);
- EXPECT_TRUE(builder_.Build(&err));
- ASSERT_EQ(1u, command_runner_.commands_ran_.size());
- EXPECT_EQ("true", command_runner_.commands_ran_[0]);
-}
-
-TEST_F(BuildTest, DyndepBuildDiscoverScheduledEdge) {
- // Verify that a dyndep file can be built and loaded to discover a
- // new input that itself is an output from an edge that has already
- // been scheduled but not finished. We should not re-schedule it.
- ASSERT_NO_FATAL_FAILURE(AssertParse(&state_,
-"rule touch\n"
-" command = touch $out $out.imp\n"
-"rule cp\n"
-" command = cp $in $out\n"
-"build out1 | out1.imp: touch\n"
-"build zdd: cp zdd-in\n"
-" verify_active_edge = out1\n" // verify out1 is active when zdd is finished
-"build out2: cp out1 || zdd\n"
-" dyndep = zdd\n"
-));
- fs_.Create("zdd-in",
-"ninja_dyndep_version = 1\n"
-"build out2: dyndep | out1.imp\n"
-);
-
- // Enable concurrent builds so that we can load the dyndep file
- // while another edge is still active.
- command_runner_.max_active_edges_ = 2;
-
- // During the build "out1" and "zdd" should be built concurrently.
- // The fake command runner will finish these in reverse order
- // of the names of the first outputs, so "zdd" will finish first
- // and we will load the dyndep file while the edge for "out1" is
- // still active. This will add a new dependency on "out1.imp",
- // also produced by the active edge. The builder should not
- // re-schedule the already-active edge.
-
- string err;
- EXPECT_TRUE(builder_.AddTarget("out1", &err));
- EXPECT_TRUE(builder_.AddTarget("out2", &err));
- ASSERT_EQ("", err);
- EXPECT_TRUE(builder_.Build(&err));
- EXPECT_EQ("", err);
- ASSERT_EQ(3u, command_runner_.commands_ran_.size());
- // Depending on how the pointers in Plan::ready_ work out, the first
- // two commands may have run in either order.
- EXPECT_TRUE((command_runner_.commands_ran_[0] == "touch out1 out1.imp" &&
- command_runner_.commands_ran_[1] == "cp zdd-in zdd") ||
- (command_runner_.commands_ran_[1] == "touch out1 out1.imp" &&
- command_runner_.commands_ran_[0] == "cp zdd-in zdd"));
- EXPECT_EQ("cp out1 out2", command_runner_.commands_ran_[2]);
-}
-
-TEST_F(BuildTest, DyndepTwoLevelDirect) {
- // Verify that a clean dyndep file can depend on a dirty dyndep file
- // and be loaded properly after the dirty one is built and loaded.
- ASSERT_NO_FATAL_FAILURE(AssertParse(&state_,
-"rule touch\n"
-" command = touch $out $out.imp\n"
-"rule cp\n"
-" command = cp $in $out\n"
-"build dd1: cp dd1-in\n"
-"build out1 | out1.imp: touch || dd1\n"
-" dyndep = dd1\n"
-"build dd2: cp dd2-in || dd1\n" // direct order-only dep on dd1
-"build out2: touch || dd2\n"
-" dyndep = dd2\n"
-));
- fs_.Create("out1.imp", "");
- fs_.Create("out2", "");
- fs_.Create("out2.imp", "");
- fs_.Create("dd1-in",
-"ninja_dyndep_version = 1\n"
-"build out1: dyndep\n"
-);
- fs_.Create("dd2-in", "");
- fs_.Create("dd2",
-"ninja_dyndep_version = 1\n"
-"build out2 | out2.imp: dyndep | out1.imp\n"
-);
-
- // During the build dd1 should be built and loaded. The RecomputeDirty
- // called as a result of loading dd1 should not cause dd2 to be loaded
- // because the builder will never get a chance to update the build plan
- // to account for dd2. Instead dd2 should only be later loaded once the
- // builder recognizes that it is now ready (as its order-only dependency
- // on dd1 has been satisfied). This test case verifies that each dyndep
- // file is loaded to update the build graph independently.
-
- string err;
- EXPECT_TRUE(builder_.AddTarget("out2", &err));
- ASSERT_EQ("", err);
- EXPECT_TRUE(builder_.Build(&err));
- EXPECT_EQ("", err);
- ASSERT_EQ(3u, command_runner_.commands_ran_.size());
- EXPECT_EQ("cp dd1-in dd1", command_runner_.commands_ran_[0]);
- EXPECT_EQ("touch out1 out1.imp", command_runner_.commands_ran_[1]);
- EXPECT_EQ("touch out2 out2.imp", command_runner_.commands_ran_[2]);
-}
-
-TEST_F(BuildTest, DyndepTwoLevelIndirect) {
- // Verify that dyndep files can add to an edge new implicit inputs that
- // correspond to implicit outputs added to other edges by other dyndep
- // files on which they (order-only) depend.
- ASSERT_NO_FATAL_FAILURE(AssertParse(&state_,
-"rule touch\n"
-" command = touch $out $out.imp\n"
-"rule cp\n"
-" command = cp $in $out\n"
-"build dd1: cp dd1-in\n"
-"build out1: touch || dd1\n"
-" dyndep = dd1\n"
-"build dd2: cp dd2-in || out1\n" // indirect order-only dep on dd1
-"build out2: touch || dd2\n"
-" dyndep = dd2\n"
-));
- fs_.Create("out1.imp", "");
- fs_.Create("out2", "");
- fs_.Create("out2.imp", "");
- fs_.Create("dd1-in",
-"ninja_dyndep_version = 1\n"
-"build out1 | out1.imp: dyndep\n"
-);
- fs_.Create("dd2-in", "");
- fs_.Create("dd2",
-"ninja_dyndep_version = 1\n"
-"build out2 | out2.imp: dyndep | out1.imp\n"
-);
-
- // During the build dd1 should be built and loaded. Then dd2 should
- // be built and loaded. Loading dd2 should cause the builder to
- // recognize that out2 needs to be built even though it was originally
- // clean without dyndep info.
-
- string err;
- EXPECT_TRUE(builder_.AddTarget("out2", &err));
- ASSERT_EQ("", err);
- EXPECT_TRUE(builder_.Build(&err));
- EXPECT_EQ("", err);
- ASSERT_EQ(3u, command_runner_.commands_ran_.size());
- EXPECT_EQ("cp dd1-in dd1", command_runner_.commands_ran_[0]);
- EXPECT_EQ("touch out1 out1.imp", command_runner_.commands_ran_[1]);
- EXPECT_EQ("touch out2 out2.imp", command_runner_.commands_ran_[2]);
-}
-
-TEST_F(BuildTest, DyndepTwoLevelDiscoveredReady) {
- // Verify that a dyndep file can discover a new input whose
- // edge also has a dyndep file that is ready to load immediately.
- ASSERT_NO_FATAL_FAILURE(AssertParse(&state_,
-"rule touch\n"
-" command = touch $out\n"
-"rule cp\n"
-" command = cp $in $out\n"
-"build dd0: cp dd0-in\n"
-"build dd1: cp dd1-in\n"
-"build in: touch\n"
-"build tmp: touch || dd0\n"
-" dyndep = dd0\n"
-"build out: touch || dd1\n"
-" dyndep = dd1\n"
- ));
- fs_.Create("dd1-in",
-"ninja_dyndep_version = 1\n"
-"build out: dyndep | tmp\n"
-);
- fs_.Create("dd0-in", "");
- fs_.Create("dd0",
-"ninja_dyndep_version = 1\n"
-"build tmp: dyndep | in\n"
-);
- fs_.Tick();
- fs_.Create("out", "");
-
- string err;
- EXPECT_TRUE(builder_.AddTarget("out", &err));
- EXPECT_EQ("", err);
-
- EXPECT_TRUE(builder_.Build(&err));
- EXPECT_EQ("", err);
- ASSERT_EQ(4u, command_runner_.commands_ran_.size());
- EXPECT_EQ("cp dd1-in dd1", command_runner_.commands_ran_[0]);
- EXPECT_EQ("touch in", command_runner_.commands_ran_[1]);
- EXPECT_EQ("touch tmp", command_runner_.commands_ran_[2]);
- EXPECT_EQ("touch out", command_runner_.commands_ran_[3]);
-}
-
-TEST_F(BuildTest, DyndepTwoLevelDiscoveredDirty) {
- // Verify that a dyndep file can discover a new input whose
- // edge also has a dyndep file that needs to be built.
- ASSERT_NO_FATAL_FAILURE(AssertParse(&state_,
-"rule touch\n"
-" command = touch $out\n"
-"rule cp\n"
-" command = cp $in $out\n"
-"build dd0: cp dd0-in\n"
-"build dd1: cp dd1-in\n"
-"build in: touch\n"
-"build tmp: touch || dd0\n"
-" dyndep = dd0\n"
-"build out: touch || dd1\n"
-" dyndep = dd1\n"
- ));
- fs_.Create("dd1-in",
-"ninja_dyndep_version = 1\n"
-"build out: dyndep | tmp\n"
-);
- fs_.Create("dd0-in",
-"ninja_dyndep_version = 1\n"
-"build tmp: dyndep | in\n"
-);
- fs_.Tick();
- fs_.Create("out", "");
-
- string err;
- EXPECT_TRUE(builder_.AddTarget("out", &err));
- EXPECT_EQ("", err);
-
- EXPECT_TRUE(builder_.Build(&err));
- EXPECT_EQ("", err);
- ASSERT_EQ(5u, command_runner_.commands_ran_.size());
- EXPECT_EQ("cp dd1-in dd1", command_runner_.commands_ran_[0]);
- EXPECT_EQ("cp dd0-in dd0", command_runner_.commands_ran_[1]);
- EXPECT_EQ("touch in", command_runner_.commands_ran_[2]);
- EXPECT_EQ("touch tmp", command_runner_.commands_ran_[3]);
- EXPECT_EQ("touch out", command_runner_.commands_ran_[4]);
-}
-
-TEST_F(BuildTest, Validation) {
- ASSERT_NO_FATAL_FAILURE(AssertParse(&state_,
- "build out: cat in |@ validate\n"
- "build validate: cat in2\n"));
-
- fs_.Create("in", "");
- fs_.Create("in2", "");
-
- string err;
- EXPECT_TRUE(builder_.AddTarget("out", &err));
- EXPECT_EQ("", err);
-
- EXPECT_TRUE(builder_.Build(&err));
- EXPECT_EQ("", err);
-
- EXPECT_EQ(2u, command_runner_.commands_ran_.size());
-
- // Test touching "in" only rebuilds "out" ("validate" doesn't depend on
- // "out").
- fs_.Tick();
- fs_.Create("in", "");
-
- err.clear();
- command_runner_.commands_ran_.clear();
- state_.Reset();
- EXPECT_TRUE(builder_.AddTarget("out", &err));
- ASSERT_EQ("", err);
-
- EXPECT_TRUE(builder_.Build(&err));
- EXPECT_EQ("", err);
-
- ASSERT_EQ(1u, command_runner_.commands_ran_.size());
- EXPECT_EQ("cat in > out", command_runner_.commands_ran_[0]);
-
- // Test touching "in2" only rebuilds "validate" ("out" doesn't depend on
- // "validate").
- fs_.Tick();
- fs_.Create("in2", "");
-
- err.clear();
- command_runner_.commands_ran_.clear();
- state_.Reset();
- EXPECT_TRUE(builder_.AddTarget("out", &err));
- ASSERT_EQ("", err);
-
- EXPECT_TRUE(builder_.Build(&err));
- EXPECT_EQ("", err);
-
- ASSERT_EQ(1u, command_runner_.commands_ran_.size());
- EXPECT_EQ("cat in2 > validate", command_runner_.commands_ran_[0]);
-}
-
-TEST_F(BuildTest, ValidationDependsOnOutput) {
- ASSERT_NO_FATAL_FAILURE(AssertParse(&state_,
- "build out: cat in |@ validate\n"
- "build validate: cat in2 | out\n"));
-
- fs_.Create("in", "");
- fs_.Create("in2", "");
-
- string err;
- EXPECT_TRUE(builder_.AddTarget("out", &err));
- EXPECT_EQ("", err);
-
- EXPECT_TRUE(builder_.Build(&err));
- EXPECT_EQ("", err);
-
- EXPECT_EQ(2u, command_runner_.commands_ran_.size());
-
- // Test touching "in" rebuilds "out" and "validate".
- fs_.Tick();
- fs_.Create("in", "");
-
- err.clear();
- command_runner_.commands_ran_.clear();
- state_.Reset();
- EXPECT_TRUE(builder_.AddTarget("out", &err));
- ASSERT_EQ("", err);
-
- EXPECT_TRUE(builder_.Build(&err));
- EXPECT_EQ("", err);
-
- EXPECT_EQ(2u, command_runner_.commands_ran_.size());
-
- // Test touching "in2" only rebuilds "validate" ("out" doesn't depend on
- // "validate").
- fs_.Tick();
- fs_.Create("in2", "");
-
- err.clear();
- command_runner_.commands_ran_.clear();
- state_.Reset();
- EXPECT_TRUE(builder_.AddTarget("out", &err));
- ASSERT_EQ("", err);
-
- EXPECT_TRUE(builder_.Build(&err));
- EXPECT_EQ("", err);
-
- ASSERT_EQ(1u, command_runner_.commands_ran_.size());
- EXPECT_EQ("cat in2 > validate", command_runner_.commands_ran_[0]);
-}
-
-TEST_F(BuildWithDepsLogTest, ValidationThroughDepfile) {
- const char* manifest =
- "build out: cat in |@ validate\n"
- "build validate: cat in2 | out\n"
- "build out2: cat in3\n"
- " deps = gcc\n"
- " depfile = out2.d\n";
-
- string err;
-
- {
- fs_.Create("in", "");
- fs_.Create("in2", "");
- fs_.Create("in3", "");
- fs_.Create("out2.d", "out: out");
-
- State state;
- ASSERT_NO_FATAL_FAILURE(AddCatRule(&state));
- ASSERT_NO_FATAL_FAILURE(AssertParse(&state, manifest));
-
- DepsLog deps_log;
- ASSERT_TRUE(deps_log.OpenForWrite("ninja_deps", &err));
- ASSERT_EQ("", err);
-
- Builder builder(&state, config_, NULL, &deps_log, &fs_, &status_, 0);
- builder.command_runner_.reset(&command_runner_);
-
- EXPECT_TRUE(builder.AddTarget("out2", &err));
- ASSERT_EQ("", err);
-
- EXPECT_TRUE(builder.Build(&err));
- EXPECT_EQ("", err);
-
- // On the first build, only the out2 command is run.
- ASSERT_EQ(command_runner_.commands_ran_.size(), 1);
- EXPECT_EQ("cat in3 > out2", command_runner_.commands_ran_[0]);
-
- // The deps file should have been removed.
- EXPECT_EQ(0, fs_.Stat("out2.d", &err));
-
- deps_log.Close();
- builder.command_runner_.release();
- }
-
- fs_.Tick();
- command_runner_.commands_ran_.clear();
-
- {
- fs_.Create("in2", "");
- fs_.Create("in3", "");
-
- State state;
- ASSERT_NO_FATAL_FAILURE(AddCatRule(&state));
- ASSERT_NO_FATAL_FAILURE(AssertParse(&state, manifest));
-
- DepsLog deps_log;
- ASSERT_TRUE(deps_log.Load("ninja_deps", &state, &err));
- ASSERT_TRUE(deps_log.OpenForWrite("ninja_deps", &err));
- ASSERT_EQ("", err);
-
- Builder builder(&state, config_, NULL, &deps_log, &fs_, &status_, 0);
- builder.command_runner_.reset(&command_runner_);
-
- EXPECT_TRUE(builder.AddTarget("out2", &err));
- ASSERT_EQ("", err);
-
- EXPECT_TRUE(builder.Build(&err));
- EXPECT_EQ("", err);
-
- // The out and validate actions should have been run as well as out2.
- ASSERT_EQ(command_runner_.commands_ran_.size(), 3);
- // out has to run first, as both out2 and validate depend on it.
- EXPECT_EQ("cat in > out", command_runner_.commands_ran_[0]);
-
- deps_log.Close();
- builder.command_runner_.release();
- }
-}
-
-TEST_F(BuildTest, ValidationCircular) {
- ASSERT_NO_FATAL_FAILURE(AssertParse(&state_,
- "build out: cat in |@ out2\n"
- "build out2: cat in2 |@ out\n"));
-
- fs_.Create("in", "");
- fs_.Create("in2", "");
-
- string err;
- EXPECT_TRUE(builder_.AddTarget("out", &err));
- EXPECT_EQ("", err);
-
- EXPECT_TRUE(builder_.Build(&err));
- EXPECT_EQ("", err);
-
- EXPECT_EQ(2u, command_runner_.commands_ran_.size());
-
- // Test touching "in" rebuilds "out".
- fs_.Tick();
- fs_.Create("in", "");
-
- err.clear();
- command_runner_.commands_ran_.clear();
- state_.Reset();
- EXPECT_TRUE(builder_.AddTarget("out", &err));
- ASSERT_EQ("", err);
-
- EXPECT_TRUE(builder_.Build(&err));
- EXPECT_EQ("", err);
-
- ASSERT_EQ(1u, command_runner_.commands_ran_.size());
- EXPECT_EQ("cat in > out", command_runner_.commands_ran_[0]);
-
- // Test touching "in2" rebuilds "out2".
- fs_.Tick();
- fs_.Create("in2", "");
-
- err.clear();
- command_runner_.commands_ran_.clear();
- state_.Reset();
- EXPECT_TRUE(builder_.AddTarget("out", &err));
- ASSERT_EQ("", err);
-
- EXPECT_TRUE(builder_.Build(&err));
- EXPECT_EQ("", err);
-
- ASSERT_EQ(1u, command_runner_.commands_ran_.size());
- EXPECT_EQ("cat in2 > out2", command_runner_.commands_ran_[0]);
-}
-
-TEST_F(BuildTest, ValidationWithCircularDependency) {
- ASSERT_NO_FATAL_FAILURE(AssertParse(&state_,
- "build out: cat in |@ validate\n"
- "build validate: cat validate_in | out\n"
- "build validate_in: cat validate\n"));
-
- fs_.Create("in", "");
-
- string err;
- EXPECT_FALSE(builder_.AddTarget("out", &err));
- EXPECT_EQ("dependency cycle: validate -> validate_in -> validate", err);
-}
diff --git a/src/canon_perftest.cc b/src/canon_perftest.cc
deleted file mode 100644
index 6b5e382..0000000
--- a/src/canon_perftest.cc
+++ /dev/null
@@ -1,58 +0,0 @@
-// Copyright 2012 Google Inc. All Rights Reserved.
-//
-// Licensed under the Apache License, Version 2.0 (the "License");
-// you may not use this file except in compliance with the License.
-// You may obtain a copy of the License at
-//
-// http://www.apache.org/licenses/LICENSE-2.0
-//
-// Unless required by applicable law or agreed to in writing, software
-// distributed under the License is distributed on an "AS IS" BASIS,
-// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-// See the License for the specific language governing permissions and
-// limitations under the License.
-
-#include <stdio.h>
-#include <string.h>
-
-#include "util.h"
-#include "metrics.h"
-
-using namespace std;
-
-const char kPath[] =
- "../../third_party/WebKit/Source/WebCore/"
- "platform/leveldb/LevelDBWriteBatch.cpp";
-
-int main() {
- vector<int> times;
-
- char buf[200];
- size_t len = strlen(kPath);
- strcpy(buf, kPath);
-
- for (int j = 0; j < 5; ++j) {
- const int kNumRepetitions = 2000000;
- int64_t start = GetTimeMillis();
- uint64_t slash_bits;
- for (int i = 0; i < kNumRepetitions; ++i) {
- CanonicalizePath(buf, &len, &slash_bits);
- }
- int delta = (int)(GetTimeMillis() - start);
- times.push_back(delta);
- }
-
- int min = times[0];
- int max = times[0];
- float total = 0;
- for (size_t i = 0; i < times.size(); ++i) {
- total += times[i];
- if (times[i] < min)
- min = times[i];
- else if (times[i] > max)
- max = times[i];
- }
-
- printf("min %dms max %dms avg %.1fms\n",
- min, max, total / times.size());
-}
diff --git a/src/clean.cc b/src/clean.cc
deleted file mode 100644
index e48eb8e..0000000
--- a/src/clean.cc
+++ /dev/null
@@ -1,302 +0,0 @@
-// Copyright 2011 Google Inc. All Rights Reserved.
-//
-// Licensed under the Apache License, Version 2.0 (the "License");
-// you may not use this file except in compliance with the License.
-// You may obtain a copy of the License at
-//
-// http://www.apache.org/licenses/LICENSE-2.0
-//
-// Unless required by applicable law or agreed to in writing, software
-// distributed under the License is distributed on an "AS IS" BASIS,
-// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-// See the License for the specific language governing permissions and
-// limitations under the License.
-
-#include "clean.h"
-
-#include <assert.h>
-#include <stdio.h>
-
-#include "disk_interface.h"
-#include "graph.h"
-#include "state.h"
-#include "util.h"
-
-using namespace std;
-
-Cleaner::Cleaner(State* state,
- const BuildConfig& config,
- DiskInterface* disk_interface)
- : state_(state),
- config_(config),
- dyndep_loader_(state, disk_interface),
- cleaned_files_count_(0),
- disk_interface_(disk_interface),
- status_(0) {
-}
-
-int Cleaner::RemoveFile(const string& path) {
- return disk_interface_->RemoveFile(path);
-}
-
-bool Cleaner::FileExists(const string& path) {
- string err;
- TimeStamp mtime = disk_interface_->Stat(path, &err);
- if (mtime == -1)
- Error("%s", err.c_str());
- return mtime > 0; // Treat Stat() errors as "file does not exist".
-}
-
-void Cleaner::Report(const string& path) {
- ++cleaned_files_count_;
- if (IsVerbose())
- printf("Remove %s\n", path.c_str());
-}
-
-void Cleaner::Remove(const string& path) {
- if (!IsAlreadyRemoved(path)) {
- removed_.insert(path);
- if (config_.dry_run) {
- if (FileExists(path))
- Report(path);
- } else {
- int ret = RemoveFile(path);
- if (ret == 0)
- Report(path);
- else if (ret == -1)
- status_ = 1;
- }
- }
-}
-
-bool Cleaner::IsAlreadyRemoved(const string& path) {
- set<string>::iterator i = removed_.find(path);
- return (i != removed_.end());
-}
-
-void Cleaner::RemoveEdgeFiles(Edge* edge) {
- string depfile = edge->GetUnescapedDepfile();
- if (!depfile.empty())
- Remove(depfile);
-
- string rspfile = edge->GetUnescapedRspfile();
- if (!rspfile.empty())
- Remove(rspfile);
-}
-
-void Cleaner::PrintHeader() {
- if (config_.verbosity == BuildConfig::QUIET)
- return;
- printf("Cleaning...");
- if (IsVerbose())
- printf("\n");
- else
- printf(" ");
- fflush(stdout);
-}
-
-void Cleaner::PrintFooter() {
- if (config_.verbosity == BuildConfig::QUIET)
- return;
- printf("%d files.\n", cleaned_files_count_);
-}
-
-int Cleaner::CleanAll(bool generator) {
- Reset();
- PrintHeader();
- LoadDyndeps();
- for (vector<Edge*>::iterator e = state_->edges_.begin();
- e != state_->edges_.end(); ++e) {
- // Do not try to remove phony targets
- if ((*e)->is_phony())
- continue;
- // Do not remove generator's files unless generator specified.
- if (!generator && (*e)->is_generator())
- continue;
- for (vector<Node*>::iterator out_node = (*e)->outputs_.begin();
- out_node != (*e)->outputs_.end(); ++out_node) {
- Remove((*out_node)->path());
- }
-
- RemoveEdgeFiles(*e);
- }
- PrintFooter();
- return status_;
-}
-
-int Cleaner::CleanDead(const BuildLog::Entries& entries) {
- Reset();
- PrintHeader();
- for (BuildLog::Entries::const_iterator i = entries.begin(); i != entries.end(); ++i) {
- Node* n = state_->LookupNode(i->first);
- // Detecting stale outputs works as follows:
- //
- // - If it has no Node, it is not in the build graph, or the deps log
- // anymore, hence is stale.
- //
- // - If it isn't an output or input for any edge, it comes from a stale
- // entry in the deps log, but no longer referenced from the build
- // graph.
- //
- if (!n || (!n->in_edge() && n->out_edges().empty())) {
- Remove(i->first.AsString());
- }
- }
- PrintFooter();
- return status_;
-}
-
-void Cleaner::DoCleanTarget(Node* target) {
- if (Edge* e = target->in_edge()) {
- // Do not try to remove phony targets
- if (!e->is_phony()) {
- Remove(target->path());
- RemoveEdgeFiles(e);
- }
- for (vector<Node*>::iterator n = e->inputs_.begin(); n != e->inputs_.end();
- ++n) {
- Node* next = *n;
- // call DoCleanTarget recursively if this node has not been visited
- if (cleaned_.count(next) == 0) {
- DoCleanTarget(next);
- }
- }
- }
-
- // mark this target to be cleaned already
- cleaned_.insert(target);
-}
-
-int Cleaner::CleanTarget(Node* target) {
- assert(target);
-
- Reset();
- PrintHeader();
- LoadDyndeps();
- DoCleanTarget(target);
- PrintFooter();
- return status_;
-}
-
-int Cleaner::CleanTarget(const char* target) {
- assert(target);
-
- Reset();
- Node* node = state_->LookupNode(target);
- if (node) {
- CleanTarget(node);
- } else {
- Error("unknown target '%s'", target);
- status_ = 1;
- }
- return status_;
-}
-
-int Cleaner::CleanTargets(int target_count, char* targets[]) {
- Reset();
- PrintHeader();
- LoadDyndeps();
- for (int i = 0; i < target_count; ++i) {
- string target_name = targets[i];
- if (target_name.empty()) {
- Error("failed to canonicalize '': empty path");
- status_ = 1;
- continue;
- }
- uint64_t slash_bits;
- CanonicalizePath(&target_name, &slash_bits);
- Node* target = state_->LookupNode(target_name);
- if (target) {
- if (IsVerbose())
- printf("Target %s\n", target_name.c_str());
- DoCleanTarget(target);
- } else {
- Error("unknown target '%s'", target_name.c_str());
- status_ = 1;
- }
- }
- PrintFooter();
- return status_;
-}
-
-void Cleaner::DoCleanRule(const Rule* rule) {
- assert(rule);
-
- for (vector<Edge*>::iterator e = state_->edges_.begin();
- e != state_->edges_.end(); ++e) {
- if ((*e)->rule().name() == rule->name()) {
- for (vector<Node*>::iterator out_node = (*e)->outputs_.begin();
- out_node != (*e)->outputs_.end(); ++out_node) {
- Remove((*out_node)->path());
- RemoveEdgeFiles(*e);
- }
- }
- }
-}
-
-int Cleaner::CleanRule(const Rule* rule) {
- assert(rule);
-
- Reset();
- PrintHeader();
- LoadDyndeps();
- DoCleanRule(rule);
- PrintFooter();
- return status_;
-}
-
-int Cleaner::CleanRule(const char* rule) {
- assert(rule);
-
- Reset();
- const Rule* r = state_->bindings().LookupRule(rule);
- if (r) {
- CleanRule(r);
- } else {
- Error("unknown rule '%s'", rule);
- status_ = 1;
- }
- return status_;
-}
-
-int Cleaner::CleanRules(int rule_count, char* rules[]) {
- assert(rules);
-
- Reset();
- PrintHeader();
- LoadDyndeps();
- for (int i = 0; i < rule_count; ++i) {
- const char* rule_name = rules[i];
- const Rule* rule = state_->bindings().LookupRule(rule_name);
- if (rule) {
- if (IsVerbose())
- printf("Rule %s\n", rule_name);
- DoCleanRule(rule);
- } else {
- Error("unknown rule '%s'", rule_name);
- status_ = 1;
- }
- }
- PrintFooter();
- return status_;
-}
-
-void Cleaner::Reset() {
- status_ = 0;
- cleaned_files_count_ = 0;
- removed_.clear();
- cleaned_.clear();
-}
-
-void Cleaner::LoadDyndeps() {
- // Load dyndep files that exist, before they are cleaned.
- for (vector<Edge*>::iterator e = state_->edges_.begin();
- e != state_->edges_.end(); ++e) {
- if (Node* dyndep = (*e)->dyndep_) {
- // Capture and ignore errors loading the dyndep file.
- // We clean as much of the graph as we know.
- std::string err;
- dyndep_loader_.LoadDyndeps(dyndep, &err);
- }
- }
-}
diff --git a/src/clean.h b/src/clean.h
deleted file mode 100644
index 0ff1221..0000000
--- a/src/clean.h
+++ /dev/null
@@ -1,111 +0,0 @@
-// Copyright 2011 Google Inc. All Rights Reserved.
-//
-// Licensed under the Apache License, Version 2.0 (the "License");
-// you may not use this file except in compliance with the License.
-// You may obtain a copy of the License at
-//
-// http://www.apache.org/licenses/LICENSE-2.0
-//
-// Unless required by applicable law or agreed to in writing, software
-// distributed under the License is distributed on an "AS IS" BASIS,
-// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-// See the License for the specific language governing permissions and
-// limitations under the License.
-
-#ifndef NINJA_CLEAN_H_
-#define NINJA_CLEAN_H_
-
-#include <set>
-#include <string>
-
-#include "build_config.h"
-#include "build_log.h"
-#include "dyndep.h"
-
-struct State;
-struct Node;
-struct Rule;
-struct DiskInterface;
-
-struct Cleaner {
- /// Build a cleaner object with the given @a disk_interface
- Cleaner(State* state,
- const BuildConfig& config,
- DiskInterface* disk_interface);
-
- /// Clean the given @a target and all the file built for it.
- /// @return non-zero if an error occurs.
- int CleanTarget(Node* target);
- /// Clean the given target @a target.
- /// @return non-zero if an error occurs.
- int CleanTarget(const char* target);
- /// Clean the given target @a targets.
- /// @return non-zero if an error occurs.
- int CleanTargets(int target_count, char* targets[]);
-
- /// Clean all built files, except for files created by generator rules.
- /// @param generator If set, also clean files created by generator rules.
- /// @return non-zero if an error occurs.
- int CleanAll(bool generator = false);
-
- /// Clean all the file built with the given rule @a rule.
- /// @return non-zero if an error occurs.
- int CleanRule(const Rule* rule);
- /// Clean the file produced by the given @a rule.
- /// @return non-zero if an error occurs.
- int CleanRule(const char* rule);
- /// Clean the file produced by the given @a rules.
- /// @return non-zero if an error occurs.
- int CleanRules(int rule_count, char* rules[]);
- /// Clean the files produced by previous builds that are no longer in the
- /// manifest.
- /// @return non-zero if an error occurs.
- int CleanDead(const BuildLog::Entries& entries);
-
- /// @return the number of file cleaned.
- int cleaned_files_count() const {
- return cleaned_files_count_;
- }
-
- /// @return whether the cleaner is in verbose mode.
- bool IsVerbose() const {
- return (config_.verbosity != BuildConfig::QUIET
- && (config_.verbosity == BuildConfig::VERBOSE || config_.dry_run));
- }
-
- private:
- /// Remove the file @a path.
- /// @return whether the file has been removed.
- int RemoveFile(const std::string& path);
- /// @returns whether the file @a path exists.
- bool FileExists(const std::string& path);
- void Report(const std::string& path);
-
- /// Remove the given @a path file only if it has not been already removed.
- void Remove(const std::string& path);
- /// @return whether the given @a path has already been removed.
- bool IsAlreadyRemoved(const std::string& path);
- /// Remove the depfile and rspfile for an Edge.
- void RemoveEdgeFiles(Edge* edge);
-
- /// Helper recursive method for CleanTarget().
- void DoCleanTarget(Node* target);
- void PrintHeader();
- void PrintFooter();
- void DoCleanRule(const Rule* rule);
- void Reset();
-
- /// Load dependencies from dyndep bindings.
- void LoadDyndeps();
-
- State* state_;
- const BuildConfig& config_;
- DyndepLoader dyndep_loader_;
- std::set<std::string> removed_;
- std::set<Node*> cleaned_;
- int cleaned_files_count_;
- DiskInterface* disk_interface_;
- int status_;
-};
-
-#endif // NINJA_CLEAN_H_
diff --git a/src/clean_test.cc b/src/clean_test.cc
deleted file mode 100644
index e99909c..0000000
--- a/src/clean_test.cc
+++ /dev/null
@@ -1,601 +0,0 @@
-// Copyright 2011 Google Inc. All Rights Reserved.
-//
-// Licensed under the Apache License, Version 2.0 (the "License");
-// you may not use this file except in compliance with the License.
-// You may obtain a copy of the License at
-//
-// http://www.apache.org/licenses/LICENSE-2.0
-//
-// Unless required by applicable law or agreed to in writing, software
-// distributed under the License is distributed on an "AS IS" BASIS,
-// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-// See the License for the specific language governing permissions and
-// limitations under the License.
-
-#include "clean.h"
-#include "build.h"
-
-#include "util.h"
-#include "test.h"
-
-#ifndef _WIN32
-#include <unistd.h>
-#endif
-
-using namespace std;
-
-namespace {
-
-const char kTestFilename[] = "CleanTest-tempfile";
-
-struct CleanTest : public StateTestWithBuiltinRules {
- VirtualFileSystem fs_;
- BuildConfig config_;
- virtual void SetUp() {
- config_.verbosity = BuildConfig::QUIET;
- }
-};
-
-TEST_F(CleanTest, CleanAll) {
- ASSERT_NO_FATAL_FAILURE(AssertParse(&state_,
-"build in1: cat src1\n"
-"build out1: cat in1\n"
-"build in2: cat src2\n"
-"build out2: cat in2\n"));
- fs_.Create("in1", "");
- fs_.Create("out1", "");
- fs_.Create("in2", "");
- fs_.Create("out2", "");
-
- Cleaner cleaner(&state_, config_, &fs_);
-
- ASSERT_EQ(0, cleaner.cleaned_files_count());
- EXPECT_EQ(0, cleaner.CleanAll());
- EXPECT_EQ(4, cleaner.cleaned_files_count());
- EXPECT_EQ(4u, fs_.files_removed_.size());
-
- // Check they are removed.
- string err;
- EXPECT_EQ(0, fs_.Stat("in1", &err));
- EXPECT_EQ(0, fs_.Stat("out1", &err));
- EXPECT_EQ(0, fs_.Stat("in2", &err));
- EXPECT_EQ(0, fs_.Stat("out2", &err));
- fs_.files_removed_.clear();
-
- EXPECT_EQ(0, cleaner.CleanAll());
- EXPECT_EQ(0, cleaner.cleaned_files_count());
- EXPECT_EQ(0u, fs_.files_removed_.size());
-}
-
-TEST_F(CleanTest, CleanAllDryRun) {
- ASSERT_NO_FATAL_FAILURE(AssertParse(&state_,
-"build in1: cat src1\n"
-"build out1: cat in1\n"
-"build in2: cat src2\n"
-"build out2: cat in2\n"));
- fs_.Create("in1", "");
- fs_.Create("out1", "");
- fs_.Create("in2", "");
- fs_.Create("out2", "");
-
- config_.dry_run = true;
- Cleaner cleaner(&state_, config_, &fs_);
-
- ASSERT_EQ(0, cleaner.cleaned_files_count());
- EXPECT_EQ(0, cleaner.CleanAll());
- EXPECT_EQ(4, cleaner.cleaned_files_count());
- EXPECT_EQ(0u, fs_.files_removed_.size());
-
- // Check they are not removed.
- string err;
- EXPECT_LT(0, fs_.Stat("in1", &err));
- EXPECT_LT(0, fs_.Stat("out1", &err));
- EXPECT_LT(0, fs_.Stat("in2", &err));
- EXPECT_LT(0, fs_.Stat("out2", &err));
- fs_.files_removed_.clear();
-
- EXPECT_EQ(0, cleaner.CleanAll());
- EXPECT_EQ(4, cleaner.cleaned_files_count());
- EXPECT_EQ(0u, fs_.files_removed_.size());
-}
-
-TEST_F(CleanTest, CleanTarget) {
- ASSERT_NO_FATAL_FAILURE(AssertParse(&state_,
-"build in1: cat src1\n"
-"build out1: cat in1\n"
-"build in2: cat src2\n"
-"build out2: cat in2\n"));
- fs_.Create("in1", "");
- fs_.Create("out1", "");
- fs_.Create("in2", "");
- fs_.Create("out2", "");
-
- Cleaner cleaner(&state_, config_, &fs_);
-
- ASSERT_EQ(0, cleaner.cleaned_files_count());
- ASSERT_EQ(0, cleaner.CleanTarget("out1"));
- EXPECT_EQ(2, cleaner.cleaned_files_count());
- EXPECT_EQ(2u, fs_.files_removed_.size());
-
- // Check they are removed.
- string err;
- EXPECT_EQ(0, fs_.Stat("in1", &err));
- EXPECT_EQ(0, fs_.Stat("out1", &err));
- EXPECT_LT(0, fs_.Stat("in2", &err));
- EXPECT_LT(0, fs_.Stat("out2", &err));
- fs_.files_removed_.clear();
-
- ASSERT_EQ(0, cleaner.CleanTarget("out1"));
- EXPECT_EQ(0, cleaner.cleaned_files_count());
- EXPECT_EQ(0u, fs_.files_removed_.size());
-}
-
-TEST_F(CleanTest, CleanTargetDryRun) {
- ASSERT_NO_FATAL_FAILURE(AssertParse(&state_,
-"build in1: cat src1\n"
-"build out1: cat in1\n"
-"build in2: cat src2\n"
-"build out2: cat in2\n"));
- fs_.Create("in1", "");
- fs_.Create("out1", "");
- fs_.Create("in2", "");
- fs_.Create("out2", "");
-
- config_.dry_run = true;
- Cleaner cleaner(&state_, config_, &fs_);
-
- ASSERT_EQ(0, cleaner.cleaned_files_count());
- ASSERT_EQ(0, cleaner.CleanTarget("out1"));
- EXPECT_EQ(2, cleaner.cleaned_files_count());
- EXPECT_EQ(0u, fs_.files_removed_.size());
-
- // Check they are not removed.
- string err;
- EXPECT_LT(0, fs_.Stat("in1", &err));
- EXPECT_LT(0, fs_.Stat("out1", &err));
- EXPECT_LT(0, fs_.Stat("in2", &err));
- EXPECT_LT(0, fs_.Stat("out2", &err));
- fs_.files_removed_.clear();
-
- ASSERT_EQ(0, cleaner.CleanTarget("out1"));
- EXPECT_EQ(2, cleaner.cleaned_files_count());
- EXPECT_EQ(0u, fs_.files_removed_.size());
-}
-
-TEST_F(CleanTest, CleanRule) {
- ASSERT_NO_FATAL_FAILURE(AssertParse(&state_,
-"rule cat_e\n"
-" command = cat -e $in > $out\n"
-"build in1: cat_e src1\n"
-"build out1: cat in1\n"
-"build in2: cat_e src2\n"
-"build out2: cat in2\n"));
- fs_.Create("in1", "");
- fs_.Create("out1", "");
- fs_.Create("in2", "");
- fs_.Create("out2", "");
-
- Cleaner cleaner(&state_, config_, &fs_);
-
- ASSERT_EQ(0, cleaner.cleaned_files_count());
- ASSERT_EQ(0, cleaner.CleanRule("cat_e"));
- EXPECT_EQ(2, cleaner.cleaned_files_count());
- EXPECT_EQ(2u, fs_.files_removed_.size());
-
- // Check they are removed.
- string err;
- EXPECT_EQ(0, fs_.Stat("in1", &err));
- EXPECT_LT(0, fs_.Stat("out1", &err));
- EXPECT_EQ(0, fs_.Stat("in2", &err));
- EXPECT_LT(0, fs_.Stat("out2", &err));
- fs_.files_removed_.clear();
-
- ASSERT_EQ(0, cleaner.CleanRule("cat_e"));
- EXPECT_EQ(0, cleaner.cleaned_files_count());
- EXPECT_EQ(0u, fs_.files_removed_.size());
-}
-
-TEST_F(CleanTest, CleanRuleDryRun) {
- ASSERT_NO_FATAL_FAILURE(AssertParse(&state_,
-"rule cat_e\n"
-" command = cat -e $in > $out\n"
-"build in1: cat_e src1\n"
-"build out1: cat in1\n"
-"build in2: cat_e src2\n"
-"build out2: cat in2\n"));
- fs_.Create("in1", "");
- fs_.Create("out1", "");
- fs_.Create("in2", "");
- fs_.Create("out2", "");
-
- config_.dry_run = true;
- Cleaner cleaner(&state_, config_, &fs_);
-
- ASSERT_EQ(0, cleaner.cleaned_files_count());
- ASSERT_EQ(0, cleaner.CleanRule("cat_e"));
- EXPECT_EQ(2, cleaner.cleaned_files_count());
- EXPECT_EQ(0u, fs_.files_removed_.size());
-
- // Check they are not removed.
- string err;
- EXPECT_LT(0, fs_.Stat("in1", &err));
- EXPECT_LT(0, fs_.Stat("out1", &err));
- EXPECT_LT(0, fs_.Stat("in2", &err));
- EXPECT_LT(0, fs_.Stat("out2", &err));
- fs_.files_removed_.clear();
-
- ASSERT_EQ(0, cleaner.CleanRule("cat_e"));
- EXPECT_EQ(2, cleaner.cleaned_files_count());
- EXPECT_EQ(0u, fs_.files_removed_.size());
-}
-
-TEST_F(CleanTest, CleanRuleGenerator) {
- ASSERT_NO_FATAL_FAILURE(AssertParse(&state_,
-"rule regen\n"
-" command = cat $in > $out\n"
-" generator = 1\n"
-"build out1: cat in1\n"
-"build out2: regen in2\n"));
- fs_.Create("out1", "");
- fs_.Create("out2", "");
-
- Cleaner cleaner(&state_, config_, &fs_);
- EXPECT_EQ(0, cleaner.CleanAll());
- EXPECT_EQ(1, cleaner.cleaned_files_count());
- EXPECT_EQ(1u, fs_.files_removed_.size());
-
- fs_.Create("out1", "");
-
- EXPECT_EQ(0, cleaner.CleanAll(/*generator=*/true));
- EXPECT_EQ(2, cleaner.cleaned_files_count());
- EXPECT_EQ(2u, fs_.files_removed_.size());
-}
-
-TEST_F(CleanTest, CleanDepFile) {
- ASSERT_NO_FATAL_FAILURE(AssertParse(&state_,
-"rule cc\n"
-" command = cc $in > $out\n"
-" depfile = $out.d\n"
-"build out1: cc in1\n"));
- fs_.Create("out1", "");
- fs_.Create("out1.d", "");
-
- Cleaner cleaner(&state_, config_, &fs_);
- EXPECT_EQ(0, cleaner.CleanAll());
- EXPECT_EQ(2, cleaner.cleaned_files_count());
- EXPECT_EQ(2u, fs_.files_removed_.size());
-}
-
-TEST_F(CleanTest, CleanDepFileOnCleanTarget) {
- ASSERT_NO_FATAL_FAILURE(AssertParse(&state_,
-"rule cc\n"
-" command = cc $in > $out\n"
-" depfile = $out.d\n"
-"build out1: cc in1\n"));
- fs_.Create("out1", "");
- fs_.Create("out1.d", "");
-
- Cleaner cleaner(&state_, config_, &fs_);
- EXPECT_EQ(0, cleaner.CleanTarget("out1"));
- EXPECT_EQ(2, cleaner.cleaned_files_count());
- EXPECT_EQ(2u, fs_.files_removed_.size());
-}
-
-TEST_F(CleanTest, CleanDepFileOnCleanRule) {
- ASSERT_NO_FATAL_FAILURE(AssertParse(&state_,
-"rule cc\n"
-" command = cc $in > $out\n"
-" depfile = $out.d\n"
-"build out1: cc in1\n"));
- fs_.Create("out1", "");
- fs_.Create("out1.d", "");
-
- Cleaner cleaner(&state_, config_, &fs_);
- EXPECT_EQ(0, cleaner.CleanRule("cc"));
- EXPECT_EQ(2, cleaner.cleaned_files_count());
- EXPECT_EQ(2u, fs_.files_removed_.size());
-}
-
-TEST_F(CleanTest, CleanDyndep) {
- // Verify that a dyndep file can be loaded to discover a new output
- // to be cleaned.
- ASSERT_NO_FATAL_FAILURE(AssertParse(&state_,
-"build out: cat in || dd\n"
-" dyndep = dd\n"
- ));
- fs_.Create("in", "");
- fs_.Create("dd",
-"ninja_dyndep_version = 1\n"
-"build out | out.imp: dyndep\n"
-);
- fs_.Create("out", "");
- fs_.Create("out.imp", "");
-
- Cleaner cleaner(&state_, config_, &fs_);
-
- ASSERT_EQ(0, cleaner.cleaned_files_count());
- EXPECT_EQ(0, cleaner.CleanAll());
- EXPECT_EQ(2, cleaner.cleaned_files_count());
- EXPECT_EQ(2u, fs_.files_removed_.size());
-
- string err;
- EXPECT_EQ(0, fs_.Stat("out", &err));
- EXPECT_EQ(0, fs_.Stat("out.imp", &err));
-}
-
-TEST_F(CleanTest, CleanDyndepMissing) {
- // Verify that a missing dyndep file is tolerated.
- ASSERT_NO_FATAL_FAILURE(AssertParse(&state_,
-"build out: cat in || dd\n"
-" dyndep = dd\n"
- ));
- fs_.Create("in", "");
- fs_.Create("out", "");
- fs_.Create("out.imp", "");
-
- Cleaner cleaner(&state_, config_, &fs_);
-
- ASSERT_EQ(0, cleaner.cleaned_files_count());
- EXPECT_EQ(0, cleaner.CleanAll());
- EXPECT_EQ(1, cleaner.cleaned_files_count());
- EXPECT_EQ(1u, fs_.files_removed_.size());
-
- string err;
- EXPECT_EQ(0, fs_.Stat("out", &err));
- EXPECT_EQ(1, fs_.Stat("out.imp", &err));
-}
-
-TEST_F(CleanTest, CleanRspFile) {
- ASSERT_NO_FATAL_FAILURE(AssertParse(&state_,
-"rule cc\n"
-" command = cc $in > $out\n"
-" rspfile = $rspfile\n"
-" rspfile_content=$in\n"
-"build out1: cc in1\n"
-" rspfile = cc1.rsp\n"));
- fs_.Create("out1", "");
- fs_.Create("cc1.rsp", "");
-
- Cleaner cleaner(&state_, config_, &fs_);
- EXPECT_EQ(0, cleaner.CleanAll());
- EXPECT_EQ(2, cleaner.cleaned_files_count());
- EXPECT_EQ(2u, fs_.files_removed_.size());
-}
-
-TEST_F(CleanTest, CleanRsp) {
- ASSERT_NO_FATAL_FAILURE(AssertParse(&state_,
-"rule cat_rsp \n"
-" command = cat $rspfile > $out\n"
-" rspfile = $rspfile\n"
-" rspfile_content = $in\n"
-"build in1: cat src1\n"
-"build out1: cat in1\n"
-"build in2: cat_rsp src2\n"
-" rspfile=in2.rsp\n"
-"build out2: cat_rsp in2\n"
-" rspfile=out2.rsp\n"
-));
- fs_.Create("in1", "");
- fs_.Create("out1", "");
- fs_.Create("in2.rsp", "");
- fs_.Create("out2.rsp", "");
- fs_.Create("in2", "");
- fs_.Create("out2", "");
-
- Cleaner cleaner(&state_, config_, &fs_);
- ASSERT_EQ(0, cleaner.cleaned_files_count());
- ASSERT_EQ(0, cleaner.CleanTarget("out1"));
- EXPECT_EQ(2, cleaner.cleaned_files_count());
- ASSERT_EQ(0, cleaner.CleanTarget("in2"));
- EXPECT_EQ(2, cleaner.cleaned_files_count());
- ASSERT_EQ(0, cleaner.CleanRule("cat_rsp"));
- EXPECT_EQ(2, cleaner.cleaned_files_count());
-
- EXPECT_EQ(6u, fs_.files_removed_.size());
-
- // Check they are removed.
- string err;
- EXPECT_EQ(0, fs_.Stat("in1", &err));
- EXPECT_EQ(0, fs_.Stat("out1", &err));
- EXPECT_EQ(0, fs_.Stat("in2", &err));
- EXPECT_EQ(0, fs_.Stat("out2", &err));
- EXPECT_EQ(0, fs_.Stat("in2.rsp", &err));
- EXPECT_EQ(0, fs_.Stat("out2.rsp", &err));
-}
-
-TEST_F(CleanTest, CleanFailure) {
- ASSERT_NO_FATAL_FAILURE(AssertParse(&state_,
- "build dir: cat src1\n"));
- fs_.MakeDir("dir");
- Cleaner cleaner(&state_, config_, &fs_);
- EXPECT_NE(0, cleaner.CleanAll());
-}
-
-TEST_F(CleanTest, CleanPhony) {
- string err;
- ASSERT_NO_FATAL_FAILURE(AssertParse(&state_,
-"build phony: phony t1 t2\n"
-"build t1: cat\n"
-"build t2: cat\n"));
-
- fs_.Create("phony", "");
- fs_.Create("t1", "");
- fs_.Create("t2", "");
-
- // Check that CleanAll does not remove "phony".
- Cleaner cleaner(&state_, config_, &fs_);
- EXPECT_EQ(0, cleaner.CleanAll());
- EXPECT_EQ(2, cleaner.cleaned_files_count());
- EXPECT_LT(0, fs_.Stat("phony", &err));
-
- fs_.Create("t1", "");
- fs_.Create("t2", "");
-
- // Check that CleanTarget does not remove "phony".
- EXPECT_EQ(0, cleaner.CleanTarget("phony"));
- EXPECT_EQ(2, cleaner.cleaned_files_count());
- EXPECT_LT(0, fs_.Stat("phony", &err));
-}
-
-TEST_F(CleanTest, CleanDepFileAndRspFileWithSpaces) {
- ASSERT_NO_FATAL_FAILURE(AssertParse(&state_,
-"rule cc_dep\n"
-" command = cc $in > $out\n"
-" depfile = $out.d\n"
-"rule cc_rsp\n"
-" command = cc $in > $out\n"
-" rspfile = $out.rsp\n"
-" rspfile_content = $in\n"
-"build out$ 1: cc_dep in$ 1\n"
-"build out$ 2: cc_rsp in$ 1\n"
-));
- fs_.Create("out 1", "");
- fs_.Create("out 2", "");
- fs_.Create("out 1.d", "");
- fs_.Create("out 2.rsp", "");
-
- Cleaner cleaner(&state_, config_, &fs_);
- EXPECT_EQ(0, cleaner.CleanAll());
- EXPECT_EQ(4, cleaner.cleaned_files_count());
- EXPECT_EQ(4u, fs_.files_removed_.size());
-
- string err;
- EXPECT_EQ(0, fs_.Stat("out 1", &err));
- EXPECT_EQ(0, fs_.Stat("out 2", &err));
- EXPECT_EQ(0, fs_.Stat("out 1.d", &err));
- EXPECT_EQ(0, fs_.Stat("out 2.rsp", &err));
-}
-
-struct CleanDeadTest : public CleanTest, public BuildLogUser{
- virtual void SetUp() {
- // In case a crashing test left a stale file behind.
- unlink(kTestFilename);
- CleanTest::SetUp();
- }
- virtual void TearDown() {
- unlink(kTestFilename);
- }
- virtual bool IsPathDead(StringPiece) const { return false; }
-};
-
-TEST_F(CleanDeadTest, CleanDead) {
- State state;
- ASSERT_NO_FATAL_FAILURE(AssertParse(&state,
-"rule cat\n"
-" command = cat $in > $out\n"
-"build out1: cat in\n"
-"build out2: cat in\n"
-));
- ASSERT_NO_FATAL_FAILURE(AssertParse(&state_,
-"build out2: cat in\n"
-));
- fs_.Create("in", "");
- fs_.Create("out1", "");
- fs_.Create("out2", "");
-
- BuildLog log1;
- string err;
- EXPECT_TRUE(log1.OpenForWrite(kTestFilename, *this, &err));
- ASSERT_EQ("", err);
- log1.RecordCommand(state.edges_[0], 15, 18);
- log1.RecordCommand(state.edges_[1], 20, 25);
- log1.Close();
-
- BuildLog log2;
- EXPECT_TRUE(log2.Load(kTestFilename, &err));
- ASSERT_EQ("", err);
- ASSERT_EQ(2u, log2.entries().size());
- ASSERT_TRUE(log2.LookupByOutput("out1"));
- ASSERT_TRUE(log2.LookupByOutput("out2"));
-
- // First use the manifest that describe how to build out1.
- Cleaner cleaner1(&state, config_, &fs_);
- EXPECT_EQ(0, cleaner1.CleanDead(log2.entries()));
- EXPECT_EQ(0, cleaner1.cleaned_files_count());
- EXPECT_EQ(0u, fs_.files_removed_.size());
- EXPECT_NE(0, fs_.Stat("in", &err));
- EXPECT_NE(0, fs_.Stat("out1", &err));
- EXPECT_NE(0, fs_.Stat("out2", &err));
-
- // Then use the manifest that does not build out1 anymore.
- Cleaner cleaner2(&state_, config_, &fs_);
- EXPECT_EQ(0, cleaner2.CleanDead(log2.entries()));
- EXPECT_EQ(1, cleaner2.cleaned_files_count());
- EXPECT_EQ(1u, fs_.files_removed_.size());
- EXPECT_EQ("out1", *(fs_.files_removed_.begin()));
- EXPECT_NE(0, fs_.Stat("in", &err));
- EXPECT_EQ(0, fs_.Stat("out1", &err));
- EXPECT_NE(0, fs_.Stat("out2", &err));
-
- // Nothing to do now.
- EXPECT_EQ(0, cleaner2.CleanDead(log2.entries()));
- EXPECT_EQ(0, cleaner2.cleaned_files_count());
- EXPECT_EQ(1u, fs_.files_removed_.size());
- EXPECT_EQ("out1", *(fs_.files_removed_.begin()));
- EXPECT_NE(0, fs_.Stat("in", &err));
- EXPECT_EQ(0, fs_.Stat("out1", &err));
- EXPECT_NE(0, fs_.Stat("out2", &err));
- log2.Close();
-}
-
-TEST_F(CleanDeadTest, CleanDeadPreservesInputs) {
- State state;
- ASSERT_NO_FATAL_FAILURE(AssertParse(&state,
-"rule cat\n"
-" command = cat $in > $out\n"
-"build out1: cat in\n"
-"build out2: cat in\n"
-));
- // This manifest does not build out1 anymore, but makes
- // it an implicit input. CleanDead should detect this
- // and preserve it.
- ASSERT_NO_FATAL_FAILURE(AssertParse(&state_,
-"build out2: cat in | out1\n"
-));
- fs_.Create("in", "");
- fs_.Create("out1", "");
- fs_.Create("out2", "");
-
- BuildLog log1;
- string err;
- EXPECT_TRUE(log1.OpenForWrite(kTestFilename, *this, &err));
- ASSERT_EQ("", err);
- log1.RecordCommand(state.edges_[0], 15, 18);
- log1.RecordCommand(state.edges_[1], 20, 25);
- log1.Close();
-
- BuildLog log2;
- EXPECT_TRUE(log2.Load(kTestFilename, &err));
- ASSERT_EQ("", err);
- ASSERT_EQ(2u, log2.entries().size());
- ASSERT_TRUE(log2.LookupByOutput("out1"));
- ASSERT_TRUE(log2.LookupByOutput("out2"));
-
- // First use the manifest that describe how to build out1.
- Cleaner cleaner1(&state, config_, &fs_);
- EXPECT_EQ(0, cleaner1.CleanDead(log2.entries()));
- EXPECT_EQ(0, cleaner1.cleaned_files_count());
- EXPECT_EQ(0u, fs_.files_removed_.size());
- EXPECT_NE(0, fs_.Stat("in", &err));
- EXPECT_NE(0, fs_.Stat("out1", &err));
- EXPECT_NE(0, fs_.Stat("out2", &err));
-
- // Then use the manifest that does not build out1 anymore.
- Cleaner cleaner2(&state_, config_, &fs_);
- EXPECT_EQ(0, cleaner2.CleanDead(log2.entries()));
- EXPECT_EQ(0, cleaner2.cleaned_files_count());
- EXPECT_EQ(0u, fs_.files_removed_.size());
- EXPECT_NE(0, fs_.Stat("in", &err));
- EXPECT_NE(0, fs_.Stat("out1", &err));
- EXPECT_NE(0, fs_.Stat("out2", &err));
-
- // Nothing to do now.
- EXPECT_EQ(0, cleaner2.CleanDead(log2.entries()));
- EXPECT_EQ(0, cleaner2.cleaned_files_count());
- EXPECT_EQ(0u, fs_.files_removed_.size());
- EXPECT_NE(0, fs_.Stat("in", &err));
- EXPECT_NE(0, fs_.Stat("out1", &err));
- EXPECT_NE(0, fs_.Stat("out2", &err));
- log2.Close();
-}
-} // anonymous namespace
diff --git a/src/clparser.cc b/src/clparser.cc
deleted file mode 100644
index 3d3e7de..0000000
--- a/src/clparser.cc
+++ /dev/null
@@ -1,130 +0,0 @@
-// Copyright 2015 Google Inc. All Rights Reserved.
-//
-// Licensed under the Apache License, Version 2.0 (the "License");
-// you may not use this file except in compliance with the License.
-// You may obtain a copy of the License at
-//
-// http://www.apache.org/licenses/LICENSE-2.0
-//
-// Unless required by applicable law or agreed to in writing, software
-// distributed under the License is distributed on an "AS IS" BASIS,
-// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-// See the License for the specific language governing permissions and
-// limitations under the License.
-
-#include "clparser.h"
-
-#include <algorithm>
-#include <assert.h>
-#include <string.h>
-
-#include "metrics.h"
-#include "string_piece_util.h"
-
-#ifdef _WIN32
-#include "includes_normalize.h"
-#include "string_piece.h"
-#else
-#include "util.h"
-#endif
-
-using namespace std;
-
-namespace {
-
-/// Return true if \a input ends with \a needle.
-bool EndsWith(const string& input, const string& needle) {
- return (input.size() >= needle.size() &&
- input.substr(input.size() - needle.size()) == needle);
-}
-
-} // anonymous namespace
-
-// static
-string CLParser::FilterShowIncludes(const string& line,
- const string& deps_prefix) {
- const string kDepsPrefixEnglish = "Note: including file: ";
- const char* in = line.c_str();
- const char* end = in + line.size();
- const string& prefix = deps_prefix.empty() ? kDepsPrefixEnglish : deps_prefix;
- if (end - in > (int)prefix.size() &&
- memcmp(in, prefix.c_str(), (int)prefix.size()) == 0) {
- in += prefix.size();
- while (*in == ' ')
- ++in;
- return line.substr(in - line.c_str());
- }
- return "";
-}
-
-// static
-bool CLParser::IsSystemInclude(string path) {
- transform(path.begin(), path.end(), path.begin(), ToLowerASCII);
- // TODO: this is a heuristic, perhaps there's a better way?
- return (path.find("program files") != string::npos ||
- path.find("microsoft visual studio") != string::npos);
-}
-
-// static
-bool CLParser::FilterInputFilename(string line) {
- transform(line.begin(), line.end(), line.begin(), ToLowerASCII);
- // TODO: other extensions, like .asm?
- return EndsWith(line, ".c") ||
- EndsWith(line, ".cc") ||
- EndsWith(line, ".cxx") ||
- EndsWith(line, ".cpp") ||
- EndsWith(line, ".c++");
-}
-
-// static
-bool CLParser::Parse(const string& output, const string& deps_prefix,
- string* filtered_output, string* err) {
- METRIC_RECORD("CLParser::Parse");
-
- // Loop over all lines in the output to process them.
- assert(&output != filtered_output);
- size_t start = 0;
- bool seen_show_includes = false;
-#ifdef _WIN32
- IncludesNormalize normalizer(".");
-#endif
-
- while (start < output.size()) {
- size_t end = output.find_first_of("\r\n", start);
- if (end == string::npos)
- end = output.size();
- string line = output.substr(start, end - start);
-
- string include = FilterShowIncludes(line, deps_prefix);
- if (!include.empty()) {
- seen_show_includes = true;
- string normalized;
-#ifdef _WIN32
- if (!normalizer.Normalize(include, &normalized, err))
- return false;
-#else
- // TODO: should this make the path relative to cwd?
- normalized = include;
- uint64_t slash_bits;
- CanonicalizePath(&normalized, &slash_bits);
-#endif
- if (!IsSystemInclude(normalized))
- includes_.insert(normalized);
- } else if (!seen_show_includes && FilterInputFilename(line)) {
- // Drop it.
- // TODO: if we support compiling multiple output files in a single
- // cl.exe invocation, we should stash the filename.
- } else {
- filtered_output->append(line);
- filtered_output->append("\n");
- }
-
- if (end < output.size() && output[end] == '\r')
- ++end;
- if (end < output.size() && output[end] == '\n')
- ++end;
- start = end;
- }
-
- return true;
-}
diff --git a/src/clparser.h b/src/clparser.h
deleted file mode 100644
index 2a33628..0000000
--- a/src/clparser.h
+++ /dev/null
@@ -1,51 +0,0 @@
-// Copyright 2015 Google Inc. All Rights Reserved.
-//
-// Licensed under the Apache License, Version 2.0 (the "License");
-// you may not use this file except in compliance with the License.
-// You may obtain a copy of the License at
-//
-// http://www.apache.org/licenses/LICENSE-2.0
-//
-// Unless required by applicable law or agreed to in writing, software
-// distributed under the License is distributed on an "AS IS" BASIS,
-// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-// See the License for the specific language governing permissions and
-// limitations under the License.
-
-#ifndef NINJA_CLPARSER_H_
-#define NINJA_CLPARSER_H_
-
-#include <set>
-#include <string>
-
-/// Visual Studio's cl.exe requires some massaging to work with Ninja;
-/// for example, it emits include information on stderr in a funny
-/// format when building with /showIncludes. This class parses this
-/// output.
-struct CLParser {
- /// Parse a line of cl.exe output and extract /showIncludes info.
- /// If a dependency is extracted, returns a nonempty string.
- /// Exposed for testing.
- static std::string FilterShowIncludes(const std::string& line,
- const std::string& deps_prefix);
-
- /// Return true if a mentioned include file is a system path.
- /// Filtering these out reduces dependency information considerably.
- static bool IsSystemInclude(std::string path);
-
- /// Parse a line of cl.exe output and return true if it looks like
- /// it's printing an input filename. This is a heuristic but it appears
- /// to be the best we can do.
- /// Exposed for testing.
- static bool FilterInputFilename(std::string line);
-
- /// Parse the full output of cl, filling filtered_output with the text that
- /// should be printed (if any). Returns true on success, or false with err
- /// filled. output must not be the same object as filtered_object.
- bool Parse(const std::string& output, const std::string& deps_prefix,
- std::string* filtered_output, std::string* err);
-
- std::set<std::string> includes_;
-};
-
-#endif // NINJA_CLPARSER_H_
diff --git a/src/clparser_perftest.cc b/src/clparser_perftest.cc
deleted file mode 100644
index 008ac46..0000000
--- a/src/clparser_perftest.cc
+++ /dev/null
@@ -1,159 +0,0 @@
-// Copyright 2017 Google Inc. All Rights Reserved.
-//
-// Licensed under the Apache License, Version 2.0 (the "License");
-// you may not use this file except in compliance with the License.
-// You may obtain a copy of the License at
-//
-// http://www.apache.org/licenses/LICENSE-2.0
-//
-// Unless required by applicable law or agreed to in writing, software
-// distributed under the License is distributed on an "AS IS" BASIS,
-// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-// See the License for the specific language governing permissions and
-// limitations under the License.
-
-#include <stdio.h>
-#include <stdlib.h>
-
-#include "clparser.h"
-#include "metrics.h"
-
-using namespace std;
-
-int main(int argc, char* argv[]) {
- // Output of /showIncludes from #include <iostream>
- string perf_testdata =
- "Note: including file: C:\\Program Files (x86)\\Microsoft Visual Studio 14.0\\VC\\INCLUDE\\iostream\r\n"
- "Note: including file: C:\\Program Files (x86)\\Microsoft Visual Studio 14.0\\VC\\INCLUDE\\istream\r\n"
- "Note: including file: C:\\Program Files (x86)\\Microsoft Visual Studio 14.0\\VC\\INCLUDE\\ostream\r\n"
- "Note: including file: C:\\Program Files (x86)\\Microsoft Visual Studio 14.0\\VC\\INCLUDE\\ios\r\n"
- "Note: including file: C:\\Program Files (x86)\\Microsoft Visual Studio 14.0\\VC\\INCLUDE\\xlocnum\r\n"
- "Note: including file: C:\\Program Files (x86)\\Microsoft Visual Studio 14.0\\VC\\INCLUDE\\climits\r\n"
- "Note: including file: C:\\Program Files (x86)\\Microsoft Visual Studio 14.0\\VC\\INCLUDE\\yvals.h\r\n"
- "Note: including file: C:\\Program Files (x86)\\Microsoft Visual Studio 14.0\\VC\\INCLUDE\\xkeycheck.h\r\n"
- "Note: including file: C:\\Program Files (x86)\\Microsoft Visual Studio 14.0\\VC\\INCLUDE\\crtdefs.h\r\n"
- "Note: including file: C:\\Program Files (x86)\\Microsoft Visual Studio 14.0\\VC\\INCLUDE\\vcruntime.h\r\n"
- "Note: including file: C:\\Program Files (x86)\\Microsoft Visual Studio 14.0\\VC\\INCLUDE\\sal.h\r\n"
- "Note: including file: C:\\Program Files (x86)\\Microsoft Visual Studio 14.0\\VC\\INCLUDE\\ConcurrencySal.h\r\n"
- "Note: including file: C:\\Program Files (x86)\\Microsoft Visual Studio 14.0\\VC\\INCLUDE\\vadefs.h\r\n"
- "Note: including file: C:\\Program Files (x86)\\Windows Kits\\10\\include\\10.0.10240.0\\ucrt\\corecrt.h\r\n"
- "Note: including file: C:\\Program Files (x86)\\Microsoft Visual Studio 14.0\\VC\\INCLUDE\\vcruntime.h\r\n"
- "Note: including file: C:\\Program Files (x86)\\Microsoft Visual Studio 14.0\\VC\\INCLUDE\\use_ansi.h\r\n"
- "Note: including file: C:\\Program Files (x86)\\Microsoft Visual Studio 14.0\\VC\\INCLUDE\\limits.h\r\n"
- "Note: including file: C:\\Program Files (x86)\\Microsoft Visual Studio 14.0\\VC\\INCLUDE\\vcruntime.h\r\n"
- "Note: including file: C:\\Program Files (x86)\\Microsoft Visual Studio 14.0\\VC\\INCLUDE\\cmath\r\n"
- "Note: including file: C:\\Program Files (x86)\\Windows Kits\\10\\include\\10.0.10240.0\\ucrt\\math.h\r\n"
- "Note: including file: C:\\Program Files (x86)\\Microsoft Visual Studio 14.0\\VC\\INCLUDE\\xtgmath.h\r\n"
- "Note: including file: C:\\Program Files (x86)\\Microsoft Visual Studio 14.0\\VC\\INCLUDE\\xtr1common\r\n"
- "Note: including file: C:\\Program Files (x86)\\Microsoft Visual Studio 14.0\\VC\\INCLUDE\\cstdlib\r\n"
- "Note: including file: C:\\Program Files (x86)\\Windows Kits\\10\\include\\10.0.10240.0\\ucrt\\stdlib.h\r\n"
- "Note: including file: C:\\Program Files (x86)\\Windows Kits\\10\\include\\10.0.10240.0\\ucrt\\corecrt_malloc.h\r\n"
- "Note: including file: C:\\Program Files (x86)\\Windows Kits\\10\\include\\10.0.10240.0\\ucrt\\corecrt_search.h\r\n"
- "Note: including file: C:\\Program Files (x86)\\Windows Kits\\10\\include\\10.0.10240.0\\ucrt\\stddef.h\r\n"
- "Note: including file: C:\\Program Files (x86)\\Windows Kits\\10\\include\\10.0.10240.0\\ucrt\\corecrt_wstdlib.h\r\n"
- "Note: including file: C:\\Program Files (x86)\\Microsoft Visual Studio 14.0\\VC\\INCLUDE\\cstdio\r\n"
- "Note: including file: C:\\Program Files (x86)\\Windows Kits\\10\\include\\10.0.10240.0\\ucrt\\stdio.h\r\n"
- "Note: including file: C:\\Program Files (x86)\\Windows Kits\\10\\include\\10.0.10240.0\\ucrt\\corecrt_wstdio.h\r\n"
- "Note: including file: C:\\Program Files (x86)\\Windows Kits\\10\\include\\10.0.10240.0\\ucrt\\corecrt_stdio_config.h\r\n"
- "Note: including file: C:\\Program Files (x86)\\Microsoft Visual Studio 14.0\\VC\\INCLUDE\\streambuf\r\n"
- "Note: including file: C:\\Program Files (x86)\\Microsoft Visual Studio 14.0\\VC\\INCLUDE\\xiosbase\r\n"
- "Note: including file: C:\\Program Files (x86)\\Microsoft Visual Studio 14.0\\VC\\INCLUDE\\xlocale\r\n"
- "Note: including file: C:\\Program Files (x86)\\Microsoft Visual Studio 14.0\\VC\\INCLUDE\\cstring\r\n"
- "Note: including file: C:\\Program Files (x86)\\Windows Kits\\10\\include\\10.0.10240.0\\ucrt\\string.h\r\n"
- "Note: including file: C:\\Program Files (x86)\\Windows Kits\\10\\include\\10.0.10240.0\\ucrt\\corecrt_memory.h\r\n"
- "Note: including file: C:\\Program Files (x86)\\Windows Kits\\10\\include\\10.0.10240.0\\ucrt\\corecrt_memcpy_s.h\r\n"
- "Note: including file: C:\\Program Files (x86)\\Windows Kits\\10\\include\\10.0.10240.0\\ucrt\\errno.h\r\n"
- "Note: including file: C:\\Program Files (x86)\\Microsoft Visual Studio 14.0\\VC\\INCLUDE\\vcruntime_string.h\r\n"
- "Note: including file: C:\\Program Files (x86)\\Microsoft Visual Studio 14.0\\VC\\INCLUDE\\vcruntime.h\r\n"
- "Note: including file: C:\\Program Files (x86)\\Windows Kits\\10\\include\\10.0.10240.0\\ucrt\\corecrt_wstring.h\r\n"
- "Note: including file: C:\\Program Files (x86)\\Microsoft Visual Studio 14.0\\VC\\INCLUDE\\stdexcept\r\n"
- "Note: including file: C:\\Program Files (x86)\\Microsoft Visual Studio 14.0\\VC\\INCLUDE\\exception\r\n"
- "Note: including file: C:\\Program Files (x86)\\Microsoft Visual Studio 14.0\\VC\\INCLUDE\\type_traits\r\n"
- "Note: including file: C:\\Program Files (x86)\\Microsoft Visual Studio 14.0\\VC\\INCLUDE\\xstddef\r\n"
- "Note: including file: C:\\Program Files (x86)\\Microsoft Visual Studio 14.0\\VC\\INCLUDE\\cstddef\r\n"
- "Note: including file: C:\\Program Files (x86)\\Microsoft Visual Studio 14.0\\VC\\INCLUDE\\initializer_list\r\n"
- "Note: including file: C:\\Program Files (x86)\\Windows Kits\\10\\include\\10.0.10240.0\\ucrt\\malloc.h\r\n"
- "Note: including file: C:\\Program Files (x86)\\Microsoft Visual Studio 14.0\\VC\\INCLUDE\\vcruntime_exception.h\r\n"
- "Note: including file: C:\\Program Files (x86)\\Microsoft Visual Studio 14.0\\VC\\INCLUDE\\eh.h\r\n"
- "Note: including file: C:\\Program Files (x86)\\Windows Kits\\10\\include\\10.0.10240.0\\ucrt\\corecrt_terminate.h\r\n"
- "Note: including file: C:\\Program Files (x86)\\Microsoft Visual Studio 14.0\\VC\\INCLUDE\\xstring\r\n"
- "Note: including file: C:\\Program Files (x86)\\Microsoft Visual Studio 14.0\\VC\\INCLUDE\\xmemory0\r\n"
- "Note: including file: C:\\Program Files (x86)\\Microsoft Visual Studio 14.0\\VC\\INCLUDE\\cstdint\r\n"
- "Note: including file: C:\\Program Files (x86)\\Microsoft Visual Studio 14.0\\VC\\INCLUDE\\stdint.h\r\n"
- "Note: including file: C:\\Program Files (x86)\\Microsoft Visual Studio 14.0\\VC\\INCLUDE\\vcruntime.h\r\n"
- "Note: including file: C:\\Program Files (x86)\\Microsoft Visual Studio 14.0\\VC\\INCLUDE\\limits\r\n"
- "Note: including file: C:\\Program Files (x86)\\Microsoft Visual Studio 14.0\\VC\\INCLUDE\\ymath.h\r\n"
- "Note: including file: C:\\Program Files (x86)\\Microsoft Visual Studio 14.0\\VC\\INCLUDE\\cfloat\r\n"
- "Note: including file: C:\\Program Files (x86)\\Windows Kits\\10\\include\\10.0.10240.0\\ucrt\\float.h\r\n"
- "Note: including file: C:\\Program Files (x86)\\Microsoft Visual Studio 14.0\\VC\\INCLUDE\\cwchar\r\n"
- "Note: including file: C:\\Program Files (x86)\\Windows Kits\\10\\include\\10.0.10240.0\\ucrt\\wchar.h\r\n"
- "Note: including file: C:\\Program Files (x86)\\Windows Kits\\10\\include\\10.0.10240.0\\ucrt\\corecrt_wconio.h\r\n"
- "Note: including file: C:\\Program Files (x86)\\Windows Kits\\10\\include\\10.0.10240.0\\ucrt\\corecrt_wctype.h\r\n"
- "Note: including file: C:\\Program Files (x86)\\Windows Kits\\10\\include\\10.0.10240.0\\ucrt\\corecrt_wdirect.h\r\n"
- "Note: including file: C:\\Program Files (x86)\\Windows Kits\\10\\include\\10.0.10240.0\\ucrt\\corecrt_wio.h\r\n"
- "Note: including file: C:\\Program Files (x86)\\Windows Kits\\10\\include\\10.0.10240.0\\ucrt\\corecrt_share.h\r\n"
- "Note: including file: C:\\Program Files (x86)\\Windows Kits\\10\\include\\10.0.10240.0\\ucrt\\corecrt_wprocess.h\r\n"
- "Note: including file: C:\\Program Files (x86)\\Windows Kits\\10\\include\\10.0.10240.0\\ucrt\\corecrt_wtime.h\r\n"
- "Note: including file: C:\\Program Files (x86)\\Windows Kits\\10\\include\\10.0.10240.0\\ucrt\\sys/stat.h\r\n"
- "Note: including file: C:\\Program Files (x86)\\Windows Kits\\10\\include\\10.0.10240.0\\ucrt\\sys/types.h\r\n"
- "Note: including file: C:\\Program Files (x86)\\Microsoft Visual Studio 14.0\\VC\\INCLUDE\\new\r\n"
- "Note: including file: C:\\Program Files (x86)\\Microsoft Visual Studio 14.0\\VC\\INCLUDE\\vcruntime_new.h\r\n"
- "Note: including file: C:\\Program Files (x86)\\Microsoft Visual Studio 14.0\\VC\\INCLUDE\\vcruntime.h\r\n"
- "Note: including file: C:\\Program Files (x86)\\Microsoft Visual Studio 14.0\\VC\\INCLUDE\\xutility\r\n"
- "Note: including file: C:\\Program Files (x86)\\Microsoft Visual Studio 14.0\\VC\\INCLUDE\\utility\r\n"
- "Note: including file: C:\\Program Files (x86)\\Microsoft Visual Studio 14.0\\VC\\INCLUDE\\iosfwd\r\n"
- "Note: including file: C:\\Program Files (x86)\\Windows Kits\\10\\include\\10.0.10240.0\\ucrt\\crtdbg.h\r\n"
- "Note: including file: C:\\Program Files (x86)\\Microsoft Visual Studio 14.0\\VC\\INCLUDE\\vcruntime_new_debug.h\r\n"
- "Note: including file: C:\\Program Files (x86)\\Microsoft Visual Studio 14.0\\VC\\INCLUDE\\xatomic0.h\r\n"
- "Note: including file: C:\\Program Files (x86)\\Microsoft Visual Studio 14.0\\VC\\INCLUDE\\intrin.h\r\n"
- "Note: including file: C:\\Program Files (x86)\\Microsoft Visual Studio 14.0\\VC\\INCLUDE\\vcruntime.h\r\n"
- "Note: including file: C:\\Program Files (x86)\\Microsoft Visual Studio 14.0\\VC\\INCLUDE\\setjmp.h\r\n"
- "Note: including file: C:\\Program Files (x86)\\Microsoft Visual Studio 14.0\\VC\\INCLUDE\\vcruntime.h\r\n"
- "Note: including file: C:\\Program Files (x86)\\Microsoft Visual Studio 14.0\\VC\\INCLUDE\\immintrin.h\r\n"
- "Note: including file: C:\\Program Files (x86)\\Microsoft Visual Studio 14.0\\VC\\INCLUDE\\wmmintrin.h\r\n"
- "Note: including file: C:\\Program Files (x86)\\Microsoft Visual Studio 14.0\\VC\\INCLUDE\\nmmintrin.h\r\n"
- "Note: including file: C:\\Program Files (x86)\\Microsoft Visual Studio 14.0\\VC\\INCLUDE\\smmintrin.h\r\n"
- "Note: including file: C:\\Program Files (x86)\\Microsoft Visual Studio 14.0\\VC\\INCLUDE\\tmmintrin.h\r\n"
- "Note: including file: C:\\Program Files (x86)\\Microsoft Visual Studio 14.0\\VC\\INCLUDE\\pmmintrin.h\r\n"
- "Note: including file: C:\\Program Files (x86)\\Microsoft Visual Studio 14.0\\VC\\INCLUDE\\emmintrin.h\r\n"
- "Note: including file: C:\\Program Files (x86)\\Microsoft Visual Studio 14.0\\VC\\INCLUDE\\xmmintrin.h\r\n"
- "Note: including file: C:\\Program Files (x86)\\Microsoft Visual Studio 14.0\\VC\\INCLUDE\\mmintrin.h\r\n"
- "Note: including file: C:\\Program Files (x86)\\Microsoft Visual Studio 14.0\\VC\\INCLUDE\\ammintrin.h\r\n"
- "Note: including file: C:\\Program Files (x86)\\Microsoft Visual Studio 14.0\\VC\\INCLUDE\\mm3dnow.h\r\n"
- "Note: including file: C:\\Program Files (x86)\\Microsoft Visual Studio 14.0\\VC\\INCLUDE\\vcruntime.h\r\n"
- "Note: including file: C:\\Program Files (x86)\\Microsoft Visual Studio 14.0\\VC\\INCLUDE\\typeinfo\r\n"
- "Note: including file: C:\\Program Files (x86)\\Microsoft Visual Studio 14.0\\VC\\INCLUDE\\vcruntime_typeinfo.h\r\n"
- "Note: including file: C:\\Program Files (x86)\\Microsoft Visual Studio 14.0\\VC\\INCLUDE\\vcruntime.h\r\n"
- "Note: including file: C:\\Program Files (x86)\\Microsoft Visual Studio 14.0\\VC\\INCLUDE\\xlocinfo\r\n"
- "Note: including file: C:\\Program Files (x86)\\Microsoft Visual Studio 14.0\\VC\\INCLUDE\\xlocinfo.h\r\n"
- "Note: including file: C:\\Program Files (x86)\\Windows Kits\\10\\include\\10.0.10240.0\\ucrt\\ctype.h\r\n"
- "Note: including file: C:\\Program Files (x86)\\Windows Kits\\10\\include\\10.0.10240.0\\ucrt\\locale.h\r\n"
- "Note: including file: C:\\Program Files (x86)\\Microsoft Visual Studio 14.0\\VC\\INCLUDE\\xfacet\r\n"
- "Note: including file: C:\\Program Files (x86)\\Microsoft Visual Studio 14.0\\VC\\INCLUDE\\system_error\r\n"
- "Note: including file: C:\\Program Files (x86)\\Microsoft Visual Studio 14.0\\VC\\INCLUDE\\cerrno\r\n"
- "Note: including file: C:\\Program Files (x86)\\Windows Kits\\10\\include\\10.0.10240.0\\ucrt\\share.h\r\n";
-
- for (int limit = 1 << 10; limit < (1<<20); limit *= 2) {
- int64_t start = GetTimeMillis();
- for (int rep = 0; rep < limit; ++rep) {
- string output;
- string err;
-
- CLParser parser;
- if (!parser.Parse(perf_testdata, "", &output, &err)) {
- printf("%s\n", err.c_str());
- return 1;
- }
- }
- int64_t end = GetTimeMillis();
-
- if (end - start > 2000) {
- int delta_ms = (int)(end - start);
- printf("Parse %d times in %dms avg %.1fus\n",
- limit, delta_ms, float(delta_ms * 1000) / limit);
- break;
- }
- }
-
- return 0;
-}
diff --git a/src/clparser_test.cc b/src/clparser_test.cc
deleted file mode 100644
index f141680..0000000
--- a/src/clparser_test.cc
+++ /dev/null
@@ -1,130 +0,0 @@
-// Copyright 2011 Google Inc. All Rights Reserved.
-//
-// Licensed under the Apache License, Version 2.0 (the "License");
-// you may not use this file except in compliance with the License.
-// You may obtain a copy of the License at
-//
-// http://www.apache.org/licenses/LICENSE-2.0
-//
-// Unless required by applicable law or agreed to in writing, software
-// distributed under the License is distributed on an "AS IS" BASIS,
-// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-// See the License for the specific language governing permissions and
-// limitations under the License.
-
-#include "clparser.h"
-
-#include "test.h"
-#include "util.h"
-
-using namespace std;
-
-TEST(CLParserTest, ShowIncludes) {
- ASSERT_EQ("", CLParser::FilterShowIncludes("", ""));
-
- ASSERT_EQ("", CLParser::FilterShowIncludes("Sample compiler output", ""));
- ASSERT_EQ("c:\\Some Files\\foobar.h",
- CLParser::FilterShowIncludes("Note: including file: "
- "c:\\Some Files\\foobar.h", ""));
- ASSERT_EQ("c:\\initspaces.h",
- CLParser::FilterShowIncludes("Note: including file: "
- "c:\\initspaces.h", ""));
- ASSERT_EQ("c:\\initspaces.h",
- CLParser::FilterShowIncludes("Non-default prefix: inc file: "
- "c:\\initspaces.h",
- "Non-default prefix: inc file:"));
-}
-
-TEST(CLParserTest, FilterInputFilename) {
- ASSERT_TRUE(CLParser::FilterInputFilename("foobar.cc"));
- ASSERT_TRUE(CLParser::FilterInputFilename("foo bar.cc"));
- ASSERT_TRUE(CLParser::FilterInputFilename("baz.c"));
- ASSERT_TRUE(CLParser::FilterInputFilename("FOOBAR.CC"));
-
- ASSERT_FALSE(CLParser::FilterInputFilename(
- "src\\cl_helper.cc(166) : fatal error C1075: end "
- "of file found ..."));
-}
-
-TEST(CLParserTest, ParseSimple) {
- CLParser parser;
- string output, err;
- ASSERT_TRUE(parser.Parse(
- "foo\r\n"
- "Note: inc file prefix: foo.h\r\n"
- "bar\r\n",
- "Note: inc file prefix:", &output, &err));
-
- ASSERT_EQ("foo\nbar\n", output);
- ASSERT_EQ(1u, parser.includes_.size());
- ASSERT_EQ("foo.h", *parser.includes_.begin());
-}
-
-TEST(CLParserTest, ParseFilenameFilter) {
- CLParser parser;
- string output, err;
- ASSERT_TRUE(parser.Parse(
- "foo.cc\r\n"
- "cl: warning\r\n",
- "", &output, &err));
- ASSERT_EQ("cl: warning\n", output);
-}
-
-TEST(CLParserTest, NoFilenameFilterAfterShowIncludes) {
- CLParser parser;
- string output, err;
- ASSERT_TRUE(parser.Parse(
- "foo.cc\r\n"
- "Note: including file: foo.h\r\n"
- "something something foo.cc\r\n",
- "", &output, &err));
- ASSERT_EQ("something something foo.cc\n", output);
-}
-
-TEST(CLParserTest, ParseSystemInclude) {
- CLParser parser;
- string output, err;
- ASSERT_TRUE(parser.Parse(
- "Note: including file: c:\\Program Files\\foo.h\r\n"
- "Note: including file: d:\\Microsoft Visual Studio\\bar.h\r\n"
- "Note: including file: path.h\r\n",
- "", &output, &err));
- // We should have dropped the first two includes because they look like
- // system headers.
- ASSERT_EQ("", output);
- ASSERT_EQ(1u, parser.includes_.size());
- ASSERT_EQ("path.h", *parser.includes_.begin());
-}
-
-TEST(CLParserTest, DuplicatedHeader) {
- CLParser parser;
- string output, err;
- ASSERT_TRUE(parser.Parse(
- "Note: including file: foo.h\r\n"
- "Note: including file: bar.h\r\n"
- "Note: including file: foo.h\r\n",
- "", &output, &err));
- // We should have dropped one copy of foo.h.
- ASSERT_EQ("", output);
- ASSERT_EQ(2u, parser.includes_.size());
-}
-
-TEST(CLParserTest, DuplicatedHeaderPathConverted) {
- CLParser parser;
- string output, err;
-
- // This isn't inline in the Parse() call below because the #ifdef in
- // a macro expansion would confuse MSVC2013's preprocessor.
- const char kInput[] =
- "Note: including file: sub/./foo.h\r\n"
- "Note: including file: bar.h\r\n"
-#ifdef _WIN32
- "Note: including file: sub\\foo.h\r\n";
-#else
- "Note: including file: sub/foo.h\r\n";
-#endif
- ASSERT_TRUE(parser.Parse(kInput, "", &output, &err));
- // We should have dropped one copy of foo.h.
- ASSERT_EQ("", output);
- ASSERT_EQ(2u, parser.includes_.size());
-}
diff --git a/src/debug_flags.cc b/src/debug_flags.cc
deleted file mode 100644
index 44b14c4..0000000
--- a/src/debug_flags.cc
+++ /dev/null
@@ -1,21 +0,0 @@
-// Copyright 2012 Google Inc. All Rights Reserved.
-//
-// Licensed under the Apache License, Version 2.0 (the "License");
-// you may not use this file except in compliance with the License.
-// You may obtain a copy of the License at
-//
-// http://www.apache.org/licenses/LICENSE-2.0
-//
-// Unless required by applicable law or agreed to in writing, software
-// distributed under the License is distributed on an "AS IS" BASIS,
-// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-// See the License for the specific language governing permissions and
-// limitations under the License.
-
-bool g_explaining = false;
-
-bool g_keep_depfile = false;
-
-bool g_keep_rsp = false;
-
-bool g_experimental_statcache = true;
diff --git a/src/debug_flags.h b/src/debug_flags.h
deleted file mode 100644
index e08a43b..0000000
--- a/src/debug_flags.h
+++ /dev/null
@@ -1,33 +0,0 @@
-// Copyright 2012 Google Inc. All Rights Reserved.
-//
-// Licensed under the Apache License, Version 2.0 (the "License");
-// you may not use this file except in compliance with the License.
-// You may obtain a copy of the License at
-//
-// http://www.apache.org/licenses/LICENSE-2.0
-//
-// Unless required by applicable law or agreed to in writing, software
-// distributed under the License is distributed on an "AS IS" BASIS,
-// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-// See the License for the specific language governing permissions and
-// limitations under the License.
-
-#ifndef NINJA_EXPLAIN_H_
-#define NINJA_EXPLAIN_H_
-
-#include <stdio.h>
-
-#define EXPLAIN(fmt, ...) { \
- if (g_explaining) \
- fprintf(stderr, "ninja explain: " fmt "\n", __VA_ARGS__); \
-}
-
-extern bool g_explaining;
-
-extern bool g_keep_depfile;
-
-extern bool g_keep_rsp;
-
-extern bool g_experimental_statcache;
-
-#endif // NINJA_EXPLAIN_H_
diff --git a/src/depfile_parser.cc b/src/depfile_parser.cc
deleted file mode 100644
index 98fba2e..0000000
--- a/src/depfile_parser.cc
+++ /dev/null
@@ -1,371 +0,0 @@
-/* Generated by re2c */
-// Copyright 2011 Google Inc. All Rights Reserved.
-//
-// Licensed under the Apache License, Version 2.0 (the "License");
-// you may not use this file except in compliance with the License.
-// You may obtain a copy of the License at
-//
-// http://www.apache.org/licenses/LICENSE-2.0
-//
-// Unless required by applicable law or agreed to in writing, software
-// distributed under the License is distributed on an "AS IS" BASIS,
-// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-// See the License for the specific language governing permissions and
-// limitations under the License.
-
-#include "depfile_parser.h"
-#include "util.h"
-
-#include <algorithm>
-
-using namespace std;
-
-DepfileParser::DepfileParser(DepfileParserOptions options)
- : options_(options)
-{
-}
-
-// A note on backslashes in Makefiles, from reading the docs:
-// Backslash-newline is the line continuation character.
-// Backslash-# escapes a # (otherwise meaningful as a comment start).
-// Backslash-% escapes a % (otherwise meaningful as a special).
-// Finally, quoting the GNU manual, "Backslashes that are not in danger
-// of quoting ‘%’ characters go unmolested."
-// How do you end a line with a backslash? The netbsd Make docs suggest
-// reading the result of a shell command echoing a backslash!
-//
-// Rather than implement all of above, we follow what GCC/Clang produces:
-// Backslashes escape a space or hash sign.
-// When a space is preceded by 2N+1 backslashes, it is represents N backslashes
-// followed by space.
-// When a space is preceded by 2N backslashes, it represents 2N backslashes at
-// the end of a filename.
-// A hash sign is escaped by a single backslash. All other backslashes remain
-// unchanged.
-//
-// If anyone actually has depfiles that rely on the more complicated
-// behavior we can adjust this.
-bool DepfileParser::Parse(string* content, string* err) {
- // in: current parser input point.
- // end: end of input.
- // parsing_targets: whether we are parsing targets or dependencies.
- char* in = &(*content)[0];
- char* end = in + content->size();
- bool have_target = false;
- bool parsing_targets = true;
- bool poisoned_input = false;
- while (in < end) {
- bool have_newline = false;
- // out: current output point (typically same as in, but can fall behind
- // as we de-escape backslashes).
- char* out = in;
- // filename: start of the current parsed filename.
- char* filename = out;
- for (;;) {
- // start: beginning of the current parsed span.
- const char* start = in;
- char* yymarker = NULL;
-
- {
- unsigned char yych;
- static const unsigned char yybm[] = {
- 0, 0, 0, 0, 0, 0, 0, 0,
- 0, 0, 0, 0, 0, 0, 0, 0,
- 0, 0, 0, 0, 0, 0, 0, 0,
- 0, 0, 0, 0, 0, 0, 0, 0,
- 0, 128, 0, 0, 0, 128, 0, 0,
- 128, 128, 0, 128, 128, 128, 128, 128,
- 128, 128, 128, 128, 128, 128, 128, 128,
- 128, 128, 128, 0, 0, 128, 0, 0,
- 128, 128, 128, 128, 128, 128, 128, 128,
- 128, 128, 128, 128, 128, 128, 128, 128,
- 128, 128, 128, 128, 128, 128, 128, 128,
- 128, 128, 128, 128, 0, 128, 0, 128,
- 0, 128, 128, 128, 128, 128, 128, 128,
- 128, 128, 128, 128, 128, 128, 128, 128,
- 128, 128, 128, 128, 128, 128, 128, 128,
- 128, 128, 128, 128, 0, 128, 128, 0,
- 128, 128, 128, 128, 128, 128, 128, 128,
- 128, 128, 128, 128, 128, 128, 128, 128,
- 128, 128, 128, 128, 128, 128, 128, 128,
- 128, 128, 128, 128, 128, 128, 128, 128,
- 128, 128, 128, 128, 128, 128, 128, 128,
- 128, 128, 128, 128, 128, 128, 128, 128,
- 128, 128, 128, 128, 128, 128, 128, 128,
- 128, 128, 128, 128, 128, 128, 128, 128,
- 128, 128, 128, 128, 128, 128, 128, 128,
- 128, 128, 128, 128, 128, 128, 128, 128,
- 128, 128, 128, 128, 128, 128, 128, 128,
- 128, 128, 128, 128, 128, 128, 128, 128,
- 128, 128, 128, 128, 128, 128, 128, 128,
- 128, 128, 128, 128, 128, 128, 128, 128,
- 128, 128, 128, 128, 128, 128, 128, 128,
- 128, 128, 128, 128, 128, 128, 128, 128,
- };
- yych = *in;
- if (yybm[0+yych] & 128) {
- goto yy9;
- }
- if (yych <= '\r') {
- if (yych <= '\t') {
- if (yych >= 0x01) goto yy4;
- } else {
- if (yych <= '\n') goto yy6;
- if (yych <= '\f') goto yy4;
- goto yy8;
- }
- } else {
- if (yych <= '$') {
- if (yych <= '#') goto yy4;
- goto yy12;
- } else {
- if (yych <= '?') goto yy4;
- if (yych <= '\\') goto yy13;
- goto yy4;
- }
- }
- ++in;
- {
- break;
- }
-yy4:
- ++in;
-yy5:
- {
- // For any other character (e.g. whitespace), swallow it here,
- // allowing the outer logic to loop around again.
- break;
- }
-yy6:
- ++in;
- {
- // A newline ends the current file name and the current rule.
- have_newline = true;
- break;
- }
-yy8:
- yych = *++in;
- if (yych == '\n') goto yy6;
- goto yy5;
-yy9:
- yych = *++in;
- if (yybm[0+yych] & 128) {
- goto yy9;
- }
-yy11:
- {
- // Got a span of plain text.
- int len = (int)(in - start);
- // Need to shift it over if we're overwriting backslashes.
- if (out < start)
- memmove(out, start, len);
- out += len;
- continue;
- }
-yy12:
- yych = *++in;
- if (yych == '$') goto yy14;
- goto yy5;
-yy13:
- yych = *(yymarker = ++in);
- if (yych <= ' ') {
- if (yych <= '\n') {
- if (yych <= 0x00) goto yy5;
- if (yych <= '\t') goto yy16;
- goto yy17;
- } else {
- if (yych == '\r') goto yy19;
- if (yych <= 0x1F) goto yy16;
- goto yy21;
- }
- } else {
- if (yych <= '9') {
- if (yych == '#') goto yy23;
- goto yy16;
- } else {
- if (yych <= ':') goto yy25;
- if (yych == '\\') goto yy27;
- goto yy16;
- }
- }
-yy14:
- ++in;
- {
- // De-escape dollar character.
- *out++ = '$';
- continue;
- }
-yy16:
- ++in;
- goto yy11;
-yy17:
- ++in;
- {
- // A line continuation ends the current file name.
- break;
- }
-yy19:
- yych = *++in;
- if (yych == '\n') goto yy17;
- in = yymarker;
- goto yy5;
-yy21:
- ++in;
- {
- // 2N+1 backslashes plus space -> N backslashes plus space.
- int len = (int)(in - start);
- int n = len / 2 - 1;
- if (out < start)
- memset(out, '\\', n);
- out += n;
- *out++ = ' ';
- continue;
- }
-yy23:
- ++in;
- {
- // De-escape hash sign, but preserve other leading backslashes.
- int len = (int)(in - start);
- if (len > 2 && out < start)
- memset(out, '\\', len - 2);
- out += len - 2;
- *out++ = '#';
- continue;
- }
-yy25:
- yych = *++in;
- if (yych <= '\f') {
- if (yych <= 0x00) goto yy28;
- if (yych <= 0x08) goto yy26;
- if (yych <= '\n') goto yy28;
- } else {
- if (yych <= '\r') goto yy28;
- if (yych == ' ') goto yy28;
- }
-yy26:
- {
- // De-escape colon sign, but preserve other leading backslashes.
- // Regular expression uses lookahead to make sure that no whitespace
- // nor EOF follows. In that case it'd be the : at the end of a target
- int len = (int)(in - start);
- if (len > 2 && out < start)
- memset(out, '\\', len - 2);
- out += len - 2;
- *out++ = ':';
- continue;
- }
-yy27:
- yych = *++in;
- if (yych <= ' ') {
- if (yych <= '\n') {
- if (yych <= 0x00) goto yy11;
- if (yych <= '\t') goto yy16;
- goto yy11;
- } else {
- if (yych == '\r') goto yy11;
- if (yych <= 0x1F) goto yy16;
- goto yy30;
- }
- } else {
- if (yych <= '9') {
- if (yych == '#') goto yy23;
- goto yy16;
- } else {
- if (yych <= ':') goto yy25;
- if (yych == '\\') goto yy32;
- goto yy16;
- }
- }
-yy28:
- ++in;
- {
- // Backslash followed by : and whitespace.
- // It is therefore normal text and not an escaped colon
- int len = (int)(in - start - 1);
- // Need to shift it over if we're overwriting backslashes.
- if (out < start)
- memmove(out, start, len);
- out += len;
- if (*(in - 1) == '\n')
- have_newline = true;
- break;
- }
-yy30:
- ++in;
- {
- // 2N backslashes plus space -> 2N backslashes, end of filename.
- int len = (int)(in - start);
- if (out < start)
- memset(out, '\\', len - 1);
- out += len - 1;
- break;
- }
-yy32:
- yych = *++in;
- if (yych <= ' ') {
- if (yych <= '\n') {
- if (yych <= 0x00) goto yy11;
- if (yych <= '\t') goto yy16;
- goto yy11;
- } else {
- if (yych == '\r') goto yy11;
- if (yych <= 0x1F) goto yy16;
- goto yy21;
- }
- } else {
- if (yych <= '9') {
- if (yych == '#') goto yy23;
- goto yy16;
- } else {
- if (yych <= ':') goto yy25;
- if (yych == '\\') goto yy27;
- goto yy16;
- }
- }
- }
-
- }
-
- int len = (int)(out - filename);
- const bool is_dependency = !parsing_targets;
- if (len > 0 && filename[len - 1] == ':') {
- len--; // Strip off trailing colon, if any.
- parsing_targets = false;
- have_target = true;
- }
-
- if (len > 0) {
- StringPiece piece = StringPiece(filename, len);
- // If we've seen this as an input before, skip it.
- std::vector<StringPiece>::iterator pos = std::find(ins_.begin(), ins_.end(), piece);
- if (pos == ins_.end()) {
- if (is_dependency) {
- if (poisoned_input) {
- *err = "inputs may not also have inputs";
- return false;
- }
- // New input.
- ins_.push_back(piece);
- } else {
- // Check for a new output.
- if (std::find(outs_.begin(), outs_.end(), piece) == outs_.end())
- outs_.push_back(piece);
- }
- } else if (!is_dependency) {
- // We've passed an input on the left side; reject new inputs.
- poisoned_input = true;
- }
- }
-
- if (have_newline) {
- // A newline ends a rule so the next filename will be a new target.
- parsing_targets = true;
- poisoned_input = false;
- }
- }
- if (!have_target) {
- *err = "expected ':' in depfile";
- return false;
- }
- return true;
-}
diff --git a/src/depfile_parser.h b/src/depfile_parser.h
deleted file mode 100644
index 88210dc..0000000
--- a/src/depfile_parser.h
+++ /dev/null
@@ -1,47 +0,0 @@
-// Copyright 2011 Google Inc. All Rights Reserved.
-//
-// Licensed under the Apache License, Version 2.0 (the "License");
-// you may not use this file except in compliance with the License.
-// You may obtain a copy of the License at
-//
-// http://www.apache.org/licenses/LICENSE-2.0
-//
-// Unless required by applicable law or agreed to in writing, software
-// distributed under the License is distributed on an "AS IS" BASIS,
-// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-// See the License for the specific language governing permissions and
-// limitations under the License.
-
-#ifndef NINJA_DEPFILE_PARSER_H_
-#define NINJA_DEPFILE_PARSER_H_
-
-#include <string>
-#include <vector>
-
-#include "string_piece.h"
-
-struct DepfileParserOptions {
- DepfileParserOptions() {}
-
- bool operator==(const DepfileParserOptions&) const {
- // struct is empty so always return true for now.
- return true;
- }
-};
-
-/// Parser for the dependency information emitted by gcc's -M flags.
-struct DepfileParser {
- explicit DepfileParser(DepfileParserOptions options =
- DepfileParserOptions());
-
- /// Parse an input file. Input must be NUL-terminated.
- /// Warning: may mutate the content in-place and parsed StringPieces are
- /// pointers within it.
- bool Parse(std::string* content, std::string* err);
-
- std::vector<StringPiece> outs_;
- std::vector<StringPiece> ins_;
- DepfileParserOptions options_;
-};
-
-#endif // NINJA_DEPFILE_PARSER_H_
diff --git a/src/depfile_parser.in.cc b/src/depfile_parser.in.cc
deleted file mode 100644
index 75ba982..0000000
--- a/src/depfile_parser.in.cc
+++ /dev/null
@@ -1,207 +0,0 @@
-// Copyright 2011 Google Inc. All Rights Reserved.
-//
-// Licensed under the Apache License, Version 2.0 (the "License");
-// you may not use this file except in compliance with the License.
-// You may obtain a copy of the License at
-//
-// http://www.apache.org/licenses/LICENSE-2.0
-//
-// Unless required by applicable law or agreed to in writing, software
-// distributed under the License is distributed on an "AS IS" BASIS,
-// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-// See the License for the specific language governing permissions and
-// limitations under the License.
-
-#include "depfile_parser.h"
-#include "util.h"
-
-#include <algorithm>
-
-using namespace std;
-
-DepfileParser::DepfileParser(DepfileParserOptions options)
- : options_(options)
-{
-}
-
-// A note on backslashes in Makefiles, from reading the docs:
-// Backslash-newline is the line continuation character.
-// Backslash-# escapes a # (otherwise meaningful as a comment start).
-// Backslash-% escapes a % (otherwise meaningful as a special).
-// Finally, quoting the GNU manual, "Backslashes that are not in danger
-// of quoting ‘%’ characters go unmolested."
-// How do you end a line with a backslash? The netbsd Make docs suggest
-// reading the result of a shell command echoing a backslash!
-//
-// Rather than implement all of above, we follow what GCC/Clang produces:
-// Backslashes escape a space or hash sign.
-// When a space is preceded by 2N+1 backslashes, it is represents N backslashes
-// followed by space.
-// When a space is preceded by 2N backslashes, it represents 2N backslashes at
-// the end of a filename.
-// A hash sign is escaped by a single backslash. All other backslashes remain
-// unchanged.
-//
-// If anyone actually has depfiles that rely on the more complicated
-// behavior we can adjust this.
-bool DepfileParser::Parse(string* content, string* err) {
- // in: current parser input point.
- // end: end of input.
- // parsing_targets: whether we are parsing targets or dependencies.
- char* in = &(*content)[0];
- char* end = in + content->size();
- bool have_target = false;
- bool parsing_targets = true;
- bool poisoned_input = false;
- while (in < end) {
- bool have_newline = false;
- // out: current output point (typically same as in, but can fall behind
- // as we de-escape backslashes).
- char* out = in;
- // filename: start of the current parsed filename.
- char* filename = out;
- for (;;) {
- // start: beginning of the current parsed span.
- const char* start = in;
- char* yymarker = NULL;
- /*!re2c
- re2c:define:YYCTYPE = "unsigned char";
- re2c:define:YYCURSOR = in;
- re2c:define:YYLIMIT = end;
- re2c:define:YYMARKER = yymarker;
-
- re2c:yyfill:enable = 0;
-
- re2c:indent:top = 2;
- re2c:indent:string = " ";
-
- nul = "\000";
- newline = '\r'?'\n';
-
- '\\\\'* '\\ ' {
- // 2N+1 backslashes plus space -> N backslashes plus space.
- int len = (int)(in - start);
- int n = len / 2 - 1;
- if (out < start)
- memset(out, '\\', n);
- out += n;
- *out++ = ' ';
- continue;
- }
- '\\\\'+ ' ' {
- // 2N backslashes plus space -> 2N backslashes, end of filename.
- int len = (int)(in - start);
- if (out < start)
- memset(out, '\\', len - 1);
- out += len - 1;
- break;
- }
- '\\'+ '#' {
- // De-escape hash sign, but preserve other leading backslashes.
- int len = (int)(in - start);
- if (len > 2 && out < start)
- memset(out, '\\', len - 2);
- out += len - 2;
- *out++ = '#';
- continue;
- }
- '\\'+ ':' [\x00\x20\r\n\t] {
- // Backslash followed by : and whitespace.
- // It is therefore normal text and not an escaped colon
- int len = (int)(in - start - 1);
- // Need to shift it over if we're overwriting backslashes.
- if (out < start)
- memmove(out, start, len);
- out += len;
- if (*(in - 1) == '\n')
- have_newline = true;
- break;
- }
- '\\'+ ':' {
- // De-escape colon sign, but preserve other leading backslashes.
- // Regular expression uses lookahead to make sure that no whitespace
- // nor EOF follows. In that case it'd be the : at the end of a target
- int len = (int)(in - start);
- if (len > 2 && out < start)
- memset(out, '\\', len - 2);
- out += len - 2;
- *out++ = ':';
- continue;
- }
- '$$' {
- // De-escape dollar character.
- *out++ = '$';
- continue;
- }
- '\\'+ [^\000\r\n] | [a-zA-Z0-9+,/_:.~()}{%=@\x5B\x5D!\x80-\xFF-]+ {
- // Got a span of plain text.
- int len = (int)(in - start);
- // Need to shift it over if we're overwriting backslashes.
- if (out < start)
- memmove(out, start, len);
- out += len;
- continue;
- }
- nul {
- break;
- }
- '\\' newline {
- // A line continuation ends the current file name.
- break;
- }
- newline {
- // A newline ends the current file name and the current rule.
- have_newline = true;
- break;
- }
- [^] {
- // For any other character (e.g. whitespace), swallow it here,
- // allowing the outer logic to loop around again.
- break;
- }
- */
- }
-
- int len = (int)(out - filename);
- const bool is_dependency = !parsing_targets;
- if (len > 0 && filename[len - 1] == ':') {
- len--; // Strip off trailing colon, if any.
- parsing_targets = false;
- have_target = true;
- }
-
- if (len > 0) {
- StringPiece piece = StringPiece(filename, len);
- // If we've seen this as an input before, skip it.
- std::vector<StringPiece>::iterator pos = std::find(ins_.begin(), ins_.end(), piece);
- if (pos == ins_.end()) {
- if (is_dependency) {
- if (poisoned_input) {
- *err = "inputs may not also have inputs";
- return false;
- }
- // New input.
- ins_.push_back(piece);
- } else {
- // Check for a new output.
- if (std::find(outs_.begin(), outs_.end(), piece) == outs_.end())
- outs_.push_back(piece);
- }
- } else if (!is_dependency) {
- // We've passed an input on the left side; reject new inputs.
- poisoned_input = true;
- }
- }
-
- if (have_newline) {
- // A newline ends a rule so the next filename will be a new target.
- parsing_targets = true;
- poisoned_input = false;
- }
- }
- if (!have_target) {
- *err = "expected ':' in depfile";
- return false;
- }
- return true;
-}
diff --git a/src/depfile_parser_perftest.cc b/src/depfile_parser_perftest.cc
deleted file mode 100644
index 52555e6..0000000
--- a/src/depfile_parser_perftest.cc
+++ /dev/null
@@ -1,79 +0,0 @@
-// Copyright 2011 Google Inc. All Rights Reserved.
-//
-// Licensed under the Apache License, Version 2.0 (the "License");
-// you may not use this file except in compliance with the License.
-// You may obtain a copy of the License at
-//
-// http://www.apache.org/licenses/LICENSE-2.0
-//
-// Unless required by applicable law or agreed to in writing, software
-// distributed under the License is distributed on an "AS IS" BASIS,
-// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-// See the License for the specific language governing permissions and
-// limitations under the License.
-
-#include <stdio.h>
-#include <stdlib.h>
-
-#include "depfile_parser.h"
-#include "util.h"
-#include "metrics.h"
-
-using namespace std;
-
-int main(int argc, char* argv[]) {
- if (argc < 2) {
- printf("usage: %s <file1> <file2...>\n", argv[0]);
- return 1;
- }
-
- vector<float> times;
- for (int i = 1; i < argc; ++i) {
- const char* filename = argv[i];
-
- for (int limit = 1 << 10; limit < (1<<20); limit *= 2) {
- int64_t start = GetTimeMillis();
- for (int rep = 0; rep < limit; ++rep) {
- string buf;
- string err;
- if (ReadFile(filename, &buf, &err) < 0) {
- printf("%s: %s\n", filename, err.c_str());
- return 1;
- }
-
- DepfileParser parser;
- if (!parser.Parse(&buf, &err)) {
- printf("%s: %s\n", filename, err.c_str());
- return 1;
- }
- }
- int64_t end = GetTimeMillis();
-
- if (end - start > 100) {
- int delta = (int)(end - start);
- float time = delta*1000 / (float)limit;
- printf("%s: %.1fus\n", filename, time);
- times.push_back(time);
- break;
- }
- }
- }
-
- if (!times.empty()) {
- float min = times[0];
- float max = times[0];
- float total = 0;
- for (size_t i = 0; i < times.size(); ++i) {
- total += times[i];
- if (times[i] < min)
- min = times[i];
- else if (times[i] > max)
- max = times[i];
- }
-
- printf("min %.1fus max %.1fus avg %.1fus\n",
- min, max, total / times.size());
- }
-
- return 0;
-}
diff --git a/src/depfile_parser_test.cc b/src/depfile_parser_test.cc
deleted file mode 100644
index 8886258..0000000
--- a/src/depfile_parser_test.cc
+++ /dev/null
@@ -1,380 +0,0 @@
-// Copyright 2011 Google Inc. All Rights Reserved.
-//
-// Licensed under the Apache License, Version 2.0 (the "License");
-// you may not use this file except in compliance with the License.
-// You may obtain a copy of the License at
-//
-// http://www.apache.org/licenses/LICENSE-2.0
-//
-// Unless required by applicable law or agreed to in writing, software
-// distributed under the License is distributed on an "AS IS" BASIS,
-// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-// See the License for the specific language governing permissions and
-// limitations under the License.
-
-#include "depfile_parser.h"
-
-#include "test.h"
-
-using namespace std;
-
-struct DepfileParserTest : public testing::Test {
- bool Parse(const char* input, string* err);
-
- DepfileParser parser_;
- string input_;
-};
-
-bool DepfileParserTest::Parse(const char* input, string* err) {
- input_ = input;
- return parser_.Parse(&input_, err);
-}
-
-TEST_F(DepfileParserTest, Basic) {
- string err;
- EXPECT_TRUE(Parse(
-"build/ninja.o: ninja.cc ninja.h eval_env.h manifest_parser.h\n",
- &err));
- ASSERT_EQ("", err);
- ASSERT_EQ(1u, parser_.outs_.size());
- EXPECT_EQ("build/ninja.o", parser_.outs_[0].AsString());
- EXPECT_EQ(4u, parser_.ins_.size());
-}
-
-TEST_F(DepfileParserTest, EarlyNewlineAndWhitespace) {
- string err;
- EXPECT_TRUE(Parse(
-" \\\n"
-" out: in\n",
- &err));
- ASSERT_EQ("", err);
-}
-
-TEST_F(DepfileParserTest, Continuation) {
- string err;
- EXPECT_TRUE(Parse(
-"foo.o: \\\n"
-" bar.h baz.h\n",
- &err));
- ASSERT_EQ("", err);
- ASSERT_EQ(1u, parser_.outs_.size());
- EXPECT_EQ("foo.o", parser_.outs_[0].AsString());
- EXPECT_EQ(2u, parser_.ins_.size());
-}
-
-TEST_F(DepfileParserTest, CarriageReturnContinuation) {
- string err;
- EXPECT_TRUE(Parse(
-"foo.o: \\\r\n"
-" bar.h baz.h\r\n",
- &err));
- ASSERT_EQ("", err);
- ASSERT_EQ(1u, parser_.outs_.size());
- EXPECT_EQ("foo.o", parser_.outs_[0].AsString());
- EXPECT_EQ(2u, parser_.ins_.size());
-}
-
-TEST_F(DepfileParserTest, BackSlashes) {
- string err;
- EXPECT_TRUE(Parse(
-"Project\\Dir\\Build\\Release8\\Foo\\Foo.res : \\\n"
-" Dir\\Library\\Foo.rc \\\n"
-" Dir\\Library\\Version\\Bar.h \\\n"
-" Dir\\Library\\Foo.ico \\\n"
-" Project\\Thing\\Bar.tlb \\\n",
- &err));
- ASSERT_EQ("", err);
- ASSERT_EQ(1u, parser_.outs_.size());
- EXPECT_EQ("Project\\Dir\\Build\\Release8\\Foo\\Foo.res",
- parser_.outs_[0].AsString());
- EXPECT_EQ(4u, parser_.ins_.size());
-}
-
-TEST_F(DepfileParserTest, Spaces) {
- string err;
- EXPECT_TRUE(Parse(
-"a\\ bc\\ def: a\\ b c d",
- &err));
- ASSERT_EQ("", err);
- ASSERT_EQ(1u, parser_.outs_.size());
- EXPECT_EQ("a bc def",
- parser_.outs_[0].AsString());
- ASSERT_EQ(3u, parser_.ins_.size());
- EXPECT_EQ("a b",
- parser_.ins_[0].AsString());
- EXPECT_EQ("c",
- parser_.ins_[1].AsString());
- EXPECT_EQ("d",
- parser_.ins_[2].AsString());
-}
-
-TEST_F(DepfileParserTest, MultipleBackslashes) {
- // Successive 2N+1 backslashes followed by space (' ') are replaced by N >= 0
- // backslashes and the space. A single backslash before hash sign is removed.
- // Other backslashes remain untouched (including 2N backslashes followed by
- // space).
- string err;
- EXPECT_TRUE(Parse(
-"a\\ b\\#c.h: \\\\\\\\\\ \\\\\\\\ \\\\share\\info\\\\#1",
- &err));
- ASSERT_EQ("", err);
- ASSERT_EQ(1u, parser_.outs_.size());
- EXPECT_EQ("a b#c.h",
- parser_.outs_[0].AsString());
- ASSERT_EQ(3u, parser_.ins_.size());
- EXPECT_EQ("\\\\ ",
- parser_.ins_[0].AsString());
- EXPECT_EQ("\\\\\\\\",
- parser_.ins_[1].AsString());
- EXPECT_EQ("\\\\share\\info\\#1",
- parser_.ins_[2].AsString());
-}
-
-TEST_F(DepfileParserTest, Escapes) {
- // Put backslashes before a variety of characters, see which ones make
- // it through.
- string err;
- EXPECT_TRUE(Parse(
-"\\!\\@\\#$$\\%\\^\\&\\[\\]\\\\:",
- &err));
- ASSERT_EQ("", err);
- ASSERT_EQ(1u, parser_.outs_.size());
- EXPECT_EQ("\\!\\@#$\\%\\^\\&\\[\\]\\\\",
- parser_.outs_[0].AsString());
- ASSERT_EQ(0u, parser_.ins_.size());
-}
-
-TEST_F(DepfileParserTest, EscapedColons)
-{
- std::string err;
- // Tests for correct parsing of depfiles produced on Windows
- // by both Clang, GCC pre 10 and GCC 10
- EXPECT_TRUE(Parse(
-"c\\:\\gcc\\x86_64-w64-mingw32\\include\\stddef.o: \\\n"
-" c:\\gcc\\x86_64-w64-mingw32\\include\\stddef.h \n",
- &err));
- ASSERT_EQ("", err);
- ASSERT_EQ(1u, parser_.outs_.size());
- EXPECT_EQ("c:\\gcc\\x86_64-w64-mingw32\\include\\stddef.o",
- parser_.outs_[0].AsString());
- ASSERT_EQ(1u, parser_.ins_.size());
- EXPECT_EQ("c:\\gcc\\x86_64-w64-mingw32\\include\\stddef.h",
- parser_.ins_[0].AsString());
-}
-
-TEST_F(DepfileParserTest, EscapedTargetColon)
-{
- std::string err;
- EXPECT_TRUE(Parse(
-"foo1\\: x\n"
-"foo1\\:\n"
-"foo1\\:\r\n"
-"foo1\\:\t\n"
-"foo1\\:",
- &err));
- ASSERT_EQ("", err);
- ASSERT_EQ(1u, parser_.outs_.size());
- EXPECT_EQ("foo1\\", parser_.outs_[0].AsString());
- ASSERT_EQ(1u, parser_.ins_.size());
- EXPECT_EQ("x", parser_.ins_[0].AsString());
-}
-
-TEST_F(DepfileParserTest, SpecialChars) {
- // See filenames like istreambuf.iterator_op!= in
- // https://github.com/google/libcxx/tree/master/test/iterators/stream.iterators/istreambuf.iterator/
- string err;
- EXPECT_TRUE(Parse(
-"C:/Program\\ Files\\ (x86)/Microsoft\\ crtdefs.h: \\\n"
-" en@quot.header~ t+t-x!=1 \\\n"
-" openldap/slapd.d/cn=config/cn=schema/cn={0}core.ldif\\\n"
-" Fu\303\244ball\\\n"
-" a[1]b@2%c",
- &err));
- ASSERT_EQ("", err);
- ASSERT_EQ(1u, parser_.outs_.size());
- EXPECT_EQ("C:/Program Files (x86)/Microsoft crtdefs.h",
- parser_.outs_[0].AsString());
- ASSERT_EQ(5u, parser_.ins_.size());
- EXPECT_EQ("en@quot.header~",
- parser_.ins_[0].AsString());
- EXPECT_EQ("t+t-x!=1",
- parser_.ins_[1].AsString());
- EXPECT_EQ("openldap/slapd.d/cn=config/cn=schema/cn={0}core.ldif",
- parser_.ins_[2].AsString());
- EXPECT_EQ("Fu\303\244ball",
- parser_.ins_[3].AsString());
- EXPECT_EQ("a[1]b@2%c",
- parser_.ins_[4].AsString());
-}
-
-TEST_F(DepfileParserTest, UnifyMultipleOutputs) {
- // check that multiple duplicate targets are properly unified
- string err;
- EXPECT_TRUE(Parse("foo foo: x y z", &err));
- ASSERT_EQ(1u, parser_.outs_.size());
- ASSERT_EQ("foo", parser_.outs_[0].AsString());
- ASSERT_EQ(3u, parser_.ins_.size());
- EXPECT_EQ("x", parser_.ins_[0].AsString());
- EXPECT_EQ("y", parser_.ins_[1].AsString());
- EXPECT_EQ("z", parser_.ins_[2].AsString());
-}
-
-TEST_F(DepfileParserTest, MultipleDifferentOutputs) {
- // check that multiple different outputs are accepted by the parser
- string err;
- EXPECT_TRUE(Parse("foo bar: x y z", &err));
- ASSERT_EQ(2u, parser_.outs_.size());
- ASSERT_EQ("foo", parser_.outs_[0].AsString());
- ASSERT_EQ("bar", parser_.outs_[1].AsString());
- ASSERT_EQ(3u, parser_.ins_.size());
- EXPECT_EQ("x", parser_.ins_[0].AsString());
- EXPECT_EQ("y", parser_.ins_[1].AsString());
- EXPECT_EQ("z", parser_.ins_[2].AsString());
-}
-
-TEST_F(DepfileParserTest, MultipleEmptyRules) {
- string err;
- EXPECT_TRUE(Parse("foo: x\n"
- "foo: \n"
- "foo:\n", &err));
- ASSERT_EQ(1u, parser_.outs_.size());
- ASSERT_EQ("foo", parser_.outs_[0].AsString());
- ASSERT_EQ(1u, parser_.ins_.size());
- EXPECT_EQ("x", parser_.ins_[0].AsString());
-}
-
-TEST_F(DepfileParserTest, UnifyMultipleRulesLF) {
- string err;
- EXPECT_TRUE(Parse("foo: x\n"
- "foo: y\n"
- "foo \\\n"
- "foo: z\n", &err));
- ASSERT_EQ(1u, parser_.outs_.size());
- ASSERT_EQ("foo", parser_.outs_[0].AsString());
- ASSERT_EQ(3u, parser_.ins_.size());
- EXPECT_EQ("x", parser_.ins_[0].AsString());
- EXPECT_EQ("y", parser_.ins_[1].AsString());
- EXPECT_EQ("z", parser_.ins_[2].AsString());
-}
-
-TEST_F(DepfileParserTest, UnifyMultipleRulesCRLF) {
- string err;
- EXPECT_TRUE(Parse("foo: x\r\n"
- "foo: y\r\n"
- "foo \\\r\n"
- "foo: z\r\n", &err));
- ASSERT_EQ(1u, parser_.outs_.size());
- ASSERT_EQ("foo", parser_.outs_[0].AsString());
- ASSERT_EQ(3u, parser_.ins_.size());
- EXPECT_EQ("x", parser_.ins_[0].AsString());
- EXPECT_EQ("y", parser_.ins_[1].AsString());
- EXPECT_EQ("z", parser_.ins_[2].AsString());
-}
-
-TEST_F(DepfileParserTest, UnifyMixedRulesLF) {
- string err;
- EXPECT_TRUE(Parse("foo: x\\\n"
- " y\n"
- "foo \\\n"
- "foo: z\n", &err));
- ASSERT_EQ(1u, parser_.outs_.size());
- ASSERT_EQ("foo", parser_.outs_[0].AsString());
- ASSERT_EQ(3u, parser_.ins_.size());
- EXPECT_EQ("x", parser_.ins_[0].AsString());
- EXPECT_EQ("y", parser_.ins_[1].AsString());
- EXPECT_EQ("z", parser_.ins_[2].AsString());
-}
-
-TEST_F(DepfileParserTest, UnifyMixedRulesCRLF) {
- string err;
- EXPECT_TRUE(Parse("foo: x\\\r\n"
- " y\r\n"
- "foo \\\r\n"
- "foo: z\r\n", &err));
- ASSERT_EQ(1u, parser_.outs_.size());
- ASSERT_EQ("foo", parser_.outs_[0].AsString());
- ASSERT_EQ(3u, parser_.ins_.size());
- EXPECT_EQ("x", parser_.ins_[0].AsString());
- EXPECT_EQ("y", parser_.ins_[1].AsString());
- EXPECT_EQ("z", parser_.ins_[2].AsString());
-}
-
-TEST_F(DepfileParserTest, IndentedRulesLF) {
- string err;
- EXPECT_TRUE(Parse(" foo: x\n"
- " foo: y\n"
- " foo: z\n", &err));
- ASSERT_EQ(1u, parser_.outs_.size());
- ASSERT_EQ("foo", parser_.outs_[0].AsString());
- ASSERT_EQ(3u, parser_.ins_.size());
- EXPECT_EQ("x", parser_.ins_[0].AsString());
- EXPECT_EQ("y", parser_.ins_[1].AsString());
- EXPECT_EQ("z", parser_.ins_[2].AsString());
-}
-
-TEST_F(DepfileParserTest, IndentedRulesCRLF) {
- string err;
- EXPECT_TRUE(Parse(" foo: x\r\n"
- " foo: y\r\n"
- " foo: z\r\n", &err));
- ASSERT_EQ(1u, parser_.outs_.size());
- ASSERT_EQ("foo", parser_.outs_[0].AsString());
- ASSERT_EQ(3u, parser_.ins_.size());
- EXPECT_EQ("x", parser_.ins_[0].AsString());
- EXPECT_EQ("y", parser_.ins_[1].AsString());
- EXPECT_EQ("z", parser_.ins_[2].AsString());
-}
-
-TEST_F(DepfileParserTest, TolerateMP) {
- string err;
- EXPECT_TRUE(Parse("foo: x y z\n"
- "x:\n"
- "y:\n"
- "z:\n", &err));
- ASSERT_EQ(1u, parser_.outs_.size());
- ASSERT_EQ("foo", parser_.outs_[0].AsString());
- ASSERT_EQ(3u, parser_.ins_.size());
- EXPECT_EQ("x", parser_.ins_[0].AsString());
- EXPECT_EQ("y", parser_.ins_[1].AsString());
- EXPECT_EQ("z", parser_.ins_[2].AsString());
-}
-
-TEST_F(DepfileParserTest, MultipleRulesTolerateMP) {
- string err;
- EXPECT_TRUE(Parse("foo: x\n"
- "x:\n"
- "foo: y\n"
- "y:\n"
- "foo: z\n"
- "z:\n", &err));
- ASSERT_EQ(1u, parser_.outs_.size());
- ASSERT_EQ("foo", parser_.outs_[0].AsString());
- ASSERT_EQ(3u, parser_.ins_.size());
- EXPECT_EQ("x", parser_.ins_[0].AsString());
- EXPECT_EQ("y", parser_.ins_[1].AsString());
- EXPECT_EQ("z", parser_.ins_[2].AsString());
-}
-
-TEST_F(DepfileParserTest, MultipleRulesDifferentOutputs) {
- // check that multiple different outputs are accepted by the parser
- // when spread across multiple rules
- string err;
- EXPECT_TRUE(Parse("foo: x y\n"
- "bar: y z\n", &err));
- ASSERT_EQ(2u, parser_.outs_.size());
- ASSERT_EQ("foo", parser_.outs_[0].AsString());
- ASSERT_EQ("bar", parser_.outs_[1].AsString());
- ASSERT_EQ(3u, parser_.ins_.size());
- EXPECT_EQ("x", parser_.ins_[0].AsString());
- EXPECT_EQ("y", parser_.ins_[1].AsString());
- EXPECT_EQ("z", parser_.ins_[2].AsString());
-}
-
-TEST_F(DepfileParserTest, BuggyMP) {
- std::string err;
- EXPECT_FALSE(Parse("foo: x y z\n"
- "x: alsoin\n"
- "y:\n"
- "z:\n", &err));
- ASSERT_EQ("inputs may not also have inputs", err);
-}
diff --git a/src/deps_log.cc b/src/deps_log.cc
deleted file mode 100644
index b728379..0000000
--- a/src/deps_log.cc
+++ /dev/null
@@ -1,454 +0,0 @@
-// Copyright 2012 Google Inc. All Rights Reserved.
-//
-// Licensed under the Apache License, Version 2.0 (the "License");
-// you may not use this file except in compliance with the License.
-// You may obtain a copy of the License at
-//
-// http://www.apache.org/licenses/LICENSE-2.0
-//
-// Unless required by applicable law or agreed to in writing, software
-// distributed under the License is distributed on an "AS IS" BASIS,
-// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-// See the License for the specific language governing permissions and
-// limitations under the License.
-
-#include "deps_log.h"
-
-#include <assert.h>
-#include <stdio.h>
-#include <errno.h>
-#include <string.h>
-#ifndef _WIN32
-#include <unistd.h>
-#elif defined(_MSC_VER) && (_MSC_VER < 1900)
-typedef __int32 int32_t;
-typedef unsigned __int32 uint32_t;
-#endif
-
-#include "graph.h"
-#include "metrics.h"
-#include "state.h"
-#include "util.h"
-
-using namespace std;
-
-// The version is stored as 4 bytes after the signature and also serves as a
-// byte order mark. Signature and version combined are 16 bytes long.
-const char kFileSignature[] = "# ninjadeps\n";
-const int kCurrentVersion = 4;
-
-// Record size is currently limited to less than the full 32 bit, due to
-// internal buffers having to have this size.
-const unsigned kMaxRecordSize = (1 << 19) - 1;
-
-DepsLog::~DepsLog() {
- Close();
- for (const Deps* deps : deps_)
- delete deps;
-}
-
-bool DepsLog::OpenForWrite(const string& path, string* err) {
- if (needs_recompaction_) {
- if (!Recompact(path, err))
- return false;
- }
-
- assert(!file_);
- file_path_ = path; // we don't actually open the file right now, but will do
- // so on the first write attempt
- return true;
-}
-
-bool DepsLog::RecordDeps(Node* node, TimeStamp mtime,
- const vector<Node*>& nodes) {
- return RecordDeps(node, mtime, nodes.size(),
- nodes.empty() ? NULL : (Node**)&nodes.front());
-}
-
-bool DepsLog::RecordDeps(Node* node, TimeStamp mtime,
- int node_count, Node** nodes) {
- // Track whether there's any new data to be recorded.
- bool made_change = false;
-
- // Assign ids to all nodes that are missing one.
- if (node->id() < 0) {
- if (!RecordId(node))
- return false;
- made_change = true;
- }
- for (int i = 0; i < node_count; ++i) {
- if (nodes[i]->id() < 0) {
- if (!RecordId(nodes[i]))
- return false;
- made_change = true;
- }
- }
-
- // See if the new data is different than the existing data, if any.
- if (!made_change) {
- Deps* deps = GetDeps(node);
- if (!deps ||
- deps->mtime != mtime ||
- deps->node_count != node_count) {
- made_change = true;
- } else {
- for (int i = 0; i < node_count; ++i) {
- if (deps->nodes[i] != nodes[i]) {
- made_change = true;
- break;
- }
- }
- }
- }
-
- // Don't write anything if there's no new info.
- if (!made_change)
- return true;
-
- // Update on-disk representation.
- unsigned size = 4 * (1 + 2 + node_count);
- if (size > kMaxRecordSize) {
- errno = ERANGE;
- return false;
- }
-
- if (!OpenForWriteIfNeeded()) {
- return false;
- }
- size |= 0x80000000; // Deps record: set high bit.
- if (fwrite(&size, 4, 1, file_) < 1)
- return false;
- int id = node->id();
- if (fwrite(&id, 4, 1, file_) < 1)
- return false;
- uint32_t mtime_part = static_cast<uint32_t>(mtime & 0xffffffff);
- if (fwrite(&mtime_part, 4, 1, file_) < 1)
- return false;
- mtime_part = static_cast<uint32_t>((mtime >> 32) & 0xffffffff);
- if (fwrite(&mtime_part, 4, 1, file_) < 1)
- return false;
- for (int i = 0; i < node_count; ++i) {
- id = nodes[i]->id();
- if (fwrite(&id, 4, 1, file_) < 1)
- return false;
- }
- if (fflush(file_) != 0)
- return false;
-
- // Update in-memory representation.
- Deps* deps = new Deps(mtime, node_count);
- for (int i = 0; i < node_count; ++i)
- deps->nodes[i] = nodes[i];
- UpdateDeps(node->id(), deps);
-
- return true;
-}
-
-void DepsLog::Close() {
- OpenForWriteIfNeeded(); // create the file even if nothing has been recorded
- if (file_)
- fclose(file_);
- file_ = NULL;
-}
-
-LoadStatus DepsLog::Load(const string& path, State* state, string* err) {
- METRIC_RECORD_LOAD(".ninja_deps load");
- char buf[kMaxRecordSize + 1];
- FILE* f = fopen(path.c_str(), "rb");
- if (!f) {
- if (errno == ENOENT)
- return LOAD_NOT_FOUND;
- *err = strerror(errno);
- return LOAD_ERROR;
- }
-
- bool valid_header = true;
- int version = 0;
- if (!fgets(buf, sizeof(buf), f) || fread(&version, 4, 1, f) < 1)
- valid_header = false;
- // Note: For version differences, this should migrate to the new format.
- // But the v1 format could sometimes (rarely) end up with invalid data, so
- // don't migrate v1 to v3 to force a rebuild. (v2 only existed for a few days,
- // and there was no release with it, so pretend that it never happened.)
- if (!valid_header || strcmp(buf, kFileSignature) != 0 ||
- version != kCurrentVersion) {
- if (version == 1)
- *err = "deps log version change; rebuilding";
- else
- *err = "bad deps log signature or version; starting over";
- fclose(f);
- unlink(path.c_str());
- // Don't report this as a failure. An empty deps log will cause
- // us to rebuild the outputs anyway.
- return LOAD_SUCCESS;
- }
-
- long offset;
- bool read_failed = false;
- int unique_dep_record_count = 0;
- int total_dep_record_count = 0;
- for (;;) {
- offset = ftell(f);
-
- unsigned size;
- if (fread(&size, 4, 1, f) < 1) {
- if (!feof(f))
- read_failed = true;
- break;
- }
- bool is_deps = (size >> 31) != 0;
- size = size & 0x7FFFFFFF;
-
- if (size > kMaxRecordSize || fread(buf, size, 1, f) < 1) {
- read_failed = true;
- break;
- }
-
- if (is_deps) {
- assert(size % 4 == 0);
- int* deps_data = reinterpret_cast<int*>(buf);
- int out_id = deps_data[0];
- TimeStamp mtime;
- mtime = (TimeStamp)(((uint64_t)(unsigned int)deps_data[2] << 32) |
- (uint64_t)(unsigned int)deps_data[1]);
- deps_data += 3;
- int deps_count = (size / 4) - 3;
-
- Deps* deps = new Deps(mtime, deps_count);
- for (int i = 0; i < deps_count; ++i) {
- assert(deps_data[i] < (int)nodes_.size());
- assert(nodes_[deps_data[i]]);
- deps->nodes[i] = nodes_[deps_data[i]];
- }
-
- total_dep_record_count++;
- if (!UpdateDeps(out_id, deps))
- ++unique_dep_record_count;
- } else {
- int path_size = size - 4;
- assert(path_size > 0); // CanonicalizePath() rejects empty paths.
- // There can be up to 3 bytes of padding.
- if (buf[path_size - 1] == '\0') --path_size;
- if (buf[path_size - 1] == '\0') --path_size;
- if (buf[path_size - 1] == '\0') --path_size;
- StringPiece subpath(buf, path_size);
- // It is not necessary to pass in a correct slash_bits here. It will
- // either be a Node that's in the manifest (in which case it will already
- // have a correct slash_bits that GetNode will look up), or it is an
- // implicit dependency from a .d which does not affect the build command
- // (and so need not have its slashes maintained).
- Node* node = state->GetNode(subpath, 0);
-
- // Check that the expected index matches the actual index. This can only
- // happen if two ninja processes write to the same deps log concurrently.
- // (This uses unary complement to make the checksum look less like a
- // dependency record entry.)
- unsigned checksum = *reinterpret_cast<unsigned*>(buf + size - 4);
- int expected_id = ~checksum;
- int id = nodes_.size();
- if (id != expected_id) {
- read_failed = true;
- break;
- }
-
- assert(node->id() < 0);
- node->set_id(id);
- nodes_.push_back(node);
- }
- }
-
- if (read_failed) {
- // An error occurred while loading; try to recover by truncating the
- // file to the last fully-read record.
- if (ferror(f)) {
- *err = strerror(ferror(f));
- } else {
- *err = "premature end of file";
- }
- fclose(f);
-
- if (!Truncate(path, offset, err))
- return LOAD_ERROR;
-
- // The truncate succeeded; we'll just report the load error as a
- // warning because the build can proceed.
- *err += "; recovering";
- return LOAD_SUCCESS;
- }
-
- fclose(f);
-
- // Rebuild the log if there are too many dead records.
- int kMinCompactionEntryCount = 1000;
- int kCompactionRatio = 3;
- if (total_dep_record_count > kMinCompactionEntryCount &&
- total_dep_record_count > unique_dep_record_count * kCompactionRatio) {
- needs_recompaction_ = true;
- }
-
- return LOAD_SUCCESS;
-}
-
-DepsLog::Deps* DepsLog::GetDeps(Node* node) {
- // Abort if the node has no id (never referenced in the deps) or if
- // there's no deps recorded for the node.
- if (node->id() < 0 || node->id() >= (int)deps_.size())
- return NULL;
- return deps_[node->id()];
-}
-
-Node* DepsLog::GetFirstReverseDepsNode(Node* node) {
- for (size_t id = 0; id < deps_.size(); ++id) {
- Deps* deps = deps_[id];
- if (!deps)
- continue;
- for (int i = 0; i < deps->node_count; ++i) {
- if (deps->nodes[i] == node)
- return nodes_[id];
- }
- }
- return NULL;
-}
-
-bool DepsLog::Recompact(const string& path, string* err) {
- METRIC_RECORD(".ninja_deps recompact");
-
- Close();
- string temp_path = path + ".recompact";
-
- // OpenForWrite() opens for append. Make sure it's not appending to a
- // left-over file from a previous recompaction attempt that crashed somehow.
- unlink(temp_path.c_str());
-
- DepsLog new_log;
- if (!new_log.OpenForWrite(temp_path, err))
- return false;
-
- // Clear all known ids so that new ones can be reassigned. The new indices
- // will refer to the ordering in new_log, not in the current log.
- for (vector<Node*>::iterator i = nodes_.begin(); i != nodes_.end(); ++i)
- (*i)->set_id(-1);
-
- // Write out all deps again.
- for (int old_id = 0; old_id < (int)deps_.size(); ++old_id) {
- Deps* deps = deps_[old_id];
- if (!deps) continue; // If nodes_[old_id] is a leaf, it has no deps.
-
- if (!IsDepsEntryLiveFor(nodes_[old_id]))
- continue;
-
- if (!new_log.RecordDeps(nodes_[old_id], deps->mtime,
- deps->node_count, deps->nodes)) {
- new_log.Close();
- return false;
- }
- }
-
- new_log.Close();
-
- // All nodes now have ids that refer to new_log, so steal its data.
- deps_.swap(new_log.deps_);
- nodes_.swap(new_log.nodes_);
-
- if (unlink(path.c_str()) < 0) {
- *err = strerror(errno);
- return false;
- }
-
- if (rename(temp_path.c_str(), path.c_str()) < 0) {
- *err = strerror(errno);
- return false;
- }
-
- return true;
-}
-
-bool DepsLog::IsDepsEntryLiveFor(const Node* node) {
- // Skip entries that don't have in-edges or whose edges don't have a
- // "deps" attribute. They were in the deps log from previous builds, but
- // the the files they were for were removed from the build and their deps
- // entries are no longer needed.
- // (Without the check for "deps", a chain of two or more nodes that each
- // had deps wouldn't be collected in a single recompaction.)
- return node->in_edge() && !node->in_edge()->GetBinding("deps").empty();
-}
-
-bool DepsLog::UpdateDeps(int out_id, Deps* deps) {
- if (out_id >= (int)deps_.size()) {
- deps_.resize(out_id + 1);
- }
-
- bool delete_old = deps_[out_id] != NULL;
- if (delete_old)
- delete deps_[out_id];
- deps_[out_id] = deps;
- return delete_old;
-}
-
-bool DepsLog::RecordId(Node* node) {
- int path_size = node->path().size();
- int padding = (4 - path_size % 4) % 4; // Pad path to 4 byte boundary.
-
- unsigned size = path_size + padding + 4;
- if (size > kMaxRecordSize) {
- errno = ERANGE;
- return false;
- }
-
- if (!OpenForWriteIfNeeded()) {
- return false;
- }
- if (fwrite(&size, 4, 1, file_) < 1)
- return false;
- if (fwrite(node->path().data(), path_size, 1, file_) < 1) {
- assert(!node->path().empty());
- return false;
- }
- if (padding && fwrite("\0\0", padding, 1, file_) < 1)
- return false;
- int id = nodes_.size();
- unsigned checksum = ~(unsigned)id;
- if (fwrite(&checksum, 4, 1, file_) < 1)
- return false;
- if (fflush(file_) != 0)
- return false;
-
- node->set_id(id);
- nodes_.push_back(node);
-
- return true;
-}
-
-bool DepsLog::OpenForWriteIfNeeded() {
- if (file_path_.empty()) {
- return true;
- }
- file_ = fopen(file_path_.c_str(), "ab");
- if (!file_) {
- return false;
- }
- // Set the buffer size to this and flush the file buffer after every record
- // to make sure records aren't written partially.
- if (setvbuf(file_, NULL, _IOFBF, kMaxRecordSize + 1) != 0) {
- return false;
- }
- SetCloseOnExec(fileno(file_));
-
- // Opening a file in append mode doesn't set the file pointer to the file's
- // end on Windows. Do that explicitly.
- fseek(file_, 0, SEEK_END);
-
- if (ftell(file_) == 0) {
- if (fwrite(kFileSignature, sizeof(kFileSignature) - 1, 1, file_) < 1) {
- return false;
- }
- if (fwrite(&kCurrentVersion, 4, 1, file_) < 1) {
- return false;
- }
- }
- if (fflush(file_) != 0) {
- return false;
- }
- file_path_.clear();
- return true;
-}
diff --git a/src/deps_log.h b/src/deps_log.h
deleted file mode 100644
index 166310f..0000000
--- a/src/deps_log.h
+++ /dev/null
@@ -1,132 +0,0 @@
-// Copyright 2012 Google Inc. All Rights Reserved.
-//
-// Licensed under the Apache License, Version 2.0 (the "License");
-// you may not use this file except in compliance with the License.
-// You may obtain a copy of the License at
-//
-// http://www.apache.org/licenses/LICENSE-2.0
-//
-// Unless required by applicable law or agreed to in writing, software
-// distributed under the License is distributed on an "AS IS" BASIS,
-// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-// See the License for the specific language governing permissions and
-// limitations under the License.
-
-#ifndef NINJA_DEPS_LOG_H_
-#define NINJA_DEPS_LOG_H_
-
-#include <string>
-#include <vector>
-
-#include <stdio.h>
-
-#include "load_status.h"
-#include "timestamp.h"
-
-struct Node;
-struct State;
-
-/// As build commands run they can output extra dependency information
-/// (e.g. header dependencies for C source) dynamically. DepsLog collects
-/// that information at build time and uses it for subsequent builds.
-///
-/// The on-disk format is based on two primary design constraints:
-/// - it must be written to as a stream (during the build, which may be
-/// interrupted);
-/// - it can be read all at once on startup. (Alternative designs, where
-/// it contains indexing information, were considered and discarded as
-/// too complicated to implement; if the file is small than reading it
-/// fully on startup is acceptable.)
-/// Here are some stats from the Windows Chrome dependency files, to
-/// help guide the design space. The total text in the files sums to
-/// 90mb so some compression is warranted to keep load-time fast.
-/// There's about 10k files worth of dependencies that reference about
-/// 40k total paths totalling 2mb of unique strings.
-///
-/// Based on these stats, here's the current design.
-/// The file is structured as version header followed by a sequence of records.
-/// Each record is either a path string or a dependency list.
-/// Numbering the path strings in file order gives them dense integer ids.
-/// A dependency list maps an output id to a list of input ids.
-///
-/// Concretely, a record is:
-/// four bytes record length, high bit indicates record type
-/// (but max record sizes are capped at 512kB)
-/// path records contain the string name of the path, followed by up to 3
-/// padding bytes to align on 4 byte boundaries, followed by the
-/// one's complement of the expected index of the record (to detect
-/// concurrent writes of multiple ninja processes to the log).
-/// dependency records are an array of 4-byte integers
-/// [output path id,
-/// output path mtime (lower 4 bytes), output path mtime (upper 4 bytes),
-/// input path id, input path id...]
-/// (The mtime is compared against the on-disk output path mtime
-/// to verify the stored data is up-to-date.)
-/// If two records reference the same output the latter one in the file
-/// wins, allowing updates to just be appended to the file. A separate
-/// repacking step can run occasionally to remove dead records.
-struct DepsLog {
- DepsLog() : needs_recompaction_(false), file_(NULL) {}
- ~DepsLog();
-
- // Writing (build-time) interface.
- bool OpenForWrite(const std::string& path, std::string* err);
- bool RecordDeps(Node* node, TimeStamp mtime, const std::vector<Node*>& nodes);
- bool RecordDeps(Node* node, TimeStamp mtime, int node_count, Node** nodes);
- void Close();
-
- // Reading (startup-time) interface.
- struct Deps {
- Deps(int64_t mtime, int node_count)
- : mtime(mtime), node_count(node_count), nodes(new Node*[node_count]) {}
- ~Deps() { delete [] nodes; }
- TimeStamp mtime;
- int node_count;
- Node** nodes;
- };
- LoadStatus Load(const std::string& path, State* state, std::string* err);
- Deps* GetDeps(Node* node);
- Node* GetFirstReverseDepsNode(Node* node);
-
- /// Rewrite the known log entries, throwing away old data.
- bool Recompact(const std::string& path, std::string* err);
-
- /// Returns if the deps entry for a node is still reachable from the manifest.
- ///
- /// The deps log can contain deps entries for files that were built in the
- /// past but are no longer part of the manifest. This function returns if
- /// this is the case for a given node. This function is slow, don't call
- /// it from code that runs on every build.
- static bool IsDepsEntryLiveFor(const Node* node);
-
- /// Used for tests.
- const std::vector<Node*>& nodes() const { return nodes_; }
- const std::vector<Deps*>& deps() const { return deps_; }
-
- /// Return the number of output paths in the deps log.
- size_t size() const { return nodes_.size(); }
-
- private:
- // Updates the in-memory representation. Takes ownership of |deps|.
- // Returns true if a prior deps record was deleted.
- bool UpdateDeps(int out_id, Deps* deps);
- // Write a node name record, assigning it an id.
- bool RecordId(Node* node);
-
- /// Should be called before using file_. When false is returned, errno will
- /// be set.
- bool OpenForWriteIfNeeded();
-
- bool needs_recompaction_;
- FILE* file_;
- std::string file_path_;
-
- /// Maps id -> Node.
- std::vector<Node*> nodes_;
- /// Maps id -> deps of that id.
- std::vector<Deps*> deps_;
-
- friend struct DepsLogTest;
-};
-
-#endif // NINJA_DEPS_LOG_H_
diff --git a/src/deps_log_test.cc b/src/deps_log_test.cc
deleted file mode 100644
index 274e700..0000000
--- a/src/deps_log_test.cc
+++ /dev/null
@@ -1,545 +0,0 @@
-// Copyright 2012 Google Inc. All Rights Reserved.
-//
-// Licensed under the Apache License, Version 2.0 (the "License");
-// you may not use this file except in compliance with the License.
-// You may obtain a copy of the License at
-//
-// http://www.apache.org/licenses/LICENSE-2.0
-//
-// Unless required by applicable law or agreed to in writing, software
-// distributed under the License is distributed on an "AS IS" BASIS,
-// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-// See the License for the specific language governing permissions and
-// limitations under the License.
-
-#include "deps_log.h"
-
-#include <sys/stat.h>
-#ifndef _WIN32
-#include <unistd.h>
-#endif
-
-#include "graph.h"
-#include "util.h"
-#include "test.h"
-
-using namespace std;
-
-namespace {
-
-const char kTestFilename[] = "DepsLogTest-tempfile";
-
-struct DepsLogTest : public testing::Test {
- virtual void SetUp() {
- // In case a crashing test left a stale file behind.
- unlink(kTestFilename);
- }
- virtual void TearDown() {
- unlink(kTestFilename);
- }
-};
-
-TEST_F(DepsLogTest, WriteRead) {
- State state1;
- DepsLog log1;
- string err;
- EXPECT_TRUE(log1.OpenForWrite(kTestFilename, &err));
- ASSERT_EQ("", err);
-
- {
- vector<Node*> deps;
- deps.push_back(state1.GetNode("foo.h", 0));
- deps.push_back(state1.GetNode("bar.h", 0));
- log1.RecordDeps(state1.GetNode("out.o", 0), 1, deps);
-
- deps.clear();
- deps.push_back(state1.GetNode("foo.h", 0));
- deps.push_back(state1.GetNode("bar2.h", 0));
- log1.RecordDeps(state1.GetNode("out2.o", 0), 2, deps);
-
- DepsLog::Deps* log_deps = log1.GetDeps(state1.GetNode("out.o", 0));
- ASSERT_TRUE(log_deps);
- ASSERT_EQ(1, log_deps->mtime);
- ASSERT_EQ(2, log_deps->node_count);
- ASSERT_EQ("foo.h", log_deps->nodes[0]->path());
- ASSERT_EQ("bar.h", log_deps->nodes[1]->path());
- }
-
- log1.Close();
-
- State state2;
- DepsLog log2;
- EXPECT_TRUE(log2.Load(kTestFilename, &state2, &err));
- ASSERT_EQ("", err);
-
- ASSERT_EQ(log1.nodes().size(), log2.nodes().size());
- for (int i = 0; i < (int)log1.nodes().size(); ++i) {
- Node* node1 = log1.nodes()[i];
- Node* node2 = log2.nodes()[i];
- ASSERT_EQ(i, node1->id());
- ASSERT_EQ(node1->id(), node2->id());
- }
-
- // Spot-check the entries in log2.
- DepsLog::Deps* log_deps = log2.GetDeps(state2.GetNode("out2.o", 0));
- ASSERT_TRUE(log_deps);
- ASSERT_EQ(2, log_deps->mtime);
- ASSERT_EQ(2, log_deps->node_count);
- ASSERT_EQ("foo.h", log_deps->nodes[0]->path());
- ASSERT_EQ("bar2.h", log_deps->nodes[1]->path());
-}
-
-TEST_F(DepsLogTest, LotsOfDeps) {
- const int kNumDeps = 100000; // More than 64k.
-
- State state1;
- DepsLog log1;
- string err;
- EXPECT_TRUE(log1.OpenForWrite(kTestFilename, &err));
- ASSERT_EQ("", err);
-
- {
- vector<Node*> deps;
- for (int i = 0; i < kNumDeps; ++i) {
- char buf[32];
- sprintf(buf, "file%d.h", i);
- deps.push_back(state1.GetNode(buf, 0));
- }
- log1.RecordDeps(state1.GetNode("out.o", 0), 1, deps);
-
- DepsLog::Deps* log_deps = log1.GetDeps(state1.GetNode("out.o", 0));
- ASSERT_EQ(kNumDeps, log_deps->node_count);
- }
-
- log1.Close();
-
- State state2;
- DepsLog log2;
- EXPECT_TRUE(log2.Load(kTestFilename, &state2, &err));
- ASSERT_EQ("", err);
-
- DepsLog::Deps* log_deps = log2.GetDeps(state2.GetNode("out.o", 0));
- ASSERT_EQ(kNumDeps, log_deps->node_count);
-}
-
-// Verify that adding the same deps twice doesn't grow the file.
-TEST_F(DepsLogTest, DoubleEntry) {
- // Write some deps to the file and grab its size.
- int file_size;
- {
- State state;
- DepsLog log;
- string err;
- EXPECT_TRUE(log.OpenForWrite(kTestFilename, &err));
- ASSERT_EQ("", err);
-
- vector<Node*> deps;
- deps.push_back(state.GetNode("foo.h", 0));
- deps.push_back(state.GetNode("bar.h", 0));
- log.RecordDeps(state.GetNode("out.o", 0), 1, deps);
- log.Close();
-#ifdef __USE_LARGEFILE64
- struct stat64 st;
- ASSERT_EQ(0, stat64(kTestFilename, &st));
-#else
- struct stat st;
- ASSERT_EQ(0, stat(kTestFilename, &st));
-#endif
- file_size = (int)st.st_size;
- ASSERT_GT(file_size, 0);
- }
-
- // Now reload the file, and read the same deps.
- {
- State state;
- DepsLog log;
- string err;
- EXPECT_TRUE(log.Load(kTestFilename, &state, &err));
-
- EXPECT_TRUE(log.OpenForWrite(kTestFilename, &err));
- ASSERT_EQ("", err);
-
- vector<Node*> deps;
- deps.push_back(state.GetNode("foo.h", 0));
- deps.push_back(state.GetNode("bar.h", 0));
- log.RecordDeps(state.GetNode("out.o", 0), 1, deps);
- log.Close();
-#ifdef __USE_LARGEFILE64
- struct stat64 st;
- ASSERT_EQ(0, stat64(kTestFilename, &st));
-#else
- struct stat st;
- ASSERT_EQ(0, stat(kTestFilename, &st));
-#endif
- int file_size_2 = (int)st.st_size;
- ASSERT_EQ(file_size, file_size_2);
- }
-}
-
-// Verify that adding the new deps works and can be compacted away.
-TEST_F(DepsLogTest, Recompact) {
- const char kManifest[] =
-"rule cc\n"
-" command = cc\n"
-" deps = gcc\n"
-"build out.o: cc\n"
-"build other_out.o: cc\n";
-
- // Write some deps to the file and grab its size.
- int file_size;
- {
- State state;
- ASSERT_NO_FATAL_FAILURE(AssertParse(&state, kManifest));
- DepsLog log;
- string err;
- ASSERT_TRUE(log.OpenForWrite(kTestFilename, &err));
- ASSERT_EQ("", err);
-
- vector<Node*> deps;
- deps.push_back(state.GetNode("foo.h", 0));
- deps.push_back(state.GetNode("bar.h", 0));
- log.RecordDeps(state.GetNode("out.o", 0), 1, deps);
-
- deps.clear();
- deps.push_back(state.GetNode("foo.h", 0));
- deps.push_back(state.GetNode("baz.h", 0));
- log.RecordDeps(state.GetNode("other_out.o", 0), 1, deps);
-
- log.Close();
-#ifdef __USE_LARGEFILE64
- struct stat64 st;
- ASSERT_EQ(0, stat64(kTestFilename, &st));
-#else
- struct stat st;
- ASSERT_EQ(0, stat(kTestFilename, &st));
-#endif
- file_size = (int)st.st_size;
- ASSERT_GT(file_size, 0);
- }
-
- // Now reload the file, and add slightly different deps.
- int file_size_2;
- {
- State state;
- ASSERT_NO_FATAL_FAILURE(AssertParse(&state, kManifest));
- DepsLog log;
- string err;
- ASSERT_TRUE(log.Load(kTestFilename, &state, &err));
-
- ASSERT_TRUE(log.OpenForWrite(kTestFilename, &err));
- ASSERT_EQ("", err);
-
- vector<Node*> deps;
- deps.push_back(state.GetNode("foo.h", 0));
- log.RecordDeps(state.GetNode("out.o", 0), 1, deps);
- log.Close();
-
-#ifdef __USE_LARGEFILE64
- struct stat64 st;
- ASSERT_EQ(0, stat64(kTestFilename, &st));
-#else
- struct stat st;
- ASSERT_EQ(0, stat(kTestFilename, &st));
-#endif
- file_size_2 = (int)st.st_size;
- // The file should grow to record the new deps.
- ASSERT_GT(file_size_2, file_size);
- }
-
- // Now reload the file, verify the new deps have replaced the old, then
- // recompact.
- int file_size_3;
- {
- State state;
- ASSERT_NO_FATAL_FAILURE(AssertParse(&state, kManifest));
- DepsLog log;
- string err;
- ASSERT_TRUE(log.Load(kTestFilename, &state, &err));
-
- Node* out = state.GetNode("out.o", 0);
- DepsLog::Deps* deps = log.GetDeps(out);
- ASSERT_TRUE(deps);
- ASSERT_EQ(1, deps->mtime);
- ASSERT_EQ(1, deps->node_count);
- ASSERT_EQ("foo.h", deps->nodes[0]->path());
-
- Node* other_out = state.GetNode("other_out.o", 0);
- deps = log.GetDeps(other_out);
- ASSERT_TRUE(deps);
- ASSERT_EQ(1, deps->mtime);
- ASSERT_EQ(2, deps->node_count);
- ASSERT_EQ("foo.h", deps->nodes[0]->path());
- ASSERT_EQ("baz.h", deps->nodes[1]->path());
-
- ASSERT_TRUE(log.Recompact(kTestFilename, &err));
-
- // The in-memory deps graph should still be valid after recompaction.
- deps = log.GetDeps(out);
- ASSERT_TRUE(deps);
- ASSERT_EQ(1, deps->mtime);
- ASSERT_EQ(1, deps->node_count);
- ASSERT_EQ("foo.h", deps->nodes[0]->path());
- ASSERT_EQ(out, log.nodes()[out->id()]);
-
- deps = log.GetDeps(other_out);
- ASSERT_TRUE(deps);
- ASSERT_EQ(1, deps->mtime);
- ASSERT_EQ(2, deps->node_count);
- ASSERT_EQ("foo.h", deps->nodes[0]->path());
- ASSERT_EQ("baz.h", deps->nodes[1]->path());
- ASSERT_EQ(other_out, log.nodes()[other_out->id()]);
-
- // The file should have shrunk a bit for the smaller deps.
-#ifdef __USE_LARGEFILE64
- struct stat64 st;
- ASSERT_EQ(0, stat64(kTestFilename, &st));
-#else
- struct stat st;
- ASSERT_EQ(0, stat(kTestFilename, &st));
-#endif
- file_size_3 = (int)st.st_size;
- ASSERT_LT(file_size_3, file_size_2);
- }
-
- // Now reload the file and recompact with an empty manifest. The previous
- // entries should be removed.
- {
- State state;
- // Intentionally not parsing kManifest here.
- DepsLog log;
- string err;
- ASSERT_TRUE(log.Load(kTestFilename, &state, &err));
-
- Node* out = state.GetNode("out.o", 0);
- DepsLog::Deps* deps = log.GetDeps(out);
- ASSERT_TRUE(deps);
- ASSERT_EQ(1, deps->mtime);
- ASSERT_EQ(1, deps->node_count);
- ASSERT_EQ("foo.h", deps->nodes[0]->path());
-
- Node* other_out = state.GetNode("other_out.o", 0);
- deps = log.GetDeps(other_out);
- ASSERT_TRUE(deps);
- ASSERT_EQ(1, deps->mtime);
- ASSERT_EQ(2, deps->node_count);
- ASSERT_EQ("foo.h", deps->nodes[0]->path());
- ASSERT_EQ("baz.h", deps->nodes[1]->path());
-
- ASSERT_TRUE(log.Recompact(kTestFilename, &err));
-
- // The previous entries should have been removed.
- deps = log.GetDeps(out);
- ASSERT_FALSE(deps);
-
- deps = log.GetDeps(other_out);
- ASSERT_FALSE(deps);
-
- // The .h files pulled in via deps should no longer have ids either.
- ASSERT_EQ(-1, state.LookupNode("foo.h")->id());
- ASSERT_EQ(-1, state.LookupNode("baz.h")->id());
-
- // The file should have shrunk more.
-#ifdef __USE_LARGEFILE64
- struct stat64 st;
- ASSERT_EQ(0, stat64(kTestFilename, &st));
-#else
- struct stat st;
- ASSERT_EQ(0, stat(kTestFilename, &st));
-#endif
- int file_size_4 = (int)st.st_size;
- ASSERT_LT(file_size_4, file_size_3);
- }
-}
-
-// Verify that invalid file headers cause a new build.
-TEST_F(DepsLogTest, InvalidHeader) {
- const char *kInvalidHeaders[] = {
- "", // Empty file.
- "# ninjad", // Truncated first line.
- "# ninjadeps\n", // No version int.
- "# ninjadeps\n\001\002", // Truncated version int.
- "# ninjadeps\n\001\002\003\004" // Invalid version int.
- };
- for (size_t i = 0; i < sizeof(kInvalidHeaders) / sizeof(kInvalidHeaders[0]);
- ++i) {
- FILE* deps_log = fopen(kTestFilename, "wb");
- ASSERT_TRUE(deps_log != NULL);
- ASSERT_EQ(
- strlen(kInvalidHeaders[i]),
- fwrite(kInvalidHeaders[i], 1, strlen(kInvalidHeaders[i]), deps_log));
- ASSERT_EQ(0 ,fclose(deps_log));
-
- string err;
- DepsLog log;
- State state;
- ASSERT_TRUE(log.Load(kTestFilename, &state, &err));
- EXPECT_EQ("bad deps log signature or version; starting over", err);
- }
-}
-
-// Simulate what happens when loading a truncated log file.
-TEST_F(DepsLogTest, Truncated) {
- // Create a file with some entries.
- {
- State state;
- DepsLog log;
- string err;
- EXPECT_TRUE(log.OpenForWrite(kTestFilename, &err));
- ASSERT_EQ("", err);
-
- vector<Node*> deps;
- deps.push_back(state.GetNode("foo.h", 0));
- deps.push_back(state.GetNode("bar.h", 0));
- log.RecordDeps(state.GetNode("out.o", 0), 1, deps);
-
- deps.clear();
- deps.push_back(state.GetNode("foo.h", 0));
- deps.push_back(state.GetNode("bar2.h", 0));
- log.RecordDeps(state.GetNode("out2.o", 0), 2, deps);
-
- log.Close();
- }
-
- // Get the file size.
-#ifdef __USE_LARGEFILE64
- struct stat64 st;
- ASSERT_EQ(0, stat64(kTestFilename, &st));
-#else
- struct stat st;
- ASSERT_EQ(0, stat(kTestFilename, &st));
-#endif
-
- // Try reloading at truncated sizes.
- // Track how many nodes/deps were found; they should decrease with
- // smaller sizes.
- int node_count = 5;
- int deps_count = 2;
- for (int size = (int)st.st_size; size > 0; --size) {
- string err;
- ASSERT_TRUE(Truncate(kTestFilename, size, &err));
-
- State state;
- DepsLog log;
- EXPECT_TRUE(log.Load(kTestFilename, &state, &err));
- if (!err.empty()) {
- // At some point the log will be so short as to be unparsable.
- break;
- }
-
- ASSERT_GE(node_count, (int)log.nodes().size());
- node_count = log.nodes().size();
-
- // Count how many non-NULL deps entries there are.
- int new_deps_count = 0;
- for (vector<DepsLog::Deps*>::const_iterator i = log.deps().begin();
- i != log.deps().end(); ++i) {
- if (*i)
- ++new_deps_count;
- }
- ASSERT_GE(deps_count, new_deps_count);
- deps_count = new_deps_count;
- }
-}
-
-// Run the truncation-recovery logic.
-TEST_F(DepsLogTest, TruncatedRecovery) {
- // Create a file with some entries.
- {
- State state;
- DepsLog log;
- string err;
- EXPECT_TRUE(log.OpenForWrite(kTestFilename, &err));
- ASSERT_EQ("", err);
-
- vector<Node*> deps;
- deps.push_back(state.GetNode("foo.h", 0));
- deps.push_back(state.GetNode("bar.h", 0));
- log.RecordDeps(state.GetNode("out.o", 0), 1, deps);
-
- deps.clear();
- deps.push_back(state.GetNode("foo.h", 0));
- deps.push_back(state.GetNode("bar2.h", 0));
- log.RecordDeps(state.GetNode("out2.o", 0), 2, deps);
-
- log.Close();
- }
-
- // Shorten the file, corrupting the last record.
- {
-#ifdef __USE_LARGEFILE64
- struct stat64 st;
- ASSERT_EQ(0, stat64(kTestFilename, &st));
-#else
- struct stat st;
- ASSERT_EQ(0, stat(kTestFilename, &st));
-#endif
- string err;
- ASSERT_TRUE(Truncate(kTestFilename, st.st_size - 2, &err));
- }
-
- // Load the file again, add an entry.
- {
- State state;
- DepsLog log;
- string err;
- EXPECT_TRUE(log.Load(kTestFilename, &state, &err));
- ASSERT_EQ("premature end of file; recovering", err);
- err.clear();
-
- // The truncated entry should've been discarded.
- EXPECT_NULL(log.GetDeps(state.GetNode("out2.o", 0)));
-
- EXPECT_TRUE(log.OpenForWrite(kTestFilename, &err));
- ASSERT_EQ("", err);
-
- // Add a new entry.
- vector<Node*> deps;
- deps.push_back(state.GetNode("foo.h", 0));
- deps.push_back(state.GetNode("bar2.h", 0));
- log.RecordDeps(state.GetNode("out2.o", 0), 3, deps);
-
- log.Close();
- }
-
- // Load the file a third time to verify appending after a mangled
- // entry doesn't break things.
- {
- State state;
- DepsLog log;
- string err;
- EXPECT_TRUE(log.Load(kTestFilename, &state, &err));
-
- // The truncated entry should exist.
- DepsLog::Deps* deps = log.GetDeps(state.GetNode("out2.o", 0));
- ASSERT_TRUE(deps);
- }
-}
-
-TEST_F(DepsLogTest, ReverseDepsNodes) {
- State state;
- DepsLog log;
- string err;
- EXPECT_TRUE(log.OpenForWrite(kTestFilename, &err));
- ASSERT_EQ("", err);
-
- vector<Node*> deps;
- deps.push_back(state.GetNode("foo.h", 0));
- deps.push_back(state.GetNode("bar.h", 0));
- log.RecordDeps(state.GetNode("out.o", 0), 1, deps);
-
- deps.clear();
- deps.push_back(state.GetNode("foo.h", 0));
- deps.push_back(state.GetNode("bar2.h", 0));
- log.RecordDeps(state.GetNode("out2.o", 0), 2, deps);
-
- log.Close();
-
- Node* rev_deps = log.GetFirstReverseDepsNode(state.GetNode("foo.h", 0));
- EXPECT_TRUE(rev_deps == state.GetNode("out.o", 0) ||
- rev_deps == state.GetNode("out2.o", 0));
-
- rev_deps = log.GetFirstReverseDepsNode(state.GetNode("bar.h", 0));
- EXPECT_TRUE(rev_deps == state.GetNode("out.o", 0));
-}
-
-} // anonymous namespace
diff --git a/src/disk_interface.cc b/src/disk_interface.cc
deleted file mode 100644
index ff7f515..0000000
--- a/src/disk_interface.cc
+++ /dev/null
@@ -1,212 +0,0 @@
-// Copyright 2011 Google Inc. All Rights Reserved.
-//
-// Licensed under the Apache License, Version 2.0 (the "License");
-// you may not use this file except in compliance with the License.
-// You may obtain a copy of the License at
-//
-// http://www.apache.org/licenses/LICENSE-2.0
-//
-// Unless required by applicable law or agreed to in writing, software
-// distributed under the License is distributed on an "AS IS" BASIS,
-// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-// See the License for the specific language governing permissions and
-// limitations under the License.
-
-#include "disk_interface.h"
-
-#include <algorithm>
-
-#include <errno.h>
-#include <stdio.h>
-#include <string.h>
-#include <sys/stat.h>
-#include <sys/types.h>
-
-#ifdef _WIN32
-#include <sstream>
-#include <windows.h>
-#include <direct.h> // _mkdir
-#else
-#include <unistd.h>
-#endif
-
-#include "metrics.h"
-#include "util.h"
-
-using namespace std;
-
-namespace {
-
-string DirName(const string& path) {
-#ifdef _WIN32
- static const char kPathSeparators[] = "\\/";
-#else
- static const char kPathSeparators[] = "/";
-#endif
- static const char* const kEnd = kPathSeparators + sizeof(kPathSeparators) - 1;
-
- string::size_type slash_pos = path.find_last_of(kPathSeparators);
- if (slash_pos == string::npos)
- return string(); // Nothing to do.
- while (slash_pos > 0 &&
- std::find(kPathSeparators, kEnd, path[slash_pos - 1]) != kEnd)
- --slash_pos;
- return path.substr(0, slash_pos);
-}
-
-int MakeDir(const string& path) {
-#ifdef _WIN32
- return _mkdir(path.c_str());
-#else
- return mkdir(path.c_str(), 0777);
-#endif
-}
-
-} // namespace
-
-// DiskInterface ---------------------------------------------------------------
-
-bool DiskInterface::MakeDirs(const string& path) {
- string dir = DirName(path);
- if (dir.empty())
- return true; // Reached root; assume it's there.
- string err;
- TimeStamp mtime = Stat(dir, &err);
- if (mtime < 0) {
- Error("%s", err.c_str());
- return false;
- }
- if (mtime > 0)
- return true; // Exists already; we're done.
-
- // Directory doesn't exist. Try creating its parent first.
- bool success = MakeDirs(dir);
- if (!success)
- return false;
- return MakeDir(dir);
-}
-
-// RealDiskInterface -----------------------------------------------------------
-
-TimeStamp RealDiskInterface::Stat(const string& path, string* err) const {
- METRIC_RECORD("node stat");
- return stat_cache_.Stat(path, err);
-}
-
-bool RealDiskInterface::WriteFile(const string& path, const string& contents) {
- FILE* fp = fopen(path.c_str(), "w");
- if (fp == NULL) {
- Error("WriteFile(%s): Unable to create file. %s",
- path.c_str(), strerror(errno));
- return false;
- }
-
- stat_cache_.Invalidate(path);
- if (fwrite(contents.data(), 1, contents.length(), fp) < contents.length()) {
- Error("WriteFile(%s): Unable to write to the file. %s",
- path.c_str(), strerror(errno));
- fclose(fp);
- return false;
- }
-
- if (fclose(fp) == EOF) {
- Error("WriteFile(%s): Unable to close the file. %s",
- path.c_str(), strerror(errno));
- return false;
- }
-
- return true;
-}
-
-bool RealDiskInterface::MakeDir(const string& path) {
- int ret = ::MakeDir(path);
- if (ret < 0 && errno == EEXIST)
- return true;
-
- int saved_errno = errno;
- // Invalidate just in case the call modified something on the disk.
- stat_cache_.Invalidate(path);
- if (ret < 0) {
- Error("mkdir(%s): %s", path.c_str(), strerror(saved_errno));
- return false;
- }
- return true;
-}
-
-FileReader::Status RealDiskInterface::ReadFile(const string& path,
- string* contents,
- string* err) {
- switch (::ReadFile(path, contents, err)) {
- case 0: return Okay;
- case -ENOENT: return NotFound;
- default: return OtherError;
- }
-}
-
-int RealDiskInterface::RemoveFile(const string& path) {
- stat_cache_.Invalidate(path);
-#ifdef _WIN32
- DWORD attributes = GetFileAttributesA(path.c_str());
- if (attributes == INVALID_FILE_ATTRIBUTES) {
- DWORD win_err = GetLastError();
- if (win_err == ERROR_FILE_NOT_FOUND || win_err == ERROR_PATH_NOT_FOUND) {
- return 1;
- }
- } else if (attributes & FILE_ATTRIBUTE_READONLY) {
- // On non-Windows systems, remove() will happily delete read-only files.
- // On Windows Ninja should behave the same:
- // https://github.com/ninja-build/ninja/issues/1886
- // Skip error checking. If this fails, accept whatever happens below.
- SetFileAttributesA(path.c_str(), attributes & ~FILE_ATTRIBUTE_READONLY);
- }
- if (attributes & FILE_ATTRIBUTE_DIRECTORY) {
- // remove() deletes both files and directories. On Windows we have to
- // select the correct function (DeleteFile will yield Permission Denied when
- // used on a directory)
- // This fixes the behavior of ninja -t clean in some cases
- // https://github.com/ninja-build/ninja/issues/828
- if (!RemoveDirectoryA(path.c_str())) {
- DWORD win_err = GetLastError();
- if (win_err == ERROR_FILE_NOT_FOUND || win_err == ERROR_PATH_NOT_FOUND) {
- return 1;
- }
- // Report remove(), not RemoveDirectory(), for cross-platform consistency.
- Error("remove(%s): %s", path.c_str(), GetLastErrorString().c_str());
- return -1;
- }
- } else {
- if (!DeleteFileA(path.c_str())) {
- DWORD win_err = GetLastError();
- if (win_err == ERROR_FILE_NOT_FOUND || win_err == ERROR_PATH_NOT_FOUND) {
- return 1;
- }
- // Report as remove(), not DeleteFile(), for cross-platform consistency.
- Error("remove(%s): %s", path.c_str(), GetLastErrorString().c_str());
- return -1;
- }
- }
-#else
- if (remove(path.c_str()) < 0) {
- switch (errno) {
- case ENOENT:
- return 1;
- default:
- Error("remove(%s): %s", path.c_str(), strerror(errno));
- return -1;
- }
- }
-#endif
- return 0;
-}
-
-void RealDiskInterface::AllowStatCache(bool allow) {
- stat_cache_.Enable(allow);
-}
-
-void RealDiskInterface::Sync() {
- stat_cache_.Sync();
-}
-
-void RealDiskInterface::FlushCache() {
- stat_cache_.Flush();
-}
diff --git a/src/disk_interface.h b/src/disk_interface.h
deleted file mode 100644
index 27960aa..0000000
--- a/src/disk_interface.h
+++ /dev/null
@@ -1,149 +0,0 @@
-// Copyright 2011 Google Inc. All Rights Reserved.
-//
-// Licensed under the Apache License, Version 2.0 (the "License");
-// you may not use this file except in compliance with the License.
-// You may obtain a copy of the License at
-//
-// http://www.apache.org/licenses/LICENSE-2.0
-//
-// Unless required by applicable law or agreed to in writing, software
-// distributed under the License is distributed on an "AS IS" BASIS,
-// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-// See the License for the specific language governing permissions and
-// limitations under the License.
-
-#ifndef NINJA_DISK_INTERFACE_H_
-#define NINJA_DISK_INTERFACE_H_
-
-#include <map>
-#include <string>
-#include <vector>
-
-#include "stat_cache.h"
-#include "timestamp.h"
-
-/// Interface for reading files from disk. See DiskInterface for details.
-/// This base offers the minimum interface needed just to read files.
-struct FileReader {
- virtual ~FileReader() {}
-
- /// Result of ReadFile.
- enum Status {
- Okay,
- NotFound,
- OtherError
- };
-
- /// Read and store in given string. On success, return Okay.
- /// On error, return another Status and fill |err|.
- virtual Status ReadFile(const std::string& path, std::string* contents,
- std::string* err) = 0;
-};
-
-/// Interface for accessing the disk.
-///
-/// Abstract so it can be mocked out for tests. The real implementation
-/// is RealDiskInterface.
-struct DiskInterface: public FileReader {
- /// stat() a file, returning the mtime, or 0 if missing and -1 on
- /// other errors.
- virtual TimeStamp Stat(const std::string& path, std::string* err) const = 0;
-
- /// Create a directory, returning false on failure.
- virtual bool MakeDir(const std::string& path) = 0;
-
- /// Create a file, with the specified name and contents
- /// Returns true on success, false on failure
- virtual bool WriteFile(const std::string& path,
- const std::string& contents) = 0;
-
- /// Remove the file named @a path. It behaves like 'rm -f path' so no errors
- /// are reported if it does not exists.
- /// @returns 0 if the file has been removed,
- /// 1 if the file does not exist, and
- /// -1 if an error occurs.
- virtual int RemoveFile(const std::string& path) = 0;
-
- /// Create all the parent directories for path; like mkdir -p
- /// `basename path`.
- bool MakeDirs(const std::string& path);
-
- /// Sync with real filesystem state, which is useful when a timestamp cache
- /// is implemented using a directory-watching system service. Calling this
- /// is only needed when calling Stat() on files that may have been modified
- /// through a different interface (e.g. files modified by command
- /// sub-processes).
- virtual void Sync() {}
-};
-
-/// Implementation of FileReader that tracks opened file paths and their
-/// timestamps. This is useful to quickly check whether one of the Ninja
-/// input manifests has changed, since even for a large Fuchsia build, there
-/// are only around 7000 files, compared to the 1,000,000 file paths in the
-/// corresponding build graph. This class will probably become obsolete when a
-/// proper filesystem-watching timestamp cache is implemented.
-struct PathRecordingFileReader : public FileReader {
- explicit PathRecordingFileReader(DiskInterface* disk_interface)
- : disk_interface_(disk_interface) {}
-
- Status ReadFile(const std::string& path, std::string* contents,
- std::string* err) override {
- entries_.emplace_back(path, disk_interface_->Stat(path, err));
- return disk_interface_->ReadFile(path, contents, err);
- }
-
- /// Drop all timestamps from the cache.
- void Reset() { entries_.clear(); }
-
- /// Return true if any recorded path was modified.
- bool CheckOutOfDate() const {
- for (const auto& entry : entries_) {
- /// Note that Ninja never follows symlinks by design, even for its input
- /// manifest files, so this implementation just calls Stat() to avoid
- /// changing its behavior.
- if (disk_interface_->Stat(entry.path, nullptr) != entry.mtime)
- return true;
- }
- return false;
- }
-
- private:
- struct Entry {
- Entry(const std::string& path, TimeStamp mtime)
- : path(path), mtime(mtime) {}
-
- std::string path;
- TimeStamp mtime;
- };
-
- DiskInterface* disk_interface_;
- std::vector<Entry> entries_;
-};
-
-/// Implementation of DiskInterface that actually hits the disk.
-struct RealDiskInterface : public DiskInterface {
- RealDiskInterface() = default;
- virtual ~RealDiskInterface() = default;
- TimeStamp Stat(const std::string& path, std::string* err) const override;
- bool MakeDir(const std::string& path) override;
- bool WriteFile(const std::string& path, const std::string& contents) override;
- Status ReadFile(const std::string& path, std::string* contents,
- std::string* err) override;
- int RemoveFile(const std::string& path) override;
-
- /// Whether stat information can be cached. Only has an effect on Windows.
- void AllowStatCache(bool allow);
-
- /// If StatCache is allowed, synchronize it with the current filesystem
- /// state. This is used to drain pending events from filesystem monitoring
- /// services like inotify on Linux.
- void Sync() override;
-
- /// Remove all cached stat information, if any.
- void FlushCache();
-
- private:
- StatCache stat_cache_;
-};
-
-#endif // NINJA_DISK_INTERFACE_H_
diff --git a/src/disk_interface_test.cc b/src/disk_interface_test.cc
deleted file mode 100644
index d37c412..0000000
--- a/src/disk_interface_test.cc
+++ /dev/null
@@ -1,359 +0,0 @@
-// Copyright 2011 Google Inc. All Rights Reserved.
-//
-// Licensed under the Apache License, Version 2.0 (the "License");
-// you may not use this file except in compliance with the License.
-// You may obtain a copy of the License at
-//
-// http://www.apache.org/licenses/LICENSE-2.0
-//
-// Unless required by applicable law or agreed to in writing, software
-// distributed under the License is distributed on an "AS IS" BASIS,
-// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-// See the License for the specific language governing permissions and
-// limitations under the License.
-
-#include <assert.h>
-#include <stdio.h>
-#ifdef _WIN32
-#include <io.h>
-#include <windows.h>
-#endif
-
-#include "disk_interface.h"
-#include "graph.h"
-#include "test.h"
-
-using namespace std;
-
-namespace {
-
-struct DiskInterfaceTest : public testing::Test {
- virtual void SetUp() {
- // These tests do real disk accesses, so create a temp dir.
- temp_dir_.CreateAndEnter("Ninja-DiskInterfaceTest");
- }
-
- virtual void TearDown() {
- temp_dir_.Cleanup();
- }
-
- bool Touch(const char* path) {
- FILE *f = fopen(path, "w");
- if (!f)
- return false;
- return fclose(f) == 0;
- }
-
- ScopedTempDir temp_dir_;
- RealDiskInterface disk_;
-};
-
-TEST_F(DiskInterfaceTest, StatMissingFile) {
- string err;
- EXPECT_EQ(0, disk_.Stat("nosuchfile", &err));
- EXPECT_EQ("", err);
-
- // On Windows, the errno for a file in a nonexistent directory
- // is different.
- EXPECT_EQ(0, disk_.Stat("nosuchdir/nosuchfile", &err));
- EXPECT_EQ("", err);
-
- // On POSIX systems, the errno is different if a component of the
- // path prefix is not a directory.
- ASSERT_TRUE(Touch("notadir"));
- EXPECT_EQ(0, disk_.Stat("notadir/nosuchfile", &err));
- EXPECT_EQ("", err);
-}
-
-TEST_F(DiskInterfaceTest, StatMissingFileWithCache) {
- disk_.AllowStatCache(true);
- string err;
-
- if (RunsUnderWine()) // This test fails under Wine.
- return;
-
- // On Windows, the errno for FindFirstFileExA, which is used when the stat
- // cache is enabled, is different when the directory name is not a directory.
- ASSERT_TRUE(Touch("notadir"));
- EXPECT_EQ(0, disk_.Stat("notadir/nosuchfile", &err));
- EXPECT_EQ("", err);
-}
-
-TEST_F(DiskInterfaceTest, StatBadPath) {
- // This test fails under Wine.
- if (RunsUnderWine())
- return;
-
- string err;
-#ifdef _WIN32
- string bad_path("cc:\\foo");
- EXPECT_EQ(-1, disk_.Stat(bad_path, &err));
- EXPECT_NE("", err);
-#else
- string too_long_name(512, 'x');
- EXPECT_EQ(-1, disk_.Stat(too_long_name, &err));
- EXPECT_NE("", err);
-#endif
-}
-
-TEST_F(DiskInterfaceTest, StatExistingFile) {
- string err;
- ASSERT_TRUE(Touch("file"));
- EXPECT_GT(disk_.Stat("file", &err), 1);
- EXPECT_EQ("", err);
-}
-
-TEST_F(DiskInterfaceTest, StatExistingDir) {
- string err;
- ASSERT_TRUE(disk_.MakeDir("subdir"));
- ASSERT_TRUE(disk_.MakeDir("subdir/subsubdir"));
- EXPECT_GT(disk_.Stat("..", &err), 1);
- EXPECT_EQ("", err);
- EXPECT_GT(disk_.Stat(".", &err), 1);
- EXPECT_EQ("", err);
- EXPECT_GT(disk_.Stat("subdir", &err), 1);
- EXPECT_EQ("", err);
- EXPECT_GT(disk_.Stat("subdir/subsubdir", &err), 1);
- EXPECT_EQ("", err);
-
- EXPECT_EQ(disk_.Stat("subdir", &err),
- disk_.Stat("subdir/.", &err));
- EXPECT_EQ(disk_.Stat("subdir", &err),
- disk_.Stat("subdir/subsubdir/..", &err));
- EXPECT_EQ(disk_.Stat("subdir/subsubdir", &err),
- disk_.Stat("subdir/subsubdir/.", &err));
-}
-
-#ifdef _WIN32
-TEST_F(DiskInterfaceTest, StatCache) {
- string err;
-
- ASSERT_TRUE(Touch("file1"));
- ASSERT_TRUE(Touch("fiLE2"));
- ASSERT_TRUE(disk_.MakeDir("subdir"));
- ASSERT_TRUE(disk_.MakeDir("subdir/subsubdir"));
- ASSERT_TRUE(Touch("subdir\\subfile1"));
- ASSERT_TRUE(Touch("subdir\\SUBFILE2"));
- ASSERT_TRUE(Touch("subdir\\SUBFILE3"));
-
- disk_.AllowStatCache(false);
- TimeStamp parent_stat_uncached = disk_.Stat("..", &err);
- disk_.AllowStatCache(true);
-
- EXPECT_GT(disk_.Stat("FIle1", &err), 1);
- EXPECT_EQ("", err);
- EXPECT_GT(disk_.Stat("file1", &err), 1);
- EXPECT_EQ("", err);
-
- EXPECT_GT(disk_.Stat("subdir/subfile2", &err), 1);
- EXPECT_EQ("", err);
- EXPECT_GT(disk_.Stat("sUbdir\\suBFile1", &err), 1);
- EXPECT_EQ("", err);
-
- EXPECT_GT(disk_.Stat("..", &err), 1);
- EXPECT_EQ("", err);
- EXPECT_GT(disk_.Stat(".", &err), 1);
- EXPECT_EQ("", err);
- EXPECT_GT(disk_.Stat("subdir", &err), 1);
- EXPECT_EQ("", err);
- EXPECT_GT(disk_.Stat("subdir/subsubdir", &err), 1);
- EXPECT_EQ("", err);
-
-#if 0 // TODO: Investigate why. Also see https://github.com/ninja-build/ninja/pull/1423
- EXPECT_EQ(disk_.Stat("subdir", &err),
- disk_.Stat("subdir/.", &err));
- EXPECT_EQ("", err);
- EXPECT_EQ(disk_.Stat("subdir", &err),
- disk_.Stat("subdir/subsubdir/..", &err));
-#endif
- EXPECT_EQ("", err);
- EXPECT_EQ(disk_.Stat("..", &err), parent_stat_uncached);
- EXPECT_EQ("", err);
- EXPECT_EQ(disk_.Stat("subdir/subsubdir", &err),
- disk_.Stat("subdir/subsubdir/.", &err));
- EXPECT_EQ("", err);
-
- if (RunsUnderWine()) // This test fails under Wine.
- return;
-
- // Test error cases.
- string bad_path("cc:\\foo");
- EXPECT_EQ(-1, disk_.Stat(bad_path, &err));
- EXPECT_NE("", err); err.clear();
- EXPECT_EQ(-1, disk_.Stat(bad_path, &err));
- EXPECT_NE("", err); err.clear();
- EXPECT_EQ(0, disk_.Stat("nosuchfile", &err));
- EXPECT_EQ("", err);
- EXPECT_EQ(0, disk_.Stat("nosuchdir/nosuchfile", &err));
- EXPECT_EQ("", err);
-}
-#endif
-
-TEST_F(DiskInterfaceTest, ReadFile) {
- string err;
- std::string content;
- ASSERT_EQ(DiskInterface::NotFound,
- disk_.ReadFile("foobar", &content, &err));
- EXPECT_EQ("", content);
- EXPECT_NE("", err); // actual value is platform-specific
- err.clear();
-
- const char* kTestFile = "testfile";
- FILE* f = fopen(kTestFile, "wb");
- ASSERT_TRUE(f);
- const char* kTestContent = "test content\nok";
- fprintf(f, "%s", kTestContent);
- ASSERT_EQ(0, fclose(f));
-
- ASSERT_EQ(DiskInterface::Okay,
- disk_.ReadFile(kTestFile, &content, &err));
- EXPECT_EQ(kTestContent, content);
- EXPECT_EQ("", err);
-}
-
-TEST_F(DiskInterfaceTest, MakeDirs) {
- string path = "path/with/double//slash/";
- EXPECT_TRUE(disk_.MakeDirs(path));
- FILE* f = fopen((path + "a_file").c_str(), "w");
- EXPECT_TRUE(f);
- EXPECT_EQ(0, fclose(f));
-#ifdef _WIN32
- string path2 = "another\\with\\back\\\\slashes\\";
- EXPECT_TRUE(disk_.MakeDirs(path2));
- FILE* f2 = fopen((path2 + "a_file").c_str(), "w");
- EXPECT_TRUE(f2);
- EXPECT_EQ(0, fclose(f2));
-#endif
-}
-
-TEST_F(DiskInterfaceTest, RemoveFile) {
- const char* kFileName = "file-to-remove";
- ASSERT_TRUE(Touch(kFileName));
- EXPECT_EQ(0, disk_.RemoveFile(kFileName));
- EXPECT_EQ(1, disk_.RemoveFile(kFileName));
- EXPECT_EQ(1, disk_.RemoveFile("does not exist"));
-#ifdef _WIN32
- ASSERT_TRUE(Touch(kFileName));
- EXPECT_EQ(0, system((std::string("attrib +R ") + kFileName).c_str()));
- EXPECT_EQ(0, disk_.RemoveFile(kFileName));
- EXPECT_EQ(1, disk_.RemoveFile(kFileName));
-#endif
-}
-
-TEST_F(DiskInterfaceTest, RemoveDirectory) {
- const char* kDirectoryName = "directory-to-remove";
- EXPECT_TRUE(disk_.MakeDir(kDirectoryName));
- EXPECT_EQ(0, disk_.RemoveFile(kDirectoryName));
- EXPECT_EQ(1, disk_.RemoveFile(kDirectoryName));
- EXPECT_EQ(1, disk_.RemoveFile("does not exist"));
-}
-
-struct StatTest : public StateTestWithBuiltinRules,
- public DiskInterface {
- StatTest() : scan_(&state_, NULL, NULL, this, NULL) {}
-
- // DiskInterface implementation.
- virtual TimeStamp Stat(const string& path, string* err) const;
- virtual bool WriteFile(const string& path, const string& contents) {
- assert(false);
- return true;
- }
- virtual bool MakeDir(const string& path) {
- assert(false);
- return false;
- }
- virtual Status ReadFile(const string& path, string* contents, string* err) {
- assert(false);
- return NotFound;
- }
- virtual int RemoveFile(const string& path) {
- assert(false);
- return 0;
- }
-
- DependencyScan scan_;
- map<string, TimeStamp> mtimes_;
- mutable vector<string> stats_;
-};
-
-TimeStamp StatTest::Stat(const string& path, string* err) const {
- stats_.push_back(path);
- map<string, TimeStamp>::const_iterator i = mtimes_.find(path);
- if (i == mtimes_.end())
- return 0; // File not found.
- return i->second;
-}
-
-TEST_F(StatTest, Simple) {
- ASSERT_NO_FATAL_FAILURE(AssertParse(&state_,
-"build out: cat in\n"));
-
- Node* out = GetNode("out");
- string err;
- EXPECT_TRUE(out->Stat(this, &err));
- EXPECT_EQ("", err);
- ASSERT_EQ(1u, stats_.size());
- scan_.RecomputeDirty(out, NULL, NULL);
- ASSERT_EQ(2u, stats_.size());
- ASSERT_EQ("out", stats_[0]);
- ASSERT_EQ("in", stats_[1]);
-}
-
-TEST_F(StatTest, TwoStep) {
- ASSERT_NO_FATAL_FAILURE(AssertParse(&state_,
-"build out: cat mid\n"
-"build mid: cat in\n"));
-
- Node* out = GetNode("out");
- string err;
- EXPECT_TRUE(out->Stat(this, &err));
- EXPECT_EQ("", err);
- ASSERT_EQ(1u, stats_.size());
- scan_.RecomputeDirty(out, NULL, NULL);
- ASSERT_EQ(3u, stats_.size());
- ASSERT_EQ("out", stats_[0]);
- ASSERT_TRUE(GetNode("out")->dirty());
- ASSERT_EQ("mid", stats_[1]);
- ASSERT_TRUE(GetNode("mid")->dirty());
- ASSERT_EQ("in", stats_[2]);
-}
-
-TEST_F(StatTest, Tree) {
- ASSERT_NO_FATAL_FAILURE(AssertParse(&state_,
-"build out: cat mid1 mid2\n"
-"build mid1: cat in11 in12\n"
-"build mid2: cat in21 in22\n"));
-
- Node* out = GetNode("out");
- string err;
- EXPECT_TRUE(out->Stat(this, &err));
- EXPECT_EQ("", err);
- ASSERT_EQ(1u, stats_.size());
- scan_.RecomputeDirty(out, NULL, NULL);
- ASSERT_EQ(1u + 6u, stats_.size());
- ASSERT_EQ("mid1", stats_[1]);
- ASSERT_TRUE(GetNode("mid1")->dirty());
- ASSERT_EQ("in11", stats_[2]);
-}
-
-TEST_F(StatTest, Middle) {
- ASSERT_NO_FATAL_FAILURE(AssertParse(&state_,
-"build out: cat mid\n"
-"build mid: cat in\n"));
-
- mtimes_["in"] = 1;
- mtimes_["mid"] = 0; // missing
- mtimes_["out"] = 1;
-
- Node* out = GetNode("out");
- string err;
- EXPECT_TRUE(out->Stat(this, &err));
- EXPECT_EQ("", err);
- ASSERT_EQ(1u, stats_.size());
- scan_.RecomputeDirty(out, NULL, NULL);
- ASSERT_FALSE(GetNode("in")->dirty());
- ASSERT_TRUE(GetNode("mid")->dirty());
- ASSERT_TRUE(GetNode("out")->dirty());
-}
-
-} // namespace
diff --git a/src/dyndep.cc b/src/dyndep.cc
deleted file mode 100644
index 7e49a75..0000000
--- a/src/dyndep.cc
+++ /dev/null
@@ -1,107 +0,0 @@
-// Copyright 2015 Google Inc. All Rights Reserved.
-//
-// Licensed under the Apache License, Version 2.0 (the "License");
-// you may not use this file except in compliance with the License.
-// You may obtain a copy of the License at
-//
-// http://www.apache.org/licenses/LICENSE-2.0
-//
-// Unless required by applicable law or agreed to in writing, software
-// distributed under the License is distributed on an "AS IS" BASIS,
-// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-// See the License for the specific language governing permissions and
-// limitations under the License.
-
-#include "dyndep.h"
-
-#include <assert.h>
-#include <stdio.h>
-
-#include "debug_flags.h"
-#include "disk_interface.h"
-#include "dyndep_parser.h"
-#include "graph.h"
-#include "state.h"
-#include "util.h"
-
-using namespace std;
-
-bool DyndepLoader::LoadDyndeps(Node* node, std::string* err) const {
- DyndepFile ddf;
- return LoadDyndeps(node, &ddf, err);
-}
-
-bool DyndepLoader::LoadDyndeps(Node* node, DyndepFile* ddf,
- std::string* err) const {
- // We are loading the dyndep file now so it is no longer pending.
- node->set_dyndep_pending(false);
-
- // Load the dyndep information from the file.
- EXPLAIN("loading dyndep file '%s'", node->path().c_str());
- if (!LoadDyndepFile(node, ddf, err))
- return false;
-
- // Update each edge that specified this node as its dyndep binding.
- std::vector<Edge*> const& out_edges = node->out_edges();
- for (std::vector<Edge*>::const_iterator oe = out_edges.begin();
- oe != out_edges.end(); ++oe) {
- Edge* const edge = *oe;
- if (edge->dyndep_ != node)
- continue;
-
- DyndepFile::iterator ddi = ddf->find(edge);
- if (ddi == ddf->end()) {
- *err = ("'" + edge->outputs_[0]->path() + "' "
- "not mentioned in its dyndep file "
- "'" + node->path() + "'");
- return false;
- }
-
- ddi->second.used_ = true;
- Dyndeps const& dyndeps = ddi->second;
- if (!UpdateEdge(edge, &dyndeps, err)) {
- return false;
- }
- }
-
- // Reject extra outputs in dyndep file.
- for (DyndepFile::const_iterator oe = ddf->begin(); oe != ddf->end();
- ++oe) {
- if (!oe->second.used_) {
- Edge* const edge = oe->first;
- *err = ("dyndep file '" + node->path() + "' mentions output "
- "'" + edge->outputs_[0]->path() + "' whose build statement "
- "does not have a dyndep binding for the file");
- return false;
- }
- }
-
- return true;
-}
-
-bool DyndepLoader::UpdateEdge(Edge* edge, Dyndeps const* dyndeps,
- std::string* err) const {
- // Add dyndep-discovered bindings to the edge.
- // We know the edge already has its own binding
- // scope because it has a "dyndep" binding.
- if (dyndeps->restat_)
- edge->SetRestat();
-
- if (!edge->UpdateDynamicImplicitOutputs(dyndeps->implicit_outputs_.size(),
- dyndeps->implicit_outputs_.data(),
- err)) {
- return false;
- }
-
- // Add the dyndep-discovered inputs to the edge.
- edge->UpdateDynamicImplicitDeps(dyndeps->implicit_inputs_.size(),
- dyndeps->implicit_inputs_.data());
-
- return true;
-}
-
-bool DyndepLoader::LoadDyndepFile(Node* file, DyndepFile* ddf,
- std::string* err) const {
- DyndepParser parser(state_, disk_interface_, ddf);
- return parser.Load(file->path(), err);
-}
diff --git a/src/dyndep.h b/src/dyndep.h
deleted file mode 100644
index 907f921..0000000
--- a/src/dyndep.h
+++ /dev/null
@@ -1,64 +0,0 @@
-// Copyright 2015 Google Inc. All Rights Reserved.
-//
-// Licensed under the Apache License, Version 2.0 (the "License");
-// you may not use this file except in compliance with the License.
-// You may obtain a copy of the License at
-//
-// http://www.apache.org/licenses/LICENSE-2.0
-//
-// Unless required by applicable law or agreed to in writing, software
-// distributed under the License is distributed on an "AS IS" BASIS,
-// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-// See the License for the specific language governing permissions and
-// limitations under the License.
-
-#ifndef NINJA_DYNDEP_LOADER_H_
-#define NINJA_DYNDEP_LOADER_H_
-
-#include <map>
-#include <string>
-#include <vector>
-
-struct DiskInterface;
-struct Edge;
-struct Node;
-struct State;
-
-/// Store dynamically-discovered dependency information for one edge.
-struct Dyndeps {
- Dyndeps() : used_(false), restat_(false) {}
- bool used_;
- bool restat_;
- std::vector<Node*> implicit_inputs_;
- std::vector<Node*> implicit_outputs_;
-};
-
-/// Store data loaded from one dyndep file. Map from an edge
-/// to its dynamically-discovered dependency information.
-/// This is a struct rather than a typedef so that we can
-/// forward-declare it in other headers.
-struct DyndepFile: public std::map<Edge*, Dyndeps> {};
-
-/// DyndepLoader loads dynamically discovered dependencies, as
-/// referenced via the "dyndep" attribute in build files.
-struct DyndepLoader {
- DyndepLoader(State* state, DiskInterface* disk_interface)
- : state_(state), disk_interface_(disk_interface) {}
-
- /// Load a dyndep file from the given node's path and update the
- /// build graph with the new information. One overload accepts
- /// a caller-owned 'DyndepFile' object in which to store the
- /// information loaded from the dyndep file.
- bool LoadDyndeps(Node* node, std::string* err) const;
- bool LoadDyndeps(Node* node, DyndepFile* ddf, std::string* err) const;
-
- private:
- bool LoadDyndepFile(Node* file, DyndepFile* ddf, std::string* err) const;
-
- bool UpdateEdge(Edge* edge, Dyndeps const* dyndeps, std::string* err) const;
-
- State* state_;
- DiskInterface* disk_interface_;
-};
-
-#endif // NINJA_DYNDEP_LOADER_H_
diff --git a/src/dyndep_parser.cc b/src/dyndep_parser.cc
deleted file mode 100644
index 1b4dddd..0000000
--- a/src/dyndep_parser.cc
+++ /dev/null
@@ -1,226 +0,0 @@
-// Copyright 2015 Google Inc. All Rights Reserved.
-//
-// Licensed under the Apache License, Version 2.0 (the "License");
-// you may not use this file except in compliance with the License.
-// You may obtain a copy of the License at
-//
-// http://www.apache.org/licenses/LICENSE-2.0
-//
-// Unless required by applicable law or agreed to in writing, software
-// distributed under the License is distributed on an "AS IS" BASIS,
-// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-// See the License for the specific language governing permissions and
-// limitations under the License.
-
-#include "dyndep_parser.h"
-
-#include <vector>
-
-#include "dyndep.h"
-#include "graph.h"
-#include "state.h"
-#include "util.h"
-#include "version.h"
-
-using namespace std;
-
-DyndepParser::DyndepParser(State* state, FileReader* file_reader,
- DyndepFile* dyndep_file)
- : Parser(state, file_reader)
- , dyndep_file_(dyndep_file) {
-}
-
-bool DyndepParser::Parse(const string& filename, const string& input,
- string* err) {
- lexer_.Start(filename, input);
-
- // Require a supported ninja_dyndep_version value immediately so
- // we can exit before encountering any syntactic surprises.
- bool haveDyndepVersion = false;
-
- for (;;) {
- Lexer::Token token = lexer_.ReadToken();
- switch (token) {
- case Lexer::BUILD: {
- if (!haveDyndepVersion)
- return lexer_.Error("expected 'ninja_dyndep_version = ...'", err);
- if (!ParseEdge(err))
- return false;
- break;
- }
- case Lexer::IDENT: {
- lexer_.UnreadToken();
- if (haveDyndepVersion)
- return lexer_.Error(string("unexpected ") + Lexer::TokenName(token),
- err);
- if (!ParseDyndepVersion(err))
- return false;
- haveDyndepVersion = true;
- break;
- }
- case Lexer::ERROR:
- return lexer_.Error(lexer_.DescribeLastError(), err);
- case Lexer::TEOF:
- if (!haveDyndepVersion)
- return lexer_.Error("expected 'ninja_dyndep_version = ...'", err);
- return true;
- case Lexer::NEWLINE:
- break;
- default:
- return lexer_.Error(string("unexpected ") + Lexer::TokenName(token),
- err);
- }
- }
- return false; // not reached
-}
-
-bool DyndepParser::ParseDyndepVersion(string* err) {
- string name;
- EvalString let_value;
- if (!ParseLet(&name, &let_value, err))
- return false;
- if (name != "ninja_dyndep_version") {
- return lexer_.Error("expected 'ninja_dyndep_version = ...'", err);
- }
- string version = let_value.Evaluate(&env_);
- int major, minor;
- ParseVersion(version, &major, &minor);
- if (major != 1 || minor != 0) {
- return lexer_.Error(
- string("unsupported 'ninja_dyndep_version = ") + version + "'", err);
- return false;
- }
- return true;
-}
-
-bool DyndepParser::ParseLet(string* key, EvalString* value, string* err) {
- if (!lexer_.ReadIdent(key))
- return lexer_.Error("expected variable name", err);
- if (!ExpectToken(Lexer::EQUALS, err))
- return false;
- if (!lexer_.ReadVarValue(value, err))
- return false;
- return true;
-}
-
-bool DyndepParser::ParseEdge(string* err) {
- // Parse one explicit output. We expect it to already have an edge.
- // We will record its dynamically-discovered dependency information.
- Dyndeps* dyndeps = NULL;
- {
- EvalString out0;
- if (!lexer_.ReadPath(&out0, err))
- return false;
- if (out0.empty())
- return lexer_.Error("expected path", err);
-
- string path = out0.Evaluate(&env_);
- if (path.empty())
- return lexer_.Error("empty path", err);
- uint64_t slash_bits;
- CanonicalizePath(&path, &slash_bits);
- Node* node = state_->LookupNode(path);
- if (!node || !node->in_edge())
- return lexer_.Error("no build statement exists for '" + path + "'", err);
- Edge* edge = node->in_edge();
- std::pair<DyndepFile::iterator, bool> res =
- dyndep_file_->insert(DyndepFile::value_type(edge, Dyndeps()));
- if (!res.second)
- return lexer_.Error("multiple statements for '" + path + "'", err);
- dyndeps = &res.first->second;
- }
-
- // Disallow explicit outputs.
- {
- EvalString out;
- if (!lexer_.ReadPath(&out, err))
- return false;
- if (!out.empty())
- return lexer_.Error("explicit outputs not supported", err);
- }
-
- // Parse implicit outputs, if any.
- vector<EvalString> outs;
- if (lexer_.PeekToken(Lexer::PIPE)) {
- for (;;) {
- EvalString out;
- if (!lexer_.ReadPath(&out, err))
- return err;
- if (out.empty())
- break;
- outs.push_back(out);
- }
- }
-
- if (!ExpectToken(Lexer::COLON, err))
- return false;
-
- string rule_name;
- if (!lexer_.ReadIdent(&rule_name) || rule_name != "dyndep")
- return lexer_.Error("expected build command name 'dyndep'", err);
-
- // Disallow explicit inputs.
- {
- EvalString in;
- if (!lexer_.ReadPath(&in, err))
- return false;
- if (!in.empty())
- return lexer_.Error("explicit inputs not supported", err);
- }
-
- // Parse implicit inputs, if any.
- vector<EvalString> ins;
- if (lexer_.PeekToken(Lexer::PIPE)) {
- for (;;) {
- EvalString in;
- if (!lexer_.ReadPath(&in, err))
- return err;
- if (in.empty())
- break;
- ins.push_back(in);
- }
- }
-
- // Disallow order-only inputs.
- if (lexer_.PeekToken(Lexer::PIPE2))
- return lexer_.Error("order-only inputs not supported", err);
-
- if (!ExpectToken(Lexer::NEWLINE, err))
- return false;
-
- if (lexer_.PeekToken(Lexer::INDENT)) {
- string key;
- EvalString val;
- if (!ParseLet(&key, &val, err))
- return false;
- if (key != "restat")
- return lexer_.Error("binding is not 'restat'", err);
- string value = val.Evaluate(&env_);
- dyndeps->restat_ = !value.empty();
- }
-
- dyndeps->implicit_inputs_.reserve(ins.size());
- for (vector<EvalString>::iterator i = ins.begin(); i != ins.end(); ++i) {
- string path = i->Evaluate(&env_);
- if (path.empty())
- return lexer_.Error("empty path", err);
- uint64_t slash_bits;
- CanonicalizePath(&path, &slash_bits);
- Node* n = state_->GetNode(path, slash_bits);
- dyndeps->implicit_inputs_.push_back(n);
- }
-
- dyndeps->implicit_outputs_.reserve(outs.size());
- for (vector<EvalString>::iterator i = outs.begin(); i != outs.end(); ++i) {
- string path = i->Evaluate(&env_);
- if (path.empty())
- return lexer_.Error("empty path", err);
- string path_err;
- uint64_t slash_bits;
- CanonicalizePath(&path, &slash_bits);
- Node* n = state_->GetNode(path, slash_bits);
- dyndeps->implicit_outputs_.push_back(n);
- }
-
- return true;
-}
diff --git a/src/dyndep_parser.h b/src/dyndep_parser.h
deleted file mode 100644
index 8f4c28d..0000000
--- a/src/dyndep_parser.h
+++ /dev/null
@@ -1,47 +0,0 @@
-// Copyright 2015 Google Inc. All Rights Reserved.
-//
-// Licensed under the Apache License, Version 2.0 (the "License");
-// you may not use this file except in compliance with the License.
-// You may obtain a copy of the License at
-//
-// http://www.apache.org/licenses/LICENSE-2.0
-//
-// Unless required by applicable law or agreed to in writing, software
-// distributed under the License is distributed on an "AS IS" BASIS,
-// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-// See the License for the specific language governing permissions and
-// limitations under the License.
-
-#ifndef NINJA_DYNDEP_PARSER_H_
-#define NINJA_DYNDEP_PARSER_H_
-
-#include "eval_env.h"
-#include "parser.h"
-
-struct DyndepFile;
-struct EvalString;
-
-/// Parses dyndep files.
-struct DyndepParser: public Parser {
- DyndepParser(State* state, FileReader* file_reader,
- DyndepFile* dyndep_file);
-
- /// Parse a text string of input. Used by tests.
- bool ParseTest(const std::string& input, std::string* err) {
- return Parse("input", input, err);
- }
-
-private:
- /// Parse a file, given its contents as a string.
- bool Parse(const std::string& filename, const std::string& input,
- std:: string* err);
-
- bool ParseDyndepVersion(std::string* err);
- bool ParseLet(std::string* key, EvalString* val, std::string* err);
- bool ParseEdge(std::string* err);
-
- DyndepFile* dyndep_file_;
- BindingEnv env_;
-};
-
-#endif // NINJA_DYNDEP_PARSER_H_
diff --git a/src/dyndep_parser_test.cc b/src/dyndep_parser_test.cc
deleted file mode 100644
index 1bba7ba..0000000
--- a/src/dyndep_parser_test.cc
+++ /dev/null
@@ -1,514 +0,0 @@
-// Copyright 2015 Google Inc. All Rights Reserved.
-//
-// Licensed under the Apache License, Version 2.0 (the "License");
-// you may not use this file except in compliance with the License.
-// You may obtain a copy of the License at
-//
-// http://www.apache.org/licenses/LICENSE-2.0
-//
-// Unless required by applicable law or agreed to in writing, software
-// distributed under the License is distributed on an "AS IS" BASIS,
-// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-// See the License for the specific language governing permissions and
-// limitations under the License.
-
-#include "dyndep_parser.h"
-
-#include <map>
-#include <vector>
-
-#include "dyndep.h"
-#include "graph.h"
-#include "state.h"
-#include "test.h"
-
-using namespace std;
-
-struct DyndepParserTest : public testing::Test {
- void AssertParse(const char* input) {
- DyndepParser parser(&state_, &fs_, &dyndep_file_);
- string err;
- EXPECT_TRUE(parser.ParseTest(input, &err));
- ASSERT_EQ("", err);
- }
-
- virtual void SetUp() {
- ::AssertParse(&state_,
-"rule touch\n"
-" command = touch $out\n"
-"build out otherout: touch\n");
- }
-
- State state_;
- VirtualFileSystem fs_;
- DyndepFile dyndep_file_;
-};
-
-TEST_F(DyndepParserTest, Empty) {
- const char kInput[] =
-"";
- DyndepParser parser(&state_, &fs_, &dyndep_file_);
- string err;
- EXPECT_FALSE(parser.ParseTest(kInput, &err));
- EXPECT_EQ("input:1: expected 'ninja_dyndep_version = ...'\n", err);
-}
-
-TEST_F(DyndepParserTest, Version1) {
- ASSERT_NO_FATAL_FAILURE(AssertParse(
-"ninja_dyndep_version = 1\n"));
-}
-
-TEST_F(DyndepParserTest, Version1Extra) {
- ASSERT_NO_FATAL_FAILURE(AssertParse(
-"ninja_dyndep_version = 1-extra\n"));
-}
-
-TEST_F(DyndepParserTest, Version1_0) {
- ASSERT_NO_FATAL_FAILURE(AssertParse(
-"ninja_dyndep_version = 1.0\n"));
-}
-
-TEST_F(DyndepParserTest, Version1_0Extra) {
- ASSERT_NO_FATAL_FAILURE(AssertParse(
-"ninja_dyndep_version = 1.0-extra\n"));
-}
-
-TEST_F(DyndepParserTest, CommentVersion) {
- ASSERT_NO_FATAL_FAILURE(AssertParse(
-"# comment\n"
-"ninja_dyndep_version = 1\n"));
-}
-
-TEST_F(DyndepParserTest, BlankLineVersion) {
- ASSERT_NO_FATAL_FAILURE(AssertParse(
-"\n"
-"ninja_dyndep_version = 1\n"));
-}
-
-TEST_F(DyndepParserTest, VersionCRLF) {
- ASSERT_NO_FATAL_FAILURE(AssertParse(
-"ninja_dyndep_version = 1\r\n"));
-}
-
-TEST_F(DyndepParserTest, CommentVersionCRLF) {
- ASSERT_NO_FATAL_FAILURE(AssertParse(
-"# comment\r\n"
-"ninja_dyndep_version = 1\r\n"));
-}
-
-TEST_F(DyndepParserTest, BlankLineVersionCRLF) {
- ASSERT_NO_FATAL_FAILURE(AssertParse(
-"\r\n"
-"ninja_dyndep_version = 1\r\n"));
-}
-
-TEST_F(DyndepParserTest, VersionUnexpectedEOF) {
- const char kInput[] =
-"ninja_dyndep_version = 1.0";
- DyndepParser parser(&state_, &fs_, &dyndep_file_);
- string err;
- EXPECT_FALSE(parser.ParseTest(kInput, &err));
- EXPECT_EQ("input:1: unexpected EOF\n"
- "ninja_dyndep_version = 1.0\n"
- " ^ near here", err);
-}
-
-TEST_F(DyndepParserTest, UnsupportedVersion0) {
- const char kInput[] =
-"ninja_dyndep_version = 0\n";
- DyndepParser parser(&state_, &fs_, &dyndep_file_);
- string err;
- EXPECT_FALSE(parser.ParseTest(kInput, &err));
- EXPECT_EQ("input:1: unsupported 'ninja_dyndep_version = 0'\n"
- "ninja_dyndep_version = 0\n"
- " ^ near here", err);
-}
-
-TEST_F(DyndepParserTest, UnsupportedVersion1_1) {
- const char kInput[] =
-"ninja_dyndep_version = 1.1\n";
- DyndepParser parser(&state_, &fs_, &dyndep_file_);
- string err;
- EXPECT_FALSE(parser.ParseTest(kInput, &err));
- EXPECT_EQ("input:1: unsupported 'ninja_dyndep_version = 1.1'\n"
- "ninja_dyndep_version = 1.1\n"
- " ^ near here", err);
-}
-
-TEST_F(DyndepParserTest, DuplicateVersion) {
- const char kInput[] =
-"ninja_dyndep_version = 1\n"
-"ninja_dyndep_version = 1\n";
- DyndepParser parser(&state_, &fs_, &dyndep_file_);
- string err;
- EXPECT_FALSE(parser.ParseTest(kInput, &err));
- EXPECT_EQ("input:2: unexpected identifier\n", err);
-}
-
-TEST_F(DyndepParserTest, MissingVersionOtherVar) {
- const char kInput[] =
-"not_ninja_dyndep_version = 1\n";
- DyndepParser parser(&state_, &fs_, &dyndep_file_);
- string err;
- EXPECT_FALSE(parser.ParseTest(kInput, &err));
- EXPECT_EQ("input:1: expected 'ninja_dyndep_version = ...'\n"
- "not_ninja_dyndep_version = 1\n"
- " ^ near here", err);
-}
-
-TEST_F(DyndepParserTest, MissingVersionBuild) {
- const char kInput[] =
-"build out: dyndep\n";
- DyndepParser parser(&state_, &fs_, &dyndep_file_);
- string err;
- EXPECT_FALSE(parser.ParseTest(kInput, &err));
- EXPECT_EQ("input:1: expected 'ninja_dyndep_version = ...'\n", err);
-}
-
-TEST_F(DyndepParserTest, UnexpectedEqual) {
- const char kInput[] =
-"= 1\n";
- DyndepParser parser(&state_, &fs_, &dyndep_file_);
- string err;
- EXPECT_FALSE(parser.ParseTest(kInput, &err));
- EXPECT_EQ("input:1: unexpected '='\n", err);
-}
-
-TEST_F(DyndepParserTest, UnexpectedIndent) {
- const char kInput[] =
-" = 1\n";
- DyndepParser parser(&state_, &fs_, &dyndep_file_);
- string err;
- EXPECT_FALSE(parser.ParseTest(kInput, &err));
- EXPECT_EQ("input:1: unexpected indent\n", err);
-}
-
-TEST_F(DyndepParserTest, OutDuplicate) {
- const char kInput[] =
-"ninja_dyndep_version = 1\n"
-"build out: dyndep\n"
-"build out: dyndep\n";
- DyndepParser parser(&state_, &fs_, &dyndep_file_);
- string err;
- EXPECT_FALSE(parser.ParseTest(kInput, &err));
- EXPECT_EQ("input:3: multiple statements for 'out'\n"
- "build out: dyndep\n"
- " ^ near here", err);
-}
-
-TEST_F(DyndepParserTest, OutDuplicateThroughOther) {
- const char kInput[] =
-"ninja_dyndep_version = 1\n"
-"build out: dyndep\n"
-"build otherout: dyndep\n";
- DyndepParser parser(&state_, &fs_, &dyndep_file_);
- string err;
- EXPECT_FALSE(parser.ParseTest(kInput, &err));
- EXPECT_EQ("input:3: multiple statements for 'otherout'\n"
- "build otherout: dyndep\n"
- " ^ near here", err);
-}
-
-TEST_F(DyndepParserTest, NoOutEOF) {
- const char kInput[] =
-"ninja_dyndep_version = 1\n"
-"build";
- DyndepParser parser(&state_, &fs_, &dyndep_file_);
- string err;
- EXPECT_FALSE(parser.ParseTest(kInput, &err));
- EXPECT_EQ("input:2: unexpected EOF\n"
- "build\n"
- " ^ near here", err);
-}
-
-TEST_F(DyndepParserTest, NoOutColon) {
- const char kInput[] =
-"ninja_dyndep_version = 1\n"
-"build :\n";
- DyndepParser parser(&state_, &fs_, &dyndep_file_);
- string err;
- EXPECT_FALSE(parser.ParseTest(kInput, &err));
- EXPECT_EQ("input:2: expected path\n"
- "build :\n"
- " ^ near here", err);
-}
-
-TEST_F(DyndepParserTest, OutNoStatement) {
- const char kInput[] =
-"ninja_dyndep_version = 1\n"
-"build missing: dyndep\n";
- DyndepParser parser(&state_, &fs_, &dyndep_file_);
- string err;
- EXPECT_FALSE(parser.ParseTest(kInput, &err));
- EXPECT_EQ("input:2: no build statement exists for 'missing'\n"
- "build missing: dyndep\n"
- " ^ near here", err);
-}
-
-TEST_F(DyndepParserTest, OutEOF) {
- const char kInput[] =
-"ninja_dyndep_version = 1\n"
-"build out";
- DyndepParser parser(&state_, &fs_, &dyndep_file_);
- string err;
- EXPECT_FALSE(parser.ParseTest(kInput, &err));
- EXPECT_EQ("input:2: unexpected EOF\n"
- "build out\n"
- " ^ near here", err);
-}
-
-TEST_F(DyndepParserTest, OutNoRule) {
- const char kInput[] =
-"ninja_dyndep_version = 1\n"
-"build out:";
- DyndepParser parser(&state_, &fs_, &dyndep_file_);
- string err;
- EXPECT_FALSE(parser.ParseTest(kInput, &err));
- EXPECT_EQ("input:2: expected build command name 'dyndep'\n"
- "build out:\n"
- " ^ near here", err);
-}
-
-TEST_F(DyndepParserTest, OutBadRule) {
- const char kInput[] =
-"ninja_dyndep_version = 1\n"
-"build out: touch";
- DyndepParser parser(&state_, &fs_, &dyndep_file_);
- string err;
- EXPECT_FALSE(parser.ParseTest(kInput, &err));
- EXPECT_EQ("input:2: expected build command name 'dyndep'\n"
- "build out: touch\n"
- " ^ near here", err);
-}
-
-TEST_F(DyndepParserTest, BuildEOF) {
- const char kInput[] =
-"ninja_dyndep_version = 1\n"
-"build out: dyndep";
- DyndepParser parser(&state_, &fs_, &dyndep_file_);
- string err;
- EXPECT_FALSE(parser.ParseTest(kInput, &err));
- EXPECT_EQ("input:2: unexpected EOF\n"
- "build out: dyndep\n"
- " ^ near here", err);
-}
-
-TEST_F(DyndepParserTest, ExplicitOut) {
- const char kInput[] =
-"ninja_dyndep_version = 1\n"
-"build out exp: dyndep\n";
- DyndepParser parser(&state_, &fs_, &dyndep_file_);
- string err;
- EXPECT_FALSE(parser.ParseTest(kInput, &err));
- EXPECT_EQ("input:2: explicit outputs not supported\n"
- "build out exp: dyndep\n"
- " ^ near here", err);
-}
-
-TEST_F(DyndepParserTest, ExplicitIn) {
- const char kInput[] =
-"ninja_dyndep_version = 1\n"
-"build out: dyndep exp\n";
- DyndepParser parser(&state_, &fs_, &dyndep_file_);
- string err;
- EXPECT_FALSE(parser.ParseTest(kInput, &err));
- EXPECT_EQ("input:2: explicit inputs not supported\n"
- "build out: dyndep exp\n"
- " ^ near here", err);
-}
-
-TEST_F(DyndepParserTest, OrderOnlyIn) {
- const char kInput[] =
-"ninja_dyndep_version = 1\n"
-"build out: dyndep ||\n";
- DyndepParser parser(&state_, &fs_, &dyndep_file_);
- string err;
- EXPECT_FALSE(parser.ParseTest(kInput, &err));
- EXPECT_EQ("input:2: order-only inputs not supported\n"
- "build out: dyndep ||\n"
- " ^ near here", err);
-}
-
-TEST_F(DyndepParserTest, BadBinding) {
- const char kInput[] =
-"ninja_dyndep_version = 1\n"
-"build out: dyndep\n"
-" not_restat = 1\n";
- DyndepParser parser(&state_, &fs_, &dyndep_file_);
- string err;
- EXPECT_FALSE(parser.ParseTest(kInput, &err));
- EXPECT_EQ("input:3: binding is not 'restat'\n"
- " not_restat = 1\n"
- " ^ near here", err);
-}
-
-TEST_F(DyndepParserTest, RestatTwice) {
- const char kInput[] =
-"ninja_dyndep_version = 1\n"
-"build out: dyndep\n"
-" restat = 1\n"
-" restat = 1\n";
- DyndepParser parser(&state_, &fs_, &dyndep_file_);
- string err;
- EXPECT_FALSE(parser.ParseTest(kInput, &err));
- EXPECT_EQ("input:4: unexpected indent\n", err);
-}
-
-TEST_F(DyndepParserTest, NoImplicit) {
- ASSERT_NO_FATAL_FAILURE(AssertParse(
-"ninja_dyndep_version = 1\n"
-"build out: dyndep\n"));
-
- EXPECT_EQ(1u, dyndep_file_.size());
- DyndepFile::iterator i = dyndep_file_.find(state_.edges_[0]);
- ASSERT_NE(i, dyndep_file_.end());
- EXPECT_EQ(false, i->second.restat_);
- EXPECT_EQ(0u, i->second.implicit_outputs_.size());
- EXPECT_EQ(0u, i->second.implicit_inputs_.size());
-}
-
-TEST_F(DyndepParserTest, EmptyImplicit) {
- ASSERT_NO_FATAL_FAILURE(AssertParse(
-"ninja_dyndep_version = 1\n"
-"build out | : dyndep |\n"));
-
- EXPECT_EQ(1u, dyndep_file_.size());
- DyndepFile::iterator i = dyndep_file_.find(state_.edges_[0]);
- ASSERT_NE(i, dyndep_file_.end());
- EXPECT_EQ(false, i->second.restat_);
- EXPECT_EQ(0u, i->second.implicit_outputs_.size());
- EXPECT_EQ(0u, i->second.implicit_inputs_.size());
-}
-
-TEST_F(DyndepParserTest, ImplicitIn) {
- ASSERT_NO_FATAL_FAILURE(AssertParse(
-"ninja_dyndep_version = 1\n"
-"build out: dyndep | impin\n"));
-
- EXPECT_EQ(1u, dyndep_file_.size());
- DyndepFile::iterator i = dyndep_file_.find(state_.edges_[0]);
- ASSERT_NE(i, dyndep_file_.end());
- EXPECT_EQ(false, i->second.restat_);
- EXPECT_EQ(0u, i->second.implicit_outputs_.size());
- ASSERT_EQ(1u, i->second.implicit_inputs_.size());
- EXPECT_EQ("impin", i->second.implicit_inputs_[0]->path());
-}
-
-TEST_F(DyndepParserTest, ImplicitIns) {
- ASSERT_NO_FATAL_FAILURE(AssertParse(
-"ninja_dyndep_version = 1\n"
-"build out: dyndep | impin1 impin2\n"));
-
- EXPECT_EQ(1u, dyndep_file_.size());
- DyndepFile::iterator i = dyndep_file_.find(state_.edges_[0]);
- ASSERT_NE(i, dyndep_file_.end());
- EXPECT_EQ(false, i->second.restat_);
- EXPECT_EQ(0u, i->second.implicit_outputs_.size());
- ASSERT_EQ(2u, i->second.implicit_inputs_.size());
- EXPECT_EQ("impin1", i->second.implicit_inputs_[0]->path());
- EXPECT_EQ("impin2", i->second.implicit_inputs_[1]->path());
-}
-
-TEST_F(DyndepParserTest, ImplicitOut) {
- ASSERT_NO_FATAL_FAILURE(AssertParse(
-"ninja_dyndep_version = 1\n"
-"build out | impout: dyndep\n"));
-
- EXPECT_EQ(1u, dyndep_file_.size());
- DyndepFile::iterator i = dyndep_file_.find(state_.edges_[0]);
- ASSERT_NE(i, dyndep_file_.end());
- EXPECT_EQ(false, i->second.restat_);
- ASSERT_EQ(1u, i->second.implicit_outputs_.size());
- EXPECT_EQ("impout", i->second.implicit_outputs_[0]->path());
- EXPECT_EQ(0u, i->second.implicit_inputs_.size());
-}
-
-TEST_F(DyndepParserTest, ImplicitOuts) {
- ASSERT_NO_FATAL_FAILURE(AssertParse(
-"ninja_dyndep_version = 1\n"
-"build out | impout1 impout2 : dyndep\n"));
-
- EXPECT_EQ(1u, dyndep_file_.size());
- DyndepFile::iterator i = dyndep_file_.find(state_.edges_[0]);
- ASSERT_NE(i, dyndep_file_.end());
- EXPECT_EQ(false, i->second.restat_);
- ASSERT_EQ(2u, i->second.implicit_outputs_.size());
- EXPECT_EQ("impout1", i->second.implicit_outputs_[0]->path());
- EXPECT_EQ("impout2", i->second.implicit_outputs_[1]->path());
- EXPECT_EQ(0u, i->second.implicit_inputs_.size());
-}
-
-TEST_F(DyndepParserTest, ImplicitInsAndOuts) {
- ASSERT_NO_FATAL_FAILURE(AssertParse(
-"ninja_dyndep_version = 1\n"
-"build out | impout1 impout2: dyndep | impin1 impin2\n"));
-
- EXPECT_EQ(1u, dyndep_file_.size());
- DyndepFile::iterator i = dyndep_file_.find(state_.edges_[0]);
- ASSERT_NE(i, dyndep_file_.end());
- EXPECT_EQ(false, i->second.restat_);
- ASSERT_EQ(2u, i->second.implicit_outputs_.size());
- EXPECT_EQ("impout1", i->second.implicit_outputs_[0]->path());
- EXPECT_EQ("impout2", i->second.implicit_outputs_[1]->path());
- ASSERT_EQ(2u, i->second.implicit_inputs_.size());
- EXPECT_EQ("impin1", i->second.implicit_inputs_[0]->path());
- EXPECT_EQ("impin2", i->second.implicit_inputs_[1]->path());
-}
-
-TEST_F(DyndepParserTest, Restat) {
- ASSERT_NO_FATAL_FAILURE(AssertParse(
-"ninja_dyndep_version = 1\n"
-"build out: dyndep\n"
-" restat = 1\n"));
-
- EXPECT_EQ(1u, dyndep_file_.size());
- DyndepFile::iterator i = dyndep_file_.find(state_.edges_[0]);
- ASSERT_NE(i, dyndep_file_.end());
- EXPECT_EQ(true, i->second.restat_);
- EXPECT_EQ(0u, i->second.implicit_outputs_.size());
- EXPECT_EQ(0u, i->second.implicit_inputs_.size());
-}
-
-TEST_F(DyndepParserTest, OtherOutput) {
- ASSERT_NO_FATAL_FAILURE(AssertParse(
-"ninja_dyndep_version = 1\n"
-"build otherout: dyndep\n"));
-
- EXPECT_EQ(1u, dyndep_file_.size());
- DyndepFile::iterator i = dyndep_file_.find(state_.edges_[0]);
- ASSERT_NE(i, dyndep_file_.end());
- EXPECT_EQ(false, i->second.restat_);
- EXPECT_EQ(0u, i->second.implicit_outputs_.size());
- EXPECT_EQ(0u, i->second.implicit_inputs_.size());
-}
-
-TEST_F(DyndepParserTest, MultipleEdges) {
- ::AssertParse(&state_,
-"build out2: touch\n");
- ASSERT_EQ(2u, state_.edges_.size());
- ASSERT_EQ(1u, state_.edges_[1]->outputs_.size());
- EXPECT_EQ("out2", state_.edges_[1]->outputs_[0]->path());
- EXPECT_EQ(0u, state_.edges_[0]->inputs_.size());
-
- ASSERT_NO_FATAL_FAILURE(AssertParse(
-"ninja_dyndep_version = 1\n"
-"build out: dyndep\n"
-"build out2: dyndep\n"
-" restat = 1\n"));
-
- EXPECT_EQ(2u, dyndep_file_.size());
- {
- DyndepFile::iterator i = dyndep_file_.find(state_.edges_[0]);
- ASSERT_NE(i, dyndep_file_.end());
- EXPECT_EQ(false, i->second.restat_);
- EXPECT_EQ(0u, i->second.implicit_outputs_.size());
- EXPECT_EQ(0u, i->second.implicit_inputs_.size());
- }
- {
- DyndepFile::iterator i = dyndep_file_.find(state_.edges_[1]);
- ASSERT_NE(i, dyndep_file_.end());
- EXPECT_EQ(true, i->second.restat_);
- EXPECT_EQ(0u, i->second.implicit_outputs_.size());
- EXPECT_EQ(0u, i->second.implicit_inputs_.size());
- }
-}
diff --git a/src/edit_distance.cc b/src/edit_distance.cc
deleted file mode 100644
index 34bf0e5..0000000
--- a/src/edit_distance.cc
+++ /dev/null
@@ -1,71 +0,0 @@
-// Copyright 2011 Google Inc. All Rights Reserved.
-//
-// Licensed under the Apache License, Version 2.0 (the "License");
-// you may not use this file except in compliance with the License.
-// You may obtain a copy of the License at
-//
-// http://www.apache.org/licenses/LICENSE-2.0
-//
-// Unless required by applicable law or agreed to in writing, software
-// distributed under the License is distributed on an "AS IS" BASIS,
-// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-// See the License for the specific language governing permissions and
-// limitations under the License.
-
-#include "edit_distance.h"
-
-#include <algorithm>
-#include <vector>
-
-using namespace std;
-
-int EditDistance(const StringPiece& s1,
- const StringPiece& s2,
- bool allow_replacements,
- int max_edit_distance) {
- // The algorithm implemented below is the "classic"
- // dynamic-programming algorithm for computing the Levenshtein
- // distance, which is described here:
- //
- // http://en.wikipedia.org/wiki/Levenshtein_distance
- //
- // Although the algorithm is typically described using an m x n
- // array, only one row plus one element are used at a time, so this
- // implementation just keeps one vector for the row. To update one entry,
- // only the entries to the left, top, and top-left are needed. The left
- // entry is in row[x-1], the top entry is what's in row[x] from the last
- // iteration, and the top-left entry is stored in previous.
- int m = s1.len_;
- int n = s2.len_;
-
- vector<int> row(n + 1);
- for (int i = 1; i <= n; ++i)
- row[i] = i;
-
- for (int y = 1; y <= m; ++y) {
- row[0] = y;
- int best_this_row = row[0];
-
- int previous = y - 1;
- for (int x = 1; x <= n; ++x) {
- int old_row = row[x];
- if (allow_replacements) {
- row[x] = min(previous + (s1.str_[y - 1] == s2.str_[x - 1] ? 0 : 1),
- min(row[x - 1], row[x]) + 1);
- }
- else {
- if (s1.str_[y - 1] == s2.str_[x - 1])
- row[x] = previous;
- else
- row[x] = min(row[x - 1], row[x]) + 1;
- }
- previous = old_row;
- best_this_row = min(best_this_row, row[x]);
- }
-
- if (max_edit_distance && best_this_row > max_edit_distance)
- return max_edit_distance + 1;
- }
-
- return row[n];
-}
diff --git a/src/edit_distance.h b/src/edit_distance.h
deleted file mode 100644
index 45ae4ae..0000000
--- a/src/edit_distance.h
+++ /dev/null
@@ -1,25 +0,0 @@
-// Copyright 2011 Google Inc. All Rights Reserved.
-//
-// Licensed under the Apache License, Version 2.0 (the "License");
-// you may not use this file except in compliance with the License.
-// You may obtain a copy of the License at
-//
-// http://www.apache.org/licenses/LICENSE-2.0
-//
-// Unless required by applicable law or agreed to in writing, software
-// distributed under the License is distributed on an "AS IS" BASIS,
-// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-// See the License for the specific language governing permissions and
-// limitations under the License.
-
-#ifndef NINJA_EDIT_DISTANCE_H_
-#define NINJA_EDIT_DISTANCE_H_
-
-#include "string_piece.h"
-
-int EditDistance(const StringPiece& s1,
- const StringPiece& s2,
- bool allow_replacements = true,
- int max_edit_distance = 0);
-
-#endif // NINJA_EDIT_DISTANCE_H_
diff --git a/src/edit_distance_test.cc b/src/edit_distance_test.cc
deleted file mode 100644
index 9dc0f82..0000000
--- a/src/edit_distance_test.cc
+++ /dev/null
@@ -1,48 +0,0 @@
-// Copyright 2011 Google Inc. All Rights Reserved.
-//
-// Licensed under the Apache License, Version 2.0 (the "License");
-// you may not use this file except in compliance with the License.
-// You may obtain a copy of the License at
-//
-// http://www.apache.org/licenses/LICENSE-2.0
-//
-// Unless required by applicable law or agreed to in writing, software
-// distributed under the License is distributed on an "AS IS" BASIS,
-// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-// See the License for the specific language governing permissions and
-// limitations under the License.
-
-#include "edit_distance.h"
-
-#include "test.h"
-
-TEST(EditDistanceTest, TestEmpty) {
- EXPECT_EQ(5, EditDistance("", "ninja"));
- EXPECT_EQ(5, EditDistance("ninja", ""));
- EXPECT_EQ(0, EditDistance("", ""));
-}
-
-TEST(EditDistanceTest, TestMaxDistance) {
- const bool allow_replacements = true;
- for (int max_distance = 1; max_distance < 7; ++max_distance) {
- EXPECT_EQ(max_distance + 1,
- EditDistance("abcdefghijklmnop", "ponmlkjihgfedcba",
- allow_replacements, max_distance));
- }
-}
-
-TEST(EditDistanceTest, TestAllowReplacements) {
- bool allow_replacements = true;
- EXPECT_EQ(1, EditDistance("ninja", "njnja", allow_replacements));
- EXPECT_EQ(1, EditDistance("njnja", "ninja", allow_replacements));
-
- allow_replacements = false;
- EXPECT_EQ(2, EditDistance("ninja", "njnja", allow_replacements));
- EXPECT_EQ(2, EditDistance("njnja", "ninja", allow_replacements));
-}
-
-TEST(EditDistanceTest, TestBasics) {
- EXPECT_EQ(0, EditDistance("browser_tests", "browser_tests"));
- EXPECT_EQ(1, EditDistance("browser_test", "browser_tests"));
- EXPECT_EQ(1, EditDistance("browser_tests", "browser_test"));
-}
diff --git a/src/eval_env.cc b/src/eval_env.cc
deleted file mode 100644
index 675bb83..0000000
--- a/src/eval_env.cc
+++ /dev/null
@@ -1,145 +0,0 @@
-// Copyright 2011 Google Inc. All Rights Reserved.
-//
-// Licensed under the Apache License, Version 2.0 (the "License");
-// you may not use this file except in compliance with the License.
-// You may obtain a copy of the License at
-//
-// http://www.apache.org/licenses/LICENSE-2.0
-//
-// Unless required by applicable law or agreed to in writing, software
-// distributed under the License is distributed on an "AS IS" BASIS,
-// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-// See the License for the specific language governing permissions and
-// limitations under the License.
-
-#include <assert.h>
-
-#include "eval_env.h"
-
-using namespace std;
-
-string BindingEnv::LookupVariable(const string& var) {
- map<string, string>::iterator i = bindings_.find(var);
- if (i != bindings_.end())
- return i->second;
- if (parent_)
- return parent_->LookupVariable(var);
- return "";
-}
-
-void BindingEnv::AddBinding(const string& key, const string& val) {
- bindings_[key] = val;
-}
-
-void BindingEnv::AddRule(Rule* rule) {
- assert(LookupRuleCurrentScope(rule->name()) == NULL);
- rules_.emplace(rule->name(), std::unique_ptr<Rule>(rule));
-}
-
-const Rule* BindingEnv::LookupRuleCurrentScope(const string& rule_name) {
- auto it = rules_.find(rule_name);
- if (it == rules_.end())
- return NULL;
- return it->second.get();
-}
-
-const Rule* BindingEnv::LookupRule(const string& rule_name) {
- auto it = rules_.find(rule_name);
- if (it != rules_.end())
- return it->second.get();
- if (parent_)
- return parent_->LookupRule(rule_name);
- return NULL;
-}
-
-void Rule::AddBinding(const string& key, const EvalString& val) {
- bindings_[key] = val;
-}
-
-const EvalString* Rule::GetBinding(const string& key) const {
- Bindings::const_iterator i = bindings_.find(key);
- if (i == bindings_.end())
- return NULL;
- return &i->second;
-}
-
-// static
-bool Rule::IsReservedBinding(const string& var) {
- return var == "command" ||
- var == "depfile" ||
- var == "dyndep" ||
- var == "description" ||
- var == "deps" ||
- var == "generator" ||
- var == "pool" ||
- var == "restat" ||
- var == "rspfile" ||
- var == "rspfile_content" ||
- var == "msvc_deps_prefix";
-}
-
-string BindingEnv::LookupWithFallback(const string& var,
- const EvalString* eval,
- Env* env) {
- map<string, string>::iterator i = bindings_.find(var);
- if (i != bindings_.end())
- return i->second;
-
- if (eval)
- return eval->Evaluate(env);
-
- if (parent_)
- return parent_->LookupVariable(var);
-
- return "";
-}
-
-string EvalString::Evaluate(Env* env) const {
- string result;
- for (TokenList::const_iterator i = parsed_.begin(); i != parsed_.end(); ++i) {
- if (i->second == RAW)
- result.append(i->first);
- else
- result.append(env->LookupVariable(i->first));
- }
- return result;
-}
-
-void EvalString::AddText(StringPiece text) {
- // Add it to the end of an existing RAW token if possible.
- if (!parsed_.empty() && parsed_.back().second == RAW) {
- parsed_.back().first.append(text.str_, text.len_);
- } else {
- parsed_.push_back(make_pair(text.AsString(), RAW));
- }
-}
-void EvalString::AddSpecial(StringPiece text) {
- parsed_.push_back(make_pair(text.AsString(), SPECIAL));
-}
-
-string EvalString::Serialize() const {
- string result;
- for (TokenList::const_iterator i = parsed_.begin();
- i != parsed_.end(); ++i) {
- result.append("[");
- if (i->second == SPECIAL)
- result.append("$");
- result.append(i->first);
- result.append("]");
- }
- return result;
-}
-
-string EvalString::Unparse() const {
- string result;
- for (TokenList::const_iterator i = parsed_.begin();
- i != parsed_.end(); ++i) {
- bool special = (i->second == SPECIAL);
- if (special)
- result.append("${");
- result.append(i->first);
- if (special)
- result.append("}");
- }
- return result;
-}
diff --git a/src/eval_env.h b/src/eval_env.h
deleted file mode 100644
index 2c69d94..0000000
--- a/src/eval_env.h
+++ /dev/null
@@ -1,123 +0,0 @@
-// Copyright 2011 Google Inc. All Rights Reserved.
-//
-// Licensed under the Apache License, Version 2.0 (the "License");
-// you may not use this file except in compliance with the License.
-// You may obtain a copy of the License at
-//
-// http://www.apache.org/licenses/LICENSE-2.0
-//
-// Unless required by applicable law or agreed to in writing, software
-// distributed under the License is distributed on an "AS IS" BASIS,
-// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-// See the License for the specific language governing permissions and
-// limitations under the License.
-
-#ifndef NINJA_EVAL_ENV_H_
-#define NINJA_EVAL_ENV_H_
-
-#include <map>
-#include <memory>
-#include <string>
-#include <vector>
-
-#include "string_piece.h"
-
-struct Rule;
-
-/// An interface for a scope for variable (e.g. "$foo") lookups.
-struct Env {
- virtual ~Env() {}
- virtual std::string LookupVariable(const std::string& var) = 0;
-};
-
-/// A tokenized string that contains variable references.
-/// Can be evaluated relative to an Env.
-struct EvalString {
- /// @return The evaluated string with variable expanded using value found in
- /// environment @a env.
- std::string Evaluate(Env* env) const;
-
- /// @return The string with variables not expanded.
- std::string Unparse() const;
-
- void Clear() { parsed_.clear(); }
- bool empty() const { return parsed_.empty(); }
-
- void AddText(StringPiece text);
- void AddSpecial(StringPiece text);
-
- /// Construct a human-readable representation of the parsed state,
- /// for use in tests.
- std::string Serialize() const;
-
-private:
- enum TokenType { RAW, SPECIAL };
- typedef std::vector<std::pair<std::string, TokenType> > TokenList;
- TokenList parsed_;
-};
-
-/// An invocable build command and associated metadata (description, etc.).
-struct Rule {
- Rule(StringPiece name)
- : name_(name.str_, name.len_), is_phony_(name_ == "phony") {}
-
- const std::string& name() const { return name_; }
-
- bool is_phony() const { return is_phony_; }
-
- void AddBinding(const std::string& key, const EvalString& val);
-
- static bool IsReservedBinding(const std::string& var);
-
- const EvalString* GetBinding(const std::string& key) const;
-
- private:
- // Allow the parsers to reach into this object and fill out its fields.
- friend struct ManifestParser;
-
- std::string name_;
- bool is_phony_;
- typedef std::map<std::string, EvalString> Bindings;
- Bindings bindings_;
-};
-
-/// An Env which contains a mapping of variables to values
-/// as well as a pointer to a parent scope.
-struct BindingEnv : public Env {
- BindingEnv() : parent_(NULL) {}
- explicit BindingEnv(BindingEnv* parent) : parent_(parent) {}
-
- BindingEnv(const BindingEnv&) = delete;
- BindingEnv& operator=(const BindingEnv&) = delete;
-
- BindingEnv(BindingEnv&&) noexcept = default;
- BindingEnv& operator=(BindingEnv&&) noexcept = default;
-
- virtual ~BindingEnv() {}
- virtual std::string LookupVariable(const std::string& var);
-
- /// Add a new rule, takes ownership.
- void AddRule(Rule* rule);
- const Rule* LookupRule(const std::string& rule_name);
- const Rule* LookupRuleCurrentScope(const std::string& rule_name);
-
- using RuleMapType = std::map<std::string, std::unique_ptr<const Rule>>;
- const RuleMapType& GetRules() const { return rules_; }
-
- void AddBinding(const std::string& key, const std::string& val);
-
- /// This is tricky. Edges want lookup scope to go in this order:
- /// 1) value set on edge itself (edge_->env_)
- /// 2) value set on rule, with expansion in the edge's scope
- /// 3) value set on enclosing scope of edge (edge_->env_->parent_)
- /// This function takes as parameters the necessary info to do (2).
- std::string LookupWithFallback(const std::string& var, const EvalString* eval,
- Env* env);
-
-private:
- std::map<std::string, std::string> bindings_;
- RuleMapType rules_;
- BindingEnv* parent_;
-};
-
-#endif // NINJA_EVAL_ENV_H_
diff --git a/src/exit_status.h b/src/exit_status.h
deleted file mode 100644
index dd45efc..0000000
--- a/src/exit_status.h
+++ /dev/null
@@ -1,25 +0,0 @@
-// Copyright 2011 Google Inc. All Rights Reserved.
-//
-// Licensed under the Apache License, Version 2.0 (the "License");
-// you may not use this file except in compliance with the License.
-// You may obtain a copy of the License at
-//
-// http://www.apache.org/licenses/LICENSE-2.0
-//
-// Unless required by applicable law or agreed to in writing, software
-// distributed under the License is distributed on an "AS IS" BASIS,
-// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-// See the License for the specific language governing permissions and
-// limitations under the License.
-
-#ifndef NINJA_EXIT_STATUS_H_
-#define NINJA_EXIT_STATUS_H_
-
-enum ExitStatus {
- ExitSuccess,
- ExitFailure,
- ExitInterrupted,
- ExitTimeout,
-};
-
-#endif // NINJA_EXIT_STATUS_H_
diff --git a/src/gen_doxygen_mainpage.sh b/src/gen_doxygen_mainpage.sh
deleted file mode 100755
index d159947..0000000
--- a/src/gen_doxygen_mainpage.sh
+++ /dev/null
@@ -1,92 +0,0 @@
-#!/bin/sh
-
-# Copyright 2011 Google Inc. All Rights Reserved.
-#
-# Licensed under the Apache License, Version 2.0 (the "License");
-# you may not use this file except in compliance with the License.
-# You may obtain a copy of the License at
-#
-# http://www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing, software
-# distributed under the License is distributed on an "AS IS" BASIS,
-# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-# See the License for the specific language governing permissions and
-# limitations under the License.
-
-set -o errexit
-set -o nounset
-
-STATUS=0
-
-# Print each of its arguments on stderr (one per line) prefixed by the
-# basename of this script.
-stderr()
-{
- local me=$(basename "$0")
- local i
- for i
- do
- echo >&2 "$me: $i"
- done
-}
-
-# Print each of its arguments on stderr (one per line) prefixed by the
-# basename of this script and 'error'.
-error()
-{
- local i
- for i
- do
- stderr "error: $i"
- done
- STATUS=1
-}
-
-generate_header()
-{
- cat <<EOF
-/**
- * \\mainpage
-EOF
-}
-
-generate_footer()
-{
- cat <<EOF
- */
-EOF
-}
-
-include_file()
-{
- local file="$1"
- if ! [ -r "$file" ]
- then
- error "'$file' is not readable."
- return
- fi
- cat <<EOF
- * \\section $file
- * \\verbatim
-EOF
- cat < "$file"
- cat <<EOF
- \\endverbatim
-EOF
-}
-
-if [ $# -eq 0 ]
-then
- echo >&2 "usage: $0 inputs..."
- exit 1
-fi
-
-generate_header
-for i in "$@"
-do
- include_file "$i"
-done
-generate_footer
-
-exit $STATUS
diff --git a/src/getopt.c b/src/getopt.c
deleted file mode 100644
index 861f07f..0000000
--- a/src/getopt.c
+++ /dev/null
@@ -1,410 +0,0 @@
-/****************************************************************************
-
-getopt.c - Read command line options
-
-AUTHOR: Gregory Pietsch
-CREATED Fri Jan 10 21:13:05 1997
-
-DESCRIPTION:
-
-The getopt() function parses the command line arguments. Its arguments argc
-and argv are the argument count and array as passed to the main() function
-on program invocation. The argument optstring is a list of available option
-characters. If such a character is followed by a colon (`:'), the option
-takes an argument, which is placed in optarg. If such a character is
-followed by two colons, the option takes an optional argument, which is
-placed in optarg. If the option does not take an argument, optarg is NULL.
-
-The external variable optind is the index of the next array element of argv
-to be processed; it communicates from one call to the next which element to
-process.
-
-The getopt_long() function works like getopt() except that it also accepts
-long options started by two dashes `--'. If these take values, it is either
-in the form
-
---arg=value
-
- or
-
---arg value
-
-It takes the additional arguments longopts which is a pointer to the first
-element of an array of type GETOPT_LONG_OPTION_T. The last element of the
-array has to be filled with NULL for the name field.
-
-The longind pointer points to the index of the current long option relative
-to longopts if it is non-NULL.
-
-The getopt() function returns the option character if the option was found
-successfully, `:' if there was a missing parameter for one of the options,
-`?' for an unknown option character, and EOF for the end of the option list.
-
-The getopt_long() function's return value is described in the header file.
-
-The function getopt_long_only() is identical to getopt_long(), except that a
-plus sign `+' can introduce long options as well as `--'.
-
-The following describes how to deal with options that follow non-option
-argv-elements.
-
-If the caller did not specify anything, the default is REQUIRE_ORDER if the
-environment variable POSIXLY_CORRECT is defined, PERMUTE otherwise.
-
-REQUIRE_ORDER means don't recognize them as options; stop option processing
-when the first non-option is seen. This is what Unix does. This mode of
-operation is selected by either setting the environment variable
-POSIXLY_CORRECT, or using `+' as the first character of the optstring
-parameter.
-
-PERMUTE is the default. We permute the contents of ARGV as we scan, so that
-eventually all the non-options are at the end. This allows options to be
-given in any order, even with programs that were not written to expect this.
-
-RETURN_IN_ORDER is an option available to programs that were written to
-expect options and other argv-elements in any order and that care about the
-ordering of the two. We describe each non-option argv-element as if it were
-the argument of an option with character code 1. Using `-' as the first
-character of the optstring parameter selects this mode of operation.
-
-The special argument `--' forces an end of option-scanning regardless of the
-value of ordering. In the case of RETURN_IN_ORDER, only `--' can cause
-getopt() and friends to return EOF with optind != argc.
-
-COPYRIGHT NOTICE AND DISCLAIMER:
-
-Copyright (C) 1997 Gregory Pietsch
-
-This file and the accompanying getopt.h header file are hereby placed in the
-public domain without restrictions. Just give the author credit, don't
-claim you wrote it or prevent anyone else from using it.
-
-Gregory Pietsch's current e-mail address:
-gpietsch@comcast.net
-****************************************************************************/
-
-/* include files */
-#include <stdio.h>
-#include <stdlib.h>
-#include <string.h>
-#ifndef GETOPT_H
-#include "getopt.h"
-#endif
-
-/* macros */
-
-/* types */
-typedef enum GETOPT_ORDERING_T
-{
- PERMUTE,
- RETURN_IN_ORDER,
- REQUIRE_ORDER
-} GETOPT_ORDERING_T;
-
-/* globally-defined variables */
-char *optarg = NULL;
-int optind = 0;
-int opterr = 1;
-int optopt = '?';
-
-/* functions */
-
-/* reverse_argv_elements: reverses num elements starting at argv */
-static void
-reverse_argv_elements (char **argv, int num)
-{
- int i;
- char *tmp;
-
- for (i = 0; i < (num >> 1); i++)
- {
- tmp = argv[i];
- argv[i] = argv[num - i - 1];
- argv[num - i - 1] = tmp;
- }
-}
-
-/* permute: swap two blocks of argv-elements given their lengths */
-static void
-permute (char **argv, int len1, int len2)
-{
- reverse_argv_elements (argv, len1);
- reverse_argv_elements (argv, len1 + len2);
- reverse_argv_elements (argv, len2);
-}
-
-/* is_option: is this argv-element an option or the end of the option list? */
-static int
-is_option (char *argv_element, int only)
-{
- return ((argv_element == NULL)
- || (argv_element[0] == '-') || (only && argv_element[0] == '+'));
-}
-
-/* getopt_internal: the function that does all the dirty work */
-static int
-getopt_internal (int argc, char **argv, char *shortopts,
- GETOPT_LONG_OPTION_T * longopts, int *longind, int only)
-{
- GETOPT_ORDERING_T ordering = PERMUTE;
- static size_t optwhere = 0;
- size_t permute_from = 0;
- int num_nonopts = 0;
- int optindex = 0;
- size_t match_chars = 0;
- char *possible_arg = NULL;
- int longopt_match = -1;
- int has_arg = -1;
- char *cp = NULL;
- int arg_next = 0;
-
- /* first, deal with silly parameters and easy stuff */
- if (argc == 0 || argv == NULL || (shortopts == NULL && longopts == NULL))
- return (optopt = '?');
- if (optind >= argc || argv[optind] == NULL)
- return EOF;
- if (strcmp (argv[optind], "--") == 0)
- {
- optind++;
- return EOF;
- }
- /* if this is our first time through */
- if (optind == 0)
- optind = optwhere = 1;
-
- /* define ordering */
- if (shortopts != NULL && (*shortopts == '-' || *shortopts == '+'))
- {
- ordering = (*shortopts == '-') ? RETURN_IN_ORDER : REQUIRE_ORDER;
- shortopts++;
- }
- else
- ordering = (getenv ("POSIXLY_CORRECT") != NULL) ? REQUIRE_ORDER : PERMUTE;
-
- /*
- * based on ordering, find our next option, if we're at the beginning of
- * one
- */
- if (optwhere == 1)
- {
- switch (ordering)
- {
- case PERMUTE:
- permute_from = optind;
- num_nonopts = 0;
- while (!is_option (argv[optind], only))
- {
- optind++;
- num_nonopts++;
- }
- if (argv[optind] == NULL)
- {
- /* no more options */
- optind = permute_from;
- return EOF;
- }
- else if (strcmp (argv[optind], "--") == 0)
- {
- /* no more options, but have to get `--' out of the way */
- permute (argv + permute_from, num_nonopts, 1);
- optind = permute_from + 1;
- return EOF;
- }
- break;
- case RETURN_IN_ORDER:
- if (!is_option (argv[optind], only))
- {
- optarg = argv[optind++];
- return (optopt = 1);
- }
- break;
- case REQUIRE_ORDER:
- if (!is_option (argv[optind], only))
- return EOF;
- break;
- }
- }
- /* we've got an option, so parse it */
-
- /* first, is it a long option? */
- if (longopts != NULL
- && (memcmp (argv[optind], "--", 2) == 0
- || (only && argv[optind][0] == '+')) && optwhere == 1)
- {
- /* handle long options */
- if (memcmp (argv[optind], "--", 2) == 0)
- optwhere = 2;
- longopt_match = -1;
- possible_arg = strchr (argv[optind] + optwhere, '=');
- if (possible_arg == NULL)
- {
- /* no =, so next argv might be arg */
- match_chars = strlen (argv[optind]);
- possible_arg = argv[optind] + match_chars;
- match_chars = match_chars - optwhere;
- }
- else
- match_chars = (possible_arg - argv[optind]) - optwhere;
- for (optindex = 0; longopts[optindex].name != NULL; optindex++)
- {
- if (memcmp (argv[optind] + optwhere,
- longopts[optindex].name, match_chars) == 0)
- {
- /* do we have an exact match? */
- if (match_chars == strlen (longopts[optindex].name))
- {
- longopt_match = optindex;
- break;
- }
- /* do any characters match? */
- else
- {
- if (longopt_match < 0)
- longopt_match = optindex;
- else
- {
- /* we have ambiguous options */
- if (opterr)
- fprintf (stderr, "%s: option `%s' is ambiguous "
- "(could be `--%s' or `--%s')\n",
- argv[0],
- argv[optind],
- longopts[longopt_match].name,
- longopts[optindex].name);
- return (optopt = '?');
- }
- }
- }
- }
- if (longopt_match >= 0)
- has_arg = longopts[longopt_match].has_arg;
- }
- /* if we didn't find a long option, is it a short option? */
- if (longopt_match < 0 && shortopts != NULL)
- {
- cp = strchr (shortopts, argv[optind][optwhere]);
- if (cp == NULL)
- {
- /* couldn't find option in shortopts */
- if (opterr)
- fprintf (stderr,
- "%s: invalid option -- `-%c'\n",
- argv[0], argv[optind][optwhere]);
- optwhere++;
- if (argv[optind][optwhere] == '\0')
- {
- optind++;
- optwhere = 1;
- }
- return (optopt = '?');
- }
- has_arg = ((cp[1] == ':')
- ? ((cp[2] == ':') ? OPTIONAL_ARG : required_argument) : no_argument);
- possible_arg = argv[optind] + optwhere + 1;
- optopt = *cp;
- }
- /* get argument and reset optwhere */
- arg_next = 0;
- switch (has_arg)
- {
- case OPTIONAL_ARG:
- if (*possible_arg == '=')
- possible_arg++;
- if (*possible_arg != '\0')
- {
- optarg = possible_arg;
- optwhere = 1;
- }
- else
- optarg = NULL;
- break;
- case required_argument:
- if (*possible_arg == '=')
- possible_arg++;
- if (*possible_arg != '\0')
- {
- optarg = possible_arg;
- optwhere = 1;
- }
- else if (optind + 1 >= argc)
- {
- if (opterr)
- {
- fprintf (stderr, "%s: argument required for option `", argv[0]);
- if (longopt_match >= 0)
- fprintf (stderr, "--%s'\n", longopts[longopt_match].name);
- else
- fprintf (stderr, "-%c'\n", *cp);
- }
- optind++;
- return (optopt = ':');
- }
- else
- {
- optarg = argv[optind + 1];
- arg_next = 1;
- optwhere = 1;
- }
- break;
- case no_argument:
- if (longopt_match < 0)
- {
- optwhere++;
- if (argv[optind][optwhere] == '\0')
- optwhere = 1;
- }
- else
- optwhere = 1;
- optarg = NULL;
- break;
- }
-
- /* do we have to permute or otherwise modify optind? */
- if (ordering == PERMUTE && optwhere == 1 && num_nonopts != 0)
- {
- permute (argv + permute_from, num_nonopts, 1 + arg_next);
- optind = permute_from + 1 + arg_next;
- }
- else if (optwhere == 1)
- optind = optind + 1 + arg_next;
-
- /* finally return */
- if (longopt_match >= 0)
- {
- if (longind != NULL)
- *longind = longopt_match;
- if (longopts[longopt_match].flag != NULL)
- {
- *(longopts[longopt_match].flag) = longopts[longopt_match].val;
- return 0;
- }
- else
- return longopts[longopt_match].val;
- }
- else
- return optopt;
-}
-
-#ifndef _AIX
-int
-getopt (int argc, char **argv, char *optstring)
-{
- return getopt_internal (argc, argv, optstring, NULL, NULL, 0);
-}
-#endif
-
-int
-getopt_long (int argc, char **argv, const char *shortopts,
- const GETOPT_LONG_OPTION_T * longopts, int *longind)
-{
- return getopt_internal (argc, argv, (char*)shortopts, (GETOPT_LONG_OPTION_T*)longopts, longind, 0);
-}
-
-int
-getopt_long_only (int argc, char **argv, const char *shortopts,
- const GETOPT_LONG_OPTION_T * longopts, int *longind)
-{
- return getopt_internal (argc, argv, (char*)shortopts, (GETOPT_LONG_OPTION_T*)longopts, longind, 1);
-}
-
-/* end of file GETOPT.C */
diff --git a/src/getopt.h b/src/getopt.h
deleted file mode 100644
index 965dc29..0000000
--- a/src/getopt.h
+++ /dev/null
@@ -1,57 +0,0 @@
-#ifndef GETOPT_H
-#define GETOPT_H
-
-/* include files needed by this include file */
-
-/* macros defined by this include file */
-#define no_argument 0
-#define required_argument 1
-#define OPTIONAL_ARG 2
-
-/* types defined by this include file */
-
-/* GETOPT_LONG_OPTION_T: The type of long option */
-typedef struct GETOPT_LONG_OPTION_T
-{
- const char *name; /* the name of the long option */
- int has_arg; /* one of the above macros */
- int *flag; /* determines if getopt_long() returns a
- * value for a long option; if it is
- * non-NULL, 0 is returned as a function
- * value and the value of val is stored in
- * the area pointed to by flag. Otherwise,
- * val is returned. */
- int val; /* determines the value to return if flag is
- * NULL. */
-} GETOPT_LONG_OPTION_T;
-
-typedef GETOPT_LONG_OPTION_T option;
-
-#ifdef __cplusplus
-extern "C"
-{
-#endif
-
- /* externally-defined variables */
- extern char *optarg;
- extern int optind;
- extern int opterr;
- extern int optopt;
-
- /* function prototypes */
-#ifndef _AIX
- int getopt (int argc, char **argv, char *optstring);
-#endif
- int getopt_long (int argc, char **argv, const char *shortopts,
- const GETOPT_LONG_OPTION_T * longopts, int *longind);
- int getopt_long_only (int argc, char **argv, const char *shortopts,
- const GETOPT_LONG_OPTION_T * longopts, int *longind);
-
-#ifdef __cplusplus
-};
-
-#endif
-
-#endif /* GETOPT_H */
-
-/* END OF FILE getopt.h */
diff --git a/src/graph.cc b/src/graph.cc
deleted file mode 100644
index af639df..0000000
--- a/src/graph.cc
+++ /dev/null
@@ -1,900 +0,0 @@
-// Copyright 2011 Google Inc. All Rights Reserved.
-//
-// Licensed under the Apache License, Version 2.0 (the "License");
-// you may not use this file except in compliance with the License.
-// You may obtain a copy of the License at
-//
-// http://www.apache.org/licenses/LICENSE-2.0
-//
-// Unless required by applicable law or agreed to in writing, software
-// distributed under the License is distributed on an "AS IS" BASIS,
-// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-// See the License for the specific language governing permissions and
-// limitations under the License.
-
-#include "graph.h"
-
-#include <assert.h>
-#include <stdio.h>
-#include <string.h>
-
-#include <algorithm>
-#include <deque>
-#include <set>
-
-#include "build_log.h"
-#include "debug_flags.h"
-#include "depfile_parser.h"
-#include "deps_log.h"
-#include "disk_interface.h"
-#include "manifest_parser.h"
-#include "metrics.h"
-#include "state.h"
-#include "util.h"
-
-using namespace std;
-
-bool Node::Stat(DiskInterface* disk_interface, string* err) {
- mtime_ = disk_interface->Stat(path_, err);
- if (mtime_ == -1) {
- return false;
- }
- exists_ = (mtime_ != 0) ? ExistenceStatusExists : ExistenceStatusMissing;
- return true;
-}
-
-void Node::UpdatePhonyMtime(TimeStamp mtime) {
- if (!exists()) {
- mtime_ = std::max(mtime_, mtime);
- }
-}
-
-bool DependencyScan::RecomputeDirty(Node* initial_node,
- std::vector<Node*>* validation_nodes,
- string* err) {
- std::vector<Node*> stack;
- std::vector<Node*> new_validation_nodes;
-
- std::deque<Node*> nodes(1, initial_node);
-
- // RecomputeNodeDirty might return new validation nodes that need to be
- // checked for dirty state, keep a queue of nodes to visit.
- while (!nodes.empty()) {
- Node* node = nodes.front();
- nodes.pop_front();
-
- stack.clear();
- new_validation_nodes.clear();
-
- if (!RecomputeNodeDirty(node, &stack, &new_validation_nodes, err))
- return false;
- nodes.insert(nodes.end(), new_validation_nodes.begin(),
- new_validation_nodes.end());
- if (!new_validation_nodes.empty()) {
- assert(validation_nodes &&
- "validations require RecomputeDirty to be called with validation_nodes");
- validation_nodes->insert(validation_nodes->end(),
- new_validation_nodes.begin(),
- new_validation_nodes.end());
- }
- }
-
- return true;
-}
-
-bool DependencyScan::RecomputeNodeDirty(Node* node, std::vector<Node*>* stack,
- std::vector<Node*>* validation_nodes,
- string* err) {
- Edge* edge = node->in_edge();
- if (!edge) {
- // If we already visited this leaf node then we are done.
- if (node->status_known())
- return true;
- // This node has no in-edge; it is dirty if it is missing.
- if (!node->StatIfNecessary(disk_interface_, err))
- return false;
- if (!node->exists())
- EXPLAIN("%s has no in-edge and is missing", node->path().c_str());
- node->set_dirty(!node->exists());
- return true;
- }
-
- // If we already finished this edge then we are done.
- if (edge->mark_ == Edge::VisitDone)
- return true;
-
- // If we encountered this edge earlier in the call stack we have a cycle.
- if (!VerifyDAG(node, stack, err))
- return false;
-
- // Mark the edge temporarily while in the call stack.
- edge->mark_ = Edge::VisitInStack;
- stack->push_back(node);
-
- bool dirty = false;
- edge->outputs_ready_ = true;
- edge->deps_missing_ = false;
-
- if (!edge->deps_loaded_) {
- // This is our first encounter with this edge.
- // If there is a pending dyndep file, visit it now:
- // * If the dyndep file is ready then load it now to get any
- // additional inputs and outputs for this and other edges.
- // Once the dyndep file is loaded it will no longer be pending
- // if any other edges encounter it, but they will already have
- // been updated.
- // * If the dyndep file is not ready then since is known to be an
- // input to this edge, the edge will not be considered ready below.
- // Later during the build the dyndep file will become ready and be
- // loaded to update this edge before it can possibly be scheduled.
- if (edge->dyndep_ && edge->dyndep_->dyndep_pending()) {
- if (!RecomputeNodeDirty(edge->dyndep_, stack, validation_nodes, err))
- return false;
-
- if (!edge->dyndep_->in_edge() ||
- edge->dyndep_->in_edge()->outputs_ready()) {
- // The dyndep file is ready, so load it now.
- if (!LoadDyndeps(edge->dyndep_, err))
- return false;
- }
- }
- }
-
- // Load output mtimes so we can compare them to the most recent input below.
- for (vector<Node*>::iterator o = edge->outputs_.begin();
- o != edge->outputs_.end(); ++o) {
- if (!(*o)->StatIfNecessary(disk_interface_, err))
- return false;
- }
-
- if (!edge->deps_loaded_) {
- // This is our first encounter with this edge. Load discovered deps.
- edge->deps_loaded_ = true;
- if (!dep_loader_.LoadDeps(edge, err)) {
- if (!err->empty())
- return false;
- // Failed to load dependency info: rebuild to regenerate it.
- // LoadDeps() did EXPLAIN() already, no need to do it here.
- dirty = edge->deps_missing_ = true;
- }
- }
-
- // Store any validation nodes from the edge for adding to the initial
- // nodes. Don't recurse into them, that would trigger the dependency
- // cycle detector if the validation node depends on this node.
- // RecomputeDirty will add the validation nodes to the initial nodes
- // and recurse into them.
- validation_nodes->insert(validation_nodes->end(),
- edge->validations_.begin(), edge->validations_.end());
-
- // Visit all inputs; we're dirty if any of the inputs are dirty.
- Node* most_recent_input = NULL;
- for (vector<Node*>::iterator i = edge->inputs_.begin();
- i != edge->inputs_.end(); ++i) {
- // Visit this input.
- if (!RecomputeNodeDirty(*i, stack, validation_nodes, err))
- return false;
-
- // If an input is not ready, neither are our outputs.
- if (Edge* in_edge = (*i)->in_edge()) {
- if (!in_edge->outputs_ready_)
- edge->outputs_ready_ = false;
- }
-
- if (!edge->is_order_only(i - edge->inputs_.begin())) {
- // If a regular input is dirty (or missing), we're dirty.
- // Otherwise consider mtime.
- if ((*i)->dirty()) {
- EXPLAIN("%s is dirty", (*i)->path().c_str());
- dirty = true;
- } else {
- if (!most_recent_input || (*i)->mtime() > most_recent_input->mtime()) {
- most_recent_input = *i;
- }
- }
- }
- }
-
- // We may also be dirty due to output state: missing outputs, out of
- // date outputs, etc. Visit all outputs and determine whether they're dirty.
- if (!dirty)
- if (!RecomputeOutputsDirty(edge, most_recent_input, &dirty, err))
- return false;
-
- // Finally, visit each output and update their dirty state if necessary.
- for (vector<Node*>::iterator o = edge->outputs_.begin();
- o != edge->outputs_.end(); ++o) {
- if (dirty)
- (*o)->MarkDirty();
- }
-
- // If an edge is dirty, its outputs are normally not ready. (It's
- // possible to be clean but still not be ready in the presence of
- // order-only inputs.)
- // But phony edges with no inputs have nothing to do, so are always
- // ready.
- if (dirty && !(edge->is_phony() && edge->inputs_.empty()))
- edge->outputs_ready_ = false;
-
- // Mark the edge as finished during this walk now that it will no longer
- // be in the call stack.
- edge->mark_ = Edge::VisitDone;
- assert(stack->back() == node);
- stack->pop_back();
-
- return true;
-}
-
-bool DependencyScan::VerifyDAG(Node* node, vector<Node*>* stack, string* err) {
- Edge* edge = node->in_edge();
- assert(edge != NULL);
-
- // If we have no temporary mark on the edge then we do not yet have a cycle.
- if (edge->mark_ != Edge::VisitInStack)
- return true;
-
- // We have this edge earlier in the call stack. Find it.
- vector<Node*>::iterator start = stack->begin();
- while (start != stack->end() && (*start)->in_edge() != edge)
- ++start;
- assert(start != stack->end());
-
- // Make the cycle clear by reporting its start as the node at its end
- // instead of some other output of the starting edge. For example,
- // running 'ninja b' on
- // build a b: cat c
- // build c: cat a
- // should report a -> c -> a instead of b -> c -> a.
- *start = node;
-
- // Construct the error message rejecting the cycle.
- *err = "dependency cycle: ";
- for (vector<Node*>::const_iterator i = start; i != stack->end(); ++i) {
- err->append((*i)->path());
- err->append(" -> ");
- }
- err->append((*start)->path());
-
- if ((start + 1) == stack->end() && edge->maybe_phonycycle_diagnostic()) {
- // The manifest parser would have filtered out the self-referencing
- // input if it were not configured to allow the error.
- err->append(" [-w phonycycle=err]");
- }
-
- return false;
-}
-
-bool DependencyScan::RecomputeOutputsDirty(Edge* edge, Node* most_recent_input,
- bool* outputs_dirty, string* err) {
- for (vector<Node*>::iterator o = edge->outputs_.begin();
- o != edge->outputs_.end(); ++o) {
- if (RecomputeOutputDirty(edge, most_recent_input, *o)) {
- *outputs_dirty = true;
- return true;
- }
- }
- return true;
-}
-
-bool DependencyScan::RecomputeOutputDirty(const Edge* edge,
- const Node* most_recent_input,
- Node* output) {
- if (edge->is_phony()) {
- // Phony edges don't write any output. Outputs are only dirty if
- // there are no inputs and we're missing the output.
- if (edge->inputs_.empty() && !output->exists()) {
- EXPLAIN("output %s of phony edge with no inputs doesn't exist",
- output->path().c_str());
- return true;
- }
-
- // Update the mtime with the newest input. Dependents can thus call mtime()
- // on the fake node and get the latest mtime of the dependencies
- if (most_recent_input) {
- output->UpdatePhonyMtime(most_recent_input->mtime());
- }
-
- // Phony edges are clean, nothing to do
- return false;
- }
-
- // Dirty if we're missing the output.
- if (!output->exists()) {
- EXPLAIN("output %s doesn't exist", output->path().c_str());
- return true;
- }
-
- BuildLog::LogEntry* entry = 0;
-
- // If this is a restat rule, we may have cleaned the output in a
- // previous run and stored the command start time in the build log.
- // We don't want to consider a restat rule's outputs as dirty unless
- // an input changed since the last run, so we'll skip checking the
- // output file's actual mtime and simply check the recorded mtime from
- // the log against the most recent input's mtime (see below)
- bool used_restat = false;
- if (edge->has_restat() && build_log() &&
- (entry = build_log()->LookupByOutput(output->path()))) {
- used_restat = true;
- }
-
- // Dirty if the output is older than the input.
- if (!used_restat && most_recent_input && output->mtime() < most_recent_input->mtime()) {
- EXPLAIN("output %s older than most recent input %s "
- "(%" PRId64 " vs %" PRId64 ")",
- output->path().c_str(),
- most_recent_input->path().c_str(),
- output->mtime(), most_recent_input->mtime());
- return true;
- }
-
- if (build_log()) {
- bool generator = edge->is_generator();
- if (entry || (entry = build_log()->LookupByOutput(output->path()))) {
- if (!generator && edge->GetCommandHash() != entry->command_hash) {
- // May also be dirty due to the command changing since the last build.
- // But if this is a generator rule, the command changing does not make us
- // dirty.
- EXPLAIN("command line changed for %s", output->path().c_str());
- return true;
- }
- if (most_recent_input && entry->mtime < most_recent_input->mtime()) {
- // May also be dirty due to the mtime in the log being older than the
- // mtime of the most recent input. This can occur even when the mtime
- // on disk is newer if a previous run wrote to the output file but
- // exited with an error or was interrupted. If this was a restat rule,
- // then we only check the recorded mtime against the most recent input
- // mtime and ignore the actual output's mtime above.
- EXPLAIN("recorded mtime of %s older than most recent input %s (%" PRId64 " vs %" PRId64 ")",
- output->path().c_str(), most_recent_input->path().c_str(),
- entry->mtime, most_recent_input->mtime());
- return true;
- }
- }
- if (!entry && !generator) {
- EXPLAIN("command line not found in log for %s", output->path().c_str());
- return true;
- }
- }
-
- return false;
-}
-
-bool DependencyScan::LoadDyndeps(Node* node, string* err) const {
- return dyndep_loader_.LoadDyndeps(node, err);
-}
-
-bool DependencyScan::LoadDyndeps(Node* node, DyndepFile* ddf,
- string* err) const {
- return dyndep_loader_.LoadDyndeps(node, ddf, err);
-}
-
-void Edge::SetRestat() {
- env_->AddBinding("restat", "1");
- has_restat_ = 1;
-}
-
-bool Edge::has_restat() const {
- if (has_restat_ < 0)
- has_restat_ = GetBindingBool("restat") ? 1 : 0;
- return has_restat_ != 0;
-}
-
-bool Edge::is_generator() const {
- if (is_generator_ < 0)
- is_generator_ = GetBindingBool("generator") ? 1 : 0;
- return is_generator_ != 0;
-}
-
-bool Edge::AllInputsReady() const {
- for (vector<Node*>::const_iterator i = inputs_.begin();
- i != inputs_.end(); ++i) {
- if ((*i)->in_edge() && !(*i)->in_edge()->outputs_ready())
- return false;
- }
- return true;
-}
-
-/// An Env for an Edge, providing $in and $out.
-struct EdgeEnv : public Env {
- enum EscapeKind { kShellEscape, kDoNotEscape };
-
- EdgeEnv(const Edge* const edge, const EscapeKind escape)
- : edge_(edge), escape_in_out_(escape), recursive_(false) {}
- virtual string LookupVariable(const string& var);
-
- /// Given a span of Nodes, construct a list of paths suitable for a command
- /// line.
- std::string MakePathList(const Node* const* span, size_t size, char sep) const;
-
- private:
- vector<string> lookups_;
- const Edge* const edge_;
- EscapeKind escape_in_out_;
- bool recursive_;
-};
-
-string EdgeEnv::LookupVariable(const string& var) {
- if (var == "in" || var == "in_newline") {
- int explicit_deps_count = edge_->inputs_.size() - edge_->implicit_deps_ -
- edge_->order_only_deps_;
- return MakePathList(edge_->inputs_.data(), explicit_deps_count,
- var == "in" ? ' ' : '\n');
- } else if (var == "out") {
- int explicit_outs_count = edge_->outputs_.size() - edge_->implicit_outs_;
- return MakePathList(&edge_->outputs_[0], explicit_outs_count, ' ');
- }
-
- if (recursive_) {
- vector<string>::const_iterator it;
- if ((it = find(lookups_.begin(), lookups_.end(), var)) != lookups_.end()) {
- string cycle;
- for (; it != lookups_.end(); ++it)
- cycle.append(*it + " -> ");
- cycle.append(var);
- Fatal(("cycle in rule variables: " + cycle).c_str());
- }
- }
-
- // See notes on BindingEnv::LookupWithFallback.
- const EvalString* eval = edge_->rule_->GetBinding(var);
- bool record_varname = recursive_ && eval;
- if (record_varname)
- lookups_.push_back(var);
-
- // In practice, variables defined on rules never use another rule variable.
- // For performance, only start checking for cycles after the first lookup.
- recursive_ = true;
- std::string result = edge_->env_->LookupWithFallback(var, eval, this);
- if (record_varname)
- lookups_.pop_back();
- return result;
-}
-
-std::string EdgeEnv::MakePathList(const Node* const* const span,
- const size_t size, const char sep) const {
- string result;
- for (const Node* const* i = span; i != span + size; ++i) {
- if (!result.empty())
- result.push_back(sep);
- const string& path = (*i)->PathDecanonicalized();
- if (escape_in_out_ == kShellEscape) {
-#ifdef _WIN32
- GetWin32EscapedString(path, &result);
-#else
- GetShellEscapedString(path, &result);
-#endif
- } else {
- result.append(path);
- }
- }
- return result;
-}
-
-void Edge::CollectInputs(bool shell_escape,
- std::vector<std::string>* out) const {
- for (std::vector<Node*>::const_iterator it = inputs_.begin();
- it != inputs_.end(); ++it) {
- std::string path = (*it)->PathDecanonicalized();
- if (shell_escape) {
- std::string unescaped;
- unescaped.swap(path);
-#ifdef _WIN32
- GetWin32EscapedString(unescaped, &path);
-#else
- GetShellEscapedString(unescaped, &path);
-#endif
- }
-#if __cplusplus >= 201103L
- out->push_back(std::move(path));
-#else
- out->push_back(path);
-#endif
- }
-}
-
-std::string Edge::EvaluateCommand(const bool incl_rsp_file) const {
- string command = GetBinding("command");
- if (incl_rsp_file) {
- string rspfile_content = GetBinding("rspfile_content");
- if (!rspfile_content.empty())
- command += ";rspfile=" + rspfile_content;
- }
- return command;
-}
-
-std::string Edge::GetBinding(const std::string& key) const {
- EdgeEnv env(this, EdgeEnv::kShellEscape);
- return env.LookupVariable(key);
-}
-
-bool Edge::GetBindingBool(const string& key) const {
- return !GetBinding(key).empty();
-}
-
-uint64_t Edge::GetCommandHash() const {
- if (!has_command_hash_) {
- std::string command = EvaluateCommand(/* incl_rsp_file */ true);
- command_hash_ = BuildLog::LogEntry::HashCommand(command);
- has_command_hash_ = true;
- }
- return command_hash_;
-}
-
-string Edge::GetUnescapedDepfile() const {
- EdgeEnv env(this, EdgeEnv::kDoNotEscape);
- return env.LookupVariable("depfile");
-}
-
-string Edge::GetUnescapedDyndep() const {
- EdgeEnv env(this, EdgeEnv::kDoNotEscape);
- return env.LookupVariable("dyndep");
-}
-
-std::string Edge::GetUnescapedRspfile() const {
- EdgeEnv env(this, EdgeEnv::kDoNotEscape);
- return env.LookupVariable("rspfile");
-}
-
-void Edge::Dump(const char* prefix) const {
- printf("%s[ ", prefix);
- for (vector<Node*>::const_iterator i = inputs_.begin();
- i != inputs_.end() && *i != NULL; ++i) {
- printf("%s ", (*i)->path().c_str());
- }
- printf("--%s-> ", rule_->name().c_str());
- for (vector<Node*>::const_iterator i = outputs_.begin();
- i != outputs_.end() && *i != NULL; ++i) {
- printf("%s ", (*i)->path().c_str());
- }
- if (!validations_.empty()) {
- printf(" validations ");
- for (std::vector<Node*>::const_iterator i = validations_.begin();
- i != validations_.end() && *i != NULL; ++i) {
- printf("%s ", (*i)->path().c_str());
- }
- }
- if (pool_) {
- if (!pool_->name().empty()) {
- printf("(in pool '%s')", pool_->name().c_str());
- }
- } else {
- printf("(null pool?)");
- }
- printf("] 0x%p\n", this);
-}
-
-void Edge::UpdateDynamicImplicitDeps(size_t new_count, Node* const* new_deps) {
- size_t cur_count =
- static_cast<size_t>(implicit_deps_ - static_implicit_deps_);
- auto cur_deps = inputs_.end() - order_only_deps_ - cur_count;
-
- // Most of the time, the content of depfiles will not change between
- // command invocations, and thus |new_deps| will already be recorded
- // in this edge. Detect when this is the case and exit immediately.
- if (cur_count == new_count &&
- !memcmp(&(*cur_deps), new_deps, cur_count * sizeof(Node*))) {
- return;
- }
-
- // If there are no recorded deps, insert the new ones directly.
- // This happens the first time this function is called for a given
- // Edge instance.
- if (cur_count == 0) {
- auto it = inputs_.insert(cur_deps, new_count, nullptr);
- implicit_deps_ += new_count;
- for (size_t n = 0; n < new_count; ++n) {
- Node* node = new_deps[n];
- *it++ = node;
- node->AddOutEdge(this);
- }
- return;
- }
-
- // This is the general case where the content of a depfile changed since
- // the last build invocation. This is rare but can happen, for example
- // when depfile inputs have content-hash based names that change with
- // the content of another input.
- //
- // Because benchmarking shows that modifying the build graph is slow for
- // very large build plans, try to minimize changes by detecting the set of
- // nodes to remove from the current edge, then the set of new ones to add.
- std::set<Node*> cur_set(cur_deps, cur_deps + cur_count);
- std::set<Node*> new_set(new_deps, new_deps + new_count);
-
- // Remove all nodes that are no longer in |new_deps|.
- {
- auto it = cur_deps;
- for (size_t n = 0; n < cur_count;) {
- Node* node = *it;
- if (!new_set.count(node)) {
- node->RemoveOutEdge(this);
- it = inputs_.erase(it);
- implicit_deps_ -= 1;
- cur_count -= 1;
- } else {
- ++it;
- ++n;
- }
- }
- cur_deps = inputs_.end() - order_only_deps_ - cur_count;
- }
-
- // Add any edge in |new_deps| that is not in the current set.
- {
- auto it = cur_deps + cur_count;
- for (size_t n = 0; n < new_count; ++n) {
- Node* node = new_deps[n];
- if (cur_set.count(node))
- continue;
- implicit_deps_ += 1;
- it = inputs_.insert(it, node) + 1;
- node->AddOutEdge(this);
- }
- }
-}
-
-bool Edge::UpdateDynamicImplicitOutputs(size_t new_count, Node* const* new_outs,
- std::string* err) {
- size_t cur_count =
- static_cast<size_t>(implicit_outs_ - static_implicit_outs_);
- auto cur_outs = outputs_.end() - cur_count;
-
- // Most of the time, the content of dyndep files will not change.
- if (cur_count == new_count &&
- !memcmp(&(*cur_outs), new_outs, cur_count * sizeof(Node*))) {
- return true;
- }
-
- // If there are no recorded outputs, insert the new ones directly.
- if (cur_count == 0) {
- auto it = outputs_.insert(cur_outs, new_count, nullptr);
- implicit_outs_ += new_count;
- for (size_t n = 0; n < new_count; ++n) {
- Node* node = new_outs[n];
- if (node->in_edge()) {
- // This node already has an edge producing it.
- *err = "multiple rules generate " + node->path();
- return false;
- }
- *it++ = node;
- node->set_in_edge(this);
- }
- return true;
- }
-
- // This is the general case where the content of a dyndep file changed since
- // the last build invocation.
- std::set<Node*> cur_set(cur_outs, cur_outs + cur_count);
- std::set<Node*> new_set(new_outs, new_outs + new_count);
-
- // Remove all nodes that are no longer in |new_outs|.
- {
- auto it = cur_outs;
- for (size_t n = 0; n < cur_count;) {
- Node* node = *it;
- assert(node->in_edge() == this);
- if (!new_set.count(node)) {
- node->set_in_edge(nullptr);
- it = outputs_.erase(it);
- implicit_outs_ -= 1;
- cur_count -= 1;
- } else {
- ++it;
- ++n;
- }
- }
- cur_outs = outputs_.end() - cur_count;
- }
-
- // Add any edge in |new_outs| that is not in the current set.
- {
- auto it = cur_outs + cur_count;
- for (size_t n = 0; n < new_count; ++n) {
- Node* node = new_outs[n];
- if (cur_set.count(node))
- continue;
- if (node->in_edge()) {
- // This node already has an edge producing it.
- *err = "multiple rules generate " + node->path();
- return false;
- }
- node->set_in_edge(this);
- implicit_outs_ += 1;
- it = outputs_.insert(it, node) + 1;
- }
- }
- return true;
-}
-
-bool Edge::is_phony() const {
- return rule_->is_phony();
-}
-
-bool Edge::use_console() const {
- return pool()->is_console();
-}
-
-bool Edge::maybe_phonycycle_diagnostic() const {
- // CMake 2.8.12.x and 3.0.x produced self-referencing phony rules
- // of the form "build a: phony ... a ...". Restrict our
- // "phonycycle" diagnostic option to the form it used.
- return is_phony() && outputs_.size() == 1 && implicit_outs_ == 0 &&
- implicit_deps_ == 0;
-}
-
-// static
-string Node::PathDecanonicalized(const string& path, uint64_t slash_bits) {
- string result = path;
-#ifdef _WIN32
- uint64_t mask = 1;
- for (char* c = &result[0]; (c = strchr(c, '/')) != NULL;) {
- if (slash_bits & mask)
- *c = '\\';
- c++;
- mask <<= 1;
- }
-#endif
- return result;
-}
-
-void Node::RemoveOutEdge(Edge* edge) {
- auto it = std::find(out_edges_.begin(), out_edges_.end(), edge);
- assert(it != out_edges_.end());
- // order is not important here, avoid O(n) deletion cost.
- *it = out_edges_.back();
- out_edges_.pop_back();
-}
-
-void Node::Dump(const char* prefix) const {
- printf("%s <%s 0x%p> mtime: %" PRId64 "%s, (:%s), ",
- prefix, path().c_str(), this,
- mtime(), exists() ? "" : " (:missing)",
- dirty() ? " dirty" : " clean");
- if (in_edge()) {
- in_edge()->Dump("in-edge: ");
- } else {
- printf("no in-edge\n");
- }
- printf(" out edges:\n");
- for (vector<Edge*>::const_iterator e = out_edges().begin();
- e != out_edges().end() && *e != NULL; ++e) {
- (*e)->Dump(" +- ");
- }
- if (!validation_out_edges().empty()) {
- printf(" validation out edges:\n");
- for (std::vector<Edge*>::const_iterator e = validation_out_edges().begin();
- e != validation_out_edges().end() && *e != NULL; ++e) {
- (*e)->Dump(" +- ");
- }
- }
-}
-
-bool ImplicitDepLoader::LoadDeps(Edge* edge, string* err) {
- string deps_type = edge->GetBinding("deps");
- if (!deps_type.empty())
- return LoadDepsFromLog(edge, err);
-
- string depfile = edge->GetUnescapedDepfile();
- if (!depfile.empty())
- return LoadDepFile(edge, depfile, err);
-
- // No deps to load.
- return true;
-}
-
-struct matches {
- explicit matches(std::vector<StringPiece>::iterator i) : i_(i) {}
-
- bool operator()(const Node* node) const {
- StringPiece opath = StringPiece(node->path());
- return *i_ == opath;
- }
-
- std::vector<StringPiece>::iterator i_;
-};
-
-bool ImplicitDepLoader::LoadDepFile(Edge* edge, const string& path,
- string* err) {
- METRIC_RECORD("depfile load");
- // Read depfile content. Treat a missing depfile as empty.
- string content;
- switch (disk_interface_->ReadFile(path, &content, err)) {
- case DiskInterface::Okay:
- break;
- case DiskInterface::NotFound:
- err->clear();
- break;
- case DiskInterface::OtherError:
- *err = "loading '" + path + "': " + *err;
- return false;
- }
- // On a missing depfile: return false and empty *err.
- if (content.empty()) {
- EXPLAIN("depfile '%s' is missing", path.c_str());
- return false;
- }
-
- DepfileParser depfile(depfile_parser_options_
- ? *depfile_parser_options_
- : DepfileParserOptions());
- string depfile_err;
- if (!depfile.Parse(&content, &depfile_err)) {
- *err = path + ": " + depfile_err;
- return false;
- }
-
- if (depfile.outs_.empty()) {
- *err = path + ": no outputs declared";
- return false;
- }
-
- uint64_t unused;
- std::vector<StringPiece>::iterator primary_out = depfile.outs_.begin();
- CanonicalizePath(const_cast<char*>(primary_out->str_), &primary_out->len_,
- &unused);
-
- // Check that this depfile matches the edge's output, if not return false to
- // mark the edge as dirty.
- Node* first_output = edge->outputs_[0];
- StringPiece opath = StringPiece(first_output->path());
- if (opath != *primary_out) {
- EXPLAIN("expected depfile '%s' to mention '%s', got '%s'", path.c_str(),
- first_output->path().c_str(), primary_out->AsString().c_str());
- return false;
- }
-
- // Ensure that all mentioned outputs are outputs of the edge.
- for (std::vector<StringPiece>::iterator o = depfile.outs_.begin();
- o != depfile.outs_.end(); ++o) {
- matches m(o);
- if (std::find_if(edge->outputs_.begin(), edge->outputs_.end(), m) == edge->outputs_.end()) {
- *err = path + ": depfile mentions '" + o->AsString() + "' as an output, but no such output was declared";
- return false;
- }
- }
-
- return ProcessDepfileDeps(edge, &depfile.ins_, err);
-}
-
-bool ImplicitDepLoader::ProcessDepfileDeps(
- Edge* edge, std::vector<StringPiece>* depfile_ins, std::string* err) {
- std::vector<Node*> new_deps;
- new_deps.reserve(depfile_ins->size());
- for (StringPiece dep : *depfile_ins) {
- uint64_t slash_bits;
- CanonicalizePath(const_cast<char*>(dep.str_), &dep.len_, &slash_bits);
- new_deps.push_back(state_->GetNode(dep, slash_bits));
- }
- edge->UpdateDynamicImplicitDeps(new_deps.size(), new_deps.data());
- return true;
-}
-
-bool ImplicitDepLoader::LoadDepsFromLog(Edge* edge, string* err) {
- // NOTE: deps are only supported for single-target edges.
- Node* output = edge->outputs_[0];
- DepsLog::Deps* deps = deps_log_ ? deps_log_->GetDeps(output) : NULL;
- if (!deps) {
- EXPLAIN("deps for '%s' are missing", output->path().c_str());
- return false;
- }
-
- // Deps are invalid if the output is newer than the deps.
- if (output->mtime() > deps->mtime) {
- EXPLAIN("stored deps info out of date for '%s' (%" PRId64 " vs %" PRId64 ")",
- output->path().c_str(), deps->mtime, output->mtime());
- return false;
- }
-
- edge->UpdateDynamicImplicitDeps(static_cast<size_t>(deps->node_count),
- deps->nodes);
- return true;
-}
-
-vector<Node*>::iterator ImplicitDepLoader::PreallocateSpace(Edge* edge,
- int count) {
- edge->inputs_.insert(edge->inputs_.end() - edge->order_only_deps_,
- (size_t)count, 0);
- edge->implicit_deps_ += count;
- return edge->inputs_.end() - edge->order_only_deps_ - count;
-}
diff --git a/src/graph.h b/src/graph.h
deleted file mode 100644
index 2cda42b..0000000
--- a/src/graph.h
+++ /dev/null
@@ -1,450 +0,0 @@
-// Copyright 2011 Google Inc. All Rights Reserved.
-//
-// Licensed under the Apache License, Version 2.0 (the "License");
-// you may not use this file except in compliance with the License.
-// You may obtain a copy of the License at
-//
-// http://www.apache.org/licenses/LICENSE-2.0
-//
-// Unless required by applicable law or agreed to in writing, software
-// distributed under the License is distributed on an "AS IS" BASIS,
-// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-// See the License for the specific language governing permissions and
-// limitations under the License.
-
-#ifndef NINJA_GRAPH_H_
-#define NINJA_GRAPH_H_
-
-#include <algorithm>
-#include <set>
-#include <string>
-#include <vector>
-
-#include "dyndep.h"
-#include "eval_env.h"
-#include "timestamp.h"
-#include "util.h"
-
-struct BuildLog;
-struct DepfileParserOptions;
-struct DiskInterface;
-struct DepsLog;
-struct Edge;
-struct Node;
-struct Pool;
-struct State;
-
-/// Information about a node in the dependency graph: the file, whether
-/// it's dirty, mtime, etc.
-struct Node {
- Node(const std::string& path, uint64_t slash_bits)
- : path_(path),
- slash_bits_(slash_bits),
- mtime_(-1),
- exists_(ExistenceStatusUnknown),
- dirty_(false),
- dyndep_pending_(false),
- in_edge_(NULL),
- id_(-1) {}
-
- /// Return false on error.
- bool Stat(DiskInterface* disk_interface, std::string* err);
-
- /// If the file doesn't exist, set the mtime_ from its dependencies
- void UpdatePhonyMtime(TimeStamp mtime);
-
- /// Return false on error.
- bool StatIfNecessary(DiskInterface* disk_interface, std::string* err) {
- if (status_known())
- return true;
- return Stat(disk_interface, err);
- }
-
- /// Mark as not-yet-stat()ed and not dirty.
- void ResetState() {
- mtime_ = -1;
- exists_ = ExistenceStatusUnknown;
- dirty_ = false;
- dyndep_pending_ = false;
- }
-
- /// Mark the Node as already-stat()ed and missing.
- void MarkMissing() {
- if (mtime_ == -1) {
- mtime_ = 0;
- }
- exists_ = ExistenceStatusMissing;
- }
-
- bool exists() const {
- return exists_ == ExistenceStatusExists;
- }
-
- bool status_known() const {
- return exists_ != ExistenceStatusUnknown;
- }
-
- const std::string& path() const { return path_; }
- /// Get |path()| but use slash_bits to convert back to original slash styles.
- std::string PathDecanonicalized() const {
- return PathDecanonicalized(path_, slash_bits_);
- }
- static std::string PathDecanonicalized(const std::string& path,
- uint64_t slash_bits);
- uint64_t slash_bits() const { return slash_bits_; }
-
- TimeStamp mtime() const { return mtime_; }
-
- bool dirty() const { return dirty_; }
- void set_dirty(bool dirty) { dirty_ = dirty; }
- void MarkDirty() { dirty_ = true; }
-
- bool dyndep_pending() const { return dyndep_pending_; }
- void set_dyndep_pending(bool pending) { dyndep_pending_ = pending; }
-
- Edge* in_edge() const { return in_edge_; }
- void set_in_edge(Edge* edge) { in_edge_ = edge; }
-
- /// Indicates whether this node was generated from a depfile or dyndep file,
- /// instead of being a regular input or output from the Ninja manifest.
- bool generated_by_dep_loader() const { return generated_by_dep_loader_; }
-
- void set_generated_by_dep_loader(bool value) {
- generated_by_dep_loader_ = value;
- }
-
- int id() const { return id_; }
- void set_id(int id) { id_ = id; }
-
- const std::vector<Edge*>& out_edges() const { return out_edges_; }
- const std::vector<Edge*>& validation_out_edges() const { return validation_out_edges_; }
- void AddOutEdge(Edge* edge) { out_edges_.push_back(edge); }
- void RemoveOutEdge(Edge* edge);
- void AddValidationOutEdge(Edge* edge) { validation_out_edges_.push_back(edge); }
-
- void Dump(const char* prefix="") const;
-
-private:
- std::string path_;
-
- /// Set bits starting from lowest for backslashes that were normalized to
- /// forward slashes by CanonicalizePath. See |PathDecanonicalized|.
- uint64_t slash_bits_;
-
- /// Possible values of mtime_:
- /// -1: file hasn't been examined
- /// 0: we looked, and file doesn't exist
- /// >0: actual file's mtime, or the latest mtime of its dependencies if it doesn't exist
- TimeStamp mtime_;
-
- enum ExistenceStatus {
- /// The file hasn't been examined.
- ExistenceStatusUnknown,
- /// The file doesn't exist. mtime_ will be the latest mtime of its dependencies.
- ExistenceStatusMissing,
- /// The path is an actual file. mtime_ will be the file's mtime.
- ExistenceStatusExists
- };
- ExistenceStatus exists_;
-
- /// Dirty is true when the underlying file is out-of-date.
- /// But note that Edge::outputs_ready_ is also used in judging which
- /// edges to build.
- bool dirty_;
-
- /// Store whether dyndep information is expected from this node but
- /// has not yet been loaded.
- bool dyndep_pending_;
-
- /// Set to true when this node comes from a depfile, a dyndep file or the
- /// deps log. If it does not have a producing edge, the build should not
- /// abort if it is missing (as for regular source inputs). By default
- /// all nodes have this flag set to true, since the deps and build logs
- /// can be loaded before the manifest.
- bool generated_by_dep_loader_ = true;
-
- /// The Edge that produces this Node, or NULL when there is no
- /// known edge to produce it.
- Edge* in_edge_;
-
- /// All Edges that use this Node as an input.
- std::vector<Edge*> out_edges_;
-
- /// All Edges that use this Node as a validation.
- std::vector<Edge*> validation_out_edges_;
-
- /// A dense integer id for the node, assigned and used by DepsLog.
- int id_;
-};
-
-/// An edge in the dependency graph; links between Nodes using Rules.
-struct Edge {
- enum VisitMark {
- VisitNone,
- VisitInStack,
- VisitDone
- };
-
- Edge()
- : rule_(NULL), pool_(NULL), dyndep_(NULL), env_(NULL), mark_(VisitNone),
- id_(0), outputs_ready_(false), deps_loaded_(false),
- deps_missing_(false), has_restat_(-1), is_generator_(-1),
- command_start_time_(0), static_implicit_deps_(0), implicit_deps_(0),
- order_only_deps_(0), static_implicit_outs_(0), implicit_outs_(0) {}
-
- /// Return true if all inputs' in-edges are ready.
- bool AllInputsReady() const;
-
- /// Expand all variables in a command and return it as a string.
- /// If incl_rsp_file is enabled, the string will also contain the
- /// full contents of a response file (if applicable)
- std::string EvaluateCommand(bool incl_rsp_file = false) const;
-
- /// Returns the shell-escaped value of |key|.
- std::string GetBinding(const std::string& key) const;
- bool GetBindingBool(const std::string& key) const;
-
- /// Like GetBinding("depfile"), but without shell escaping.
- std::string GetUnescapedDepfile() const;
- /// Like GetBinding("dyndep"), but without shell escaping.
- std::string GetUnescapedDyndep() const;
- /// Like GetBinding("rspfile"), but without shell escaping.
- std::string GetUnescapedRspfile() const;
-
- void Dump(const char* prefix="") const;
-
- /// Append all edge explicit inputs to |*out|. Possibly with shell escaping.
- void CollectInputs(bool shell_escape, std::vector<std::string>* out) const;
-
- /// Reset state of edge for next build / dependency scan.
- void ResetState() {
- outputs_ready_ = false;
- deps_missing_ = false;
- mark_ = VisitNone;
- }
-
- const Rule* rule_;
- Pool* pool_;
- std::vector<Node*> inputs_;
- std::vector<Node*> outputs_;
- std::vector<Node*> validations_;
- Node* dyndep_;
- BindingEnv* env_;
- VisitMark mark_;
- size_t id_;
- bool outputs_ready_;
-
- /// Set to true to indicate that this edge contains extra dependencies that
- /// were loaded from depfiles, the deps log, or dyndep files.
- bool deps_loaded_;
-
- bool deps_missing_;
-
- /// True for special phony edges that are created when loading extra
- /// dependencies from depfiles or the deps log that do not have a
- /// generating edge.
- bool generated_by_dep_loader_;
-
- /// Return the command hash for this edge.
- uint64_t GetCommandHash() const;
-
- /// True if command_hash_ is valid. Modified by const method.
- mutable bool has_command_hash_ = false;
- mutable uint64_t command_hash_ = 0;
-
- TimeStamp command_start_time_;
-
- const Rule& rule() const { return *rule_; }
- Pool* pool() const { return pool_; }
- int weight() const { return 1; }
- bool outputs_ready() const { return outputs_ready_; }
-
- /// Return true if "restat" is set for this edge.
- bool has_restat() const;
- mutable int has_restat_ = -1; // computed on-demand by const method.
-
- /// Return true if "generator" is set for this edge.
- bool is_generator() const;
- mutable int is_generator_ = -1; // computed on-demand by const method.
-
- void SetRestat();
-
- // There are four types of inputs.
- // 1) explicit deps, which show up as $in on the command line;
- // 2) static implicit deps, which the target depends on implicitly (e.g. C
- // headers), as they appear in the build plan, and changes in them cause
- // the target to be rebuild.
- // 3) dynamic implicit deps, which come from depfiles, the deps log or
- // dyndep files. They never appear in the build plan, and are inserted
- // into the build plan during incremental builds. They are otherwise
- // considered implicit dependencies.
- // 4) order-only deps, which are needed before the target builds but which
- // don't cause the target to rebuild.
- // These are stored in inputs_ in that order, and we keep counts of
- // #2, #3 and #4 when we need to access the various subsets.
- //
- // static_implicit_deps_
- // |
- // inputs_ [...|<----*----->| |<--order_only_deps_-->]
- // |<------implicit_deps_--->|
- //
- int static_implicit_deps_;
- int implicit_deps_;
- int order_only_deps_;
- bool is_implicit(size_t index) {
- return index >= inputs_.size() - order_only_deps_ - implicit_deps_ &&
- !is_order_only(index);
- }
- bool is_order_only(size_t index) {
- return index >= inputs_.size() - order_only_deps_;
- }
-
- // There are three types of outputs.
- // 1) explicit outs, which show up as $out on the command line;
- // 2) static implicit outs, that the target generates in the build plan, and
- // which are not listed as part of $out.
- // 3) dynamic implicit outs. which do not appear in the build plan, but
- // inserted into the build graph through dyndep files only.
- // These are stored in outputs_ in that order, and we keep a count of
- // #2 and #3 to use when we need to access the various subsets.
- //
- // static_implicit_outs_
- // |
- // outputs_ [.....|<-----*------>| ]
- // |<--------implicit_outs_-------->|
- //
- int static_implicit_outs_;
- int implicit_outs_;
- bool is_implicit_out(size_t index) const {
- return index >= outputs_.size() - implicit_outs_;
- }
-
- /// Update the set of dynamic implicit inputs for this edge. These can
- /// come from the deps log, a depfile, or a dyndep file. This method tries
- /// to minimize the changes to the build graph during incremental builds.
- void UpdateDynamicImplicitDeps(size_t new_count, Node* const* new_deps);
-
- /// Update the set of dynamic implicit outputs for this edge. These only
- /// come from dyndep files. On success, return true. On failure, which means
- /// that one of the new outputs already has a producing edge, set |*err|
- /// then return false.
- bool UpdateDynamicImplicitOutputs(size_t new_count, Node* const* new_outs,
- std::string* err);
-
- bool is_phony() const;
- bool use_console() const;
- bool maybe_phonycycle_diagnostic() const;
-};
-
-struct EdgeCmp {
- bool operator()(const Edge* a, const Edge* b) const {
- return a->id_ < b->id_;
- }
-};
-
-typedef std::set<Edge*, EdgeCmp> EdgeSet;
-
-/// ImplicitDepLoader loads implicit dependencies, as referenced via the
-/// "depfile" attribute in build files.
-struct ImplicitDepLoader {
- ImplicitDepLoader(State* state, DepsLog* deps_log,
- DiskInterface* disk_interface,
- DepfileParserOptions const* depfile_parser_options)
- : state_(state), disk_interface_(disk_interface), deps_log_(deps_log),
- depfile_parser_options_(depfile_parser_options) {}
-
- /// Load implicit dependencies for \a edge.
- /// @return false on error (without filling \a err if info is just missing
- // or out of date).
- bool LoadDeps(Edge* edge, std::string* err);
-
- DepsLog* deps_log() const {
- return deps_log_;
- }
-
- protected:
- /// Process loaded implicit dependencies for \a edge and update the graph
- /// @return false on error (without filling \a err if info is just missing)
- virtual bool ProcessDepfileDeps(Edge* edge,
- std::vector<StringPiece>* depfile_ins,
- std::string* err);
-
- /// Load implicit dependencies for \a edge from a depfile attribute.
- /// @return false on error (without filling \a err if info is just missing).
- bool LoadDepFile(Edge* edge, const std::string& path, std::string* err);
-
- /// Load implicit dependencies for \a edge from the DepsLog.
- /// @return false on error (without filling \a err if info is just missing).
- bool LoadDepsFromLog(Edge* edge, std::string* err);
-
- /// Preallocate \a count spaces in the input array on \a edge, returning
- /// an iterator pointing at the first new space.
- std::vector<Node*>::iterator PreallocateSpace(Edge* edge, int count);
-
- State* state_;
- DiskInterface* disk_interface_;
- DepsLog* deps_log_;
- DepfileParserOptions const* depfile_parser_options_;
-};
-
-
-/// DependencyScan manages the process of scanning the files in a graph
-/// and updating the dirty/outputs_ready state of all the nodes and edges.
-struct DependencyScan {
- DependencyScan(State* state, BuildLog* build_log, DepsLog* deps_log,
- DiskInterface* disk_interface,
- DepfileParserOptions const* depfile_parser_options)
- : build_log_(build_log),
- disk_interface_(disk_interface),
- dep_loader_(state, deps_log, disk_interface, depfile_parser_options),
- dyndep_loader_(state, disk_interface) {}
-
- /// Update the |dirty_| state of the given nodes by transitively inspecting
- /// their input edges.
- /// Examine inputs, outputs, and command lines to judge whether an edge
- /// needs to be re-run, and update outputs_ready_ and each outputs' |dirty_|
- /// state accordingly.
- /// Appends any validation nodes found to the nodes parameter.
- /// Returns false on failure.
- bool RecomputeDirty(Node* node, std::vector<Node*>* validation_nodes, std::string* err);
-
- /// Recompute whether any output of the edge is dirty, if so sets |*dirty|.
- /// Returns false on failure.
- bool RecomputeOutputsDirty(Edge* edge, Node* most_recent_input,
- bool* dirty, std::string* err);
-
- BuildLog* build_log() const {
- return build_log_;
- }
- void set_build_log(BuildLog* log) {
- build_log_ = log;
- }
-
- DepsLog* deps_log() const {
- return dep_loader_.deps_log();
- }
-
- /// Load a dyndep file from the given node's path and update the
- /// build graph with the new information. One overload accepts
- /// a caller-owned 'DyndepFile' object in which to store the
- /// information loaded from the dyndep file.
- bool LoadDyndeps(Node* node, std::string* err) const;
- bool LoadDyndeps(Node* node, DyndepFile* ddf, std::string* err) const;
-
- private:
- bool RecomputeNodeDirty(Node* node, std::vector<Node*>* stack,
- std::vector<Node*>* validation_nodes, std::string* err);
- bool VerifyDAG(Node* node, std::vector<Node*>* stack, std::string* err);
-
- /// Recompute whether a given single output should be marked dirty.
- /// Returns true if so.
- bool RecomputeOutputDirty(const Edge* edge, const Node* most_recent_input,
- Node* output);
-
- BuildLog* build_log_;
- DiskInterface* disk_interface_;
- ImplicitDepLoader dep_loader_;
- DyndepLoader dyndep_loader_;
-};
-
-#endif // NINJA_GRAPH_H_
diff --git a/src/graph_test.cc b/src/graph_test.cc
deleted file mode 100644
index 8a738ec..0000000
--- a/src/graph_test.cc
+++ /dev/null
@@ -1,1166 +0,0 @@
-// Copyright 2011 Google Inc. All Rights Reserved.
-//
-// Licensed under the Apache License, Version 2.0 (the "License");
-// you may not use this file except in compliance with the License.
-// You may obtain a copy of the License at
-//
-// http://www.apache.org/licenses/LICENSE-2.0
-//
-// Unless required by applicable law or agreed to in writing, software
-// distributed under the License is distributed on an "AS IS" BASIS,
-// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-// See the License for the specific language governing permissions and
-// limitations under the License.
-
-#include "graph.h"
-#include "build.h"
-
-#include "test.h"
-
-using namespace std;
-
-struct GraphTest : public StateTestWithBuiltinRules {
- GraphTest() : scan_(&state_, NULL, NULL, &fs_, NULL) {}
-
- VirtualFileSystem fs_;
- DependencyScan scan_;
-};
-
-TEST_F(GraphTest, MissingImplicit) {
- ASSERT_NO_FATAL_FAILURE(AssertParse(&state_,
-"build out: cat in | implicit\n"));
- fs_.Create("in", "");
- fs_.Create("out", "");
-
- string err;
- EXPECT_TRUE(scan_.RecomputeDirty(GetNode("out"), NULL, &err));
- ASSERT_EQ("", err);
-
- // A missing implicit dep *should* make the output dirty.
- // (In fact, a build will fail.)
- // This is a change from prior semantics of ninja.
- EXPECT_TRUE(GetNode("out")->dirty());
-}
-
-TEST_F(GraphTest, ModifiedImplicit) {
- ASSERT_NO_FATAL_FAILURE(AssertParse(&state_,
-"build out: cat in | implicit\n"));
- fs_.Create("in", "");
- fs_.Create("out", "");
- fs_.Tick();
- fs_.Create("implicit", "");
-
- string err;
- EXPECT_TRUE(scan_.RecomputeDirty(GetNode("out"), NULL, &err));
- ASSERT_EQ("", err);
-
- // A modified implicit dep should make the output dirty.
- EXPECT_TRUE(GetNode("out")->dirty());
-}
-
-TEST_F(GraphTest, FunkyMakefilePath) {
- ASSERT_NO_FATAL_FAILURE(AssertParse(&state_,
-"rule catdep\n"
-" depfile = $out.d\n"
-" command = cat $in > $out\n"
-"build out.o: catdep foo.cc\n"));
- fs_.Create("foo.cc", "");
- fs_.Create("out.o.d", "out.o: ./foo/../implicit.h\n");
- fs_.Create("out.o", "");
- fs_.Tick();
- fs_.Create("implicit.h", "");
-
- string err;
- EXPECT_TRUE(scan_.RecomputeDirty(GetNode("out.o"), NULL, &err));
- ASSERT_EQ("", err);
-
- // implicit.h has changed, though our depfile refers to it with a
- // non-canonical path; we should still find it.
- EXPECT_TRUE(GetNode("out.o")->dirty());
-}
-
-TEST_F(GraphTest, ExplicitImplicit) {
- ASSERT_NO_FATAL_FAILURE(AssertParse(&state_,
-"rule catdep\n"
-" depfile = $out.d\n"
-" command = cat $in > $out\n"
-"build implicit.h: cat data\n"
-"build out.o: catdep foo.cc || implicit.h\n"));
- fs_.Create("implicit.h", "");
- fs_.Create("foo.cc", "");
- fs_.Create("out.o.d", "out.o: implicit.h\n");
- fs_.Create("out.o", "");
- fs_.Tick();
- fs_.Create("data", "");
-
- string err;
- EXPECT_TRUE(scan_.RecomputeDirty(GetNode("out.o"), NULL, &err));
- ASSERT_EQ("", err);
-
- // We have both an implicit and an explicit dep on implicit.h.
- // The implicit dep should "win" (in the sense that it should cause
- // the output to be dirty).
- EXPECT_TRUE(GetNode("out.o")->dirty());
-}
-
-TEST_F(GraphTest, ImplicitOutputParse) {
- ASSERT_NO_FATAL_FAILURE(AssertParse(&state_,
-"build out | out.imp: cat in\n"));
-
- Edge* edge = GetNode("out")->in_edge();
- EXPECT_EQ(2, edge->outputs_.size());
- EXPECT_EQ("out", edge->outputs_[0]->path());
- EXPECT_EQ("out.imp", edge->outputs_[1]->path());
- EXPECT_EQ(1, edge->implicit_outs_);
- EXPECT_EQ(edge, GetNode("out.imp")->in_edge());
-}
-
-TEST_F(GraphTest, ImplicitOutputMissing) {
- ASSERT_NO_FATAL_FAILURE(AssertParse(&state_,
-"build out | out.imp: cat in\n"));
- fs_.Create("in", "");
- fs_.Create("out", "");
-
- string err;
- EXPECT_TRUE(scan_.RecomputeDirty(GetNode("out"), NULL, &err));
- ASSERT_EQ("", err);
-
- EXPECT_TRUE(GetNode("out")->dirty());
- EXPECT_TRUE(GetNode("out.imp")->dirty());
-}
-
-TEST_F(GraphTest, ImplicitOutputOutOfDate) {
- ASSERT_NO_FATAL_FAILURE(AssertParse(&state_,
-"build out | out.imp: cat in\n"));
- fs_.Create("out.imp", "");
- fs_.Tick();
- fs_.Create("in", "");
- fs_.Create("out", "");
-
- string err;
- EXPECT_TRUE(scan_.RecomputeDirty(GetNode("out"), NULL, &err));
- ASSERT_EQ("", err);
-
- EXPECT_TRUE(GetNode("out")->dirty());
- EXPECT_TRUE(GetNode("out.imp")->dirty());
-}
-
-TEST_F(GraphTest, ImplicitOutputOnlyParse) {
- ASSERT_NO_FATAL_FAILURE(AssertParse(&state_,
-"build | out.imp: cat in\n"));
-
- Edge* edge = GetNode("out.imp")->in_edge();
- EXPECT_EQ(1, edge->outputs_.size());
- EXPECT_EQ("out.imp", edge->outputs_[0]->path());
- EXPECT_EQ(1, edge->implicit_outs_);
- EXPECT_EQ(edge, GetNode("out.imp")->in_edge());
-}
-
-TEST_F(GraphTest, ImplicitOutputOnlyMissing) {
- ASSERT_NO_FATAL_FAILURE(AssertParse(&state_,
-"build | out.imp: cat in\n"));
- fs_.Create("in", "");
-
- string err;
- EXPECT_TRUE(scan_.RecomputeDirty(GetNode("out.imp"), NULL, &err));
- ASSERT_EQ("", err);
-
- EXPECT_TRUE(GetNode("out.imp")->dirty());
-}
-
-TEST_F(GraphTest, ImplicitOutputOnlyOutOfDate) {
- ASSERT_NO_FATAL_FAILURE(AssertParse(&state_,
-"build | out.imp: cat in\n"));
- fs_.Create("out.imp", "");
- fs_.Tick();
- fs_.Create("in", "");
-
- string err;
- EXPECT_TRUE(scan_.RecomputeDirty(GetNode("out.imp"), NULL, &err));
- ASSERT_EQ("", err);
-
- EXPECT_TRUE(GetNode("out.imp")->dirty());
-}
-
-TEST_F(GraphTest, PathWithCurrentDirectory) {
- ASSERT_NO_FATAL_FAILURE(AssertParse(&state_,
-"rule catdep\n"
-" depfile = $out.d\n"
-" command = cat $in > $out\n"
-"build ./out.o: catdep ./foo.cc\n"));
- fs_.Create("foo.cc", "");
- fs_.Create("out.o.d", "out.o: foo.cc\n");
- fs_.Create("out.o", "");
-
- string err;
- EXPECT_TRUE(scan_.RecomputeDirty(GetNode("out.o"), NULL, &err));
- ASSERT_EQ("", err);
-
- EXPECT_FALSE(GetNode("out.o")->dirty());
-}
-
-TEST_F(GraphTest, RootNodes) {
- ASSERT_NO_FATAL_FAILURE(AssertParse(&state_,
-"build out1: cat in1\n"
-"build mid1: cat in1\n"
-"build out2: cat mid1\n"
-"build out3 out4: cat mid1\n"));
-
- string err;
- vector<Node*> root_nodes = state_.RootNodes(&err);
- EXPECT_EQ(4u, root_nodes.size());
- for (size_t i = 0; i < root_nodes.size(); ++i) {
- string name = root_nodes[i]->path();
- EXPECT_EQ("out", name.substr(0, 3));
- }
-}
-
-TEST_F(GraphTest, CollectInputs) {
- ASSERT_NO_FATAL_FAILURE(AssertParse(
- &state_,
- "build out$ 1: cat in1 in2 in$ with$ space | implicit || order_only\n"));
-
- std::vector<std::string> inputs;
- Edge* edge = GetNode("out 1")->in_edge();
-
- // Test without shell escaping.
- inputs.clear();
- edge->CollectInputs(false, &inputs);
- EXPECT_EQ(5u, inputs.size());
- EXPECT_EQ("in1", inputs[0]);
- EXPECT_EQ("in2", inputs[1]);
- EXPECT_EQ("in with space", inputs[2]);
- EXPECT_EQ("implicit", inputs[3]);
- EXPECT_EQ("order_only", inputs[4]);
-
- // Test with shell escaping.
- inputs.clear();
- edge->CollectInputs(true, &inputs);
- EXPECT_EQ(5u, inputs.size());
- EXPECT_EQ("in1", inputs[0]);
- EXPECT_EQ("in2", inputs[1]);
-#ifdef _WIN32
- EXPECT_EQ("\"in with space\"", inputs[2]);
-#else
- EXPECT_EQ("'in with space'", inputs[2]);
-#endif
- EXPECT_EQ("implicit", inputs[3]);
- EXPECT_EQ("order_only", inputs[4]);
-}
-
-TEST_F(GraphTest, VarInOutPathEscaping) {
- ASSERT_NO_FATAL_FAILURE(AssertParse(&state_,
-"build a$ b: cat no'space with$ space$$ no\"space2\n"));
-
- Edge* edge = GetNode("a b")->in_edge();
-#ifdef _WIN32
- EXPECT_EQ("cat no'space \"with space$\" \"no\\\"space2\" > \"a b\"",
- edge->EvaluateCommand());
-#else
- EXPECT_EQ("cat 'no'\\''space' 'with space$' 'no\"space2' > 'a b'",
- edge->EvaluateCommand());
-#endif
-}
-
-// Regression test for https://github.com/ninja-build/ninja/issues/380
-TEST_F(GraphTest, DepfileWithCanonicalizablePath) {
- ASSERT_NO_FATAL_FAILURE(AssertParse(&state_,
-"rule catdep\n"
-" depfile = $out.d\n"
-" command = cat $in > $out\n"
-"build ./out.o: catdep ./foo.cc\n"));
- fs_.Create("foo.cc", "");
- fs_.Create("out.o.d", "out.o: bar/../foo.cc\n");
- fs_.Create("out.o", "");
-
- string err;
- EXPECT_TRUE(scan_.RecomputeDirty(GetNode("out.o"), NULL, &err));
- ASSERT_EQ("", err);
-
- EXPECT_FALSE(GetNode("out.o")->dirty());
-}
-
-// Regression test for https://github.com/ninja-build/ninja/issues/404
-TEST_F(GraphTest, DepfileRemoved) {
- ASSERT_NO_FATAL_FAILURE(AssertParse(&state_,
-"rule catdep\n"
-" depfile = $out.d\n"
-" command = cat $in > $out\n"
-"build ./out.o: catdep ./foo.cc\n"));
- fs_.Create("foo.h", "");
- fs_.Create("foo.cc", "");
- fs_.Tick();
- fs_.Create("out.o.d", "out.o: foo.h\n");
- fs_.Create("out.o", "");
-
- string err;
- EXPECT_TRUE(scan_.RecomputeDirty(GetNode("out.o"), NULL, &err));
- ASSERT_EQ("", err);
- EXPECT_FALSE(GetNode("out.o")->dirty());
-
- fs_.RemoveFile("out.o.d");
-
- // Note that State::Reset() does not remove the recorded deps from the edge
- // so a new dependency scan will ingore the depfile being removed.
- state_.Reset();
- EXPECT_TRUE(scan_.RecomputeDirty(GetNode("out.o"), NULL, &err));
- ASSERT_EQ("", err);
- EXPECT_FALSE(GetNode("out.o")->dirty());
-
- // Set the edge's |deps_are_invalid_| flag to ensure the next dependency
- // scan will try to reload the depfile.
- state_.Reset();
- GetNode("out.o")->in_edge()->deps_loaded_ = false;
- EXPECT_TRUE(scan_.RecomputeDirty(GetNode("out.o"), NULL, &err));
- ASSERT_EQ("", err);
- EXPECT_TRUE(GetNode("out.o")->dirty());
-}
-
-// Regression test for https://fxbug.dev/135792
-TEST_F(GraphTest, DepfileOutputChanged) {
- ASSERT_NO_FATAL_FAILURE(AssertParse(&state_,
- "rule catdep\n"
- " depfile = $out.d\n"
- " command = echo OUT > $out\n"
- "build ./out: catdep\n"));
- // Create three files as if 'out' had been built by a command that generated
- // a depfile pointing to blobs/1, all three files have the same timestamp
- // so the corresponding Node should not be dirty.
- fs_.Create("out.d", "out: blobs/1\n");
- fs_.Create("out", "");
- fs_.Create("blobs/1", "1");
-
- Node* out_node = GetNode("out");
- Edge* out_edge = out_node->in_edge();
- EXPECT_TRUE(out_edge->inputs_.empty());
-
- // Perform a dependency scan, then verify that the node is not dirty, and
- // that blobs/1 was injected into the edge's inputs.
- string err;
- EXPECT_TRUE(scan_.RecomputeDirty(GetNode("out"), NULL, &err));
- ASSERT_EQ("", err);
- EXPECT_FALSE(out_node->dirty());
- ASSERT_EQ(1u, out_edge->inputs_.size());
- EXPECT_EQ(out_edge->inputs_[0]->path(), "blobs/1");
-
- // Simulate a command that builds out while generating a depfile
- // pointing to a different file. All three files have the same timestamp.
- fs_.Tick();
- fs_.Create("blobs/2", "2");
- fs_.WriteFile("out.d", "out: blobs/2");
- fs_.WriteFile("out", "");
-
- state_.Reset();
- out_edge->deps_loaded_ = false;
-
- GetNode("out")->in_edge()->deps_loaded_ = false;
- EXPECT_TRUE(scan_.RecomputeDirty(GetNode("out"), NULL, &err));
- ASSERT_EQ("", err);
- EXPECT_FALSE(out_node->dirty());
-
- // Verify that blobs/1 was removed from the list of inputs.
- EXPECT_EQ(1u, out_edge->inputs_.size());
- EXPECT_EQ(out_edge->inputs_[0]->path(), "blobs/2");
-}
-
-// Check that rule-level variables are in scope for eval.
-TEST_F(GraphTest, RuleVariablesInScope) {
- ASSERT_NO_FATAL_FAILURE(AssertParse(&state_,
-"rule r\n"
-" depfile = x\n"
-" command = depfile is $depfile\n"
-"build out: r in\n"));
- Edge* edge = GetNode("out")->in_edge();
- EXPECT_EQ("depfile is x", edge->EvaluateCommand());
-}
-
-// Check that build statements can override rule builtins like depfile.
-TEST_F(GraphTest, DepfileOverride) {
- ASSERT_NO_FATAL_FAILURE(AssertParse(&state_,
-"rule r\n"
-" depfile = x\n"
-" command = unused\n"
-"build out: r in\n"
-" depfile = y\n"));
- Edge* edge = GetNode("out")->in_edge();
- EXPECT_EQ("y", edge->GetBinding("depfile"));
-}
-
-// Check that overridden values show up in expansion of rule-level bindings.
-TEST_F(GraphTest, DepfileOverrideParent) {
- ASSERT_NO_FATAL_FAILURE(AssertParse(&state_,
-"rule r\n"
-" depfile = x\n"
-" command = depfile is $depfile\n"
-"build out: r in\n"
-" depfile = y\n"));
- Edge* edge = GetNode("out")->in_edge();
- EXPECT_EQ("depfile is y", edge->GetBinding("command"));
-}
-
-// Verify that building a nested phony rule prints "no work to do"
-TEST_F(GraphTest, NestedPhonyPrintsDone) {
- AssertParse(&state_,
-"build n1: phony \n"
-"build n2: phony n1\n"
- );
- string err;
- EXPECT_TRUE(scan_.RecomputeDirty(GetNode("n2"), NULL, &err));
- ASSERT_EQ("", err);
-
- Plan plan_;
- EXPECT_TRUE(plan_.AddTarget(GetNode("n2"), &err));
- ASSERT_EQ("", err);
-
- EXPECT_EQ(0, plan_.command_edge_count());
- ASSERT_FALSE(plan_.more_to_do());
-}
-
-TEST_F(GraphTest, PhonySelfReferenceError) {
- ManifestParserOptions parser_opts;
- parser_opts.phony_cycle_action_ = kPhonyCycleActionError;
- AssertParse(&state_,
-"build a: phony a\n",
- parser_opts);
-
- string err;
- EXPECT_FALSE(scan_.RecomputeDirty(GetNode("a"), NULL, &err));
- ASSERT_EQ("dependency cycle: a -> a [-w phonycycle=err]", err);
-}
-
-TEST_F(GraphTest, DependencyCycle) {
- AssertParse(&state_,
-"build out: cat mid\n"
-"build mid: cat in\n"
-"build in: cat pre\n"
-"build pre: cat out\n");
-
- string err;
- EXPECT_FALSE(scan_.RecomputeDirty(GetNode("out"), NULL, &err));
- ASSERT_EQ("dependency cycle: out -> mid -> in -> pre -> out", err);
-}
-
-TEST_F(GraphTest, CycleInEdgesButNotInNodes1) {
- string err;
- AssertParse(&state_,
-"build a b: cat a\n");
- EXPECT_FALSE(scan_.RecomputeDirty(GetNode("b"), NULL, &err));
- ASSERT_EQ("dependency cycle: a -> a", err);
-}
-
-TEST_F(GraphTest, CycleInEdgesButNotInNodes2) {
- string err;
- ASSERT_NO_FATAL_FAILURE(AssertParse(&state_,
-"build b a: cat a\n"));
- EXPECT_FALSE(scan_.RecomputeDirty(GetNode("b"), NULL, &err));
- ASSERT_EQ("dependency cycle: a -> a", err);
-}
-
-TEST_F(GraphTest, CycleInEdgesButNotInNodes3) {
- string err;
- ASSERT_NO_FATAL_FAILURE(AssertParse(&state_,
-"build a b: cat c\n"
-"build c: cat a\n"));
- EXPECT_FALSE(scan_.RecomputeDirty(GetNode("b"), NULL, &err));
- ASSERT_EQ("dependency cycle: a -> c -> a", err);
-}
-
-TEST_F(GraphTest, CycleInEdgesButNotInNodes4) {
- string err;
- ASSERT_NO_FATAL_FAILURE(AssertParse(&state_,
-"build d: cat c\n"
-"build c: cat b\n"
-"build b: cat a\n"
-"build a e: cat d\n"
-"build f: cat e\n"));
- EXPECT_FALSE(scan_.RecomputeDirty(GetNode("f"), NULL, &err));
- ASSERT_EQ("dependency cycle: a -> d -> c -> b -> a", err);
-}
-
-// Verify that cycles in graphs with multiple outputs are handled correctly
-// in RecomputeDirty() and don't cause deps to be loaded multiple times.
-TEST_F(GraphTest, CycleWithLengthZeroFromDepfile) {
- AssertParse(&state_,
-"rule deprule\n"
-" depfile = dep.d\n"
-" command = unused\n"
-"build a b: deprule\n"
- );
- fs_.Create("dep.d", "a: b\n");
-
- string err;
- EXPECT_FALSE(scan_.RecomputeDirty(GetNode("a"), NULL, &err));
- ASSERT_EQ("dependency cycle: b -> b", err);
-
- // Despite the depfile causing edge to be a cycle (it has outputs a and b,
- // but the depfile also adds b as an input), the deps should have been loaded
- // only once:
- Edge* edge = GetNode("a")->in_edge();
- EXPECT_EQ(1, edge->inputs_.size());
- EXPECT_EQ("b", edge->inputs_[0]->path());
-}
-
-// Like CycleWithLengthZeroFromDepfile but with a higher cycle length.
-TEST_F(GraphTest, CycleWithLengthOneFromDepfile) {
- AssertParse(&state_,
-"rule deprule\n"
-" depfile = dep.d\n"
-" command = unused\n"
-"rule r\n"
-" command = unused\n"
-"build a b: deprule\n"
-"build c: r b\n"
- );
- fs_.Create("dep.d", "a: c\n");
-
- string err;
- EXPECT_FALSE(scan_.RecomputeDirty(GetNode("a"), NULL, &err));
- ASSERT_EQ("dependency cycle: b -> c -> b", err);
-
- // Despite the depfile causing edge to be a cycle (|edge| has outputs a and b,
- // but c's in_edge has b as input but the depfile also adds |edge| as
- // output)), the deps should have been loaded only once:
- Edge* edge = GetNode("a")->in_edge();
- EXPECT_EQ(1, edge->inputs_.size());
- EXPECT_EQ("c", edge->inputs_[0]->path());
-}
-
-// Like CycleWithLengthOneFromDepfile but building a node one hop away from
-// the cycle.
-TEST_F(GraphTest, CycleWithLengthOneFromDepfileOneHopAway) {
- AssertParse(&state_,
-"rule deprule\n"
-" depfile = dep.d\n"
-" command = unused\n"
-"rule r\n"
-" command = unused\n"
-"build a b: deprule\n"
-"build c: r b\n"
-"build d: r a\n"
- );
- fs_.Create("dep.d", "a: c\n");
-
- string err;
- EXPECT_FALSE(scan_.RecomputeDirty(GetNode("d"), NULL, &err));
- ASSERT_EQ("dependency cycle: b -> c -> b", err);
-
- // Despite the depfile causing edge to be a cycle (|edge| has outputs a and b,
- // but c's in_edge has b as input but the depfile also adds |edge| as
- // output)), the deps should have been loaded only once:
- Edge* edge = GetNode("a")->in_edge();
- EXPECT_EQ(1, edge->inputs_.size());
- EXPECT_EQ("c", edge->inputs_[0]->path());
-}
-
-#ifdef _WIN32
-TEST_F(GraphTest, Decanonicalize) {
- ASSERT_NO_FATAL_FAILURE(AssertParse(&state_,
-"build out\\out1: cat src\\in1\n"
-"build out\\out2/out3\\out4: cat mid1\n"
-"build out3 out4\\foo: cat mid1\n"));
-
- string err;
- vector<Node*> root_nodes = state_.RootNodes(&err);
- EXPECT_EQ(4u, root_nodes.size());
- EXPECT_EQ(root_nodes[0]->path(), "out/out1");
- EXPECT_EQ(root_nodes[1]->path(), "out/out2/out3/out4");
- EXPECT_EQ(root_nodes[2]->path(), "out3");
- EXPECT_EQ(root_nodes[3]->path(), "out4/foo");
- EXPECT_EQ(root_nodes[0]->PathDecanonicalized(), "out\\out1");
- EXPECT_EQ(root_nodes[1]->PathDecanonicalized(), "out\\out2/out3\\out4");
- EXPECT_EQ(root_nodes[2]->PathDecanonicalized(), "out3");
- EXPECT_EQ(root_nodes[3]->PathDecanonicalized(), "out4\\foo");
-}
-#endif
-
-TEST_F(GraphTest, DyndepLoadTrivial) {
- AssertParse(&state_,
-"rule r\n"
-" command = unused\n"
-"build out: r in || dd\n"
-" dyndep = dd\n"
- );
- fs_.Create("dd",
-"ninja_dyndep_version = 1\n"
-"build out: dyndep\n"
- );
-
- string err;
- ASSERT_TRUE(GetNode("dd")->dyndep_pending());
- EXPECT_TRUE(scan_.LoadDyndeps(GetNode("dd"), &err));
- EXPECT_EQ("", err);
- EXPECT_FALSE(GetNode("dd")->dyndep_pending());
-
- Edge* edge = GetNode("out")->in_edge();
- ASSERT_EQ(1u, edge->outputs_.size());
- EXPECT_EQ("out", edge->outputs_[0]->path());
- ASSERT_EQ(2u, edge->inputs_.size());
- EXPECT_EQ("in", edge->inputs_[0]->path());
- EXPECT_EQ("dd", edge->inputs_[1]->path());
- EXPECT_EQ(0u, edge->implicit_deps_);
- EXPECT_EQ(1u, edge->order_only_deps_);
- EXPECT_FALSE(edge->GetBindingBool("restat"));
-}
-
-TEST_F(GraphTest, DyndepLoadImplicit) {
- AssertParse(&state_,
-"rule r\n"
-" command = unused\n"
-"build out1: r in || dd\n"
-" dyndep = dd\n"
-"build out2: r in\n"
- );
- fs_.Create("dd",
-"ninja_dyndep_version = 1\n"
-"build out1: dyndep | out2\n"
- );
-
- string err;
- ASSERT_TRUE(GetNode("dd")->dyndep_pending());
- EXPECT_TRUE(scan_.LoadDyndeps(GetNode("dd"), &err));
- EXPECT_EQ("", err);
- EXPECT_FALSE(GetNode("dd")->dyndep_pending());
-
- Edge* edge = GetNode("out1")->in_edge();
- ASSERT_EQ(1u, edge->outputs_.size());
- EXPECT_EQ("out1", edge->outputs_[0]->path());
- ASSERT_EQ(3u, edge->inputs_.size());
- EXPECT_EQ("in", edge->inputs_[0]->path());
- EXPECT_EQ("out2", edge->inputs_[1]->path());
- EXPECT_EQ("dd", edge->inputs_[2]->path());
- EXPECT_EQ(1u, edge->implicit_deps_);
- EXPECT_EQ(1u, edge->order_only_deps_);
- EXPECT_FALSE(edge->GetBindingBool("restat"));
-}
-
-TEST_F(GraphTest, DyndepLoadMissingFile) {
- AssertParse(&state_,
-"rule r\n"
-" command = unused\n"
-"build out: r in || dd\n"
-" dyndep = dd\n"
- );
-
- string err;
- ASSERT_TRUE(GetNode("dd")->dyndep_pending());
- EXPECT_FALSE(scan_.LoadDyndeps(GetNode("dd"), &err));
- EXPECT_EQ("loading 'dd': No such file or directory", err);
-}
-
-TEST_F(GraphTest, DyndepLoadMissingEntry) {
- AssertParse(&state_,
-"rule r\n"
-" command = unused\n"
-"build out: r in || dd\n"
-" dyndep = dd\n"
- );
- fs_.Create("dd",
-"ninja_dyndep_version = 1\n"
- );
-
- string err;
- ASSERT_TRUE(GetNode("dd")->dyndep_pending());
- EXPECT_FALSE(scan_.LoadDyndeps(GetNode("dd"), &err));
- EXPECT_EQ("'out' not mentioned in its dyndep file 'dd'", err);
-}
-
-TEST_F(GraphTest, DyndepLoadExtraEntry) {
- AssertParse(&state_,
-"rule r\n"
-" command = unused\n"
-"build out: r in || dd\n"
-" dyndep = dd\n"
-"build out2: r in || dd\n"
- );
- fs_.Create("dd",
-"ninja_dyndep_version = 1\n"
-"build out: dyndep\n"
-"build out2: dyndep\n"
- );
-
- string err;
- ASSERT_TRUE(GetNode("dd")->dyndep_pending());
- EXPECT_FALSE(scan_.LoadDyndeps(GetNode("dd"), &err));
- EXPECT_EQ("dyndep file 'dd' mentions output 'out2' whose build statement "
- "does not have a dyndep binding for the file", err);
-}
-
-TEST_F(GraphTest, DyndepLoadOutputWithMultipleRules1) {
- AssertParse(&state_,
-"rule r\n"
-" command = unused\n"
-"build out1 | out-twice.imp: r in1\n"
-"build out2: r in2 || dd\n"
-" dyndep = dd\n"
- );
- fs_.Create("dd",
-"ninja_dyndep_version = 1\n"
-"build out2 | out-twice.imp: dyndep\n"
- );
-
- string err;
- ASSERT_TRUE(GetNode("dd")->dyndep_pending());
- EXPECT_FALSE(scan_.LoadDyndeps(GetNode("dd"), &err));
- EXPECT_EQ("multiple rules generate out-twice.imp", err);
-}
-
-TEST_F(GraphTest, DyndepLoadOutputWithMultipleRules2) {
- AssertParse(&state_,
-"rule r\n"
-" command = unused\n"
-"build out1: r in1 || dd1\n"
-" dyndep = dd1\n"
-"build out2: r in2 || dd2\n"
-" dyndep = dd2\n"
- );
- fs_.Create("dd1",
-"ninja_dyndep_version = 1\n"
-"build out1 | out-twice.imp: dyndep\n"
- );
- fs_.Create("dd2",
-"ninja_dyndep_version = 1\n"
-"build out2 | out-twice.imp: dyndep\n"
- );
-
- string err;
- ASSERT_TRUE(GetNode("dd1")->dyndep_pending());
- EXPECT_TRUE(scan_.LoadDyndeps(GetNode("dd1"), &err));
- EXPECT_EQ("", err);
- ASSERT_TRUE(GetNode("dd2")->dyndep_pending());
- EXPECT_FALSE(scan_.LoadDyndeps(GetNode("dd2"), &err));
- EXPECT_EQ("multiple rules generate out-twice.imp", err);
-}
-
-TEST_F(GraphTest, DyndepLoadMultiple) {
- AssertParse(&state_,
-"rule r\n"
-" command = unused\n"
-"build out1: r in1 || dd\n"
-" dyndep = dd\n"
-"build out2: r in2 || dd\n"
-" dyndep = dd\n"
-"build outNot: r in3 || dd\n"
- );
- fs_.Create("dd",
-"ninja_dyndep_version = 1\n"
-"build out1 | out1imp: dyndep | in1imp\n"
-"build out2: dyndep | in2imp\n"
-" restat = 1\n"
- );
-
- string err;
- ASSERT_TRUE(GetNode("dd")->dyndep_pending());
- EXPECT_TRUE(scan_.LoadDyndeps(GetNode("dd"), &err));
- EXPECT_EQ("", err);
- EXPECT_FALSE(GetNode("dd")->dyndep_pending());
-
- Edge* edge1 = GetNode("out1")->in_edge();
- ASSERT_EQ(2u, edge1->outputs_.size());
- EXPECT_EQ("out1", edge1->outputs_[0]->path());
- EXPECT_EQ("out1imp", edge1->outputs_[1]->path());
- EXPECT_EQ(1u, edge1->implicit_outs_);
- ASSERT_EQ(3u, edge1->inputs_.size());
- EXPECT_EQ("in1", edge1->inputs_[0]->path());
- EXPECT_EQ("in1imp", edge1->inputs_[1]->path());
- EXPECT_EQ("dd", edge1->inputs_[2]->path());
- EXPECT_EQ(1u, edge1->implicit_deps_);
- EXPECT_EQ(1u, edge1->order_only_deps_);
- EXPECT_FALSE(edge1->GetBindingBool("restat"));
- EXPECT_EQ(edge1, GetNode("out1imp")->in_edge());
- Node* in1imp = GetNode("in1imp");
- ASSERT_EQ(1u, in1imp->out_edges().size());
- EXPECT_EQ(edge1, in1imp->out_edges()[0]);
-
- Edge* edge2 = GetNode("out2")->in_edge();
- ASSERT_EQ(1u, edge2->outputs_.size());
- EXPECT_EQ("out2", edge2->outputs_[0]->path());
- EXPECT_EQ(0u, edge2->implicit_outs_);
- ASSERT_EQ(3u, edge2->inputs_.size());
- EXPECT_EQ("in2", edge2->inputs_[0]->path());
- EXPECT_EQ("in2imp", edge2->inputs_[1]->path());
- EXPECT_EQ("dd", edge2->inputs_[2]->path());
- EXPECT_EQ(1u, edge2->implicit_deps_);
- EXPECT_EQ(1u, edge2->order_only_deps_);
- EXPECT_TRUE(edge2->GetBindingBool("restat"));
- Node* in2imp = GetNode("in2imp");
- ASSERT_EQ(1u, in2imp->out_edges().size());
- EXPECT_EQ(edge2, in2imp->out_edges()[0]);
-}
-
-TEST_F(GraphTest, DyndepFileMissing) {
- AssertParse(&state_,
-"rule r\n"
-" command = unused\n"
-"build out: r || dd\n"
-" dyndep = dd\n"
- );
-
- string err;
- EXPECT_FALSE(scan_.RecomputeDirty(GetNode("out"), NULL, &err));
- ASSERT_EQ("loading 'dd': No such file or directory", err);
-}
-
-TEST_F(GraphTest, DyndepFileError) {
- AssertParse(&state_,
-"rule r\n"
-" command = unused\n"
-"build out: r || dd\n"
-" dyndep = dd\n"
- );
- fs_.Create("dd",
-"ninja_dyndep_version = 1\n"
- );
-
- string err;
- EXPECT_FALSE(scan_.RecomputeDirty(GetNode("out"), NULL, &err));
- ASSERT_EQ("'out' not mentioned in its dyndep file 'dd'", err);
-}
-
-TEST_F(GraphTest, DyndepImplicitInputNewer) {
- AssertParse(&state_,
-"rule r\n"
-" command = unused\n"
-"build out: r || dd\n"
-" dyndep = dd\n"
- );
- fs_.Create("dd",
-"ninja_dyndep_version = 1\n"
-"build out: dyndep | in\n"
- );
- fs_.Create("out", "");
- fs_.Tick();
- fs_.Create("in", "");
-
- string err;
- EXPECT_TRUE(scan_.RecomputeDirty(GetNode("out"), NULL, &err));
- ASSERT_EQ("", err);
-
- EXPECT_FALSE(GetNode("in")->dirty());
- EXPECT_FALSE(GetNode("dd")->dirty());
-
- // "out" is dirty due to dyndep-specified implicit input
- EXPECT_TRUE(GetNode("out")->dirty());
-}
-
-TEST_F(GraphTest, DyndepFileReady) {
- AssertParse(&state_,
-"rule r\n"
-" command = unused\n"
-"build dd: r dd-in\n"
-"build out: r || dd\n"
-" dyndep = dd\n"
- );
- fs_.Create("dd-in", "");
- fs_.Create("dd",
-"ninja_dyndep_version = 1\n"
-"build out: dyndep | in\n"
- );
- fs_.Create("out", "");
- fs_.Tick();
- fs_.Create("in", "");
-
- string err;
- EXPECT_TRUE(scan_.RecomputeDirty(GetNode("out"), NULL, &err));
- ASSERT_EQ("", err);
-
- EXPECT_FALSE(GetNode("in")->dirty());
- EXPECT_FALSE(GetNode("dd")->dirty());
- EXPECT_TRUE(GetNode("dd")->in_edge()->outputs_ready());
-
- // "out" is dirty due to dyndep-specified implicit input
- EXPECT_TRUE(GetNode("out")->dirty());
-}
-
-TEST_F(GraphTest, DyndepFileNotClean) {
- AssertParse(&state_,
-"rule r\n"
-" command = unused\n"
-"build dd: r dd-in\n"
-"build out: r || dd\n"
-" dyndep = dd\n"
- );
- fs_.Create("dd", "this-should-not-be-loaded");
- fs_.Tick();
- fs_.Create("dd-in", "");
- fs_.Create("out", "");
-
- string err;
- EXPECT_TRUE(scan_.RecomputeDirty(GetNode("out"), NULL, &err));
- ASSERT_EQ("", err);
-
- EXPECT_TRUE(GetNode("dd")->dirty());
- EXPECT_FALSE(GetNode("dd")->in_edge()->outputs_ready());
-
- // "out" is clean but not ready since "dd" is not ready
- EXPECT_FALSE(GetNode("out")->dirty());
- EXPECT_FALSE(GetNode("out")->in_edge()->outputs_ready());
-}
-
-TEST_F(GraphTest, DyndepFileNotReady) {
- AssertParse(&state_,
-"rule r\n"
-" command = unused\n"
-"build tmp: r\n"
-"build dd: r dd-in || tmp\n"
-"build out: r || dd\n"
-" dyndep = dd\n"
- );
- fs_.Create("dd", "this-should-not-be-loaded");
- fs_.Create("dd-in", "");
- fs_.Tick();
- fs_.Create("out", "");
-
- string err;
- EXPECT_TRUE(scan_.RecomputeDirty(GetNode("out"), NULL, &err));
- ASSERT_EQ("", err);
-
- EXPECT_FALSE(GetNode("dd")->dirty());
- EXPECT_FALSE(GetNode("dd")->in_edge()->outputs_ready());
- EXPECT_FALSE(GetNode("out")->dirty());
- EXPECT_FALSE(GetNode("out")->in_edge()->outputs_ready());
-}
-
-TEST_F(GraphTest, DyndepFileSecondNotReady) {
- AssertParse(&state_,
-"rule r\n"
-" command = unused\n"
-"build dd1: r dd1-in\n"
-"build dd2-in: r || dd1\n"
-" dyndep = dd1\n"
-"build dd2: r dd2-in\n"
-"build out: r || dd2\n"
-" dyndep = dd2\n"
- );
- fs_.Create("dd1", "");
- fs_.Create("dd2", "");
- fs_.Create("dd2-in", "");
- fs_.Tick();
- fs_.Create("dd1-in", "");
- fs_.Create("out", "");
-
- string err;
- EXPECT_TRUE(scan_.RecomputeDirty(GetNode("out"), NULL, &err));
- ASSERT_EQ("", err);
-
- EXPECT_TRUE(GetNode("dd1")->dirty());
- EXPECT_FALSE(GetNode("dd1")->in_edge()->outputs_ready());
- EXPECT_FALSE(GetNode("dd2")->dirty());
- EXPECT_FALSE(GetNode("dd2")->in_edge()->outputs_ready());
- EXPECT_FALSE(GetNode("out")->dirty());
- EXPECT_FALSE(GetNode("out")->in_edge()->outputs_ready());
-}
-
-TEST_F(GraphTest, DyndepFileCircular) {
- AssertParse(&state_,
-"rule r\n"
-" command = unused\n"
-"build out: r in || dd\n"
-" depfile = out.d\n"
-" dyndep = dd\n"
-"build in: r circ\n"
- );
- fs_.Create("out.d", "out: inimp\n");
- fs_.Create("dd",
-"ninja_dyndep_version = 1\n"
-"build out | circ: dyndep\n"
- );
- fs_.Create("out", "");
-
- Edge* edge = GetNode("out")->in_edge();
- string err;
- EXPECT_FALSE(scan_.RecomputeDirty(GetNode("out"), NULL, &err));
- EXPECT_EQ("dependency cycle: circ -> in -> circ", err);
-
- // Verify that "out.d" was loaded exactly once despite
- // circular reference discovered from dyndep file.
- ASSERT_EQ(3u, edge->inputs_.size());
- EXPECT_EQ("in", edge->inputs_[0]->path());
- EXPECT_EQ("inimp", edge->inputs_[1]->path());
- EXPECT_EQ("dd", edge->inputs_[2]->path());
- EXPECT_EQ(1u, edge->implicit_deps_);
- EXPECT_EQ(1u, edge->order_only_deps_);
-}
-
-TEST_F(GraphTest, DyndepLoadIncremental) {
- AssertParse(&state_,
- "rule r\n"
- " command = unused\n"
- "build out: r in || dd\n"
- " dyndep = dd\n");
-
- // First version of the dyndep file adds one implicit output, and
- // one implicit input.
- fs_.Create("dd",
- "ninja_dyndep_version = 1\n"
- "build out | implicit_out: dyndep | implicit1\n");
-
- string err;
- ASSERT_TRUE(GetNode("dd")->dyndep_pending());
- EXPECT_TRUE(scan_.RecomputeDirty(GetNode("out"), NULL, &err));
-
- EXPECT_EQ("", err);
- Node* out_node = GetNode("out");
- Edge* edge = out_node->in_edge();
-
- // Check that implicit_out was inserted as a dynamic implicit output.
- ASSERT_EQ(2u, edge->outputs_.size());
- EXPECT_EQ(0, edge->static_implicit_outs_);
- EXPECT_EQ(1, edge->implicit_outs_);
- EXPECT_EQ("out", edge->outputs_[0]->path());
- EXPECT_EQ("implicit_out", edge->outputs_[1]->path());
-
- // Check that implicit1 was inserted as a dynamic implicit input,
- // i.e. before order-only deps in the inputs_ array.
- ASSERT_EQ(3u, edge->inputs_.size());
- EXPECT_EQ("in", edge->inputs_[0]->path());
- EXPECT_EQ("implicit1", edge->inputs_[1]->path());
- EXPECT_EQ("dd", edge->inputs_[2]->path());
- EXPECT_EQ(0u, edge->static_implicit_deps_);
- EXPECT_EQ(1u, edge->implicit_deps_);
- EXPECT_EQ(1u, edge->order_only_deps_);
- EXPECT_FALSE(edge->GetBindingBool("restat"));
-
- // Perform a second scan, forcing a reload of the dyndep information.
- // and verify that nothing changed.
- state_.Reset();
- edge->deps_loaded_ = false;
- edge->dyndep_->set_dyndep_pending(true);
- EXPECT_TRUE(scan_.RecomputeDirty(out_node, NULL, &err));
-
- EXPECT_EQ("", err);
- ASSERT_EQ(2u, edge->outputs_.size());
- EXPECT_EQ(0, edge->static_implicit_outs_);
- EXPECT_EQ(1, edge->implicit_outs_);
- EXPECT_EQ("out", edge->outputs_[0]->path());
- EXPECT_EQ("implicit_out", edge->outputs_[1]->path());
-
- ASSERT_EQ(3u, edge->inputs_.size());
- EXPECT_EQ("in", edge->inputs_[0]->path());
- EXPECT_EQ("implicit1", edge->inputs_[1]->path());
- EXPECT_EQ("dd", edge->inputs_[2]->path());
- EXPECT_EQ(0u, edge->static_implicit_deps_);
- EXPECT_EQ(1u, edge->implicit_deps_);
- EXPECT_EQ(1u, edge->order_only_deps_);
- EXPECT_FALSE(edge->GetBindingBool("restat"));
-
- // Now modify the dyndep file content to add a new implicit output,
- // and two new implicit inputs. Note that some of the new files are listed
- // _before_ the current ones.
- fs_.Tick();
- fs_.WriteFile("dd",
- "ninja_dyndep_version = 1\n"
- "build out | implicit_out2 implicit_out: dyndep | implicit2 "
- "implicit1 implicit3\n");
-
- state_.Reset();
- edge->deps_loaded_ = false;
- edge->dyndep_->set_dyndep_pending(true);
- EXPECT_TRUE(scan_.RecomputeDirty(out_node, NULL, &err));
-
- EXPECT_EQ("", err);
- // Verify that the new implicit output was inserted _after_ the first one
- // even though it appeared before it in the dyndep file.
- ASSERT_EQ(3u, edge->outputs_.size());
- EXPECT_EQ(0, edge->static_implicit_outs_);
- EXPECT_EQ(2, edge->implicit_outs_);
- EXPECT_EQ("out", edge->outputs_[0]->path());
- EXPECT_EQ("implicit_out", edge->outputs_[1]->path());
- EXPECT_EQ("implicit_out2", edge->outputs_[2]->path());
-
- // Verify that the new implicits input were inserted _after_ the first one
- // even though some appeared before it in the dyndep file.
- ASSERT_EQ(5u, edge->inputs_.size());
- EXPECT_EQ("in", edge->inputs_[0]->path());
- EXPECT_EQ("implicit1", edge->inputs_[1]->path());
- EXPECT_EQ("implicit2", edge->inputs_[2]->path());
- EXPECT_EQ("implicit3", edge->inputs_[3]->path());
- EXPECT_EQ("dd", edge->inputs_[4]->path());
- EXPECT_EQ(0u, edge->static_implicit_deps_);
- EXPECT_EQ(3u, edge->implicit_deps_);
- EXPECT_EQ(1u, edge->order_only_deps_);
- EXPECT_FALSE(edge->GetBindingBool("restat"));
-
- // Modify the dyndep file again to remove all implicit outputs, and the
- // two implicit inputs.
- fs_.Tick();
- fs_.WriteFile("dd",
- "ninja_dyndep_version = 1\n"
- "build out: dyndep | implicit2\n");
-
- state_.Reset();
- edge->deps_loaded_ = false;
- edge->dyndep_->set_dyndep_pending(true);
- EXPECT_TRUE(scan_.RecomputeDirty(out_node, NULL, &err));
-
- EXPECT_EQ("", err);
- // Verify that all dynamic implicit outputs were removed.
- ASSERT_EQ(1u, edge->outputs_.size());
- EXPECT_EQ(0, edge->static_implicit_outs_);
- EXPECT_EQ(0, edge->implicit_outs_);
- EXPECT_EQ("out", edge->outputs_[0]->path());
-
- // Verify that only one dynamic implicit input remains.
- ASSERT_EQ(3u, edge->inputs_.size());
- EXPECT_EQ("in", edge->inputs_[0]->path());
- EXPECT_EQ("implicit2", edge->inputs_[1]->path());
- EXPECT_EQ("dd", edge->inputs_[2]->path());
- EXPECT_EQ(0u, edge->static_implicit_deps_);
- EXPECT_EQ(1u, edge->implicit_deps_);
- EXPECT_EQ(1u, edge->order_only_deps_);
- EXPECT_FALSE(edge->GetBindingBool("restat"));
-}
-
-TEST_F(GraphTest, Validation) {
- ASSERT_NO_FATAL_FAILURE(AssertParse(&state_,
-"build out: cat in |@ validate\n"
-"build validate: cat in\n"));
-
- fs_.Create("in", "");
- string err;
- std::vector<Node*> validation_nodes;
- EXPECT_TRUE(scan_.RecomputeDirty(GetNode("out"), &validation_nodes, &err));
- ASSERT_EQ("", err);
-
- ASSERT_EQ(validation_nodes.size(), 1);
- EXPECT_EQ(validation_nodes[0]->path(), "validate");
-
- EXPECT_TRUE(GetNode("out")->dirty());
- EXPECT_TRUE(GetNode("validate")->dirty());
-}
-
-// Check that phony's dependencies' mtimes are propagated.
-TEST_F(GraphTest, PhonyDepsMtimes) {
- string err;
- ASSERT_NO_FATAL_FAILURE(AssertParse(&state_,
-"rule touch\n"
-" command = touch $out\n"
-"build in_ph: phony in1\n"
-"build out1: touch in_ph\n"
-));
- fs_.Create("in1", "");
- fs_.Create("out1", "");
- Node* out1 = GetNode("out1");
- Node* in1 = GetNode("in1");
-
- EXPECT_TRUE(scan_.RecomputeDirty(out1, NULL, &err));
- EXPECT_TRUE(!out1->dirty());
-
- // Get the mtime of out1
- ASSERT_TRUE(in1->Stat(&fs_, &err));
- ASSERT_TRUE(out1->Stat(&fs_, &err));
- TimeStamp out1Mtime1 = out1->mtime();
- TimeStamp in1Mtime1 = in1->mtime();
-
- // Touch in1. This should cause out1 to be dirty
- state_.Reset();
- fs_.Tick();
- fs_.Create("in1", "");
-
- ASSERT_TRUE(in1->Stat(&fs_, &err));
- EXPECT_GT(in1->mtime(), in1Mtime1);
-
- EXPECT_TRUE(scan_.RecomputeDirty(out1, NULL, &err));
- EXPECT_GT(in1->mtime(), in1Mtime1);
- EXPECT_EQ(out1->mtime(), out1Mtime1);
- EXPECT_TRUE(out1->dirty());
-}
diff --git a/src/graphviz.cc b/src/graphviz.cc
deleted file mode 100644
index 37b7108..0000000
--- a/src/graphviz.cc
+++ /dev/null
@@ -1,90 +0,0 @@
-// Copyright 2011 Google Inc. All Rights Reserved.
-//
-// Licensed under the Apache License, Version 2.0 (the "License");
-// you may not use this file except in compliance with the License.
-// You may obtain a copy of the License at
-//
-// http://www.apache.org/licenses/LICENSE-2.0
-//
-// Unless required by applicable law or agreed to in writing, software
-// distributed under the License is distributed on an "AS IS" BASIS,
-// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-// See the License for the specific language governing permissions and
-// limitations under the License.
-
-#include "graphviz.h"
-
-#include <stdio.h>
-#include <algorithm>
-
-#include "dyndep.h"
-#include "graph.h"
-
-using namespace std;
-
-void GraphViz::AddTarget(Node* node) {
- if (visited_nodes_.find(node) != visited_nodes_.end())
- return;
-
- string pathstr = node->path();
- replace(pathstr.begin(), pathstr.end(), '\\', '/');
- printf("\"%p\" [label=\"%s\"]\n", node, pathstr.c_str());
- visited_nodes_.insert(node);
-
- Edge* edge = node->in_edge();
-
- if (!edge) {
- // Leaf node.
- // Draw as a rect?
- return;
- }
-
- if (visited_edges_.find(edge) != visited_edges_.end())
- return;
- visited_edges_.insert(edge);
-
- if (edge->dyndep_ && edge->dyndep_->dyndep_pending()) {
- std::string err;
- if (!dyndep_loader_.LoadDyndeps(edge->dyndep_, &err)) {
- Warning("%s\n", err.c_str());
- }
- }
-
- if (edge->inputs_.size() == 1 && edge->outputs_.size() == 1) {
- // Can draw simply.
- // Note extra space before label text -- this is cosmetic and feels
- // like a graphviz bug.
- printf("\"%p\" -> \"%p\" [label=\" %s\"]\n",
- edge->inputs_[0], edge->outputs_[0], edge->rule_->name().c_str());
- } else {
- printf("\"%p\" [label=\"%s\", shape=ellipse]\n",
- edge, edge->rule_->name().c_str());
- for (vector<Node*>::iterator out = edge->outputs_.begin();
- out != edge->outputs_.end(); ++out) {
- printf("\"%p\" -> \"%p\"\n", edge, *out);
- }
- for (vector<Node*>::iterator in = edge->inputs_.begin();
- in != edge->inputs_.end(); ++in) {
- const char* order_only = "";
- if (edge->is_order_only(in - edge->inputs_.begin()))
- order_only = " style=dotted";
- printf("\"%p\" -> \"%p\" [arrowhead=none%s]\n", (*in), edge, order_only);
- }
- }
-
- for (vector<Node*>::iterator in = edge->inputs_.begin();
- in != edge->inputs_.end(); ++in) {
- AddTarget(*in);
- }
-}
-
-void GraphViz::Start() {
- printf("digraph ninja {\n");
- printf("rankdir=\"LR\"\n");
- printf("node [fontsize=10, shape=box, height=0.25]\n");
- printf("edge [fontsize=10]\n");
-}
-
-void GraphViz::Finish() {
- printf("}\n");
-}
diff --git a/src/graphviz.h b/src/graphviz.h
deleted file mode 100644
index 3a3282e..0000000
--- a/src/graphviz.h
+++ /dev/null
@@ -1,41 +0,0 @@
-// Copyright 2011 Google Inc. All Rights Reserved.
-//
-// Licensed under the Apache License, Version 2.0 (the "License");
-// you may not use this file except in compliance with the License.
-// You may obtain a copy of the License at
-//
-// http://www.apache.org/licenses/LICENSE-2.0
-//
-// Unless required by applicable law or agreed to in writing, software
-// distributed under the License is distributed on an "AS IS" BASIS,
-// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-// See the License for the specific language governing permissions and
-// limitations under the License.
-
-#ifndef NINJA_GRAPHVIZ_H_
-#define NINJA_GRAPHVIZ_H_
-
-#include <set>
-
-#include "dyndep.h"
-#include "graph.h"
-
-struct DiskInterface;
-struct Node;
-struct Edge;
-struct State;
-
-/// Runs the process of creating GraphViz .dot file output.
-struct GraphViz {
- GraphViz(State* state, DiskInterface* disk_interface)
- : dyndep_loader_(state, disk_interface) {}
- void Start();
- void AddTarget(Node* node);
- void Finish();
-
- DyndepLoader dyndep_loader_;
- std::set<Node*> visited_nodes_;
- EdgeSet visited_edges_;
-};
-
-#endif // NINJA_GRAPHVIZ_H_
diff --git a/src/hash_collision_bench.cc b/src/hash_collision_bench.cc
deleted file mode 100644
index 8f37ed0..0000000
--- a/src/hash_collision_bench.cc
+++ /dev/null
@@ -1,65 +0,0 @@
-// Copyright 2012 Google Inc. All Rights Reserved.
-//
-// Licensed under the Apache License, Version 2.0 (the "License");
-// you may not use this file except in compliance with the License.
-// You may obtain a copy of the License at
-//
-// http://www.apache.org/licenses/LICENSE-2.0
-//
-// Unless required by applicable law or agreed to in writing, software
-// distributed under the License is distributed on an "AS IS" BASIS,
-// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-// See the License for the specific language governing permissions and
-// limitations under the License.
-
-#include "build_log.h"
-
-#include <algorithm>
-
-#include <stdlib.h>
-#include <time.h>
-
-using namespace std;
-
-int random(int low, int high) {
- return int(low + (rand() / double(RAND_MAX)) * (high - low) + 0.5);
-}
-
-void RandomCommand(char** s) {
- int len = random(5, 100);
- *s = new char[len+1];
- for (int i = 0; i < len; ++i)
- (*s)[i] = (char)random(32, 127);
- (*s)[len] = '\0';
-}
-
-int main() {
- const int N = 20 * 1000 * 1000;
-
- // Leak these, else 10% of the runtime is spent destroying strings.
- char** commands = new char*[N];
- pair<uint64_t, int>* hashes = new pair<uint64_t, int>[N];
-
- srand((int)time(NULL));
-
- for (int i = 0; i < N; ++i) {
- RandomCommand(&commands[i]);
- hashes[i] = make_pair(BuildLog::LogEntry::HashCommand(commands[i]), i);
- }
-
- sort(hashes, hashes + N);
-
- int collision_count = 0;
- for (int i = 1; i < N; ++i) {
- if (hashes[i - 1].first == hashes[i].first) {
- if (strcmp(commands[hashes[i - 1].second],
- commands[hashes[i].second]) != 0) {
- printf("collision!\n string 1: '%s'\n string 2: '%s'\n",
- commands[hashes[i - 1].second],
- commands[hashes[i].second]);
- collision_count++;
- }
- }
- }
- printf("\n\n%d collisions after %d runs\n", collision_count, N);
-}
diff --git a/src/hash_map.h b/src/hash_map.h
deleted file mode 100644
index 4353609..0000000
--- a/src/hash_map.h
+++ /dev/null
@@ -1,79 +0,0 @@
-// Copyright 2011 Google Inc. All Rights Reserved.
-//
-// Licensed under the Apache License, Version 2.0 (the "License");
-// you may not use this file except in compliance with the License.
-// You may obtain a copy of the License at
-//
-// http://www.apache.org/licenses/LICENSE-2.0
-//
-// Unless required by applicable law or agreed to in writing, software
-// distributed under the License is distributed on an "AS IS" BASIS,
-// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-// See the License for the specific language governing permissions and
-// limitations under the License.
-
-#ifndef NINJA_MAP_H_
-#define NINJA_MAP_H_
-
-#include <algorithm>
-#include <string.h>
-#include "string_piece.h"
-#include "util.h"
-
-// MurmurHash2, by Austin Appleby
-static inline
-unsigned int MurmurHash2(const void* key, size_t len) {
- static const unsigned int seed = 0xDECAFBAD;
- const unsigned int m = 0x5bd1e995;
- const int r = 24;
- unsigned int h = seed ^ len;
- const unsigned char* data = (const unsigned char*)key;
- while (len >= 4) {
- unsigned int k;
- memcpy(&k, data, sizeof k);
- k *= m;
- k ^= k >> r;
- k *= m;
- h *= m;
- h ^= k;
- data += 4;
- len -= 4;
- }
- switch (len) {
- case 3: h ^= data[2] << 16;
- NINJA_FALLTHROUGH;
- case 2: h ^= data[1] << 8;
- NINJA_FALLTHROUGH;
- case 1: h ^= data[0];
- h *= m;
- };
- h ^= h >> 13;
- h *= m;
- h ^= h >> 15;
- return h;
-}
-
-#include <unordered_map>
-
-namespace std {
-template<>
-struct hash<StringPiece> {
- typedef StringPiece argument_type;
- typedef size_t result_type;
-
- size_t operator()(StringPiece key) const {
- return MurmurHash2(key.str_, key.len_);
- }
-};
-}
-
-/// A template for hash_maps keyed by a StringPiece whose string is
-/// owned externally (typically by the values). Use like:
-/// ExternalStringHash<Foo*>::Type foos; to make foos into a hash
-/// mapping StringPiece => Foo*.
-template<typename V>
-struct ExternalStringHashMap {
- typedef std::unordered_map<StringPiece, V> Type;
-};
-
-#endif // NINJA_MAP_H_
diff --git a/src/includes_normalize-win32.cc b/src/includes_normalize-win32.cc
deleted file mode 100644
index 081e364..0000000
--- a/src/includes_normalize-win32.cc
+++ /dev/null
@@ -1,210 +0,0 @@
-// Copyright 2012 Google Inc. All Rights Reserved.
-//
-// Licensed under the Apache License, Version 2.0 (the "License");
-// you may not use this file except in compliance with the License.
-// You may obtain a copy of the License at
-//
-// http://www.apache.org/licenses/LICENSE-2.0
-//
-// Unless required by applicable law or agreed to in writing, software
-// distributed under the License is distributed on an "AS IS" BASIS,
-// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-// See the License for the specific language governing permissions and
-// limitations under the License.
-
-#include "includes_normalize.h"
-
-#include "string_piece.h"
-#include "string_piece_util.h"
-#include "util.h"
-
-#include <algorithm>
-#include <iterator>
-#include <sstream>
-
-#include <windows.h>
-
-using namespace std;
-
-namespace {
-
-bool InternalGetFullPathName(const StringPiece& file_name, char* buffer,
- size_t buffer_length, string *err) {
- DWORD result_size = GetFullPathNameA(file_name.AsString().c_str(),
- buffer_length, buffer, NULL);
- if (result_size == 0) {
- *err = "GetFullPathNameA(" + file_name.AsString() + "): " +
- GetLastErrorString();
- return false;
- } else if (result_size > buffer_length) {
- *err = "path too long";
- return false;
- }
- return true;
-}
-
-bool IsPathSeparator(char c) {
- return c == '/' || c == '\\';
-}
-
-// Return true if paths a and b are on the same windows drive.
-// Return false if this function cannot check
-// whether or not on the same windows drive.
-bool SameDriveFast(StringPiece a, StringPiece b) {
- if (a.size() < 3 || b.size() < 3) {
- return false;
- }
-
- if (!islatinalpha(a[0]) || !islatinalpha(b[0])) {
- return false;
- }
-
- if (ToLowerASCII(a[0]) != ToLowerASCII(b[0])) {
- return false;
- }
-
- if (a[1] != ':' || b[1] != ':') {
- return false;
- }
-
- return IsPathSeparator(a[2]) && IsPathSeparator(b[2]);
-}
-
-// Return true if paths a and b are on the same Windows drive.
-bool SameDrive(StringPiece a, StringPiece b, string* err) {
- if (SameDriveFast(a, b)) {
- return true;
- }
-
- char a_absolute[_MAX_PATH];
- char b_absolute[_MAX_PATH];
- if (!InternalGetFullPathName(a, a_absolute, sizeof(a_absolute), err)) {
- return false;
- }
- if (!InternalGetFullPathName(b, b_absolute, sizeof(b_absolute), err)) {
- return false;
- }
- char a_drive[_MAX_DIR];
- char b_drive[_MAX_DIR];
- _splitpath(a_absolute, a_drive, NULL, NULL, NULL);
- _splitpath(b_absolute, b_drive, NULL, NULL, NULL);
- return _stricmp(a_drive, b_drive) == 0;
-}
-
-// Check path |s| is FullPath style returned by GetFullPathName.
-// This ignores difference of path separator.
-// This is used not to call very slow GetFullPathName API.
-bool IsFullPathName(StringPiece s) {
- if (s.size() < 3 ||
- !islatinalpha(s[0]) ||
- s[1] != ':' ||
- !IsPathSeparator(s[2])) {
- return false;
- }
-
- // Check "." or ".." is contained in path.
- for (size_t i = 2; i < s.size(); ++i) {
- if (!IsPathSeparator(s[i])) {
- continue;
- }
-
- // Check ".".
- if (i + 1 < s.size() && s[i+1] == '.' &&
- (i + 2 >= s.size() || IsPathSeparator(s[i+2]))) {
- return false;
- }
-
- // Check "..".
- if (i + 2 < s.size() && s[i+1] == '.' && s[i+2] == '.' &&
- (i + 3 >= s.size() || IsPathSeparator(s[i+3]))) {
- return false;
- }
- }
-
- return true;
-}
-
-} // anonymous namespace
-
-IncludesNormalize::IncludesNormalize(const string& relative_to) {
- string err;
- relative_to_ = AbsPath(relative_to, &err);
- if (!err.empty()) {
- Fatal("Initializing IncludesNormalize(): %s", err.c_str());
- }
- split_relative_to_ = SplitStringPiece(relative_to_, '/');
-}
-
-string IncludesNormalize::AbsPath(StringPiece s, string* err) {
- if (IsFullPathName(s)) {
- string result = s.AsString();
- for (size_t i = 0; i < result.size(); ++i) {
- if (result[i] == '\\') {
- result[i] = '/';
- }
- }
- return result;
- }
-
- char result[_MAX_PATH];
- if (!InternalGetFullPathName(s, result, sizeof(result), err)) {
- return "";
- }
- for (char* c = result; *c; ++c)
- if (*c == '\\')
- *c = '/';
- return result;
-}
-
-string IncludesNormalize::Relativize(
- StringPiece path, const vector<StringPiece>& start_list, string* err) {
- string abs_path = AbsPath(path, err);
- if (!err->empty())
- return "";
- vector<StringPiece> path_list = SplitStringPiece(abs_path, '/');
- int i;
- for (i = 0; i < static_cast<int>(min(start_list.size(), path_list.size()));
- ++i) {
- if (!EqualsCaseInsensitiveASCII(start_list[i], path_list[i])) {
- break;
- }
- }
-
- vector<StringPiece> rel_list;
- rel_list.reserve(start_list.size() - i + path_list.size() - i);
- for (int j = 0; j < static_cast<int>(start_list.size() - i); ++j)
- rel_list.push_back("..");
- for (int j = i; j < static_cast<int>(path_list.size()); ++j)
- rel_list.push_back(path_list[j]);
- if (rel_list.size() == 0)
- return ".";
- return JoinStringPiece(rel_list, '/');
-}
-
-bool IncludesNormalize::Normalize(const string& input,
- string* result, string* err) const {
- char copy[_MAX_PATH + 1];
- size_t len = input.size();
- if (len > _MAX_PATH) {
- *err = "path too long";
- return false;
- }
- strncpy(copy, input.c_str(), input.size() + 1);
- uint64_t slash_bits;
- CanonicalizePath(copy, &len, &slash_bits);
- StringPiece partially_fixed(copy, len);
- string abs_input = AbsPath(partially_fixed, err);
- if (!err->empty())
- return false;
-
- if (!SameDrive(abs_input, relative_to_, err)) {
- if (!err->empty())
- return false;
- *result = partially_fixed.AsString();
- return true;
- }
- *result = Relativize(abs_input, split_relative_to_, err);
- if (!err->empty())
- return false;
- return true;
-}
diff --git a/src/includes_normalize.h b/src/includes_normalize.h
deleted file mode 100644
index 7d50556..0000000
--- a/src/includes_normalize.h
+++ /dev/null
@@ -1,40 +0,0 @@
-// Copyright 2012 Google Inc. All Rights Reserved.
-//
-// Licensed under the Apache License, Version 2.0 (the "License");
-// you may not use this file except in compliance with the License.
-// You may obtain a copy of the License at
-//
-// http://www.apache.org/licenses/LICENSE-2.0
-//
-// Unless required by applicable law or agreed to in writing, software
-// distributed under the License is distributed on an "AS IS" BASIS,
-// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-// See the License for the specific language governing permissions and
-// limitations under the License.
-
-#include <string>
-#include <vector>
-
-struct StringPiece;
-
-/// Utility functions for normalizing include paths on Windows.
-/// TODO: this likely duplicates functionality of CanonicalizePath; refactor.
-struct IncludesNormalize {
- /// Normalize path relative to |relative_to|.
- IncludesNormalize(const std::string& relative_to);
-
- // Internal utilities made available for testing, maybe useful otherwise.
- static std::string AbsPath(StringPiece s, std::string* err);
- static std::string Relativize(StringPiece path,
- const std::vector<StringPiece>& start_list,
- std::string* err);
-
- /// Normalize by fixing slashes style, fixing redundant .. and . and makes the
- /// path |input| relative to |this->relative_to_| and store to |result|.
- bool Normalize(const std::string& input, std::string* result,
- std::string* err) const;
-
- private:
- std::string relative_to_;
- std::vector<StringPiece> split_relative_to_;
-};
diff --git a/src/includes_normalize_test.cc b/src/includes_normalize_test.cc
deleted file mode 100644
index 5d99396..0000000
--- a/src/includes_normalize_test.cc
+++ /dev/null
@@ -1,169 +0,0 @@
-// Copyright 2012 Google Inc. All Rights Reserved.
-//
-// Licensed under the Apache License, Version 2.0 (the "License");
-// you may not use this file except in compliance with the License.
-// You may obtain a copy of the License at
-//
-// http://www.apache.org/licenses/LICENSE-2.0
-//
-// Unless required by applicable law or agreed to in writing, software
-// distributed under the License is distributed on an "AS IS" BASIS,
-// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-// See the License for the specific language governing permissions and
-// limitations under the License.
-
-#include "includes_normalize.h"
-
-#include <algorithm>
-
-#include <direct.h>
-
-#include "string_piece_util.h"
-#include "test.h"
-#include "util.h"
-
-using namespace std;
-
-namespace {
-
-string GetCurDir() {
- char buf[_MAX_PATH];
- _getcwd(buf, sizeof(buf));
- vector<StringPiece> parts = SplitStringPiece(buf, '\\');
- return parts[parts.size() - 1].AsString();
-}
-
-string NormalizeAndCheckNoError(const string& input) {
- string result, err;
- IncludesNormalize normalizer(".");
- EXPECT_TRUE(normalizer.Normalize(input, &result, &err));
- EXPECT_EQ("", err);
- return result;
-}
-
-string NormalizeRelativeAndCheckNoError(const string& input,
- const string& relative_to) {
- string result, err;
- IncludesNormalize normalizer(relative_to);
- EXPECT_TRUE(normalizer.Normalize(input, &result, &err));
- EXPECT_EQ("", err);
- return result;
-}
-
-} // namespace
-
-TEST(IncludesNormalize, Simple) {
- EXPECT_EQ("b", NormalizeAndCheckNoError("a\\..\\b"));
- EXPECT_EQ("b", NormalizeAndCheckNoError("a\\../b"));
- EXPECT_EQ("a/b", NormalizeAndCheckNoError("a\\.\\b"));
- EXPECT_EQ("a/b", NormalizeAndCheckNoError("a\\./b"));
-}
-
-TEST(IncludesNormalize, WithRelative) {
- string err;
- string currentdir = GetCurDir();
- EXPECT_EQ("c", NormalizeRelativeAndCheckNoError("a/b/c", "a/b"));
- EXPECT_EQ("a",
- NormalizeAndCheckNoError(IncludesNormalize::AbsPath("a", &err)));
- EXPECT_EQ("", err);
- EXPECT_EQ(string("../") + currentdir + string("/a"),
- NormalizeRelativeAndCheckNoError("a", "../b"));
- EXPECT_EQ(string("../") + currentdir + string("/a/b"),
- NormalizeRelativeAndCheckNoError("a/b", "../c"));
- EXPECT_EQ("../../a", NormalizeRelativeAndCheckNoError("a", "b/c"));
- EXPECT_EQ(".", NormalizeRelativeAndCheckNoError("a", "a"));
-}
-
-TEST(IncludesNormalize, Case) {
- EXPECT_EQ("b", NormalizeAndCheckNoError("Abc\\..\\b"));
- EXPECT_EQ("BdEf", NormalizeAndCheckNoError("Abc\\..\\BdEf"));
- EXPECT_EQ("A/b", NormalizeAndCheckNoError("A\\.\\b"));
- EXPECT_EQ("a/b", NormalizeAndCheckNoError("a\\./b"));
- EXPECT_EQ("A/B", NormalizeAndCheckNoError("A\\.\\B"));
- EXPECT_EQ("A/B", NormalizeAndCheckNoError("A\\./B"));
-}
-
-TEST(IncludesNormalize, DifferentDrive) {
- EXPECT_EQ("stuff.h",
- NormalizeRelativeAndCheckNoError("p:\\vs08\\stuff.h", "p:\\vs08"));
- EXPECT_EQ("stuff.h",
- NormalizeRelativeAndCheckNoError("P:\\Vs08\\stuff.h", "p:\\vs08"));
- EXPECT_EQ("p:/vs08/stuff.h",
- NormalizeRelativeAndCheckNoError("p:\\vs08\\stuff.h", "c:\\vs08"));
- EXPECT_EQ("P:/vs08/stufF.h", NormalizeRelativeAndCheckNoError(
- "P:\\vs08\\stufF.h", "D:\\stuff/things"));
- EXPECT_EQ("P:/vs08/stuff.h", NormalizeRelativeAndCheckNoError(
- "P:/vs08\\stuff.h", "D:\\stuff/things"));
- EXPECT_EQ("P:/wee/stuff.h",
- NormalizeRelativeAndCheckNoError("P:/vs08\\../wee\\stuff.h",
- "D:\\stuff/things"));
-}
-
-TEST(IncludesNormalize, LongInvalidPath) {
- const char kLongInputString[] =
- "C:\\Program Files (x86)\\Microsoft Visual Studio "
- "12.0\\VC\\INCLUDEwarning #31001: The dll for reading and writing the "
- "pdb (for example, mspdb110.dll) could not be found on your path. This "
- "is usually a configuration error. Compilation will continue using /Z7 "
- "instead of /Zi, but expect a similar error when you link your program.";
- // Too long, won't be canonicalized. Ensure doesn't crash.
- string result, err;
- IncludesNormalize normalizer(".");
- EXPECT_FALSE(
- normalizer.Normalize(kLongInputString, &result, &err));
- EXPECT_EQ("path too long", err);
-
-
- // Construct max size path having cwd prefix.
- // kExactlyMaxPath = "$cwd\\a\\aaaa...aaaa\0";
- char kExactlyMaxPath[_MAX_PATH + 1];
- ASSERT_NOT_NULL(_getcwd(kExactlyMaxPath, sizeof kExactlyMaxPath));
-
- int cwd_len = strlen(kExactlyMaxPath);
- ASSERT_LE(cwd_len + 3 + 1, _MAX_PATH)
- kExactlyMaxPath[cwd_len] = '\\';
- kExactlyMaxPath[cwd_len + 1] = 'a';
- kExactlyMaxPath[cwd_len + 2] = '\\';
-
- kExactlyMaxPath[cwd_len + 3] = 'a';
-
- for (int i = cwd_len + 4; i < _MAX_PATH; ++i) {
- if (i > cwd_len + 4 && i < _MAX_PATH - 1 && i % 10 == 0)
- kExactlyMaxPath[i] = '\\';
- else
- kExactlyMaxPath[i] = 'a';
- }
-
- kExactlyMaxPath[_MAX_PATH] = '\0';
- EXPECT_EQ(strlen(kExactlyMaxPath), _MAX_PATH);
-
- string forward_slashes(kExactlyMaxPath);
- replace(forward_slashes.begin(), forward_slashes.end(), '\\', '/');
- // Make sure a path that's exactly _MAX_PATH long is canonicalized.
- EXPECT_EQ(forward_slashes.substr(cwd_len + 1),
- NormalizeAndCheckNoError(kExactlyMaxPath));
-}
-
-TEST(IncludesNormalize, ShortRelativeButTooLongAbsolutePath) {
- string result, err;
- IncludesNormalize normalizer(".");
- // A short path should work
- EXPECT_TRUE(normalizer.Normalize("a", &result, &err));
- EXPECT_EQ("", err);
-
- // Construct max size path having cwd prefix.
- // kExactlyMaxPath = "aaaa\\aaaa...aaaa\0";
- char kExactlyMaxPath[_MAX_PATH + 1];
- for (int i = 0; i < _MAX_PATH; ++i) {
- if (i < _MAX_PATH - 1 && i % 10 == 4)
- kExactlyMaxPath[i] = '\\';
- else
- kExactlyMaxPath[i] = 'a';
- }
- kExactlyMaxPath[_MAX_PATH] = '\0';
- EXPECT_EQ(strlen(kExactlyMaxPath), _MAX_PATH);
-
- // Make sure a path that's exactly _MAX_PATH long fails with a proper error.
- EXPECT_FALSE(normalizer.Normalize(kExactlyMaxPath, &result, &err));
- EXPECT_TRUE(err.find("GetFullPathName") != string::npos);
-}
diff --git a/src/inline.sh b/src/inline.sh
deleted file mode 100755
index 5092fa2..0000000
--- a/src/inline.sh
+++ /dev/null
@@ -1,32 +0,0 @@
-#!/bin/sh
-#
-# Copyright 2001 Google Inc. All Rights Reserved.
-#
-# Licensed under the Apache License, Version 2.0 (the "License");
-# you may not use this file except in compliance with the License.
-# You may obtain a copy of the License at
-#
-# http://www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing, software
-# distributed under the License is distributed on an "AS IS" BASIS,
-# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-# See the License for the specific language governing permissions and
-# limitations under the License.
-
-# This quick script converts a text file into an #include-able header.
-# It expects the name of the variable as its first argument, and reads
-# stdin and writes stdout.
-
-varname="$1"
-
-# 'od' and 'sed' may not be available on all platforms, and may not support the
-# flags used here. We must ensure that the script exits with a non-zero exit
-# code in those cases.
-byte_vals=$(od -t x1 -A n -v) || exit 1
-escaped_byte_vals=$(echo "${byte_vals}" \
- | sed -e 's|^[\t ]\{0,\}$||g; s|[\t ]\{1,\}| |g; s| \{1,\}$||g; s| |\\x|g; s|^|"|; s|$|"|') \
- || exit 1
-
-# Only write output once we have successfully generated the required data
-printf "const char %s[] = \n%s;" "${varname}" "${escaped_byte_vals}"
diff --git a/src/interrupt_handling-posix.cc b/src/interrupt_handling-posix.cc
deleted file mode 100644
index fa47131..0000000
--- a/src/interrupt_handling-posix.cc
+++ /dev/null
@@ -1,177 +0,0 @@
-// Copyright 2023 Google Inc. All Rights Reserved.
-//
-// Licensed under the Apache License, Version 2.0 (the "License");
-// you may not use this file except in compliance with the License.
-// You may obtain a copy of the License at
-//
-// http://www.apache.org/licenses/LICENSE-2.0
-//
-// Unless required by applicable law or agreed to in writing, software
-// distributed under the License is distributed on an "AS IS" BASIS,
-// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-// See the License for the specific language governing permissions and
-// limitations under the License.
-
-#include <stdio.h>
-#include <unistd.h>
-
-#include "interrupt_handling.h"
-#include "util.h"
-
-// Set to 1 to print debug messages to stderr during development
-#define DEBUG 0
-
-namespace {
-
-// Retrieve a signal mask for SIGINT/SIGHUP/SIGTERM
-sigset_t GetInterruptSignalMask() {
- sigset_t mask;
- sigemptyset(&mask);
- sigaddset(&mask, SIGINT);
- sigaddset(&mask, SIGHUP);
- sigaddset(&mask, SIGTERM);
- return mask;
-}
-
-// Set the signal action for a given |signum|, returning the previous one
-// in |*old_action| is |old_action != nullptr|.
-void SetSignalAction(int signum, const struct sigaction* action,
- struct sigaction* old_action) {
- if (sigaction(signum, action, old_action) < 0)
- ErrnoFatal("sigaction");
-}
-
-} // namespace
-
-//////////////////////////////////////////////////////////////////////////
-///
-/// InterruptBlocker
-///
-
-InterruptBlocker::InterruptBlocker() {
- sigset_t block_interrupts = GetInterruptSignalMask();
- if (sigprocmask(SIG_BLOCK, &block_interrupts, &prev_signal_mask_) < 0)
- ErrnoFatal("sigprocmask");
-}
-
-InterruptBlocker::~InterruptBlocker() {
- if (sigprocmask(SIG_SETMASK, &prev_signal_mask_, nullptr) < 0)
- ErrnoFatal("sigprocmask");
-}
-
-//////////////////////////////////////////////////////////////////////////
-///
-/// InterruptHandlerBase
-///
-
-InterruptHandlerBase::InterruptHandlerBase(const struct sigaction& action) {
- // Block the signals before changing the handlers.
- sigset_t mask = GetInterruptSignalMask();
- sigprocmask(SIG_BLOCK, &mask, &old_mask_);
-
- SetSignalAction(SIGINT, &action, &old_int_action_);
- SetSignalAction(SIGHUP, &action, &old_hup_action_);
- SetSignalAction(SIGTERM, &action, &old_term_action_);
-
- // Unblock the signals now.
- sigprocmask(SIG_UNBLOCK, &mask, nullptr);
-}
-
-InterruptHandlerBase::~InterruptHandlerBase() {
- // Block the signal before changing the action handlers.
- sigset_t mask = GetInterruptSignalMask();
- sigprocmask(SIG_BLOCK, &mask, nullptr);
-
- SetSignalAction(SIGINT, &old_int_action_, nullptr);
- SetSignalAction(SIGHUP, &old_hup_action_, nullptr);
- SetSignalAction(SIGTERM, &old_term_action_, nullptr);
-
- // Restore the original signal mask.
- sigprocmask(SIG_SETMASK, &old_mask_, nullptr);
-}
-
-//////////////////////////////////////////////////////////////////////////
-///
-/// InterruptCatcher
-///
-
-InterruptCatcher::InterruptCatcher() : InterruptHandlerBase(MakeAction()) {
- s_interrupted_ = 0;
- HandlePendingInterrupt();
-}
-
-InterruptCatcher::~InterruptCatcher() = default;
-
-#if DEBUG
-#define WRITE(msg) ::write(2, msg, sizeof(msg) - 1)
-#else
-#define WRITE(msg) (void)(msg)
-#endif
-
-// static
-struct sigaction InterruptCatcher::MakeAction() {
- struct sigaction result = {};
- result.sa_handler = [](int signum) {
- s_interrupted_ = signum;
- if (signum == SIGINT)
- WRITE("\nSIGINT SIGNALED\n");
- else if (signum == SIGHUP)
- WRITE("\nSIGHUP SIGNALED\n");
- else if (signum == SIGTERM)
- WRITE("\nSIGTERM SIGNALED\n");
- };
- return result;
-}
-
-// static
-void InterruptCatcher::HandlePendingInterrupt() {
- sigset_t pending;
- sigemptyset(&pending);
- if (sigpending(&pending) == -1) {
- perror("ninja: sigpending");
- return;
- }
- if (sigismember(&pending, SIGINT)) {
- WRITE("\nSIGINT PENDING\n");
- s_interrupted_ = SIGINT;
- } else if (sigismember(&pending, SIGTERM)) {
- WRITE("\nSIGTERM PENDING\n");
- s_interrupted_ = SIGTERM;
- } else if (sigismember(&pending, SIGHUP)) {
- WRITE("\nSIGHUP PENDING\n");
- s_interrupted_ = SIGHUP;
- }
-}
-
-// static
-volatile sig_atomic_t InterruptCatcher::s_interrupted_ = 0;
-
-//////////////////////////////////////////////////////////////////////////
-///
-/// InterruptForwarder
-///
-
-#include <unistd.h>
-
-InterruptForwarder::InterruptForwarder(pid_t process_group)
- : InterruptHandlerBase(MakeAction()), old_process_group_(s_process_group_) {
- s_process_group_ = process_group;
-}
-
-InterruptForwarder::~InterruptForwarder() {
- s_process_group_ = old_process_group_;
-}
-
-// static
-struct sigaction InterruptForwarder::MakeAction() {
- struct sigaction result = {};
- result.sa_handler = [](int signum) {
- // Send the interrupt to the server's process group
- kill(-s_process_group_, signum);
- WRITE("\nINTERRUPT FORWARDED\n");
- };
- return result;
-}
-
-// static
-pid_t InterruptForwarder::s_process_group_ = 0;
diff --git a/src/interrupt_handling-win32.cc b/src/interrupt_handling-win32.cc
deleted file mode 100644
index a0b866c..0000000
--- a/src/interrupt_handling-win32.cc
+++ /dev/null
@@ -1,88 +0,0 @@
-// Copyright 2023 Google Inc. All Rights Reserved.
-//
-// Licensed under the Apache License, Version 2.0 (the "License");
-// you may not use this file except in compliance with the License.
-// You may obtain a copy of the License at
-//
-// http://www.apache.org/licenses/LICENSE-2.0
-//
-// Unless required by applicable law or agreed to in writing, software
-// distributed under the License is distributed on an "AS IS" BASIS,
-// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-// See the License for the specific language governing permissions and
-// limitations under the License.
-
-#include "interrupt_handling.h"
-#include "util.h"
-
-//////////////////////////////////////////////////////////////////////////
-///
-/// InterruptCompletionPortHandler
-///
-
-InterruptCompletionPortHandler::InterruptCompletionPortHandler(
- HANDLE ioport, ULONG_PTR completion_key)
- : old_ioport_(s_ioport_), old_completion_key_(s_completion_key_) {
- s_ioport_ = ioport;
- s_completion_key_ = completion_key;
-
- if (!SetConsoleCtrlHandler(HandlerRoutine, TRUE))
- Win32Fatal("SetConsoleCtrlHandler");
-}
-
-InterruptCompletionPortHandler::~InterruptCompletionPortHandler() {
- s_ioport_ = old_ioport_;
- s_completion_key_ = old_completion_key_;
-
- if (!SetConsoleCtrlHandler(HandlerRoutine, FALSE))
- Win32Fatal("SetConsoleCtrlHandler");
-}
-
-// static
-BOOL InterruptCompletionPortHandler::HandlerRoutine(DWORD dwCtrlType) {
- if (dwCtrlType != CTRL_C_EVENT && dwCtrlType != CTRL_BREAK_EVENT)
- return FALSE;
-
- if (!PostQueuedCompletionStatus(s_ioport_, 0, s_completion_key_, nullptr))
- Win32Fatal("PostQueuedCompletionStatus");
-
- return TRUE;
-}
-
-// static
-HANDLE InterruptCompletionPortHandler::s_ioport_ = INVALID_HANDLE_VALUE;
-
-// static
-ULONG_PTR InterruptCompletionPortHandler::s_completion_key_ = 0;
-
-//////////////////////////////////////////////////////////////////////////
-///
-/// InterruptForwarder
-///
-
-InterruptForwarder::InterruptForwarder(DWORD pgid)
- : old_process_group_id_(s_process_group_id_) {
- s_process_group_id_ = pgid;
- if (!SetConsoleCtrlHandler(InterruptForwarder::HandlerRoutine, TRUE))
- Win32Fatal("SetConsoleCtrlHandler");
-}
-
-InterruptForwarder::~InterruptForwarder() {
- s_process_group_id_ = old_process_group_id_;
- if (!SetConsoleCtrlHandler(InterruptForwarder::HandlerRoutine, FALSE))
- Win32Fatal("SetConsoleCtrlHandler");
-}
-
-// static
-BOOL InterruptForwarder::HandlerRoutine(DWORD dwCtrlType) {
- if (dwCtrlType != CTRL_C_EVENT && dwCtrlType != CTRL_BREAK_EVENT)
- return FALSE;
-
- if (!GenerateConsoleCtrlEvent(dwCtrlType, s_process_group_id_))
- Win32Fatal("GenerateConsoleCtrlEvent");
-
- return TRUE;
-}
-
-// static
-DWORD InterruptForwarder::s_process_group_id_ = 0;
diff --git a/src/interrupt_handling.h b/src/interrupt_handling.h
deleted file mode 100644
index 6dc562c..0000000
--- a/src/interrupt_handling.h
+++ /dev/null
@@ -1,125 +0,0 @@
-// Copyright 2023 Google Inc. All Rights Reserved.
-//
-// Licensed under the Apache License, Version 2.0 (the "License");
-// you may not use this file except in compliance with the License.
-// You may obtain a copy of the License at
-//
-// http://www.apache.org/licenses/LICENSE-2.0
-//
-// Unless required by applicable law or agreed to in writing, software
-// distributed under the License is distributed on an "AS IS" BASIS,
-// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-// See the License for the specific language governing permissions and
-// limitations under the License.
-#ifndef NINJA_INTERRUPT_HANDLING_H_
-#define NINJA_INTERRUPT_HANDLING_H_
-
-/// Convenience classes used to control how user interruption
-/// is handled by Ninja at various times. This means Ctrl+C and Ctrl+Break
-/// events on Win32, and SIGINT/SIGHUP/SIGTERM ones on Posix.
-
-#ifdef _WIN32
-
-#include <windows.h>
-
-/// On Ctrl-C or Ctrl-Break, post en empty i/o completion packet
-/// to a given i/o completion queue. Useful to catch signals when
-/// waiting for overlapped i/o on Win32.
-struct InterruptCompletionPortHandler {
- InterruptCompletionPortHandler(HANDLE ioport, ULONG_PTR completion_key = 0);
- ~InterruptCompletionPortHandler();
-
- private:
- static BOOL WINAPI HandlerRoutine(DWORD dwCtrlType);
- HANDLE old_ioport_;
- ULONG_PTR old_completion_key_;
- static HANDLE s_ioport_;
- static ULONG_PTR s_completion_key_;
-};
-
-/// Forward all Ctrl-C and Ctrl-Break signals to a different
-/// process group.
-struct InterruptForwarder {
- InterruptForwarder(DWORD process_group_id);
- ~InterruptForwarder();
-
- private:
- static BOOL WINAPI HandlerRoutine(DWORD dwCtrlType);
- DWORD old_process_group_id_;
- static DWORD s_process_group_id_;
-};
-
-#else // !_WIN32
-
-#include <signal.h>
-
-/// A class used to block all SIGINT/SIGHUP/SIGTERM signals
-/// in the current process. Restores the previous signal
-/// mask in the destructor.
-struct InterruptBlocker {
- InterruptBlocker();
- ~InterruptBlocker();
-
- const sigset_t& old_mask() const { return prev_signal_mask_; }
-
- private:
- sigset_t prev_signal_mask_;
-};
-
-/// Base class for all interrupt handlers.
-struct InterruptHandlerBase {
- /// Constructor sets a new signal handler for SIGINT/SIGHUP/SIGTERM
- /// and unblocks these signals!
- InterruptHandlerBase(const struct sigaction& action);
-
- /// Destructor restores previous interrupt handlers and signal mask.
- ~InterruptHandlerBase();
-
- /// Return the signal mask before construction. This will be restored
- /// on destruction as well.
- sigset_t old_mask() const { return old_mask_; }
-
- private:
- struct sigaction old_int_action_;
- struct sigaction old_hup_action_;
- struct sigaction old_term_action_;
- sigset_t old_mask_;
-};
-
-/// Catch all SIGINT/SIGHUP/SIGTERM signals and stores the
-/// corresponding signal number into a global interrupted()
-/// variable. This can also detect pending signals.
-struct InterruptCatcher : public InterruptHandlerBase {
- InterruptCatcher();
- ~InterruptCatcher();
-
- /// Return interrupt signal number, or 0 if there were none.
- int interrupted() const { return s_interrupted_; }
-
- /// Clear the interrupted signal number.
- void Clear() { s_interrupted_ = 0; }
-
- /// Handle any pending interruption signal. This updates
- /// the interrupted() value but does not cancel the signals.
- static void HandlePendingInterrupt();
-
- private:
- static struct sigaction MakeAction();
- static volatile sig_atomic_t s_interrupted_;
-};
-
-/// Forward all SIGINT/SIGHUP/SIGTERM signal to a different
-/// process group
-struct InterruptForwarder : public InterruptHandlerBase {
- explicit InterruptForwarder(pid_t process_group);
- ~InterruptForwarder();
-
- private:
- static struct sigaction MakeAction();
- pid_t old_process_group_ = -1;
- static pid_t s_process_group_;
-};
-
-#endif // !_WIN32
-
-#endif // NINJA_INTERRUPT_HANDLING_H_
diff --git a/src/interrupt_handling_test.cc b/src/interrupt_handling_test.cc
deleted file mode 100644
index 2df18db..0000000
--- a/src/interrupt_handling_test.cc
+++ /dev/null
@@ -1,204 +0,0 @@
-// Copyright 2023 Google Inc. All Rights Reserved.
-//
-// Licensed under the Apache License, Version 2.0 (the "License");
-// you may not use this file except in compliance with the License.
-// You may obtain a copy of the License at
-//
-// http://www.apache.org/licenses/LICENSE-2.0
-//
-// Unless required by applicable law or agreed to in writing, software
-// distributed under the License is distributed on an "AS IS" BASIS,
-// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-// See the License for the specific language governing permissions and
-// limitations under the License.
-
-#include "interrupt_handling.h"
-
-#include "test.h"
-#include "util.h"
-
-#ifdef _WIN32
-
-// TODO(digit): Write real test for _WIN32
-char dummy_;
-
-#else // !_WIN32
-
-#include <sys/signal.h>
-#include <unistd.h>
-
-namespace {
-
-// Retrieve a signal mask for SIGINT/SIGHUP/SIGTERM
-sigset_t GetInterruptSignalMask() {
- sigset_t mask;
- sigemptyset(&mask);
- sigaddset(&mask, SIGINT);
- sigaddset(&mask, SIGHUP);
- sigaddset(&mask, SIGTERM);
- return mask;
-}
-
-// Set the signal action for a given |signum|, returning the previous one
-// in |*old_action| is |old_action != nullptr|.
-void SetSignalAction(int signum, const struct sigaction* action,
- struct sigaction* old_action) {
- if (sigaction(signum, action, old_action) < 0)
- ErrnoFatal("sigaction");
-}
-
-// Base class for all tests, used to set the signal mask and actions for
-// interrupts to the same base state.
-class InterruptHandlingTest : public ::testing::Test {
- public:
- InterruptHandlingTest() {
- // Block signals before changing the action handler + save previous mask.
- sigset_t mask = GetInterruptSignalMask();
- sigprocmask(SIG_BLOCK, &mask, &prev_mask_);
-
- // Change signal handlers.
- struct sigaction sigint_action = {};
- sigint_action.sa_handler = [](int) { s_got_sigint = 1; };
- SetSignalAction(SIGINT, &sigint_action, &prev_sigint_action_);
-
- struct sigaction sighup_action = {};
- sighup_action.sa_handler = [](int) { s_got_sighup = 1; };
- SetSignalAction(SIGHUP, &sighup_action, &prev_sighup_action_);
-
- struct sigaction sigterm_action = {};
- sigterm_action.sa_handler = [](int) { s_got_sigterm = 1; };
- SetSignalAction(SIGTERM, &sigterm_action, &prev_sigterm_action_);
-
- // Unblock signals.
- sigprocmask(SIG_UNBLOCK, &mask, nullptr);
- }
-
- ~InterruptHandlingTest() {
- // Block signals before changing handlers.
- sigset_t mask = GetInterruptSignalMask();
- sigprocmask(SIG_BLOCK, &mask, nullptr);
-
- // Restore previous handlers.
- SetSignalAction(SIGINT, &prev_sigint_action_, nullptr);
- SetSignalAction(SIGHUP, &prev_sighup_action_, nullptr);
- SetSignalAction(SIGTERM, &prev_sigterm_action_, nullptr);
-
- // Clear flags for next test.
- Clear();
-
- // Restore previous signal mask.
- sigprocmask(SIG_SETMASK, &prev_mask_, nullptr);
- }
-
- void Clear() {
- s_got_sigint = 0;
- s_got_sighup = 0;
- s_got_sigterm = 0;
- }
-
- void SendSelfSignal(int signum) { ::kill(getpid(), signum); }
-
- sigset_t prev_mask_;
- struct sigaction prev_sigint_action_;
- struct sigaction prev_sighup_action_;
- struct sigaction prev_sigterm_action_;
-
- static volatile sig_atomic_t s_got_sigint;
- static volatile sig_atomic_t s_got_sighup;
- static volatile sig_atomic_t s_got_sigterm;
-};
-
-volatile sig_atomic_t InterruptHandlingTest::s_got_sigint = 0;
-volatile sig_atomic_t InterruptHandlingTest::s_got_sighup = 0;
-volatile sig_atomic_t InterruptHandlingTest::s_got_sigterm = 0;
-
-} // namespace
-
-TEST_F(InterruptHandlingTest, SendSelfSignals) {
- // Verify that the interrupt signals are not blocked
- sigset_t empty_mask;
- sigemptyset(&empty_mask);
- sigset_t cur_mask;
- sigprocmask(SIG_BLOCK, &empty_mask, &cur_mask);
- ASSERT_FALSE(sigismember(&cur_mask, SIGINT));
- ASSERT_FALSE(sigismember(&cur_mask, SIGHUP));
- ASSERT_FALSE(sigismember(&cur_mask, SIGTERM));
-
- SendSelfSignal(SIGINT);
- ASSERT_TRUE(s_got_sigint);
-
- SendSelfSignal(SIGHUP);
- ASSERT_TRUE(s_got_sighup);
-
- SendSelfSignal(SIGTERM);
- ASSERT_TRUE(s_got_sigterm);
-
- Clear();
- ASSERT_FALSE(s_got_sigint);
- ASSERT_FALSE(s_got_sighup);
- ASSERT_FALSE(s_got_sigterm);
-}
-
-TEST_F(InterruptHandlingTest, InterruptBlocker) {
- {
- InterruptBlocker blocker;
-
- SendSelfSignal(SIGINT);
- ASSERT_FALSE(s_got_sigint);
-
- SendSelfSignal(SIGHUP);
- ASSERT_FALSE(s_got_sighup);
-
- SendSelfSignal(SIGTERM);
- ASSERT_FALSE(s_got_sigterm);
- }
- ASSERT_TRUE(s_got_sigint);
- ASSERT_TRUE(s_got_sighup);
- ASSERT_TRUE(s_got_sigterm);
-}
-
-TEST_F(InterruptHandlingTest, InterruptCatcher) {
- {
- InterruptCatcher catcher;
-
- SendSelfSignal(SIGINT);
- ASSERT_FALSE(s_got_sigint);
- ASSERT_EQ(SIGINT, catcher.interrupted());
-
- SendSelfSignal(SIGHUP);
- ASSERT_FALSE(s_got_sighup);
- ASSERT_EQ(SIGHUP, catcher.interrupted());
-
- SendSelfSignal(SIGTERM);
- ASSERT_FALSE(s_got_sigterm);
- ASSERT_EQ(SIGTERM, catcher.interrupted());
- }
-
- // Verify that a second instance does not keep the old interrupted()
- // value from a stale global variable.
- {
- InterruptCatcher catcher;
- ASSERT_EQ(0, catcher.interrupted());
- }
-}
-
-TEST_F(InterruptHandlingTest, InterruptForwarder) {
- ASSERT_FALSE(s_got_sigint);
-
- // Create child process with fork.
- pid_t child_pid = fork();
- ASSERT_GE(child_pid, 0);
-
- if (child_pid == 0) {
- // In the child process, do nothing, just wait for an interrupt.
- sleep(10);
- exit(0);
- }
-
- InterruptForwarder forwarder(child_pid);
-
- SendSelfSignal(SIGINT);
- ASSERT_FALSE(s_got_sigint);
-}
-
-#endif // !_WIN32
diff --git a/src/ipc_handle-posix.cc b/src/ipc_handle-posix.cc
deleted file mode 100644
index 09d3c78..0000000
--- a/src/ipc_handle-posix.cc
+++ /dev/null
@@ -1,757 +0,0 @@
-// Copyright 2023 Google Inc. All Rights Reserved.
-//
-// Licensed under the Apache License, Version 2.0 (the "License");
-// you may not use this file except in compliance with the License.
-// You may obtain a copy of the License at
-//
-// http://www.apache.org/licenses/LICENSE-2.0
-//
-// Unless required by applicable law or agreed to in writing, software
-// distributed under the License is distributed on an "AS IS" BASIS,
-// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-// See the License for the specific language governing permissions and
-// limitations under the License.
-
-#include <errno.h>
-#include <fcntl.h>
-#include <stddef.h>
-#include <stdio.h>
-#include <sys/socket.h>
-#include <sys/types.h>
-#include <sys/un.h>
-#include <unistd.h>
-
-#include "ipc_handle.h"
-#include "util.h" // For StringFormat() and GetLastErrorString()
-
-namespace {
-
-// helper macro to loop on EINTR during syscalls.
-// Important: Do not use it for close(), use CloseFd() instead.
-#define HANDLE_EINTR(x) \
- ({ \
- decltype(x) eintr_wrapper_result; \
- do { \
- eintr_wrapper_result = (x); \
- } while (eintr_wrapper_result == -1 && errno == EINTR); \
- eintr_wrapper_result; \
- })
-
-// Close file descriptor if needed, preserving errno
-// since EINTR can happen during a close(), but there
-// is nothing that can be done when it does (since
-// it is impossible to tell whether the descriptor
-// was already closed or not, the result being kernel
-// and system specific).
-void CloseFd(int& fd) {
- if (fd >= 0) {
- int save_errno = errno;
- ::close(fd);
- fd = -1;
- errno = save_errno;
- }
-}
-
-// Convenience function to write the errno message to a string
-// and return false.
-bool SetErrnoMessage(std::string* error_message) {
- *error_message = strerror(errno);
- return false;
-}
-
-// Return true if |fd| is in non-blocking mode.
-bool IsNonBlockingFd(int fd) {
- int flags = fcntl(fd, F_GETFL);
- return (flags >= 0) && (flags & O_NONBLOCK) != 0;
-}
-
-// Set the non-blocking flags of |fd| to |enabled|
-void SetNonBlockingFd(int fd, bool enabled) {
- int flags = fcntl(fd, F_GETFL);
- if (flags < 0)
- return;
-
- int new_flags = enabled ? (flags | O_NONBLOCK) : (flags & ~O_NONBLOCK);
- if (new_flags != flags)
- fcntl(fd, F_SETFL, new_flags);
-}
-
-bool IsClosedOnExec(int fd) {
- int flags = fcntl(fd, F_GETFD);
- return (flags >= 0) && (flags & FD_CLOEXEC) != 0;
-}
-
-void SetClosedOnExecFlag(int fd, bool enabled) {
- if (fd >= 0) {
- int flags = fcntl(fd, F_GETFD);
- int new_flags = enabled ? (flags | FD_CLOEXEC) : (flags & ~FD_CLOEXEC);
- if (flags != new_flags)
- fcntl(fd, F_SETFD, new_flags);
- }
-}
-
-// Create a new unix-domain socket, potentially in non-blocking mode,
-// always with CLOEXEC.
-int CreateUnixSocket(bool non_blocking) {
-#if defined(SOCK_NONBLOCK) && defined(SOCK_CLOEXEC)
- int flags = SOCK_STREAM | SOCK_CLOEXEC | (non_blocking ? SOCK_NONBLOCK : 0);
- return socket(AF_UNIX, flags, 0);
-#else // !SOCK_NONBLOCK || !SOCK_CLOEXEC
- int sock = socket(AF_UNIX, SOCK_STREAM, 0);
- if (sock < 0)
- return -1;
-
- int flags = fcntl(sock, F_GETFD);
- fcntl(sock, F_SETFD, flags | FD_CLOEXEC);
-
- if (non_blocking)
- SetNonBlockingFd(sock, true);
-
- return sock;
-#endif // !SOCK_NONBLOCK || !SOCK_CLOEXEC
-}
-
-// Convenience class to wait for a single file descriptor to become
-// either readable or writable. Usage is:
-//
-// - Create instance.
-// - Call Wait() passing a timeout.
-//
-struct PosixIoConditionWaiter {
- // Constructor. Set |writable| to true to wait for write events,
- // otherwise for |read| events.
- PosixIoConditionWaiter(int fd, bool writable) : fd_(fd), writable_(writable) {
- FD_ZERO(&fds_);
- }
-
- // Wait for the specific condition. On success return true.
- // On failure, set |*error| then return false. In all cases
- // |*did_timeout| will be set to true only in case of timeout.
- bool Wait(int64_t timeout_ms, bool* did_timeout, std::string* error) {
- // Reset fds_ in case Wait() is called multiple times.
- FD_SET(fd_, &fds_);
-
- struct timespec* ts = nullptr;
- struct timespec timeout_ts;
- if (timeout_ms >= 0) {
- timeout_ts.tv_sec = static_cast<time_t>(timeout_ms / 1000);
- timeout_ts.tv_nsec =
- static_cast<int32_t>((timeout_ms % 1000) * 1000000LL);
- ts = &timeout_ts;
- }
-
- *did_timeout = false;
-
- fd_set* readable = writable_ ? nullptr : &fds_;
- fd_set* writable = writable_ ? &fds_ : nullptr;
- int ret = pselect(fd_ + 1, readable, writable, nullptr, ts, nullptr);
- if (ret < 0)
- return SetErrnoMessage(error);
-
- if (!FD_ISSET(fd_, &fds_)) {
- *did_timeout = true;
- *error = "timed out";
- return false;
- }
- return true;
- }
-
- const int fd_;
- const bool writable_;
- fd_set fds_;
-};
-
-// Retrieve non-blocking socket connection status.
-int GetSocketConnectStatus(int fd) {
- int so_error = 0;
- socklen_t so_error_len = sizeof(so_error);
- int ret = getsockopt(fd, SOL_SOCKET, SO_ERROR, &so_error, &so_error_len);
- if (ret < 0)
- return ret;
-
- return so_error;
-}
-
-// Set USE_LINUX_NAMESPACE to 1 to use Linux abstract
-// unix namespace, which do not require a filesystem
-// entry point.
-#ifdef __linux__
-#define USE_LINUX_NAMESPACE 1
-#endif
-
-#if !USE_LINUX_NAMESPACE
-// Return runtime directory where to create a Unix socket.
-// Only used for non-Linux systems. Callers can assume
-// that the directory already exists (otherwise, the system
-// is not configured properly, and an error on bind or
-// connect operation is expected).
-std::string GetRuntimeDirectory() {
- std::string result;
- // XDG_RUNTIME_DIR might be defined on BSDs and other operating
- // systems.
- const char* xdg_runtime_dir = getenv("XDG_RUNTIME_DIR");
- if (xdg_runtime_dir) {
- result = xdg_runtime_dir;
- }
- if (result.empty()) {
- const char* tmp = getenv("TMPDIR");
- if (!tmp || !tmp[0])
- tmp = "/tmp";
- result = tmp;
- }
- return result;
-}
-#endif // !USE_LINUX_NAMESPACE
-
-// Return the Unix socket path to be used for |service_name|.
-std::string CreateUnixSocketPath(StringPiece service_name) {
- // On Linux, use the abstract namespace by creating a string with
- // a NUL byte at the front. On other platform, use the runtime
- // directory instead.
-#if USE_LINUX_NAMESPACE
- std::string result(1, '\0');
-#else
- std::string result = GetRuntimeDirectory() + "/";
-#endif
- result += "basic_ipc-";
- const char* user = getenv("USER");
- if (!user || !user[0])
- user = "unknown_user";
- result += user;
- result += "-";
- result += service_name.AsString();
- return result;
-}
-
-// Convenience class to model a Unix socket address.
-// Usage is:
-// 1) Create instance, passing service name.
-// 2) Call valid() to check the instance. If false the
-// service name was too long.
-// 3) Use address() and size() to pass to sendmsg().
-class LocalAddress {
- public:
- LocalAddress(StringPiece service_name) {
- local_ = {};
- local_.sun_family = AF_UNIX;
- std::string path = CreateUnixSocketPath(service_name);
- if (path.size() >= sizeof(local_.sun_path))
- return; // Service name is too long.
-
- memcpy(local_.sun_path, path.data(), path.size());
- local_.sun_path[path.size()] = '\0';
- size_ = offsetof(sockaddr_un, sun_path) + path.size() + 1;
- }
-
- bool valid() const { return size_ > 0; }
- sockaddr* address() const { return const_cast<sockaddr*>(&generic_); }
- size_t size() const { return size_; }
- const char* path() const { return local_.sun_path; }
- std::string pid_path() const {
- return StringFormat("%s.pid", local_.sun_path);
- }
-
- private:
- size_t size_ = 0;
- union {
- sockaddr_un local_;
- sockaddr generic_;
- };
-};
-
-} // namespace
-
-// static
-constexpr int IpcHandle::kInvalid;
-
-// static
-IpcHandle::HandleType IpcHandle::CloneNativeHandle(HandleType handle,
- bool inherited) {
- int fd = ::dup(handle);
- SetClosedOnExecFlag(fd, inherited);
- return fd;
-}
-
-void IpcHandle::Close() {
- CloseFd(handle_);
-}
-
-int IpcHandle::ReleaseNativeHandle() {
- int result = handle_;
- handle_ = -1;
- return result;
-}
-
-ssize_t IpcHandle::Read(void* buff, size_t buffer_size,
- std::string* error_message) const {
- auto* buffer = static_cast<char*>(buff);
- ssize_t result = 0;
- while (buffer_size > 0) {
- ssize_t count = read(handle_, buffer, buffer_size);
- if (count < 0) {
- if (errno == EINTR)
- continue;
- if (result > 0) {
- // Ignore this error to return the current read result.
- // This assumes the error will repeat on the next call.
- break;
- }
- *error_message = strerror(errno);
- return -1;
- } else if (count == 0) {
- break;
- }
- buffer += count;
- buffer_size -= static_cast<size_t>(count);
- result += count;
- }
- return result;
-}
-
-ssize_t IpcHandle::Write(const void* buff, size_t buffer_size,
- std::string* error_message) const {
- auto* buffer = static_cast<const char*>(buff);
- ssize_t result = 0;
- while (buffer_size > 0) {
- ssize_t count = write(handle_, buffer, buffer_size);
- if (count < 0) {
- if (errno == EINTR)
- continue;
- if (result > 0) {
- break;
- }
- *error_message = strerror(errno);
- return -1;
- } else if (count == 0) {
- break;
- }
- buffer += count;
- buffer_size -= static_cast<size_t>(count);
- result += count;
- }
- return result;
-}
-
-bool IpcHandle::SendNativeHandle(HandleType native,
- std::string* error_message) const {
- char ch = 'x';
- iovec iov = { &ch, 1 };
- union {
- char buf[CMSG_SPACE(sizeof(int))];
- cmsghdr align;
- } control;
- memset(control.buf, 0, sizeof(control.buf));
-
- msghdr header = {};
- header.msg_iov = &iov;
- header.msg_iovlen = 1;
- header.msg_control = control.buf;
- header.msg_controllen = sizeof(control.buf);
-
- cmsghdr* control_header = CMSG_FIRSTHDR(&header);
- control_header->cmsg_len = CMSG_LEN(sizeof(int));
- control_header->cmsg_level = SOL_SOCKET;
- control_header->cmsg_type = SCM_RIGHTS;
- reinterpret_cast<int*>(CMSG_DATA(control_header))[0] = native;
-
- ssize_t ret = HANDLE_EINTR(sendmsg(handle_, &header, 0));
- if (ret == -1)
- return SetErrnoMessage(error_message);
-
- return true;
-}
-
-bool IpcHandle::ReceiveNativeHandle(IpcHandle* native,
- std::string* error_message) const {
- char ch = '\0';
- iovec iov = { &ch, 1 };
- union {
- char buf[CMSG_SPACE(sizeof(int))];
- cmsghdr align;
- } control;
- memset(control.buf, 0, sizeof(control.buf));
-
- msghdr header = {};
- header.msg_iov = &iov;
- header.msg_iovlen = 1;
- header.msg_control = control.buf;
- header.msg_controllen = sizeof(control.buf);
-
- ssize_t ret = HANDLE_EINTR(recvmsg(handle_, &header, 0));
- if (ret == -1)
- return SetErrnoMessage(error_message);
-
- cmsghdr* control_header = CMSG_FIRSTHDR(&header);
- if (!control_header || control_header->cmsg_len != CMSG_LEN(sizeof(int)) ||
- control_header->cmsg_level != SOL_SOCKET ||
- control_header->cmsg_type != SCM_RIGHTS) {
- *error_message =
- std::string("Invalid data when receiving file descriptor!");
- return false;
- }
- *native = IpcHandle(reinterpret_cast<int*>(CMSG_DATA(control_header))[0]);
- return true;
-}
-
-bool IpcHandle::IsInheritable() const {
- return IsClosedOnExec(handle_);
-}
-
-void IpcHandle::SetInheritable(bool enabled) {
- SetClosedOnExecFlag(handle_, enabled);
-}
-
-bool IpcHandle::IsNonBlocking() const {
- return IsNonBlockingFd(handle_);
-}
-
-void IpcHandle::SetNonBlocking(bool enable) {
- SetNonBlockingFd(handle_, enable);
-}
-
-// static
-IpcHandle::HandleType IpcHandle::NativeForStdio(FILE* file) {
- return fileno(file);
-}
-
-// static
-IpcHandle IpcHandle::CloneFromStdio(FILE* file) {
- fflush(file);
- return { CloneNativeHandle(fileno(file)) };
-}
-
-bool IpcHandle::CloneIntoStdio(FILE* file) {
- if (file != stdout && file != stderr && file != stdin) {
- errno = EINVAL;
- return false;
- }
- if (handle_ < 0) {
- errno = EINVAL;
- return false;
- }
-
- fflush(file);
- int ret = ::dup2(handle_, fileno(file));
- if (ret < 0)
- return false;
-
- return true;
-}
-
-void IpcServiceHandle::Close() {
- this->IpcHandle::Close();
- if (!socket_path_.empty() && socket_path_[0] != '\0') {
- // Remove socket and pid file.
- unlink(socket_path_.c_str());
-
- std::string pid_path = socket_path_;
- pid_path += ".pid";
- unlink(pid_path.c_str());
-
- socket_path_.clear();
- }
-}
-
-IpcServiceHandle::~IpcServiceHandle() {
- Close();
-}
-
-#if !USE_LINUX_NAMESPACE
-// Try to read the pidfile for |address| if it exists, and return the server
-// process id it contains. Return 0 if there is no pid file or if it is
-// malformed. Return -1 and set |*err| if the pid file could not be read
-// (likely a permission issue).
-int ReadPidFile(const std::string& pid_path, std::string* err) {
- // Try to open the pid file.
- FILE* pid_file = fopen(pid_path.c_str(), "r");
- if (!pid_file) {
- if (errno != ENOENT) {
- *err = StringFormat("Cannot open pid file: %s", strerror(errno));
- return -1;
- }
- // There is no pid file.
- return 0;
- }
-
- int server_pid = -1;
- int ret = fscanf(pid_file, "%d", &server_pid);
- (void)fclose(pid_file);
-
- if (ret != 1 || server_pid <= 0) {
- // A malformed pid file, consider server not running and
- // do not report error.
- return 0;
- }
-
- return server_pid;
-}
-
-#endif // !USE_LINUX_NAMESPACE
-
-// static
-IpcServiceHandle IpcServiceHandle::BindTo(StringPiece service_name,
- std::string* error_message) {
- LocalAddress address(service_name);
- if (!address.valid()) {
- *error_message = std::string("Service name too long");
- return {};
- }
-#if !USE_LINUX_NAMESPACE
- // Try to see if another server is already running. Use a .pid file
- // that contains the server's process PID to do that, and check whether
- // it is still alive.
- std::string pid_path = address.pid_path();
- int server_pid = ReadPidFile(pid_path, error_message);
- if (server_pid < 0)
- return {};
-
- if (server_pid > 0 && kill(server_pid, 0) == 0) {
- // The server process is still running.
- *error_message = "already in use";
- return {};
- }
-
- // Create new temporary pid file before doing an atomic filesystem rename.
- int cur_pid = getpid();
- std::string temp_pid_path =
- StringFormat("%s.temp.%d", pid_path.c_str(), cur_pid);
- {
- bool pid_file_error = false;
- FILE* pid_file = fopen(temp_pid_path.c_str(), "w");
- if (!pid_file) {
- pid_file_error = true;
- } else {
- if (fprintf(pid_file, "%d", cur_pid) <= 0)
- pid_file_error = true;
- fclose(pid_file);
- }
- if (pid_file_error) {
- *error_message = "Cannot create temporary pid file: ";
- *error_message += strerror(errno);
- return {};
- }
- }
- // atomically rename the temporary file.
- // Note that EINTR can happen in practice in rename() :-(
- if (HANDLE_EINTR(rename(temp_pid_path.c_str(), pid_path.c_str())) < 0) {
- *error_message = "Cannot rename pid file: ";
- *error_message += strerror(errno);
- return {};
- }
-
- // Remove stale socket if any.
- if (server_pid > 0)
- (void)unlink(address.path());
-
-#endif // !USE_LINUX_NAMESPACE
-
- int server_fd = socket(AF_UNIX, SOCK_STREAM, 0);
- if (server_fd == -1) {
- SetErrnoMessage(error_message);
- return {};
- }
- if (bind(server_fd, address.address(), address.size()) < 0 ||
- listen(server_fd, 1) < 0) {
- CloseFd(server_fd);
- SetErrnoMessage(error_message);
- return {};
- }
- IpcServiceHandle result(server_fd, address.path());
- return result;
-}
-
-IpcHandle IpcServiceHandle::AcceptClient(std::string* error_message) const {
- int client = HANDLE_EINTR(accept(handle_, nullptr, nullptr));
- if (client < 0) {
- SetErrnoMessage(error_message);
- return {};
- }
- return { client };
-}
-
-IpcHandle IpcServiceHandle::AcceptClient(int64_t timeout_ms, bool* did_timeout,
- std::string* error_message) const {
- PosixIoConditionWaiter waiter(handle_, false);
- if (!waiter.Wait(timeout_ms, did_timeout, error_message))
- return {};
-
- int client = HANDLE_EINTR(accept(handle_, nullptr, nullptr));
- if (client < 0) {
- SetErrnoMessage(error_message);
- return {};
- }
- return { client };
-}
-
-// static
-bool IpcServiceHandle::IsBound(StringPiece service_name) {
- LocalAddress address(service_name);
-#if !USE_LINUX_NAMESPACE
- std::string pid_path = address.pid_path();
- std::string error;
- int server_pid = ReadPidFile(pid_path, &error);
- if (server_pid <= 0) {
- // No pid file means there is no server running.
- return false;
- } else if (kill(server_pid, 0) == 0) {
- // Server is still running.
- return true;
- }
-#endif // !USE_LINUX_NAMESPACE
- int server_fd = CreateUnixSocket(false);
- if (server_fd == -1)
- return false;
-
- bool result;
- if (bind(server_fd, address.address(), address.size()) == 0) {
- // fprintf(stderr, "IsBound(): bind() succeeded!\n");
- result = false;
- } else if (errno == EADDRINUSE) {
- // fprintf(stderr, "IsBound(): address in use!\n");
- result = true;
- } else {
- // fprintf(stderr, "IsBound(): bind() returned error: %s\n",
- // strerror(errno));
- result = false;
- }
- CloseFd(server_fd);
- return result;
-}
-
-// static
-IpcHandle IpcServiceHandle::ConnectTo(StringPiece service_name,
- std::string* error_message) {
- LocalAddress address(service_name);
- if (!address.valid()) {
- *error_message = std::string("Service name too long");
- return {};
- }
- int client_fd = CreateUnixSocket(false);
- if (client_fd == -1) {
- SetErrnoMessage(error_message);
- return {};
- }
- if (HANDLE_EINTR(connect(client_fd, address.address(), address.size())) < 0) {
- SetErrnoMessage(error_message);
- CloseFd(client_fd);
- return {};
- }
- return { client_fd };
-}
-
-// static
-IpcHandle IpcServiceHandle::ConnectTo(StringPiece service_name,
- int64_t timeout_ms, bool* did_timeout,
- std::string* error_message) {
- bool did_connect = false;
- *did_timeout = false;
- IpcHandle client = AsyncConnectTo(service_name, &did_connect, error_message);
- if (!client)
- return {};
-
- if (did_connect)
- return client;
-
- PosixIoConditionWaiter waiter(client.native_handle(), false);
- if (!waiter.Wait(timeout_ms, did_timeout, error_message)) {
- return false;
- }
-
- int so_error = GetSocketConnectStatus(client.native_handle());
- if (so_error != 0) {
- SetErrnoMessage(error_message);
- return {};
- }
-
- client.SetNonBlocking(false);
- return client;
-}
-
-// static
-IpcHandle IpcServiceHandle::AsyncConnectTo(StringPiece service_name,
- bool* did_connect,
- std::string* error_message) {
- LocalAddress address(service_name);
- if (!address.valid()) {
- *error_message = std::string("Service name too long");
- return {};
- }
- int client_fd = CreateUnixSocket(true);
- if (client_fd == -1) {
- SetErrnoMessage(error_message);
- return {};
- }
-
- if (!HANDLE_EINTR(connect(client_fd, address.address(), address.size()))) {
- // Connection completed immediately!
- *did_connect = true;
- return { client_fd };
- }
-
- if (errno == EINPROGRESS) {
- // Connection could not be completed immediately.
- *did_connect = false;
- return { client_fd };
- }
-
- SetErrnoMessage(error_message);
- CloseFd(client_fd);
- return {};
-}
-
-// static
-int IpcHandle::GetNativeAsyncConnectStatus(int fd) {
- return GetSocketConnectStatus(fd);
-}
-
-// static
-bool IpcHandle::CreatePipe(IpcHandle* read, IpcHandle* write,
- std::string* error_message) {
- int fds[2] = { -1, -1 };
- if (pipe(fds) != 0)
- return SetErrnoMessage(error_message);
-
- *read = fds[0];
- *write = fds[1];
- return true;
-}
-
-bool IpcHandle::CreateAsyncPipe(IpcHandle* read, IpcHandle* write,
- std::string* error_message) {
- if (!CreatePipe(read, write, error_message))
- return false;
-
- read->SetNonBlocking(true);
- write->SetNonBlocking(true);
- return true;
-}
-
-bool IpcHandle::ReadFull(void* buffer, size_t buffer_size,
- std::string* error_message) const {
- ssize_t count = Read(buffer, buffer_size, error_message);
- if (count < 0)
- return false;
- if (count != static_cast<ssize_t>(buffer_size)) {
- *error_message =
- StringFormat("Received %zu bytes, expected %zu", count, buffer_size);
- return false;
- }
- return true;
-}
-
-bool IpcHandle::WriteFull(const void* buffer, size_t buffer_size,
- std::string* error_message) const {
- ssize_t count = Write(buffer, buffer_size, error_message);
- if (count < 0)
- return false;
- if (count != static_cast<ssize_t>(buffer_size)) {
- *error_message =
- StringFormat("Sent %zu bytes, expected %zu", count, buffer_size);
- return false;
- }
- return true;
-}
-
-std::string IpcHandle::display() const {
- return StringFormat("fd=%d", handle_);
-}
diff --git a/src/ipc_handle-win32.cc b/src/ipc_handle-win32.cc
deleted file mode 100644
index a28f4a6..0000000
--- a/src/ipc_handle-win32.cc
+++ /dev/null
@@ -1,498 +0,0 @@
-// Copyright 2023 Google Inc. All Rights Reserved.
-//
-// Licensed under the Apache License, Version 2.0 (the "License");
-// you may not use this file except in compliance with the License.
-// You may obtain a copy of the License at
-//
-// http://www.apache.org/licenses/LICENSE-2.0
-//
-// Unless required by applicable law or agreed to in writing, software
-// distributed under the License is distributed on an "AS IS" BASIS,
-// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-// See the License for the specific language governing permissions and
-// limitations under the License.
-
-// Must appear before <stdio.h> which includes <fileapi.h> which will complain
-// of "No Target Architecture" for some unknown reason (!?)
-#include <fcntl.h>
-#include <stdio.h>
-#include <windows.h>
-
-// Must appear after <windows.h>
-#include <io.h>
-#include <lmcons.h> // required for UNLEN
-
-#include "ipc_handle.h"
-#include "util.h" // For StringFormat() and GetLastErrorString()
-
-namespace {
-
-std::string Win32ErrorMessage(const char* prefix, LONG error) {
- return StringFormat("%s: %s", prefix, GetLastErrorString(error).c_str());
-}
-
-std::string Win32ErrorMessage(const char* prefix) {
- return Win32ErrorMessage(prefix, GetLastError());
-}
-
-std::wstring CurrentUserName() {
- wchar_t user[UNLEN + 1];
- DWORD count = UNLEN + 1;
- if (!GetUserNameW(user, &count) || count < 2) {
- return std::wstring(L"unknown_user");
- }
- // count includes the terminating zero.
- return std::wstring(user, count - 1);
-}
-
-std::wstring GetNamedPipePath(StringPiece service_name) {
- std::wstring result = L"\\\\.\\pipe\\basic_ipc-";
- result += CurrentUserName();
- result += L'-';
- result += ConvertToUnicodeString(service_name.str_, service_name.len_);
- return result;
-}
-
-HANDLE CreateNamedPipeHandle(const std::wstring& pipe_path, bool async,
- std::string* error_message) {
- HANDLE handle = CreateNamedPipeW(
- pipe_path.data(),
- PIPE_ACCESS_DUPLEX | (async ? FILE_FLAG_OVERLAPPED : 0), // bidirectional
- PIPE_TYPE_BYTE | // write bytes, not messages
- PIPE_READMODE_BYTE | // read bytes, not messages
- PIPE_WAIT | PIPE_REJECT_REMOTE_CLIENTS, // local only
- 1, // max. instances
- 4096, // out buffer size
- 4096, // in buffer size
- 0, // default time out
- nullptr); // default security attribute
- if (handle == INVALID_HANDLE_VALUE)
- *error_message = Win32ErrorMessage("Could not create named pipe");
-
- return handle;
-}
-
-HANDLE ConnectToNamedPipe(const std::wstring& pipe_path, bool async,
- std::string* error_message) {
- HANDLE handle = CreateFileW(pipe_path.data(), GENERIC_READ | GENERIC_WRITE,
- 0, // no sharing
- nullptr, // default security attributes
- CREATE_NEW, // fail if it already exists
- async ? FILE_FLAG_OVERLAPPED : 0,
- nullptr); // no template file
- if (handle == INVALID_HANDLE_VALUE)
- *error_message = Win32ErrorMessage("Coult not connect pipe");
-
- return handle;
-}
-
-std::wstring GetUniqueNamedPipePath() {
- // Do not use CreatePipe because these are documented as only
- // unidirectional and synchronous only. Instead create a
- // named pipe with a unique name. This matches the current
- // implementation in Windows, though it may change in future
- // releases of the platform, see:
- // https://stackoverflow.com/questions/60645/overlapped-i-o-on-anonymous-pipe/51448441#51448441
- static LONG serial_number = 1;
- wchar_t pipe_path[64];
- swprintf_s(pipe_path, 64, L"\\\\.\\pipe\\IpcHandle.%08x.%08x",
- GetCurrentProcessId(), InterlockedIncrement(&serial_number));
- return std::wstring(pipe_path);
-}
-
-} // namespace
-
-// INVALID_HANDLE_VALUE expands to an expression that includes
-// a reinterpret_cast<>, which is why it cannot be used to
-// define a constexpr static member.
-
-// static
-const HANDLE IpcHandle::kInvalid = INVALID_HANDLE_VALUE;
-
-// static
-void IpcHandle::Close() {
- if (handle_ != kInvalid) {
- CloseHandle(handle_);
- handle_ = kInvalid;
- }
-}
-
-HANDLE IpcHandle::ReleaseNativeHandle() {
- HANDLE result = handle_;
- handle_ = INVALID_HANDLE_VALUE;
- return result;
-}
-
-bool IpcHandle::IsInheritable() const {
- DWORD flags;
- if (!GetHandleInformation(handle_, &flags))
- return false;
- return (flags & HANDLE_FLAG_INHERIT) != 0;
-}
-
-void IpcHandle::SetInheritable(bool enabled) {
- if (!SetHandleInformation(handle_, HANDLE_FLAG_INHERIT,
- enabled ? HANDLE_FLAG_INHERIT : 0)) {
- Win32Fatal("SetHandleInformation");
- }
-}
-
-// static
-IpcHandle::HandleType IpcHandle::CloneNativeHandle(HandleType handle,
- bool inherited) {
- HANDLE process = GetCurrentProcess();
- HANDLE peer = INVALID_HANDLE_VALUE;
- if (!DuplicateHandle(process, handle, process, &peer, 0, inherited,
- DUPLICATE_SAME_ACCESS)) {
- return INVALID_HANDLE_VALUE;
- }
- return peer;
-}
-
-// static
-IpcHandle::HandleType IpcHandle::NativeForStdio(FILE* file) {
- int fd = _fileno(file);
- intptr_t int_handle = _get_osfhandle(fd);
- if (int_handle < 0)
- return INVALID_HANDLE_VALUE;
- return reinterpret_cast<HANDLE>(int_handle);
-}
-
-// static
-IpcHandle IpcHandle::CloneFromStdio(FILE* file) {
- return { CloneNativeHandle(NativeForStdio(file)) };
-}
-
-bool IpcHandle::CloneIntoStdio(FILE* file) {
- HANDLE new_handle = CloneNativeHandle(handle_);
- // Ensure low-level Win32 operations will write to the new handle.
- // by calling SetStdHandle.
- DWORD std_index = 0;
- int std_fd;
- int open_flags;
- if (file == stdout) {
- std_index = STD_OUTPUT_HANDLE;
- std_fd = 1;
- open_flags = _O_WRONLY | _fmode;
- } else if (file == stderr) {
- std_index = STD_ERROR_HANDLE;
- std_fd = 2;
- open_flags = _O_WRONLY | _fmode;
- } else if (file == stdin) {
- std_index = STD_INPUT_HANDLE;
- std_fd = 0;
- open_flags = _O_RDONLY | _fmode;
- } else {
- errno = EINVAL;
- return false;
- }
- SetStdHandle(std_index, new_handle);
- int new_fd =
- ::_open_osfhandle(reinterpret_cast<intptr_t>(new_handle), open_flags);
- ::_dup2(new_fd, std_fd);
- ::close(new_fd);
- return true;
-}
-
-ssize_t IpcHandle::Read(void* buff, size_t buffer_size,
- std::string* error_message) const {
- auto* buffer = static_cast<char*>(buff);
- DWORD count = 0;
- if (!ReadFile(handle_, buffer, buffer_size, &count, nullptr)) {
- DWORD error = GetLastError();
- if (error == ERROR_BROKEN_PIPE) // Pipe was closed.
- return 0;
- *error_message = Win32ErrorMessage("Could not read from pipe");
- return -1;
- }
- return static_cast<ssize_t>(count);
-}
-
-ssize_t IpcHandle::Write(const void* buff, size_t buffer_size,
- std::string* error_message) const {
- const auto* buffer = static_cast<const char*>(buff);
- DWORD count = 0;
- if (!WriteFile(handle_, buffer, buffer_size, &count, nullptr)) {
- LONG error = GetLastError();
- if (error == ERROR_BROKEN_PIPE) // Pipe was closed.
- return 0;
- *error_message = Win32ErrorMessage("Could not write to pipe", error);
- return -1;
- }
- return static_cast<ssize_t>(count);
-}
-
-struct HandleMessage {
- HANDLE process_id;
- HANDLE handle;
-};
-
-bool IpcHandle::SendNativeHandle(HandleType native,
- std::string* error_message) const {
- // Send a message that contains the current process ID, and the handle
- // through the named pipe. The ReceiveNativeHandle() method will use them
- // to call DuplicateHandle(). Note that this does not work for console
- // input/output handles (the handles can be duplicated, but trying to use them
- // from a different process returns an error), so in addition to using this
- // method, the sender should use a specialized class to redirect stdout/stderr
- // using new named pipe handles. See the Win32StdOutputBridge class.
- HandleMessage msg;
- msg.process_id =
- OpenProcess(PROCESS_ALL_ACCESS, FALSE, GetCurrentProcessId());
- msg.handle = native;
-
- ssize_t count = Write(&msg, sizeof(msg), error_message);
- if (count < 0)
- return false;
- if (count != static_cast<ssize_t>(sizeof(msg))) {
- *error_message = "Error when sending handle";
- return false;
- }
- return true;
-}
-
-bool IpcHandle::ReceiveNativeHandle(IpcHandle* handle,
- std::string* error_message) const {
- HandleMessage msg;
- ssize_t count = Read(&msg, sizeof(msg), error_message);
- if (count < 0)
- return false;
- if (count != static_cast<ssize_t>(sizeof(msg))) {
- *error_message = "Error when receiving handle";
- return false;
- }
-
- // Create a duplicate of the source handle in the current process.
- HANDLE native = INVALID_HANDLE_VALUE;
- if (!DuplicateHandle(msg.process_id, // source process
- msg.handle, // source handle
- GetCurrentProcess(), // target process
- &native, // target handle pointer
- 0, // ignored with DUPLICATE_SAME_ACCESS
- FALSE, // not inheritable
- DUPLICATE_SAME_ACCESS)) {
- *error_message = Win32ErrorMessage("Could not duplicate handle");
- return false;
- }
- *handle = IpcHandle(native);
- return true;
-}
-
-IpcServiceHandle::~IpcServiceHandle() {
- Close();
-}
-
-void IpcServiceHandle::Close() {
- this->IpcHandle::Close();
-}
-
-// static
-IpcServiceHandle IpcServiceHandle::BindTo(StringPiece service_name,
- std::string* error_message) {
- return IpcServiceHandle(CreateNamedPipeHandle(GetNamedPipePath(service_name),
- true, error_message));
-}
-
-IpcHandle IpcServiceHandle::AcceptClient(std::string* error_message) const {
- // Duplicate the handle to return it into a new IpcHandle. This
- // will allow the caller to communicate with the client, and the next
- // ConnectNamedPipe() call will wait for another client instead.
- HANDLE peer = IpcHandle::CloneNativeHandle(handle_);
- if (peer == INVALID_HANDLE_VALUE) {
- DWORD error = GetLastError();
- *error_message =
- Win32ErrorMessage("Could not duplicate client pipe handle", error);
- return {};
- }
- if (!ConnectNamedPipe(peer, NULL)) {
- DWORD error = GetLastError();
- // ERROR_PIPE_CONNECTED is not an actual error and means that
- // a client is already connected, which happens during unit-testing.
- if (error != ERROR_PIPE_CONNECTED) {
- ::CloseHandle(peer);
- *error_message =
- Win32ErrorMessage("Could not accept named pipe client", error);
- return {};
- }
- }
- return IpcHandle(peer);
-}
-
-IpcHandle IpcServiceHandle::AcceptClient(int64_t timeout_ms, bool* did_timeout,
- std::string* error_message) const {
- *did_timeout = false;
- // Duplicate the handle to return it into a new IpcHandle. This
- // will allow the caller to communicate with the client, and the next
- // ConnectNamedPipe() call will wait for another client instead.
- HANDLE peer = IpcHandle::CloneNativeHandle(handle_);
- if (peer == INVALID_HANDLE_VALUE) {
- DWORD error = GetLastError();
- *error_message =
- Win32ErrorMessage("Could not duplicate client pipe handle", error);
- return {};
- }
-
- HANDLE result = INVALID_HANDLE_VALUE;
- OVERLAPPED overlapped = {};
- overlapped.hEvent = ::CreateEvent(NULL, TRUE, FALSE, NULL);
-
- do {
- if (ConnectNamedPipe(peer, &overlapped)) {
- // Should not happen with overlapped i/o, but just in case.
- result = peer;
- peer = INVALID_HANDLE_VALUE;
- break;
- }
-
- DWORD error = GetLastError();
- if (error == ERROR_PIPE_CONNECTED) {
- // Immediate connection, success!
- result = peer;
- peer = INVALID_HANDLE_VALUE;
- break;
- }
-
- if (error != ERROR_IO_PENDING) {
- // Something unexpected happened here!
- *error_message =
- Win32ErrorMessage("Could not accept named pipe client", error);
- break;
- }
-
- // Wait for connection.
- DWORD timeout =
- (timeout_ms < 0) ? INFINITE : static_cast<DWORD>(timeout_ms);
- DWORD ret = WaitForSingleObject(overlapped.hEvent, timeout);
-
- if (ret == WAIT_TIMEOUT) {
- *did_timeout = true;
- *error_message = "timed out";
- break;
- }
-
- if (ret != WAIT_OBJECT_0) {
- Win32Fatal("WaitForSingleObject");
- }
-
- // Success!
- result = peer;
- peer = INVALID_HANDLE_VALUE;
-
- } while (0);
-
- ::CloseHandle(overlapped.hEvent);
- if (peer != INVALID_HANDLE_VALUE)
- ::CloseHandle(peer);
-
- return { result };
-}
-
-// static
-bool IpcServiceHandle::IsBound(StringPiece service_name) {
- std::wstring pipe_path = GetNamedPipePath(service_name);
- if (WaitNamedPipeW(pipe_path.data(), 1))
- return true;
-
- DWORD error = GetLastError();
- if (error == ERROR_SEM_TIMEOUT)
- return true;
-
- return false;
-}
-
-// static
-IpcHandle IpcServiceHandle::ConnectTo(StringPiece service_name,
- std::string* error_message) {
-#if 0
- // For some reason, the line below generates code that crashes
- // at runtime when compiled with the Mingw64 toolchain, so use
- // the equivalent below.
- return { ConnectToNamedPipe(GetNamedPipePath(service_name), true, error_message) };
-#else
- std::wstring pipe_path = GetNamedPipePath(service_name);
- HANDLE handle = ConnectToNamedPipe(pipe_path, true, error_message);
- return { handle };
-#endif
-}
-
-// static
-IpcHandle IpcServiceHandle::ConnectTo(StringPiece service_name,
- int64_t timeout_ms, bool* did_timeout,
- std::string* error_message) {
- // On Windows, connecting to a named pipe either succeeds or fails immediately
- *did_timeout = (timeout_ms > 0);
- return ConnectTo(service_name, error_message);
-}
-
-// static
-IpcHandle IpcServiceHandle::AsyncConnectTo(StringPiece service_name,
- bool* did_connect,
- std::string* error_message) {
- IpcHandle result =
- ConnectToNamedPipe(GetNamedPipePath(service_name), true, error_message);
- if (result) {
- // On Win32, connecting to a named pipe always fails or succeeds
- // immediately.
- *did_connect = true;
- }
- return result;
-}
-
-static bool CreatePipeInternal(IpcHandle* read, IpcHandle* write, bool async,
- std::string* error_message) {
- std::wstring pipe_path = GetUniqueNamedPipePath();
- *read = IpcHandle(
- CreateNamedPipeHandle(std::wstring(pipe_path), async, error_message));
- if (!*read)
- return false;
-
- *write = IpcHandle(ConnectToNamedPipe(pipe_path, async, error_message));
- if (!*write) {
- read->Close();
- return false;
- }
- return true;
-}
-
-// static
-bool IpcHandle::CreatePipe(IpcHandle* read, IpcHandle* write,
- std::string* error_message) {
- return CreatePipeInternal(read, write, false, error_message);
-}
-
-// static
-bool IpcHandle::CreateAsyncPipe(IpcHandle* read, IpcHandle* write,
- std::string* error_message) {
- return CreatePipeInternal(read, write, true, error_message);
-}
-
-bool IpcHandle::ReadFull(void* buffer, size_t buffer_size,
- std::string* error_message) const {
- ssize_t count = Read(buffer, buffer_size, error_message);
- if (count < 0)
- return false;
- if (count != static_cast<ssize_t>(buffer_size)) {
- *error_message = StringFormat("Received %u bytes, expected %u",
- static_cast<unsigned>(count),
- static_cast<unsigned>(buffer_size));
- return false;
- }
- return true;
-}
-
-bool IpcHandle::WriteFull(const void* buffer, size_t buffer_size,
- std::string* error_message) const {
- ssize_t count = Write(buffer, buffer_size, error_message);
- if (count < 0)
- return false;
- if (count != static_cast<ssize_t>(buffer_size)) {
- *error_message =
- StringFormat("Sent %u bytes, expected %u", static_cast<unsigned>(count),
- static_cast<unsigned>(buffer_size));
- }
- return true;
-}
-
-std::string IpcHandle::display() const {
- return StringFormat("handle=%p", handle_);
-}
diff --git a/src/ipc_handle.h b/src/ipc_handle.h
deleted file mode 100644
index f58f7cd..0000000
--- a/src/ipc_handle.h
+++ /dev/null
@@ -1,295 +0,0 @@
-// Copyright 2023 Google Inc. All Rights Reserved.
-//
-// Licensed under the Apache License, Version 2.0 (the "License");
-// you may not use this file except in compliance with the License.
-// You may obtain a copy of the License at
-//
-// http://www.apache.org/licenses/LICENSE-2.0
-//
-// Unless required by applicable law or agreed to in writing, software
-// distributed under the License is distributed on an "AS IS" BASIS,
-// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-// See the License for the specific language governing permissions and
-// limitations under the License.
-
-#ifndef NINJA_IPC_HANDLE_H_
-#define NINJA_IPC_HANDLE_H_
-
-#include <stddef.h>
-
-#include <string>
-#include <string_view>
-
-#include "string_piece.h"
-
-#ifdef _WIN32
-#include <basetsd.h>
-#include <windows.h>
-using ssize_t = SSIZE_T;
-#else
-#include <signal.h>
-#endif
-
-/// Support for basic inter-process communication.
-///
-/// The IpcHandle models a scoped pipe handle (Win32) or unix socket file
-/// descriptor (Unix) and provides method to read/write data through
-/// them, as well as passing other handles/file descriptors.
-///
-/// For Win32, all handles are created with FILE_FLAG_OVERLAPPED and
-/// support overlapped operations. For Posix, the non-blocking flag of
-/// a descriptor can be checked and changed with IsNonBlocking() and
-/// SetNonBlocking() methods.
-///
-
-/// Wrapper for a local Unix socket or Win32 named pipe handle
-/// used for inter-process communication.
-class IpcHandle {
- public:
-#ifdef _WIN32
- using HandleType = HANDLE;
- static const HandleType kInvalid;
-#else
- using HandleType = int;
- static constexpr int kInvalid = -1;
-#endif
-
- IpcHandle() = default;
- IpcHandle(HandleType handle) : handle_(handle) {}
-
- /// Disallow copy operations.
- IpcHandle(const IpcHandle&) = delete;
- IpcHandle& operator=(const IpcHandle&) = delete;
-
- /// Allow move operations.
- IpcHandle(IpcHandle&& other) noexcept : handle_(other.handle_) {
- other.handle_ = kInvalid;
- }
- IpcHandle& operator=(IpcHandle&& other) noexcept {
- if (this != &other) {
- this->~IpcHandle();
- new (this) IpcHandle(std::move(other));
- }
- return *this;
- }
-
- ~IpcHandle() { Close(); }
-
- /// bool conversion allows easy checks for valid handles with:
- /// if (!handle) { ... handle is invalid };
- explicit operator bool() const noexcept { return handle_ != kInvalid; }
-
- /// Try to read |buffer_size| bytes into |buffer|. On success
- /// return the number of bytes actually read into the buffer,
- /// which will be 0 if the connection was closed by the peer.
- /// On failure, return -1 and sets |*error_message|.
- ssize_t Read(void* buffer, size_t buffer_size,
- std::string* error_message) const;
-
- /// Read |buffer_size| bytes exactly into |buffer|. On success
- /// return true. On failure, return false and set |*error_message|.
- bool ReadFull(void* buffer, size_t buffer_size,
- std::string* error_message) const;
-
- /// Try to write |buffer_size| bytes form |buffer|. On success
- /// return the number of bytes actually written to the handle,
- /// which will be 0 if the connection was called by the peer.
- /// On failure, return -1 and sets |*error_message|.
- ssize_t Write(const void* buffer, size_t buffer_size,
- std::string* error_message) const;
-
- /// Write |buffer_size| bytes exactly from |buffer|. On success
- /// return true. On failure, return false and set |*error_message|.
- bool WriteFull(const void* buffer, size_t buffer_size,
- std::string* error_message) const;
-
- /// Send a |native| handle to the peer. On success return true.
- /// On failure, return false and sets |*error_message|.
- bool SendNativeHandle(HandleType native, std::string* error_message) const;
-
- /// Receive a |native| handle from the peer. On success return true
- /// and sets |*handle|. On failure, return false and sets |*error_message|.
- bool ReceiveNativeHandle(IpcHandle* handle, std::string* error_message) const;
-
- /// Return true if the handle is inheritable (on Win32), or is _not_ closed
- /// on exec (on Posix).
- bool IsInheritable() const;
-
- /// Reset the inheritable / non-O_CLOEXEC flag for this handle.
- void SetInheritable(bool enable);
-
-#ifndef _WIN32
- /// Return true if the file descriptor is in non-blocking mode.
- bool IsNonBlocking() const;
-
- /// Reset the O_NONBLOCK flag for the corresponding file descriptor.
- void SetNonBlocking(bool enable);
-
- /// Return the current status of an asynchronous AsyncClientTo() connection.
- /// This only makes sense on Posix, and this function should only be called
- /// after a writable event was detected on the native handle with select()
- /// or one of its variants. It returns an errno value, which will be 0 if
- /// the connection succeeded, EAGAIN or EINPROGRESS in case of a spurious
- /// select() wakeup, or any other error value in case of failed connection,
- /// or using an invalid handle.
- static int GetNativeAsyncConnectStatus(int fd);
-#endif
-
- /// Create anonymous bi-directional pipe. On success return true and
- /// sets |*read| and |*write|. On failure, return false and sets
- /// |*error_message|.
- static bool CreatePipe(IpcHandle* read, IpcHandle* write,
- std::string* error_message);
-
- /// Same as CreatePipe() but returns handles that can be used for asychronous
- /// operations (i.e. O_NONBLOCK on Posix, and FILE_FLAG_OVERLAPPED on Win32).
- static bool CreateAsyncPipe(IpcHandle* read, IpcHandle* write,
- std::string* error_message);
-
- /// Close the handle, making it invalid.
- void Close();
-
- /// Clone a native handle.
- static HandleType CloneNativeHandle(HandleType handle,
- bool inherited = false);
-
- /// Clone existing instance. Result is not inheritable on Win32, and has
- /// O_CLOEXEC on Posix.
- IpcHandle Clone() { return { CloneNativeHandle(handle_) }; };
-
- /// Flush |file| then clone its handle. Result is not inheritable on Win32,
- /// and has O_CLOEXEC on Posix.
- static IpcHandle CloneFromStdio(FILE* file);
-
- /// Clone the handle into an stdio FILE instance.
- /// |file| can only be one of stdout, stderr, or stdin.
- /// On success return true, on failure, set errno (even on Win32)
- /// then return false.
- bool CloneIntoStdio(FILE* file);
-
- /// Return the native handle value for an stdio stream.
- static HandleType NativeForStdio(FILE* file);
-
- /// Return native handle value.
- HandleType native_handle() const { return handle_; }
-
- /// Release the native handle, transferring ownership to the caller.
- HandleType ReleaseNativeHandle();
-
- /// Return user visible string for this handle.
- std::string display() const;
-
- protected:
- HandleType handle_ = kInvalid;
-};
-
-/// Models an IpcHandle used to bind to specific service.
-/// Only one process can bind to a specific named service at
-/// a time on a given machine.
-class IpcServiceHandle : public IpcHandle {
- public:
- IpcServiceHandle() = default;
- ~IpcServiceHandle();
-
- IpcServiceHandle(IpcServiceHandle&&) noexcept = default;
- IpcServiceHandle& operator=(IpcServiceHandle&&) noexcept = default;
-
- /// Create a server handle for |service_name|, which is an arbitrary name
- /// used to identify a specific global service, which can have only one
- /// serving instance per (machine, user) combination.
- ///
- /// On success, return a valid IpcHandle, that can be used with
- /// AcceptClient(). On failure, return an invalid handle, and sets
- /// |*error_message|.
- ///
- /// This will fail if another server is already running with the
- /// same name on the current machine (for the same user). Closing
- /// the service handle will release the corresponding socket or
- /// named pipe immediately, and of course the destructor closes
- /// automatically.
- ///
- /// Note that the implementation should be resilient to program
- /// crashes as well, i.e. on Linux and Win32, it uses kernel features
- /// that ensure proper socket/pipe cleanup on process exit. On
- /// other Unix systems, a Unix-domain socket and associated PID file
- /// are used to detect stale socket files and remove them properly.
- static IpcServiceHandle BindTo(StringPiece service_name,
- std::string* error_message);
-
- /// Return true if a given service is already bound. This is racy by
- /// definition, but useful during unit-tests.
- static bool IsBound(StringPiece service_name);
-
- /// Accept one client connection. This is only valid for instances
- /// returned from BindTo().
- IpcHandle AcceptClient(std::string* error_message) const;
-
- /// Accept one client connection, with a timeout. On success, return a valid
- /// IpcHandle value. On failure, set |*did_timeout| to true if the timeout
- /// occured, and set |*error_message| to an error message.
- IpcHandle AcceptClient(int64_t timeout_ms, bool* did_timeout,
- std::string* error_message) const;
-
- /// Connect to the server implementing |service_name|.
- /// On success, return valid IpcHandle. On failure, set |*error_message|
- /// then return an invalid value.
- static IpcHandle ConnectTo(StringPiece service_name,
- std::string* error_message);
-
- /// Connect to the server implementing |service_name|, with a timeout
- /// in milliseconds. On success, return a valid IpcHandle. On error or
- /// timeout, set |*error_message| and |*did_timeout| before returning
- /// an invalid value.
- static IpcHandle ConnectTo(StringPiece service_name, int64_t timeout_ms,
- bool* did_timeout, std::string* error_message);
-
- /// Connect asychronously to local |service_name|. On success, set
- /// |*did_connect| and return a valid handle. On failure, set |*error_message|
- /// and return an invalid handle.
- ///
- /// Note that the connection can happen immediately, in which case
- /// |*did_connect| will be set to true.
- ///
- /// On Win32, the returned handle has FILE_FLAG_OVERLAPPED and connection
- /// always succeeds.
- ///
- /// On Posix, the returned handle is non-blocking, and the caller should
- /// wait for a writable event on it (using select() or one of its variants)
- /// then use GetNativeAsyncConnectStatus() on the native_handle() value.
- static IpcHandle AsyncConnectTo(StringPiece service_name, bool* did_connect,
- std::string* error_message);
-
- /// Close the handle, make it invalid and remove service socket.
- void Close();
-
- private:
-#ifdef _WIN32
- IpcServiceHandle(IpcHandle::HandleType handle) : IpcHandle(handle) {}
-#else
- IpcServiceHandle(IpcHandle::HandleType handle, const std::string& path)
- : IpcHandle(handle), socket_path_(path) {}
-
- std::string socket_path_;
-#endif
-};
-
-#ifndef _WIN32
-/// Helper class to temporarily disable SIGPIPE, which halts
-/// the current process by default on Posix. These happen when IPC
-/// pipes are broken by the client.
-class SigPipeIgnore {
- public:
- SigPipeIgnore() {
- struct sigaction new_handler = {};
- new_handler.sa_handler = SIG_IGN;
- sigaction(SIGPIPE, &new_handler, &prev_handler_);
- }
-
- ~SigPipeIgnore() { sigaction(SIGPIPE, &prev_handler_, nullptr); }
-
- private:
- struct sigaction prev_handler_;
-};
-#endif // !_WIN32
-
-#endif // NINJA_IPC_HANDLE_H_
diff --git a/src/ipc_handle_test.cc b/src/ipc_handle_test.cc
deleted file mode 100644
index 47412e2..0000000
--- a/src/ipc_handle_test.cc
+++ /dev/null
@@ -1,307 +0,0 @@
-// Copyright 2023 Google Inc. All Rights Reserved.
-//
-// Licensed under the Apache License, Version 2.0 (the "License");
-// you may not use this file except in compliance with the License.
-// You may obtain a copy of the License at
-//
-// http://www.apache.org/licenses/LICENSE-2.0
-//
-// Unless required by applicable law or agreed to in writing, software
-// distributed under the License is distributed on an "AS IS" BASIS,
-// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-// See the License for the specific language governing permissions and
-// limitations under the License.
-
-#include "ipc_handle.h"
-
-#include <stdio.h>
-#include <string.h>
-
-#include "test.h"
-
-#ifdef _WIN32
-#include <windows.h>
-#else
-#include <fcntl.h>
-#include <unistd.h>
-#endif
-
-namespace {
-
-IpcHandle::HandleType CreateTestNativeHandle() {
-#ifdef _WIN32
- return CreateFileW(L"NUL", GENERIC_READ | GENERIC_WRITE, 0, nullptr,
- OPEN_EXISTING, 0, NULL);
-#else
- return open("/dev/null", O_RDWR);
-#endif
-}
-
-IpcHandle CreateTestHandle() {
- return { CreateTestNativeHandle() };
-}
-
-// Create a pipe for testing. On success return true and
-// set |*read| and |*write| to be the read and write ends
-// of the pipe. Note that the pipe is unidirectional due
-// to portability with Windows.
-bool CreateTestPipe(IpcHandle* read, IpcHandle* write) {
- std::string error;
- if (!IpcHandle::CreatePipe(read, write, &error)) {
- fprintf(stderr, "ERROR: when creating pipe: %s\n", error.c_str());
- return false;
- }
- return true;
-}
-
-} // namespace
-
-TEST(IpcHandle, Constructor) {
- // Default constructor makes invalid handle
- IpcHandle empty;
- EXPECT_FALSE(empty);
- EXPECT_EQ(IpcHandle::kInvalid, empty.native_handle());
-
- // Constructor gets test native handle
- IpcHandle::HandleType test_native_handle = CreateTestNativeHandle();
- IpcHandle test_handle(test_native_handle);
- EXPECT_TRUE(test_handle);
- EXPECT_EQ(test_native_handle, test_handle.native_handle());
-
- // Move constructor works.
- IpcHandle test_handle2 = std::move(test_handle);
- EXPECT_TRUE(test_handle2);
- EXPECT_EQ(test_native_handle, test_handle2.native_handle());
- EXPECT_FALSE(test_handle);
- EXPECT_EQ(IpcHandle::kInvalid, test_handle.native_handle());
-}
-
-TEST(IpcHandle, Close) {
- IpcHandle test_handle = CreateTestHandle();
- EXPECT_TRUE(test_handle);
- EXPECT_NE(IpcHandle::kInvalid, test_handle.native_handle());
-
- test_handle.Close();
- EXPECT_FALSE(test_handle);
- EXPECT_EQ(IpcHandle::kInvalid, test_handle.native_handle());
-
- // Ensure closing a closed handle doesn't crash.
- test_handle.Close();
- EXPECT_FALSE(test_handle);
- EXPECT_EQ(IpcHandle::kInvalid, test_handle.native_handle());
-}
-
-TEST(IpcHandle, ReadWrite) {
- const char kInputData[] = "Hello World!";
- const size_t kInputDataSize = sizeof(kInputData); // includes terminating \0
- IpcHandle pipe_read;
- IpcHandle pipe_write;
- ASSERT_TRUE(CreateTestPipe(&pipe_read, &pipe_write));
-
- std::string error_message;
- ssize_t count = pipe_write.Write(kInputData, kInputDataSize, &error_message);
- EXPECT_EQ(static_cast<ssize_t>(kInputDataSize), count);
- EXPECT_TRUE(error_message.empty());
-
- char data[kInputDataSize] = {};
- count = pipe_read.Read(data, sizeof(data), &error_message);
- EXPECT_EQ(static_cast<ssize_t>(kInputDataSize), count);
- EXPECT_TRUE(error_message.empty());
-
- // Check transfered content.
- EXPECT_TRUE(!memcmp(data, kInputData, kInputDataSize));
-
- // Close the write pipe, trying to read should result in zero
- // being returned without an error (indicating closed pipe).
- pipe_write.Close();
- count = pipe_read.Read(data, kInputDataSize, &error_message);
- EXPECT_EQ(0, count);
- EXPECT_TRUE(error_message.empty());
-}
-
-TEST(IpcHandle, Clone) {
- const char kInputData[] = "Hello World!";
- const size_t kInputDataSize = sizeof(kInputData); // includes terminating \0
- IpcHandle pipe_read;
- IpcHandle pipe_write;
- ASSERT_TRUE(CreateTestPipe(&pipe_read, &pipe_write));
-
- // Clone pipe_read, then close it.
- IpcHandle pipe_read2 = pipe_read.Clone();
- pipe_read.Close();
-
- std::string error_message;
- ssize_t count = pipe_write.Write(kInputData, kInputDataSize, &error_message);
- EXPECT_EQ(static_cast<ssize_t>(kInputDataSize), count);
- EXPECT_TRUE(error_message.empty());
-
- char data[kInputDataSize] = {};
- count = pipe_read2.Read(data, sizeof(data), &error_message);
- EXPECT_EQ(static_cast<ssize_t>(kInputDataSize), count);
- EXPECT_TRUE(error_message.empty());
-
- // Check transfered content.
- EXPECT_TRUE(!memcmp(data, kInputData, kInputDataSize));
-
- // Close the write pipe, trying to read should result in zero
- // being returned without an error (indicating closed pipe).
- pipe_write.Close();
- count = pipe_read2.Read(data, kInputDataSize, &error_message);
- EXPECT_EQ(0, count);
- EXPECT_TRUE(error_message.empty());
-}
-
-TEST(IpcHandle, ReadWriteFull) {
- const char kInputData[] = "Hello World!";
- const size_t kInputDataSize = sizeof(kInputData); // includes terminating \0
- IpcHandle pipe_read;
- IpcHandle pipe_write;
- ASSERT_TRUE(CreateTestPipe(&pipe_read, &pipe_write));
-
- std::string error_message;
- EXPECT_TRUE(pipe_write.WriteFull(kInputData, kInputDataSize, &error_message));
- EXPECT_TRUE(error_message.empty());
-
- char data[kInputDataSize] = {};
- EXPECT_TRUE(pipe_read.ReadFull(data, kInputDataSize, &error_message));
- EXPECT_TRUE(error_message.empty());
-
- // Check transfered content.
- EXPECT_TRUE(!memcmp(data, kInputData, kInputDataSize));
-
- // Close the write pipe, trying to read should result in an error.
- pipe_write.Close();
- EXPECT_FALSE(pipe_read.ReadFull(data, kInputDataSize, &error_message));
- EXPECT_FALSE(error_message.empty());
-}
-
-TEST(IpcHandle, BindConnectAndAccept) {
- std::string error_message;
- StringPiece service = "test_service";
-
- ASSERT_FALSE(IpcServiceHandle::IsBound(service));
-
- // Tring to connect to a service without a server should fail.
- IpcHandle no_client = IpcServiceHandle::ConnectTo(service, &error_message);
- EXPECT_FALSE(no_client);
- EXPECT_FALSE(error_message.empty());
-
- ASSERT_FALSE(IpcServiceHandle::IsBound(service));
-
- // Create server
- IpcServiceHandle server = IpcServiceHandle::BindTo(service, &error_message);
- ASSERT_TRUE(server);
- EXPECT_FALSE(error_message.empty());
- error_message.clear();
-
- ASSERT_TRUE(IpcServiceHandle::IsBound(service));
-
- // Trying to create a secondary server for the same service should fail.
- IpcServiceHandle no_server =
- IpcServiceHandle::BindTo(service, &error_message);
- ASSERT_FALSE(no_server);
- EXPECT_FALSE(error_message.empty());
- error_message.clear();
-
- // Connecto the server, and receive a peer handle.
- IpcHandle client = IpcServiceHandle::ConnectTo(service, &error_message);
- EXPECT_TRUE(client);
- EXPECT_TRUE(error_message.empty());
-
- IpcHandle peer = server.AcceptClient(&error_message);
- EXPECT_TRUE(peer);
- EXPECT_TRUE(error_message.empty());
-
- // Send data from the client to the peer.
- const char kInput[] = "sending data";
- const size_t kInputSize = sizeof(kInput);
- EXPECT_TRUE(client.WriteFull(kInput, kInputSize, &error_message));
- EXPECT_TRUE(error_message.empty());
-
- char output[kInputSize] = {};
- EXPECT_TRUE(peer.ReadFull(output, sizeof(output), &error_message));
- EXPECT_TRUE(error_message.empty());
-
- EXPECT_TRUE(!memcmp(output, kInput, kInputSize));
-
- // Close all handles and verify that IsBound() returns false.
- // Note that on Unix, only closing the server handle is necessary for this,
- // but the way Win32 named pipes work require all client handles closed too.
- peer.Close();
- client.Close();
- server.Close();
- ASSERT_FALSE(IpcServiceHandle::IsBound(service));
-}
-
-TEST(IpcHandle, BindAcceptWithTimeout) {
- std::string error_message;
- StringPiece service = "test_service";
-
- // Create server
- IpcServiceHandle server = IpcServiceHandle::BindTo(service, &error_message);
- ASSERT_TRUE(server);
- EXPECT_TRUE(error_message.empty());
-
- // Accepting should time out since no client is trying to connect.
- bool did_timeout = false;
- IpcHandle connection = server.AcceptClient(10, &did_timeout, &error_message);
- EXPECT_FALSE(connection);
- EXPECT_TRUE(did_timeout);
- EXPECT_FALSE(error_message.empty());
- error_message.clear();
-
- // Connecto the server, and receive a peer handle.
- IpcHandle client = IpcServiceHandle::ConnectTo(service, &error_message);
- EXPECT_TRUE(client);
- EXPECT_TRUE(error_message.empty());
-
- // Accepting should not work.
- connection = server.AcceptClient(10, &did_timeout, &error_message);
- EXPECT_TRUE(connection);
- EXPECT_FALSE(did_timeout);
- EXPECT_TRUE(error_message.empty());
-}
-
-TEST(IpcHandle, SendAndReceiveNativeHandle) {
- IpcHandle pipe1_read;
- IpcHandle pipe1_write;
- ASSERT_TRUE(CreateTestPipe(&pipe1_read, &pipe1_write));
-
- std::string error_message;
- StringPiece service = "test_service";
- IpcServiceHandle server = IpcServiceHandle::BindTo(service, &error_message);
- ASSERT_TRUE(server);
- EXPECT_TRUE(error_message.empty());
-
- IpcHandle client = IpcServiceHandle::ConnectTo(service, &error_message);
- EXPECT_TRUE(client);
- EXPECT_TRUE(error_message.empty());
-
- IpcHandle peer = server.AcceptClient(&error_message);
- EXPECT_TRUE(peer);
- EXPECT_TRUE(error_message.empty());
-
- // Send pipe1_write.native_handle() from client to peer.
- EXPECT_TRUE(
- client.SendNativeHandle(pipe1_write.native_handle(), &error_message));
- EXPECT_TRUE(error_message.empty());
-
- IpcHandle received;
- EXPECT_TRUE(peer.ReceiveNativeHandle(&received, &error_message));
- EXPECT_TRUE(error_message.empty());
-
- // Write to |received|, this should send data to the first pipe.
- const char kInputData[] = "Bonjour monde!";
- const size_t kInputDataSize = sizeof(kInputData);
-
- EXPECT_TRUE(received.WriteFull(kInputData, kInputDataSize, &error_message));
- EXPECT_TRUE(error_message.empty());
-
- char data[kInputDataSize] = {};
- ssize_t count = pipe1_read.Read(data, sizeof(data), &error_message);
- EXPECT_EQ(static_cast<ssize_t>(sizeof(data)), count);
- EXPECT_TRUE(error_message.empty());
-
- // Verify content.
- EXPECT_TRUE(!memcmp(data, kInputData, kInputDataSize));
-}
diff --git a/src/ipc_utils.cc b/src/ipc_utils.cc
deleted file mode 100644
index ca08848..0000000
--- a/src/ipc_utils.cc
+++ /dev/null
@@ -1,154 +0,0 @@
-// Copyright 2023 Google Inc. All Rights Reserved.
-//
-// Licensed under the Apache License, Version 2.0 (the "License");
-// you may not use this file except in compliance with the License.
-// You may obtain a copy of the License at
-//
-// http://www.apache.org/licenses/LICENSE-2.0
-//
-// Unless required by applicable law or agreed to in writing, software
-// distributed under the License is distributed on an "AS IS" BASIS,
-// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-// See the License for the specific language governing permissions and
-// limitations under the License.
-
-#include "ipc_utils.h"
-
-#include "util.h"
-
-#ifndef _WIN32
-#include <sys/signal.h>
-#include <unistd.h>
-#endif
-
-RemoteArguments::RemoteArguments(int argc, char** argv) {
- if (argc > 0) {
- args_.reserve(static_cast<size_t>(argc));
- for (int n = 0; n < argc; ++n) {
- args_.push_back(argv[n]);
- }
- }
-}
-
-void RemoteArguments::Reset(const std::vector<std::string>& args) {
- args_ = args;
-}
-
-char** RemoteArguments::argv() const {
- if (args_.empty())
- return nullptr;
-
- argv_.clear();
- argv_.reserve(args_.size());
- for (const auto& arg : args_)
- argv_.push_back(const_cast<char*>(arg.data()));
- return argv_.data();
-}
-
-void RemoteArguments::InsertAt(size_t pos, std::string arg) {
- if (pos > args_.size())
- pos = args_.size();
- args_.insert(args_.begin() + pos, std::move(arg));
-}
-
-template <>
-bool RemoteWrite<std::string>(const std::string& str, IpcHandle& con,
- std::string* error) {
- size_t size = str.size();
- return RemoteWrite(size, con, error) &&
- con.WriteFull(str.data(), size, error);
-}
-
-template <>
-bool RemoteWrite<RemoteArguments>(const RemoteArguments& args, IpcHandle& con,
- std::string* error) {
- size_t size = args.args().size();
- if (!RemoteWrite(size, con, error))
- return false;
- for (const auto& arg : args.args()) {
- if (!RemoteWrite(arg, con, error))
- return false;
- }
- return true;
-}
-
-template <>
-bool RemoteRead<std::string>(std::string& str, IpcHandle& con,
- std::string* error) {
- size_t size;
- if (!RemoteRead(size, con, error))
- return false;
- str.resize(size);
- if (!size)
- return true;
- return con.ReadFull(const_cast<char*>(str.data()), size, error);
-}
-
-template <>
-bool RemoteRead<RemoteArguments>(RemoteArguments& args, IpcHandle& con,
- std::string* error) {
- size_t size;
- if (!RemoteRead(size, con, error))
- return false;
- std::vector<std::string> vec;
- vec.resize(size);
- for (auto& arg : vec) {
- if (!RemoteRead(arg, con, error))
- return false;
- }
- args.Reset(std::move(vec));
- return true;
-}
-
-void WireEncoder::Write(const void* buffer, size_t size) {
- result_.append(static_cast<const char*>(buffer), size);
-}
-
-void WireEncoder::Write(const std::string& str) {
- Write(static_cast<uint32_t>(str.size()));
- Write(str.data(), str.size());
-}
-
-WireDecoder::WireDecoder(const void* buffer, size_t size)
- : p_(static_cast<const char*>(buffer)), end_(p_ + size) {}
-
-WireDecoder::WireDecoder(const std::string& str)
- : WireDecoder(str.data(), str.size()) {}
-
-void WireDecoder::Read(void* buffer, size_t size) {
- if (p_ + size <= end_) {
- ::memcpy(buffer, p_, size);
- p_ += size;
- } else {
- // To avoid relying on un-initialized memory at runtime
- // if the client fails to check for errors.
- ::memset(buffer, '\0', size);
- p_ = end_;
- has_error_ = true;
- }
-}
-
-void WireDecoder::Read(std::string& str) {
- uint32_t size = 0;
- Read(size);
- std::string result;
- if (size) {
- result.resize(size);
- Read(const_cast<char*>(result.data()), result.size());
- }
- str = std::move(result);
-}
-
-#ifndef _WIN32
-SigPipeBlocker::SigPipeBlocker() {
- struct sigaction action = {};
- action.sa_handler = SIG_IGN;
- if (sigaction(SIGPIPE, &action, &prev_action_) < 0)
- ErrnoFatal("sigaction");
-}
-
-SigPipeBlocker::~SigPipeBlocker() {
- if (sigaction(SIGPIPE, &prev_action_, nullptr) < 0)
- ErrnoFatal("sigaction");
-}
-#endif // !_WIN32
diff --git a/src/ipc_utils.h b/src/ipc_utils.h
deleted file mode 100644
index 8e3ecf0..0000000
--- a/src/ipc_utils.h
+++ /dev/null
@@ -1,132 +0,0 @@
-// Copyright 2023 Google Inc. All Rights Reserved.
-//
-// Licensed under the Apache License, Version 2.0 (the "License");
-// you may not use this file except in compliance with the License.
-// You may obtain a copy of the License at
-//
-// http://www.apache.org/licenses/LICENSE-2.0
-//
-// Unless required by applicable law or agreed to in writing, software
-// distributed under the License is distributed on an "AS IS" BASIS,
-// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-// See the License for the specific language governing permissions and
-// limitations under the License.
-
-#ifndef NINJA_SRC_IPC_UTILS_H_
-#define NINJA_SRC_IPC_UTILS_H_
-
-#include <string>
-#include <vector>
-
-#include "ipc_handle.h"
-
-/// Convenience wrapper for an std::vector<std::string> that can save
-/// the content of an (argc, argv) list of command-line arguments.
-struct RemoteArguments {
- RemoteArguments() = default;
- RemoteArguments(int argc, char** argv);
-
- void Reset(const std::vector<std::string>& args);
-
- const std::vector<std::string>& args() const { return args_; }
-
- /// Export instance as (argc, argv) pair.
- int argc() const { return static_cast<int>(args_.size()); }
- char** argv() const;
-
- void InsertAt(size_t pos, std::string arg);
-
- protected:
- std::vector<std::string> args_;
- mutable std::vector<char*> argv_;
-};
-
-/// Helper template to write values through an IpcHandle.
-template <typename T>
-bool RemoteWrite(const T& obj, IpcHandle& con, std::string* error) {
- return con.WriteFull(&obj, sizeof(obj), error);
-}
-
-template <>
-bool RemoteWrite<std::string>(const std::string& str, IpcHandle& con,
- std::string* error);
-
-template <>
-bool RemoteWrite<RemoteArguments>(const RemoteArguments& args, IpcHandle& con,
- std::string* error);
-
-/// Helper template to read values through an IpcHandle
-template <typename T>
-bool RemoteRead(T& obj, IpcHandle& con, std::string* error) {
- return con.ReadFull(&obj, sizeof(obj), error);
-}
-
-template <>
-bool RemoteRead<std::string>(std::string& str, IpcHandle& con,
- std::string* error);
-
-template <>
-bool RemoteRead<RemoteArguments>(RemoteArguments& args, IpcHandle& con,
- std::string* error);
-
-/// Simple class to encode values into a byte stream that
-/// can be sent through IPC to another process. Usage is:
-///
-/// 1) Create instance.
-/// 2) Call one of the Write() methods any number of times.
-/// 3) Call GetResult() to retrieve the result as an std::string.
-///
-struct WireEncoder {
- void Write(const void* buffer, size_t size);
- void Write(const std::string& str);
-
- template <typename T>
- void Write(const T& v) {
- Write(&v, sizeof(v));
- }
-
- std::string TakeResult() { return std::move(result_); }
-
- std::string result_;
-};
-
-/// Decode a string of bytes received through IPC into values.
-/// Usage is:
-/// 1) Create instance passing the input stream as an std::string
-/// 2) Call Read() methods as many times as necessary.
-/// 3) Check has_error() after each Read(), or after a series of
-/// Read() calls to see if there was any error (i.e. read overflow).
-///
-struct WireDecoder {
- WireDecoder(const void* buffer, size_t size);
- explicit WireDecoder(const std::string& str);
-
- void Read(void* buffer, size_t size);
- void Read(std::string& str);
-
- template <typename T>
- void Read(T& v) {
- Read(&v, sizeof(T));
- }
-
- bool has_error() const { return has_error_; }
-
- const char* p_ = nullptr;
- const char* end_ = nullptr;
- bool has_error_ = false;
-};
-
-#ifndef _WIN32
-/// Convenience class to ignore SIGPIPE signals when
-/// doing inter-process writes through a pipe.
-class SigPipeBlocker {
- public:
- SigPipeBlocker();
- ~SigPipeBlocker();
-
- private:
- struct sigaction prev_action_;
-};
-#endif // !_WIN32
-
-#endif // NINJA_SRC_IPC_UTILS_H_
diff --git a/src/ipc_utils_test.cc b/src/ipc_utils_test.cc
deleted file mode 100644
index 7edc5c0..0000000
--- a/src/ipc_utils_test.cc
+++ /dev/null
@@ -1,223 +0,0 @@
-// Copyright 2023 Google Inc. All Rights Reserved.
-//
-// Licensed under the Apache License, Version 2.0 (the "License");
-// you may not use this file except in compliance with the License.
-// You may obtain a copy of the License at
-//
-// http://www.apache.org/licenses/LICENSE-2.0
-//
-// Unless required by applicable law or agreed to in writing, software
-// distributed under the License is distributed on an "AS IS" BASIS,
-// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-// See the License for the specific language governing permissions and
-// limitations under the License.
-
-#include "ipc_utils.h"
-
-#include "test.h"
-
-namespace {
-
-#ifndef _WIN32
-// Helper class used to catch SIGPIPE and set a global flag when
-// it happens instead of terminating the current process. Will be
-// used to verify that SigPipeBlocker works.
-struct SigPipeCatcher {
- SigPipeCatcher() {
- // Install signal handler.
- struct sigaction action = {};
- action.sa_handler = [](int) { sigpipe_happened_ = 1; };
- sigaction(SIGPIPE, &action, &prev_action_);
-
- // Unblock signal
- sigset_t mask;
- sigemptyset(&mask);
- sigaddset(&mask, SIGPIPE);
- sigprocmask(SIG_UNBLOCK, &mask, &prev_mask_);
- }
-
- ~SigPipeCatcher() {
- sigaction(SIGPIPE, &prev_action_, nullptr);
- sigprocmask(SIG_SETMASK, &prev_mask_, nullptr);
- }
-
- void Reset() { sigpipe_happened_ = 0; }
-
- bool sigpipe_happened() const { return bool(sigpipe_happened_); }
-
- struct sigaction prev_action_;
- sigset_t prev_mask_;
- static volatile sig_atomic_t sigpipe_happened_;
-};
-
-// static
-volatile sig_atomic_t SigPipeCatcher::sigpipe_happened_ = 0;
-
-#endif // !_WIN32
-
-} // namespace
-
-TEST(RemoteArguments, DefaultConstruction) {
- RemoteArguments args;
- EXPECT_EQ(0, args.argc());
- EXPECT_FALSE(args.argv());
- EXPECT_EQ(0u, args.args().size());
-}
-
-TEST(RemoteArguments, Construction) {
- const char* const kTestArgs[] = {
- "foo",
- "bar",
- };
- RemoteArguments args(2, (char**)kTestArgs);
- EXPECT_EQ(2, args.argc());
- char** argv = args.argv();
- ASSERT_TRUE(argv);
- ASSERT_TRUE(argv[0]);
- ASSERT_TRUE(argv[1]);
- ASSERT_TRUE(!strcmp(argv[0], kTestArgs[0]));
- ASSERT_TRUE(!strcmp(argv[1], kTestArgs[1]));
-
- auto vec = args.args();
- ASSERT_EQ(2u, vec.size());
- ASSERT_EQ(vec[0], kTestArgs[0]);
- ASSERT_EQ(vec[1], kTestArgs[1]);
-}
-
-TEST(RemoteArguments, Reset) {
- const char* const kTestArgs[] = {
- "foo",
- "bar",
- };
- RemoteArguments args(2, (char**)kTestArgs);
- EXPECT_EQ(2, args.argc());
-
- std::vector<std::string> new_args;
- new_args.push_back("zoo");
- args.Reset(new_args);
-
- EXPECT_EQ(1, args.argc());
- char** argv = args.argv();
- ASSERT_TRUE(argv);
- ASSERT_TRUE(argv[0]);
- ASSERT_EQ(new_args[0], argv[0]);
-}
-
-TEST(RemoteArguments, InsertAt) {
- RemoteArguments args;
- args.InsertAt(10, "foo");
- ASSERT_EQ(1, args.argc());
- ASSERT_EQ(args.args()[0], "foo");
- args.InsertAt(0, "bar");
- ASSERT_EQ(2, args.argc());
- ASSERT_EQ(args.args()[0], "bar");
- ASSERT_EQ(args.args()[1], "foo");
- args.InsertAt(1, "zoo");
- ASSERT_EQ(3, args.argc());
- ASSERT_EQ(args.args()[0], "bar");
- ASSERT_EQ(args.args()[1], "zoo");
- ASSERT_EQ(args.args()[2], "foo");
-}
-
-TEST(WireEncoderAndDecoder, SimpleValues) {
- WireEncoder encoder;
- uint8_t byte1 = 12;
- uint32_t word1 = 42;
- uint8_t byte2 = 56;
- encoder.Write(byte1);
- encoder.Write(word1);
- encoder.Write(byte2);
-
- std::string r = encoder.TakeResult();
- ASSERT_EQ(6u, r.size());
-
- WireDecoder decoder(r);
- uint8_t rbyte1 = 0;
- uint32_t rword1 = 0;
- uint8_t rbyte2 = 0;
- decoder.Read(rbyte1);
- ASSERT_FALSE(decoder.has_error());
- decoder.Read(rword1);
- ASSERT_FALSE(decoder.has_error());
- decoder.Read(rbyte2);
- ASSERT_FALSE(decoder.has_error());
- ASSERT_EQ(byte1, rbyte1);
- ASSERT_EQ(word1, rword1);
- ASSERT_EQ(byte2, rbyte2);
-
- decoder.Read(rbyte1);
- ASSERT_TRUE(decoder.has_error());
-}
-
-TEST(WireEncoderAndDecoder, Strings) {
- static const char* const kStrings[] = {
- "foo_bar",
- "",
- "hello world!",
- };
- WireEncoder encoder;
- size_t expected_size = 0;
- for (const char* str : kStrings) {
- encoder.Write(std::string(str));
- expected_size += 4 + ::strlen(str);
- }
-
- std::string r = encoder.TakeResult();
- ASSERT_EQ(expected_size, r.size());
-
- WireDecoder decoder(r);
- std::vector<std::string> result;
- for (const char* str : kStrings) {
- result.emplace_back(str);
- decoder.Read(result.back());
- }
- ASSERT_FALSE(decoder.has_error());
-
- auto it = result.begin();
- for (const char* str : kStrings) {
- ASSERT_EQ(*it, str);
- ++it;
- }
-}
-
-#ifndef _WIN32
-
-TEST(SigPipeBlocker, Test) {
- SigPipeCatcher catcher;
-
- // First, verify that the catcher works properly.
- std::string error;
- char byte[1] = { 'x' };
- IpcHandle read_end, write_end;
-
- ASSERT_TRUE(IpcHandle::CreatePipe(&read_end, &write_end, &error));
- read_end.Close();
- errno = 0;
- ASSERT_FALSE(write_end.WriteFull(byte, 1, &error));
- ASSERT_EQ(EPIPE, errno);
- ASSERT_TRUE(catcher.sigpipe_happened());
- write_end.Close();
-
- // Then verify that the blocker works properly.
- {
- SigPipeBlocker blocker;
- catcher.Reset();
-
- ASSERT_TRUE(IpcHandle::CreatePipe(&read_end, &write_end, &error));
- read_end.Close();
- errno = 0;
- ASSERT_FALSE(write_end.WriteFull(byte, 1, &error));
- ASSERT_EQ(EPIPE, errno);
- ASSERT_FALSE(catcher.sigpipe_happened());
- write_end.Close();
- }
-
- // Do it again, to verify the destructor released the action.
- ASSERT_TRUE(IpcHandle::CreatePipe(&read_end, &write_end, &error));
- read_end.Close();
- errno = 0;
- ASSERT_FALSE(write_end.WriteFull(byte, 1, &error));
- ASSERT_EQ(EPIPE, errno);
- ASSERT_TRUE(catcher.sigpipe_happened());
-}
-#endif // !_WIN32
diff --git a/src/json.cc b/src/json.cc
deleted file mode 100644
index 4bbf6e1..0000000
--- a/src/json.cc
+++ /dev/null
@@ -1,53 +0,0 @@
-// Copyright 2021 Google Inc. All Rights Reserved.
-//
-// Licensed under the Apache License, Version 2.0 (the "License");
-// you may not use this file except in compliance with the License.
-// You may obtain a copy of the License at
-//
-// http://www.apache.org/licenses/LICENSE-2.0
-//
-// Unless required by applicable law or agreed to in writing, software
-// distributed under the License is distributed on an "AS IS" BASIS,
-// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-// See the License for the specific language governing permissions and
-// limitations under the License.
-
-#include "json.h"
-
-#include <cstdio>
-#include <string>
-
-std::string EncodeJSONString(const std::string& in) {
- static const char* hex_digits = "0123456789abcdef";
- std::string out;
- out.reserve(in.length() * 1.2);
- for (std::string::const_iterator it = in.begin(); it != in.end(); ++it) {
- char c = *it;
- if (c == '\b')
- out += "\\b";
- else if (c == '\f')
- out += "\\f";
- else if (c == '\n')
- out += "\\n";
- else if (c == '\r')
- out += "\\r";
- else if (c == '\t')
- out += "\\t";
- else if (0x0 <= c && c < 0x20) {
- out += "\\u00";
- out += hex_digits[c >> 4];
- out += hex_digits[c & 0xf];
- } else if (c == '\\')
- out += "\\\\";
- else if (c == '\"')
- out += "\\\"";
- else
- out += c;
- }
- return out;
-}
-
-void PrintJSONString(const std::string& in) {
- std::string out = EncodeJSONString(in);
- fwrite(out.c_str(), 1, out.length(), stdout);
-}
diff --git a/src/json.h b/src/json.h
deleted file mode 100644
index f39c759..0000000
--- a/src/json.h
+++ /dev/null
@@ -1,26 +0,0 @@
-// Copyright 2021 Google Inc. All Rights Reserved.
-//
-// Licensed under the Apache License, Version 2.0 (the "License");
-// you may not use this file except in compliance with the License.
-// You may obtain a copy of the License at
-//
-// http://www.apache.org/licenses/LICENSE-2.0
-//
-// Unless required by applicable law or agreed to in writing, software
-// distributed under the License is distributed on an "AS IS" BASIS,
-// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-// See the License for the specific language governing permissions and
-// limitations under the License.
-
-#ifndef NINJA_JSON_H_
-#define NINJA_JSON_H_
-
-#include <string>
-
-// Encode a string in JSON format without encolsing quotes
-std::string EncodeJSONString(const std::string& in);
-
-// Print a string in JSON format to stdout without enclosing quotes
-void PrintJSONString(const std::string& in);
-
-#endif
diff --git a/src/json_test.cc b/src/json_test.cc
deleted file mode 100644
index b4afc73..0000000
--- a/src/json_test.cc
+++ /dev/null
@@ -1,40 +0,0 @@
-// Copyright 2021 Google Inc. All Rights Reserved.
-//
-// Licensed under the Apache License, Version 2.0 (the "License");
-// you may not use this file except in compliance with the License.
-// You may obtain a copy of the License at
-//
-// http://www.apache.org/licenses/LICENSE-2.0
-//
-// Unless required by applicable law or agreed to in writing, software
-// distributed under the License is distributed on an "AS IS" BASIS,
-// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-// See the License for the specific language governing permissions and
-// limitations under the License.
-
-#include "json.h"
-
-#include "test.h"
-
-TEST(JSONTest, RegularAscii) {
- EXPECT_EQ(EncodeJSONString("foo bar"), "foo bar");
-}
-
-TEST(JSONTest, EscapedChars) {
- EXPECT_EQ(EncodeJSONString("\"\\\b\f\n\r\t"),
- "\\\""
- "\\\\"
- "\\b\\f\\n\\r\\t");
-}
-
-// codepoints between 0 and 0x1f should be escaped
-TEST(JSONTest, ControlChars) {
- EXPECT_EQ(EncodeJSONString("\x01\x1f"), "\\u0001\\u001f");
-}
-
-// Leave them alone as JSON accepts unicode literals
-// out of control character range
-TEST(JSONTest, UTF8) {
- const char* utf8str = "\xe4\xbd\xa0\xe5\xa5\xbd";
- EXPECT_EQ(EncodeJSONString(utf8str), utf8str);
-}
diff --git a/src/lexer.cc b/src/lexer.cc
deleted file mode 100644
index b1e1152..0000000
--- a/src/lexer.cc
+++ /dev/null
@@ -1,825 +0,0 @@
-/* Generated by re2c */
-// Copyright 2011 Google Inc. All Rights Reserved.
-//
-// Licensed under the Apache License, Version 2.0 (the "License");
-// you may not use this file except in compliance with the License.
-// You may obtain a copy of the License at
-//
-// http://www.apache.org/licenses/LICENSE-2.0
-//
-// Unless required by applicable law or agreed to in writing, software
-// distributed under the License is distributed on an "AS IS" BASIS,
-// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-// See the License for the specific language governing permissions and
-// limitations under the License.
-
-#include "lexer.h"
-
-#include <stdio.h>
-
-#include "eval_env.h"
-#include "util.h"
-
-using namespace std;
-
-bool Lexer::Error(const string& message, string* err) {
- // Compute line/column.
- int line = 1;
- const char* line_start = input_.str_;
- for (const char* p = input_.str_; p < last_token_; ++p) {
- if (*p == '\n') {
- ++line;
- line_start = p + 1;
- }
- }
- int col = last_token_ ? (int)(last_token_ - line_start) : 0;
-
- *err = StringFormat("%.*s:%d: %s\n", filename_.len_, filename_.str_, line,
- message.c_str());
-
- // Add some context to the message.
- const int kTruncateColumn = 72;
- if (col > 0 && col < kTruncateColumn) {
- int len;
- bool truncated = true;
- for (len = 0; len < kTruncateColumn; ++len) {
- if (line_start[len] == 0 || line_start[len] == '\n') {
- truncated = false;
- break;
- }
- }
- *err += string(line_start, len);
- if (truncated)
- *err += "...";
- *err += "\n";
- *err += string(col, ' ');
- *err += "^ near here";
- }
-
- return false;
-}
-
-Lexer::Lexer(const char* input) {
- Start("input", input);
-}
-
-void Lexer::Start(StringPiece filename, StringPiece input) {
- filename_ = filename;
- input_ = input;
- ofs_ = input_.str_;
- last_token_ = NULL;
-}
-
-const char* Lexer::TokenName(Token t) {
- switch (t) {
- case ERROR: return "lexing error";
- case BUILD: return "'build'";
- case COLON: return "':'";
- case DEFAULT: return "'default'";
- case EQUALS: return "'='";
- case IDENT: return "identifier";
- case INCLUDE: return "'include'";
- case INDENT: return "indent";
- case NEWLINE: return "newline";
- case PIPE2: return "'||'";
- case PIPE: return "'|'";
- case PIPEAT: return "'|@'";
- case POOL: return "'pool'";
- case RULE: return "'rule'";
- case SUBNINJA: return "'subninja'";
- case TEOF: return "eof";
- }
- return NULL; // not reached
-}
-
-const char* Lexer::TokenErrorHint(Token expected) {
- switch (expected) {
- case COLON:
- return " ($ also escapes ':')";
- default:
- return "";
- }
-}
-
-string Lexer::DescribeLastError() {
- if (last_token_) {
- switch (last_token_[0]) {
- case '\t':
- return "tabs are not allowed, use spaces";
- }
- }
- return "lexing error";
-}
-
-void Lexer::UnreadToken() {
- ofs_ = last_token_;
-}
-
-Lexer::Token Lexer::ReadToken() {
- const char* p = ofs_;
- const char* q;
- const char* start;
- Lexer::Token token;
- for (;;) {
- start = p;
-
-{
- unsigned char yych;
- unsigned int yyaccept = 0;
- static const unsigned char yybm[] = {
- 0, 128, 128, 128, 128, 128, 128, 128,
- 128, 128, 0, 128, 128, 128, 128, 128,
- 128, 128, 128, 128, 128, 128, 128, 128,
- 128, 128, 128, 128, 128, 128, 128, 128,
- 160, 128, 128, 128, 128, 128, 128, 128,
- 128, 128, 128, 128, 128, 192, 192, 128,
- 192, 192, 192, 192, 192, 192, 192, 192,
- 192, 192, 128, 128, 128, 128, 128, 128,
- 128, 192, 192, 192, 192, 192, 192, 192,
- 192, 192, 192, 192, 192, 192, 192, 192,
- 192, 192, 192, 192, 192, 192, 192, 192,
- 192, 192, 192, 128, 128, 128, 128, 192,
- 128, 192, 192, 192, 192, 192, 192, 192,
- 192, 192, 192, 192, 192, 192, 192, 192,
- 192, 192, 192, 192, 192, 192, 192, 192,
- 192, 192, 192, 128, 128, 128, 128, 128,
- 128, 128, 128, 128, 128, 128, 128, 128,
- 128, 128, 128, 128, 128, 128, 128, 128,
- 128, 128, 128, 128, 128, 128, 128, 128,
- 128, 128, 128, 128, 128, 128, 128, 128,
- 128, 128, 128, 128, 128, 128, 128, 128,
- 128, 128, 128, 128, 128, 128, 128, 128,
- 128, 128, 128, 128, 128, 128, 128, 128,
- 128, 128, 128, 128, 128, 128, 128, 128,
- 128, 128, 128, 128, 128, 128, 128, 128,
- 128, 128, 128, 128, 128, 128, 128, 128,
- 128, 128, 128, 128, 128, 128, 128, 128,
- 128, 128, 128, 128, 128, 128, 128, 128,
- 128, 128, 128, 128, 128, 128, 128, 128,
- 128, 128, 128, 128, 128, 128, 128, 128,
- 128, 128, 128, 128, 128, 128, 128, 128,
- 128, 128, 128, 128, 128, 128, 128, 128,
- };
- yych = *p;
- if (yybm[0+yych] & 32) {
- goto yy9;
- }
- if (yych <= '^') {
- if (yych <= ',') {
- if (yych <= '\f') {
- if (yych <= 0x00) goto yy2;
- if (yych == '\n') goto yy6;
- goto yy4;
- } else {
- if (yych <= '\r') goto yy8;
- if (yych == '#') goto yy12;
- goto yy4;
- }
- } else {
- if (yych <= ':') {
- if (yych == '/') goto yy4;
- if (yych <= '9') goto yy13;
- goto yy16;
- } else {
- if (yych <= '=') {
- if (yych <= '<') goto yy4;
- goto yy18;
- } else {
- if (yych <= '@') goto yy4;
- if (yych <= 'Z') goto yy13;
- goto yy4;
- }
- }
- }
- } else {
- if (yych <= 'i') {
- if (yych <= 'b') {
- if (yych == '`') goto yy4;
- if (yych <= 'a') goto yy13;
- goto yy20;
- } else {
- if (yych == 'd') goto yy21;
- if (yych <= 'h') goto yy13;
- goto yy22;
- }
- } else {
- if (yych <= 'r') {
- if (yych == 'p') goto yy23;
- if (yych <= 'q') goto yy13;
- goto yy24;
- } else {
- if (yych <= 'z') {
- if (yych <= 's') goto yy25;
- goto yy13;
- } else {
- if (yych == '|') goto yy26;
- goto yy4;
- }
- }
- }
- }
-yy2:
- ++p;
- { token = TEOF; break; }
-yy4:
- ++p;
-yy5:
- { token = ERROR; break; }
-yy6:
- ++p;
- { token = NEWLINE; break; }
-yy8:
- yych = *++p;
- if (yych == '\n') goto yy28;
- goto yy5;
-yy9:
- yyaccept = 0;
- yych = *(q = ++p);
- if (yybm[0+yych] & 32) {
- goto yy9;
- }
- if (yych <= '\f') {
- if (yych == '\n') goto yy6;
- } else {
- if (yych <= '\r') goto yy30;
- if (yych == '#') goto yy32;
- }
-yy11:
- { token = INDENT; break; }
-yy12:
- yyaccept = 1;
- yych = *(q = ++p);
- if (yych <= 0x00) goto yy5;
- goto yy33;
-yy13:
- yych = *++p;
-yy14:
- if (yybm[0+yych] & 64) {
- goto yy13;
- }
- { token = IDENT; break; }
-yy16:
- ++p;
- { token = COLON; break; }
-yy18:
- ++p;
- { token = EQUALS; break; }
-yy20:
- yych = *++p;
- if (yych == 'u') goto yy36;
- goto yy14;
-yy21:
- yych = *++p;
- if (yych == 'e') goto yy37;
- goto yy14;
-yy22:
- yych = *++p;
- if (yych == 'n') goto yy38;
- goto yy14;
-yy23:
- yych = *++p;
- if (yych == 'o') goto yy39;
- goto yy14;
-yy24:
- yych = *++p;
- if (yych == 'u') goto yy40;
- goto yy14;
-yy25:
- yych = *++p;
- if (yych == 'u') goto yy41;
- goto yy14;
-yy26:
- yych = *++p;
- if (yych == '@') goto yy42;
- if (yych == '|') goto yy44;
- { token = PIPE; break; }
-yy28:
- ++p;
- { token = NEWLINE; break; }
-yy30:
- yych = *++p;
- if (yych == '\n') goto yy28;
-yy31:
- p = q;
- if (yyaccept == 0) {
- goto yy11;
- } else {
- goto yy5;
- }
-yy32:
- yych = *++p;
-yy33:
- if (yybm[0+yych] & 128) {
- goto yy32;
- }
- if (yych <= 0x00) goto yy31;
- ++p;
- { continue; }
-yy36:
- yych = *++p;
- if (yych == 'i') goto yy46;
- goto yy14;
-yy37:
- yych = *++p;
- if (yych == 'f') goto yy47;
- goto yy14;
-yy38:
- yych = *++p;
- if (yych == 'c') goto yy48;
- goto yy14;
-yy39:
- yych = *++p;
- if (yych == 'o') goto yy49;
- goto yy14;
-yy40:
- yych = *++p;
- if (yych == 'l') goto yy50;
- goto yy14;
-yy41:
- yych = *++p;
- if (yych == 'b') goto yy51;
- goto yy14;
-yy42:
- ++p;
- { token = PIPEAT; break; }
-yy44:
- ++p;
- { token = PIPE2; break; }
-yy46:
- yych = *++p;
- if (yych == 'l') goto yy52;
- goto yy14;
-yy47:
- yych = *++p;
- if (yych == 'a') goto yy53;
- goto yy14;
-yy48:
- yych = *++p;
- if (yych == 'l') goto yy54;
- goto yy14;
-yy49:
- yych = *++p;
- if (yych == 'l') goto yy55;
- goto yy14;
-yy50:
- yych = *++p;
- if (yych == 'e') goto yy57;
- goto yy14;
-yy51:
- yych = *++p;
- if (yych == 'n') goto yy59;
- goto yy14;
-yy52:
- yych = *++p;
- if (yych == 'd') goto yy60;
- goto yy14;
-yy53:
- yych = *++p;
- if (yych == 'u') goto yy62;
- goto yy14;
-yy54:
- yych = *++p;
- if (yych == 'u') goto yy63;
- goto yy14;
-yy55:
- yych = *++p;
- if (yybm[0+yych] & 64) {
- goto yy13;
- }
- { token = POOL; break; }
-yy57:
- yych = *++p;
- if (yybm[0+yych] & 64) {
- goto yy13;
- }
- { token = RULE; break; }
-yy59:
- yych = *++p;
- if (yych == 'i') goto yy64;
- goto yy14;
-yy60:
- yych = *++p;
- if (yybm[0+yych] & 64) {
- goto yy13;
- }
- { token = BUILD; break; }
-yy62:
- yych = *++p;
- if (yych == 'l') goto yy65;
- goto yy14;
-yy63:
- yych = *++p;
- if (yych == 'd') goto yy66;
- goto yy14;
-yy64:
- yych = *++p;
- if (yych == 'n') goto yy67;
- goto yy14;
-yy65:
- yych = *++p;
- if (yych == 't') goto yy68;
- goto yy14;
-yy66:
- yych = *++p;
- if (yych == 'e') goto yy70;
- goto yy14;
-yy67:
- yych = *++p;
- if (yych == 'j') goto yy72;
- goto yy14;
-yy68:
- yych = *++p;
- if (yybm[0+yych] & 64) {
- goto yy13;
- }
- { token = DEFAULT; break; }
-yy70:
- yych = *++p;
- if (yybm[0+yych] & 64) {
- goto yy13;
- }
- { token = INCLUDE; break; }
-yy72:
- yych = *++p;
- if (yych != 'a') goto yy14;
- yych = *++p;
- if (yybm[0+yych] & 64) {
- goto yy13;
- }
- { token = SUBNINJA; break; }
-}
-
- }
-
- last_token_ = start;
- ofs_ = p;
- if (token != NEWLINE && token != TEOF)
- EatWhitespace();
- return token;
-}
-
-bool Lexer::PeekToken(Token token) {
- Token t = ReadToken();
- if (t == token)
- return true;
- UnreadToken();
- return false;
-}
-
-void Lexer::EatWhitespace() {
- const char* p = ofs_;
- const char* q;
- for (;;) {
- ofs_ = p;
-
-{
- unsigned char yych;
- static const unsigned char yybm[] = {
- 0, 0, 0, 0, 0, 0, 0, 0,
- 0, 0, 0, 0, 0, 0, 0, 0,
- 0, 0, 0, 0, 0, 0, 0, 0,
- 0, 0, 0, 0, 0, 0, 0, 0,
- 128, 0, 0, 0, 0, 0, 0, 0,
- 0, 0, 0, 0, 0, 0, 0, 0,
- 0, 0, 0, 0, 0, 0, 0, 0,
- 0, 0, 0, 0, 0, 0, 0, 0,
- 0, 0, 0, 0, 0, 0, 0, 0,
- 0, 0, 0, 0, 0, 0, 0, 0,
- 0, 0, 0, 0, 0, 0, 0, 0,
- 0, 0, 0, 0, 0, 0, 0, 0,
- 0, 0, 0, 0, 0, 0, 0, 0,
- 0, 0, 0, 0, 0, 0, 0, 0,
- 0, 0, 0, 0, 0, 0, 0, 0,
- 0, 0, 0, 0, 0, 0, 0, 0,
- 0, 0, 0, 0, 0, 0, 0, 0,
- 0, 0, 0, 0, 0, 0, 0, 0,
- 0, 0, 0, 0, 0, 0, 0, 0,
- 0, 0, 0, 0, 0, 0, 0, 0,
- 0, 0, 0, 0, 0, 0, 0, 0,
- 0, 0, 0, 0, 0, 0, 0, 0,
- 0, 0, 0, 0, 0, 0, 0, 0,
- 0, 0, 0, 0, 0, 0, 0, 0,
- 0, 0, 0, 0, 0, 0, 0, 0,
- 0, 0, 0, 0, 0, 0, 0, 0,
- 0, 0, 0, 0, 0, 0, 0, 0,
- 0, 0, 0, 0, 0, 0, 0, 0,
- 0, 0, 0, 0, 0, 0, 0, 0,
- 0, 0, 0, 0, 0, 0, 0, 0,
- 0, 0, 0, 0, 0, 0, 0, 0,
- 0, 0, 0, 0, 0, 0, 0, 0,
- };
- yych = *p;
- if (yybm[0+yych] & 128) {
- goto yy81;
- }
- if (yych <= 0x00) goto yy77;
- if (yych == '$') goto yy84;
- goto yy79;
-yy77:
- ++p;
- { break; }
-yy79:
- ++p;
-yy80:
- { break; }
-yy81:
- yych = *++p;
- if (yybm[0+yych] & 128) {
- goto yy81;
- }
- { continue; }
-yy84:
- yych = *(q = ++p);
- if (yych == '\n') goto yy85;
- if (yych == '\r') goto yy87;
- goto yy80;
-yy85:
- ++p;
- { continue; }
-yy87:
- yych = *++p;
- if (yych == '\n') goto yy89;
- p = q;
- goto yy80;
-yy89:
- ++p;
- { continue; }
-}
-
- }
-}
-
-bool Lexer::ReadIdent(string* out) {
- const char* p = ofs_;
- const char* start;
- for (;;) {
- start = p;
-
-{
- unsigned char yych;
- static const unsigned char yybm[] = {
- 0, 0, 0, 0, 0, 0, 0, 0,
- 0, 0, 0, 0, 0, 0, 0, 0,
- 0, 0, 0, 0, 0, 0, 0, 0,
- 0, 0, 0, 0, 0, 0, 0, 0,
- 0, 0, 0, 0, 0, 0, 0, 0,
- 0, 0, 0, 0, 0, 128, 128, 0,
- 128, 128, 128, 128, 128, 128, 128, 128,
- 128, 128, 0, 0, 0, 0, 0, 0,
- 0, 128, 128, 128, 128, 128, 128, 128,
- 128, 128, 128, 128, 128, 128, 128, 128,
- 128, 128, 128, 128, 128, 128, 128, 128,
- 128, 128, 128, 0, 0, 0, 0, 128,
- 0, 128, 128, 128, 128, 128, 128, 128,
- 128, 128, 128, 128, 128, 128, 128, 128,
- 128, 128, 128, 128, 128, 128, 128, 128,
- 128, 128, 128, 0, 0, 0, 0, 0,
- 0, 0, 0, 0, 0, 0, 0, 0,
- 0, 0, 0, 0, 0, 0, 0, 0,
- 0, 0, 0, 0, 0, 0, 0, 0,
- 0, 0, 0, 0, 0, 0, 0, 0,
- 0, 0, 0, 0, 0, 0, 0, 0,
- 0, 0, 0, 0, 0, 0, 0, 0,
- 0, 0, 0, 0, 0, 0, 0, 0,
- 0, 0, 0, 0, 0, 0, 0, 0,
- 0, 0, 0, 0, 0, 0, 0, 0,
- 0, 0, 0, 0, 0, 0, 0, 0,
- 0, 0, 0, 0, 0, 0, 0, 0,
- 0, 0, 0, 0, 0, 0, 0, 0,
- 0, 0, 0, 0, 0, 0, 0, 0,
- 0, 0, 0, 0, 0, 0, 0, 0,
- 0, 0, 0, 0, 0, 0, 0, 0,
- 0, 0, 0, 0, 0, 0, 0, 0,
- };
- yych = *p;
- if (yybm[0+yych] & 128) {
- goto yy95;
- }
- ++p;
- {
- last_token_ = start;
- return false;
- }
-yy95:
- yych = *++p;
- if (yybm[0+yych] & 128) {
- goto yy95;
- }
- {
- out->assign(start, p - start);
- break;
- }
-}
-
- }
- last_token_ = start;
- ofs_ = p;
- EatWhitespace();
- return true;
-}
-
-bool Lexer::ReadEvalString(EvalString* eval, bool path, string* err) {
- const char* p = ofs_;
- const char* q;
- const char* start;
- for (;;) {
- start = p;
-
-{
- unsigned char yych;
- static const unsigned char yybm[] = {
- 0, 16, 16, 16, 16, 16, 16, 16,
- 16, 16, 0, 16, 16, 0, 16, 16,
- 16, 16, 16, 16, 16, 16, 16, 16,
- 16, 16, 16, 16, 16, 16, 16, 16,
- 32, 16, 16, 16, 0, 16, 16, 16,
- 16, 16, 16, 16, 16, 208, 144, 16,
- 208, 208, 208, 208, 208, 208, 208, 208,
- 208, 208, 0, 16, 16, 16, 16, 16,
- 16, 208, 208, 208, 208, 208, 208, 208,
- 208, 208, 208, 208, 208, 208, 208, 208,
- 208, 208, 208, 208, 208, 208, 208, 208,
- 208, 208, 208, 16, 16, 16, 16, 208,
- 16, 208, 208, 208, 208, 208, 208, 208,
- 208, 208, 208, 208, 208, 208, 208, 208,
- 208, 208, 208, 208, 208, 208, 208, 208,
- 208, 208, 208, 16, 0, 16, 16, 16,
- 16, 16, 16, 16, 16, 16, 16, 16,
- 16, 16, 16, 16, 16, 16, 16, 16,
- 16, 16, 16, 16, 16, 16, 16, 16,
- 16, 16, 16, 16, 16, 16, 16, 16,
- 16, 16, 16, 16, 16, 16, 16, 16,
- 16, 16, 16, 16, 16, 16, 16, 16,
- 16, 16, 16, 16, 16, 16, 16, 16,
- 16, 16, 16, 16, 16, 16, 16, 16,
- 16, 16, 16, 16, 16, 16, 16, 16,
- 16, 16, 16, 16, 16, 16, 16, 16,
- 16, 16, 16, 16, 16, 16, 16, 16,
- 16, 16, 16, 16, 16, 16, 16, 16,
- 16, 16, 16, 16, 16, 16, 16, 16,
- 16, 16, 16, 16, 16, 16, 16, 16,
- 16, 16, 16, 16, 16, 16, 16, 16,
- 16, 16, 16, 16, 16, 16, 16, 16,
- };
- yych = *p;
- if (yybm[0+yych] & 16) {
- goto yy102;
- }
- if (yych <= '\r') {
- if (yych <= 0x00) goto yy100;
- if (yych <= '\n') goto yy105;
- goto yy107;
- } else {
- if (yych <= ' ') goto yy105;
- if (yych <= '$') goto yy109;
- goto yy105;
- }
-yy100:
- ++p;
- {
- last_token_ = start;
- return Error("unexpected EOF", err);
- }
-yy102:
- yych = *++p;
- if (yybm[0+yych] & 16) {
- goto yy102;
- }
- {
- eval->AddText(StringPiece(start, p - start));
- continue;
- }
-yy105:
- ++p;
- {
- if (path) {
- p = start;
- break;
- } else {
- if (*start == '\n')
- break;
- eval->AddText(StringPiece(start, 1));
- continue;
- }
- }
-yy107:
- yych = *++p;
- if (yych == '\n') goto yy110;
- {
- last_token_ = start;
- return Error(DescribeLastError(), err);
- }
-yy109:
- yych = *++p;
- if (yybm[0+yych] & 64) {
- goto yy122;
- }
- if (yych <= ' ') {
- if (yych <= '\f') {
- if (yych == '\n') goto yy114;
- goto yy112;
- } else {
- if (yych <= '\r') goto yy117;
- if (yych <= 0x1F) goto yy112;
- goto yy118;
- }
- } else {
- if (yych <= '/') {
- if (yych == '$') goto yy120;
- goto yy112;
- } else {
- if (yych <= ':') goto yy125;
- if (yych <= '`') goto yy112;
- if (yych <= '{') goto yy127;
- goto yy112;
- }
- }
-yy110:
- ++p;
- {
- if (path)
- p = start;
- break;
- }
-yy112:
- ++p;
-yy113:
- {
- last_token_ = start;
- return Error("bad $-escape (literal $ must be written as $$)", err);
- }
-yy114:
- yych = *++p;
- if (yybm[0+yych] & 32) {
- goto yy114;
- }
- {
- continue;
- }
-yy117:
- yych = *++p;
- if (yych == '\n') goto yy128;
- goto yy113;
-yy118:
- ++p;
- {
- eval->AddText(StringPiece(" ", 1));
- continue;
- }
-yy120:
- ++p;
- {
- eval->AddText(StringPiece("$", 1));
- continue;
- }
-yy122:
- yych = *++p;
- if (yybm[0+yych] & 64) {
- goto yy122;
- }
- {
- eval->AddSpecial(StringPiece(start + 1, p - start - 1));
- continue;
- }
-yy125:
- ++p;
- {
- eval->AddText(StringPiece(":", 1));
- continue;
- }
-yy127:
- yych = *(q = ++p);
- if (yybm[0+yych] & 128) {
- goto yy131;
- }
- goto yy113;
-yy128:
- yych = *++p;
- if (yych == ' ') goto yy128;
- {
- continue;
- }
-yy131:
- yych = *++p;
- if (yybm[0+yych] & 128) {
- goto yy131;
- }
- if (yych == '}') goto yy134;
- p = q;
- goto yy113;
-yy134:
- ++p;
- {
- eval->AddSpecial(StringPiece(start + 2, p - start - 3));
- continue;
- }
-}
-
- }
- last_token_ = start;
- ofs_ = p;
- if (path)
- EatWhitespace();
- // Non-path strings end in newlines, so there's no whitespace to eat.
- return true;
-}
diff --git a/src/lexer.h b/src/lexer.h
deleted file mode 100644
index 683fd6c..0000000
--- a/src/lexer.h
+++ /dev/null
@@ -1,106 +0,0 @@
-// Copyright 2011 Google Inc. All Rights Reserved.
-//
-// Licensed under the Apache License, Version 2.0 (the "License");
-// you may not use this file except in compliance with the License.
-// You may obtain a copy of the License at
-//
-// http://www.apache.org/licenses/LICENSE-2.0
-//
-// Unless required by applicable law or agreed to in writing, software
-// distributed under the License is distributed on an "AS IS" BASIS,
-// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-// See the License for the specific language governing permissions and
-// limitations under the License.
-
-#ifndef NINJA_LEXER_H_
-#define NINJA_LEXER_H_
-
-#include "string_piece.h"
-
-// Windows may #define ERROR.
-#ifdef ERROR
-#undef ERROR
-#endif
-
-struct EvalString;
-
-struct Lexer {
- Lexer() {}
- /// Helper ctor useful for tests.
- explicit Lexer(const char* input);
-
- enum Token {
- ERROR,
- BUILD,
- COLON,
- DEFAULT,
- EQUALS,
- IDENT,
- INCLUDE,
- INDENT,
- NEWLINE,
- PIPE,
- PIPE2,
- PIPEAT,
- POOL,
- RULE,
- SUBNINJA,
- TEOF,
- };
-
- /// Return a human-readable form of a token, used in error messages.
- static const char* TokenName(Token t);
-
- /// Return a human-readable token hint, used in error messages.
- static const char* TokenErrorHint(Token expected);
-
- /// If the last token read was an ERROR token, provide more info
- /// or the empty string.
- std::string DescribeLastError();
-
- /// Start parsing some input.
- void Start(StringPiece filename, StringPiece input);
-
- /// Read a Token from the Token enum.
- Token ReadToken();
-
- /// Rewind to the last read Token.
- void UnreadToken();
-
- /// If the next token is \a token, read it and return true.
- bool PeekToken(Token token);
-
- /// Read a simple identifier (a rule or variable name).
- /// Returns false if a name can't be read.
- bool ReadIdent(std::string* out);
-
- /// Read a path (complete with $escapes).
- /// Returns false only on error, returned path may be empty if a delimiter
- /// (space, newline) is hit.
- bool ReadPath(EvalString* path, std::string* err) {
- return ReadEvalString(path, true, err);
- }
-
- /// Read the value side of a var = value line (complete with $escapes).
- /// Returns false only on error.
- bool ReadVarValue(EvalString* value, std::string* err) {
- return ReadEvalString(value, false, err);
- }
-
- /// Construct an error message with context.
- bool Error(const std::string& message, std::string* err);
-
-private:
- /// Skip past whitespace (called after each read token/ident/etc.).
- void EatWhitespace();
-
- /// Read a $-escaped string.
- bool ReadEvalString(EvalString* eval, bool path, std::string* err);
-
- StringPiece filename_;
- StringPiece input_;
- const char* ofs_;
- const char* last_token_;
-};
-
-#endif // NINJA_LEXER_H_
diff --git a/src/lexer.in.cc b/src/lexer.in.cc
deleted file mode 100644
index 6f36e6a..0000000
--- a/src/lexer.in.cc
+++ /dev/null
@@ -1,280 +0,0 @@
-// Copyright 2011 Google Inc. All Rights Reserved.
-//
-// Licensed under the Apache License, Version 2.0 (the "License");
-// you may not use this file except in compliance with the License.
-// You may obtain a copy of the License at
-//
-// http://www.apache.org/licenses/LICENSE-2.0
-//
-// Unless required by applicable law or agreed to in writing, software
-// distributed under the License is distributed on an "AS IS" BASIS,
-// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-// See the License for the specific language governing permissions and
-// limitations under the License.
-
-#include "lexer.h"
-
-#include <stdio.h>
-
-#include "eval_env.h"
-#include "util.h"
-
-using namespace std;
-
-bool Lexer::Error(const string& message, string* err) {
- // Compute line/column.
- int line = 1;
- const char* line_start = input_.str_;
- for (const char* p = input_.str_; p < last_token_; ++p) {
- if (*p == '\n') {
- ++line;
- line_start = p + 1;
- }
- }
- int col = last_token_ ? (int)(last_token_ - line_start) : 0;
-
- *err = StringFormat("%.*s:%d: %s\n", filename_.len_, filename_.str_, line,
- message.c_str());
-
- // Add some context to the message.
- const int kTruncateColumn = 72;
- if (col > 0 && col < kTruncateColumn) {
- int len;
- bool truncated = true;
- for (len = 0; len < kTruncateColumn; ++len) {
- if (line_start[len] == 0 || line_start[len] == '\n') {
- truncated = false;
- break;
- }
- }
- *err += string(line_start, len);
- if (truncated)
- *err += "...";
- *err += "\n";
- *err += string(col, ' ');
- *err += "^ near here";
- }
-
- return false;
-}
-
-Lexer::Lexer(const char* input) {
- Start("input", input);
-}
-
-void Lexer::Start(StringPiece filename, StringPiece input) {
- filename_ = filename;
- input_ = input;
- ofs_ = input_.str_;
- last_token_ = NULL;
-}
-
-const char* Lexer::TokenName(Token t) {
- switch (t) {
- case ERROR: return "lexing error";
- case BUILD: return "'build'";
- case COLON: return "':'";
- case DEFAULT: return "'default'";
- case EQUALS: return "'='";
- case IDENT: return "identifier";
- case INCLUDE: return "'include'";
- case INDENT: return "indent";
- case NEWLINE: return "newline";
- case PIPE2: return "'||'";
- case PIPE: return "'|'";
- case PIPEAT: return "'|@'";
- case POOL: return "'pool'";
- case RULE: return "'rule'";
- case SUBNINJA: return "'subninja'";
- case TEOF: return "eof";
- }
- return NULL; // not reached
-}
-
-const char* Lexer::TokenErrorHint(Token expected) {
- switch (expected) {
- case COLON:
- return " ($ also escapes ':')";
- default:
- return "";
- }
-}
-
-string Lexer::DescribeLastError() {
- if (last_token_) {
- switch (last_token_[0]) {
- case '\t':
- return "tabs are not allowed, use spaces";
- }
- }
- return "lexing error";
-}
-
-void Lexer::UnreadToken() {
- ofs_ = last_token_;
-}
-
-Lexer::Token Lexer::ReadToken() {
- const char* p = ofs_;
- const char* q;
- const char* start;
- Lexer::Token token;
- for (;;) {
- start = p;
- /*!re2c
- re2c:define:YYCTYPE = "unsigned char";
- re2c:define:YYCURSOR = p;
- re2c:define:YYMARKER = q;
- re2c:yyfill:enable = 0;
-
- nul = "\000";
- simple_varname = [a-zA-Z0-9_-]+;
- varname = [a-zA-Z0-9_.-]+;
-
- [ ]*"#"[^\000\n]*"\n" { continue; }
- [ ]*"\r\n" { token = NEWLINE; break; }
- [ ]*"\n" { token = NEWLINE; break; }
- [ ]+ { token = INDENT; break; }
- "build" { token = BUILD; break; }
- "pool" { token = POOL; break; }
- "rule" { token = RULE; break; }
- "default" { token = DEFAULT; break; }
- "=" { token = EQUALS; break; }
- ":" { token = COLON; break; }
- "|@" { token = PIPEAT; break; }
- "||" { token = PIPE2; break; }
- "|" { token = PIPE; break; }
- "include" { token = INCLUDE; break; }
- "subninja" { token = SUBNINJA; break; }
- varname { token = IDENT; break; }
- nul { token = TEOF; break; }
- [^] { token = ERROR; break; }
- */
- }
-
- last_token_ = start;
- ofs_ = p;
- if (token != NEWLINE && token != TEOF)
- EatWhitespace();
- return token;
-}
-
-bool Lexer::PeekToken(Token token) {
- Token t = ReadToken();
- if (t == token)
- return true;
- UnreadToken();
- return false;
-}
-
-void Lexer::EatWhitespace() {
- const char* p = ofs_;
- const char* q;
- for (;;) {
- ofs_ = p;
- /*!re2c
- [ ]+ { continue; }
- "$\r\n" { continue; }
- "$\n" { continue; }
- nul { break; }
- [^] { break; }
- */
- }
-}
-
-bool Lexer::ReadIdent(string* out) {
- const char* p = ofs_;
- const char* start;
- for (;;) {
- start = p;
- /*!re2c
- varname {
- out->assign(start, p - start);
- break;
- }
- [^] {
- last_token_ = start;
- return false;
- }
- */
- }
- last_token_ = start;
- ofs_ = p;
- EatWhitespace();
- return true;
-}
-
-bool Lexer::ReadEvalString(EvalString* eval, bool path, string* err) {
- const char* p = ofs_;
- const char* q;
- const char* start;
- for (;;) {
- start = p;
- /*!re2c
- [^$ :\r\n|\000]+ {
- eval->AddText(StringPiece(start, p - start));
- continue;
- }
- "\r\n" {
- if (path)
- p = start;
- break;
- }
- [ :|\n] {
- if (path) {
- p = start;
- break;
- } else {
- if (*start == '\n')
- break;
- eval->AddText(StringPiece(start, 1));
- continue;
- }
- }
- "$$" {
- eval->AddText(StringPiece("$", 1));
- continue;
- }
- "$ " {
- eval->AddText(StringPiece(" ", 1));
- continue;
- }
- "$\r\n"[ ]* {
- continue;
- }
- "$\n"[ ]* {
- continue;
- }
- "${"varname"}" {
- eval->AddSpecial(StringPiece(start + 2, p - start - 3));
- continue;
- }
- "$"simple_varname {
- eval->AddSpecial(StringPiece(start + 1, p - start - 1));
- continue;
- }
- "$:" {
- eval->AddText(StringPiece(":", 1));
- continue;
- }
- "$". {
- last_token_ = start;
- return Error("bad $-escape (literal $ must be written as $$)", err);
- }
- nul {
- last_token_ = start;
- return Error("unexpected EOF", err);
- }
- [^] {
- last_token_ = start;
- return Error(DescribeLastError(), err);
- }
- */
- }
- last_token_ = start;
- ofs_ = p;
- if (path)
- EatWhitespace();
- // Non-path strings end in newlines, so there's no whitespace to eat.
- return true;
-}
diff --git a/src/lexer_test.cc b/src/lexer_test.cc
deleted file mode 100644
index c5c416d..0000000
--- a/src/lexer_test.cc
+++ /dev/null
@@ -1,98 +0,0 @@
-// Copyright 2011 Google Inc. All Rights Reserved.
-//
-// Licensed under the Apache License, Version 2.0 (the "License");
-// you may not use this file except in compliance with the License.
-// You may obtain a copy of the License at
-//
-// http://www.apache.org/licenses/LICENSE-2.0
-//
-// Unless required by applicable law or agreed to in writing, software
-// distributed under the License is distributed on an "AS IS" BASIS,
-// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-// See the License for the specific language governing permissions and
-// limitations under the License.
-
-#include "lexer.h"
-
-#include "eval_env.h"
-#include "test.h"
-
-using namespace std;
-
-TEST(Lexer, ReadVarValue) {
- Lexer lexer("plain text $var $VaR ${x}\n");
- EvalString eval;
- string err;
- EXPECT_TRUE(lexer.ReadVarValue(&eval, &err));
- EXPECT_EQ("", err);
- EXPECT_EQ("[plain text ][$var][ ][$VaR][ ][$x]",
- eval.Serialize());
-}
-
-TEST(Lexer, ReadEvalStringEscapes) {
- Lexer lexer("$ $$ab c$: $\ncde\n");
- EvalString eval;
- string err;
- EXPECT_TRUE(lexer.ReadVarValue(&eval, &err));
- EXPECT_EQ("", err);
- EXPECT_EQ("[ $ab c: cde]",
- eval.Serialize());
-}
-
-TEST(Lexer, ReadIdent) {
- Lexer lexer("foo baR baz_123 foo-bar");
- string ident;
- EXPECT_TRUE(lexer.ReadIdent(&ident));
- EXPECT_EQ("foo", ident);
- EXPECT_TRUE(lexer.ReadIdent(&ident));
- EXPECT_EQ("baR", ident);
- EXPECT_TRUE(lexer.ReadIdent(&ident));
- EXPECT_EQ("baz_123", ident);
- EXPECT_TRUE(lexer.ReadIdent(&ident));
- EXPECT_EQ("foo-bar", ident);
-}
-
-TEST(Lexer, ReadIdentCurlies) {
- // Verify that ReadIdent includes dots in the name,
- // but in an expansion $bar.dots stops at the dot.
- Lexer lexer("foo.dots $bar.dots ${bar.dots}\n");
- string ident;
- EXPECT_TRUE(lexer.ReadIdent(&ident));
- EXPECT_EQ("foo.dots", ident);
-
- EvalString eval;
- string err;
- EXPECT_TRUE(lexer.ReadVarValue(&eval, &err));
- EXPECT_EQ("", err);
- EXPECT_EQ("[$bar][.dots ][$bar.dots]",
- eval.Serialize());
-}
-
-TEST(Lexer, Error) {
- Lexer lexer("foo$\nbad $");
- EvalString eval;
- string err;
- ASSERT_FALSE(lexer.ReadVarValue(&eval, &err));
- EXPECT_EQ("input:2: bad $-escape (literal $ must be written as $$)\n"
- "bad $\n"
- " ^ near here"
- , err);
-}
-
-TEST(Lexer, CommentEOF) {
- // Verify we don't run off the end of the string when the EOF is
- // mid-comment.
- Lexer lexer("# foo");
- Lexer::Token token = lexer.ReadToken();
- EXPECT_EQ(Lexer::ERROR, token);
-}
-
-TEST(Lexer, Tabs) {
- // Verify we print a useful error on a disallowed character.
- Lexer lexer(" \tfoobar");
- Lexer::Token token = lexer.ReadToken();
- EXPECT_EQ(Lexer::INDENT, token);
- token = lexer.ReadToken();
- EXPECT_EQ(Lexer::ERROR, token);
- EXPECT_EQ("tabs are not allowed, use spaces", lexer.DescribeLastError());
-}
diff --git a/src/line_printer.cc b/src/line_printer.cc
deleted file mode 100644
index c883837..0000000
--- a/src/line_printer.cc
+++ /dev/null
@@ -1,175 +0,0 @@
-// Copyright 2013 Google Inc. All Rights Reserved.
-//
-// Licensed under the Apache License, Version 2.0 (the "License");
-// you may not use this file except in compliance with the License.
-// You may obtain a copy of the License at
-//
-// http://www.apache.org/licenses/LICENSE-2.0
-//
-// Unless required by applicable law or agreed to in writing, software
-// distributed under the License is distributed on an "AS IS" BASIS,
-// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-// See the License for the specific language governing permissions and
-// limitations under the License.
-
-#include "line_printer.h"
-
-#include <stdio.h>
-#include <stdlib.h>
-#ifdef _WIN32
-#include <windows.h>
-#ifndef ENABLE_VIRTUAL_TERMINAL_PROCESSING
-#define ENABLE_VIRTUAL_TERMINAL_PROCESSING 0x4
-#endif
-#else
-#include <unistd.h>
-#include <sys/ioctl.h>
-#include <termios.h>
-#include <sys/time.h>
-#endif
-
-#include "util.h"
-
-using namespace std;
-
-LinePrinter::LinePrinter() {
- Reset(getenv("TERM"), getenv("CLICOLOR_FORCE"));
-}
-
-void LinePrinter::Reset(const char* term, const char* clicolor_force) {
- have_blank_line_ = true;
- console_locked_ = false;
- line_buffer_.clear();
- output_buffer_.clear();
- line_type_ = FULL;
-
-#ifndef _WIN32
- smart_terminal_ = isatty(1) && term && string(term) != "dumb";
-#else
- if (term && string(term) == "dumb") {
- smart_terminal_ = false;
- } else {
- console_ = GetStdHandle(STD_OUTPUT_HANDLE);
- CONSOLE_SCREEN_BUFFER_INFO csbi;
- smart_terminal_ = GetConsoleScreenBufferInfo(console_, &csbi);
- }
-#endif
- supports_color_ = smart_terminal_;
-#ifdef _WIN32
- // Try enabling ANSI escape sequence support on Windows 10 terminals.
- if (supports_color_) {
- DWORD mode;
- if (GetConsoleMode(console_, &mode)) {
- if (!SetConsoleMode(console_, mode | ENABLE_VIRTUAL_TERMINAL_PROCESSING)) {
- supports_color_ = false;
- }
- }
- }
-#endif
- if (!supports_color_) {
- supports_color_ = clicolor_force && std::string(clicolor_force) != "0";
- }
-}
-
-void LinePrinter::Print(string to_print, LineType type) {
- if (console_locked_) {
- line_buffer_ = to_print;
- line_type_ = type;
- return;
- }
-
- if (smart_terminal_) {
- printf("\r"); // Print over previous line, if any.
- // On Windows, calling a C library function writing to stdout also handles
- // pausing the executable when the "Pause" key or Ctrl-S is pressed.
- }
-
- if (smart_terminal_ && type == ELIDE) {
-#ifdef _WIN32
- CONSOLE_SCREEN_BUFFER_INFO csbi;
- GetConsoleScreenBufferInfo(console_, &csbi);
-
- to_print = ElideMiddle(to_print, static_cast<size_t>(csbi.dwSize.X));
- if (supports_color_) { // this means ENABLE_VIRTUAL_TERMINAL_PROCESSING
- // succeeded
- printf("%s\x1B[K", to_print.c_str()); // Clear to end of line.
- fflush(stdout);
- } else {
- // We don't want to have the cursor spamming back and forth, so instead of
- // printf use WriteConsoleOutput which updates the contents of the buffer,
- // but doesn't move the cursor position.
- COORD buf_size = { csbi.dwSize.X, 1 };
- COORD zero_zero = { 0, 0 };
- SMALL_RECT target = { csbi.dwCursorPosition.X, csbi.dwCursorPosition.Y,
- static_cast<SHORT>(csbi.dwCursorPosition.X +
- csbi.dwSize.X - 1),
- csbi.dwCursorPosition.Y };
- vector<CHAR_INFO> char_data(csbi.dwSize.X);
- for (size_t i = 0; i < static_cast<size_t>(csbi.dwSize.X); ++i) {
- char_data[i].Char.AsciiChar = i < to_print.size() ? to_print[i] : ' ';
- char_data[i].Attributes = csbi.wAttributes;
- }
- WriteConsoleOutput(console_, &char_data[0], buf_size, zero_zero, &target);
- }
-#else
- // Limit output to width of the terminal if provided so we don't cause
- // line-wrapping.
- winsize size;
- if ((ioctl(STDOUT_FILENO, TIOCGWINSZ, &size) == 0) && size.ws_col) {
- to_print = ElideMiddle(to_print, size.ws_col);
- }
- printf("%s", to_print.c_str());
- printf("\x1B[K"); // Clear to end of line.
- fflush(stdout);
-#endif
-
- have_blank_line_ = false;
- } else {
- printf("%s\n", to_print.c_str());
- fflush(stdout);
- }
-}
-
-void LinePrinter::PrintOrBuffer(const char* data, size_t size) {
- if (console_locked_) {
- output_buffer_.append(data, size);
- } else {
- // Avoid printf and C strings, since the actual output might contain null
- // bytes like UTF-16 does (yuck).
- fwrite(data, 1, size, stdout);
- }
-}
-
-void LinePrinter::PrintOnNewLine(const string& to_print) {
- if (console_locked_ && !line_buffer_.empty()) {
- output_buffer_.append(line_buffer_);
- output_buffer_.append(1, '\n');
- line_buffer_.clear();
- }
- if (!have_blank_line_) {
- PrintOrBuffer("\n", 1);
- }
- if (!to_print.empty()) {
- PrintOrBuffer(&to_print[0], to_print.size());
- }
- have_blank_line_ = to_print.empty() || *to_print.rbegin() == '\n';
-}
-
-void LinePrinter::SetConsoleLocked(bool locked) {
- if (locked == console_locked_)
- return;
-
- if (locked)
- PrintOnNewLine("");
-
- console_locked_ = locked;
-
- if (!locked) {
- PrintOnNewLine(output_buffer_);
- if (!line_buffer_.empty()) {
- Print(line_buffer_, line_type_);
- }
- output_buffer_.clear();
- line_buffer_.clear();
- }
-}
diff --git a/src/line_printer.h b/src/line_printer.h
deleted file mode 100644
index 60e1450..0000000
--- a/src/line_printer.h
+++ /dev/null
@@ -1,83 +0,0 @@
-// Copyright 2013 Google Inc. All Rights Reserved.
-//
-// Licensed under the Apache License, Version 2.0 (the "License");
-// you may not use this file except in compliance with the License.
-// You may obtain a copy of the License at
-//
-// http://www.apache.org/licenses/LICENSE-2.0
-//
-// Unless required by applicable law or agreed to in writing, software
-// distributed under the License is distributed on an "AS IS" BASIS,
-// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-// See the License for the specific language governing permissions and
-// limitations under the License.
-
-#ifndef NINJA_LINE_PRINTER_H_
-#define NINJA_LINE_PRINTER_H_
-
-#include <stddef.h>
-#include <string>
-
-/// Prints lines of text, possibly overprinting previously printed lines
-/// if the terminal supports it.
-struct LinePrinter {
- LinePrinter();
-
- bool is_smart_terminal() const { return smart_terminal_; }
- void set_smart_terminal(bool smart) { smart_terminal_ = smart; }
-
- bool supports_color() const { return supports_color_; }
-
- enum LineType {
- FULL,
- ELIDE
- };
- /// Overprints the current line. If type is ELIDE, elides to_print to fit on
- /// one line.
- void Print(std::string to_print, LineType type);
-
- /// Prints a string on a new line, not overprinting previous output.
- void PrintOnNewLine(const std::string& to_print);
-
- /// Lock or unlock the console. Any output sent to the LinePrinter while the
- /// console is locked will not be printed until it is unlocked.
- void SetConsoleLocked(bool locked);
-
- /// Reset LinePrinter instance, re-reading environment variables and other
- /// console seettings to adapt to changes during incremental builds.
- /// |term| is the value of the TERM environment variable, or NULL if not
- /// defined, and |clicolor_force| is the value of the CLICOLOR_FORCE
- /// environment variable if define, or NULL otherwise.
- void Reset(const char* term, const char* clicolor_force);
-
- private:
- /// Whether we can do fancy terminal control codes.
- bool smart_terminal_;
-
- /// Whether we can use ISO 6429 (ANSI) color sequences.
- bool supports_color_;
-
- /// Whether the caret is at the beginning of a blank line.
- bool have_blank_line_;
-
- /// Whether console is locked.
- bool console_locked_;
-
- /// Buffered current line while console is locked.
- std::string line_buffer_;
-
- /// Buffered line type while console is locked.
- LineType line_type_;
-
- /// Buffered console output while console is locked.
- std::string output_buffer_;
-
-#ifdef _WIN32
- void* console_;
-#endif
-
- /// Print the given data to the console, or buffer it if it is locked.
- void PrintOrBuffer(const char *data, size_t size);
-};
-
-#endif // NINJA_LINE_PRINTER_H_
diff --git a/src/load_status.h b/src/load_status.h
deleted file mode 100644
index 0b16b1a..0000000
--- a/src/load_status.h
+++ /dev/null
@@ -1,24 +0,0 @@
-// Copyright 2019 Google Inc. All Rights Reserved.
-//
-// Licensed under the Apache License, Version 2.0 (the "License");
-// you may not use this file except in compliance with the License.
-// You may obtain a copy of the License at
-//
-// http://www.apache.org/licenses/LICENSE-2.0
-//
-// Unless required by applicable law or agreed to in writing, software
-// distributed under the License is distributed on an "AS IS" BASIS,
-// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-// See the License for the specific language governing permissions and
-// limitations under the License.
-
-#ifndef NINJA_LOAD_STATUS_H_
-#define NINJA_LOAD_STATUS_H_
-
-enum LoadStatus {
- LOAD_ERROR,
- LOAD_SUCCESS,
- LOAD_NOT_FOUND,
-};
-
-#endif // NINJA_LOAD_STATUS_H_
diff --git a/src/manifest_parser.cc b/src/manifest_parser.cc
deleted file mode 100644
index c90b9b6..0000000
--- a/src/manifest_parser.cc
+++ /dev/null
@@ -1,447 +0,0 @@
-// Copyright 2011 Google Inc. All Rights Reserved.
-//
-// Licensed under the Apache License, Version 2.0 (the "License");
-// you may not use this file except in compliance with the License.
-// You may obtain a copy of the License at
-//
-// http://www.apache.org/licenses/LICENSE-2.0
-//
-// Unless required by applicable law or agreed to in writing, software
-// distributed under the License is distributed on an "AS IS" BASIS,
-// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-// See the License for the specific language governing permissions and
-// limitations under the License.
-
-#include "manifest_parser.h"
-
-#include <assert.h>
-#include <stdio.h>
-#include <stdlib.h>
-
-#include <vector>
-
-#include "graph.h"
-#include "state.h"
-#include "util.h"
-#include "version.h"
-
-using namespace std;
-
-ManifestParser::ManifestParser(State* state, FileReader* file_reader,
- ManifestParserOptions options)
- : Parser(state, file_reader),
- options_(options), quiet_(false) {
- env_ = &state->bindings();
-}
-
-bool ManifestParser::Parse(const string& filename, const string& input,
- string* err) {
- lexer_.Start(filename, input);
-
- for (;;) {
- Lexer::Token token = lexer_.ReadToken();
- switch (token) {
- case Lexer::POOL:
- if (!ParsePool(err))
- return false;
- break;
- case Lexer::BUILD:
- if (!ParseEdge(err))
- return false;
- break;
- case Lexer::RULE:
- if (!ParseRule(err))
- return false;
- break;
- case Lexer::DEFAULT:
- if (!ParseDefault(err))
- return false;
- break;
- case Lexer::IDENT: {
- lexer_.UnreadToken();
- string name;
- EvalString let_value;
- if (!ParseLet(&name, &let_value, err))
- return false;
- string value = let_value.Evaluate(env_);
- // Check ninja_required_version immediately so we can exit
- // before encountering any syntactic surprises.
- if (name == "ninja_required_version")
- CheckNinjaVersion(value);
- env_->AddBinding(name, value);
- break;
- }
- case Lexer::INCLUDE:
- if (!ParseFileInclude(false, err))
- return false;
- break;
- case Lexer::SUBNINJA:
- if (!ParseFileInclude(true, err))
- return false;
- break;
- case Lexer::ERROR: {
- return lexer_.Error(lexer_.DescribeLastError(), err);
- }
- case Lexer::TEOF:
- return true;
- case Lexer::NEWLINE:
- break;
- default:
- return lexer_.Error(string("unexpected ") + Lexer::TokenName(token),
- err);
- }
- }
- return false; // not reached
-}
-
-
-bool ManifestParser::ParsePool(string* err) {
- string name;
- if (!lexer_.ReadIdent(&name))
- return lexer_.Error("expected pool name", err);
-
- if (!ExpectToken(Lexer::NEWLINE, err))
- return false;
-
- if (state_->LookupPool(name) != NULL)
- return lexer_.Error("duplicate pool '" + name + "'", err);
-
- int depth = -1;
-
- while (lexer_.PeekToken(Lexer::INDENT)) {
- string key;
- EvalString value;
- if (!ParseLet(&key, &value, err))
- return false;
-
- if (key == "depth") {
- string depth_string = value.Evaluate(env_);
- depth = atol(depth_string.c_str());
- if (depth < 0)
- return lexer_.Error("invalid pool depth", err);
- } else {
- return lexer_.Error("unexpected variable '" + key + "'", err);
- }
- }
-
- if (depth < 0)
- return lexer_.Error("expected 'depth =' line", err);
-
- state_->AddPool(new Pool(name, depth));
- return true;
-}
-
-
-bool ManifestParser::ParseRule(string* err) {
- string name;
- if (!lexer_.ReadIdent(&name))
- return lexer_.Error("expected rule name", err);
-
- if (!ExpectToken(Lexer::NEWLINE, err))
- return false;
-
- if (env_->LookupRuleCurrentScope(name) != NULL)
- return lexer_.Error("duplicate rule '" + name + "'", err);
-
- auto rule = std::unique_ptr<Rule>(new Rule(name));
-
- while (lexer_.PeekToken(Lexer::INDENT)) {
- string key;
- EvalString value;
- if (!ParseLet(&key, &value, err))
- return false;
-
- if (Rule::IsReservedBinding(key)) {
- rule->AddBinding(key, value);
- } else {
- // Die on other keyvals for now; revisit if we want to add a
- // scope here.
- return lexer_.Error("unexpected variable '" + key + "'", err);
- }
- }
-
- if (rule->bindings_["rspfile"].empty() !=
- rule->bindings_["rspfile_content"].empty()) {
- return lexer_.Error("rspfile and rspfile_content need to be "
- "both specified", err);
- }
-
- if (rule->bindings_["command"].empty())
- return lexer_.Error("expected 'command =' line", err);
-
- env_->AddRule(rule.release());
- return true;
-}
-
-bool ManifestParser::ParseLet(string* key, EvalString* value, string* err) {
- if (!lexer_.ReadIdent(key))
- return lexer_.Error("expected variable name", err);
- if (!ExpectToken(Lexer::EQUALS, err))
- return false;
- if (!lexer_.ReadVarValue(value, err))
- return false;
- return true;
-}
-
-bool ManifestParser::ParseDefault(string* err) {
- EvalString eval;
- if (!lexer_.ReadPath(&eval, err))
- return false;
- if (eval.empty())
- return lexer_.Error("expected target name", err);
-
- do {
- string path = eval.Evaluate(env_);
- if (path.empty())
- return lexer_.Error("empty path", err);
- uint64_t slash_bits; // Unused because this only does lookup.
- CanonicalizePath(&path, &slash_bits);
- std::string default_err;
- if (!state_->AddDefault(path, &default_err))
- return lexer_.Error(default_err, err);
-
- eval.Clear();
- if (!lexer_.ReadPath(&eval, err))
- return false;
- } while (!eval.empty());
-
- return ExpectToken(Lexer::NEWLINE, err);
-}
-
-bool ManifestParser::ParseEdge(string* err) {
- vector<EvalString> ins, outs, validations;
-
- {
- EvalString out;
- if (!lexer_.ReadPath(&out, err))
- return false;
- while (!out.empty()) {
- outs.push_back(out);
-
- out.Clear();
- if (!lexer_.ReadPath(&out, err))
- return false;
- }
- }
-
- // Add all implicit outs, counting how many as we go.
- int implicit_outs = 0;
- if (lexer_.PeekToken(Lexer::PIPE)) {
- for (;;) {
- EvalString out;
- if (!lexer_.ReadPath(&out, err))
- return false;
- if (out.empty())
- break;
- outs.push_back(out);
- ++implicit_outs;
- }
- }
-
- if (outs.empty())
- return lexer_.Error("expected path", err);
-
- if (!ExpectToken(Lexer::COLON, err))
- return false;
-
- string rule_name;
- if (!lexer_.ReadIdent(&rule_name))
- return lexer_.Error("expected build command name", err);
-
- const Rule* rule = env_->LookupRule(rule_name);
- if (!rule)
- return lexer_.Error("unknown build rule '" + rule_name + "'", err);
-
- for (;;) {
- // XXX should we require one path here?
- EvalString in;
- if (!lexer_.ReadPath(&in, err))
- return false;
- if (in.empty())
- break;
- ins.push_back(in);
- }
-
- // Add all implicit deps, counting how many as we go.
- int implicit = 0;
- if (lexer_.PeekToken(Lexer::PIPE)) {
- for (;;) {
- EvalString in;
- if (!lexer_.ReadPath(&in, err))
- return false;
- if (in.empty())
- break;
- ins.push_back(in);
- ++implicit;
- }
- }
-
- // Add all order-only deps, counting how many as we go.
- int order_only = 0;
- if (lexer_.PeekToken(Lexer::PIPE2)) {
- for (;;) {
- EvalString in;
- if (!lexer_.ReadPath(&in, err))
- return false;
- if (in.empty())
- break;
- ins.push_back(in);
- ++order_only;
- }
- }
-
- // Add all validations, counting how many as we go.
- if (lexer_.PeekToken(Lexer::PIPEAT)) {
- for (;;) {
- EvalString validation;
- if (!lexer_.ReadPath(&validation, err))
- return false;
- if (validation.empty())
- break;
- validations.push_back(validation);
- }
- }
-
- if (!ExpectToken(Lexer::NEWLINE, err))
- return false;
-
- // Bindings on edges are rare, so allocate per-edge envs only when needed.
- bool has_indent_token = lexer_.PeekToken(Lexer::INDENT);
- BindingEnv* env = has_indent_token ? state_->CreateNewEnv(env_) : env_;
- while (has_indent_token) {
- string key;
- EvalString val;
- if (!ParseLet(&key, &val, err))
- return false;
-
- env->AddBinding(key, val.Evaluate(env_));
- has_indent_token = lexer_.PeekToken(Lexer::INDENT);
- }
-
- Edge* edge = state_->AddEdge(rule);
- edge->env_ = env;
-
- string pool_name = edge->GetBinding("pool");
- if (!pool_name.empty()) {
- Pool* pool = state_->LookupPool(pool_name);
- if (pool == NULL)
- return lexer_.Error("unknown pool name '" + pool_name + "'", err);
- edge->pool_ = pool;
- }
-
- edge->outputs_.reserve(outs.size());
- for (size_t i = 0, e = outs.size(); i != e; ++i) {
- string path = outs[i].Evaluate(env);
- if (path.empty())
- return lexer_.Error("empty path", err);
- uint64_t slash_bits;
- CanonicalizePath(&path, &slash_bits);
- if (!state_->AddOut(edge, path, slash_bits)) {
- if (options_.dupe_edge_action_ == kDupeEdgeActionError) {
- lexer_.Error("multiple rules generate " + path, err);
- return false;
- } else {
- if (!quiet_) {
- Warning(
- "multiple rules generate %s. builds involving this target will "
- "not be correct; continuing anyway",
- path.c_str());
- }
- if (e - i <= static_cast<size_t>(implicit_outs))
- --implicit_outs;
- }
- }
- }
-
- if (edge->outputs_.empty()) {
- // All outputs of the edge are already created by other edges. Don't add
- // this edge. Do this check before input nodes are connected to the edge.
- state_->edges_.pop_back();
- delete edge;
- return true;
- }
- edge->static_implicit_outs_ = edge->implicit_outs_ = implicit_outs;
-
- edge->inputs_.reserve(ins.size());
- for (vector<EvalString>::iterator i = ins.begin(); i != ins.end(); ++i) {
- string path = i->Evaluate(env);
- if (path.empty())
- return lexer_.Error("empty path", err);
- uint64_t slash_bits;
- CanonicalizePath(&path, &slash_bits);
- state_->AddIn(edge, path, slash_bits);
- }
- edge->static_implicit_deps_ = edge->implicit_deps_ = implicit;
- edge->order_only_deps_ = order_only;
-
- edge->validations_.reserve(validations.size());
- for (std::vector<EvalString>::iterator v = validations.begin();
- v != validations.end(); ++v) {
- string path = v->Evaluate(env);
- if (path.empty())
- return lexer_.Error("empty path", err);
- uint64_t slash_bits;
- CanonicalizePath(&path, &slash_bits);
- state_->AddValidation(edge, path, slash_bits);
- }
-
- if (options_.phony_cycle_action_ == kPhonyCycleActionWarn &&
- edge->maybe_phonycycle_diagnostic()) {
- // CMake 2.8.12.x and 3.0.x incorrectly write phony build statements
- // that reference themselves. Ninja used to tolerate these in the
- // build graph but that has since been fixed. Filter them out to
- // support users of those old CMake versions.
- Node* out = edge->outputs_[0];
- vector<Node*>::iterator new_end =
- remove(edge->inputs_.begin(), edge->inputs_.end(), out);
- if (new_end != edge->inputs_.end()) {
- edge->inputs_.erase(new_end, edge->inputs_.end());
- if (!quiet_) {
- Warning("phony target '%s' names itself as an input; "
- "ignoring [-w phonycycle=warn]",
- out->path().c_str());
- }
- }
- }
-
- // Lookup, validate, and save any dyndep binding. It will be used later
- // to load generated dependency information dynamically, but it must
- // be one of our manifest-specified inputs.
- string dyndep = edge->GetUnescapedDyndep();
- if (!dyndep.empty()) {
- uint64_t slash_bits;
- CanonicalizePath(&dyndep, &slash_bits);
- edge->dyndep_ = state_->GetNode(dyndep, slash_bits);
- edge->dyndep_->set_dyndep_pending(true);
- vector<Node*>::iterator dgi =
- std::find(edge->inputs_.begin(), edge->inputs_.end(), edge->dyndep_);
- if (dgi == edge->inputs_.end()) {
- return lexer_.Error("dyndep '" + dyndep + "' is not an input", err);
- }
- assert(!edge->dyndep_->generated_by_dep_loader());
- }
-
- return true;
-}
-
-bool ManifestParser::ParseFileInclude(bool new_scope, string* err) {
- EvalString eval;
- if (!lexer_.ReadPath(&eval, err))
- return false;
- string path = eval.Evaluate(env_);
-
- ManifestParser subparser(state_, file_reader_, options_);
- if (new_scope) {
- subparser.env_ = state_->CreateNewEnv(env_);
- } else {
- subparser.env_ = env_;
- }
-
- if (!subparser.Load(path, err, &lexer_))
- return false;
-
- if (!ExpectToken(Lexer::NEWLINE, err))
- return false;
-
- return true;
-}
diff --git a/src/manifest_parser.h b/src/manifest_parser.h
deleted file mode 100644
index 954cf46..0000000
--- a/src/manifest_parser.h
+++ /dev/null
@@ -1,72 +0,0 @@
-// Copyright 2011 Google Inc. All Rights Reserved.
-//
-// Licensed under the Apache License, Version 2.0 (the "License");
-// you may not use this file except in compliance with the License.
-// You may obtain a copy of the License at
-//
-// http://www.apache.org/licenses/LICENSE-2.0
-//
-// Unless required by applicable law or agreed to in writing, software
-// distributed under the License is distributed on an "AS IS" BASIS,
-// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-// See the License for the specific language governing permissions and
-// limitations under the License.
-
-#ifndef NINJA_MANIFEST_PARSER_H_
-#define NINJA_MANIFEST_PARSER_H_
-
-#include "parser.h"
-
-struct BindingEnv;
-struct EvalString;
-
-enum DupeEdgeAction {
- kDupeEdgeActionWarn,
- kDupeEdgeActionError,
-};
-
-enum PhonyCycleAction {
- kPhonyCycleActionWarn,
- kPhonyCycleActionError,
-};
-
-struct ManifestParserOptions {
- ManifestParserOptions()
- : dupe_edge_action_(kDupeEdgeActionWarn),
- phony_cycle_action_(kPhonyCycleActionWarn) {}
- DupeEdgeAction dupe_edge_action_;
- PhonyCycleAction phony_cycle_action_;
-};
-
-/// Parses .ninja files.
-struct ManifestParser : public Parser {
- ManifestParser(State* state, FileReader* file_reader,
- ManifestParserOptions options = ManifestParserOptions());
-
- /// Parse a text string of input. Used by tests.
- bool ParseTest(const std::string& input, std::string* err) {
- quiet_ = true;
- return Parse("input", input, err);
- }
-
-private:
- /// Parse a file, given its contents as a string.
- bool Parse(const std::string& filename, const std::string& input,
- std::string* err);
-
- /// Parse various statement types.
- bool ParsePool(std::string* err);
- bool ParseRule(std::string* err);
- bool ParseLet(std::string* key, EvalString* val, std::string* err);
- bool ParseEdge(std::string* err);
- bool ParseDefault(std::string* err);
-
- /// Parse either a 'subninja' or 'include' line.
- bool ParseFileInclude(bool new_scope, std::string* err);
-
- BindingEnv* env_;
- ManifestParserOptions options_;
- bool quiet_;
-};
-
-#endif // NINJA_MANIFEST_PARSER_H_
diff --git a/src/manifest_parser_perftest.cc b/src/manifest_parser_perftest.cc
deleted file mode 100644
index fb1dbbf..0000000
--- a/src/manifest_parser_perftest.cc
+++ /dev/null
@@ -1,123 +0,0 @@
-// Copyright 2014 Google Inc. All Rights Reserved.
-//
-// Licensed under the Apache License, Version 2.0 (the "License");
-// you may not use this file except in compliance with the License.
-// You may obtain a copy of the License at
-//
-// http://www.apache.org/licenses/LICENSE-2.0
-//
-// Unless required by applicable law or agreed to in writing, software
-// distributed under the License is distributed on an "AS IS" BASIS,
-// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-// See the License for the specific language governing permissions and
-// limitations under the License.
-
-// Tests manifest parser performance. Expects to be run in ninja's root
-// directory.
-
-#include <numeric>
-
-#include <errno.h>
-#include <stdio.h>
-#include <stdlib.h>
-#include <string.h>
-
-#ifdef _WIN32
-#include "getopt.h"
-#include <direct.h>
-#elif defined(_AIX)
-#include "getopt.h"
-#include <unistd.h>
-#else
-#include <getopt.h>
-#include <unistd.h>
-#endif
-
-#include "disk_interface.h"
-#include "graph.h"
-#include "manifest_parser.h"
-#include "metrics.h"
-#include "state.h"
-#include "util.h"
-
-using namespace std;
-
-bool WriteFakeManifests(const string& dir, string* err) {
- RealDiskInterface disk_interface;
- TimeStamp mtime = disk_interface.Stat(dir + "/build.ninja", err);
- if (mtime != 0) // 0 means that the file doesn't exist yet.
- return mtime != -1;
-
- string command = "python misc/write_fake_manifests.py " + dir;
- printf("Creating manifest data..."); fflush(stdout);
- int exit_code = system(command.c_str());
- printf("done.\n");
- if (exit_code != 0)
- *err = "Failed to run " + command;
- return exit_code == 0;
-}
-
-int LoadManifests(bool measure_command_evaluation) {
- string err;
- RealDiskInterface disk_interface;
- State state;
- ManifestParser parser(&state, &disk_interface);
- if (!parser.Load("build.ninja", &err)) {
- fprintf(stderr, "Failed to read test data: %s\n", err.c_str());
- exit(1);
- }
- // Doing an empty build involves reading the manifest and evaluating all
- // commands required for the requested targets. So include command
- // evaluation in the perftest by default.
- int optimization_guard = 0;
- if (measure_command_evaluation)
- for (size_t i = 0; i < state.edges_.size(); ++i)
- optimization_guard += state.edges_[i]->EvaluateCommand().size();
- return optimization_guard;
-}
-
-int main(int argc, char* argv[]) {
- bool measure_command_evaluation = true;
- int opt;
- while ((opt = getopt(argc, argv, const_cast<char*>("fh"))) != -1) {
- switch (opt) {
- case 'f':
- measure_command_evaluation = false;
- break;
- case 'h':
- default:
- printf("usage: manifest_parser_perftest\n"
-"\n"
-"options:\n"
-" -f only measure manifest load time, not command evaluation time\n"
- );
- return 1;
- }
- }
-
- const char kManifestDir[] = "build/manifest_perftest";
-
- string err;
- if (!WriteFakeManifests(kManifestDir, &err)) {
- fprintf(stderr, "Failed to write test data: %s\n", err.c_str());
- return 1;
- }
-
- if (chdir(kManifestDir) < 0)
- ErrnoFatal("chdir");
-
- const int kNumRepetitions = 5;
- vector<int> times;
- for (int i = 0; i < kNumRepetitions; ++i) {
- int64_t start = GetTimeMillis();
- int optimization_guard = LoadManifests(measure_command_evaluation);
- int delta = (int)(GetTimeMillis() - start);
- printf("%dms (hash: %x)\n", delta, optimization_guard);
- times.push_back(delta);
- }
-
- int min = *min_element(times.begin(), times.end());
- int max = *max_element(times.begin(), times.end());
- float total = accumulate(times.begin(), times.end(), 0.0f);
- printf("min %dms max %dms avg %.1fms\n", min, max, total / times.size());
-}
diff --git a/src/manifest_parser_test.cc b/src/manifest_parser_test.cc
deleted file mode 100644
index b286d85..0000000
--- a/src/manifest_parser_test.cc
+++ /dev/null
@@ -1,1167 +0,0 @@
-// Copyright 2011 Google Inc. All Rights Reserved.
-//
-// Licensed under the Apache License, Version 2.0 (the "License");
-// you may not use this file except in compliance with the License.
-// You may obtain a copy of the License at
-//
-// http://www.apache.org/licenses/LICENSE-2.0
-//
-// Unless required by applicable law or agreed to in writing, software
-// distributed under the License is distributed on an "AS IS" BASIS,
-// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-// See the License for the specific language governing permissions and
-// limitations under the License.
-
-#include "manifest_parser.h"
-
-#include <map>
-#include <vector>
-
-#include "graph.h"
-#include "state.h"
-#include "test.h"
-
-using namespace std;
-
-struct ParserTest : public testing::Test {
- void AssertParse(const char* input) {
- ManifestParser parser(&state, &fs_);
- string err;
- EXPECT_TRUE(parser.ParseTest(input, &err));
- ASSERT_EQ("", err);
- VerifyGraph(state);
- }
-
- State state;
- VirtualFileSystem fs_;
-};
-
-TEST_F(ParserTest, Empty) {
- ASSERT_NO_FATAL_FAILURE(AssertParse(""));
-}
-
-TEST_F(ParserTest, Rules) {
- ASSERT_NO_FATAL_FAILURE(AssertParse(
-"rule cat\n"
-" command = cat $in > $out\n"
-"\n"
-"rule date\n"
-" command = date > $out\n"
-"\n"
-"build result: cat in_1.cc in-2.O\n"));
-
- ASSERT_EQ(3u, state.bindings().GetRules().size());
- const Rule* rule = state.bindings().GetRules().begin()->second.get();
- EXPECT_EQ("cat", rule->name());
- EXPECT_EQ("[cat ][$in][ > ][$out]",
- rule->GetBinding("command")->Serialize());
-}
-
-TEST_F(ParserTest, RuleAttributes) {
- // Check that all of the allowed rule attributes are parsed ok.
- ASSERT_NO_FATAL_FAILURE(AssertParse(
-"rule cat\n"
-" command = a\n"
-" depfile = a\n"
-" deps = a\n"
-" description = a\n"
-" generator = a\n"
-" restat = a\n"
-" rspfile = a\n"
-" rspfile_content = a\n"
-));
-}
-
-TEST_F(ParserTest, IgnoreIndentedComments) {
- ASSERT_NO_FATAL_FAILURE(AssertParse(
-" #indented comment\n"
-"rule cat\n"
-" command = cat $in > $out\n"
-" #generator = 1\n"
-" restat = 1 # comment\n"
-" #comment\n"
-"build result: cat in_1.cc in-2.O\n"
-" #comment\n"));
-
- ASSERT_EQ(2u, state.bindings().GetRules().size());
- const Rule* rule = state.bindings().GetRules().begin()->second.get();
- EXPECT_EQ("cat", rule->name());
- Edge* edge = state.GetNode("result", 0)->in_edge();
- EXPECT_TRUE(edge->GetBindingBool("restat"));
- EXPECT_FALSE(edge->GetBindingBool("generator"));
-}
-
-TEST_F(ParserTest, IgnoreIndentedBlankLines) {
- // the indented blanks used to cause parse errors
- ASSERT_NO_FATAL_FAILURE(AssertParse(
-" \n"
-"rule cat\n"
-" command = cat $in > $out\n"
-" \n"
-"build result: cat in_1.cc in-2.O\n"
-" \n"
-"variable=1\n"));
-
- // the variable must be in the top level environment
- EXPECT_EQ("1", state.bindings().LookupVariable("variable"));
-}
-
-TEST_F(ParserTest, ResponseFiles) {
- ASSERT_NO_FATAL_FAILURE(AssertParse(
-"rule cat_rsp\n"
-" command = cat $rspfile > $out\n"
-" rspfile = $rspfile\n"
-" rspfile_content = $in\n"
-"\n"
-"build out: cat_rsp in\n"
-" rspfile=out.rsp\n"));
-
- ASSERT_EQ(2u, state.bindings().GetRules().size());
- const Rule* rule = state.bindings().GetRules().begin()->second.get();
- EXPECT_EQ("cat_rsp", rule->name());
- EXPECT_EQ("[cat ][$rspfile][ > ][$out]",
- rule->GetBinding("command")->Serialize());
- EXPECT_EQ("[$rspfile]", rule->GetBinding("rspfile")->Serialize());
- EXPECT_EQ("[$in]", rule->GetBinding("rspfile_content")->Serialize());
-}
-
-TEST_F(ParserTest, InNewline) {
- ASSERT_NO_FATAL_FAILURE(AssertParse(
-"rule cat_rsp\n"
-" command = cat $in_newline > $out\n"
-"\n"
-"build out: cat_rsp in in2\n"
-" rspfile=out.rsp\n"));
-
- ASSERT_EQ(2u, state.bindings().GetRules().size());
- const Rule* rule = state.bindings().GetRules().begin()->second.get();
- EXPECT_EQ("cat_rsp", rule->name());
- EXPECT_EQ("[cat ][$in_newline][ > ][$out]",
- rule->GetBinding("command")->Serialize());
-
- Edge* edge = state.edges_[0];
- EXPECT_EQ("cat in\nin2 > out", edge->EvaluateCommand());
-}
-
-TEST_F(ParserTest, Variables) {
- ASSERT_NO_FATAL_FAILURE(AssertParse(
-"l = one-letter-test\n"
-"rule link\n"
-" command = ld $l $extra $with_under -o $out $in\n"
-"\n"
-"extra = -pthread\n"
-"with_under = -under\n"
-"build a: link b c\n"
-"nested1 = 1\n"
-"nested2 = $nested1/2\n"
-"build supernested: link x\n"
-" extra = $nested2/3\n"));
-
- ASSERT_EQ(2u, state.edges_.size());
- Edge* edge = state.edges_[0];
- EXPECT_EQ("ld one-letter-test -pthread -under -o a b c",
- edge->EvaluateCommand());
- EXPECT_EQ("1/2", state.bindings().LookupVariable("nested2"));
-
- edge = state.edges_[1];
- EXPECT_EQ("ld one-letter-test 1/2/3 -under -o supernested x",
- edge->EvaluateCommand());
-}
-
-TEST_F(ParserTest, VariableScope) {
- ASSERT_NO_FATAL_FAILURE(AssertParse(
-"foo = bar\n"
-"rule cmd\n"
-" command = cmd $foo $in $out\n"
-"\n"
-"build inner: cmd a\n"
-" foo = baz\n"
-"build outer: cmd b\n"
-"\n" // Extra newline after build line tickles a regression.
-));
-
- ASSERT_EQ(2u, state.edges_.size());
- EXPECT_EQ("cmd baz a inner", state.edges_[0]->EvaluateCommand());
- EXPECT_EQ("cmd bar b outer", state.edges_[1]->EvaluateCommand());
-}
-
-TEST_F(ParserTest, Continuation) {
- ASSERT_NO_FATAL_FAILURE(AssertParse(
-"rule link\n"
-" command = foo bar $\n"
-" baz\n"
-"\n"
-"build a: link c $\n"
-" d e f\n"));
-
- ASSERT_EQ(2u, state.bindings().GetRules().size());
- const Rule* rule = state.bindings().GetRules().begin()->second.get();
- EXPECT_EQ("link", rule->name());
- EXPECT_EQ("[foo bar baz]", rule->GetBinding("command")->Serialize());
-}
-
-TEST_F(ParserTest, Backslash) {
- ASSERT_NO_FATAL_FAILURE(AssertParse(
-"foo = bar\\baz\n"
-"foo2 = bar\\ baz\n"
-));
- EXPECT_EQ("bar\\baz", state.bindings().LookupVariable("foo"));
- EXPECT_EQ("bar\\ baz", state.bindings().LookupVariable("foo2"));
-}
-
-TEST_F(ParserTest, Comment) {
- ASSERT_NO_FATAL_FAILURE(AssertParse(
-"# this is a comment\n"
-"foo = not # a comment\n"));
- EXPECT_EQ("not # a comment", state.bindings().LookupVariable("foo"));
-}
-
-TEST_F(ParserTest, Dollars) {
- ASSERT_NO_FATAL_FAILURE(AssertParse(
-"rule foo\n"
-" command = ${out}bar$$baz$$$\n"
-"blah\n"
-"x = $$dollar\n"
-"build $x: foo y\n"
-));
- EXPECT_EQ("$dollar", state.bindings().LookupVariable("x"));
-#ifdef _WIN32
- EXPECT_EQ("$dollarbar$baz$blah", state.edges_[0]->EvaluateCommand());
-#else
- EXPECT_EQ("'$dollar'bar$baz$blah", state.edges_[0]->EvaluateCommand());
-#endif
-}
-
-TEST_F(ParserTest, EscapeSpaces) {
- ASSERT_NO_FATAL_FAILURE(AssertParse(
-"rule spaces\n"
-" command = something\n"
-"build foo$ bar: spaces $$one two$$$ three\n"
-));
- EXPECT_TRUE(state.LookupNode("foo bar"));
- EXPECT_EQ(state.edges_[0]->outputs_[0]->path(), "foo bar");
- EXPECT_EQ(state.edges_[0]->inputs_[0]->path(), "$one");
- EXPECT_EQ(state.edges_[0]->inputs_[1]->path(), "two$ three");
- EXPECT_EQ(state.edges_[0]->EvaluateCommand(), "something");
-}
-
-TEST_F(ParserTest, CanonicalizeFile) {
- ASSERT_NO_FATAL_FAILURE(AssertParse(
-"rule cat\n"
-" command = cat $in > $out\n"
-"build out: cat in/1 in//2\n"
-"build in/1: cat\n"
-"build in/2: cat\n"));
-
- EXPECT_TRUE(state.LookupNode("in/1"));
- EXPECT_TRUE(state.LookupNode("in/2"));
- EXPECT_FALSE(state.LookupNode("in//1"));
- EXPECT_FALSE(state.LookupNode("in//2"));
-}
-
-#ifdef _WIN32
-TEST_F(ParserTest, CanonicalizeFileBackslashes) {
- ASSERT_NO_FATAL_FAILURE(AssertParse(
-"rule cat\n"
-" command = cat $in > $out\n"
-"build out: cat in\\1 in\\\\2\n"
-"build in\\1: cat\n"
-"build in\\2: cat\n"));
-
- Node* node = state.LookupNode("in/1");;
- EXPECT_TRUE(node);
- EXPECT_EQ(1, node->slash_bits());
- node = state.LookupNode("in/2");
- EXPECT_TRUE(node);
- EXPECT_EQ(1, node->slash_bits());
- EXPECT_FALSE(state.LookupNode("in//1"));
- EXPECT_FALSE(state.LookupNode("in//2"));
-}
-#endif
-
-TEST_F(ParserTest, PathVariables) {
- ASSERT_NO_FATAL_FAILURE(AssertParse(
-"rule cat\n"
-" command = cat $in > $out\n"
-"dir = out\n"
-"build $dir/exe: cat src\n"));
-
- EXPECT_FALSE(state.LookupNode("$dir/exe"));
- EXPECT_TRUE(state.LookupNode("out/exe"));
-}
-
-TEST_F(ParserTest, CanonicalizePaths) {
- ASSERT_NO_FATAL_FAILURE(AssertParse(
-"rule cat\n"
-" command = cat $in > $out\n"
-"build ./out.o: cat ./bar/baz/../foo.cc\n"));
-
- EXPECT_FALSE(state.LookupNode("./out.o"));
- EXPECT_TRUE(state.LookupNode("out.o"));
- EXPECT_FALSE(state.LookupNode("./bar/baz/../foo.cc"));
- EXPECT_TRUE(state.LookupNode("bar/foo.cc"));
-}
-
-#ifdef _WIN32
-TEST_F(ParserTest, CanonicalizePathsBackslashes) {
- ASSERT_NO_FATAL_FAILURE(AssertParse(
-"rule cat\n"
-" command = cat $in > $out\n"
-"build ./out.o: cat ./bar/baz/../foo.cc\n"
-"build .\\out2.o: cat .\\bar/baz\\..\\foo.cc\n"
-"build .\\out3.o: cat .\\bar\\baz\\..\\foo3.cc\n"
-));
-
- EXPECT_FALSE(state.LookupNode("./out.o"));
- EXPECT_FALSE(state.LookupNode(".\\out2.o"));
- EXPECT_FALSE(state.LookupNode(".\\out3.o"));
- EXPECT_TRUE(state.LookupNode("out.o"));
- EXPECT_TRUE(state.LookupNode("out2.o"));
- EXPECT_TRUE(state.LookupNode("out3.o"));
- EXPECT_FALSE(state.LookupNode("./bar/baz/../foo.cc"));
- EXPECT_FALSE(state.LookupNode(".\\bar/baz\\..\\foo.cc"));
- EXPECT_FALSE(state.LookupNode(".\\bar/baz\\..\\foo3.cc"));
- Node* node = state.LookupNode("bar/foo.cc");
- EXPECT_TRUE(node);
- EXPECT_EQ(0, node->slash_bits());
- node = state.LookupNode("bar/foo3.cc");
- EXPECT_TRUE(node);
- EXPECT_EQ(1, node->slash_bits());
-}
-#endif
-
-TEST_F(ParserTest, DuplicateEdgeWithMultipleOutputs) {
- ASSERT_NO_FATAL_FAILURE(AssertParse(
-"rule cat\n"
-" command = cat $in > $out\n"
-"build out1 out2: cat in1\n"
-"build out1: cat in2\n"
-"build final: cat out1\n"
-));
- // AssertParse() checks that the generated build graph is self-consistent.
- // That's all the checking that this test needs.
-}
-
-TEST_F(ParserTest, NoDeadPointerFromDuplicateEdge) {
- ASSERT_NO_FATAL_FAILURE(AssertParse(
-"rule cat\n"
-" command = cat $in > $out\n"
-"build out: cat in\n"
-"build out: cat in\n"
-));
- // AssertParse() checks that the generated build graph is self-consistent.
- // That's all the checking that this test needs.
-}
-
-TEST_F(ParserTest, DuplicateEdgeWithMultipleOutputsError) {
- const char kInput[] =
-"rule cat\n"
-" command = cat $in > $out\n"
-"build out1 out2: cat in1\n"
-"build out1: cat in2\n"
-"build final: cat out1\n";
- ManifestParserOptions parser_opts;
- parser_opts.dupe_edge_action_ = kDupeEdgeActionError;
- ManifestParser parser(&state, &fs_, parser_opts);
- string err;
- EXPECT_FALSE(parser.ParseTest(kInput, &err));
- EXPECT_EQ("input:5: multiple rules generate out1\n", err);
-}
-
-TEST_F(ParserTest, DuplicateEdgeInIncludedFile) {
- fs_.Create("sub.ninja",
- "rule cat\n"
- " command = cat $in > $out\n"
- "build out1 out2: cat in1\n"
- "build out1: cat in2\n"
- "build final: cat out1\n");
- const char kInput[] =
- "subninja sub.ninja\n";
- ManifestParserOptions parser_opts;
- parser_opts.dupe_edge_action_ = kDupeEdgeActionError;
- ManifestParser parser(&state, &fs_, parser_opts);
- string err;
- EXPECT_FALSE(parser.ParseTest(kInput, &err));
- EXPECT_EQ("sub.ninja:5: multiple rules generate out1\n", err);
-}
-
-TEST_F(ParserTest, PhonySelfReferenceIgnored) {
- ASSERT_NO_FATAL_FAILURE(AssertParse(
-"build a: phony a\n"
-));
-
- Node* node = state.LookupNode("a");
- Edge* edge = node->in_edge();
- ASSERT_TRUE(edge->inputs_.empty());
-}
-
-TEST_F(ParserTest, PhonySelfReferenceKept) {
- const char kInput[] =
-"build a: phony a\n";
- ManifestParserOptions parser_opts;
- parser_opts.phony_cycle_action_ = kPhonyCycleActionError;
- ManifestParser parser(&state, &fs_, parser_opts);
- string err;
- EXPECT_TRUE(parser.ParseTest(kInput, &err));
- EXPECT_EQ("", err);
-
- Node* node = state.LookupNode("a");
- Edge* edge = node->in_edge();
- ASSERT_EQ(edge->inputs_.size(), 1);
- ASSERT_EQ(edge->inputs_[0], node);
-}
-
-TEST_F(ParserTest, ReservedWords) {
- ASSERT_NO_FATAL_FAILURE(AssertParse(
-"rule build\n"
-" command = rule run $out\n"
-"build subninja: build include default foo.cc\n"
-"default subninja\n"));
-}
-
-TEST_F(ParserTest, Errors) {
- {
- State local_state;
- ManifestParser parser(&local_state, NULL);
- string err;
- EXPECT_FALSE(parser.ParseTest(string("subn", 4), &err));
- EXPECT_EQ("input:1: expected '=', got eof\n"
- "subn\n"
- " ^ near here"
- , err);
- }
-
- {
- State local_state;
- ManifestParser parser(&local_state, NULL);
- string err;
- EXPECT_FALSE(parser.ParseTest("foobar", &err));
- EXPECT_EQ("input:1: expected '=', got eof\n"
- "foobar\n"
- " ^ near here"
- , err);
- }
-
- {
- State local_state;
- ManifestParser parser(&local_state, NULL);
- string err;
- EXPECT_FALSE(parser.ParseTest("x 3", &err));
- EXPECT_EQ("input:1: expected '=', got identifier\n"
- "x 3\n"
- " ^ near here"
- , err);
- }
-
- {
- State local_state;
- ManifestParser parser(&local_state, NULL);
- string err;
- EXPECT_FALSE(parser.ParseTest("x = 3", &err));
- EXPECT_EQ("input:1: unexpected EOF\n"
- "x = 3\n"
- " ^ near here"
- , err);
- }
-
- {
- State local_state;
- ManifestParser parser(&local_state, NULL);
- string err;
- EXPECT_FALSE(parser.ParseTest("x = 3\ny 2", &err));
- EXPECT_EQ("input:2: expected '=', got identifier\n"
- "y 2\n"
- " ^ near here"
- , err);
- }
-
- {
- State local_state;
- ManifestParser parser(&local_state, NULL);
- string err;
- EXPECT_FALSE(parser.ParseTest("x = $", &err));
- EXPECT_EQ("input:1: bad $-escape (literal $ must be written as $$)\n"
- "x = $\n"
- " ^ near here"
- , err);
- }
-
- {
- State local_state;
- ManifestParser parser(&local_state, NULL);
- string err;
- EXPECT_FALSE(parser.ParseTest("x = $\n $[\n", &err));
- EXPECT_EQ("input:2: bad $-escape (literal $ must be written as $$)\n"
- " $[\n"
- " ^ near here"
- , err);
- }
-
- {
- State local_state;
- ManifestParser parser(&local_state, NULL);
- string err;
- EXPECT_FALSE(parser.ParseTest("x = a$\n b$\n $\n", &err));
- EXPECT_EQ("input:4: unexpected EOF\n"
- , err);
- }
-
- {
- State local_state;
- ManifestParser parser(&local_state, NULL);
- string err;
- EXPECT_FALSE(parser.ParseTest("build\n", &err));
- EXPECT_EQ("input:1: expected path\n"
- "build\n"
- " ^ near here"
- , err);
- }
-
- {
- State local_state;
- ManifestParser parser(&local_state, NULL);
- string err;
- EXPECT_FALSE(parser.ParseTest("build x: y z\n", &err));
- EXPECT_EQ("input:1: unknown build rule 'y'\n"
- "build x: y z\n"
- " ^ near here"
- , err);
- }
-
- {
- State local_state;
- ManifestParser parser(&local_state, NULL);
- string err;
- EXPECT_FALSE(parser.ParseTest("build x:: y z\n", &err));
- EXPECT_EQ("input:1: expected build command name\n"
- "build x:: y z\n"
- " ^ near here"
- , err);
- }
-
- {
- State local_state;
- ManifestParser parser(&local_state, NULL);
- string err;
- EXPECT_FALSE(parser.ParseTest("rule cat\n command = cat ok\n"
- "build x: cat $\n :\n",
- &err));
- EXPECT_EQ("input:4: expected newline, got ':'\n"
- " :\n"
- " ^ near here"
- , err);
- }
-
- {
- State local_state;
- ManifestParser parser(&local_state, NULL);
- string err;
- EXPECT_FALSE(parser.ParseTest("rule cat\n",
- &err));
- EXPECT_EQ("input:2: expected 'command =' line\n", err);
- }
-
- {
- State local_state;
- ManifestParser parser(&local_state, NULL);
- string err;
- EXPECT_FALSE(parser.ParseTest("rule cat\n"
- " command = echo\n"
- "rule cat\n"
- " command = echo\n", &err));
- EXPECT_EQ("input:3: duplicate rule 'cat'\n"
- "rule cat\n"
- " ^ near here"
- , err);
- }
-
- {
- State local_state;
- ManifestParser parser(&local_state, NULL);
- string err;
- EXPECT_FALSE(parser.ParseTest("rule cat\n"
- " command = echo\n"
- " rspfile = cat.rsp\n", &err));
- EXPECT_EQ(
- "input:4: rspfile and rspfile_content need to be both specified\n",
- err);
- }
-
- {
- State local_state;
- ManifestParser parser(&local_state, NULL);
- string err;
- EXPECT_FALSE(parser.ParseTest("rule cat\n"
- " command = ${fafsd\n"
- "foo = bar\n",
- &err));
- EXPECT_EQ("input:2: bad $-escape (literal $ must be written as $$)\n"
- " command = ${fafsd\n"
- " ^ near here"
- , err);
- }
-
-
- {
- State local_state;
- ManifestParser parser(&local_state, NULL);
- string err;
- EXPECT_FALSE(parser.ParseTest("rule cat\n"
- " command = cat\n"
- "build $.: cat foo\n",
- &err));
- EXPECT_EQ("input:3: bad $-escape (literal $ must be written as $$)\n"
- "build $.: cat foo\n"
- " ^ near here"
- , err);
- }
-
-
- {
- State local_state;
- ManifestParser parser(&local_state, NULL);
- string err;
- EXPECT_FALSE(parser.ParseTest("rule cat\n"
- " command = cat\n"
- "build $: cat foo\n",
- &err));
- EXPECT_EQ("input:3: expected ':', got newline ($ also escapes ':')\n"
- "build $: cat foo\n"
- " ^ near here"
- , err);
- }
-
- {
- State local_state;
- ManifestParser parser(&local_state, NULL);
- string err;
- EXPECT_FALSE(parser.ParseTest("rule %foo\n",
- &err));
- EXPECT_EQ("input:1: expected rule name\n"
- "rule %foo\n"
- " ^ near here",
- err);
- }
-
- {
- State local_state;
- ManifestParser parser(&local_state, NULL);
- string err;
- EXPECT_FALSE(parser.ParseTest("rule cc\n"
- " command = foo\n"
- " othervar = bar\n",
- &err));
- EXPECT_EQ("input:3: unexpected variable 'othervar'\n"
- " othervar = bar\n"
- " ^ near here"
- , err);
- }
-
- {
- State local_state;
- ManifestParser parser(&local_state, NULL);
- string err;
- EXPECT_FALSE(parser.ParseTest("rule cc\n command = foo\n"
- "build $.: cc bar.cc\n",
- &err));
- EXPECT_EQ("input:3: bad $-escape (literal $ must be written as $$)\n"
- "build $.: cc bar.cc\n"
- " ^ near here"
- , err);
- }
-
- {
- State local_state;
- ManifestParser parser(&local_state, NULL);
- string err;
- EXPECT_FALSE(parser.ParseTest("rule cc\n command = foo\n && bar",
- &err));
- EXPECT_EQ("input:3: expected variable name\n"
- " && bar\n"
- " ^ near here",
- err);
- }
-
- {
- State local_state;
- ManifestParser parser(&local_state, NULL);
- string err;
- EXPECT_FALSE(parser.ParseTest("rule cc\n command = foo\n"
- "build $: cc bar.cc\n",
- &err));
- EXPECT_EQ("input:3: expected ':', got newline ($ also escapes ':')\n"
- "build $: cc bar.cc\n"
- " ^ near here"
- , err);
- }
-
- {
- State local_state;
- ManifestParser parser(&local_state, NULL);
- string err;
- EXPECT_FALSE(parser.ParseTest("default\n",
- &err));
- EXPECT_EQ("input:1: expected target name\n"
- "default\n"
- " ^ near here"
- , err);
- }
-
- {
- State local_state;
- ManifestParser parser(&local_state, NULL);
- string err;
- EXPECT_FALSE(parser.ParseTest("default nonexistent\n",
- &err));
- EXPECT_EQ("input:1: unknown target 'nonexistent'\n"
- "default nonexistent\n"
- " ^ near here"
- , err);
- }
-
- {
- State local_state;
- ManifestParser parser(&local_state, NULL);
- string err;
- EXPECT_FALSE(parser.ParseTest("rule r\n command = r\n"
- "build b: r\n"
- "default b:\n",
- &err));
- EXPECT_EQ("input:4: expected newline, got ':'\n"
- "default b:\n"
- " ^ near here"
- , err);
- }
-
- {
- State local_state;
- ManifestParser parser(&local_state, NULL);
- string err;
- EXPECT_FALSE(parser.ParseTest("default $a\n", &err));
- EXPECT_EQ("input:1: empty path\n"
- "default $a\n"
- " ^ near here"
- , err);
- }
-
- {
- State local_state;
- ManifestParser parser(&local_state, NULL);
- string err;
- EXPECT_FALSE(parser.ParseTest("rule r\n"
- " command = r\n"
- "build $a: r $c\n", &err));
- // XXX the line number is wrong; we should evaluate paths in ParseEdge
- // as we see them, not after we've read them all!
- EXPECT_EQ("input:4: empty path\n", err);
- }
-
- {
- State local_state;
- ManifestParser parser(&local_state, NULL);
- string err;
- // the indented blank line must terminate the rule
- // this also verifies that "unexpected (token)" errors are correct
- EXPECT_FALSE(parser.ParseTest("rule r\n"
- " command = r\n"
- " \n"
- " generator = 1\n", &err));
- EXPECT_EQ("input:4: unexpected indent\n", err);
- }
-
- {
- State local_state;
- ManifestParser parser(&local_state, NULL);
- string err;
- EXPECT_FALSE(parser.ParseTest("pool\n", &err));
- EXPECT_EQ("input:1: expected pool name\n"
- "pool\n"
- " ^ near here", err);
- }
-
- {
- State local_state;
- ManifestParser parser(&local_state, NULL);
- string err;
- EXPECT_FALSE(parser.ParseTest("pool foo\n", &err));
- EXPECT_EQ("input:2: expected 'depth =' line\n", err);
- }
-
- {
- State local_state;
- ManifestParser parser(&local_state, NULL);
- string err;
- EXPECT_FALSE(parser.ParseTest("pool foo\n"
- " depth = 4\n"
- "pool foo\n", &err));
- EXPECT_EQ("input:3: duplicate pool 'foo'\n"
- "pool foo\n"
- " ^ near here"
- , err);
- }
-
- {
- State local_state;
- ManifestParser parser(&local_state, NULL);
- string err;
- EXPECT_FALSE(parser.ParseTest("pool foo\n"
- " depth = -1\n", &err));
- EXPECT_EQ("input:2: invalid pool depth\n"
- " depth = -1\n"
- " ^ near here"
- , err);
- }
-
- {
- State local_state;
- ManifestParser parser(&local_state, NULL);
- string err;
- EXPECT_FALSE(parser.ParseTest("pool foo\n"
- " bar = 1\n", &err));
- EXPECT_EQ("input:2: unexpected variable 'bar'\n"
- " bar = 1\n"
- " ^ near here"
- , err);
- }
-
- {
- State local_state;
- ManifestParser parser(&local_state, NULL);
- string err;
- // Pool names are dereferenced at edge parsing time.
- EXPECT_FALSE(parser.ParseTest("rule run\n"
- " command = echo\n"
- " pool = unnamed_pool\n"
- "build out: run in\n", &err));
- EXPECT_EQ("input:5: unknown pool name 'unnamed_pool'\n", err);
- }
-}
-
-TEST_F(ParserTest, MissingInput) {
- State local_state;
- ManifestParser parser(&local_state, &fs_);
- string err;
- EXPECT_FALSE(parser.Load("build.ninja", &err));
- EXPECT_EQ("loading 'build.ninja': No such file or directory", err);
-}
-
-TEST_F(ParserTest, MultipleOutputs) {
- State local_state;
- ManifestParser parser(&local_state, NULL);
- string err;
- EXPECT_TRUE(parser.ParseTest("rule cc\n command = foo\n depfile = bar\n"
- "build a.o b.o: cc c.cc\n",
- &err));
- EXPECT_EQ("", err);
-}
-
-TEST_F(ParserTest, MultipleOutputsWithDeps) {
- State local_state;
- ManifestParser parser(&local_state, NULL);
- string err;
- EXPECT_TRUE(parser.ParseTest("rule cc\n command = foo\n deps = gcc\n"
- "build a.o b.o: cc c.cc\n",
- &err));
- EXPECT_EQ("", err);
-}
-
-TEST_F(ParserTest, SubNinja) {
- fs_.Create("test.ninja",
- "var = inner\n"
- "build $builddir/inner: varref\n");
- ASSERT_NO_FATAL_FAILURE(AssertParse(
-"builddir = some_dir/\n"
-"rule varref\n"
-" command = varref $var\n"
-"var = outer\n"
-"build $builddir/outer: varref\n"
-"subninja test.ninja\n"
-"build $builddir/outer2: varref\n"));
- ASSERT_EQ(1u, fs_.files_read_.size());
-
- EXPECT_EQ("test.ninja", fs_.files_read_[0]);
- EXPECT_TRUE(state.LookupNode("some_dir/outer"));
- // Verify our builddir setting is inherited.
- EXPECT_TRUE(state.LookupNode("some_dir/inner"));
-
- ASSERT_EQ(3u, state.edges_.size());
- EXPECT_EQ("varref outer", state.edges_[0]->EvaluateCommand());
- EXPECT_EQ("varref inner", state.edges_[1]->EvaluateCommand());
- EXPECT_EQ("varref outer", state.edges_[2]->EvaluateCommand());
-}
-
-TEST_F(ParserTest, MissingSubNinja) {
- ManifestParser parser(&state, &fs_);
- string err;
- EXPECT_FALSE(parser.ParseTest("subninja foo.ninja\n", &err));
- EXPECT_EQ("input:1: loading 'foo.ninja': No such file or directory\n"
- "subninja foo.ninja\n"
- " ^ near here"
- , err);
-}
-
-TEST_F(ParserTest, DuplicateRuleInDifferentSubninjas) {
- // Test that rules are scoped to subninjas.
- fs_.Create("test.ninja", "rule cat\n"
- " command = cat\n");
- ManifestParser parser(&state, &fs_);
- string err;
- EXPECT_TRUE(parser.ParseTest("rule cat\n"
- " command = cat\n"
- "subninja test.ninja\n", &err));
-}
-
-TEST_F(ParserTest, DuplicateRuleInDifferentSubninjasWithInclude) {
- // Test that rules are scoped to subninjas even with includes.
- fs_.Create("rules.ninja", "rule cat\n"
- " command = cat\n");
- fs_.Create("test.ninja", "include rules.ninja\n"
- "build x : cat\n");
- ManifestParser parser(&state, &fs_);
- string err;
- EXPECT_TRUE(parser.ParseTest("include rules.ninja\n"
- "subninja test.ninja\n"
- "build y : cat\n", &err));
-}
-
-TEST_F(ParserTest, Include) {
- fs_.Create("include.ninja", "var = inner\n");
- ASSERT_NO_FATAL_FAILURE(AssertParse(
-"var = outer\n"
-"include include.ninja\n"));
-
- ASSERT_EQ(1u, fs_.files_read_.size());
- EXPECT_EQ("include.ninja", fs_.files_read_[0]);
- EXPECT_EQ("inner", state.bindings().LookupVariable("var"));
-}
-
-TEST_F(ParserTest, BrokenInclude) {
- fs_.Create("include.ninja", "build\n");
- ManifestParser parser(&state, &fs_);
- string err;
- EXPECT_FALSE(parser.ParseTest("include include.ninja\n", &err));
- EXPECT_EQ("include.ninja:1: expected path\n"
- "build\n"
- " ^ near here"
- , err);
-}
-
-TEST_F(ParserTest, Implicit) {
- ASSERT_NO_FATAL_FAILURE(AssertParse(
-"rule cat\n"
-" command = cat $in > $out\n"
-"build foo: cat bar | baz\n"));
-
- Edge* edge = state.LookupNode("foo")->in_edge();
- ASSERT_TRUE(edge->is_implicit(1));
-}
-
-TEST_F(ParserTest, OrderOnly) {
- ASSERT_NO_FATAL_FAILURE(AssertParse(
-"rule cat\n command = cat $in > $out\n"
-"build foo: cat bar || baz\n"));
-
- Edge* edge = state.LookupNode("foo")->in_edge();
- ASSERT_TRUE(edge->is_order_only(1));
-}
-
-TEST_F(ParserTest, Validations) {
- ASSERT_NO_FATAL_FAILURE(AssertParse(
-"rule cat\n command = cat $in > $out\n"
-"build foo: cat bar |@ baz\n"));
-
- Edge* edge = state.LookupNode("foo")->in_edge();
- ASSERT_EQ(edge->validations_.size(), 1);
- EXPECT_EQ(edge->validations_[0]->path(), "baz");
-}
-
-TEST_F(ParserTest, ImplicitOutput) {
- ASSERT_NO_FATAL_FAILURE(AssertParse(
-"rule cat\n"
-" command = cat $in > $out\n"
-"build foo | imp: cat bar\n"));
-
- Edge* edge = state.LookupNode("imp")->in_edge();
- ASSERT_EQ(edge->outputs_.size(), 2);
- EXPECT_TRUE(edge->is_implicit_out(1));
-}
-
-TEST_F(ParserTest, ImplicitOutputEmpty) {
- ASSERT_NO_FATAL_FAILURE(AssertParse(
-"rule cat\n"
-" command = cat $in > $out\n"
-"build foo | : cat bar\n"));
-
- Edge* edge = state.LookupNode("foo")->in_edge();
- ASSERT_EQ(edge->outputs_.size(), 1);
- EXPECT_FALSE(edge->is_implicit_out(0));
-}
-
-TEST_F(ParserTest, ImplicitOutputDupe) {
- ASSERT_NO_FATAL_FAILURE(AssertParse(
-"rule cat\n"
-" command = cat $in > $out\n"
-"build foo baz | foo baq foo: cat bar\n"));
-
- Edge* edge = state.LookupNode("foo")->in_edge();
- ASSERT_EQ(edge->outputs_.size(), 3);
- EXPECT_FALSE(edge->is_implicit_out(0));
- EXPECT_FALSE(edge->is_implicit_out(1));
- EXPECT_TRUE(edge->is_implicit_out(2));
-}
-
-TEST_F(ParserTest, ImplicitOutputDupes) {
- ASSERT_NO_FATAL_FAILURE(AssertParse(
-"rule cat\n"
-" command = cat $in > $out\n"
-"build foo foo foo | foo foo foo foo: cat bar\n"));
-
- Edge* edge = state.LookupNode("foo")->in_edge();
- ASSERT_EQ(edge->outputs_.size(), 1);
- EXPECT_FALSE(edge->is_implicit_out(0));
-}
-
-TEST_F(ParserTest, NoExplicitOutput) {
- ManifestParser parser(&state, NULL);
- string err;
- EXPECT_TRUE(parser.ParseTest(
-"rule cat\n"
-" command = cat $in > $out\n"
-"build | imp : cat bar\n", &err));
-}
-
-TEST_F(ParserTest, DefaultDefault) {
- ASSERT_NO_FATAL_FAILURE(AssertParse(
-"rule cat\n command = cat $in > $out\n"
-"build a: cat foo\n"
-"build b: cat foo\n"
-"build c: cat foo\n"
-"build d: cat foo\n"));
-
- string err;
- EXPECT_EQ(4u, state.DefaultNodes(&err).size());
- EXPECT_EQ("", err);
-}
-
-TEST_F(ParserTest, DefaultDefaultCycle) {
- ASSERT_NO_FATAL_FAILURE(AssertParse(
-"rule cat\n command = cat $in > $out\n"
-"build a: cat a\n"));
-
- string err;
- EXPECT_EQ(0u, state.DefaultNodes(&err).size());
- EXPECT_EQ("could not determine root nodes of build graph", err);
-}
-
-TEST_F(ParserTest, DefaultStatements) {
- ASSERT_NO_FATAL_FAILURE(AssertParse(
-"rule cat\n command = cat $in > $out\n"
-"build a: cat foo\n"
-"build b: cat foo\n"
-"build c: cat foo\n"
-"build d: cat foo\n"
-"third = c\n"
-"default a b\n"
-"default $third\n"));
-
- string err;
- vector<Node*> nodes = state.DefaultNodes(&err);
- EXPECT_EQ("", err);
- ASSERT_EQ(3u, nodes.size());
- EXPECT_EQ("a", nodes[0]->path());
- EXPECT_EQ("b", nodes[1]->path());
- EXPECT_EQ("c", nodes[2]->path());
-}
-
-TEST_F(ParserTest, UTF8) {
- ASSERT_NO_FATAL_FAILURE(AssertParse(
-"rule utf8\n"
-" command = true\n"
-" description = compilaci\xC3\xB3\n"));
-}
-
-TEST_F(ParserTest, CRLF) {
- State local_state;
- ManifestParser parser(&local_state, NULL);
- string err;
-
- EXPECT_TRUE(parser.ParseTest("# comment with crlf\r\n", &err));
- EXPECT_TRUE(parser.ParseTest("foo = foo\nbar = bar\r\n", &err));
- EXPECT_TRUE(parser.ParseTest(
- "pool link_pool\r\n"
- " depth = 15\r\n\r\n"
- "rule xyz\r\n"
- " command = something$expand \r\n"
- " description = YAY!\r\n",
- &err));
-}
-
-TEST_F(ParserTest, DyndepNotSpecified) {
- ASSERT_NO_FATAL_FAILURE(AssertParse(
-"rule cat\n"
-" command = cat $in > $out\n"
-"build result: cat in\n"));
- Edge* edge = state.GetNode("result", 0)->in_edge();
- ASSERT_FALSE(edge->dyndep_);
-}
-
-TEST_F(ParserTest, DyndepNotInput) {
- State lstate;
- ManifestParser parser(&lstate, NULL);
- string err;
- EXPECT_FALSE(parser.ParseTest(
-"rule touch\n"
-" command = touch $out\n"
-"build result: touch\n"
-" dyndep = notin\n",
- &err));
- EXPECT_EQ("input:5: dyndep 'notin' is not an input\n", err);
-}
-
-TEST_F(ParserTest, DyndepExplicitInput) {
- ASSERT_NO_FATAL_FAILURE(AssertParse(
-"rule cat\n"
-" command = cat $in > $out\n"
-"build result: cat in\n"
-" dyndep = in\n"));
- Edge* edge = state.GetNode("result", 0)->in_edge();
- ASSERT_TRUE(edge->dyndep_);
- EXPECT_TRUE(edge->dyndep_->dyndep_pending());
- EXPECT_EQ(edge->dyndep_->path(), "in");
-}
-
-TEST_F(ParserTest, DyndepImplicitInput) {
- ASSERT_NO_FATAL_FAILURE(AssertParse(
-"rule cat\n"
-" command = cat $in > $out\n"
-"build result: cat in | dd\n"
-" dyndep = dd\n"));
- Edge* edge = state.GetNode("result", 0)->in_edge();
- ASSERT_TRUE(edge->dyndep_);
- EXPECT_TRUE(edge->dyndep_->dyndep_pending());
- EXPECT_EQ(edge->dyndep_->path(), "dd");
-}
-
-TEST_F(ParserTest, DyndepOrderOnlyInput) {
- ASSERT_NO_FATAL_FAILURE(AssertParse(
-"rule cat\n"
-" command = cat $in > $out\n"
-"build result: cat in || dd\n"
-" dyndep = dd\n"));
- Edge* edge = state.GetNode("result", 0)->in_edge();
- ASSERT_TRUE(edge->dyndep_);
- EXPECT_TRUE(edge->dyndep_->dyndep_pending());
- EXPECT_EQ(edge->dyndep_->path(), "dd");
-}
-
-TEST_F(ParserTest, DyndepRuleInput) {
- ASSERT_NO_FATAL_FAILURE(AssertParse(
-"rule cat\n"
-" command = cat $in > $out\n"
-" dyndep = $in\n"
-"build result: cat in\n"));
- Edge* edge = state.GetNode("result", 0)->in_edge();
- ASSERT_TRUE(edge->dyndep_);
- EXPECT_TRUE(edge->dyndep_->dyndep_pending());
- EXPECT_EQ(edge->dyndep_->path(), "in");
-}
diff --git a/src/metrics.cc b/src/metrics.cc
deleted file mode 100644
index 88d0180..0000000
--- a/src/metrics.cc
+++ /dev/null
@@ -1,138 +0,0 @@
-// Copyright 2011 Google Inc. All Rights Reserved.
-//
-// Licensed under the Apache License, Version 2.0 (the "License");
-// you may not use this file except in compliance with the License.
-// You may obtain a copy of the License at
-//
-// http://www.apache.org/licenses/LICENSE-2.0
-//
-// Unless required by applicable law or agreed to in writing, software
-// distributed under the License is distributed on an "AS IS" BASIS,
-// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-// See the License for the specific language governing permissions and
-// limitations under the License.
-
-#include "metrics.h"
-
-#include <errno.h>
-#include <stdio.h>
-#include <string.h>
-
-#include <algorithm>
-#include <chrono>
-
-#include "util.h"
-
-using namespace std;
-
-Metrics* g_metrics = NULL;
-
-namespace {
-
-/// Compute a platform-specific high-res timer value that fits into an int64.
-int64_t HighResTimer() {
- auto now = chrono::steady_clock::now();
- return chrono::duration_cast<chrono::steady_clock::duration>(
- now.time_since_epoch())
- .count();
-}
-
-constexpr int64_t GetFrequency() {
- // If numerator isn't 1 then we lose precision and that will need to be
- // assessed.
- static_assert(std::chrono::steady_clock::period::num == 1,
- "Numerator must be 1");
- return std::chrono::steady_clock::period::den /
- std::chrono::steady_clock::period::num;
-}
-
-int64_t TimerToMicros(int64_t dt) {
- // dt is in ticks. We want microseconds.
- return (dt * 1000000) / GetFrequency();
-}
-
-int64_t TimerToMicros(double dt) {
- // dt is in ticks. We want microseconds.
- return (dt * 1000000) / GetFrequency();
-}
-
-} // anonymous namespace
-
-ScopedMetric::ScopedMetric(Metric* metric) {
- metric_ = metric;
- if (!metric_)
- return;
- start_ = HighResTimer();
-}
-ScopedMetric::~ScopedMetric() {
- if (!metric_)
- return;
- metric_->count++;
- // Leave in the timer's natural frequency to avoid paying the conversion cost
- // on every measurement.
- int64_t dt = HighResTimer() - start_;
- metric_->sum += dt;
-}
-
-Metric* MetricsDomain::NewMetric(StringPiece name) {
- metrics_.emplace_back(new Metric(name));
- return metrics_.back().get();
-}
-
-void MetricsDomain::Reset() {
- for (auto& metric : metrics_) {
- metric->count = 0;
- metric->sum = 0;
- }
-}
-
-int MetricsDomain::ComputeMaxNameWidth(int max_width) {
- for (const auto& metric : metrics_)
- max_width = max((int)(metric->name.size()), max_width);
- return max_width;
-}
-
-// static
-void MetricsDomain::PrintBanner(int max_width) {
- printf("%-*s\t%-6s\t%-9s\t%s\n", max_width, "metric", "count", "avg (us)",
- "total (ms)");
-}
-
-void MetricsDomain::Print(int max_width) {
- for (const auto& metric : metrics_) {
- uint64_t micros = TimerToMicros(metric->sum);
- double total = micros / (double)1000;
- double avg = micros / (double)metric->count;
- printf("%-*s\t%-6d\t%-8.1f\t%.1f\n", max_width, metric->name.c_str(),
- metric->count, avg, total);
- }
-}
-
-void MetricsDomain::Report() {
- int max_width = ComputeMaxNameWidth(0);
- PrintBanner(max_width);
- Print(max_width);
-}
-
-void Metrics::Report() {
- int max_width = 0;
- max_width = load_.ComputeMaxNameWidth(max_width);
- max_width = build_.ComputeMaxNameWidth(max_width);
-
- MetricsDomain::PrintBanner(max_width);
- load_.Print(max_width);
- build_.Print(max_width);
-}
-
-double Stopwatch::Elapsed() const {
- // Convert to micros after converting to double to minimize error.
- return 1e-6 * TimerToMicros(static_cast<double>(NowRaw() - started_));
-}
-
-uint64_t Stopwatch::NowRaw() const {
- return HighResTimer();
-}
-
-int64_t GetTimeMillis() {
- return TimerToMicros(HighResTimer()) / 1000;
-}
diff --git a/src/metrics.h b/src/metrics.h
deleted file mode 100644
index a105984..0000000
--- a/src/metrics.h
+++ /dev/null
@@ -1,139 +0,0 @@
-// Copyright 2011 Google Inc. All Rights Reserved.
-//
-// Licensed under the Apache License, Version 2.0 (the "License");
-// you may not use this file except in compliance with the License.
-// You may obtain a copy of the License at
-//
-// http://www.apache.org/licenses/LICENSE-2.0
-//
-// Unless required by applicable law or agreed to in writing, software
-// distributed under the License is distributed on an "AS IS" BASIS,
-// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-// See the License for the specific language governing permissions and
-// limitations under the License.
-
-#ifndef NINJA_METRICS_H_
-#define NINJA_METRICS_H_
-
-#include <memory>
-#include <string>
-#include <vector>
-
-#include "string_piece.h"
-#include "util.h" // For int64_t.
-
-/// The Metrics module is used for the debug mode that dumps timing stats of
-/// various actions. To use, see METRIC_RECORD below.
-
-/// A single metrics we're tracking, like "depfile load time".
-struct Metric {
- Metric(StringPiece name) : name(name.AsString()) {}
-
- std::string name;
- /// Number of times we've hit the code path.
- int count = 0;
- /// Total time (in platform-dependent units) we've spent on the code path.
- int64_t sum = 0;
-};
-
-/// A scoped object for recording a metric across the body of a function.
-/// Used by the METRIC_RECORD macro.
-struct ScopedMetric {
- explicit ScopedMetric(Metric* metric);
- ~ScopedMetric();
-
-private:
- Metric* metric_;
- /// Timestamp when the measurement started.
- /// Value is platform-dependent.
- int64_t start_;
-};
-
-/// A set of metrics scoped to a given domain, e.g. manifest loading, or
-/// build invocation.
-struct MetricsDomain {
- Metric* NewMetric(StringPiece name);
-
- /// Reset all Metric instances in this domain.
- void Reset();
-
- /// Compute the max width of all metric names in this domain.
- /// If |cur_max_width| is not 0, then ensure the result is always greater
- /// or equal to it, which is useful when combining several domain reports.
- int ComputeMaxNameWidth(int cur_max_width = 0);
-
- /// Print a one-line table banner describing metric details.
- static void PrintBanner(int max_width);
-
- /// Print a summary of all metrics to stdout, without any banner.
- void Print(int max_width = 0);
-
- /// Print a summary report for just this domain to stdout.
- void Report();
-
-private:
- std::vector<std::unique_ptr<Metric>> metrics_;
-};
-
-/// The set of Ninja metrics domains.
-struct Metrics {
- /// Print a summary report for all domains to stdout.
- void Report();
-
- MetricsDomain load_;
- MetricsDomain build_;
-};
-
-/// Get the current time as relative to some epoch.
-/// Epoch varies between platforms; only useful for measuring elapsed time.
-int64_t GetTimeMillis();
-
-/// A simple stopwatch which returns the time
-/// in seconds since Restart() was called.
-struct Stopwatch {
- public:
- Stopwatch() : started_(0) {}
-
- /// Seconds since Restart() call.
- double Elapsed() const;
-
- void Restart() { started_ = NowRaw(); }
-
- private:
- uint64_t started_;
- // Return the current time using the native frequency of the high resolution
- // timer.
- uint64_t NowRaw() const;
-};
-
-/// The primary interface to metrics. Use METRIC_RECORD("foobar") at the top
-/// of a function to get timing stats recorded for each call of the function.
-/// This creates a metric in the "build" domain, for operations performed
-/// when loading the manifest, use METRIC_RECORD_LOAD() instead.
-#define METRIC_RECORD(name) \
- static Metric* metrics_h_metric = \
- g_metrics ? g_metrics->build_.NewMetric(name) : NULL; \
- ScopedMetric metrics_h_scoped(metrics_h_metric);
-
-/// A variant of METRIC_RECORD() for timing manifest loading operations.
-#define METRIC_RECORD_LOAD(name) \
- static Metric* metrics_h_metric = \
- g_metrics ? g_metrics->load_.NewMetric(name) : NULL; \
- ScopedMetric metrics_h_scoped(metrics_h_metric);
-
-/// A variant of METRIC_RECORD that doesn't record anything if |condition|
-/// is false.
-#define METRIC_RECORD_IF(name, condition) \
- static Metric* metrics_h_metric = \
- g_metrics ? g_metrics->build_.NewMetric(name) : NULL; \
- ScopedMetric metrics_h_scoped((condition) ? metrics_h_metric : NULL);
-
-/// A variant of METRIC_RECORD_IF for timing manifest loading operations.
-#define METRIC_RECORD_LOAD_IF(name, condition) \
- static Metric* metrics_h_metric = \
- g_metrics ? g_metrics->load_.NewMetric(name) : NULL; \
- ScopedMetric metrics_h_scoped((condition) ? metrics_h_metric : NULL);
-
-extern Metrics* g_metrics;
-
-#endif // NINJA_METRICS_H_
diff --git a/src/minidump-win32.cc b/src/minidump-win32.cc
deleted file mode 100644
index 9aea767..0000000
--- a/src/minidump-win32.cc
+++ /dev/null
@@ -1,89 +0,0 @@
-// Copyright 2012 Google Inc. All Rights Reserved.
-//
-// Licensed under the Apache License, Version 2.0 (the "License");
-// you may not use this file except in compliance with the License.
-// You may obtain a copy of the License at
-//
-// http://www.apache.org/licenses/LICENSE-2.0
-//
-// Unless required by applicable law or agreed to in writing, software
-// distributed under the License is distributed on an "AS IS" BASIS,
-// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-// See the License for the specific language governing permissions and
-// limitations under the License.
-
-#ifdef _MSC_VER
-
-#include <windows.h>
-#include <DbgHelp.h>
-
-#include "util.h"
-
-using namespace std;
-
-typedef BOOL (WINAPI *MiniDumpWriteDumpFunc) (
- IN HANDLE,
- IN DWORD,
- IN HANDLE,
- IN MINIDUMP_TYPE,
- IN CONST PMINIDUMP_EXCEPTION_INFORMATION, OPTIONAL
- IN CONST PMINIDUMP_USER_STREAM_INFORMATION, OPTIONAL
- IN CONST PMINIDUMP_CALLBACK_INFORMATION OPTIONAL
- );
-
-/// Creates a windows minidump in temp folder.
-void CreateWin32MiniDump(_EXCEPTION_POINTERS* pep) {
- char temp_path[MAX_PATH];
- GetTempPathA(sizeof(temp_path), temp_path);
- char temp_file[MAX_PATH];
- sprintf(temp_file, "%s\\ninja_crash_dump_%lu.dmp",
- temp_path, GetCurrentProcessId());
-
- // Delete any previous minidump of the same name.
- DeleteFileA(temp_file);
-
- // Load DbgHelp.dll dynamically, as library is not present on all
- // Windows versions.
- HMODULE dbghelp = LoadLibraryA("dbghelp.dll");
- if (dbghelp == NULL) {
- Error("failed to create minidump: LoadLibrary('dbghelp.dll'): %s",
- GetLastErrorString().c_str());
- return;
- }
-
- MiniDumpWriteDumpFunc mini_dump_write_dump =
- (MiniDumpWriteDumpFunc)GetProcAddress(dbghelp, "MiniDumpWriteDump");
- if (mini_dump_write_dump == NULL) {
- Error("failed to create minidump: GetProcAddress('MiniDumpWriteDump'): %s",
- GetLastErrorString().c_str());
- return;
- }
-
- HANDLE hFile = CreateFileA(temp_file, GENERIC_READ | GENERIC_WRITE, 0, NULL,
- CREATE_ALWAYS, FILE_ATTRIBUTE_NORMAL, NULL);
- if (hFile == NULL) {
- Error("failed to create minidump: CreateFileA(%s): %s",
- temp_file, GetLastErrorString().c_str());
- return;
- }
-
- MINIDUMP_EXCEPTION_INFORMATION mdei;
- mdei.ThreadId = GetCurrentThreadId();
- mdei.ExceptionPointers = pep;
- mdei.ClientPointers = FALSE;
- MINIDUMP_TYPE mdt = (MINIDUMP_TYPE) (MiniDumpWithDataSegs |
- MiniDumpWithHandleData);
-
- BOOL rv = mini_dump_write_dump(GetCurrentProcess(), GetCurrentProcessId(),
- hFile, mdt, (pep != 0) ? &mdei : 0, 0, 0);
- CloseHandle(hFile);
-
- if (!rv) {
- Error("MiniDumpWriteDump failed: %s", GetLastErrorString().c_str());
- return;
- }
-
- Warning("minidump created: %s", temp_file);
-}
-
-#endif // _MSC_VER
diff --git a/src/missing_deps.cc b/src/missing_deps.cc
deleted file mode 100644
index de76620..0000000
--- a/src/missing_deps.cc
+++ /dev/null
@@ -1,192 +0,0 @@
-// Copyright 2019 Google Inc. All Rights Reserved.
-//
-// Licensed under the Apache License, Version 2.0 (the "License");
-// you may not use this file except in compliance with the License.
-// You may obtain a copy of the License at
-//
-// http://www.apache.org/licenses/LICENSE-2.0
-//
-// Unless required by applicable law or agreed to in writing, software
-// distributed under the License is distributed on an "AS IS" BASIS,
-// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-// See the License for the specific language governing permissions and
-// limitations under the License.
-
-#include "missing_deps.h"
-
-#include <string.h>
-
-#include <iostream>
-
-#include "depfile_parser.h"
-#include "deps_log.h"
-#include "disk_interface.h"
-#include "graph.h"
-#include "state.h"
-#include "util.h"
-
-namespace {
-
-/// ImplicitDepLoader variant that stores dep nodes into the given output
-/// without updating graph deps like the base loader does.
-struct NodeStoringImplicitDepLoader : public ImplicitDepLoader {
- NodeStoringImplicitDepLoader(
- State* state, DepsLog* deps_log, DiskInterface* disk_interface,
- DepfileParserOptions const* depfile_parser_options,
- std::vector<Node*>* dep_nodes_output)
- : ImplicitDepLoader(state, deps_log, disk_interface,
- depfile_parser_options),
- dep_nodes_output_(dep_nodes_output) {}
-
- protected:
- virtual bool ProcessDepfileDeps(Edge* edge,
- std::vector<StringPiece>* depfile_ins,
- std::string* err);
-
- private:
- std::vector<Node*>* dep_nodes_output_;
-};
-
-bool NodeStoringImplicitDepLoader::ProcessDepfileDeps(
- Edge* edge, std::vector<StringPiece>* depfile_ins, std::string* err) {
- for (std::vector<StringPiece>::iterator i = depfile_ins->begin();
- i != depfile_ins->end(); ++i) {
- uint64_t slash_bits;
- CanonicalizePath(const_cast<char*>(i->str_), &i->len_, &slash_bits);
- Node* node = state_->GetNode(*i, slash_bits);
- dep_nodes_output_->push_back(node);
- }
- return true;
-}
-
-} // namespace
-
-MissingDependencyScannerDelegate::~MissingDependencyScannerDelegate() {}
-
-void MissingDependencyPrinter::OnMissingDep(Node* node, const std::string& path,
- const Rule& generator) {
- std::cout << "Missing dep: " << node->path() << " uses " << path
- << " (generated by " << generator.name() << ")\n";
-}
-
-MissingDependencyScanner::MissingDependencyScanner(
- MissingDependencyScannerDelegate* delegate, DepsLog* deps_log, State* state,
- DiskInterface* disk_interface)
- : delegate_(delegate), deps_log_(deps_log), state_(state),
- disk_interface_(disk_interface), missing_dep_path_count_(0) {}
-
-void MissingDependencyScanner::ProcessNode(Node* node) {
- if (!node)
- return;
- Edge* edge = node->in_edge();
- if (!edge)
- return;
- if (!seen_.insert(node).second)
- return;
-
- for (std::vector<Node*>::iterator in = edge->inputs_.begin();
- in != edge->inputs_.end(); ++in) {
- ProcessNode(*in);
- }
-
- std::string deps_type = edge->GetBinding("deps");
- if (!deps_type.empty()) {
- DepsLog::Deps* deps = deps_log_->GetDeps(node);
- if (deps)
- ProcessNodeDeps(node, deps->nodes, deps->node_count);
- } else {
- DepfileParserOptions parser_opts;
- std::vector<Node*> depfile_deps;
- NodeStoringImplicitDepLoader dep_loader(state_, deps_log_, disk_interface_,
- &parser_opts, &depfile_deps);
- std::string err;
- dep_loader.LoadDeps(edge, &err);
- if (!depfile_deps.empty())
- ProcessNodeDeps(node, &depfile_deps[0], depfile_deps.size());
- }
-}
-
-void MissingDependencyScanner::ProcessNodeDeps(Node* node, Node** dep_nodes,
- int dep_nodes_count) {
- Edge* edge = node->in_edge();
- std::set<Edge*> deplog_edges;
- for (int i = 0; i < dep_nodes_count; ++i) {
- Node* deplog_node = dep_nodes[i];
- // Special exception: A dep on build.ninja can be used to mean "always
- // rebuild this target when the build is reconfigured", but build.ninja is
- // often generated by a configuration tool like cmake or gn. The rest of
- // the build "implicitly" depends on the entire build being reconfigured,
- // so a missing dep path to build.ninja is not an actual missing dependency
- // problem.
- if (deplog_node->path() == "build.ninja")
- return;
- Edge* deplog_edge = deplog_node->in_edge();
- if (deplog_edge) {
- deplog_edges.insert(deplog_edge);
- }
- }
- std::vector<Edge*> missing_deps;
- for (std::set<Edge*>::iterator de = deplog_edges.begin();
- de != deplog_edges.end(); ++de) {
- if (!PathExistsBetween(*de, edge)) {
- missing_deps.push_back(*de);
- }
- }
-
- if (!missing_deps.empty()) {
- std::set<std::string> missing_deps_rule_names;
- for (std::vector<Edge*>::iterator ne = missing_deps.begin();
- ne != missing_deps.end(); ++ne) {
- for (int i = 0; i < dep_nodes_count; ++i) {
- if (dep_nodes[i]->in_edge() == *ne) {
- generated_nodes_.insert(dep_nodes[i]);
- generator_rules_.insert(&(*ne)->rule());
- missing_deps_rule_names.insert((*ne)->rule().name());
- delegate_->OnMissingDep(node, dep_nodes[i]->path(), (*ne)->rule());
- }
- }
- }
- missing_dep_path_count_ += missing_deps_rule_names.size();
- nodes_missing_deps_.insert(node);
- }
-}
-
-void MissingDependencyScanner::PrintStats() {
- std::cout << "Processed " << seen_.size() << " nodes.\n";
- if (HadMissingDeps()) {
- std::cout << "Error: There are " << missing_dep_path_count_
- << " missing dependency paths.\n";
- std::cout << nodes_missing_deps_.size()
- << " targets had depfile dependencies on "
- << generated_nodes_.size() << " distinct generated inputs "
- << "(from " << generator_rules_.size() << " rules) "
- << " without a non-depfile dep path to the generator.\n";
- std::cout << "There might be build flakiness if any of the targets listed "
- "above are built alone, or not late enough, in a clean output "
- "directory.\n";
- } else {
- std::cout << "No missing dependencies on generated files found.\n";
- }
-}
-
-bool MissingDependencyScanner::PathExistsBetween(Edge* from, Edge* to) {
- AdjacencyMap::iterator it = adjacency_map_.find(from);
- if (it != adjacency_map_.end()) {
- InnerAdjacencyMap::iterator inner_it = it->second.find(to);
- if (inner_it != it->second.end()) {
- return inner_it->second;
- }
- } else {
- it = adjacency_map_.insert(std::make_pair(from, InnerAdjacencyMap())).first;
- }
- bool found = false;
- for (size_t i = 0; i < to->inputs_.size(); ++i) {
- Edge* e = to->inputs_[i]->in_edge();
- if (e && (e == from || PathExistsBetween(from, e))) {
- found = true;
- break;
- }
- }
- it->second.insert(std::make_pair(to, found));
- return found;
-}
diff --git a/src/missing_deps.h b/src/missing_deps.h
deleted file mode 100644
index 7a615da..0000000
--- a/src/missing_deps.h
+++ /dev/null
@@ -1,74 +0,0 @@
-// Copyright 2019 Google Inc. All Rights Reserved.
-//
-// Licensed under the Apache License, Version 2.0 (the "License");
-// you may not use this file except in compliance with the License.
-// You may obtain a copy of the License at
-//
-// http://www.apache.org/licenses/LICENSE-2.0
-//
-// Unless required by applicable law or agreed to in writing, software
-// distributed under the License is distributed on an "AS IS" BASIS,
-// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-// See the License for the specific language governing permissions and
-// limitations under the License.
-
-#ifndef NINJA_MISSING_DEPS_H_
-#define NINJA_MISSING_DEPS_H_
-
-#include <map>
-#include <set>
-#include <string>
-
-#include <unordered_map>
-
-struct DepsLog;
-struct DiskInterface;
-struct Edge;
-struct Node;
-struct Rule;
-struct State;
-
-class MissingDependencyScannerDelegate {
- public:
- virtual ~MissingDependencyScannerDelegate();
- virtual void OnMissingDep(Node* node, const std::string& path,
- const Rule& generator) = 0;
-};
-
-class MissingDependencyPrinter : public MissingDependencyScannerDelegate {
- void OnMissingDep(Node* node, const std::string& path, const Rule& generator);
- void OnStats(int nodes_processed, int nodes_missing_deps,
- int missing_dep_path_count, int generated_nodes,
- int generator_rules);
-};
-
-struct MissingDependencyScanner {
- public:
- MissingDependencyScanner(MissingDependencyScannerDelegate* delegate,
- DepsLog* deps_log, State* state,
- DiskInterface* disk_interface);
- void ProcessNode(Node* node);
- void PrintStats();
- bool HadMissingDeps() { return !nodes_missing_deps_.empty(); }
-
- void ProcessNodeDeps(Node* node, Node** dep_nodes, int dep_nodes_count);
-
- bool PathExistsBetween(Edge* from, Edge* to);
-
- MissingDependencyScannerDelegate* delegate_;
- DepsLog* deps_log_;
- State* state_;
- DiskInterface* disk_interface_;
- std::set<Node*> seen_;
- std::set<Node*> nodes_missing_deps_;
- std::set<Node*> generated_nodes_;
- std::set<const Rule*> generator_rules_;
- int missing_dep_path_count_;
-
- private:
- using InnerAdjacencyMap = std::unordered_map<Edge*, bool>;
- using AdjacencyMap = std::unordered_map<Edge*, InnerAdjacencyMap>;
- AdjacencyMap adjacency_map_;
-};
-
-#endif // NINJA_MISSING_DEPS_H_
diff --git a/src/missing_deps_test.cc b/src/missing_deps_test.cc
deleted file mode 100644
index db66885..0000000
--- a/src/missing_deps_test.cc
+++ /dev/null
@@ -1,162 +0,0 @@
-// Copyright 2019 Google Inc. All Rights Reserved.
-//
-// Licensed under the Apache License, Version 2.0 (the "License");
-// you may not use this file except in compliance with the License.
-// You may obtain a copy of the License at
-//
-// http://www.apache.org/licenses/LICENSE-2.0
-//
-// Unless required by applicable law or agreed to in writing, software
-// distributed under the License is distributed on an "AS IS" BASIS,
-// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-// See the License for the specific language governing permissions and
-// limitations under the License.
-
-#include <memory>
-
-#include "deps_log.h"
-#include "graph.h"
-#include "missing_deps.h"
-#include "state.h"
-#include "test.h"
-
-const char kTestDepsLogFilename[] = "MissingDepTest-tempdepslog";
-
-class MissingDependencyTestDelegate : public MissingDependencyScannerDelegate {
- void OnMissingDep(Node* node, const std::string& path,
- const Rule& generator) {}
-};
-
-struct MissingDependencyScannerTest : public testing::Test {
- MissingDependencyScannerTest()
- : generator_rule_("generator_rule"), compile_rule_("compile_rule"),
- scanner_(&delegate_, &deps_log_, &state_, &filesystem_) {
- std::string err;
- deps_log_.OpenForWrite(kTestDepsLogFilename, &err);
- ASSERT_EQ("", err);
- }
-
- MissingDependencyScanner& scanner() { return scanner_; }
-
- void RecordDepsLogDep(const std::string& from, const std::string& to) {
- Node* node_deps[] = { state_.LookupNode(to) };
- deps_log_.RecordDeps(state_.LookupNode(from), 0, 1, node_deps);
- }
-
- void ProcessAllNodes() {
- std::string err;
- std::vector<Node*> nodes = state_.RootNodes(&err);
- EXPECT_EQ("", err);
- for (std::vector<Node*>::iterator it = nodes.begin(); it != nodes.end();
- ++it) {
- scanner().ProcessNode(*it);
- }
- }
-
- void CreateInitialState() {
- EvalString deps_type;
- deps_type.AddText("gcc");
- compile_rule_.AddBinding("deps", deps_type);
- generator_rule_.AddBinding("deps", deps_type);
- Edge* header_edge = state_.AddEdge(&generator_rule_);
- state_.AddOut(header_edge, "generated_header", 0);
- Edge* compile_edge = state_.AddEdge(&compile_rule_);
- state_.AddOut(compile_edge, "compiled_object", 0);
- }
-
- void CreateGraphDependencyBetween(const char* from, const char* to) {
- Node* from_node = state_.LookupNode(from);
- Edge* from_edge = from_node->in_edge();
- state_.AddIn(from_edge, to, 0);
- }
-
- void AssertMissingDependencyBetween(const char* flaky, const char* generated,
- Rule* rule) {
- Node* flaky_node = state_.LookupNode(flaky);
- ASSERT_EQ(1u, scanner().nodes_missing_deps_.count(flaky_node));
- Node* generated_node = state_.LookupNode(generated);
- ASSERT_EQ(1u, scanner().generated_nodes_.count(generated_node));
- ASSERT_EQ(1u, scanner().generator_rules_.count(rule));
- }
-
- MissingDependencyTestDelegate delegate_;
- Rule generator_rule_;
- Rule compile_rule_;
- DepsLog deps_log_;
- State state_;
- VirtualFileSystem filesystem_;
- MissingDependencyScanner scanner_;
-};
-
-TEST_F(MissingDependencyScannerTest, EmptyGraph) {
- ProcessAllNodes();
- ASSERT_FALSE(scanner().HadMissingDeps());
-}
-
-TEST_F(MissingDependencyScannerTest, NoMissingDep) {
- CreateInitialState();
- ProcessAllNodes();
- ASSERT_FALSE(scanner().HadMissingDeps());
-}
-
-TEST_F(MissingDependencyScannerTest, MissingDepPresent) {
- CreateInitialState();
- // compiled_object uses generated_header, without a proper dependency
- RecordDepsLogDep("compiled_object", "generated_header");
- ProcessAllNodes();
- ASSERT_TRUE(scanner().HadMissingDeps());
- ASSERT_EQ(1u, scanner().nodes_missing_deps_.size());
- ASSERT_EQ(1u, scanner().missing_dep_path_count_);
- AssertMissingDependencyBetween("compiled_object", "generated_header",
- &generator_rule_);
-}
-
-TEST_F(MissingDependencyScannerTest, MissingDepFixedDirect) {
- CreateInitialState();
- // Adding the direct dependency fixes the missing dep
- CreateGraphDependencyBetween("compiled_object", "generated_header");
- RecordDepsLogDep("compiled_object", "generated_header");
- ProcessAllNodes();
- ASSERT_FALSE(scanner().HadMissingDeps());
-}
-
-TEST_F(MissingDependencyScannerTest, MissingDepFixedIndirect) {
- CreateInitialState();
- // Adding an indirect dependency also fixes the issue
- Edge* intermediate_edge = state_.AddEdge(&generator_rule_);
- state_.AddOut(intermediate_edge, "intermediate", 0);
- CreateGraphDependencyBetween("compiled_object", "intermediate");
- CreateGraphDependencyBetween("intermediate", "generated_header");
- RecordDepsLogDep("compiled_object", "generated_header");
- ProcessAllNodes();
- ASSERT_FALSE(scanner().HadMissingDeps());
-}
-
-TEST_F(MissingDependencyScannerTest, CyclicMissingDep) {
- CreateInitialState();
- RecordDepsLogDep("generated_header", "compiled_object");
- RecordDepsLogDep("compiled_object", "generated_header");
- // In case of a cycle, both paths are reported (and there is
- // no way to fix the issue by adding deps).
- ProcessAllNodes();
- ASSERT_TRUE(scanner().HadMissingDeps());
- ASSERT_EQ(2u, scanner().nodes_missing_deps_.size());
- ASSERT_EQ(2u, scanner().missing_dep_path_count_);
- AssertMissingDependencyBetween("compiled_object", "generated_header",
- &generator_rule_);
- AssertMissingDependencyBetween("generated_header", "compiled_object",
- &compile_rule_);
-}
-
-TEST_F(MissingDependencyScannerTest, CycleInGraph) {
- CreateInitialState();
- CreateGraphDependencyBetween("compiled_object", "generated_header");
- CreateGraphDependencyBetween("generated_header", "compiled_object");
- // The missing-deps tool doesn't deal with cycles in the graph, because
- // there will be an error loading the graph before we get to the tool.
- // This test is to illustrate that.
- std::string err;
- std::vector<Node*> nodes = state_.RootNodes(&err);
- ASSERT_NE("", err);
-}
-
diff --git a/src/msvc_helper-win32.cc b/src/msvc_helper-win32.cc
deleted file mode 100644
index 1148ae5..0000000
--- a/src/msvc_helper-win32.cc
+++ /dev/null
@@ -1,108 +0,0 @@
-// Copyright 2011 Google Inc. All Rights Reserved.
-//
-// Licensed under the Apache License, Version 2.0 (the "License");
-// you may not use this file except in compliance with the License.
-// You may obtain a copy of the License at
-//
-// http://www.apache.org/licenses/LICENSE-2.0
-//
-// Unless required by applicable law or agreed to in writing, software
-// distributed under the License is distributed on an "AS IS" BASIS,
-// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-// See the License for the specific language governing permissions and
-// limitations under the License.
-
-#include "msvc_helper.h"
-
-#include <windows.h>
-
-#include "util.h"
-
-using namespace std;
-
-namespace {
-
-string Replace(const string& input, const string& find, const string& replace) {
- string result = input;
- size_t start_pos = 0;
- while ((start_pos = result.find(find, start_pos)) != string::npos) {
- result.replace(start_pos, find.length(), replace);
- start_pos += replace.length();
- }
- return result;
-}
-
-} // anonymous namespace
-
-string EscapeForDepfile(const string& path) {
- // Depfiles don't escape single \.
- return Replace(path, " ", "\\ ");
-}
-
-int CLWrapper::Run(const string& command, string* output) {
- SECURITY_ATTRIBUTES security_attributes = {};
- security_attributes.nLength = sizeof(SECURITY_ATTRIBUTES);
- security_attributes.bInheritHandle = TRUE;
-
- // Must be inheritable so subprocesses can dup to children.
- HANDLE nul =
- CreateFileA("NUL", GENERIC_READ,
- FILE_SHARE_READ | FILE_SHARE_WRITE | FILE_SHARE_DELETE,
- &security_attributes, OPEN_EXISTING, 0, NULL);
- if (nul == INVALID_HANDLE_VALUE)
- Fatal("couldn't open nul");
-
- HANDLE stdout_read, stdout_write;
- if (!CreatePipe(&stdout_read, &stdout_write, &security_attributes, 0))
- Win32Fatal("CreatePipe");
-
- if (!SetHandleInformation(stdout_read, HANDLE_FLAG_INHERIT, 0))
- Win32Fatal("SetHandleInformation");
-
- PROCESS_INFORMATION process_info = {};
- STARTUPINFOA startup_info = {};
- startup_info.cb = sizeof(STARTUPINFOA);
- startup_info.hStdInput = nul;
- startup_info.hStdError = ::GetStdHandle(STD_ERROR_HANDLE);
- startup_info.hStdOutput = stdout_write;
- startup_info.dwFlags |= STARTF_USESTDHANDLES;
-
- if (!CreateProcessA(NULL, (char*)command.c_str(), NULL, NULL,
- /* inherit handles */ TRUE, 0,
- env_block_, NULL,
- &startup_info, &process_info)) {
- Win32Fatal("CreateProcess");
- }
-
- if (!CloseHandle(nul) ||
- !CloseHandle(stdout_write)) {
- Win32Fatal("CloseHandle");
- }
-
- // Read all output of the subprocess.
- DWORD read_len = 1;
- while (read_len) {
- char buf[64 << 10];
- read_len = 0;
- if (!::ReadFile(stdout_read, buf, sizeof(buf), &read_len, NULL) &&
- GetLastError() != ERROR_BROKEN_PIPE) {
- Win32Fatal("ReadFile");
- }
- output->append(buf, read_len);
- }
-
- // Wait for it to exit and grab its exit code.
- if (WaitForSingleObject(process_info.hProcess, INFINITE) == WAIT_FAILED)
- Win32Fatal("WaitForSingleObject");
- DWORD exit_code = 0;
- if (!GetExitCodeProcess(process_info.hProcess, &exit_code))
- Win32Fatal("GetExitCodeProcess");
-
- if (!CloseHandle(stdout_read) ||
- !CloseHandle(process_info.hProcess) ||
- !CloseHandle(process_info.hThread)) {
- Win32Fatal("CloseHandle");
- }
-
- return exit_code;
-}
diff --git a/src/msvc_helper.h b/src/msvc_helper.h
deleted file mode 100644
index 568b9f9..0000000
--- a/src/msvc_helper.h
+++ /dev/null
@@ -1,32 +0,0 @@
-// Copyright 2011 Google Inc. All Rights Reserved.
-//
-// Licensed under the Apache License, Version 2.0 (the "License");
-// you may not use this file except in compliance with the License.
-// You may obtain a copy of the License at
-//
-// http://www.apache.org/licenses/LICENSE-2.0
-//
-// Unless required by applicable law or agreed to in writing, software
-// distributed under the License is distributed on an "AS IS" BASIS,
-// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-// See the License for the specific language governing permissions and
-// limitations under the License.
-
-#include <string>
-
-std::string EscapeForDepfile(const std::string& path);
-
-/// Wraps a synchronous execution of a CL subprocess.
-struct CLWrapper {
- CLWrapper() : env_block_(NULL) {}
-
- /// Set the environment block (as suitable for CreateProcess) to be used
- /// by Run().
- void SetEnvBlock(void* env_block) { env_block_ = env_block; }
-
- /// Start a process and gather its raw output. Returns its exit code.
- /// Crashes (calls Fatal()) on error.
- int Run(const std::string& command, std::string* output);
-
- void* env_block_;
-};
diff --git a/src/msvc_helper_main-win32.cc b/src/msvc_helper_main-win32.cc
deleted file mode 100644
index 7d59307..0000000
--- a/src/msvc_helper_main-win32.cc
+++ /dev/null
@@ -1,150 +0,0 @@
-// Copyright 2011 Google Inc. All Rights Reserved.
-//
-// Licensed under the Apache License, Version 2.0 (the "License");
-// you may not use this file except in compliance with the License.
-// You may obtain a copy of the License at
-//
-// http://www.apache.org/licenses/LICENSE-2.0
-//
-// Unless required by applicable law or agreed to in writing, software
-// distributed under the License is distributed on an "AS IS" BASIS,
-// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-// See the License for the specific language governing permissions and
-// limitations under the License.
-
-#include "msvc_helper.h"
-
-#include <fcntl.h>
-#include <io.h>
-#include <stdio.h>
-#include <windows.h>
-
-#include "clparser.h"
-#include "util.h"
-
-#include "getopt.h"
-
-using namespace std;
-
-namespace {
-
-void Usage() {
- printf(
-"usage: ninja -t msvc [options] -- cl.exe /showIncludes /otherArgs\n"
-"options:\n"
-" -e ENVFILE load environment block from ENVFILE as environment\n"
-" -o FILE write output dependency information to FILE.d\n"
-" -p STRING localized prefix of msvc's /showIncludes output\n"
- );
-}
-
-void PushPathIntoEnvironment(const string& env_block) {
- const char* as_str = env_block.c_str();
- while (as_str[0]) {
- if (_strnicmp(as_str, "path=", 5) == 0) {
- _putenv(as_str);
- return;
- } else {
- as_str = &as_str[strlen(as_str) + 1];
- }
- }
-}
-
-void WriteDepFileOrDie(const char* object_path, const CLParser& parse) {
- string depfile_path = string(object_path) + ".d";
- FILE* depfile = fopen(depfile_path.c_str(), "w");
- if (!depfile) {
- unlink(object_path);
- Fatal("opening %s: %s", depfile_path.c_str(),
- GetLastErrorString().c_str());
- }
- if (fprintf(depfile, "%s: ", object_path) < 0) {
- unlink(object_path);
- fclose(depfile);
- unlink(depfile_path.c_str());
- Fatal("writing %s", depfile_path.c_str());
- }
- const set<string>& headers = parse.includes_;
- for (set<string>::const_iterator i = headers.begin();
- i != headers.end(); ++i) {
- if (fprintf(depfile, "%s\n", EscapeForDepfile(*i).c_str()) < 0) {
- unlink(object_path);
- fclose(depfile);
- unlink(depfile_path.c_str());
- Fatal("writing %s", depfile_path.c_str());
- }
- }
- fclose(depfile);
-}
-
-} // anonymous namespace
-
-int MSVCHelperMain(int argc, char** argv) {
- const char* output_filename = NULL;
- const char* envfile = NULL;
-
- const option kLongOptions[] = {
- { "help", no_argument, NULL, 'h' },
- { NULL, 0, NULL, 0 }
- };
- int opt;
- string deps_prefix;
- while ((opt = getopt_long(argc, argv, "e:o:p:h", kLongOptions, NULL)) != -1) {
- switch (opt) {
- case 'e':
- envfile = optarg;
- break;
- case 'o':
- output_filename = optarg;
- break;
- case 'p':
- deps_prefix = optarg;
- break;
- case 'h':
- default:
- Usage();
- return 0;
- }
- }
-
- string env;
- if (envfile) {
- string err;
- if (ReadFile(envfile, &env, &err) != 0)
- Fatal("couldn't open %s: %s", envfile, err.c_str());
- PushPathIntoEnvironment(env);
- }
-
- char* command = GetCommandLineA();
- command = strstr(command, " -- ");
- if (!command) {
- Fatal("expected command line to end with \" -- command args\"");
- }
- command += 4;
-
- CLWrapper cl;
- if (!env.empty())
- cl.SetEnvBlock((void*)env.data());
- string output;
- int exit_code = cl.Run(command, &output);
-
- if (output_filename) {
- CLParser parser;
- string err;
- if (!parser.Parse(output, deps_prefix, &output, &err))
- Fatal("%s\n", err.c_str());
- WriteDepFileOrDie(output_filename, parser);
- }
-
- if (output.empty())
- return exit_code;
-
- // CLWrapper's output already as \r\n line endings, make sure the C runtime
- // doesn't expand this to \r\r\n.
- _setmode(_fileno(stdout), _O_BINARY);
- // Avoid printf and C strings, since the actual output might contain null
- // bytes like UTF-16 does (yuck).
- fwrite(&output[0], 1, output.size(), stdout);
-
- return exit_code;
-}
diff --git a/src/msvc_helper_test.cc b/src/msvc_helper_test.cc
deleted file mode 100644
index d9e2ee6..0000000
--- a/src/msvc_helper_test.cc
+++ /dev/null
@@ -1,41 +0,0 @@
-// Copyright 2011 Google Inc. All Rights Reserved.
-//
-// Licensed under the Apache License, Version 2.0 (the "License");
-// you may not use this file except in compliance with the License.
-// You may obtain a copy of the License at
-//
-// http://www.apache.org/licenses/LICENSE-2.0
-//
-// Unless required by applicable law or agreed to in writing, software
-// distributed under the License is distributed on an "AS IS" BASIS,
-// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-// See the License for the specific language governing permissions and
-// limitations under the License.
-
-#include "msvc_helper.h"
-
-#include "test.h"
-#include "util.h"
-
-using namespace std;
-
-TEST(EscapeForDepfileTest, SpacesInFilename) {
- ASSERT_EQ("sub\\some\\ sdk\\foo.h",
- EscapeForDepfile("sub\\some sdk\\foo.h"));
-}
-
-TEST(MSVCHelperTest, EnvBlock) {
- char env_block[] = "foo=bar\0";
- CLWrapper cl;
- cl.SetEnvBlock(env_block);
- string output;
- cl.Run("cmd /c \"echo foo is %foo%", &output);
- ASSERT_EQ("foo is bar\r\n", output);
-}
-
-TEST(MSVCHelperTest, NoReadOfStderr) {
- CLWrapper cl;
- string output;
- cl.Run("cmd /c \"echo to stdout&& echo to stderr 1>&2", &output);
- ASSERT_EQ("to stdout\r\n", output);
-}
diff --git a/src/ninja.cc b/src/ninja.cc
deleted file mode 100644
index df67736..0000000
--- a/src/ninja.cc
+++ /dev/null
@@ -1,1974 +0,0 @@
-// Copyright 2011 Google Inc. All Rights Reserved.
-//
-// Licensed under the Apache License, Version 2.0 (the "License");
-// you may not use this file except in compliance with the License.
-// You may obtain a copy of the License at
-//
-// http://www.apache.org/licenses/LICENSE-2.0
-//
-// Unless required by applicable law or agreed to in writing, software
-// distributed under the License is distributed on an "AS IS" BASIS,
-// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-// See the License for the specific language governing permissions and
-// limitations under the License.
-
-#include <assert.h>
-#include <errno.h>
-#include <limits.h>
-#include <stdio.h>
-#include <stdlib.h>
-#include <string.h>
-
-#include <algorithm>
-#include <cstdlib>
-
-#ifdef _WIN32
-#include "getopt.h"
-#include <direct.h>
-#include <windows.h>
-#elif defined(_AIX)
-#include "getopt.h"
-#include <unistd.h>
-#else
-#include <getopt.h>
-#include <unistd.h>
-#endif
-
-#include "async_loop.h"
-#include "browse.h"
-#include "build.h"
-#include "build_config.h"
-#include "build_log.h"
-#include "clean.h"
-#include "debug_flags.h"
-#include "depfile_parser.h"
-#include "deps_log.h"
-#include "disk_interface.h"
-#include "graph.h"
-#include "graphviz.h"
-#include "ipc_utils.h"
-#include "json.h"
-#include "manifest_parser.h"
-#include "metrics.h"
-#include "missing_deps.h"
-#include "persistent_mode.h"
-#include "state.h"
-#include "status.h"
-#include "string_piece.h"
-#include "util.h"
-#include "version.h"
-
-using namespace std;
-
-#ifdef _WIN32
-// Defined in msvc_helper_main-win32.cc.
-int MSVCHelperMain(int argc, char** argv);
-
-// Defined in minidump-win32.cc.
-void CreateWin32MiniDump(_EXCEPTION_POINTERS* pep);
-#endif
-
-namespace {
-
-struct Tool;
-
-/// Command-line options.
-struct Options {
- /// Directory to change into before running.
- const char* working_dir = nullptr;
-
- /// Tool to run rather than building.
- const Tool* tool = nullptr;
-
- /// Whether duplicate rules for one target should warn or print an error.
- bool dupe_edges_should_err = true;
-
- /// Whether phony cycles should warn or print an error.
- bool phony_cycle_should_err = false;
-};
-
-/// A special value return by NinjaMain::RunBeforeBuild() to
-/// indicate that the build can proceed after loading the manifest
-/// and the logs. Must be strictly negative.
-static const int kBuildCanProceed = -1;
-
-/// The Ninja main() loads up a series of data structures; various tools need
-/// to poke into these, so store them as fields on an object.
-struct NinjaMain : public BuildLogUser {
- NinjaMain(const char* ninja_command, const BuildConfig& config)
- : ninja_command_(ninja_command), config_(&config),
- status_(new StatusPrinter(config)),
- path_recording_disk_interface_(&disk_interface_),
- start_time_millis_(GetTimeMillis()) {}
-
- /// Command line used to run Ninja.
- const char* ninja_command_;
-
- /// Build configuration set from flags (e.g. parallelism).
- const BuildConfig* config_;
-
- /// The Status instance to send update status messages.
- Status* status() const { return status_.get(); }
-
- std::unique_ptr<Status> status_;
-
- /// Completely reset state. This gets rid of the current build graph,
- /// rule definitions, logs and timestamp caches.
- void Reset() {
- // Note: state_.Reset() does not fully reset the variable!
- build_log_ = BuildLog();
-
- // deps_log_ contains pointers into Node instance owned by state_, so
- // reset it before it.
- deps_log_ = DepsLog();
-
- state_ = State();
- start_time_millis_ = GetTimeMillis();
- path_recording_disk_interface_.Reset();
- disk_interface_.FlushCache();
- }
-
- /// Reset just enough state to allow a new (possibly incremental) build.
- /// This keeps the build graph in memory, but resets its state properly
- /// to avoid relying on previously computed data from a previous build
- /// (e.g. timestamps, or undrained pools when the build was
- /// user-interrupted).
- void PrepareBuild(const BuildConfig& config) {
- state_.Reset();
- start_time_millis_ = GetTimeMillis();
- config_ = &config;
- // Reset status, since stdio was redirected when in persistent
- // server process.
- status_.reset(new StatusPrinter(config));
- disk_interface_.Sync();
- }
-
- /// Loaded state (rules, nodes).
- State state_;
-
- /// Functions for accessing the disk.
- RealDiskInterface disk_interface_;
-
- /// A DiskInterface instance that records which input files were opened
- /// when loading manifests. Used later to shutdown a persistent server
- /// automatically if any one of these files changed.
- PathRecordingFileReader path_recording_disk_interface_;
-
- /// The build directory, used for storing the build log etc.
- string build_dir_;
-
- BuildLog build_log_;
- DepsLog deps_log_;
-
- /// The type of functions that are the entry points to tools (subcommands).
- typedef int (NinjaMain::*ToolFunc)(const Options*, int, char**);
-
- /// Get the Node for a given command-line path, handling features like
- /// spell correction.
- Node* CollectTarget(const char* cpath, string* err);
-
- /// CollectTarget for all command-line arguments, filling in \a targets.
- bool CollectTargetsFromArgs(int argc, char* argv[],
- vector<Node*>* targets, string* err);
-
- // The various subcommands, run via "-t XXX".
- int ToolGraph(const Options* options, int argc, char* argv[]);
- int ToolQuery(const Options* options, int argc, char* argv[]);
- int ToolDeps(const Options* options, int argc, char* argv[]);
- int ToolMissingDeps(const Options* options, int argc, char* argv[]);
- int ToolBrowse(const Options* options, int argc, char* argv[]);
- int ToolMSVC(const Options* options, int argc, char* argv[]);
- int ToolTargets(const Options* options, int argc, char* argv[]);
- int ToolCommands(const Options* options, int argc, char* argv[]);
- int ToolInputs(const Options* options, int argc, char* argv[]);
- int ToolClean(const Options* options, int argc, char* argv[]);
- int ToolCleanDead(const Options* options, int argc, char* argv[]);
- int ToolCompilationDatabase(const Options* options, int argc, char* argv[]);
- int ToolRecompact(const Options* options, int argc, char* argv[]);
- int ToolRestat(const Options* options, int argc, char* argv[]);
- int ToolUrtle(const Options* options, int argc, char** argv);
- int ToolRules(const Options* options, int argc, char* argv[]);
- int ToolWinCodePage(const Options* options, int argc, char* argv[]);
- int ToolServer(const Options* options, int argc, char* argv[]);
-
- /// Open the build log.
- /// @return false on error.
- bool OpenBuildLog(bool recompact_only = false);
-
- /// Open the deps log: load it, then open for writing.
- /// @return false on error.
- bool OpenDepsLog(bool recompact_only = false);
-
- /// Ensure the build directory exists, creating it if necessary.
- /// @return false on error.
- bool EnsureBuildDirExists();
-
- /// Rebuild the manifest, if necessary.
- /// Fills in \a err on error.
- /// @return true if the manifest was rebuilt.
- bool RebuildManifest(std::string* err, bool silent_dry_run = false);
-
- /// Perform all operations before the build itself, i.e.
- /// load the manifest, the build log, the deps log, and
- /// any tool if needed. Return kBuildCanProceed to indicate that
- /// the build can proceed after the call, or a positive process
- /// exit code to tell Ninja to stop.
- int RunBeforeBuild(const Options& options, int argc, char** argv);
-
- /// Build the targets listed on the command line.
- /// @return an exit code.
- int RunBuild(int argc, char** argv);
-
- /// Dump the output requested by '-d stats'.
- void DumpMetrics();
-
- virtual bool IsPathDead(StringPiece s) const {
- Node* n = state_.LookupNode(s);
- if (n && n->in_edge())
- return false;
- // Just checking n isn't enough: If an old output is both in the build log
- // and in the deps log, it will have a Node object in state_. (It will also
- // have an in edge if one of its inputs is another output that's in the deps
- // log, but having a deps edge product an output that's input to another deps
- // edge is rare, and the first recompaction will delete all old outputs from
- // the deps log, and then a second recompaction will clear the build log,
- // which seems good enough for this corner case.)
- // Do keep entries around for files which still exist on disk, for
- // generators that want to use this information.
- string err;
- TimeStamp mtime = disk_interface_.Stat(s.AsString(), &err);
- if (mtime == -1)
- Error("%s", err.c_str()); // Log and ignore Stat() errors.
- return mtime == 0;
- }
-
- int64_t start_time_millis_;
-};
-
-/// Subtools, accessible via "-t foo".
-struct Tool {
- /// Short name of the tool.
- const char* name;
-
- /// Description (shown in "-t list").
- const char* desc;
-
- /// When to run the tool.
- enum {
- /// Run after parsing the command-line flags and potentially changing
- /// the current working directory (as early as possible).
- RUN_AFTER_FLAGS,
-
- /// Run after loading build.ninja.
- RUN_AFTER_LOAD,
-
- /// Run after loading the build/deps logs.
- RUN_AFTER_LOGS,
- } when;
-
- /// Implementation of the tool.
- NinjaMain::ToolFunc func;
-};
-
-/// Print usage information.
-void Usage(const BuildConfig& config) {
- fprintf(stderr,
-"usage: ninja [options] [targets...]\n"
-"\n"
-"if targets are unspecified, builds the 'default' target (see manual).\n"
-"\n"
-"options:\n"
-" --version print ninja version (\"%s\")\n"
-" -v, --verbose show all command lines while building\n"
-" --quiet don't show progress status, just command output\n"
-"\n"
-" -C DIR change to DIR before doing anything else\n"
-" -f FILE specify input build file [default=build.ninja]\n"
-"\n"
-" -j N run N jobs in parallel (0 means infinity) [default=%d on this system]\n"
-" -k N keep going until N jobs fail (0 means infinity) [default=1]\n"
-" -l N do not start new jobs if the load average is greater than N\n"
-" -n dry run (don't run commands but act like they succeeded)\n"
-"\n"
-" -d MODE enable debugging (use '-d list' to list modes)\n"
-" -t TOOL run a subtool (use '-t list' to list subtools)\n"
-" terminates toplevel options; further flags are passed to the tool\n"
-" -w FLAG adjust warnings (use '-w list' to list warnings)\n",
- kNinjaVersion, config.parallelism);
-}
-
-/// Choose a default value for the -j (parallelism) flag.
-int GuessParallelism() {
- switch (int processors = GetProcessorCount()) {
- case 0:
- case 1:
- return 2;
- case 2:
- return 3;
- default:
- return processors + 2;
- }
-}
-
-/// Rebuild the build manifest, if necessary.
-/// If \arg silenty_dry_run is true, do not modify anything on disk.
-/// Returns true if the manifest was rebuilt.
-bool NinjaMain::RebuildManifest(std::string* err, bool silent_dry_run) {
- std::string path = config_->input_file;
- if (path.empty()) {
- *err = "empty path";
- return false;
- }
-
- uint64_t slash_bits; // Unused because this path is only used for lookup.
- CanonicalizePath(&path, &slash_bits);
- Node* node = state_.LookupNode(path);
- if (!node)
- return false;
-
- BuildConfig config = *config_;
- if (silent_dry_run) {
- config.verbosity = BuildConfig::QUIET;
- config.dry_run = true;
- }
-
- Builder builder(&state_, config, &build_log_, &deps_log_, &disk_interface_,
- status(), start_time_millis_);
-
- if (!builder.AddTarget(node, err))
- return false;
-
- if (builder.AlreadyUpToDate())
- return false; // Not an error, but we didn't rebuild.
-
- if (!builder.Build(err))
- return false;
-
- // The manifest was only rebuilt if it is now dirty (it may have been cleaned
- // by a restat).
- if (!node->dirty()) {
- // Reset the state to prevent problems like
- // https://github.com/ninja-build/ninja/issues/874
- state_.Reset();
- return false;
- }
-
- return true;
-}
-
-Node* NinjaMain::CollectTarget(const char* cpath, string* err) {
- string path = cpath;
- if (path.empty()) {
- *err = "empty path";
- return NULL;
- }
- uint64_t slash_bits;
- CanonicalizePath(&path, &slash_bits);
-
- // Special syntax: "foo.cc^" means "the first output of foo.cc".
- bool first_dependent = false;
- if (!path.empty() && path[path.size() - 1] == '^') {
- path.resize(path.size() - 1);
- first_dependent = true;
- }
-
- Node* node = state_.LookupNode(path);
- if (node) {
- if (first_dependent) {
- if (node->out_edges().empty()) {
- Node* rev_deps = deps_log_.GetFirstReverseDepsNode(node);
- if (!rev_deps) {
- *err = "'" + path + "' has no out edge";
- return NULL;
- }
- node = rev_deps;
- } else {
- Edge* edge = node->out_edges()[0];
- if (edge->outputs_.empty()) {
- edge->Dump();
- Fatal("edge has no outputs");
- }
- node = edge->outputs_[0];
- }
- }
- return node;
- } else {
- *err =
- "unknown target '" + Node::PathDecanonicalized(path, slash_bits) + "'";
- if (path == "clean") {
- *err += ", did you mean 'ninja -t clean'?";
- } else if (path == "help") {
- *err += ", did you mean 'ninja -h'?";
- } else {
- Node* suggestion = state_.SpellcheckNode(path);
- if (suggestion) {
- *err += ", did you mean '" + suggestion->path() + "'?";
- }
- }
- return NULL;
- }
-}
-
-bool NinjaMain::CollectTargetsFromArgs(int argc, char* argv[],
- vector<Node*>* targets, string* err) {
- if (argc == 0) {
- *targets = state_.DefaultNodes(err);
- return err->empty();
- }
-
- for (int i = 0; i < argc; ++i) {
- Node* node = CollectTarget(argv[i], err);
- if (node == NULL)
- return false;
- targets->push_back(node);
- }
- return true;
-}
-
-int NinjaMain::ToolGraph(const Options* options, int argc, char* argv[]) {
- vector<Node*> nodes;
- string err;
- if (!CollectTargetsFromArgs(argc, argv, &nodes, &err)) {
- Error("%s", err.c_str());
- return 1;
- }
-
- GraphViz graph(&state_, &disk_interface_);
- graph.Start();
- for (vector<Node*>::const_iterator n = nodes.begin(); n != nodes.end(); ++n)
- graph.AddTarget(*n);
- graph.Finish();
-
- return 0;
-}
-
-int NinjaMain::ToolQuery(const Options* options, int argc, char* argv[]) {
- if (argc == 0) {
- Error("expected a target to query");
- return 1;
- }
-
- DyndepLoader dyndep_loader(&state_, &disk_interface_);
-
- for (int i = 0; i < argc; ++i) {
- string err;
- Node* node = CollectTarget(argv[i], &err);
- if (!node) {
- Error("%s", err.c_str());
- return 1;
- }
-
- printf("%s:\n", node->path().c_str());
- if (Edge* edge = node->in_edge()) {
- if (edge->dyndep_ && edge->dyndep_->dyndep_pending()) {
- if (!dyndep_loader.LoadDyndeps(edge->dyndep_, &err)) {
- Warning("%s\n", err.c_str());
- }
- }
- printf(" input: %s\n", edge->rule_->name().c_str());
- for (int in = 0; in < (int)edge->inputs_.size(); in++) {
- const char* label = "";
- if (edge->is_implicit(in))
- label = "| ";
- else if (edge->is_order_only(in))
- label = "|| ";
- printf(" %s%s\n", label, edge->inputs_[in]->path().c_str());
- }
- if (!edge->validations_.empty()) {
- printf(" validations:\n");
- for (std::vector<Node*>::iterator validation = edge->validations_.begin();
- validation != edge->validations_.end(); ++validation) {
- printf(" %s\n", (*validation)->path().c_str());
- }
- }
- }
- printf(" outputs:\n");
- for (vector<Edge*>::const_iterator edge = node->out_edges().begin();
- edge != node->out_edges().end(); ++edge) {
- for (vector<Node*>::iterator out = (*edge)->outputs_.begin();
- out != (*edge)->outputs_.end(); ++out) {
- printf(" %s\n", (*out)->path().c_str());
- }
- }
- const std::vector<Edge*> validation_edges = node->validation_out_edges();
- if (!validation_edges.empty()) {
- printf(" validation for:\n");
- for (std::vector<Edge*>::const_iterator edge = validation_edges.begin();
- edge != validation_edges.end(); ++edge) {
- for (vector<Node*>::iterator out = (*edge)->outputs_.begin();
- out != (*edge)->outputs_.end(); ++out) {
- printf(" %s\n", (*out)->path().c_str());
- }
- }
- }
- }
- return 0;
-}
-
-#if defined(NINJA_HAVE_BROWSE)
-int NinjaMain::ToolBrowse(const Options* options, int argc, char* argv[]) {
- RunBrowsePython(&state_, ninja_command_, config_->input_file.c_str(), argc,
- argv);
- // If we get here, the browse failed.
- return 1;
-}
-#else
-int NinjaMain::ToolBrowse(const Options*, int, char**) {
- Fatal("browse tool not supported on this platform");
- return 1;
-}
-#endif
-
-#if defined(_WIN32)
-int NinjaMain::ToolMSVC(const Options* options, int argc, char* argv[]) {
- // Reset getopt: push one argument onto the front of argv, reset optind.
- argc++;
- argv--;
- optind = 0;
- return MSVCHelperMain(argc, argv);
-}
-#endif
-
-int ToolTargetsList(const vector<Node*>& nodes, int depth, int indent) {
- for (vector<Node*>::const_iterator n = nodes.begin();
- n != nodes.end();
- ++n) {
- for (int i = 0; i < indent; ++i)
- printf(" ");
- const char* target = (*n)->path().c_str();
- if ((*n)->in_edge()) {
- printf("%s: %s\n", target, (*n)->in_edge()->rule_->name().c_str());
- if (depth > 1 || depth <= 0)
- ToolTargetsList((*n)->in_edge()->inputs_, depth - 1, indent + 1);
- } else {
- printf("%s\n", target);
- }
- }
- return 0;
-}
-
-int ToolTargetsSourceList(State* state) {
- for (vector<Edge*>::iterator e = state->edges_.begin();
- e != state->edges_.end(); ++e) {
- for (vector<Node*>::iterator inps = (*e)->inputs_.begin();
- inps != (*e)->inputs_.end(); ++inps) {
- if (!(*inps)->in_edge())
- printf("%s\n", (*inps)->path().c_str());
- }
- }
- return 0;
-}
-
-int ToolTargetsList(State* state, const string& rule_name) {
- set<string> rules;
-
- // Gather the outputs.
- for (vector<Edge*>::iterator e = state->edges_.begin();
- e != state->edges_.end(); ++e) {
- if ((*e)->rule_->name() == rule_name) {
- for (vector<Node*>::iterator out_node = (*e)->outputs_.begin();
- out_node != (*e)->outputs_.end(); ++out_node) {
- rules.insert((*out_node)->path());
- }
- }
- }
-
- // Print them.
- for (set<string>::const_iterator i = rules.begin();
- i != rules.end(); ++i) {
- printf("%s\n", (*i).c_str());
- }
-
- return 0;
-}
-
-int ToolTargetsList(State* state) {
- for (vector<Edge*>::iterator e = state->edges_.begin();
- e != state->edges_.end(); ++e) {
- for (vector<Node*>::iterator out_node = (*e)->outputs_.begin();
- out_node != (*e)->outputs_.end(); ++out_node) {
- printf("%s: %s\n",
- (*out_node)->path().c_str(),
- (*e)->rule_->name().c_str());
- }
- }
- return 0;
-}
-
-int NinjaMain::ToolDeps(const Options* options, int argc, char** argv) {
- vector<Node*> nodes;
- if (argc == 0) {
- for (vector<Node*>::const_iterator ni = deps_log_.nodes().begin();
- ni != deps_log_.nodes().end(); ++ni) {
- if (DepsLog::IsDepsEntryLiveFor(*ni))
- nodes.push_back(*ni);
- }
- } else {
- string err;
- if (!CollectTargetsFromArgs(argc, argv, &nodes, &err)) {
- Error("%s", err.c_str());
- return 1;
- }
- }
-
- RealDiskInterface disk_interface;
- for (vector<Node*>::iterator it = nodes.begin(), end = nodes.end();
- it != end; ++it) {
- DepsLog::Deps* deps = deps_log_.GetDeps(*it);
- if (!deps) {
- printf("%s: deps not found\n", (*it)->path().c_str());
- continue;
- }
-
- string err;
- TimeStamp mtime = disk_interface.Stat((*it)->path(), &err);
- if (mtime == -1)
- Error("%s", err.c_str()); // Log and ignore Stat() errors;
- printf("%s: #deps %d, deps mtime %" PRId64 " (%s)\n",
- (*it)->path().c_str(), deps->node_count, deps->mtime,
- (!mtime || mtime > deps->mtime ? "STALE":"VALID"));
- for (int i = 0; i < deps->node_count; ++i)
- printf(" %s\n", deps->nodes[i]->path().c_str());
- printf("\n");
- }
-
- return 0;
-}
-
-int NinjaMain::ToolMissingDeps(const Options* options, int argc, char** argv) {
- vector<Node*> nodes;
- string err;
- if (!CollectTargetsFromArgs(argc, argv, &nodes, &err)) {
- Error("%s", err.c_str());
- return 1;
- }
- RealDiskInterface disk_interface;
- MissingDependencyPrinter printer;
- MissingDependencyScanner scanner(&printer, &deps_log_, &state_,
- &disk_interface);
- for (vector<Node*>::iterator it = nodes.begin(); it != nodes.end(); ++it) {
- scanner.ProcessNode(*it);
- }
- scanner.PrintStats();
- if (scanner.HadMissingDeps())
- return 3;
- return 0;
-}
-
-int NinjaMain::ToolTargets(const Options* options, int argc, char* argv[]) {
- int depth = 1;
- if (argc >= 1) {
- string mode = argv[0];
- if (mode == "rule") {
- string rule;
- if (argc > 1)
- rule = argv[1];
- if (rule.empty())
- return ToolTargetsSourceList(&state_);
- else
- return ToolTargetsList(&state_, rule);
- } else if (mode == "depth") {
- if (argc > 1)
- depth = atoi(argv[1]);
- } else if (mode == "all") {
- return ToolTargetsList(&state_);
- } else {
- const char* suggestion =
- SpellcheckString(mode.c_str(), "rule", "depth", "all", NULL);
- if (suggestion) {
- Error("unknown target tool mode '%s', did you mean '%s'?",
- mode.c_str(), suggestion);
- } else {
- Error("unknown target tool mode '%s'", mode.c_str());
- }
- return 1;
- }
- }
-
- string err;
- vector<Node*> root_nodes = state_.RootNodes(&err);
- if (err.empty()) {
- return ToolTargetsList(root_nodes, depth, 0);
- } else {
- Error("%s", err.c_str());
- return 1;
- }
-}
-
-int NinjaMain::ToolRules(const Options* options, int argc, char* argv[]) {
- // Parse options.
-
- // The rules tool uses getopt, and expects argv[0] to contain the name of
- // the tool, i.e. "rules".
- argc++;
- argv--;
-
- bool print_description = false;
-
- optind = 1;
- int opt;
- while ((opt = getopt(argc, argv, const_cast<char*>("hd"))) != -1) {
- switch (opt) {
- case 'd':
- print_description = true;
- break;
- case 'h':
- default:
- printf("usage: ninja -t rules [options]\n"
- "\n"
- "options:\n"
- " -d also print the description of the rule\n"
- " -h print this message\n"
- );
- return 1;
- }
- }
- argv += optind;
- argc -= optind;
-
- // Print rules
-
- for (const auto& pair : state_.bindings().GetRules()) {
- printf("%s", pair.first.c_str());
- if (print_description) {
- const Rule* rule = pair.second.get();
- const EvalString* description = rule->GetBinding("description");
- if (description != NULL) {
- printf(": %s", description->Unparse().c_str());
- }
- }
- printf("\n");
- fflush(stdout);
- }
- return 0;
-}
-
-#ifdef _WIN32
-int NinjaMain::ToolWinCodePage(const Options* options, int argc, char* argv[]) {
- if (argc != 0) {
- printf("usage: ninja -t wincodepage\n");
- return 1;
- }
- printf("Build file encoding: %s\n", GetACP() == CP_UTF8? "UTF-8" : "ANSI");
- return 0;
-}
-#endif
-
-enum PrintCommandMode { PCM_Single, PCM_All };
-void PrintCommands(Edge* edge, EdgeSet* seen, PrintCommandMode mode) {
- if (!edge)
- return;
- if (!seen->insert(edge).second)
- return;
-
- if (mode == PCM_All) {
- for (vector<Node*>::iterator in = edge->inputs_.begin();
- in != edge->inputs_.end(); ++in)
- PrintCommands((*in)->in_edge(), seen, mode);
- }
-
- if (!edge->is_phony())
- puts(edge->EvaluateCommand().c_str());
-}
-
-int NinjaMain::ToolCommands(const Options* options, int argc, char* argv[]) {
- // The commands tool uses getopt, and expects argv[0] to contain the name of
- // the tool, i.e. "commands".
- ++argc;
- --argv;
-
- PrintCommandMode mode = PCM_All;
-
- optind = 1;
- int opt;
- while ((opt = getopt(argc, argv, const_cast<char*>("hs"))) != -1) {
- switch (opt) {
- case 's':
- mode = PCM_Single;
- break;
- case 'h':
- default:
- printf("usage: ninja -t commands [options] [targets]\n"
-"\n"
-"options:\n"
-" -s only print the final command to build [target], not the whole chain\n"
- );
- return 1;
- }
- }
- argv += optind;
- argc -= optind;
-
- vector<Node*> nodes;
- string err;
- if (!CollectTargetsFromArgs(argc, argv, &nodes, &err)) {
- Error("%s", err.c_str());
- return 1;
- }
-
- EdgeSet seen;
- for (vector<Node*>::iterator in = nodes.begin(); in != nodes.end(); ++in)
- PrintCommands((*in)->in_edge(), &seen, mode);
-
- return 0;
-}
-
-void CollectInputs(Edge* edge, std::set<Edge*>* seen,
- std::vector<std::string>* result) {
- if (!edge)
- return;
- if (!seen->insert(edge).second)
- return;
-
- for (vector<Node*>::iterator in = edge->inputs_.begin();
- in != edge->inputs_.end(); ++in)
- CollectInputs((*in)->in_edge(), seen, result);
-
- if (!edge->is_phony()) {
- edge->CollectInputs(true, result);
- }
-}
-
-int NinjaMain::ToolInputs(const Options* options, int argc, char* argv[]) {
- // The inputs tool uses getopt, and expects argv[0] to contain the name of
- // the tool, i.e. "inputs".
- argc++;
- argv--;
- optind = 1;
- int opt;
- const option kLongOptions[] = { { "help", no_argument, NULL, 'h' },
- { NULL, 0, NULL, 0 } };
- while ((opt = getopt_long(argc, argv, "h", kLongOptions, NULL)) != -1) {
- switch (opt) {
- case 'h':
- default:
- // clang-format off
- printf(
-"Usage '-t inputs [options] [targets]\n"
-"\n"
-"List all inputs used for a set of targets. Note that this includes\n"
-"explicit, implicit and order-only inputs, but not validation ones.\n\n"
-"Options:\n"
-" -h, --help Print this message.\n");
- // clang-format on
- return 1;
- }
- }
- argv += optind;
- argc -= optind;
-
- vector<Node*> nodes;
- string err;
- if (!CollectTargetsFromArgs(argc, argv, &nodes, &err)) {
- Error("%s", err.c_str());
- return 1;
- }
-
- std::set<Edge*> seen;
- std::vector<std::string> result;
- for (vector<Node*>::iterator in = nodes.begin(); in != nodes.end(); ++in)
- CollectInputs((*in)->in_edge(), &seen, &result);
-
- // Make output deterministic by sorting then removing duplicates.
- std::sort(result.begin(), result.end());
- result.erase(std::unique(result.begin(), result.end()), result.end());
-
- for (size_t n = 0; n < result.size(); ++n)
- puts(result[n].c_str());
-
- return 0;
-}
-
-int NinjaMain::ToolClean(const Options* options, int argc, char* argv[]) {
- // The clean tool uses getopt, and expects argv[0] to contain the name of
- // the tool, i.e. "clean".
- argc++;
- argv--;
-
- bool generator = false;
- bool clean_rules = false;
-
- optind = 1;
- int opt;
- while ((opt = getopt(argc, argv, const_cast<char*>("hgr"))) != -1) {
- switch (opt) {
- case 'g':
- generator = true;
- break;
- case 'r':
- clean_rules = true;
- break;
- case 'h':
- default:
- printf("usage: ninja -t clean [options] [targets]\n"
-"\n"
-"options:\n"
-" -g also clean files marked as ninja generator output\n"
-" -r interpret targets as a list of rules to clean instead\n"
- );
- return 1;
- }
- }
- argv += optind;
- argc -= optind;
-
- if (clean_rules && argc == 0) {
- Error("expected a rule to clean");
- return 1;
- }
-
- Cleaner cleaner(&state_, *config_, &disk_interface_);
- if (argc >= 1) {
- if (clean_rules)
- return cleaner.CleanRules(argc, argv);
- else
- return cleaner.CleanTargets(argc, argv);
- } else {
- return cleaner.CleanAll(generator);
- }
-}
-
-int NinjaMain::ToolCleanDead(const Options* options, int argc, char* argv[]) {
- Cleaner cleaner(&state_, *config_, &disk_interface_);
- return cleaner.CleanDead(build_log_.entries());
-}
-
-enum EvaluateCommandMode {
- ECM_NORMAL,
- ECM_EXPAND_RSPFILE
-};
-std::string EvaluateCommandWithRspfile(const Edge* edge,
- const EvaluateCommandMode mode) {
- string command = edge->EvaluateCommand();
- if (mode == ECM_NORMAL)
- return command;
-
- string rspfile = edge->GetUnescapedRspfile();
- if (rspfile.empty())
- return command;
-
- size_t index = command.find(rspfile);
- if (index == 0 || index == string::npos || command[index - 1] != '@')
- return command;
-
- string rspfile_content = edge->GetBinding("rspfile_content");
- size_t newline_index = 0;
- while ((newline_index = rspfile_content.find('\n', newline_index)) !=
- string::npos) {
- rspfile_content.replace(newline_index, 1, 1, ' ');
- ++newline_index;
- }
- command.replace(index - 1, rspfile.length() + 1, rspfile_content);
- return command;
-}
-
-void printCompdb(const char* const directory, const Edge* const edge,
- const EvaluateCommandMode eval_mode) {
- printf("\n {\n \"directory\": \"");
- PrintJSONString(directory);
- printf("\",\n \"command\": \"");
- PrintJSONString(EvaluateCommandWithRspfile(edge, eval_mode));
- printf("\",\n \"file\": \"");
- PrintJSONString(edge->inputs_[0]->path());
- printf("\",\n \"output\": \"");
- PrintJSONString(edge->outputs_[0]->path());
- printf("\"\n }");
-}
-
-int NinjaMain::ToolCompilationDatabase(const Options* options, int argc,
- char* argv[]) {
- // The compdb tool uses getopt, and expects argv[0] to contain the name of
- // the tool, i.e. "compdb".
- argc++;
- argv--;
-
- EvaluateCommandMode eval_mode = ECM_NORMAL;
-
- optind = 1;
- int opt;
- while ((opt = getopt(argc, argv, const_cast<char*>("hx"))) != -1) {
- switch(opt) {
- case 'x':
- eval_mode = ECM_EXPAND_RSPFILE;
- break;
-
- case 'h':
- default:
- printf(
- "usage: ninja -t compdb [options] [rules]\n"
- "\n"
- "options:\n"
- " -x expand @rspfile style response file invocations\n"
- );
- return 1;
- }
- }
- argv += optind;
- argc -= optind;
-
- bool first = true;
- vector<char> cwd;
- char* success = NULL;
-
- do {
- cwd.resize(cwd.size() + 1024);
- errno = 0;
- success = getcwd(&cwd[0], cwd.size());
- } while (!success && errno == ERANGE);
- if (!success) {
- Error("cannot determine working directory: %s", strerror(errno));
- return 1;
- }
-
- putchar('[');
- for (vector<Edge*>::iterator e = state_.edges_.begin();
- e != state_.edges_.end(); ++e) {
- if ((*e)->inputs_.empty())
- continue;
- if (argc == 0) {
- if (!first) {
- putchar(',');
- }
- printCompdb(&cwd[0], *e, eval_mode);
- first = false;
- } else {
- for (int i = 0; i != argc; ++i) {
- if ((*e)->rule_->name() == argv[i]) {
- if (!first) {
- putchar(',');
- }
- printCompdb(&cwd[0], *e, eval_mode);
- first = false;
- }
- }
- }
- }
-
- puts("\n]");
- return 0;
-}
-
-int NinjaMain::ToolRecompact(const Options* options, int argc, char* argv[]) {
- if (!EnsureBuildDirExists())
- return 1;
-
- if (!OpenBuildLog(/*recompact_only=*/true) ||
- !OpenDepsLog(/*recompact_only=*/true))
- return 1;
-
- return 0;
-}
-
-int NinjaMain::ToolRestat(const Options* options, int argc, char* argv[]) {
- // The restat tool uses getopt, and expects argv[0] to contain the name of the
- // tool, i.e. "restat"
- argc++;
- argv--;
-
- optind = 1;
- int opt;
- while ((opt = getopt(argc, argv, const_cast<char*>("h"))) != -1) {
- switch (opt) {
- case 'h':
- default:
- printf("usage: ninja -t restat [outputs]\n");
- return 1;
- }
- }
- argv += optind;
- argc -= optind;
-
- if (!EnsureBuildDirExists())
- return 1;
-
- string log_path = ".ninja_log";
- if (!build_dir_.empty())
- log_path = build_dir_ + "/" + log_path;
-
- string err;
- const LoadStatus status = build_log_.Load(log_path, &err);
- if (status == LOAD_ERROR) {
- Error("loading build log %s: %s", log_path.c_str(), err.c_str());
- return EXIT_FAILURE;
- }
- if (status == LOAD_NOT_FOUND) {
- // Nothing to restat, ignore this
- return EXIT_SUCCESS;
- }
- if (!err.empty()) {
- // Hack: Load() can return a warning via err by returning LOAD_SUCCESS.
- Warning("%s", err.c_str());
- err.clear();
- }
-
- bool success = build_log_.Restat(log_path, disk_interface_, argc, argv, &err);
- if (!success) {
- Error("failed recompaction: %s", err.c_str());
- return EXIT_FAILURE;
- }
-
- if (!config_->dry_run) {
- if (!build_log_.OpenForWrite(log_path, *this, &err)) {
- Error("opening build log: %s", err.c_str());
- return EXIT_FAILURE;
- }
- }
-
- return EXIT_SUCCESS;
-}
-
-int NinjaMain::ToolUrtle(const Options* options, int argc, char** argv) {
- // RLE encoded.
- const char* urtle =
-" 13 ,3;2!2;\n8 ,;<11!;\n5 `'<10!(2`'2!\n11 ,6;, `\\. `\\9 .,c13$ec,.\n6 "
-",2;11!>; `. ,;!2> .e8$2\".2 \"?7$e.\n <:<8!'` 2.3,.2` ,3!' ;,(?7\";2!2'<"
-"; `?6$PF ,;,\n2 `'4!8;<!3'`2 3! ;,`'2`2'3!;4!`2.`!;2 3,2 .<!2'`).\n5 3`5"
-"'2`9 `!2 `4!><3;5! J2$b,`!>;2!:2!`,d?b`!>\n26 `'-;,(<9!> $F3 )3.:!.2 d\""
-"2 ) !>\n30 7`2'<3!- \"=-='5 .2 `2-=\",!>\n25 .ze9$er2 .,cd16$bc.'\n22 .e"
-"14$,26$.\n21 z45$c .\n20 J50$c\n20 14$P\"`?34$b\n20 14$ dbc `2\"?22$?7$c"
-"\n20 ?18$c.6 4\"8?4\" c8$P\n9 .2,.8 \"20$c.3 ._14 J9$\n .2,2c9$bec,.2 `?"
-"21$c.3`4%,3%,3 c8$P\"\n22$c2 2\"?21$bc2,.2` .2,c7$P2\",cb\n23$b bc,.2\"2"
-"?14$2F2\"5?2\",J5$P\" ,zd3$\n24$ ?$3?%3 `2\"2?12$bcucd3$P3\"2 2=7$\n23$P"
-"\" ,3;<5!>2;,. `4\"6?2\"2 ,9;, `\"?2$\n";
- int count = 0;
- for (const char* p = urtle; *p; p++) {
- if ('0' <= *p && *p <= '9') {
- count = count*10 + *p - '0';
- } else {
- for (int i = 0; i < max(count, 1); ++i)
- printf("%c", *p);
- count = 0;
- }
- }
- return 0;
-}
-
-int NinjaMain::ToolServer(const Options* options, int argc, char* argv[]) {
- if (argc == 0 || !strcmp(argv[0], "help")) {
- printf(
- "usage: ninja -t server <command>\n"
- "\n"
- "commands:\n"
- " help print this message\n"
- " status print server status\n"
- " stop stop server\n"
- " pid print server pid, or -1\n");
- return 1;
- }
- std::string work_dir = GetCurrentDir();
- const char* command = argv[0];
- if (!strcmp(command, "status")) {
- PersistentMode::Status status = PersistentMode::GetCurrentProcessStatus();
- if (status == PersistentMode::Disabled)
- printf("persistent mode disabled\n");
- else if (status == PersistentMode::IsClient) {
- bool running = PersistentMode::Client().IsServerRunning(work_dir);
- if (running)
- printf("server is running for %s\n", work_dir.c_str());
- else
- printf("no server found for %s\n", work_dir.c_str());
- } else {
- printf("this is a server process for %s\n", work_dir.c_str());
- }
- return 0;
- }
-
- if (!strcmp(command, "stop")) {
- std::string err;
- bool stopped = PersistentMode::Client().StopServer(work_dir, &err);
- if (stopped)
- printf("server stopped for %s\n", work_dir.c_str());
- else
- printf("no server found for %s\n", work_dir.c_str());
- return 0;
- }
-
- if (!strcmp(command, "pid")) {
- int server_pid = PersistentMode::Client().GetServerPidFor(work_dir);
- printf("%d\n", server_pid);
- return 0;
- }
-
- fprintf(stderr, "Invalid command %s, see `-t server help`.\n", command);
- return 1;
-}
-
-/// Find the function to execute for \a tool_name and return it via \a func.
-/// Returns a Tool, or NULL if Ninja should exit.
-const Tool* ChooseTool(const string& tool_name) {
- static const Tool kTools[] = {
- { "browse", "browse dependency graph in a web browser",
- Tool::RUN_AFTER_LOAD, &NinjaMain::ToolBrowse },
-#ifdef _WIN32
- { "msvc", "build helper for MSVC cl.exe (DEPRECATED)",
- Tool::RUN_AFTER_FLAGS, &NinjaMain::ToolMSVC },
-#endif
- { "clean", "clean built files", Tool::RUN_AFTER_LOAD,
- &NinjaMain::ToolClean },
- { "commands", "list all commands required to rebuild given targets",
- Tool::RUN_AFTER_LOAD, &NinjaMain::ToolCommands },
- { "inputs", "list all inputs required to rebuild given targets",
- Tool::RUN_AFTER_LOAD, &NinjaMain::ToolInputs },
- { "deps", "show dependencies stored in the deps log", Tool::RUN_AFTER_LOGS,
- &NinjaMain::ToolDeps },
- { "missingdeps", "check deps log dependencies on generated files",
- Tool::RUN_AFTER_LOGS, &NinjaMain::ToolMissingDeps },
- { "graph", "output graphviz dot file for targets", Tool::RUN_AFTER_LOAD,
- &NinjaMain::ToolGraph },
- { "query", "show inputs/outputs for a path", Tool::RUN_AFTER_LOGS,
- &NinjaMain::ToolQuery },
- { "targets", "list targets by their rule or depth in the DAG",
- Tool::RUN_AFTER_LOAD, &NinjaMain::ToolTargets },
- { "compdb", "dump JSON compilation database to stdout",
- Tool::RUN_AFTER_LOAD, &NinjaMain::ToolCompilationDatabase },
- { "recompact", "recompacts ninja-internal data structures",
- Tool::RUN_AFTER_LOAD, &NinjaMain::ToolRecompact },
- { "restat", "restats all outputs in the build log", Tool::RUN_AFTER_FLAGS,
- &NinjaMain::ToolRestat },
- { "rules", "list all rules", Tool::RUN_AFTER_LOAD, &NinjaMain::ToolRules },
- { "cleandead",
- "clean built files that are no longer produced by the manifest",
- Tool::RUN_AFTER_LOGS, &NinjaMain::ToolCleanDead },
- { "urtle", NULL, Tool::RUN_AFTER_FLAGS, &NinjaMain::ToolUrtle },
- { "server", "interact with persistent server", Tool::RUN_AFTER_FLAGS,
- &NinjaMain::ToolServer },
-#ifdef _WIN32
- { "wincodepage", "print the Windows code page used by ninja",
- Tool::RUN_AFTER_FLAGS, &NinjaMain::ToolWinCodePage },
-#endif
- { NULL, NULL, Tool::RUN_AFTER_FLAGS, NULL }
- };
-
- if (tool_name == "list") {
- printf("ninja subtools:\n");
- for (const Tool* tool = &kTools[0]; tool->name; ++tool) {
- if (tool->desc)
- printf("%11s %s\n", tool->name, tool->desc);
- }
- return NULL;
- }
-
- for (const Tool* tool = &kTools[0]; tool->name; ++tool) {
- if (tool->name == tool_name)
- return tool;
- }
-
- vector<const char*> words;
- for (const Tool* tool = &kTools[0]; tool->name; ++tool)
- words.push_back(tool->name);
- const char* suggestion = SpellcheckStringV(tool_name, words);
- if (suggestion) {
- Fatal("unknown tool '%s', did you mean '%s'?",
- tool_name.c_str(), suggestion);
- } else {
- Fatal("unknown tool '%s'", tool_name.c_str());
- }
- return NULL; // Not reached.
-}
-
-/// Enable a debugging mode. Returns false if Ninja should exit instead
-/// of continuing.
-bool DebugEnable(const string& name) {
- if (name == "list") {
- printf("debugging modes:\n"
-" stats print operation counts/timing info\n"
-" explain explain what caused a command to execute\n"
-" keepdepfile don't delete depfiles after they're read by ninja\n"
-" keeprsp don't delete @response files on success\n"
-#ifdef _WIN32
-" nostatcache don't batch stat() calls per directory and cache them\n"
-#endif
-"multiple modes can be enabled via -d FOO -d BAR\n");
- return false;
- } else if (name == "stats") {
- g_metrics = new Metrics;
- return true;
- } else if (name == "explain") {
- g_explaining = true;
- return true;
- } else if (name == "keepdepfile") {
- g_keep_depfile = true;
- return true;
- } else if (name == "keeprsp") {
- g_keep_rsp = true;
- return true;
- } else if (name == "nostatcache") {
- g_experimental_statcache = false;
- return true;
- } else {
- const char* suggestion =
- SpellcheckString(name.c_str(),
- "stats", "explain", "keepdepfile", "keeprsp",
- "nostatcache", NULL);
- if (suggestion) {
- Error("unknown debug setting '%s', did you mean '%s'?",
- name.c_str(), suggestion);
- } else {
- Error("unknown debug setting '%s'", name.c_str());
- }
- return false;
- }
-}
-
-/// Set a warning flag. Returns false if Ninja should exit instead of
-/// continuing.
-bool WarningEnable(const string& name, Options* options) {
- if (name == "list") {
- printf("warning flags:\n"
-" phonycycle={err,warn} phony build statement references itself\n"
- );
- return false;
- } else if (name == "dupbuild=err") {
- options->dupe_edges_should_err = true;
- return true;
- } else if (name == "dupbuild=warn") {
- options->dupe_edges_should_err = false;
- return true;
- } else if (name == "phonycycle=err") {
- options->phony_cycle_should_err = true;
- return true;
- } else if (name == "phonycycle=warn") {
- options->phony_cycle_should_err = false;
- return true;
- } else if (name == "depfilemulti=err" ||
- name == "depfilemulti=warn") {
- Warning("deprecated warning 'depfilemulti'");
- return true;
- } else {
- const char* suggestion =
- SpellcheckString(name.c_str(), "dupbuild=err", "dupbuild=warn",
- "phonycycle=err", "phonycycle=warn", NULL);
- if (suggestion) {
- Error("unknown warning flag '%s', did you mean '%s'?",
- name.c_str(), suggestion);
- } else {
- Error("unknown warning flag '%s'", name.c_str());
- }
- return false;
- }
-}
-
-bool NinjaMain::OpenBuildLog(bool recompact_only) {
- string log_path = ".ninja_log";
- if (!build_dir_.empty())
- log_path = build_dir_ + "/" + log_path;
-
- string err;
- const LoadStatus status = build_log_.Load(log_path, &err);
- if (status == LOAD_ERROR) {
- Error("loading build log %s: %s", log_path.c_str(), err.c_str());
- return false;
- }
- if (!err.empty()) {
- // Hack: Load() can return a warning via err by returning LOAD_SUCCESS.
- Warning("%s", err.c_str());
- err.clear();
- }
-
- if (recompact_only) {
- if (status == LOAD_NOT_FOUND) {
- return true;
- }
- bool success = build_log_.Recompact(log_path, *this, &err);
- if (!success)
- Error("failed recompaction: %s", err.c_str());
- return success;
- }
-
- if (!config_->dry_run) {
- if (!build_log_.OpenForWrite(log_path, *this, &err)) {
- Error("opening build log: %s", err.c_str());
- return false;
- }
- }
-
- return true;
-}
-
-/// Open the deps log: load it, then open for writing.
-/// @return false on error.
-bool NinjaMain::OpenDepsLog(bool recompact_only) {
- string path = ".ninja_deps";
- if (!build_dir_.empty())
- path = build_dir_ + "/" + path;
-
- string err;
- const LoadStatus status = deps_log_.Load(path, &state_, &err);
- if (status == LOAD_ERROR) {
- Error("loading deps log %s: %s", path.c_str(), err.c_str());
- return false;
- }
- if (!err.empty()) {
- // Hack: Load() can return a warning via err by returning LOAD_SUCCESS.
- Warning("%s", err.c_str());
- err.clear();
- }
-
- if (recompact_only) {
- if (status == LOAD_NOT_FOUND) {
- return true;
- }
- bool success = deps_log_.Recompact(path, &err);
- if (!success)
- Error("failed recompaction: %s", err.c_str());
- return success;
- }
-
- if (!config_->dry_run) {
- if (!deps_log_.OpenForWrite(path, &err)) {
- Error("opening deps log: %s", err.c_str());
- return false;
- }
- }
-
- return true;
-}
-
-void NinjaMain::DumpMetrics() {
- g_metrics->Report();
-
- printf("\n");
- int count = (int)state_.paths_.size();
- int buckets = (int)state_.paths_.bucket_count();
- printf("path->node hash load %.2f (%d entries / %d buckets)\n",
- count / (double) buckets, count, buckets);
-
- printf("paths: %zu, edges: %zu\n", state_.paths_.size(),
- state_.edges_.size());
- printf("build_log_entries %zu, deps_log_paths %zu\n", build_log_.size(),
- deps_log_.size());
-}
-
-bool NinjaMain::EnsureBuildDirExists() {
- build_dir_ = state_.bindings().LookupVariable("builddir");
- if (!build_dir_.empty() && !config_->dry_run) {
- if (!disk_interface_.MakeDirs(build_dir_ + "/.") && errno != EEXIST) {
- Error("creating build directory %s: %s",
- build_dir_.c_str(), strerror(errno));
- return false;
- }
- }
- return true;
-}
-
-int NinjaMain::RunBeforeBuild(const Options& options, int argc, char** argv) {
- // Fully reset NinjaMain instance on each run. This gets rid of
- // the currently loaded manifest, if there is one, avoiding unexpected
- // errors like:
- //
- // ```
- // [0/1](1) Regenerating ninja files
- // ninja: error: build.ninja:3: duplicate rule 'gn'
- // rule gn
- // ^ near here
- // ```
- Reset();
-
- ManifestParserOptions parser_opts;
- if (options.dupe_edges_should_err) {
- parser_opts.dupe_edge_action_ = kDupeEdgeActionError;
- }
- if (options.phony_cycle_should_err) {
- parser_opts.phony_cycle_action_ = kPhonyCycleActionError;
- }
-
- ManifestParser parser(&state_, &path_recording_disk_interface_, parser_opts);
- std::string err;
- if (!parser.Load(config_->input_file.c_str(), &err)) {
- status_->Error("%s", err.c_str());
- return 1;
- }
-
- if (options.tool && options.tool->when == Tool::RUN_AFTER_LOAD)
- return (this->*options.tool->func)(&options, argc, argv);
-
- if (!EnsureBuildDirExists() || !OpenBuildLog() || !OpenDepsLog())
- return 1;
-
- if (options.tool && options.tool->when == Tool::RUN_AFTER_LOGS)
- return (this->*options.tool->func)(&options, argc, argv);
-
- return kBuildCanProceed;
-}
-
-int NinjaMain::RunBuild(int argc, char** argv) {
- string err;
- vector<Node*> targets;
- if (!CollectTargetsFromArgs(argc, argv, &targets, &err)) {
- status_->Error("%s", err.c_str());
- return 1;
- }
-
- disk_interface_.AllowStatCache(g_experimental_statcache);
-
- Builder builder(&state_, *config_, &build_log_, &deps_log_, &disk_interface_,
- status(), start_time_millis_);
- {
- METRIC_RECORD("dependency scan");
- for (size_t i = 0; i < targets.size(); ++i) {
- if (!builder.AddTarget(targets[i], &err)) {
- if (!err.empty()) {
- status_->Error("%s", err.c_str());
- return 1;
- } else {
- // Added a target that is already up-to-date; not really
- // an error.
- }
- }
- }
-
- if (builder.AlreadyUpToDate()) {
- status_->Info("no work to do.");
- return 0;
- }
- }
-
- if (!builder.Build(&err)) {
- status_->Info("build stopped: %s.", err.c_str());
- if (err.find("interrupted by user") != string::npos) {
- return 2;
- }
- return 1;
- }
-
- return 0;
-}
-
-#ifdef _MSC_VER
-
-/// This handler processes fatal crashes that you can't catch
-/// Test example: C++ exception in a stack-unwind-block
-/// Real-world example: ninja launched a compiler to process a tricky
-/// C++ input file. The compiler got itself into a state where it
-/// generated 3 GB of output and caused ninja to crash.
-void TerminateHandler() {
- CreateWin32MiniDump(NULL);
- Fatal("terminate handler called");
-}
-
-/// On Windows, we want to prevent error dialogs in case of exceptions.
-/// This function handles the exception, and writes a minidump.
-int ExceptionFilter(unsigned int code, struct _EXCEPTION_POINTERS *ep) {
- Error("exception: 0x%X", code); // e.g. EXCEPTION_ACCESS_VIOLATION
- fflush(stderr);
- CreateWin32MiniDump(ep);
- return EXCEPTION_EXECUTE_HANDLER;
-}
-
-#endif // _MSC_VER
-
-class DeferGuessParallelism {
- public:
- bool needGuess;
- BuildConfig* config;
-
- DeferGuessParallelism(BuildConfig* config)
- : needGuess(true), config(config) {}
-
- void Refresh() {
- if (needGuess) {
- needGuess = false;
- config->parallelism = GuessParallelism();
- }
- }
- ~DeferGuessParallelism() { Refresh(); }
-};
-
-/// Parse argv for command-line options.
-/// Returns an exit code, or -1 if Ninja should continue.
-int ReadFlags(int* argc, char*** argv,
- Options* options, BuildConfig* config) {
- DeferGuessParallelism deferGuessParallelism(config);
-
- enum { OPT_VERSION = 1, OPT_QUIET = 2 };
- const option kLongOptions[] = {
- { "help", no_argument, NULL, 'h' },
- { "version", no_argument, NULL, OPT_VERSION },
- { "verbose", no_argument, NULL, 'v' },
- { "quiet", no_argument, NULL, OPT_QUIET },
- { NULL, 0, NULL, 0 }
- };
-
- // First grab values from environment variables.
- config->environment = EnvironmentBlock::CreateFromCurrentEnvironment();
-
- int opt;
- while (!options->tool &&
- (opt = getopt_long(*argc, *argv, "d:f:j:k:l:nt:vw:C:h", kLongOptions,
- NULL)) != -1) {
- switch (opt) {
- case 'd':
- if (!DebugEnable(optarg))
- return 1;
- break;
- case 'f':
- config->input_file = optarg;
- break;
- case 'j': {
- char* end;
- int value = strtol(optarg, &end, 10);
- if (*end != 0 || value < 0)
- Fatal("invalid -j parameter");
-
- // We want to run N jobs in parallel. For N = 0, INT_MAX
- // is close enough to infinite for most sane builds.
- config->parallelism = value > 0 ? value : INT_MAX;
- deferGuessParallelism.needGuess = false;
- break;
- }
- case 'k': {
- char* end;
- int value = strtol(optarg, &end, 10);
- if (*end != 0)
- Fatal("-k parameter not numeric; did you mean -k 0?");
-
- // We want to go until N jobs fail, which means we should allow
- // N failures and then stop. For N <= 0, INT_MAX is close enough
- // to infinite for most sane builds.
- config->failures_allowed = value > 0 ? value : INT_MAX;
- break;
- }
- case 'l': {
- char* end;
- double value = strtod(optarg, &end);
- if (end == optarg)
- Fatal("-l parameter not numeric: did you mean -l 0.0?");
- config->max_load_average = value;
- break;
- }
- case 'n':
- config->dry_run = true;
- break;
- case 't':
- options->tool = ChooseTool(optarg);
- if (!options->tool)
- return 0;
- break;
- case 'v':
- config->verbosity = BuildConfig::VERBOSE;
- break;
- case OPT_QUIET:
- config->verbosity = BuildConfig::NO_STATUS_UPDATE;
- break;
- case 'w':
- if (!WarningEnable(optarg, options))
- return 1;
- break;
- case 'C':
- options->working_dir = optarg;
- break;
- case OPT_VERSION:
- printf("%s\n", kNinjaVersion);
- return 0;
- case 'h':
- default:
- deferGuessParallelism.Refresh();
- Usage(*config);
- return 1;
- }
- }
- *argv += optind;
- *argc -= optind;
-
- return -1;
-}
-
-NORETURN void real_main(int argc, char** argv) {
- // Use exit() instead of return in this function to avoid potentially
- // expensive cleanup when destructing NinjaMain.
- BuildConfig config;
- Options options;
-
- // Save original arguments and current directory for persistent mode since
- // ReadFlags() will modify them.
- const auto original_args = RemoteArguments(argc, argv).args();
-
- setvbuf(stdout, NULL, _IOLBF, BUFSIZ);
- const char* ninja_command = argv[0];
-
- int exit_code = ReadFlags(&argc, &argv, &options, &config);
- if (exit_code >= 0)
- exit(exit_code);
-
- // Always enable metrics when in persistent server mode,
- // since the METRIC_RECORD macro probes the value of g_metrics
- // once per execution, it must be initialized before any
- // use of that macro to ensure everything works correctly.
- PersistentMode::Status persistence =
- PersistentMode::GetCurrentProcessStatus();
-
- bool dump_metrics = !!g_metrics;
- if (persistence == PersistentMode::IsServer && !g_metrics)
- g_metrics = new Metrics();
-
- NinjaMain ninja(ninja_command, config);
-
- if (options.working_dir) {
- // The formatting of this string, complete with funny quotes, is
- // so Emacs can properly identify that the cwd has changed for
- // subsequent commands.
- // Don't print this if a tool is being used, so that tool output
- // can be piped into a file without this string showing up.
- if (!options.tool && config.verbosity != BuildConfig::NO_STATUS_UPDATE)
- ninja.status()->Info("Entering directory `%s'", options.working_dir);
- if (chdir(options.working_dir) < 0) {
- Fatal("chdir to '%s' - %s", options.working_dir, strerror(errno));
- }
- }
-
- if (options.tool && options.tool->when == Tool::RUN_AFTER_FLAGS) {
- // None of the RUN_AFTER_FLAGS actually use a NinjaMain, but it's needed
- // by other tools.
- exit((ninja.*options.tool->func)(&options, argc, argv));
- }
-
- // A callable object that runs all operations prior to the build itself,
- // which includes regenerating the build plan files if needed, loading the
- // build graph, and answering tool requests.
- //
- // It returns an exit status code if no more work is needed, or the
- // special value kBuildCanProceed to indicate that the build can proceed
- // afterwards.
- auto run_before_build = [&]() -> int {
- // Limit number of rebuilds, to prevent infinite loops.
- const int kCycleLimit = 100;
- for (int cycle = 1; cycle <= kCycleLimit; ++cycle) {
- int result = ninja.RunBeforeBuild(options, argc, argv);
- if (result != kBuildCanProceed)
- _exit(result);
-
- // Attempt to rebuild the manifest before building anything else
- std::string err;
- if (ninja.RebuildManifest(&err)) {
- // In dry_run mode the regeneration will succeed without changing the
- // manifest forever. Better to return immediately.
- if (config.dry_run)
- return 0;
- // Start the build over with the new manifest.
- continue;
- } else if (!err.empty()) {
- ninja.status()->Error("rebuilding '%s': %s",
- ninja.config_->input_file.c_str(), err.c_str());
- return 1;
- }
-
- return kBuildCanProceed;
- }
- ninja.status()->Error(
- "manifest '%s' still dirty after %d tries, perhaps system time is not "
- "set",
- ninja.config_->input_file.c_str(), kCycleLimit);
- return 1;
- };
-
- PersistentMode::BuildQuery build_query;
- build_query.config = config;
- build_query.debug_explaining = g_explaining;
- build_query.debug_keep_depfile = g_keep_depfile;
- build_query.debug_keep_rsp = g_keep_rsp;
- build_query.debug_experimental_statcache = g_experimental_statcache;
- build_query.dump_metrics = dump_metrics;
-
- if (options.tool)
- build_query.tool = options.tool->name;
-
- for (int n = 0; n < argc; ++n) {
- build_query.args.push_back(argv[n]);
- }
-
- // NOTE: For now, do not run tools in persistent client/server mode.
- bool use_persistent_mode =
- !options.tool && (persistence != PersistentMode::Disabled);
-
- // Note: since the working dir has already been changed here, do not
- // use options.working_dir, which is no longer valid if it is a relative
- // path. Compatibility will use the current working directory as the
- // build dir by default.
- PersistentMode::Compatibility compatibility;
- compatibility.SetInputFile(config.input_file);
- compatibility.SetFlagDupeEdgesShouldErr(options.dupe_edges_should_err);
- compatibility.SetFlagPhonyCycleShouldErr(options.phony_cycle_should_err);
-
- if (use_persistent_mode) {
- if (persistence == PersistentMode::IsServer) {
- // Persistent server mode. Load the build graph and all other expensive
- // things first. Exit immediately if there is a problem.
- PersistentMode::Server server(compatibility);
-
- std::string err;
- if (!server.StartLocalServer(&err)) {
- printf("Could not start local server, aborting: %s\n", err.c_str());
- exit(1);
- }
-
- printf(
- "\n***********************************************\n"
- "Server starting, loading build graph...\n");
- int result = ninja.RunBeforeBuild(options, argc, argv);
- if (result != kBuildCanProceed)
- exit(result);
-
- // Print load metrics
- printf("Manifest loading metrics\n");
- g_metrics->load_.Report();
-
- printf(
- "%zu nodes, %zu edges, %zu pools\n%zu build log entries, %zu deps "
- "log paths\n",
- ninja.state_.paths_.size(), ninja.state_.edges_.size(),
- ninja.state_.pools_.size(), ninja.build_log_.size(),
- ninja.deps_log_.size());
-
- // This callable returns true if the manifest(s) changed since the
- // last call. Which will force a server restart.
- auto restart_check = [&]() -> bool {
- // A fast check that returns true if any input .ninja file was
- // modified. Happens when the generator was called by the user
- // before Ninja.
- return ninja.path_recording_disk_interface_.CheckOutOfDate();
- };
-
- // This callable runs the part of the build and returns an exit status.
- // or the special value PersistentMode::kServerExit to indicate that
- // the server should exit.
- auto do_build = [&](const PersistentMode::BuildQuery& query) -> int {
- if (query.dump_metrics) {
- // Do not reset the load metrics here, only the build ones.
- g_metrics->build_.Reset();
- }
-
- ninja.PrepareBuild(query.config);
-
- if (!query.tool.empty()) {
- // Note that tools are always run on the client process because they
- // disable persistent mode support (see below). This currently happens
- // in the run_before_build lambda above.
- // TODO(digit): Implement tool in the server if it makes sense.
- fprintf(stderr,
- "UNIMPLEMENTED FEATURE: RUNNING TOOLS IN PERSISTENT MODE!\n");
- return 1;
- }
-
- std::string err;
- if (ninja.RebuildManifest(&err)) {
- // In dry_run mode the regeneration will succeed without changing the
- // manifest forever. Better to return with 0.
- if (query.config.dry_run)
- return 0;
- // The manifest has been regenerated, so the build graph in this
- // server is no longer valid. Tell it to exit so that the next
- // client invocation will start a new instance that will read
- // the new manifest.
- return PersistentMode::kServerExit;
- }
-
- RemoteArguments targets;
- targets.Reset(query.args);
-
- int result = ninja.RunBuild(targets.argc(), targets.argv());
-
- if (query.dump_metrics)
- ninja.DumpMetrics();
-
- return result;
- };
-
- printf("Server mode waiting for client requests\n");
-
- // Now serve client requests in a loop with |do_build| as the request
- // handler. This exits the process on completion.
- server.RunServerThenExit(restart_check, do_build);
- ninja.status()->Error("Server could not run or exit properly!\n");
- exit(1);
- } else {
- assert(persistence == PersistentMode::IsClient);
- }
- }
-
- // For regular and persistent client builds.
- // Limit number of rebuilds, to prevent infinite loops.
- const int kCycleLimit = 100;
- for (int cycle = 1; cycle <= kCycleLimit; ++cycle) {
- std::string err;
-
- //////////////////////////////////////////////////////////
- // Persistent client build.
-
- if (use_persistent_mode) {
- assert(persistence == PersistentMode::IsClient);
- PersistentMode::Client client;
- int result = 0;
- if (!client.RunQuery(compatibility, build_query, &result, &err)) {
- ninja.status()->Error(
- "Error contacting server, falling back to local build: %s\n",
- err.c_str());
- // Try again with a regular build.
- persistence = PersistentMode::Disabled;
- continue;
- }
-
- if (result != PersistentMode::kServerExit) {
- // Normal termination, exit with status code from server.
- _exit(result);
- }
- // The server exited after rebuilding the manifest, loop to
- // create a new server instance that loads the new manifest
- // then build with it.
- continue;
- }
-
- //////////////////////////////////////////////////////////
- // Normal (Non-persistent) builds.
-
- int result = ninja.RunBeforeBuild(options, argc, argv);
- if (result != kBuildCanProceed)
- _exit(result);
-
- // Attempt to rebuild the manifest before building anything else
- if (ninja.RebuildManifest(&err)) {
- // In dry_run mode the regeneration will succeed without changing the
- // manifest forever. Better to return immediately.
- if (config.dry_run)
- _exit(0);
- // Start the build over with the new manifest.
- continue;
- } else if (!err.empty()) {
- ninja.status()->Error("rebuilding '%s': %s", config.input_file.c_str(),
- err.c_str());
- exit(1);
- }
-
- result = ninja.RunBuild(argc, argv);
- if (g_metrics)
- ninja.DumpMetrics();
- _exit(result);
- }
-
- ninja.status()->Error(
- "manifest '%s' still dirty after %d tries, perhaps system time is not "
- "set",
- config.input_file.c_str(), kCycleLimit);
- exit(1);
-}
-
-} // anonymous namespace
-
-int main(int argc, char** argv) {
-#if defined(_MSC_VER)
- // Set a handler to catch crashes not caught by the __try..__except
- // block (e.g. an exception in a stack-unwind-block).
- std::set_terminate(TerminateHandler);
- __try {
- // Running inside __try ... __except suppresses any Windows error
- // dialogs for errors such as bad_alloc.
- real_main(argc, argv);
- }
- __except(ExceptionFilter(GetExceptionCode(), GetExceptionInformation())) {
- // Common error situations return exitCode=1. 2 was chosen to
- // indicate a more serious problem.
- return 2;
- }
-#else
- real_main(argc, argv);
-#endif
-}
diff --git a/src/ninja_test.cc b/src/ninja_test.cc
deleted file mode 100644
index 44ae03a..0000000
--- a/src/ninja_test.cc
+++ /dev/null
@@ -1,179 +0,0 @@
-// Copyright 2013 Google Inc. All Rights Reserved.
-//
-// Licensed under the Apache License, Version 2.0 (the "License");
-// you may not use this file except in compliance with the License.
-// You may obtain a copy of the License at
-//
-// http://www.apache.org/licenses/LICENSE-2.0
-//
-// Unless required by applicable law or agreed to in writing, software
-// distributed under the License is distributed on an "AS IS" BASIS,
-// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-// See the License for the specific language governing permissions and
-// limitations under the License.
-
-#include <stdarg.h>
-#include <stdio.h>
-#include <stdlib.h>
-
-#ifdef _WIN32
-#include "getopt.h"
-#elif defined(_AIX)
-#include "getopt.h"
-#include <unistd.h>
-#else
-#include <getopt.h>
-#endif
-
-#include "test.h"
-#include "line_printer.h"
-
-using namespace std;
-
-struct RegisteredTest {
- testing::Test* (*factory)();
- const char *name;
- bool should_run;
-};
-// This can't be a vector because tests call RegisterTest from static
-// initializers and the order static initializers run it isn't specified. So
-// the vector constructor isn't guaranteed to run before all of the
-// RegisterTest() calls.
-static RegisteredTest tests[10000];
-testing::Test* g_current_test;
-static int ntests;
-static LinePrinter printer;
-
-void RegisterTest(testing::Test* (*factory)(), const char* name) {
- tests[ntests].factory = factory;
- tests[ntests++].name = name;
-}
-
-namespace {
-string StringPrintf(const char* format, ...) {
- const int N = 1024;
- char buf[N];
-
- va_list ap;
- va_start(ap, format);
- vsnprintf(buf, N, format, ap);
- va_end(ap);
-
- return buf;
-}
-
-void Usage() {
- fprintf(stderr,
-"usage: ninja_tests [options]\n"
-"\n"
-"options:\n"
-" --gtest_filter=POSITIVE_PATTERN[-NEGATIVE_PATTERN]\n"
-" Run tests whose names match the positive but not the negative pattern.\n"
-" '*' matches any substring. (gtest's ':', '?' are not implemented).\n");
-}
-
-bool PatternMatchesString(const char* pattern, const char* str) {
- switch (*pattern) {
- case '\0':
- case '-': return *str == '\0';
- case '*': return (*str != '\0' && PatternMatchesString(pattern, str + 1)) ||
- PatternMatchesString(pattern + 1, str);
- default: return *pattern == *str &&
- PatternMatchesString(pattern + 1, str + 1);
- }
-}
-
-bool TestMatchesFilter(const char* test, const char* filter) {
- // Split --gtest_filter at '-' into positive and negative filters.
- const char* const dash = strchr(filter, '-');
- const char* pos = dash == filter ? "*" : filter; //Treat '-test1' as '*-test1'
- const char* neg = dash ? dash + 1 : "";
- return PatternMatchesString(pos, test) && !PatternMatchesString(neg, test);
-}
-
-bool ReadFlags(int* argc, char*** argv, const char** test_filter) {
- enum { OPT_GTEST_FILTER = 1 };
- const option kLongOptions[] = {
- { "gtest_filter", required_argument, NULL, OPT_GTEST_FILTER },
- { NULL, 0, NULL, 0 }
- };
-
- int opt;
- while ((opt = getopt_long(*argc, *argv, "h", kLongOptions, NULL)) != -1) {
- switch (opt) {
- case OPT_GTEST_FILTER:
- if (strchr(optarg, '?') == NULL && strchr(optarg, ':') == NULL) {
- *test_filter = optarg;
- break;
- } // else fall through.
- default:
- Usage();
- return false;
- }
- }
- *argv += optind;
- *argc -= optind;
- return true;
-}
-
-} // namespace
-
-bool testing::Test::NullFailure(bool null_expected, const char* file, int line,
- const char* error, const char* value) {
- printer.PrintOnNewLine(StringPrintf(
- "*** Failure in %s:%d\n%s\nExpected: %s\nActual: %s\n", file, line,
- error, null_expected ? "nullptr" : "not nullptr", value));
- failed_ = true;
- return false;
-}
-
-bool testing::Test::BooleanFailure(bool expected, const char* file, int line,
- const char* error, const char* value) {
- printer.PrintOnNewLine(
- StringPrintf("*** Failure in %s:%d\n%s\nExpected: %s\nActual: %s\n",
- file, line, error, expected ? "true" : "false", value));
- failed_ = true;
- return false;
-}
-
-bool testing::Test::BinopFailure(const char* file, int line,
- const char* error, const char* first_value,
- const char* second_value) {
- printer.PrintOnNewLine(
- StringPrintf("*** Failure in %s:%d\n%s\nLeft: %s\nRight: %s\n", file, line, error, first_value, second_value));
- failed_ = true;
- return false;
-}
-
-int main(int argc, char **argv) {
- int tests_started = 0;
-
- const char* test_filter = "*";
- if (!ReadFlags(&argc, &argv, &test_filter))
- return 1;
-
- int nactivetests = 0;
- for (int i = 0; i < ntests; i++)
- if ((tests[i].should_run = TestMatchesFilter(tests[i].name, test_filter)))
- ++nactivetests;
-
- bool passed = true;
- for (int i = 0; i < ntests; i++) {
- if (!tests[i].should_run) continue;
-
- ++tests_started;
- testing::Test* test = tests[i].factory();
- printer.Print(
- StringPrintf("[%d/%d] %s", tests_started, nactivetests, tests[i].name),
- LinePrinter::ELIDE);
- test->SetUp();
- test->Run();
- test->TearDown();
- if (test->Failed())
- passed = false;
- delete test;
- }
-
- printer.PrintOnNewLine(passed ? "passed\n" : "failed\n");
- return passed ? EXIT_SUCCESS : EXIT_FAILURE;
-}
diff --git a/src/parser.cc b/src/parser.cc
deleted file mode 100644
index 96c90f3..0000000
--- a/src/parser.cc
+++ /dev/null
@@ -1,49 +0,0 @@
-// Copyright 2018 Google Inc. All Rights Reserved.
-//
-// Licensed under the Apache License, Version 2.0 (the "License");
-// you may not use this file except in compliance with the License.
-// You may obtain a copy of the License at
-//
-// http://www.apache.org/licenses/LICENSE-2.0
-//
-// Unless required by applicable law or agreed to in writing, software
-// distributed under the License is distributed on an "AS IS" BASIS,
-// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-// See the License for the specific language governing permissions and
-// limitations under the License.
-
-#include "parser.h"
-
-#include "disk_interface.h"
-#include "metrics.h"
-
-using namespace std;
-
-bool Parser::Load(const string& filename, string* err, Lexer* parent) {
- // If |parent| is not NULL, metrics collection has been started by a parent
- // Parser::Load() in our call stack. Do not start a new one here to avoid
- // over-counting parsing times.
- METRIC_RECORD_LOAD_IF(".ninja parse", parent == NULL);
- string contents;
- string read_err;
- if (file_reader_->ReadFile(filename, &contents, &read_err) !=
- FileReader::Okay) {
- *err = "loading '" + filename + "': " + read_err;
- if (parent)
- parent->Error(string(*err), err);
- return false;
- }
-
- return Parse(filename, contents, err);
-}
-
-bool Parser::ExpectToken(Lexer::Token expected, string* err) {
- Lexer::Token token = lexer_.ReadToken();
- if (token != expected) {
- string message = string("expected ") + Lexer::TokenName(expected);
- message += string(", got ") + Lexer::TokenName(token);
- message += Lexer::TokenErrorHint(expected);
- return lexer_.Error(message, err);
- }
- return true;
-}
diff --git a/src/parser.h b/src/parser.h
deleted file mode 100644
index 011fad8..0000000
--- a/src/parser.h
+++ /dev/null
@@ -1,48 +0,0 @@
-// Copyright 2018 Google Inc. All Rights Reserved.
-//
-// Licensed under the Apache License, Version 2.0 (the "License");
-// you may not use this file except in compliance with the License.
-// You may obtain a copy of the License at
-//
-// http://www.apache.org/licenses/LICENSE-2.0
-//
-// Unless required by applicable law or agreed to in writing, software
-// distributed under the License is distributed on an "AS IS" BASIS,
-// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-// See the License for the specific language governing permissions and
-// limitations under the License.
-
-#ifndef NINJA_PARSER_H_
-#define NINJA_PARSER_H_
-
-#include <string>
-
-#include "lexer.h"
-
-struct FileReader;
-struct State;
-
-/// Base class for parsers.
-struct Parser {
- Parser(State* state, FileReader* file_reader)
- : state_(state), file_reader_(file_reader) {}
-
- /// Load and parse a file.
- bool Load(const std::string& filename, std::string* err, Lexer* parent = NULL);
-
-protected:
- /// If the next token is not \a expected, produce an error string
- /// saying "expected foo, got bar".
- bool ExpectToken(Lexer::Token expected, std::string* err);
-
- State* state_;
- FileReader* file_reader_;
- Lexer lexer_;
-
-private:
- /// Parse a file, given its contents as a string.
- virtual bool Parse(const std::string& filename, const std::string& input,
- std::string* err) = 0;
-};
-
-#endif // NINJA_PARSER_H_
diff --git a/src/persistent_mode.cc b/src/persistent_mode.cc
deleted file mode 100644
index 16ef3bc..0000000
--- a/src/persistent_mode.cc
+++ /dev/null
@@ -1,593 +0,0 @@
-// Copyright 2023 Google Inc. All Rights Reserved.
-//
-// Licensed under the Apache License, Version 2.0 (the "License");
-// you may not use this file except in compliance with the License.
-// You may obtain a copy of the License at
-//
-// http://www.apache.org/licenses/LICENSE-2.0
-//
-// Unless required by applicable law or agreed to in writing, software
-// distributed under the License is distributed on an "AS IS" BASIS,
-// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-// See the License for the specific language governing permissions and
-// limitations under the License.
-
-#include "persistent_mode.h"
-
-#include <assert.h>
-#include <inttypes.h>
-#include <string.h>
-
-#include "debug_flags.h"
-#include "interrupt_handling.h"
-#include "ipc_handle.h"
-#include "ipc_utils.h"
-#include "metrics.h"
-#include "process_utils.h"
-#include "stdio_redirection.h"
-#include "util.h"
-#include "version.h"
-#ifndef _WIN32
-#include <sys/stat.h>
-#include <unistd.h>
-#endif
-
-#define DEBUG 0
-
-#define SERVER_LOG(...) \
- do { \
- fprintf(stderr, "NINJA_SERVER_LOG: "); \
- fprintf(stderr, __VA_ARGS__); \
- fprintf(stderr, "\n"); \
- } while (0)
-
-#if DEBUG
-#define CLIENT_LOG(...) \
- do { \
- fprintf(stderr, "NINJA_CLIENT_LOG: "); \
- fprintf(stderr, __VA_ARGS__); \
- fprintf(stderr, "\n"); \
- } while (0)
-#else
-#define CLIENT_LOG(...) (void)0
-#endif
-
-namespace {
-
-// Print error message, then return false
-bool PrintError(const char* fmt, ...) {
- va_list args;
- va_start(args, fmt);
- fputs("ERROR: ", stderr);
- vfprintf(stderr, fmt, args);
- fputc('\n', stderr);
- va_end(args);
- return false;
-}
-
-extern "C" char** environ;
-
-// Return the name of the IPC service for a given current build
-// directory. This allows several servers to co-exist on the same
-// machine, if they are invoked / used from different build
-// directories.
-std::string GetServiceName(const std::string& build_dir) {
- std::string real_dir = build_dir.empty() ? GetCurrentDir() : build_dir;
- return StringFormat("ninja-server-%08zx", std::hash<std::string>()(real_dir));
-}
-
-// Name of the environment variable used to control the feature at runtime.
-const char kPersistentModeEnv[] = "NINJA_PERSISTENT_MODE";
-
-// Name of the environment variable used to control the server timeout.
-const char kPersistentTimeoutSecondsEnv[] = "NINJA_PERSISTENT_TIMEOUT_SECONDS";
-
-} // namespace
-
-////////////////////////////////////////////////////////////////////////
-////////////////////////////////////////////////////////////////////////
-/////
-///// C O M P A T I B I L I T Y
-/////
-/////
-
-PersistentMode::Compatibility::Compatibility()
- : ninja_version_(GetDefaultNinjaVersion()), build_dir_(GetCurrentDir()),
- input_file_("build.ninja") {}
-
-PersistentMode::Compatibility& PersistentMode::Compatibility::SetInputFile(
- const std::string& input_file) {
- input_file_ = input_file;
- return *this;
-}
-
-// static
-std::string PersistentMode::Compatibility::GetDefaultNinjaVersion() {
- // Ignore the error returned by GetFileTimestamp() since the executable
- // is known to exist.
- std::string err;
- return StringFormat("%s-%" PRId64, kNinjaVersion,
- ::GetFileTimestamp(GetCurrentExecutable(), &err));
-}
-
-PersistentMode::Compatibility&
-PersistentMode::Compatibility::SetNinjaVersionForTest(
- const std::string& ninja_version) {
- ninja_version_ = ninja_version;
- return *this;
-}
-
-PersistentMode::Compatibility& PersistentMode::Compatibility::SetBuildDir(
- const std::string& build_dir) {
- build_dir_ = build_dir;
- return *this;
-}
-
-PersistentMode::Compatibility&
-PersistentMode::Compatibility::SetFlagDupeEdgesShouldErr(bool enabled) {
- dupe_edges_should_err_ = enabled;
- return *this;
-}
-
-PersistentMode::Compatibility&
-PersistentMode::Compatibility::SetFlagPhonyCycleShouldErr(bool enabled) {
- phony_cycle_should_err_ = enabled;
- return *this;
-}
-
-bool PersistentMode::Compatibility::CheckBuildDir(std::string* err) const {
- if (build_dir_.empty())
- return true;
-
- if (build_dir_[0] != '/' && build_dir_[0] != '\\') {
- *err = StringFormat("build directory path is not absolute: %s",
- build_dir_.c_str());
- return false;
- }
-
- // TODO(digit): What about Win32 drive letters?
- return true;
-}
-
-// static
-PersistentMode::Compatibility PersistentMode::Compatibility::FromEncodedString(
- const std::string& str, std::string* error) {
- error->clear();
- WireDecoder decoder(str);
- Compatibility result = {};
- decoder.Read(result.ninja_version_);
- decoder.Read(result.build_dir_);
- decoder.Read(result.input_file_);
- decoder.Read(result.dupe_edges_should_err_);
- decoder.Read(result.phony_cycle_should_err_);
-
- if (decoder.has_error()) {
- *error = "Truncated PersistentMode::Compatibility encoded string";
- result = {};
- }
- return result;
-}
-
-std::string PersistentMode::Compatibility::ToEncodedString() const {
- WireEncoder encoder;
- encoder.Write(ninja_version_);
- encoder.Write(build_dir_);
- encoder.Write(input_file_);
- encoder.Write(dupe_edges_should_err_);
- encoder.Write(phony_cycle_should_err_);
- return encoder.TakeResult();
-}
-
-std::string PersistentMode::Compatibility::ToString() const {
- return StringFormat(
- "build_dir=%s input_file=%s dupe_edges_should_err=%s "
- "phony_cycle_shoud_err=%s ninja_version=%s",
- build_dir_.c_str(), input_file_.c_str(),
- dupe_edges_should_err_ ? "true" : "false",
- phony_cycle_should_err_ ? "true" : "false", ninja_version_.c_str());
-}
-
-bool PersistentMode::Compatibility::IsCompatibleWith(
- const PersistentMode::Compatibility& other, std::string* reason) const {
- if (ninja_version_ != other.ninja_version_) {
- *reason =
- StringFormat("Ninja version mismatch, expected [%s] vs [%s]",
- ninja_version_.c_str(), other.ninja_version_.c_str());
- return false;
- }
- if (build_dir_ != other.build_dir_) {
- *reason = StringFormat("Working dir mismatch, expected [%s] vs [%s]",
- build_dir_.c_str(), other.build_dir_.c_str());
- return false;
- }
- if (input_file_ != other.input_file_) {
- *reason = StringFormat("Input file mismatch, expected [%s] vs [%s]",
- input_file_.c_str(), other.input_file_.c_str());
- return false;
- }
- if (dupe_edges_should_err_ != other.dupe_edges_should_err_) {
- *reason =
- StringFormat("Flag dupe_edges_should_err mismatch, expected %s vs %s",
- dupe_edges_should_err_ ? "true" : "false",
- other.dupe_edges_should_err_ ? "true" : "false");
- return false;
- }
- if (phony_cycle_should_err_ != other.phony_cycle_should_err_) {
- *reason =
- StringFormat("Flag phony_cycle_should_err mismatch, expected %s vs %s",
- phony_cycle_should_err_ ? "true" : "false",
- other.phony_cycle_should_err_ ? "true" : "false");
- return false;
- }
- return true;
-}
-
-std::vector<std::string> PersistentMode::Compatibility::ToServerArgs(
- const std::string& server_executable) const {
- std::vector<std::string> result;
- result.push_back(server_executable);
- result.push_back("-C");
- result.push_back(build_dir_);
-
- if (input_file_ != "build.ninja") {
- result.push_back("-f");
- result.push_back(input_file_);
- }
- if (dupe_edges_should_err_) {
- result.push_back("-wdupbuild=err");
- } else {
- result.push_back("-wdupbuild=warn");
- }
- if (phony_cycle_should_err_) {
- result.push_back("-wphonycycle=err");
- } else {
- result.push_back("-wphonycycle=warn");
- }
- return result;
-}
-
-////////////////////////////////////////////////////////////////////////
-////////////////////////////////////////////////////////////////////////
-/////
-///// B U I L D Q U E R Y
-/////
-/////
-
-// static
-PersistentMode::BuildQuery PersistentMode::BuildQuery::FromEncodedString(
- const std::string& str, std::string* error) {
- BuildQuery result;
- std::string encoded;
- WireDecoder decoder(str);
-
- // Read BuildConfig.
- decoder.Read(encoded);
- result.config = BuildConfig::FromEncodedString(encoded, error);
- if (!error->empty())
- return {};
-
- decoder.Read(result.debug_explaining);
- decoder.Read(result.debug_keep_depfile);
- decoder.Read(result.debug_keep_rsp);
- decoder.Read(result.debug_experimental_statcache);
- decoder.Read(result.dump_metrics);
- decoder.Read(result.tool);
- size_t num_args = 0;
- decoder.Read(num_args);
- result.args.resize(num_args);
- for (size_t n = 0; n < num_args; ++n)
- decoder.Read(result.args[n]);
-
- if (decoder.has_error()) {
- *error = "Truncated BuildQuery encoded string";
- result = {};
- }
-
- return result;
-}
-
-std::string PersistentMode::BuildQuery::ToEncodedString() const {
- WireEncoder encoder;
- encoder.Write(config.ToEncodedString());
- encoder.Write(debug_explaining);
- encoder.Write(debug_keep_depfile);
- encoder.Write(debug_keep_rsp);
- encoder.Write(debug_experimental_statcache);
- encoder.Write(dump_metrics);
- encoder.Write(tool);
- encoder.Write(args.size());
- for (const auto& arg : args)
- encoder.Write(arg);
-
- return encoder.TakeResult();
-}
-
-std::string PersistentMode::BuildQuery::ToString() const {
- std::string result = config.ToString();
- StringAppendFormat(result,
- " explain=%s keep_depfile=%s keep_rsp=%s "
- "experimental_statcache=%s dump_metrics=%s",
- debug_explaining ? "true" : "false",
- debug_keep_depfile ? "true" : "false",
- debug_keep_rsp ? "true" : "false",
- debug_experimental_statcache ? "true" : "false",
- dump_metrics ? "true" : "false");
-
- if (!tool.empty())
- StringAppendFormat(result, " tool=%s", tool.c_str());
-
- for (const auto& arg : args) {
- result += " ";
- result += arg;
- }
- return result;
-}
-
-void PersistentMode::BuildQuery::WriteGlobalVariables() const {
- g_explaining = debug_explaining;
- g_keep_depfile = debug_keep_depfile;
- g_keep_rsp = debug_keep_rsp;
- g_experimental_statcache = debug_experimental_statcache;
-}
-
-////////////////////////////////////////////////////////////////////////
-////////////////////////////////////////////////////////////////////////
-/////
-///// P E R S I S T E N T M O D E
-/////
-/////
-
-// static
-PersistentMode::Status PersistentMode::GetCurrentProcessStatus() {
- const char* env = getenv(kPersistentModeEnv);
- std::string mode(env ? env : "0");
- if (mode == "0" || mode == "off")
- return PersistentMode::Disabled;
-
- if (mode == "1" || mode == "on" || mode == "client")
- return PersistentMode::IsClient;
-
- if (mode == "server") // Used internally when spawning the server.
- return PersistentMode::IsServer;
-
- fprintf(stderr,
- "WARNING: Unknown %s value '%s', must be one of: 0, 1, on, off, "
- "client, server\n",
- kPersistentModeEnv, mode.c_str());
- return PersistentMode::Disabled;
-}
-
-PersistentMode::Client::Client() : server_executable_(GetCurrentExecutable()) {}
-
-void PersistentMode::Client::SetServerExecutable(
- const std::string& server_executable) {
- server_executable_ = server_executable;
-}
-
-// static
-PersistentService::Client PersistentMode::Client::GetService(
- const std::string& build_dir) {
- CLIENT_LOG("GetService(%s)", build_dir.c_str());
- return PersistentService::Client(GetServiceName(build_dir));
-}
-
-bool PersistentMode::Client::IsServerRunning(const std::string& build_dir) {
- return GetService(build_dir).HasServer();
-}
-
-int PersistentMode::Client::GetServerPidFor(const std::string& build_dir) {
- return GetService(build_dir).GetServerPid();
-}
-
-bool PersistentMode::Client::StopServer(const std::string& build_dir,
- std::string* err) {
- return GetService(build_dir).StopServer(err);
-}
-
-bool PersistentMode::Client::RunQuery(const Compatibility& compatibility,
- const BuildQuery& query,
- int* exit_code_ptr, std::string* error) {
- // Return an error early if the build directory is not valid.
- if (!compatibility.CheckBuildDir(error))
- return false;
-
- // Ensure the persistent mode status is set to 'server' in spawned servers.
- PersistentService::Config server_config =
- PersistentService::Config(compatibility.ToServerArgs(server_executable_))
- .SetWorkingDir(compatibility.build_dir())
- .SetVersionInfo(compatibility.ToEncodedString())
- .AddEnvVariable(kPersistentModeEnv, "server");
- // Set log file path from env. This is a debugging aid.
- {
- const char* env = getenv("NINJA_PERSISTENT_LOG_FILE");
- if (env && env[0]) {
- server_config.SetLogFile(std::string(env));
- }
- }
-
- // Ensure that the persistent timeout value from the client environment
- // is passed to new server instances.
- {
- const char* env = getenv(kPersistentTimeoutSecondsEnv);
- if (env)
- server_config.AddEnvVariable(kPersistentTimeoutSecondsEnv, env);
- }
-
- CLIENT_LOG("Connecting to server.");
- PersistentService::Client client = GetService(compatibility.build_dir());
- IpcHandle connection = client.Connect(server_config, error);
- if (!connection) {
- CLIENT_LOG("Could not connect to server: %s", error->c_str());
- return false;
- }
-
- // Send the query now.
- CLIENT_LOG("Sending query to server.");
- if (!RemoteWrite(query.ToEncodedString(), connection, error)) {
- *error = "Could not send build query: " + *error;
- return false;
- }
-
- // Receive the server PID, to redirect signals to it.
-#ifdef _WIN32
- DWORD server_pid = 0;
-#else // !_WIN32
- pid_t server_pid = -1;
-#endif // !_WIN32
- if (!RemoteRead(server_pid, connection, error)) {
- *error = "Could not receive server pid: " + *error;
- return false;
- }
-
- CLIENT_LOG("Received remote server pid: %d\n", server_pid);
-
- StdioRedirector stdio_redirect(connection);
- if (!stdio_redirect.SendStandardDescriptors(error))
- return false;
-
- InterruptForwarder interrupt_forwarder(server_pid);
-
- // Wait for the corresponding exit code.
- CLIENT_LOG("Waiting for query exit code from server.");
- int exit_code = -1;
- if (!RemoteRead(exit_code, connection, error)) {
- *error = "Could not receive build request exit code: " + *error;
- return false;
- }
- CLIENT_LOG("Query ended with exit code %d", exit_code);
- *exit_code_ptr = exit_code;
- return true;
-}
-
-PersistentMode::Server::Server(const Compatibility& compatibility)
- : compatibility_(compatibility),
- server_(GetServiceName(compatibility_.build_dir())) {
- SERVER_LOG("Server for %s", compatibility_.build_dir().c_str());
-
- // Compute the server connection timeout, default value is 5 minutes
- // and can be overriden with kPersistentTimeoutSecondsEnv in the
- // environment.
- int64_t connection_timeout_ms = 5 * 60 * 1000;
- const char* env = getenv(kPersistentTimeoutSecondsEnv);
- if (env) {
- int64_t timeout_secs = static_cast<int64_t>(atoll(env));
- if (timeout_secs < 0) {
- SERVER_LOG(
- "Ignoring invalid timeout value (%s): must be strictly positive!",
- env);
- } else {
- connection_timeout_ms = timeout_secs * 1000;
- }
- }
- server_.SetConnectionTimeoutMs(connection_timeout_ms);
-}
-
-bool PersistentMode::Server::StartLocalServer(std::string* error) {
- // Return an error early if the build directory is not valid.
- if (!compatibility_.CheckBuildDir(error))
- return false;
-
- return server_.BindService(error);
-}
-
-void PersistentMode::Server::RunServerThenExit(
- RestartChecker ninja_restart_check, BuildQueryHandler query_handler) {
- // PersistentService::Server::VersionCheckHandler used to verify compatibility
- // and invoke the restart check callback before each query.
- auto version_check_handler =
- [this, &ninja_restart_check](const std::string& version) -> std::string {
- std::string error;
- auto client_compatibility =
- Compatibility::FromEncodedString(version, &error);
- if (!error.empty())
- return error;
- std::string reason;
- if (!compatibility_.IsCompatibleWith(client_compatibility, &reason))
- return StringFormat("Incompatible build plan: %s", reason.c_str());
-
- if (ninja_restart_check())
- return "Build manifest files updated!";
-
- return {};
- };
-
- // A Persistent::Server::RequestHandler instance to run queries on the
- // server.
- auto request_handler = [this, &query_handler](IpcHandle connection) -> bool {
- return RunQueryOnServer(std::move(connection), query_handler);
- };
-
- // Ensure that NINJA_PERSISTENT_MODE is disabled by default when
- // running queries, since Ninja commands can themselves invoke Ninja
- // (e.g. to perform sub-builds in other directories).
- //
- // Persistent mode for these sub-builds is disabled by default, but can
- // be enabled by the user by adding NINJA_PERSISTENT_MODE to the list in
- // NINJA_PERSISTENT_PASS_VARIABLES.
- ScopedEnvironmentVariable no_persistent_mode(kPersistentModeEnv, "0");
-
- server_.RunServerThenExit(version_check_handler, request_handler);
-}
-
-bool PersistentMode::Server::RunQueryOnServer(
- IpcHandle connection, const BuildQueryHandler& query_handler) {
- int64_t query_start_ms = AsyncLoop::NowMs();
- printf("Starting client request\n");
- std::string error;
- SERVER_LOG("New client request from handle %s", connection.display().c_str());
- // Receive build query.
- std::string encoded_query;
- if (!RemoteRead(encoded_query, connection, &error)) {
- return PrintError("Could not receive build query: %s", error.c_str());
- }
-
- auto query =
- PersistentMode::BuildQuery::FromEncodedString(encoded_query, &error);
- if (!error.empty())
- return PrintError("Could not receive build query: %s\n", error.c_str());
-
- query.WriteGlobalVariables();
-
- // Send our pid to allow the client to redirect signals to us.
-#ifdef _WIN32
- DWORD pid = GetCurrentProcessId();
-#else // !_WIN32
- pid_t pid = getpid();
-#endif // !_WIN32
- if (!RemoteWrite(pid, connection, &error))
- return PrintError("Could not send server pid: %s", error.c_str());
-
- // Temporarily redirect stdin/stdout/stderr from client-provided handles.
- int exit_code;
- {
- StdioRedirector stdio_redirect(connection);
- if (!stdio_redirect.ReceiveStandardDescriptors(&error))
- return PrintError("Could not receive standard descriptors: %s",
- error.c_str());
-
- exit_code = query_handler(query);
- }
-
- if (!RemoteWrite(exit_code, connection, &error)) {
- return PrintError("Could not send exit_code=%d back to client: %s",
- error.c_str());
- }
-
- // Keep server running until next client request.
- SERVER_LOG("Request completed with exit_code=%d", exit_code);
-
- // Print statistics about the request.
- int64_t query_time_ms = AsyncLoop::NowMs() - query_start_ms;
- printf("Request took %s to complete\n",
- StringFormatDurationMs(query_time_ms).c_str());
-
- if (exit_code == kServerExit) {
- printf("Server exiting after query.");
- return false;
- }
-
- return true;
-}
-
-// Avoid compiler warnings in debug mode.
-constexpr int PersistentMode::kServerExit;
diff --git a/src/persistent_mode.h b/src/persistent_mode.h
deleted file mode 100644
index e55a075..0000000
--- a/src/persistent_mode.h
+++ /dev/null
@@ -1,359 +0,0 @@
-// Copyright 2023 Google Inc. All Rights Reserved.
-//
-// Licensed under the Apache License, Version 2.0 (the "License");
-// you may not use this file except in compliance with the License.
-// You may obtain a copy of the License at
-//
-// http://www.apache.org/licenses/LICENSE-2.0
-//
-// Unless required by applicable law or agreed to in writing, software
-// distributed under the License is distributed on an "AS IS" BASIS,
-// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-// See the License for the specific language governing permissions and
-// limitations under the License.
-
-#ifndef NINJA_PERSISTENT_MODE_H_
-#define NINJA_PERSISTENT_MODE_H_
-
-#include <functional>
-#include <string>
-#include <vector>
-
-#include "build_config.h"
-#include "ipc_utils.h"
-#include "persistent_service.h"
-
-/// Implementation for Ninja's persistent mode.
-///
-/// This class wraps Ninja's persistent mode implementation on top of the
-/// generic PersistentService class. In particular:
-///
-/// - Provides static methods to determine the role of the current process
-/// (based on the NNINJA_PERSISTENT_MODE environment variable).
-///
-/// - Provides a way to check that the client and the server correspond to
-/// the same build plan (see Compatibility).
-///
-/// - Provides client methods to check the status of the server, or stop it
-/// (to implement the `-t server` tool commands).
-///
-/// - Provides a client method to run a query on the server, automatically
-/// starting a new instance if none is available, if the available one
-/// is not compatible with the current build plan, or if any of the input
-/// .ninja manifest files has been updated.
-///
-/// - Provides a way to start the server early, and to process Ninja build
-/// or tool requests on the server.
-///
-/// Example Usage:
-///
-/// // build plan configuration data used to match client/server
-/// // compatibility.
-/// auto compatibility = PersistentMode::Compatibility();
-/// compatibility.SetBuildDir(<absolute_build_dir>);
-///
-/// // An object describing the current Ninja build query or tool
-/// // invocation to perform.
-/// PersistentMode::BuildQuery query;
-/// query.config = build_config;
-/// query.args = RemoteArguments(argc, argv).args();
-/// ...
-///
-/// // A callable used to run the query, either on the server, or in the
-/// // client if launching a new server was not possible.
-/// auto handle_query = [](const PersistentMode::BuildQuery& query) -> int {
-/// ... // perform build or tool query.
-/// return 0;
-/// };
-///
-/// auto persistent_status = PersistentMode::GetProcessStatus();
-/// is (status == PersistentMode::IsServer) {
-/// PersistentMode::Server server(compatibility);
-///
-/// if (!server.StartLocalServer(&err))
-/// Fatal("Could not start server: %s", err.c_str());
-///
-/// ... load build plan
-///
-/// // A callable used by the server before running each
-/// // query to verify if the build plan changed (e.g. an
-/// // input build.ninja file was updated on the filesystem).
-/// auto restart_check = []() -> bool {
-/// return false;
-/// };
-///
-/// // Run the server loop till the end.
-/// server.RunServerThenExit(std::move(restart_check),
-/// std::move(handle_query));
-/// }
-///
-/// if (persistent_status == PersistentMode::Client) {
-/// PersistentMode::Client client;
-///
-/// // Run the query, this takes care of redirecting stdio
-/// // and ensuring Ctrl-C will be handled by the server
-/// // properly (i.e. to stop current query, and not abort
-/// // the server).
-/// int exit_code = -1;
-/// if (!client.RunQuery(compatibility, query, &exit_code, &error)) {
-/// Fatal("Could not run Ninja query: %s", error.c_str());
-/// }
-///
-/// // query was run on the server.
-/// exit(exit_code);
-/// }
-///
-/// assert(persistent_status == PersistentMode::Disabled) {
-/// ... load build plan
-/// ... do a local build as usual.
-/// }
-///
-struct PersistentMode {
- /// Status of persistent mode for the current process
- enum Status {
- Disabled = 0,
- IsClient,
- IsServer,
- };
-
- /// Return the status of the current process.
- static Status GetCurrentProcessStatus();
-
- /// The configuration information that each persistent server must compare
- /// with each client query to verify that they are compatible, i.e. correspond
- /// to the same Ninja build plan. Note that some flags change the way
- /// manifests are loaded, and thus introduce incompatibilities when they
- /// are different.
- struct Compatibility {
- /// Create new instance from command-line options.
- ///
- /// |input_file| is an optional pointer to the top-level Ninja manifest
- /// file name. The nullptr value defaults to "build.ninja".
- ///
- /// |build_dir| is an optional pointer to the build directory, the nullptr
- /// value defaults to the current working directory.
- ///
- /// |dupe_edges_should_err| corresponds to the `-w dupbuild=err` option,
- /// and |phony_cycle_should_err| corresponds to the `-w phonycycle=err` one,
- /// and both change the way manifest files are loaded.
- static Compatibility FromOptions(const char* input_file,
- const char* build_dir,
- bool dupe_edges_should_err,
- bool phony_cycle_should_err);
-
- Compatibility();
-
- /// Override the ninja_version() string. Only use this for tests.
- Compatibility& SetNinjaVersionForTest(const std::string& new_version);
-
- /// Change the input file, default value if "build.ninja"
- Compatibility& SetInputFile(const std::string& input_file);
-
- /// Change the build directory, and empty value matches the current working
- /// directory. WARNING: It is critically important for the client and server
- /// to use the same value consistenly. Outside of tests, ensure that a
- /// non-empty value is always an absolute path!
- Compatibility& SetBuildDir(const std::string& build_dir);
-
- /// Set the value of the `-w dupedges` flag, which changes the way build
- /// manifests are loaded. Default value is true.
- Compatibility& SetFlagDupeEdgesShouldErr(bool enabled);
-
- /// Set the value of the `-w phonycycle` flag, which changes the way
- /// build manifests are loaded. Default value is false.
- Compatibility& SetFlagPhonyCycleShouldErr(bool enabled);
-
- /// Create new instance from an encoded string.
- /// On success return new instance after clearing |*error|.
- /// On failure return empty instance after setting |*error| to non-empty
- /// string.
- static Compatibility FromEncodedString(const std::string& str,
- std::string* error);
-
- /// Convert to string for sending through IPC. Not human-readable.
- std::string ToEncodedString() const;
-
- /// Convert to human-readable string for debugging.
- std::string ToString() const;
-
- /// Return true if this instance is compatiable with |other|.
- /// On failure, return false after setting |*reason|.
- bool IsCompatibleWith(const Compatibility& other,
- std::string* reason) const;
-
- /// Return working directory.
- const std::string& build_dir() const { return build_dir_; }
-
- /// Return a string trying to identify the Ninja version being used.
- /// Note that this may include a timestamp or content hash of the current
- /// executable as well. The default value is computed by the constructor
- /// automatically.
- const std::string& ninja_version() const { return ninja_version_; };
-
- /// Return a command-line used to start a server compatible with this
- /// instance.
- std::vector<std::string> ToServerArgs(
- const std::string& server_executable) const;
-
- /// Returns true if the build directory is absolute (or empty, in which
- /// case this will be interpreted as the absolute path of the current
- /// directory). On failure, set |*err| then return false.
- bool CheckBuildDir(std::string* err) const;
-
- private:
- /// Return the default Ninja version, called from constructor.
- static std::string GetDefaultNinjaVersion();
-
- /// Ninja version. This includes a timestamp of the Ninja executable
- /// as well. Must be the first field in this struct.
- std::string ninja_version_;
-
- /// Current build directory.
- std::string build_dir_;
-
- /// Input file name, cannot be empty, relative paths are always
- /// relative to |build_dir|.
- std::string input_file_ = "build.ninja";
-
- /// Options controlling how the manifest is loaded.
- bool dupe_edges_should_err_ = true;
- bool phony_cycle_should_err_ = false;
- };
-
- /// A callable object that returns true if any condition invalidated
- /// the content of the in-memory build graph. In practice this would be
- /// when any of the input .ninja files has changed. A return value of true
- /// indicates that the server must be stopped, and another one restarted.
- using RestartChecker = std::function<bool(void)>;
-
- /// Describe a query from the client to the server. This can be used to
- /// run either a build or a tool (when the |tool| field is not empty).
- struct BuildQuery {
- /// Build configuration
- BuildConfig config;
-
- /// Mirror the set of debug flags in "debug_flags.h" that can be set
- /// individually with `-d <flag>` on the command line that do affect
- /// each build. These are currently stored in global variables instead
- /// of BuildConfig :-/
- bool debug_explaining = false;
- bool debug_keep_depfile = false;
- bool debug_keep_rsp = false;
- bool debug_experimental_statcache = false;
-
- /// Set to true to dump metrics after a build.
- bool dump_metrics = false;
-
- /// Optional tool name, empty means a build is requested, instead of a
- /// tool run.
- std::string tool;
-
- /// List of command-line arguments. If |tool| is empty, this is a list
- /// of targets and should not contain any option. If |tool| is not empty
- /// then this is a list of arguments for the tool.
- std::vector<std::string> args;
-
- std::string ToEncodedString() const;
- std::string ToString() const;
-
- void WriteGlobalVariables() const;
-
- static BuildQuery FromEncodedString(const std::string& str,
- std::string* error);
- };
-
- /// A special value that can be returned by a BuildQueryHandler to
- /// indicate that the server should exit immediately after
- /// serving the query.
- static constexpr int kServerExit = -2;
-
- /// A callable object that implements a query. The result value can
- /// be the special kServerExit value to indicate that the server
- /// should stop immediately. Otherwise, it must be a process exit
- /// code that is >= 0, corresponding to the result of the query.
- using BuildQueryHandler = std::function<int(const BuildQuery&)>;
-
- class Client {
- public:
- /// Create new instance.
- Client();
-
- /// Set the path to the server executable. By default, this is the value
- /// returned by GetCurrentExecutable(), but this method allows one to
- /// override it for testing.
- void SetServerExecutable(const std::string& server_path);
-
- /// Return server executable path. Used for testing.
- const std::string server_executable() const { return server_executable_; }
-
- /// Return true if a server is already running, serving a given build
- /// directory. An empty |build_dir| string means the current working
- /// directory.
- bool IsServerRunning(const std::string& build_dir);
-
- /// Retrieve process ID of server, if it exists, for |build_dir|,
- /// or -1 otherwise. NOTE: DOES NOT WORK ON WINDOWS YET.
- int GetServerPidFor(const std::string& build_dir);
-
- /// Stop the server if it exists, return true if a server was running
- /// before the call for a given build directory. An empty |build_dir|
- /// string means the current working directory.
- bool StopServer(const std::string& build_dir, std::string* err);
-
- /// Ask the server to run a query for us.
- ///
- /// |compatibility| is used to connect either launch a new server instance,
- /// or verify that the existing one serving |compatibility.build_dir()| is
- /// compatible (if not, that instance is shut down, and a new one is
- /// launched).
- ///
- /// On success return true and set |*exit_code_ptr| to the result of the
- /// query, on failure to connect to the server, set |*error| and return
- /// false.
- bool RunQuery(const Compatibility& compatibility, const BuildQuery& query,
- int* exit_code_ptr, std::string* error);
-
- private:
- static PersistentService::Client GetService(const std::string& build_dir);
-
- std::string server_executable_;
- };
-
- class Server {
- public:
- /// Create new instance. This does not do anything except recording
- /// the value of |compatibility|.
- explicit Server(const Compatibility& compatibility);
-
- /// Set the timeout, in milliseconds, used by server instances waiting
- /// for new client connections. On expiration, the server will shutdown
- /// gracefully. A negative value (the default) means no timeout.
- /// This must be called before StartLocalServer() or RunServerThenExit().
- void SetConnectionTimeoutMs(int64_t connection_timeout_ms) {
- server_.SetConnectionTimeoutMs(connection_timeout_ms);
- }
-
- /// Start the server in the current process. This can be called before
- /// RunServerThenExit() to quickly acquire the service named pipe and fail
- /// if not possible, before performing expensive operations like loading
- /// the build plan. Called by RunServerThenExit() implicitly otherwise.
- bool StartLocalServer(std::string* error);
-
- /// Run the server main loop, which will handle incoming
- /// build requests by first calling |restart_checker| to verify whether
- /// a restart is needed (e.g. if the build plan changed), then serve
- /// the request with |query_handler|. This function never returns.
- void RunServerThenExit(RestartChecker restart_checker,
- BuildQueryHandler query_handler);
-
- private:
- bool RunQueryOnServer(IpcHandle connection,
- const BuildQueryHandler& query_handler);
-
- Compatibility compatibility_;
- int64_t connection_timeout_ms_ = -1;
- PersistentService::Server server_;
- };
-};
-
-#endif // NINJA_PERSISTENT_MODE_H_
diff --git a/src/persistent_mode_test.cc b/src/persistent_mode_test.cc
deleted file mode 100644
index 80a685d..0000000
--- a/src/persistent_mode_test.cc
+++ /dev/null
@@ -1,249 +0,0 @@
-// Copyright 2023 Google Inc. All Rights Reserved.
-//
-// Licensed under the Apache License, Version 2.0 (the "License");
-// you may not use this file except in compliance with the License.
-// You may obtain a copy of the License at
-//
-// http://www.apache.org/licenses/LICENSE-2.0
-//
-// Unless required by applicable law or agreed to in writing, software
-// distributed under the License is distributed on an "AS IS" BASIS,
-// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-// See the License for the specific language governing permissions and
-// limitations under the License.
-
-#include "persistent_mode.h"
-
-#include <inttypes.h>
-#include <stdlib.h>
-
-#include "async_loop.h"
-#include "persistent_mode_test_lib.cc"
-#include "process_utils.h"
-#include "stdio_redirection.h"
-#include "test.h"
-#include "util.h"
-
-TEST(PersistentMode, GetCurrentProcessStatus) {
- static const char kStatusVarName[] = "NINJA_PERSISTENT_MODE";
-
- {
- static const char* const kValues[] = { nullptr, "off", "0" };
- for (const char* value : kValues) {
- ScopedEnvironmentVariable env(kStatusVarName, value);
- EXPECT_EQ(PersistentMode::Disabled,
- PersistentMode::GetCurrentProcessStatus());
- }
- }
-
- {
- static const char* const kValues[] = { "on", "1", "client" };
- for (const char* value : kValues) {
- ScopedEnvironmentVariable env(kStatusVarName, value);
- ASSERT_TRUE(getenv(kStatusVarName));
- EXPECT_EQ(std::string(value), getenv(kStatusVarName));
- EXPECT_EQ(PersistentMode::IsClient,
- PersistentMode::GetCurrentProcessStatus());
- }
- }
-
- {
- static const char* const kValues[] = { "server" };
- for (const char* value : kValues) {
- ScopedEnvironmentVariable env(kStatusVarName, value);
- EXPECT_EQ(PersistentMode::IsServer,
- PersistentMode::GetCurrentProcessStatus());
- }
- }
-}
-
-TEST(PersistentMode, Compatibility) {
- // Convenience helper to return a value with default values
- // appropriate for this test.
- auto new_compat = []() -> PersistentMode::Compatibility {
- return PersistentMode::Compatibility()
- .SetNinjaVersionForTest("this_ninja")
- .SetInputFile("input_file")
- .SetBuildDir("build_dir");
- };
- PersistentMode::Compatibility compat = new_compat();
-
- std::string reason;
- ASSERT_TRUE(compat.IsCompatibleWith(compat, &reason));
-
- std::string encoded = compat.ToEncodedString();
- std::string error;
- auto compat2 =
- PersistentMode::Compatibility::FromEncodedString(encoded, &error);
- ASSERT_TRUE(error.empty());
-
- auto to_string = [](const std::vector<std::string>& args) -> std::string {
- std::string result;
- for (const auto& arg : args) {
- if (!result.empty())
- result += " ";
- result += arg;
- }
- return result;
- };
-
- ASSERT_TRUE(compat.IsCompatibleWith(compat2, &reason));
- ASSERT_TRUE(compat2.IsCompatibleWith(compat, &reason));
-
- compat2 = new_compat().SetBuildDir("another_build_dir");
-
- ASSERT_FALSE(compat.IsCompatibleWith(compat2, &reason));
- EXPECT_EQ(
- reason,
- "Working dir mismatch, expected [build_dir] vs [another_build_dir]");
- EXPECT_EQ(
- "ninja -C another_build_dir -f input_file -wdupbuild=err "
- "-wphonycycle=warn",
- to_string(compat2.ToServerArgs("ninja")));
-
- compat2 = new_compat().SetInputFile("another_input_file");
-
- ASSERT_FALSE(compat.IsCompatibleWith(compat2, &reason));
- EXPECT_EQ(
- reason,
- "Input file mismatch, expected [input_file] vs [another_input_file]");
- EXPECT_EQ(
- "ninja -C build_dir -f another_input_file -wdupbuild=err "
- "-wphonycycle=warn",
- to_string(compat2.ToServerArgs("ninja")));
-
- compat2 = new_compat().SetFlagDupeEdgesShouldErr(false);
- ASSERT_FALSE(compat.IsCompatibleWith(compat2, &reason));
- EXPECT_EQ(reason,
- "Flag dupe_edges_should_err mismatch, expected true vs false");
- EXPECT_EQ(
- "ninja -C build_dir -f input_file -wdupbuild=warn -wphonycycle=warn",
- to_string(compat2.ToServerArgs("ninja")));
-
- compat2 = new_compat().SetFlagPhonyCycleShouldErr(true);
- ASSERT_FALSE(compat.IsCompatibleWith(compat2, &reason));
- EXPECT_EQ(reason,
- "Flag phony_cycle_should_err mismatch, expected false vs true");
- EXPECT_EQ("ninja -C build_dir -f input_file -wdupbuild=err -wphonycycle=err",
- to_string(compat2.ToServerArgs("ninja")));
-
- compat2 = compat;
- compat2.SetNinjaVersionForTest("not_this_ninja");
- ASSERT_FALSE(compat.IsCompatibleWith(compat2, &reason));
- EXPECT_EQ(
- reason,
- "Ninja version mismatch, expected [this_ninja] vs [not_this_ninja]");
- EXPECT_EQ("ninja -C build_dir -f input_file -wdupbuild=err -wphonycycle=warn",
- to_string(compat2.ToServerArgs("ninja")));
-}
-
-// Unfortunately, this test, and PersistentMode in general do not work
-// properly on Windows yet. The root of the problem is that StdioRedirector
-// does not work because it is impossible to pass Win32 console handlers
-// to other processes. Solving this requires an alternative implementation
-// that relies on proxying the console handles through anonymous pipes on
-// the client, which will be provided in a future fix.
-#ifndef _WIN32
-TEST(PersistentModeClient, DefaultMode) {
- PersistentMode::Client client;
- client.SetServerExecutable(persistent_mode_test::GetServerExecutable());
-
- ScopedTempDir test_dir;
- test_dir.CreateAndEnter("persistent_mode_test");
- std::string build_dir = GetCurrentDir();
-
- ASSERT_FALSE(client.IsServerRunning(build_dir));
-
- auto compat = persistent_mode_test::GetClientCompatibility(build_dir);
- std::string error;
- int exit_code = -1;
-
- auto query = persistent_mode_test::GetClientTestQuery1(build_dir);
-
- AsyncLoop::ResetForTesting();
- AsyncLoop& async_loop = AsyncLoop::Get();
-
- {
- StdioAsyncStringRedirector buffered_stdout(async_loop, stdout);
- bool ret = client.RunQuery(compat, query, &exit_code, &error);
- if (!ret)
- fprintf(stderr, "\nERROR: %s\n", error.c_str());
- std::string result;
- EXPECT_TRUE(buffered_stdout.WaitForResult(&result));
-
- ASSERT_TRUE(ret);
- EXPECT_EQ(0u, exit_code);
- EXPECT_EQ(result, build_dir);
- }
-
- ASSERT_TRUE(client.IsServerRunning(build_dir));
-
- ASSERT_TRUE(client.StopServer(build_dir, &error));
-}
-
-TEST(PersistentModeClient, EnvironmentVariables) {
- PersistentMode::Client client;
- client.SetServerExecutable(persistent_mode_test::GetServerExecutable());
-
- ScopedTempDir test_dir;
- test_dir.CreateAndEnter("persistent_mode_test");
- std::string build_dir = test_dir.temp_dir_name_;
-
- ASSERT_FALSE(client.IsServerRunning(build_dir));
-
- auto compat = persistent_mode_test::GetClientCompatibility(build_dir);
- std::string error;
- int exit_code = -1;
-
- std::vector<std::string> print_varnames;
- print_varnames.emplace_back("bar");
- print_varnames.emplace_back("foo");
- print_varnames.emplace_back("undefined");
-
- auto query = persistent_mode_test::GetClientTestQuery2(print_varnames);
- query.config.environment.Insert("foo", "FOO");
- query.config.environment.Insert("bar", "BAR");
- query.config.environment.Remove("undefined");
-
- AsyncLoop::ResetForTesting();
- AsyncLoop& async_loop = AsyncLoop::Get();
-
- // The first query should retrieve the variable values from the client
- // process that started it.
- {
- StdioAsyncStringRedirector buffered_stdout(async_loop, stdout);
- bool ret = client.RunQuery(compat, query, &exit_code, &error);
- if (!ret)
- fprintf(stderr, "\nERROR: %s\n", error.c_str());
- std::string result;
- EXPECT_TRUE(buffered_stdout.WaitForResult(&result));
-
- ASSERT_TRUE(ret);
- EXPECT_EQ(0u, exit_code);
- EXPECT_EQ(result, "bar=BAR\nfoo=FOO\nundefined=<UNSET>\n");
- }
-
- // Change the local values of 'foo' and 'undefined', and verify that only the
- // ones listed by passthrough_varnames were modified on the server.
- {
- query.config.environment.Insert("foo", "NEW_FOO");
- query.config.environment.Insert("undefined", "SURPRISE!");
-
- StdioAsyncStringRedirector buffered_stdout(async_loop, stdout);
- bool ret = client.RunQuery(compat, query, &exit_code, &error);
- if (!ret)
- fprintf(stderr, "\nERROR: %s\n", error.c_str());
- std::string result;
- EXPECT_TRUE(buffered_stdout.WaitForResult(&result));
-
- ASSERT_TRUE(ret);
- EXPECT_EQ(0u, exit_code);
- EXPECT_EQ(result, "bar=BAR\nfoo=NEW_FOO\nundefined=SURPRISE!\n");
- }
-
- ASSERT_TRUE(client.IsServerRunning(build_dir));
-
- ASSERT_TRUE(client.StopServer(build_dir, &error));
-}
-
-#endif // !_WIN32
diff --git a/src/persistent_mode_test_helper.cc b/src/persistent_mode_test_helper.cc
deleted file mode 100644
index ca22500..0000000
--- a/src/persistent_mode_test_helper.cc
+++ /dev/null
@@ -1,29 +0,0 @@
-// Copyright 2023 Google Inc. All Rights Reserved.
-//
-// Licensed under the Apache License, Version 2.0 (the "License");
-// you may not use this file except in compliance with the License.
-// You may obtain a copy of the License at
-//
-// http://www.apache.org/licenses/LICENSE-2.0
-//
-// Unless required by applicable law or agreed to in writing, software
-// distributed under the License is distributed on an "AS IS" BASIS,
-// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-// See the License for the specific language governing permissions and
-// limitations under the License.
-
-#include <stdio.h>
-#include <stdlib.h>
-
-#include "persistent_mode.h"
-#include "persistent_mode_test_lib.cc"
-#include "util.h"
-
-int main(int argc, char** argv) {
- fprintf(stderr, "STARTING SERVER IN %s\n", GetCurrentDir().c_str());
- int64_t connection_timeout_ms = 3000;
- auto compatibility = persistent_mode_test::GetServerCompatibility(
- argc, argv, &connection_timeout_ms);
- persistent_mode_test::RunServerThenExit(compatibility, connection_timeout_ms);
- return 127;
-}
diff --git a/src/persistent_mode_test_lib.cc b/src/persistent_mode_test_lib.cc
deleted file mode 100644
index 3d45355..0000000
--- a/src/persistent_mode_test_lib.cc
+++ /dev/null
@@ -1,177 +0,0 @@
-// Copyright 2023 Google Inc. All Rights Reserved.
-//
-// Licensed under the Apache License, Version 2.0 (the "License");
-// you may not use this file except in compliance with the License.
-// You may obtain a copy of the License at
-//
-// http://www.apache.org/licenses/LICENSE-2.0
-//
-// Unless required by applicable law or agreed to in writing, software
-// distributed under the License is distributed on an "AS IS" BASIS,
-// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-// See the License for the specific language governing permissions and
-// limitations under the License.
-
-#include "persistent_mode_test_lib.h"
-
-#ifdef _WIN32
-#include "getopt.h"
-#elif defined(_AIX)
-#include "getopt.h"
-#else
-#include <getopt.h>
-#endif
-
-#include <string>
-
-#include "util.h"
-
-namespace persistent_mode_test {
-
-namespace {
-
-struct ServerState {
- ServerState(const PersistentMode::Compatibility& compatibility,
- int64_t connection_timeout_ms)
- : server_(compatibility) {
- server_.SetConnectionTimeoutMs(connection_timeout_ms);
- }
-
- void RunServerThenExit() {
- server_.RunServerThenExit(
- [this]() { return RestartCheck(); },
- [this](const PersistentMode::BuildQuery& query) -> int {
- return HandleQuery(query);
- });
- }
-
- bool RestartCheck() { return false; };
-
- int HandleQuery(const PersistentMode::BuildQuery& query) {
- if (query.tool == "print-current-dir") {
- fprintf(stdout, "%s", GetCurrentDir().c_str());
- return 0;
- }
- if (query.tool == "get-env-vars") {
- for (const auto& varname : query.args) {
- const char* varvalue = query.config.environment.Get(varname.c_str());
- if (!varvalue)
- varvalue = "<UNSET>";
- fprintf(stdout, "%s=%s\n", varname.c_str(), varvalue);
- }
- return 0;
- }
- fprintf(stderr, "UNKNOWN QUERY TYPE!\n");
- return 1;
- }
-
- // Create new query to print the current directory.
- static PersistentMode::BuildQuery MakeQuery1(const std::string& build_dir) {
- PersistentMode::BuildQuery query;
- query.tool = "print-current-dir";
- return query;
- }
-
- // Create a new query to print the environment variables of the server
- // process.
- static PersistentMode::BuildQuery MakeQuery2(
- const std::vector<std::string>& print_variables) {
- PersistentMode::BuildQuery query;
- query.tool = "get-env-vars";
- query.args = print_variables;
- return query;
- }
- PersistentMode::Server server_;
-};
-
-} // namespace
-
-std::string GetServerExecutable() {
- std::string result =
- GetCurrentExecutableDir() + "/persistent_mode_test_helper";
-#ifdef _WIN32
- result += ".exe";
-#endif
- return result;
-}
-
-PersistentMode::Compatibility GetClientCompatibility(
- const std::string& build_dir) {
- PersistentMode::Compatibility result;
- result.SetNinjaVersionForTest("version-1.0")
- .SetInputFile("persistent_mode.input")
- .SetBuildDir(build_dir);
- return result;
-}
-
-PersistentMode::Compatibility GetServerCompatibility(
- int argc, char** argv, int64_t* connection_timeout_ms) {
- const char* progname = argv[0];
-
- auto print_usage = [progname]() {
- fprintf(stderr,
- "Usage: %s [-C BUILD_DIR] [-f INPUT_FILE] [-t TIMEOUT_MILLIS] [-w "
- "WARNING]+\n",
- progname);
- exit(1);
- };
-
- PersistentMode::Compatibility result;
-
- int opt;
- while ((opt = getopt(argc, argv, const_cast<char*>("C:f:w:t:"))) != -1) {
- fprintf(stderr, "OPT %c\n", opt);
- switch (opt) {
- case 'C':
- result.SetBuildDir(optarg);
- break;
- case 'f':
- result.SetInputFile(optarg);
- break;
- case 'w':
- if (!strcmp(optarg, "dupbuild=err")) {
- result.SetFlagDupeEdgesShouldErr(true);
- } else if (!strcmp(optarg, "dupbuild=warn")) {
- result.SetFlagDupeEdgesShouldErr(false);
- } else if (!strcmp(optarg, "phonycycle=err")) {
- result.SetFlagPhonyCycleShouldErr(true);
- } else if (!strcmp(optarg, "phonycycle=warn")) {
- result.SetFlagPhonyCycleShouldErr(false);
- } else {
- Fatal("Unknown -d argument value: %s", optarg);
- }
- break;
- case 't':
- *connection_timeout_ms = static_cast<int64_t>(atoll(optarg));
- break;
- default:
- print_usage();
- }
- }
- fprintf(stderr, "argc=%d optind=%d\n", argc, optind);
- argc -= optind;
- argv += optind;
- if (argc > 0)
- print_usage();
-
- // Must match the version in GetClientCompatibility().
- result.SetNinjaVersionForTest("version-1.0");
- return result;
-}
-
-PersistentMode::BuildQuery GetClientTestQuery1(const std::string& build_dir) {
- return ServerState::MakeQuery1(build_dir);
-}
-
-PersistentMode::BuildQuery GetClientTestQuery2(
- const std::vector<std::string>& print_variables) {
- return ServerState::MakeQuery2(print_variables);
-}
-
-void RunServerThenExit(const PersistentMode::Compatibility& compatibility,
- int64_t connection_timeout_ms) {
- ServerState state(compatibility, connection_timeout_ms);
- state.RunServerThenExit();
-}
-
-} // namespace persistent_mode_test
diff --git a/src/persistent_mode_test_lib.h b/src/persistent_mode_test_lib.h
deleted file mode 100644
index 98b725e..0000000
--- a/src/persistent_mode_test_lib.h
+++ /dev/null
@@ -1,43 +0,0 @@
-// Copyright 2023 Google Inc. All Rights Reserved.
-//
-// Licensed under the Apache License, Version 2.0 (the "License");
-// you may not use this file except in compliance with the License.
-// You may obtain a copy of the License at
-//
-// http://www.apache.org/licenses/LICENSE-2.0
-//
-// Unless required by applicable law or agreed to in writing, software
-// distributed under the License is distributed on an "AS IS" BASIS,
-// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-// See the License for the specific language governing permissions and
-// limitations under the License.
-
-#include <stdint.h>
-
-#include <string>
-#include <vector>
-
-#include "persistent_mode.h"
-
-namespace persistent_mode_test {
-
-// Return path to the server executable for this test.
-extern std::string GetServerExecutable();
-
-// Return a PersistentMode::Compatibility value for the default service
-// implementation.
-extern PersistentMode::Compatibility GetClientCompatibility(
- const std::string& build_dir);
-
-// Return a PersistentMode::Compatibility value to be used on the server,
-// from the command-line content.
-extern PersistentMode::Compatibility GetServerCompatibility(
- int argc, char** argv, int64_t* connection_timeout_ms);
-
-extern PersistentMode::BuildQuery GetClientTestQuery1(
- const std::string& build_dir);
-
-extern PersistentMode::BuildQuery GetClientTestQuery2(
- const std::vector<std::string>& print_variables);
-
-} // namespace persistent_mode_test
diff --git a/src/persistent_service.cc b/src/persistent_service.cc
deleted file mode 100644
index 2a3726d..0000000
--- a/src/persistent_service.cc
+++ /dev/null
@@ -1,624 +0,0 @@
-// Copyright 2023 Google Inc. All Rights Reserved.
-//
-// Licensed under the Apache License, Version 2.0 (the "License");
-// you may not use this file except in compliance with the License.
-// You may obtain a copy of the License at
-//
-// http://www.apache.org/licenses/LICENSE-2.0
-//
-// Unless required by applicable law or agreed to in writing, software
-// distributed under the License is distributed on an "AS IS" BASIS,
-// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-// See the License for the specific language governing permissions and
-// limitations under the License.
-
-#include "persistent_service.h"
-
-#include "async_loop.h"
-#include "ipc_utils.h"
-#include "util.h"
-
-#define DEBUG 0
-
-#ifdef _WIN32
-#include <windows.h>
-#else
-#include <fcntl.h>
-#include <sys/stat.h>
-#include <unistd.h>
-#endif
-
-#if DEBUG
-#define SERVER_LOG(...) \
- do { \
- fprintf(stderr, "SERVER_LOG: "); \
- fprintf(stderr, __VA_ARGS__); \
- fprintf(stderr, "\n"); \
- } while (0)
-#define CLIENT_LOG(...) \
- do { \
- fprintf(stderr, "CLIENT_LOG: "); \
- fprintf(stderr, __VA_ARGS__); \
- fprintf(stderr, "\n"); \
- } while (0)
-#else
-#define CLIENT_LOG(...) (void)0
-#define SERVER_LOG(...) (void)0
-#endif
-
-namespace {
-
-// Sleep for |delay_ms| milliseconds.
-void SleepMilliSeconds(int delay_ms) {
-#ifdef _WIN32
- if (delay_ms > 0)
- ::Sleep(static_cast<DWORD>(delay_ms));
-#else
- usleep(static_cast<useconds_t>(delay_ms) * 1000);
-#endif
-}
-
-struct ProcessInfo {
-#ifdef _WIN32
- HANDLE process_handle;
-#else
- pid_t process_pid;
-#endif
-};
-
-// Start a new process, with command-line |args|.
-// Uses fork()/exec() on Posix, and CreateProcess on Win32.
-// Return true on success, or set |*err| and return false on failure.
-bool SpawnServerProcess(const PersistentService::Config& config,
- ProcessInfo* info, std::string* err) {
- if (config.command.empty()) {
- *err = "Empty command line!";
- return false;
- }
-
-#ifdef _WIN32
- std::string command_string;
- for (const auto& arg : config.command) {
- std::string escaped;
- GetWin32EscapedString(arg, &escaped);
- command_string += escaped;
- command_string += ' ';
- }
- // Remove trailing space if any.
- if (!command_string.empty())
- command_string.resize(command_string.size() - 1u);
-
- SECURITY_ATTRIBUTES security_attributes = {};
- security_attributes.nLength = sizeof(SECURITY_ATTRIBUTES);
- security_attributes.bInheritHandle = TRUE;
- // Must be inheritable so subprocesses can dup to children.
- HANDLE nul =
- CreateFileA("NUL", GENERIC_READ | GENERIC_WRITE,
- FILE_SHARE_READ | FILE_SHARE_WRITE | FILE_SHARE_DELETE,
- &security_attributes, OPEN_EXISTING, 0, NULL);
- if (nul == INVALID_HANDLE_VALUE)
- Win32Fatal("couldn't open nul");
-
- HANDLE log = nul;
- std::string log_file = config.log_file;
- if (log_file.empty()) {
- // As a debug helper, use the log file from this environment variable.
- const char* env = getenv("DEBUG_PERSISTENT_SERVICE_LOG_FILE");
- if (env)
- log_file = env;
- }
- if (!log_file.empty()) {
- log =
- CreateFileA(log_file.c_str(), STANDARD_RIGHTS_WRITE | FILE_APPEND_DATA,
- FILE_SHARE_READ | FILE_SHARE_WRITE | FILE_SHARE_DELETE,
- &security_attributes, OPEN_ALWAYS, 0, NULL);
- if (log == INVALID_HANDLE_VALUE)
- Win32Fatal("couldn't open log file", log_file.c_str());
- }
-
- STARTUPINFOA startup_info = {};
- startup_info.cb = sizeof(STARTUPINFO);
- startup_info.dwFlags = STARTF_USESTDHANDLES;
- startup_info.hStdInput = nul;
- startup_info.hStdOutput = log;
- startup_info.hStdError = log;
- PROCESS_INFORMATION process_info = {};
-
- // Ninja handles ctrl-c, except for subprocesses in console pools.
- DWORD process_flags = CREATE_NEW_PROCESS_GROUP;
-
- {
- // TODO(digit): Create new environment variable block and add/replace
- // the value in it, without touching the parent env.
- for (const auto& pair : config.env_vars) {
- const char* varname = pair.first.c_str();
- const char* value = pair.second.c_str();
- SetEnvironmentVariable(varname, value);
- }
- }
-
- // Do not prepend 'cmd /c' on Windows, this breaks command
- // lines greater than 8,191 chars.
- if (!CreateProcessA(NULL, (char*)command_string.c_str(), NULL, NULL,
- /* inherit handles */ TRUE, process_flags, NULL, NULL,
- &startup_info, &process_info)) {
- DWORD error = GetLastError();
- if (error == ERROR_FILE_NOT_FOUND) {
- CloseHandle(nul);
- if (log != nul)
- CloseHandle(log);
- // child_ is already NULL;
- *err =
- "CreateProcess failed: The system cannot find the file "
- "specified: [" +
- command_string + "]";
- return false;
- } else {
- fprintf(stderr, "\nCreateProcess failed. Command attempted:\n\"%s\"\n",
- command_string.c_str());
- const char* hint = NULL;
- // ERROR_INVALID_PARAMETER means the command line was formatted
- // incorrectly. This can be caused by a command line being too long or
- // leading whitespace in the command. Give extra context for this case.
- if (error == ERROR_INVALID_PARAMETER) {
- hint = "is the command line too long?";
- }
- Win32Fatal("CreateProcess", hint);
- }
- }
-
- CloseHandle(nul);
- if (log != nul)
- CloseHandle(log);
-
- CloseHandle(process_info.hThread);
- return true;
-#else // !_WIN32
- // Build arguments array for future exec() call.
- std::vector<char*> exec_args;
- exec_args.reserve(config.command.size() + 1);
- for (const auto& arg : config.command) {
- exec_args.push_back(const_cast<char*>(arg.data()));
- CLIENT_LOG("CMD: [%s]", arg.c_str());
- }
- exec_args.push_back(nullptr);
-
- pid_t process = fork();
- if (process < 0) {
- *err = "fork failed()!";
- return false;
- }
-
- if (process == 0) {
- // Create new session to not receive signals from parent process group.
- if (setsid() < 0) {
- fprintf(stderr, "ERROR: setsid() failed: %s\n", strerror(errno));
- exit(1);
- }
-
- // Change current working directory.
- if (!config.working_dir.empty()) {
- const char* work_dir = config.working_dir.c_str();
- if (chdir(work_dir) < 0)
- ErrnoFatal("chdir", work_dir);
- }
-
- // Redirect stdin to /dev/null and stdout/stderr to a log file if
- // PERSISTENT_SERVER_LOG_FILE is set in the environment, or to
- // /dev/null otherwise.
- int null_fd = open("/dev/null", O_RDWR);
- if (null_fd < 0) {
- fprintf(stderr, "ERROR: open(/dev/null) failed: %s\n", strerror(errno));
- exit(1);
- }
- int log_fd = null_fd;
- std::string log_file = config.log_file;
- if (log_file.empty()) {
- // As a debug helper, use the log file from this environment variable.
- const char* env = getenv("DEBUG_PERSISTENT_SERVICE_LOG_FILE");
- if (env)
- log_file = env;
- }
- if (!log_file.empty()) {
- log_fd = open(log_file.c_str(), O_WRONLY | O_APPEND | O_CREAT, 0755);
- if (log_fd < 0) {
- fprintf(stderr, "ERROR: open(%s) failed: %s\n", log_file.c_str(),
- strerror(errno));
- exit(1);
- }
- }
-
- fflush(stdout);
- fflush(stderr);
-
- dup2(null_fd, 0);
- dup2(log_fd, 1);
- dup2(log_fd, 2);
-
- // Set extra environment variables.
- for (const auto& pair : config.env_vars) {
- const char* varname = pair.first.c_str();
- const char* value = pair.second.c_str();
- setenv(varname, value, 1);
- }
-
- fprintf(stderr, "\n\nSTARTING NEW PERSISTENT SERVER: %s\n",
- config.command[0].c_str());
- execv(config.command[0].c_str(), exec_args.data());
- fprintf(stderr, "ERROR: exec() failed: %s\n", strerror(errno));
- exit(1);
- }
- // In parent process, do not do anything.
- info->process_pid = process;
- return true;
-#endif // !_WIN32
-}
-
-// Type of commands received from the server.
-enum ServerCommandType {
- kServerCommandTypeStop,
- kServerCommandTypeGetPid,
- kServerCommandTypeClientQuery,
-};
-
-} // namespace
-
-///////////////////////////////////////////////////////////////////////////
-///
-/// C L I E N T S I D E
-///
-
-PersistentService::Client::Client(const std::string& service_name)
- : service_name_(service_name) {}
-
-PersistentService::Client::~Client() = default;
-
-bool PersistentService::Client::HasServer() const {
- return IpcServiceHandle::IsBound(service_name_);
-}
-
-int PersistentService::Client::GetServerPid() const {
- std::string err;
- IpcHandle client = RawConnect(&err);
- if (!client)
- return -1;
-
- uint8_t query_type = kServerCommandTypeGetPid;
- int server_pid = -1;
- if (!RemoteWrite(query_type, client, &err) ||
- !RemoteRead(server_pid, client, &err)) {
- return -1;
- }
- return server_pid;
-}
-
-bool PersistentService::Client::StopServer(std::string* err) const {
- IpcHandle client = RawConnect(err);
- if (!client)
- return false;
-
- uint8_t query_type = kServerCommandTypeStop;
- if (!client.Write(&query_type, sizeof(query_type), err)) {
- *err = StringFormat("Could not stop server: %s", err->c_str());
- return false;
- }
-
- return true;
-}
-
-bool PersistentService::Client::WaitForServerShutdown() {
- std::string error;
- for (int retry_count = 20; retry_count > 0; --retry_count) {
- if (!HasServer())
- return true;
-
- SleepMilliSeconds(100);
- }
- return false;
-}
-
-IpcHandle PersistentService::Client::Connect(const Config& config,
- std::string* error) {
- bool try_again = true;
-
- while (true) {
- CLIENT_LOG("Trying to connect to server.");
- IpcHandle client = ConnectOrStartServer(config, error);
- if (!client)
- return {};
-
- CLIENT_LOG("Sending version info to server.");
- if (!RemoteWrite(config.version_info, client, error)) {
- *error = "Could not send version info: " + *error;
- return {};
- }
-
- // Receive the |compatible| flag that indicates that the server is
- // compatible with the current build plan.
- std::string version_check;
- if (!RemoteRead(version_check, client, error)) {
- *error = "Could not read version check result: " + *error;
- return {};
- }
-
- if (version_check.empty()) {
- // Good, return the handle now.
- return client;
- }
-
- // The server was not compatible with the current client.
- // Assume it exited, and start another one at least once.
- CLIENT_LOG("Incompatible server version: %s", version_check.c_str());
-
- if (!try_again) {
- // Already tried once, so report failure.
- CLIENT_LOG("Failed to connect to or start server!");
- return {};
- }
-
- try_again = false;
- CLIENT_LOG("Waiting for incompatible server shutdown.");
- if (!WaitForServerShutdown()) {
- *error = "Could not shutdown incompatible server!?!";
- return {};
- }
- }
-}
-
-IpcHandle PersistentService::Client::RawConnect(std::string* err) const {
- return IpcServiceHandle::ConnectTo(service_name_, err);
-}
-
-IpcHandle PersistentService::Client::ConnectOrStartServer(
- const Config& config, std::string* err) const {
- int retry_count = 5;
- int retry_delay_ms = 10;
- bool server_started = false;
- ProcessInfo info = {};
- while (true) {
- // Try to connect to the server first.
- IpcHandle client = RawConnect(err);
- if (client) {
- CLIENT_LOG("Got client connection to server!");
- uint8_t query_type = kServerCommandTypeClientQuery;
- if (!client.Write(&query_type, sizeof(query_type), err)) {
- CLIENT_LOG(
- "ERROR: Could not write query type, did server disconnect?: %s",
- err->c_str());
- client.Close();
- } else {
- CLIENT_LOG("Sent query type");
- }
- return client;
- }
-
- if (!server_started) {
- CLIENT_LOG("No initial connection. Spawning server");
- // Spawn a server if one wasn't already started.
- if (!SpawnServerProcess(config, &info, err)) {
- CLIENT_LOG("Could not spawn server: %s", err->c_str());
- return {};
- }
- server_started = true;
-
- } else if (retry_count == 0) {
- CLIENT_LOG("Failure to connect to server, exiting retry loop: %s",
- err->c_str());
- return {};
- } else {
- --retry_count;
- if (retry_delay_ms < 1024)
- retry_delay_ms *= 2;
- }
-
- CLIENT_LOG("Waiting for %ld milliseconds", (long)retry_delay_ms);
- SleepMilliSeconds(retry_delay_ms);
- }
-}
-
-///////////////////////////////////////////////////////////////////////////
-///
-/// S E R V E R S I D E
-///
-
-PersistentService::Server::Server(const std::string& service_name)
- : service_name_(service_name) {}
-
-bool PersistentService::Server::BindService(std::string* err) {
- if (service_handle_) {
- *err = "Server already started!";
- return false;
- }
- SERVER_LOG("Trying to get service %s", service_name_.c_str());
- service_handle_ = IpcServiceHandle::BindTo(service_name_, err);
- if (!service_handle_)
- SERVER_LOG("Got error %s", err->c_str());
- else
- SERVER_LOG("Got it!");
- return !!service_handle_;
-}
-
-void PersistentService::Server::RunServerThenExit(
- const VersionCheckHandler& version_check_handler,
- const RequestHandler& request_handler) {
- std::string error;
- if (!service_handle_ && !BindService(&error)) {
- Error("Could not acquire service handle: %s", error.c_str());
- exit(1);
- }
- SERVER_LOG("Service handle acquired, starting server loop");
- RunServerThenExitInternal(version_check_handler, std::move(request_handler));
-}
-
-void PersistentService::Server::RunServerThenExitInternal(
- const VersionCheckHandler& version_check_handler,
- const RequestHandler& request_handler) {
- AsyncLoop& async_loop = AsyncLoop::Get();
- std::string error;
-#ifndef _WIN32
- SigPipeBlocker sig_pipe_blocker;
-#endif
-
- /// Convenience class to wait for client connections with a timeout.
- /// Usage is:
- ///
- /// 1) Create class, passing references to an IpcServiceHandle
- /// and an AsyncLoop instance.
- ///
- /// 2) Call Wait() to wait for a new connection.
- ///
- /// 3) Either destroy the instance, or call Close() before that to
- /// ensure the corresponding server handle is closed before
- /// calling exit().
- ///
- class ConnectionWaiter {
- public:
- /// Constructor sets up an internal AsyncHandle to do the wait.
- /// Note that this moves the native service handle into this instance, but
- /// |service_handle| still needs to be closed manually before calling
- /// ::exit(), because on MacOS it does extra work to remove a Unix socket
- /// and pid file.
- ConnectionWaiter(IpcServiceHandle& service_handle, AsyncLoop& async_loop)
- : async_loop_(async_loop), async_(
- AsyncHandle::Create(std::move(service_handle), async_loop, callback())) {}
-
- /// Wait for a new client connection for |timeout_ms| milliseconds.
- /// Return AsyncLoop exit status, on success, set |client| to receive
- /// the new client connection handle.
- AsyncLoop::ExitStatus Wait(int64_t timeout_ms, IpcHandle& client) {
- completed_ = false;
- accepted_ = false;
-
- int64_t now_ms = async_loop_.NowMs();
- (void)now_ms; // silence compiler when SERVER_LOG() expansion is empty.
-
- if (timeout_ms < 0) {
- SERVER_LOG("Waiting for new client connection (no timeout)");
- } else {
- SERVER_LOG("Waiting for new client connection (for up to %.1f seconds)",
- timeout_ms / 1000.);
- }
-
- async_.StartAccept();
- auto status = async_loop_.RunUntil([this]() { return completed_; },
- timeout_ms);
-
- if (accepted_)
- client = async_.TakeAcceptedHandle();
-
- SERVER_LOG("Connection time %s",
- StringFormatDurationMs(async_loop_.NowMs() - now_ms).c_str());
- return status;
- }
-
- /// Close the internal handle explicitly.
- void Close() {
- async_.Close();
- }
-
- private:
- AsyncLoop& async_loop_;
- AsyncHandle async_;
- IpcHandle client_;
- bool completed_ = false;
- bool accepted_ = false;
-
- // Return the AsyncHandle::Callback to be used by |async| in this instance.
- AsyncHandle::Callback callback() {
- return [this](AsyncError error, size_t) {
- completed_ = true;
- accepted_ = (error == 0);
- };
- }
- };
-
- ConnectionWaiter waiter(service_handle_, async_loop);
- while (true) {
- IpcHandle client;
- AsyncLoop::ExitStatus status = waiter.Wait(connection_timeout_ms_, client);
-
- if (status == AsyncLoop::ExitInterrupted)
- break;
-
- if (status == AsyncLoop::ExitTimeout) {
- SERVER_LOG("Timeout waiting for client connection");
- break;
- }
- if (!client) {
- SERVER_LOG("Could not accept new client: %s", error.c_str());
- break;
- }
-
- SERVER_LOG("Reading query type...");
- // Get command, which can be 'kill' or 'query' at the moment.
- uint8_t query_type = 0;
- if (!client.Read(&query_type, sizeof(query_type), &error)) {
- SERVER_LOG("Could not read client query type !?");
- break;
- }
-
- SERVER_LOG("Got query_type %d\n", query_type);
-
- if (query_type == kServerCommandTypeStop) {
- SERVER_LOG("Client asking server to stop!");
- break;
- }
- if (query_type == kServerCommandTypeGetPid) {
- SERVER_LOG("Client asking for server pid!");
-#ifdef _WIN32
- int pid = static_cast<int>(GetCurrentProcessId());
-#else
- int pid = getpid();
-#endif
- if (!RemoteWrite(pid, client, &error)) {
- SERVER_LOG("Could not send pid %d back to client!: %s", pid,
- error.c_str());
- break;
- }
- SERVER_LOG("Sent pid %d to client. Looping", pid);
- continue;
- }
- if (query_type != kServerCommandTypeClientQuery) {
- SERVER_LOG("Unknown client query type: %d", query_type);
- break;
- }
-
- SERVER_LOG("Accepted client connection, checking version info");
- std::string version_info;
- if (!RemoteRead(version_info, client, &error)) {
- SERVER_LOG("Could not client version info: %s", error.c_str());
- break;
- }
-
- std::string version_check = version_check_handler(version_info);
- if (!RemoteWrite(version_check, client, &error)) {
- SERVER_LOG("Could not write version check result to client: %s",
- error.c_str());
- break;
- }
-
- if (!version_check.empty()) {
- SERVER_LOG("Incompatible client version info: %s", version_check.c_str());
- break;
- }
-
- if (!request_handler(std::move(client))) {
- SERVER_LOG("Request handler returned false, exiting server loop");
- break;
- }
- async_loop.ClearInterrupt();
- }
- SERVER_LOG("Exiting!");
-
- // Since calling ::exit() directly here prevents the destructors
- // of the variables defined in this function from running, close the
- // waiter handle explicitly.
- waiter.Close();
-
- // Note: while the file descriptor was moved to waiter, this
- // instance must be destroyed explicitly to remove the pid file and
- // Unix socket filesystem entry on MacOS.
- service_handle_.Close();
-
- ::exit(0);
-}
diff --git a/src/persistent_service.h b/src/persistent_service.h
deleted file mode 100644
index d54e3f7..0000000
--- a/src/persistent_service.h
+++ /dev/null
@@ -1,212 +0,0 @@
-// Copyright 2023 Google Inc. All Rights Reserved.
-//
-// Licensed under the Apache License, Version 2.0 (the "License");
-// you may not use this file except in compliance with the License.
-// You may obtain a copy of the License at
-//
-// http://www.apache.org/licenses/LICENSE-2.0
-//
-// Unless required by applicable law or agreed to in writing, software
-// distributed under the License is distributed on an "AS IS" BASIS,
-// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-// See the License for the specific language governing permissions and
-// limitations under the License.
-
-#ifndef NINJA_PERSISTENT_SERVICE_H_
-#define NINJA_PERSISTENT_SERVICE_H_
-
-#include <functional>
-#include <memory>
-#include <string>
-#include <utility>
-#include <vector>
-
-#include "ipc_handle.h"
-
-/// PersistentService implements a "persistent server" mode for
-/// command-line executables. The main idea is that a client process
-/// uses an anonymous pipe (on Win32) or a Unix domain socket (on Posix)
-/// to connect to a server process, then ask for work to be done by
-/// the server on its behalf.
-///
-/// If a server is not available, the client process will automatically launch
-/// one, as a detached background process. Supports both Posix and Windows.
-///
-/// After creating an instance, usage on the client side is:
-///
-/// 1) Create a PersistentService::Config object describing how to launch
-/// the server, if needed.
-///
-/// 2) Call CreateClient() which will give an IpcHandle to communicate with
-/// the server from the current process.
-///
-///
-/// While usage on the server is:
-///
-/// 1) Call BindService() to immediately bind the service pipe/socket.
-/// This is optional, but is useful when the server needs to perform
-/// a long setup operation before serving client requests.
-///
-/// 2) Call RunServerThenExit() to enter an infinite loop to serve
-/// client queries. This takes two callable objects that will be invoked
-/// on each query.
-///
-
-class PersistentService {
- public:
- /// Convenience struct to hold the configuration used to spawn
- /// a new server. This includes a command line, optional working directory,
- /// and other options.
- struct Config {
- /// Constructor provides the command used to spawn the new server process.
- explicit Config(const std::vector<std::string>& server_command)
- : command(server_command) {}
-
- /// Set the working directory to be used when running the server process.
- /// If empty (the default), not change will be applied.
- Config& SetWorkingDir(const std::string& dir) {
- working_dir = dir;
- return *this;
- }
-
- /// By default, the server process redirects its stdin/stdout/stderr
- /// to /dev/null. Call this method to specify the path of a file where
- /// server logs will be written to instead.
- Config& SetLogFile(const std::string& log_file_path) {
- log_file = log_file_path;
- return *this;
- }
-
- /// Add an environment variable definition that will be set before
- /// spawning a server process.
- Config& AddEnvVariable(const char* name, const char* value) {
- env_vars.push_back(std::make_pair(name, value));
- return *this;
- }
-
- /// Set a string describing version information that will be matched
- /// against each new client connection. A mistmatch will be reported
- /// then the server will stop automatically.
- Config& SetVersionInfo(const std::string& info) {
- version_info = info;
- return *this;
- }
-
- std::vector<std::string> command;
- std::string working_dir;
- std::string version_info;
- std::string log_file;
- std::vector<std::pair<std::string, std::string>> env_vars;
- };
-
- ///////////////////////////////////////////////////////////////////////////
- ///
- /// C L I E N T S I D E
- ///
-
- class Client {
- public:
- /// Create new instance. This doesn't do anything yet.
- /// |service_name| is a unique service name, used to create a named pipe
- /// on the host system.
- explicit Client(const std::string& service_name);
-
- /// Destructor. Note that this does *not* kill any server instance
- /// started by this client.
- ~Client();
-
- /// Returns true if a server is already running for the service.
- bool HasServer() const;
-
- /// Return server PID if it exists, or -1 otherwise.
- int GetServerPid() const;
-
- /// Stop a server. Return true on success (meaning there was a server, and
- /// that it was asked to stop), and false otherwise. Note that the function
- /// returns immediately after sending the stop command. Use
- /// WaitForServerShutdown() to wait for its complete shutdown if needed.
- bool StopServer(std::string* err) const;
-
- /// Wait until the server is properly shutdown after a StopServer() call.
- /// Returns after 2 seconds max, return true on success, false otherwise.
- bool WaitForServerShutdown();
-
- /// Create new client connection. This will start a server automatically
- /// if one is not already running. If an existing server has incompatible
- /// version_info, it is also stopped and another instance restarted.
- ///
- /// In case of error, return an invalid IpcHandle and sets |*err|.
- /// In case of success, the result can be used to communicate with the
- /// server.
- IpcHandle Connect(const Config& config, std::string* err);
-
- private:
- IpcHandle RawConnect(std::string* err) const;
- IpcHandle ConnectOrStartServer(const Config& config,
- std::string* err) const;
-
- std::string service_name_;
- };
-
- ///////////////////////////////////////////////////////////////////////////
- ///
- /// S E R V E R S I D E
- ///
-
- class Server {
- public:
- /// Create new instance, |service_name| is the unique service name
- /// and |config| is the server configuration that will be used by the
- /// server.
- explicit Server(const std::string& service_name);
-
- /// Change the connection timeout, in milliseconds, used by a server
- /// loop when waiting for new client connections. On expiration, the server
- /// will shut down graciously. The default value (-1) means no timeout.
- void SetConnectionTimeoutMs(int64_t connection_timeout_ms) {
- connection_timeout_ms_ = connection_timeout_ms;
- }
-
- /// Bind to the service named pipe early. This is called implicitly by
- /// RunServerThenExit() but can be called earlier from a server process
- /// before expensive operations, in order to avoid races.
- bool BindService(std::string* err);
-
- /// A callable that receives a version_info string from the client and
- /// compares it to its own version. Returns an empty string when the
- /// versions are compatible, or a failure message otherwise.
- using VersionCheckHandler = std::function<std::string(const std::string&)>;
-
- /// A callable object that receives an IpcHandle corresponding to a new
- /// client request. Returns true to indicate that the server should keep
- /// running, or false to tell it to exit immediately.
- using RequestHandler = std::function<bool(IpcHandle)>;
-
- /// Start a server in the current process, then start a loop that waits for
- /// a client request. This function never returns (and calls exit() directly
- /// when needed).
- ///
- /// For each request, the client's Config::version_info string is received
- /// and passed to |version_check_handler| to verify that it is compatible
- /// with the client. If this callable returns a non-empty string, the loop
- /// exits after reporting the mismatch to the client.
- ///
- /// Otherwise, |request_handler| is invoked, receiving ownership of the
- /// client connection handle. If this returns true, the function exits.
- ///
- /// This function should only be called when starting a server executable.
- void RunServerThenExit(const VersionCheckHandler& version_check_handler,
- const RequestHandler& request_handler);
-
- private:
- void RunServerThenExitInternal(
- const VersionCheckHandler& version_check_handler,
- const RequestHandler& request_handler);
-
- std::string service_name_;
- int64_t connection_timeout_ms_ = -1;
- IpcServiceHandle service_handle_;
- };
-};
-
-#endif // NINJA_PERSISTENT_SERVICE_H_
diff --git a/src/persistent_service_test.cc b/src/persistent_service_test.cc
deleted file mode 100644
index 5fda0d5..0000000
--- a/src/persistent_service_test.cc
+++ /dev/null
@@ -1,134 +0,0 @@
-// Copyright 2023 Google Inc. All Rights Reserved.
-//
-// Licensed under the Apache License, Version 2.0 (the "License");
-// you may not use this file except in compliance with the License.
-// You may obtain a copy of the License at
-//
-// http://www.apache.org/licenses/LICENSE-2.0
-//
-// Unless required by applicable law or agreed to in writing, software
-// distributed under the License is distributed on an "AS IS" BASIS,
-// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-// See the License for the specific language governing permissions and
-// limitations under the License.
-
-#include "persistent_service.h"
-
-#include "persistent_service_test_lib.cc"
-#include "test.h"
-#include "util.h"
-
-#ifndef _WIN32
-#include <unistd.h> // For sleep()
-#endif
-
-static std::string kTestServiceName = persistent_service_test::kServiceName;
-
-class PersistentServiceServerTest : public ::testing::Test {
- public:
- PersistentServiceServerTest() : server(kTestServiceName) {}
-
- PersistentService::Server server;
-};
-
-class PersistentServiceClientTest : public ::testing::Test {
- public:
- PersistentServiceClientTest() : client(kTestServiceName) {}
-
- void TearDown() override {
- // Ensure any server process started by the test is stopped.
- if (!client.HasServer())
- return;
-
- std::string err;
- if (!client.StopServer(&err)) {
- fprintf(stderr, "\nERROR: %s", err.c_str());
- AddAssertionFailure();
- } else {
- if (!client.WaitForServerShutdown()) {
- fprintf(stderr, "\nERROR: Could not shutdown server!\n");
- AddAssertionFailure();
- }
- }
- }
-
- PersistentService::Client client;
-};
-
-TEST_F(PersistentServiceServerTest, BindService) {
- std::string error;
- EXPECT_TRUE(server.BindService(&error));
-
- PersistentService::Client client(kTestServiceName);
- EXPECT_TRUE(client.HasServer());
-}
-
-TEST_F(PersistentServiceClientTest, DefaultMode) {
- std::string error;
- auto config = persistent_service_test::GetServerConfig();
- IpcHandle conn = client.Connect(config, &error);
- if (!conn)
- fprintf(stderr, "ERROR [%s]\n", error.c_str());
- ASSERT_TRUE(conn);
-
- EXPECT_TRUE(client.HasServer());
-
- bool success = persistent_service_test::RunTest(conn, false, &error);
- if (!success)
- fprintf(stderr, "ERROR: %s\n", error.c_str());
- ASSERT_TRUE(success);
-
- EXPECT_TRUE(client.HasServer());
-
- success = persistent_service_test::RunTest(conn, true, &error);
- if (!success)
- fprintf(stderr, "ERROR: %s\n", error.c_str());
- ASSERT_TRUE(success);
-
- ASSERT_TRUE(client.WaitForServerShutdown());
- ASSERT_FALSE(client.HasServer());
-}
-
-TEST_F(PersistentServiceClientTest, WithConnectionTimeout) {
- std::string error;
- auto config = persistent_service_test::GetServerConfig();
- persistent_service_test::SetServiceConfigTimeoutMs(config, 100);
- IpcHandle conn = client.Connect(config, &error);
- if (!conn)
- fprintf(stderr, "ERROR [%s]\n", error.c_str());
- ASSERT_TRUE(conn);
-
- bool success = persistent_service_test::RunTest(conn, false, &error);
- if (!success)
- fprintf(stderr, "ERROR: %s\n", error.c_str());
- ASSERT_TRUE(success);
-
- conn.Close();
-
-#ifdef _WIN32
- ::Sleep(1000);
-#else
- ::sleep(1);
-#endif
- EXPECT_FALSE(client.HasServer());
-}
-
-TEST_F(PersistentServiceClientTest, WithDifferentVersion) {
- // First start an instance with the default version.
- std::string error;
- auto config = persistent_service_test::GetServerConfig();
- IpcHandle conn = client.Connect(config, &error);
- ASSERT_TRUE(conn);
- bool success = persistent_service_test::RunTest(conn, false, &error);
- ASSERT_TRUE(success);
- EXPECT_TRUE(client.HasServer());
-
- conn.Close();
-
- persistent_service_test::SetServiceConfigVersion(config, "another");
- conn = client.Connect(config, &error);
- if (!conn)
- fprintf(stderr, "ERROR: %s\n", error.c_str());
- EXPECT_TRUE(conn);
- EXPECT_TRUE(client.HasServer());
-}
diff --git a/src/persistent_service_test_helper.cc b/src/persistent_service_test_helper.cc
deleted file mode 100644
index b1e4eca..0000000
--- a/src/persistent_service_test_helper.cc
+++ /dev/null
@@ -1,56 +0,0 @@
-// Copyright 2023 Google Inc. All Rights Reserved.
-//
-// Licensed under the Apache License, Version 2.0 (the "License");
-// you may not use this file except in compliance with the License.
-// You may obtain a copy of the License at
-//
-// http://www.apache.org/licenses/LICENSE-2.0
-//
-// Unless required by applicable law or agreed to in writing, software
-// distributed under the License is distributed on an "AS IS" BASIS,
-// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-// See the License for the specific language governing permissions and
-// limitations under the License.
-
-#include <stdio.h>
-#include <stdlib.h>
-
-#include "persistent_service.h"
-#include "persistent_service_test_lib.cc"
-
-void PrintUsage(const char* progname) {
- fprintf(stderr, "Usage: %s [-t<timeout>] [-v<version>]\n", progname);
-}
-
-int main(int argc, char** argv) {
- const char* progname = argv[0];
- PersistentService::Server server(persistent_service_test::kServiceName);
-
- std::string version = persistent_service_test::kDefaultVersion;
-
- for (; argc > 1; --argc, argv++) {
- const char* arg = argv[1];
- if (arg[0] != '-') {
- PrintUsage(progname);
- return 1;
- }
-
- switch (arg[1]) {
- case 't': // -t<value> Server timeout in milliseconds.
- server.SetConnectionTimeoutMs(static_cast<int64_t>(atoll(arg + 2)));
- break;
- case 'v': // -v<version> is server version.
- version = arg + 2;
- break;
- default:
- PrintUsage(progname);
- return 1;
- }
- }
-
- server.RunServerThenExit(
- persistent_service_test::GetVersionCheckHandler(version),
- persistent_service_test::RequestHandler);
-
- return 0;
-}
diff --git a/src/persistent_service_test_lib.cc b/src/persistent_service_test_lib.cc
deleted file mode 100644
index 30735d4..0000000
--- a/src/persistent_service_test_lib.cc
+++ /dev/null
@@ -1,174 +0,0 @@
-// Copyright 2023 Google Inc. All Rights Reserved.
-//
-// Licensed under the Apache License, Version 2.0 (the "License");
-// you may not use this file except in compliance with the License.
-// You may obtain a copy of the License at
-//
-// http://www.apache.org/licenses/LICENSE-2.0
-//
-// Unless required by applicable law or agreed to in writing, software
-// distributed under the License is distributed on an "AS IS" BASIS,
-// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-// See the License for the specific language governing permissions and
-// limitations under the License.
-
-#include "persistent_service_test_lib.h"
-
-#include <inttypes.h>
-
-#include "ipc_utils.h"
-#include "persistent_service.h"
-#include "util.h"
-
-#define DEBUG 0
-
-// Common macros used to print a prefix then an message to stderr.
-#define STDERR_PRINTF(prefix, ...) \
- do { \
- fputs(prefix, stderr); \
- fprintf(stderr, __VA_ARGS__); \
- fputs("\n", stderr); \
- } while (0)
-
-#if DEBUG
-#define SERVER_LOG(...) STDERR_PRINTF("TEST_SERVER: ", __VA_ARGS__)
-#define CLIENT_LOG(...) STDERR_PRINTF("TEST_CLIENT: ", __VA_ARGS__)
-#else
-#define SERVER_LOG(...) (void)0
-#define CLIENT_LOG(...) (void)0
-#endif
-
-#define SERVER_ERR(...) STDERR_PRINTF("TEST_SERVER: ERROR: ", __VA_ARGS__)
-#define SERVER_WARN(...) STDERR_PRINTF("TEST_SERVER: WARNING: ", __VA_ARGS__)
-
-#define CLIENT_ERR(...) STDERR_PRINTF("TEST_CLIENT: ERROR: ", __VA_ARGS__)
-#define CLIENT_WARN(...) STDERR_PRINTF("TEST_CLIENT: WARNING: ", __VA_ARGS__)
-
-namespace {
-
-std::vector<std::string> GetServerArgs(const std::string* version) {
- std::vector<std::string> result;
- std::string program =
- GetCurrentExecutableDir() + "/persistent_service_test_helper";
-#ifdef _WIN32
- program.append(".exe");
-#endif
- result.push_back(std::move(program));
- if (version)
- result.push_back(*version);
- return result;
-}
-
-// This is necessary because RemoteWrite("ping", ...) will send a 5-byte
-// character sequence (including the terminating zero), instead of a
-// string size + its content.
-bool SendString(const char* str, IpcHandle& con, std::string* err) {
- return RemoteWrite(std::string(str), con, err);
-}
-
-} // namespace
-
-namespace persistent_service_test {
-
-const char kServiceName[] = "persistent-server-test";
-
-const char kDefaultVersion[] = "default-version";
-
-PersistentService::Config GetServerConfig() {
- PersistentService::Config config(GetServerArgs(nullptr));
- return config.SetVersionInfo(kDefaultVersion);
-}
-
-void SetServiceConfigVersion(PersistentService::Config& config,
- const std::string& version) {
- config.SetVersionInfo(version);
- config.command.push_back(StringFormat("-v%s", version.c_str()));
-}
-
-void SetServiceConfigTimeoutMs(PersistentService::Config& config,
- int64_t connection_timeout_ms) {
- config.command.push_back(StringFormat("-t%" PRId64, connection_timeout_ms));
-}
-
-PersistentService::Server::VersionCheckHandler GetVersionCheckHandler(
- const std::string& server_version_info) {
- return [server_version_info](
- const std::string& client_version_info) -> std::string {
- if (client_version_info != server_version_info) {
- return StringFormat("Version mismatch, expected [%s] got [%s]",
- server_version_info.c_str(),
- client_version_info.c_str());
- }
- return {};
- };
-}
-
-bool RequestHandler(IpcHandle connection) {
- std::string error;
- std::string request;
- bool is_first = true;
- while (true) {
- SERVER_LOG("Waiting for request");
- if (!RemoteRead(request, connection, &error)) {
- if (!is_first) {
- SERVER_LOG("Client connection closed");
- return true;
- }
- SERVER_ERR("Could not read request: %s\n", error.c_str());
- return false;
- }
- SERVER_LOG("Received request [%.*s]", (int)request.size(), request.c_str());
-
- is_first = false;
-
- if (request == "kill-server") {
- SERVER_LOG("TEST_SERVER: kill-server command received, exiting");
- return false;
- }
-
- if (request == "ping") {
- SERVER_LOG("TEST_SERVER: ping request received, sending reply");
- if (!SendString("pong", connection, &error)) {
- SERVER_ERR("Could not send reply: %s\n", error.c_str());
- return false;
- }
- SERVER_LOG("pong sent");
- continue;
- }
-
- SERVER_ERR("Unknown request [%s]\n", request.c_str());
- return false;
- }
-}
-
-bool RunTest(IpcHandle& client, bool kill_server, std::string* err) {
- if (!SendString("ping", client, err)) {
- CLIENT_ERR("Could not send test request: %s\n", err->c_str());
- return false;
- }
- std::string reply;
- if (!RemoteRead(reply, client, err)) {
- CLIENT_ERR("Could not receive test reply: %s\n", err->c_str());
- return false;
- }
-
- bool success = (reply == "pong");
- if (!success) {
- CLIENT_ERR("Invalid reply [%s] expected [pong]\n", reply.c_str());
- // Do not return here to ensure the server is killed.
- }
-
- if (kill_server) {
- if (!SendString("kill-server", client, err)) {
- CLIENT_ERR("Could not kill server: %s\n", err->c_str());
- }
-
- PersistentService::Client persistent(kServiceName);
- if (!persistent.WaitForServerShutdown()) {
- CLIENT_WARN("Could not wait for server shutdown\n");
- }
- }
- return success;
-}
-
-} // namespace persistent_service_test
diff --git a/src/persistent_service_test_lib.h b/src/persistent_service_test_lib.h
deleted file mode 100644
index 87431e1..0000000
--- a/src/persistent_service_test_lib.h
+++ /dev/null
@@ -1,61 +0,0 @@
-// Copyright 2023 Google Inc. All Rights Reserved.
-//
-// Licensed under the Apache License, Version 2.0 (the "License");
-// you may not use this file except in compliance with the License.
-// You may obtain a copy of the License at
-//
-// http://www.apache.org/licenses/LICENSE-2.0
-//
-// Unless required by applicable law or agreed to in writing, software
-// distributed under the License is distributed on an "AS IS" BASIS,
-// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-// See the License for the specific language governing permissions and
-// limitations under the License.
-
-#ifndef NINJA_PERSISTENT_SERVICE_TEST_LIB_H_
-#define NINJA_PERSISTENT_SERVICE_TEST_LIB_H_
-
-#include <string>
-#include <vector>
-
-#include "ipc_handle.h"
-
-namespace persistent_service_test {
-
-/// Name of persistent service name for the test.
-extern const char kServiceName[];
-
-/// Default PersistentService::Config::version_info as a C string.
-extern const char kDefaultVersion[];
-
-/// Return the server arguments to pass to PersistentService::Client::Connect()
-/// For this helper, this should only be the name of or path to the executable
-/// itself.
-PersistentService::Config GetServerConfig();
-
-/// Set a non-default service version information.
-/// information for the server.
-void SetServiceConfigVersion(PersistentService::Config& config,
- const std::string& version);
-
-/// Set the server connection timeout in milliseconds.
-void SetServiceConfigTimeoutMs(PersistentService::Config& config,
- int64_t connection_timeout_ms);
-
-/// Retrieve a VersionCheckHandler instance that expects client version info
-/// to match |server_version_info|.
-PersistentService::Server::VersionCheckHandler GetVersionCheckHandler(
- const std::string& server_version_info);
-
-/// Implement the request handler for the test handler.
-bool RequestHandler(IpcHandle connection);
-
-/// Run the test. Return true in case of success. In case of failure,
-/// set |*error| and return false. |client| is the handle returned
-/// PersistentService::CreateClient(). If |kill_server| is true, this also
-/// sends a command to kill the server and wait for its proper shutdown.
-bool RunTest(IpcHandle& client, bool kill_server, std::string* error);
-
-} // namespace persistent_service_test
-
-#endif // NINJA_PERSISTENT_SERVICE_TEST_LIB_H_
diff --git a/src/process_utils.cc b/src/process_utils.cc
deleted file mode 100644
index 81b574f..0000000
--- a/src/process_utils.cc
+++ /dev/null
@@ -1,282 +0,0 @@
-// Copyright 2023 Google Inc. All Rights Reserved.
-//
-// Licensed under the Apache License, Version 2.0 (the "License");
-// you may not use this file except in compliance with the License.
-// You may obtain a copy of the License at
-//
-// http://www.apache.org/licenses/LICENSE-2.0
-//
-// Unless required by applicable law or agreed to in writing, software
-// distributed under the License is distributed on an "AS IS" BASIS,
-// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-// See the License for the specific language governing permissions and
-// limitations under the License.
-
-#include "process_utils.h"
-
-#include <assert.h>
-
-#include <algorithm>
-
-#include "ipc_utils.h"
-#include "util.h"
-
-///////////////////////////////////////////////////////////////////////////
-///////////////////////////////////////////////////////////////////////////
-/////
-///// ScopedEnvironmentVariable
-/////
-
-ScopedEnvironmentVariable::ScopedEnvironmentVariable(const char* varname,
- const char* value)
- : varname_(varname) {
- const char* env = getenv(varname);
- if (env) {
- has_prev_value_ = true;
- prev_value_ = env;
- }
-#ifdef _WIN32
- // On Windows, setting the value to the empty string removes the variable.
- // The following check is to ensure that UnsetEnv() is always called when
- // trying to set an undefined |varname| to an empty |value|.
- if (value && value[0]) {
-#else
- if (value) {
-#endif
- if (SetEnv(varname_.c_str(), value) < 0)
- ErrnoFatal("setenv");
- } else {
- UnsetEnv(varname_.c_str());
- }
-}
-
-ScopedEnvironmentVariable::~ScopedEnvironmentVariable() {
- if (has_prev_value_) {
- SetEnv(varname_.c_str(), prev_value_.c_str());
- } else {
- UnsetEnv(varname_.c_str());
- }
-}
-
-ScopedEnvironmentVariable::ScopedEnvironmentVariable(
- ScopedEnvironmentVariable&&) noexcept = default;
-ScopedEnvironmentVariable& ScopedEnvironmentVariable::operator=(
- ScopedEnvironmentVariable&&) noexcept = default;
-
-int ScopedEnvironmentVariable::SetEnv(const char* varname, const char* value) {
-#ifdef _WIN32
- // There is no setenv() on Win32!?
- // _putenv_s() returns EINVAL in case of error, but also
- // sets errno, so convert errors to -1 here.
- return (_putenv_s(varname, value) == 0) ? 0 : -1;
-#else // !_WIN32
- return ::setenv(varname, value, 1);
-#endif // !_WIN32
-}
-
-void ScopedEnvironmentVariable::UnsetEnv(const char* varname) {
-#ifdef _WIN32
- _putenv_s(varname, "");
-#else // !_WIN32
- ::unsetenv(varname);
-#endif // !_WIN32
-}
-
-///////////////////////////////////////////////////////////////////////////
-///////////////////////////////////////////////////////////////////////////
-/////
-///// EnvironmentBlock
-/////
-
-EnvironmentBlock::EnvironmentBlock() = default;
-
-extern char** environ;
-
-// static
-EnvironmentBlock EnvironmentBlock::CreateFromCurrentEnvironment() {
- EnvironmentBlock result;
-
- for (const char* const* env = environ; *env; ++env) {
- std::string definition = *env;
- size_t pos = definition.find('=');
- if (pos == std::string::npos) {
- // Should not happen, ignore it.
- continue;
- }
-
- std::string varname = definition.substr(0, pos);
- std::string varvalue = definition.substr(pos + 1);
-
-#ifdef _WIN32
- // Empty values are not possible on Win32, so skip them on this platform
- // if we ever find them in the environ block.
- if (varvalue.empty())
- continue;
-#endif
- result.map_[varname] = varvalue;
- }
- return result;
-}
-
-void EnvironmentBlock::MergeWith(const EnvironmentBlock& other) {
- for (const auto& pair : other.map_)
- map_.emplace(pair.first, pair.second);
-}
-
-void EnvironmentBlock::Insert(const char* varname, const char* value) {
- if (!value)
- value = "";
- map_[std::string(varname)] = value;
-}
-
-void EnvironmentBlock::Remove(const char* varname) {
- map_.erase(std::string(varname));
-}
-
-const char* EnvironmentBlock::Get(const char* varname) const {
- auto it = map_.find(std::string(varname));
- if (it == map_.end())
- return nullptr;
- return it->second.c_str();
-}
-
-std::string EnvironmentBlock::ToEncodedString() const {
- auto definitions = GetDefinitions();
- WireEncoder encoder;
- encoder.Write(map_.size());
- for (const auto& pair : map_) {
- encoder.Write(pair.first);
- encoder.Write(pair.second);
- }
- return encoder.TakeResult();
-}
-
-// static
-EnvironmentBlock EnvironmentBlock::FromEncodedString(const std::string& encoded,
- std::string* error) {
- error->clear();
- EnvironmentBlock::MapType map;
- WireDecoder decoder(encoded);
- size_t count = 0;
- decoder.Read(count);
- for (; count > 0; --count) {
- std::string varname, varvalue;
- decoder.Read(varname);
- decoder.Read(varvalue);
- map.emplace(varname, std::move(varvalue));
- }
- EnvironmentBlock result;
- if (!decoder.has_error()) {
- result.map_ = std::move(map);
- } else {
- *error = "Truncated encoded EnvironmentBlock string";
- }
- return result;
-}
-
-std::string EnvironmentBlock::AsString() const {
- auto defs = GetDefinitions();
- std::string result = StringFormat("Environment(%zu)[\n", defs.list.size());
- for (const auto& def : defs.list)
- result += StringFormat(" %s\n", def.c_str());
- result += "]";
- return result;
-}
-
-bool EnvironmentBlock::operator==(const EnvironmentBlock& other) const {
- auto defs = GetDefinitions();
- auto other_defs = other.GetDefinitions();
- if (defs.total_size != other_defs.total_size)
- return false;
- if (defs.list.size() != other_defs.list.size())
- return false;
- auto other_it = other_defs.list.begin();
- for (const auto& def : defs.list) {
- if (def != *other_it)
- return false;
- ++other_it;
- }
- return true;
-}
-
-EnvironmentBlock::Definitions EnvironmentBlock::GetDefinitions() const {
- Definitions result;
- for (const auto& pair : map_) {
- result.list.push_back(pair.first + "=" + pair.second);
- result.total_size += result.list.back().size() + 1;
- }
- std::sort(result.list.begin(), result.list.end());
- return result;
-}
-
-#ifdef _WIN32
-char* EnvironmentBlock::AsAnsiEnvironmentBlock() const {
- auto definitions = GetDefinitions();
-
- block_.clear();
- block_.reserve(definitions.total_size + 1);
- for (const auto& def : definitions.list) {
- block_.append(def.c_str(), def.size() + 1);
- }
- block_ += '\0';
-
- return &block_[0];
-}
-
-wchar_t* EnvironmentBlock::AsUnicodeEnvironmentBlock() const {
- auto definitions = GetDefinitions();
-
- block_.clear();
- block_.reserve(definitions.total_size * 2 + 2);
- for (const auto& def : definitions.list) {
- std::wstring wdef = ConvertToUnicodeString(def);
- block_.append(reinterpret_cast<const char*>(wdef.c_str()),
- wdef.size() * 2 + 2);
- }
- block_ += '\0';
- block_ += '\0';
-
- return reinterpret_cast<wchar_t*>(&block_[0]);
-}
-
-#else // !_WIN32
-char** EnvironmentBlock::AsExecEnvironmentBlock() const {
- auto definitions = GetDefinitions();
- block_.clear();
- block_.reserve(definitions.total_size);
-
- env_.clear();
- env_.reserve(definitions.list.size() + 1);
- for (const auto& def : definitions.list) {
- char* dst = const_cast<char*>(block_.data()) + block_.size();
- env_.push_back(dst);
- block_.append(def.c_str(), def.size() + 1);
- }
- assert(block_.size() == definitions.total_size);
- env_.push_back(nullptr);
- return &env_.front();
-}
-#endif // !_WIN32
-
-// static
-std::vector<StringPiece> SplitCommaOrSpaceSeparatedList(StringPiece input) {
- std::vector<StringPiece> result;
- const char* p = input.str_;
- const char* end = p + input.len_;
-
- while (p < end) {
- // Find next variable name length.
- const char* q = p;
- while (q < end && *q != ' ' && *q != ',')
- q++;
-
- size_t len = q - p;
- if (len > 0)
- result.emplace_back(p, len);
- if (q == end)
- break;
-
- p = q + 1;
- }
- return result;
-}
diff --git a/src/process_utils.h b/src/process_utils.h
deleted file mode 100644
index 6723363..0000000
--- a/src/process_utils.h
+++ /dev/null
@@ -1,151 +0,0 @@
-// Copyright 2023 Google Inc. All Rights Reserved.
-//
-// Licensed under the Apache License, Version 2.0 (the "License");
-// you may not use this file except in compliance with the License.
-// You may obtain a copy of the License at
-//
-// http://www.apache.org/licenses/LICENSE-2.0
-//
-// Unless required by applicable law or agreed to in writing, software
-// distributed under the License is distributed on an "AS IS" BASIS,
-// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-// See the License for the specific language governing permissions and
-// limitations under the License.
-
-#ifndef NINJA_PROCESS_UTILS_H
-#define NINJA_PROCESS_UTILS_H
-
-#include <memory>
-#include <string>
-#include <unordered_map>
-#include <vector>
-
-#ifdef _WIN32
-#include <windows.h>
-#else
-#include <sys/types.h>
-#endif
-
-#include "string_piece.h"
-
-/// Convenience class to temporarily set the value of an environment variable
-/// in the current process.
-class ScopedEnvironmentVariable {
- public:
- /// Constructor sets the value of a given environment variable.
- /// Set |value| to nullptr to remove the variable from the environment.
- /// Note that on Windows, setting |value| to an empty string will also
- /// remove the value, while it will set it to the empty string on Posix.
- ScopedEnvironmentVariable(const char* varname, const char* value);
-
- /// Destructor restores the previous value.
- ~ScopedEnvironmentVariable();
-
- /// Allow move operations.
- ScopedEnvironmentVariable(ScopedEnvironmentVariable&&) noexcept;
- ScopedEnvironmentVariable& operator=(ScopedEnvironmentVariable&&) noexcept;
-
- private:
- int SetEnv(const char* varname, const char* value);
- void UnsetEnv(const char* varname);
-
- std::string varname_;
- std::string prev_value_;
-
- // On Posix, it is possible to set an environment variable to the empty value
- // while on Windows, this simply unsets / removes the variable. This flag is
- // only used on Posix to distinguish between these two cases.
- bool has_prev_value_ = false;
-};
-
-/// A convenience wrapper for a set of environment variables.
-class EnvironmentBlock {
- public:
- /// Default constructor creates an empty set.
- EnvironmentBlock();
-
- /// Create new instance from current process environment.
- static EnvironmentBlock CreateFromCurrentEnvironment();
-
- /// Merge with another instance. This only gets variables from |other|
- /// which were not set
- void MergeWith(const EnvironmentBlock& other);
-
- /// Add a given variable to the set, with its associated value.
- /// If the variable is already in the set, replace its value.
- void Insert(const char* varname, const char* value);
-
- /// Remove |varname| and its associated value from the set.
- void Remove(const char* varname);
-
- /// Return the value associated with |varname| in the set, or nullptr
- /// if it is not in it.
- const char* Get(const char* varname) const;
-
- /// Convert this instance to an encoded string, useful to send it
- /// to another process.
- std::string ToEncodedString() const;
-
- /// Decode a new instance from an encoded string. In case of
- /// failure, return an empty environment block, then set |*err|
- /// with an error message. On success |*err| is cleared to ease
- /// error handling on the client side.
- static EnvironmentBlock FromEncodedString(const std::string& encoded,
- std::string* err);
-
- /// Convert instance to string for debugging and testing only.
- std::string AsString() const;
-
- /// Compare for equality.
- bool operator==(const EnvironmentBlock& other) const;
-
- /// Compare for inequality.
- bool operator!=(const EnvironmentBlock& other) const {
- return !(*this == other);
- }
-
-#ifdef _WIN32
- /// Return the current instance as a Win32 environment block, which is
- /// a sequence of zero-terminated C strings, followed by a single zero
- /// (as in `FOO=foo<0>BAR=bar<0><0>`, this is the value expected by
- /// the `lpEnvironment` parameter of CreateProcessA.
- ///
- /// NOTE: The returned address belongs to the instance, but its content
- /// may become invalid after calling any other methods.
- char* AsAnsiEnvironmentBlock() const;
-
- /// Same as AsWin32AnsiEnvironmentBlock(), but uses Unicode characters
- /// instead. This is the format expected by CreateProcessW.
- ///
- /// NOTE: The returned address belongs to the instance, but its content
- /// may become invalid after calling any other methods.
- wchar_t* AsUnicodeEnvironmentBlock() const;
-#else // !_WIN32
- /// A pointer to an array of zero-terminated C string pointers, followed
- /// by a NULL pointer. This is the value expected by the execve() function.
- ///
- /// NOTE: The returned address belongs to the instance, but its content
- /// may become invalid after calling any other methods.
- char** AsExecEnvironmentBlock() const;
-#endif // !_WIN32
-
- private:
- struct Definitions {
- std::vector<std::string> list;
- size_t total_size = 0;
- };
- Definitions GetDefinitions() const;
-
- using MapType = std::unordered_map<std::string, std::string>;
- MapType map_;
- mutable std::string block_;
-#ifndef _WIN32
- mutable std::vector<char*> env_;
-#endif // !_WIN32
-};
-
-/// Split an input list separated by commas or spaces into separate items.
-/// Trailing, leading or duplicate separators are ignored.
-std::vector<StringPiece> SplitCommaOrSpaceSeparatedList(StringPiece list);
-
-#endif // NINJA_PROCESS_UTILS_H
diff --git a/src/process_utils_test.cc b/src/process_utils_test.cc
deleted file mode 100644
index 54ae84e..0000000
--- a/src/process_utils_test.cc
+++ /dev/null
@@ -1,243 +0,0 @@
-// Copyright 2023 Google Inc. All Rights Reserved.
-//
-// Licensed under the Apache License, Version 2.0 (the "License");
-// you may not use this file except in compliance with the License.
-// You may obtain a copy of the License at
-//
-// http://www.apache.org/licenses/LICENSE-2.0
-//
-// Unless required by applicable law or agreed to in writing, software
-// distributed under the License is distributed on an "AS IS" BASIS,
-// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-// See the License for the specific language governing permissions and
-// limitations under the License.
-
-#include "process_utils.h"
-
-#include <stdlib.h>
-
-#include <string>
-
-#include "test.h"
-
-TEST(ProcessUtils, ScopedEnvironmentVariable) {
- const char kVarName[] = "FOO_FOR_TEST";
- const char* prev_value = getenv(kVarName);
- ASSERT_FALSE(prev_value);
-
- {
- ScopedEnvironmentVariable scoped_var(kVarName, "");
-#ifdef _WIN32
- // On Windows, the variable was forcefully removed.
- ASSERT_FALSE(getenv(kVarName));
-#else
- // On Posix, the variable was set to the empty string.
- ASSERT_TRUE(getenv(kVarName));
- EXPECT_EQ(std::string(""), getenv(kVarName));
-#endif
- }
-
- {
- ScopedEnvironmentVariable scoped_var(kVarName, "value1");
- EXPECT_EQ(std::string("value1"), getenv(kVarName));
-
- {
- ScopedEnvironmentVariable scoped_var2(kVarName, "VALUE2");
- EXPECT_EQ(std::string("VALUE2"), getenv(kVarName));
- }
-
- {
- ScopedEnvironmentVariable scoped_var2(kVarName, "");
-#ifdef _WIN32
- ASSERT_FALSE(getenv(kVarName));
-#else
- ASSERT_TRUE(getenv(kVarName));
- EXPECT_EQ(std::string(""), getenv(kVarName));
-#endif
- }
-
- EXPECT_EQ(std::string("value1"), getenv(kVarName));
- }
-
- ASSERT_FALSE(getenv(kVarName));
-}
-
-TEST(ProcessUtils, EnvironmentBlockDefault) {
- EnvironmentBlock empty_block;
-#ifdef _WIN32
- char* b = empty_block.AsAnsiEnvironmentBlock();
- ASSERT_EQ(*b, '\0');
- ASSERT_EQ(empty_block, empty_block);
-
- wchar_t* wb = empty_block.AsUnicodeEnvironmentBlock();
- ASSERT_EQ(*wb, L'\0');
-#else // !_WIN32
- char** vec = empty_block.AsExecEnvironmentBlock();
- ASSERT_FALSE(vec[0]);
-#endif // !_WIN32
-
- EXPECT_EQ(empty_block.AsString(), "Environment(0)[\n]");
-}
-
-TEST(ProcessUtils, EnvironmentBlockFromCurrentEnvironment) {
- const char kDefinedVarName[] = "DEFINED_VARIABLE_FOR_NINJA_TEST";
- const char kUndefinedVarName[] = "UNDEFINED_VARIABLE_FOR_NINJA_TEST";
- ASSERT_FALSE(getenv(kDefinedVarName));
- ASSERT_FALSE(getenv(kUndefinedVarName));
-
- {
- ScopedEnvironmentVariable scoped_var(kDefinedVarName, "");
- EnvironmentBlock block = EnvironmentBlock::CreateFromCurrentEnvironment();
- EXPECT_FALSE(block.Get(kUndefinedVarName));
-#ifdef _WIN32
- ASSERT_FALSE(block.Get(kDefinedVarName));
-#else
- ASSERT_TRUE(block.Get(kDefinedVarName));
- EXPECT_EQ('\0', block.Get(kDefinedVarName)[0]);
-#endif
- }
-
- {
- EnvironmentBlock block = EnvironmentBlock::CreateFromCurrentEnvironment();
- EXPECT_FALSE(block.Get(kUndefinedVarName));
- EXPECT_FALSE(block.Get(kDefinedVarName));
- }
-}
-
-TEST(ProcessUtils, EnvironmentBlockMergeWith) {
- EnvironmentBlock block;
- block.Insert("foo", "FOO");
- block.Insert("bar", "BAR");
- block.Insert("qux", "");
- EXPECT_EQ(block.AsString(),
- "Environment(3)[\n bar=BAR\n foo=FOO\n qux=\n]");
-
- EXPECT_EQ(block, block);
-
- EnvironmentBlock block2;
- block2.Insert("foo", "NOT_FOO");
- block2.Insert("qux", "QUX");
- block2.Insert("zoo", "ZOO");
- EXPECT_EQ(block2.AsString(),
- "Environment(3)[\n foo=NOT_FOO\n qux=QUX\n zoo=ZOO\n]");
-
- EXPECT_EQ(block, block);
- EXPECT_NE(block, block2);
-
- block.MergeWith(block2);
- EXPECT_EQ(block.Get("foo"), std::string("FOO"));
- EXPECT_EQ(block.Get("bar"), std::string("BAR"));
- EXPECT_EQ(block.Get("qux"), std::string(""));
- ASSERT_TRUE(block.Get("zoo"));
- EXPECT_EQ(block.Get("zoo"), std::string("ZOO"));
-
- EXPECT_EQ(block.AsString(),
- "Environment(4)[\n bar=BAR\n foo=FOO\n qux=\n zoo=ZOO\n]");
-}
-
-#ifdef _WIN32
-
-TEST(ProcessUtils, EnvironmentBlockAsAnsiEnvironmentBlock) {
- EnvironmentBlock block;
- block.Insert("foo", "FOO");
- block.Insert("bar", "BARBAR");
- block.Insert("zoo", "");
-
- ASSERT_TRUE(block.Get("foo"));
- EXPECT_EQ(std::string("FOO"), block.Get("foo"));
- EXPECT_EQ(std::string("BARBAR"), block.Get("bar"));
- EXPECT_EQ(std::string(""), block.Get("zoo"));
-
- char* b = block.AsAnsiEnvironmentBlock();
- ASSERT_FALSE(::memcmp(b, "bar=BARBAR\0foo=FOO\0zoo=\0\0", 25));
-}
-
-TEST(ProcessUtils, EnvironmentBlockAsUnicodeEnvironmentBlock) {
- EnvironmentBlock block;
- block.Insert("foo", "FOO");
- block.Insert("bar", "BARBAR");
- block.Insert("zoo", "");
-
- ASSERT_TRUE(block.Get("foo"));
- EXPECT_EQ(std::string("FOO"), block.Get("foo"));
- EXPECT_EQ(std::string("BARBAR"), block.Get("bar"));
- EXPECT_EQ(std::string(""), block.Get("zoo"));
-
- wchar_t* wb = block.AsUnicodeEnvironmentBlock();
- ASSERT_FALSE(::wmemcmp(wb, L"bar=BARBAR\0foo=FOO\0zoo=\0\0", 25));
-}
-#else // !_WIN32
-TEST(ProcessUtils, EnvironmentBlockAsExecEnvironmentBlock) {
- EnvironmentBlock block;
- block.Insert("foo", "FOO");
- block.Insert("bar", "BARBAR");
- block.Insert("zoo", "");
-
- ASSERT_TRUE(block.Get("foo"));
- EXPECT_EQ(std::string("FOO"), block.Get("foo"));
- EXPECT_EQ(std::string("BARBAR"), block.Get("bar"));
- EXPECT_EQ(std::string(""), block.Get("zoo"));
-
- char** vec = block.AsExecEnvironmentBlock();
- ASSERT_TRUE(vec[0]);
- ASSERT_TRUE(vec[1]);
- ASSERT_TRUE(vec[2]);
- ASSERT_FALSE(vec[3]);
- EXPECT_EQ(std::string(vec[0]), "bar=BARBAR");
- EXPECT_EQ(std::string(vec[1]), "foo=FOO");
- EXPECT_EQ(std::string(vec[2]), "zoo=");
-}
-#endif // !_WIN32
-
-TEST(ProcessUtils, EnvironmentBlockToEncodedString) {
- EnvironmentBlock block;
- block.Insert("foo", "FOO");
- block.Insert("bar", "BARBAR");
- block.Insert("zoo", "");
- EXPECT_EQ(block.AsString(),
- "Environment(3)[\n bar=BARBAR\n foo=FOO\n zoo=\n]");
-
- std::string encoded = block.ToEncodedString();
- ASSERT_FALSE(encoded.empty());
-
- std::string error;
- auto block2 = EnvironmentBlock::FromEncodedString(encoded, &error);
- EXPECT_TRUE(error.empty());
- EXPECT_EQ(block.AsString(), block2.AsString());
-
- // Detect errors and return empty instance when decoding truncated string.
- auto block3 =
- EnvironmentBlock::FromEncodedString(encoded.substr(0, 10), &error);
- EXPECT_FALSE(error.empty());
- EXPECT_EQ(block3.AsString(), "Environment(0)[\n]");
-}
-
-TEST(ProcessUtils, SplitCommaOrSpaceSeparatedList) {
- std::vector<StringPiece> result;
-
- // Verify empty inputs.
- result = SplitCommaOrSpaceSeparatedList("");
- EXPECT_EQ(result.size(), 0u);
-
- result = SplitCommaOrSpaceSeparatedList(" ");
- EXPECT_EQ(result.size(), 0u);
-
- result = SplitCommaOrSpaceSeparatedList(" ,,, ");
- EXPECT_EQ(result.size(), 0u);
-
- result = SplitCommaOrSpaceSeparatedList(" foo,");
- EXPECT_EQ(result.size(), 1u);
- EXPECT_EQ(result[0].AsString(), "foo");
-
- result = SplitCommaOrSpaceSeparatedList("foo bar zoo");
- EXPECT_EQ(result.size(), 3u);
- EXPECT_EQ(result[0].AsString(), "foo");
- EXPECT_EQ(result[1].AsString(), "bar");
- EXPECT_EQ(result[2].AsString(), "zoo");
-
- result = SplitCommaOrSpaceSeparatedList(" foo,,bar zoo,");
- EXPECT_EQ(result.size(), 3u);
- EXPECT_EQ(result[0].AsString(), "foo");
- EXPECT_EQ(result[1].AsString(), "bar");
- EXPECT_EQ(result[2].AsString(), "zoo");
-}
diff --git a/src/stat_cache-posix.cc b/src/stat_cache-posix.cc
deleted file mode 100644
index 2855df3..0000000
--- a/src/stat_cache-posix.cc
+++ /dev/null
@@ -1,51 +0,0 @@
-// Copyright 2023 Google Inc. All Rights Reserved.
-//
-// Licensed under the Apache License, Version 2.0 (the "License");
-// you may not use this file except in compliance with the License.
-// You may obtain a copy of the License at
-//
-// http://www.apache.org/licenses/LICENSE-2.0
-//
-// Unless required by applicable law or agreed to in writing, software
-// distributed under the License is distributed on an "AS IS" BASIS,
-// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-// See the License for the specific language governing permissions and
-// limitations under the License.
-
-#include <errno.h>
-#include <string.h>
-#include <sys/stat.h>
-#include <sys/types.h>
-
-#include "stat_cache.h"
-#include "util.h"
-
-// This implementation calls stat() directly and never caches anything.
-class StatCache::Impl {
- public:
- void Enable(bool) {}
-
- TimeStamp Stat(const std::string& path, std::string* err) const {
- return ::GetFileTimestamp(path, err);
- }
-};
-
-StatCache::StatCache() : impl_(new StatCache::Impl()) {}
-
-StatCache::~StatCache() = default;
-
-void StatCache::Enable(bool enabled) {
- impl_->Enable(enabled);
-}
-
-void StatCache::Invalidate(const std::string&) {
- // Nothing to do here.
-}
-
-TimeStamp StatCache::Stat(const std::string& path, std::string* err) const {
- return impl_->Stat(path, err);
-}
-
-void StatCache::Sync() {}
-
-void StatCache::Flush() {}
diff --git a/src/stat_cache-win32.cc b/src/stat_cache-win32.cc
deleted file mode 100644
index 87bc053..0000000
--- a/src/stat_cache-win32.cc
+++ /dev/null
@@ -1,195 +0,0 @@
-// Copyright 2023 Google Inc. All Rights Reserved.
-//
-// Licensed under the Apache License, Version 2.0 (the "License");
-// you may not use this file except in compliance with the License.
-// You may obtain a copy of the License at
-//
-// http://www.apache.org/licenses/LICENSE-2.0
-//
-// Unless required by applicable law or agreed to in writing, software
-// distributed under the License is distributed on an "AS IS" BASIS,
-// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-// See the License for the specific language governing permissions and
-// limitations under the License.
-
-#include <windows.h>
-
-#include <algorithm>
-#include <map>
-
-#include "stat_cache.h"
-#include "util.h"
-
-namespace {
-
-bool IsPathSeparator(char ch) {
- return (ch == '/' || ch == '\\');
-}
-
-// Compute the dirname and basename of a given path.
-// If there is no directory separator, set |*dir| to ".".
-void DecomposePath(const std::string& path, std::string* dir,
- std::string* base) {
- size_t pos = path.size();
-
- // Find first directory separator before base name.
- while (pos > 0 && !IsPathSeparator(path[pos - 1]))
- --pos;
-
- *base = path.substr(pos);
-
- // Skip over separator(s) to find directory name, might be empty
- while (pos > 1 && IsPathSeparator(path[pos - 2]))
- --pos;
-
- *dir = path.substr(0, pos);
-}
-
-bool IsWindows7OrLater() {
- OSVERSIONINFOEX version_info = {
- sizeof(OSVERSIONINFOEX), 6, 1, 0, 0, { 0 }, 0, 0, 0, 0, 0
- };
- DWORDLONG comparison = 0;
- VER_SET_CONDITION(comparison, VER_MAJORVERSION, VER_GREATER_EQUAL);
- VER_SET_CONDITION(comparison, VER_MINORVERSION, VER_GREATER_EQUAL);
- return VerifyVersionInfo(&version_info, VER_MAJORVERSION | VER_MINORVERSION,
- comparison);
-}
-
-using DirCache = std::map<std::string, TimeStamp>;
-
-// TODO: Neither a map nor a hashmap seems ideal here. If the statcache
-// works out, come up with a better data structure.
-using Cache = std::map<std::string, DirCache>;
-
-bool StatAllFilesInDir(const std::string& dir, DirCache* stamps,
- std::string* err) {
- // FindExInfoBasic is 30% faster than FindExInfoStandard.
- static bool can_use_basic_info = IsWindows7OrLater();
- // This is not in earlier SDKs.
- const FINDEX_INFO_LEVELS kFindExInfoBasic =
- static_cast<FINDEX_INFO_LEVELS>(1);
- FINDEX_INFO_LEVELS level =
- can_use_basic_info ? kFindExInfoBasic : FindExInfoStandard;
- WIN32_FIND_DATAA ffd;
- HANDLE find_handle = FindFirstFileExA((dir + "\\*").c_str(), level, &ffd,
- FindExSearchNameMatch, NULL, 0);
-
- if (find_handle == INVALID_HANDLE_VALUE) {
- DWORD win_err = GetLastError();
- if (win_err == ERROR_FILE_NOT_FOUND || win_err == ERROR_PATH_NOT_FOUND ||
- win_err == ERROR_DIRECTORY)
- return true;
- *err = StringFormat("FindFirstFileExA(%s): %s", dir.c_str(),
- GetLastErrorString().c_str());
- return false;
- }
- do {
- std::string lowername = ffd.cFileName;
- if (lowername == "..") {
- // Seems to just copy the timestamp for ".." from ".", which is wrong.
- // This is the case at least on NTFS under Windows 7.
- continue;
- }
- std::transform(lowername.begin(), lowername.end(), lowername.begin(),
- ::tolower);
- // C++11 equivalent to
- // stamps->try_emplace(std::move(lowername), TimeStampFromFile(...))
- stamps->emplace(
- std::piecewise_construct, std::forward_as_tuple(std::move(lowername)),
- std::forward_as_tuple(TimeStampFromFileTime(ffd.ftLastWriteTime)));
- } while (FindNextFileA(find_handle, &ffd));
- FindClose(find_handle);
- return true;
-}
-
-} // namespace
-
-class StatCache::Impl {
- public:
- void Enable(bool enabled) {
- if (!enabled)
- cache_.clear();
-
- enabled_ = enabled;
- }
-
- TimeStamp Stat(const std::string& path, std::string* err) const {
- // MSDN: "Naming Files, Paths, and Namespaces"
- // http://msdn.microsoft.com/en-us/library/windows/desktop/aa365247(v=vs.85).aspx
- if (!path.empty() && path[0] != '\\' && path.size() > MAX_PATH) {
- *err = StringFormat("Stat(%s): Filename longer than %u characters",
- path.c_str(), MAX_PATH);
- return -1;
- }
- if (!enabled_)
- return ::GetFileTimestamp(path, err);
-
- std::string dir, base;
- DecomposePath(path, &dir, &base);
- if (base == "..") {
- // StatAllFilesInDir does not report any information for base = "..".
- base = ".";
- dir = path;
- }
-
- std::string dir_lowercase = dir;
- std::transform(dir.begin(), dir.end(), dir_lowercase.begin(), ::tolower);
- std::transform(base.begin(), base.end(), base.begin(), ::tolower);
-
- // NOTE: The following is the C++11 equivalent of
- // cache_.try_emplace(std::move(dir_lowercase))
- auto ret = cache_.emplace(std::piecewise_construct,
- std::forward_as_tuple(std::move(dir_lowercase)),
- std::forward_as_tuple());
- Cache::iterator ci = ret.first;
- if (ret.second) {
- if (!StatAllFilesInDir(dir.empty() ? "." : dir, &ci->second, err)) {
- cache_.erase(ci);
- return -1;
- }
- }
- DirCache::iterator di = ci->second.find(base);
- return di != ci->second.end() ? di->second : 0;
- }
-
- void Sync() {
- // TODO(digit): Implement this properly!
- // FOR NOW, drop everything from the cache to pass the unit-tests!
- cache_.clear();
- }
-
- void Flush() { cache_.clear(); }
-
- private:
- /// Whether stat information can be cached.
- bool enabled_ = false;
-
- /// The cache itself.
- mutable Cache cache_;
-};
-
-StatCache::StatCache() : impl_(new StatCache::Impl()) {}
-
-StatCache::~StatCache() = default;
-
-void StatCache::Enable(bool enabled) {
- impl_->Enable(enabled);
-}
-
-TimeStamp StatCache::Stat(const std::string& path, std::string* err) const {
- return impl_->Stat(path, err);
-}
-
-void StatCache::Invalidate(const std::string& path) {
- // TODO(digit): Only remove entries from the path's parent directory.
- impl_->Sync();
-}
-
-void StatCache::Sync() {
- impl_->Sync();
-}
-
-void StatCache::Flush() {
- impl_->Flush();
-}
diff --git a/src/stat_cache.h b/src/stat_cache.h
deleted file mode 100644
index 7d6322d..0000000
--- a/src/stat_cache.h
+++ /dev/null
@@ -1,56 +0,0 @@
-// Copyright 2023 Google Inc. All Rights Reserved.
-//
-// Licensed under the Apache License, Version 2.0 (the "License");
-// you may not use this file except in compliance with the License.
-// You may obtain a copy of the License at
-//
-// http://www.apache.org/licenses/LICENSE-2.0
-//
-// Unless required by applicable law or agreed to in writing, software
-// distributed under the License is distributed on an "AS IS" BASIS,
-// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-// See the License for the specific language governing permissions and
-// limitations under the License.
-
-#ifndef NINJA_STAT_CACHE_H_
-#define NINJA_STAT_CACHE_H_
-
-#include <memory>
-#include <string>
-
-#include "timestamp.h"
-
-/// Implement a cache for file path timestamps.
-class StatCache {
- public:
- /// Constructor
- StatCache();
-
- /// Destructor
- ~StatCache();
-
- /// Enable caching of timestamps. If false (the default), the Stat() performs
- /// a single stat() operation per file and no caching is performed.
- void Enable(bool enabled);
-
- /// Mark a path as invalid.
- void Invalidate(const std::string& path);
-
- /// Return the timestamp of a given file path. On error, set |*err| then
- /// return -1. Otherwise, return 0 if the file is missing, or a strictly
- /// positive value if it exists.
- TimeStamp Stat(const std::string& path, std::string* err) const;
-
- /// Synchronize the cache state with recent filesystem events.
- /// Call this before one or more Stat() calls.
- void Sync();
-
- /// Remove all entries from the cache.
- void Flush();
-
- private:
- class Impl;
- std::unique_ptr<Impl> impl_;
-};
-
-#endif // NINJA_STAT_CACHE_H_
diff --git a/src/stat_cache_test.cc b/src/stat_cache_test.cc
deleted file mode 100644
index f6b8455..0000000
--- a/src/stat_cache_test.cc
+++ /dev/null
@@ -1,128 +0,0 @@
-// Copyright 2023 Google Inc. All Rights Reserved.
-//
-// Licensed under the Apache License, Version 2.0 (the "License");
-// you may not use this file except in compliance with the License.
-// You may obtain a copy of the License at
-//
-// http://www.apache.org/licenses/LICENSE-2.0
-//
-// Unless required by applicable law or agreed to in writing, software
-// distributed under the License is distributed on an "AS IS" BASIS,
-// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-// See the License for the specific language governing permissions and
-// limitations under the License.
-
-#include "stat_cache.h"
-
-#include <stdio.h>
-
-#include "test.h"
-#include "util.h"
-
-namespace {
-
-void WriteFile(const std::string& path, const std::string& content) {
- FILE* f = fopen(path.c_str(), "wb");
- if (!f)
- ErrnoFatal("fopen", path.c_str());
-
- size_t ret = fwrite(content.c_str(), content.size(), 1, f);
- if (ret != 1)
- ErrnoFatal("Could not write to %s", path.c_str());
- fclose(f);
-}
-
-void RemoveFile(const std::string& path) {
- ::remove(path.c_str());
-}
-
-} // namespace
-
-TEST(StatCache, CheckMissingTimestamp) {
- ScopedTempDir temp_dir;
- temp_dir.CreateAndEnter("StatCacheTest");
- auto top_dir = GetCurrentDir();
-
- StatCache cache;
- cache.Enable(true);
-
- std::string err;
- TimeStamp t = cache.Stat(top_dir + "/foo", &err);
- EXPECT_EQ(0, t);
- EXPECT_TRUE(err.empty());
-
- t = cache.Stat(top_dir + "/bar", &err);
- EXPECT_EQ(0, t);
- EXPECT_TRUE(err.empty());
-
- // Try foo again, just in case.
- t = cache.Stat(top_dir + "/foo", &err);
- EXPECT_EQ(0, t);
- EXPECT_TRUE(err.empty());
-}
-
-TEST(StatCache, CheckExistingTimestamp) {
- ScopedTempDir temp_dir;
- temp_dir.CreateAndEnter("StatCacheTest");
- auto top_dir = GetCurrentDir();
-
- StatCache cache;
- cache.Enable(true);
-
- std::string foo_path = top_dir + "/foo";
-
- WriteFile(foo_path, "foo!!");
-
- std::string err;
- TimeStamp t = cache.Stat(foo_path, &err);
- EXPECT_GE(t, 0);
- EXPECT_TRUE(err.empty());
-}
-
-TEST(StatCache, CheckCreatedTimestamp) {
- ScopedTempDir temp_dir;
- temp_dir.CreateAndEnter("StatCacheTest");
- auto top_dir = GetCurrentDir();
-
- StatCache cache;
- cache.Enable(true);
-
- std::string foo_path = top_dir + "/foo";
-
- std::string err;
- TimeStamp t = cache.Stat(foo_path, &err);
- EXPECT_EQ(0, t);
- EXPECT_TRUE(err.empty());
-
- WriteFile(foo_path, "foo!!");
- cache.Sync();
-
- TimeStamp t2 = cache.Stat(foo_path, &err);
- EXPECT_NE(0, t2);
- EXPECT_TRUE(err.empty());
-}
-
-TEST(StatCache, CheckDeletedTimestamp) {
- ScopedTempDir temp_dir;
- temp_dir.CreateAndEnter("StatCacheTest");
- auto top_dir = GetCurrentDir();
-
- StatCache cache;
- cache.Enable(true);
-
- std::string foo_path = top_dir + "/foo";
- WriteFile(foo_path, "foo!!");
-
- std::string err;
- TimeStamp t = cache.Stat(foo_path, &err);
- EXPECT_NE(0, t);
- EXPECT_TRUE(err.empty());
-
- RemoveFile(foo_path);
-
- cache.Sync();
-
- TimeStamp t2 = cache.Stat(foo_path, &err);
- EXPECT_EQ(0, t2);
- EXPECT_TRUE(err.empty());
-}
diff --git a/src/state.cc b/src/state.cc
deleted file mode 100644
index e163599..0000000
--- a/src/state.cc
+++ /dev/null
@@ -1,238 +0,0 @@
-// Copyright 2011 Google Inc. All Rights Reserved.
-//
-// Licensed under the Apache License, Version 2.0 (the "License");
-// you may not use this file except in compliance with the License.
-// You may obtain a copy of the License at
-//
-// http://www.apache.org/licenses/LICENSE-2.0
-//
-// Unless required by applicable law or agreed to in writing, software
-// distributed under the License is distributed on an "AS IS" BASIS,
-// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-// See the License for the specific language governing permissions and
-// limitations under the License.
-
-#include "state.h"
-
-#include <assert.h>
-#include <stdio.h>
-
-#include "edit_distance.h"
-#include "graph.h"
-#include "metrics.h"
-#include "util.h"
-
-using namespace std;
-
-void Pool::EdgeScheduled(const Edge& edge) {
- if (depth_ != 0)
- current_use_ += edge.weight();
-}
-
-void Pool::EdgeFinished(const Edge& edge) {
- if (depth_ != 0)
- current_use_ -= edge.weight();
-}
-
-void Pool::DelayEdge(Edge* edge) {
- assert(depth_ != 0);
- delayed_.insert(edge);
-}
-
-void Pool::RetrieveReadyEdges(EdgeSet* ready_queue) {
- DelayedEdges::iterator it = delayed_.begin();
- while (it != delayed_.end()) {
- Edge* edge = *it;
- if (current_use_ + edge->weight() > depth_)
- break;
- ready_queue->insert(edge);
- EdgeScheduled(*edge);
- ++it;
- }
- delayed_.erase(delayed_.begin(), it);
-}
-
-void Pool::Dump() const {
- printf("%s (%d/%d) ->\n", name_.c_str(), current_use_, depth_);
- for (DelayedEdges::const_iterator it = delayed_.begin();
- it != delayed_.end(); ++it)
- {
- printf("\t");
- (*it)->Dump();
- }
-}
-
-void Pool::Reset() {
- current_use_ = 0;
- delayed_.clear();
-}
-
-State::State() {
- // Create top-level scope.
- bindings_.emplace_back(new BindingEnv());
-
- // Add the phony rule to it.
- phony_rule_ = new Rule("phony");
- bindings_[0]->AddRule(phony_rule_);
-
- // Create default and console pools.
- default_pool_ = new Pool("", 0);
- console_pool_ = new Pool("console", 1);
- AddPool(default_pool_);
- AddPool(console_pool_);
-}
-
-State::~State() {
- // Delete Edge instances.
- for (Edge* edge : edges_)
- delete edge;
-
- // Delete Node instances.
- for (auto& pair : paths_)
- delete pair.second;
-}
-
-void State::AddPool(Pool* pool) {
- auto ret = pools_.emplace(pool->name(), pool);
- assert(ret.second && "Duplicate pool insertion!");
-}
-
-Pool* State::LookupPool(const string& pool_name) {
- auto it = pools_.find(pool_name);
- if (it == pools_.end())
- return NULL;
- return it->second.get();
-}
-
-Edge* State::AddEdge(const Rule* rule) {
- Edge* edge = new Edge();
- edge->rule_ = rule;
- edge->pool_ = default_pool_;
- edge->env_ = bindings_[0].get();
- edge->id_ = edges_.size();
- edges_.push_back(edge);
- return edge;
-}
-
-Node* State::GetNode(StringPiece path, uint64_t slash_bits) {
- Node* node = LookupNode(path);
- if (node)
- return node;
- node = new Node(path.AsString(), slash_bits);
- paths_[node->path()] = node;
- return node;
-}
-
-Node* State::LookupNode(StringPiece path) const {
- Paths::const_iterator i = paths_.find(path);
- if (i != paths_.end())
- return i->second;
- return NULL;
-}
-
-Node* State::SpellcheckNode(const string& path) {
- const bool kAllowReplacements = true;
- const int kMaxValidEditDistance = 3;
-
- int min_distance = kMaxValidEditDistance + 1;
- Node* result = NULL;
- for (Paths::iterator i = paths_.begin(); i != paths_.end(); ++i) {
- int distance = EditDistance(
- i->first, path, kAllowReplacements, kMaxValidEditDistance);
- if (distance < min_distance && i->second) {
- min_distance = distance;
- result = i->second;
- }
- }
- return result;
-}
-
-void State::AddIn(Edge* edge, StringPiece path, uint64_t slash_bits) {
- Node* node = GetNode(path, slash_bits);
- node->set_generated_by_dep_loader(false);
- edge->inputs_.push_back(node);
- node->AddOutEdge(edge);
-}
-
-bool State::AddOut(Edge* edge, StringPiece path, uint64_t slash_bits) {
- Node* node = GetNode(path, slash_bits);
- if (node->in_edge())
- return false;
- edge->outputs_.push_back(node);
- node->set_in_edge(edge);
- node->set_generated_by_dep_loader(false);
- return true;
-}
-
-void State::AddValidation(Edge* edge, StringPiece path, uint64_t slash_bits) {
- Node* node = GetNode(path, slash_bits);
- edge->validations_.push_back(node);
- node->AddValidationOutEdge(edge);
- node->set_generated_by_dep_loader(false);
-}
-
-bool State::AddDefault(StringPiece path, string* err) {
- Node* node = LookupNode(path);
- if (!node) {
- *err = "unknown target '" + path.AsString() + "'";
- return false;
- }
- defaults_.push_back(node);
- return true;
-}
-
-vector<Node*> State::RootNodes(string* err) const {
- vector<Node*> root_nodes;
- // Search for nodes with no output.
- for (vector<Edge*>::const_iterator e = edges_.begin();
- e != edges_.end(); ++e) {
- for (vector<Node*>::const_iterator out = (*e)->outputs_.begin();
- out != (*e)->outputs_.end(); ++out) {
- if ((*out)->out_edges().empty())
- root_nodes.push_back(*out);
- }
- }
-
- if (!edges_.empty() && root_nodes.empty())
- *err = "could not determine root nodes of build graph";
-
- return root_nodes;
-}
-
-vector<Node*> State::DefaultNodes(string* err) const {
- return defaults_.empty() ? RootNodes(err) : defaults_;
-}
-
-BindingEnv* State::CreateNewEnv(BindingEnv* parent) {
- bindings_.emplace_back(new BindingEnv(parent));
- return bindings_.back().get();
-}
-
-void State::Reset() {
- METRIC_RECORD("state reset");
- for (auto& pair : pools_)
- pair.second->Reset();
- for (auto& pair : paths_)
- pair.second->ResetState();
- for (Edge* edge : edges_)
- edge->ResetState();
-}
-
-void State::Dump() {
- for (Paths::iterator i = paths_.begin(); i != paths_.end(); ++i) {
- Node* node = i->second;
- printf("%s %s [id:%d]\n",
- node->path().c_str(),
- node->status_known() ? (node->dirty() ? "dirty" : "clean")
- : "unknown",
- node->id());
- }
- if (!pools_.empty()) {
- printf("resource_pools:\n");
- for (const auto& pair : pools_) {
- if (!pair.second->name().empty()) {
- pair.second->Dump();
- }
- }
- }
-}
diff --git a/src/state.h b/src/state.h
deleted file mode 100644
index f965805..0000000
--- a/src/state.h
+++ /dev/null
@@ -1,190 +0,0 @@
-// Copyright 2011 Google Inc. All Rights Reserved.
-//
-// Licensed under the Apache License, Version 2.0 (the "License");
-// you may not use this file except in compliance with the License.
-// You may obtain a copy of the License at
-//
-// http://www.apache.org/licenses/LICENSE-2.0
-//
-// Unless required by applicable law or agreed to in writing, software
-// distributed under the License is distributed on an "AS IS" BASIS,
-// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-// See the License for the specific language governing permissions and
-// limitations under the License.
-
-#ifndef NINJA_STATE_H_
-#define NINJA_STATE_H_
-
-#include <map>
-#include <memory>
-#include <set>
-#include <string>
-#include <vector>
-
-#include "eval_env.h"
-#include "graph.h"
-#include "hash_map.h"
-#include "util.h"
-
-struct Edge;
-struct Node;
-struct Rule;
-
-/// A pool for delayed edges.
-/// Pools are scoped to a State. Edges within a State will share Pools. A Pool
-/// will keep a count of the total 'weight' of the currently scheduled edges. If
-/// a Plan attempts to schedule an Edge which would cause the total weight to
-/// exceed the depth of the Pool, the Pool will enqueue the Edge instead of
-/// allowing the Plan to schedule it. The Pool will relinquish queued Edges when
-/// the total scheduled weight diminishes enough (i.e. when a scheduled edge
-/// completes).
-struct Pool {
- Pool(const std::string& name, int depth)
- : name_(name), current_use_(0), depth_(depth),
- is_console_(name == "console"), delayed_() {}
-
- /// A depth of 0 is infinite
- bool is_valid() const { return depth_ >= 0; }
-
- /// Return true if this is the console pool.
- bool is_console() const { return is_console_; }
-
- int depth() const { return depth_; }
- const std::string& name() const { return name_; }
- int current_use() const { return current_use_; }
-
- /// true if the Pool might delay this edge
- bool ShouldDelayEdge() const { return depth_ != 0; }
-
- /// informs this Pool that the given edge is committed to be run.
- /// Pool will count this edge as using resources from this pool.
- void EdgeScheduled(const Edge& edge);
-
- /// informs this Pool that the given edge is no longer runnable, and should
- /// relinquish its resources back to the pool
- void EdgeFinished(const Edge& edge);
-
- /// adds the given edge to this Pool to be delayed.
- void DelayEdge(Edge* edge);
-
- /// Pool will add zero or more edges to the ready_queue
- void RetrieveReadyEdges(EdgeSet* ready_queue);
-
- /// Dump the Pool and its edges (useful for debugging).
- void Dump() const;
-
- /// Reset state.
- void Reset();
-
- private:
- std::string name_;
-
- /// |current_use_| is the total of the weights of the edges which are
- /// currently scheduled in the Plan (i.e. the edges in Plan::ready_).
- int current_use_;
- int depth_;
- bool is_console_;
-
- struct WeightedEdgeCmp {
- bool operator()(const Edge* a, const Edge* b) const {
- if (!a) return b;
- if (!b) return false;
- int weight_diff = a->weight() - b->weight();
- return ((weight_diff < 0) || (weight_diff == 0 && EdgeCmp()(a, b)));
- }
- };
-
- typedef std::set<Edge*, WeightedEdgeCmp> DelayedEdges;
- DelayedEdges delayed_;
-};
-
-/// Global state (file status) for a single run.
-struct State {
- State();
-
- ~State();
-
- State(State&&) noexcept = default;
- State& operator=(State&&) noexcept = default;
-
- State(const State&) = delete;
- State& operator=(const State&) = delete;
-
- /// Add pool instance, takes ownership.
- void AddPool(Pool* pool);
-
- Pool* LookupPool(const std::string& pool_name);
-
- /// Return pointer to the default pool. This one is always created implicitly.
- Pool* default_pool() const;
-
- /// Return pointer to the console_pool(). This one is always created
- /// implicitly.
- Pool* console_pool() const;
-
- /// Return pointer to phony rule. This one is always created implicitly.
- const Rule* phony_rule() const { return phony_rule_; }
-
- /// Allocate new Rule instance.
- Rule* NewRule(StringPiece name);
-
- Edge* AddEdge(const Rule* rule);
-
- Node* GetNode(StringPiece path, uint64_t slash_bits);
- Node* LookupNode(StringPiece path) const;
- Node* SpellcheckNode(const std::string& path);
-
- /// Add input / output / validation nodes to a given edge. This also
- /// ensure that the generated_by_dep_loader() flag for all these nodes
- /// is set to false, to indicate that they come from the input manifest.
- void AddIn(Edge* edge, StringPiece path, uint64_t slash_bits);
- bool AddOut(Edge* edge, StringPiece path, uint64_t slash_bits);
- void AddValidation(Edge* edge, StringPiece path, uint64_t slash_bits);
- bool AddDefault(StringPiece path, std::string* error);
-
- /// Reset state. Keeps all nodes and edges, but restores them to the
- /// state where we haven't yet examined the disk for dirty state.
- void Reset();
-
- /// Dump the nodes and Pools (useful for debugging).
- void Dump();
-
- /// @return the root node(s) of the graph. (Root nodes have no output edges).
- /// @param error where to write the error message if somethings went wrong.
- std::vector<Node*> RootNodes(std::string* error) const;
- std::vector<Node*> DefaultNodes(std::string* error) const;
-
- /// Create new BindingEnv instance.
- BindingEnv* CreateNewEnv(BindingEnv* parent);
-
- /// Return top-level BindingEnv instance.
- BindingEnv& bindings() const { return *bindings_[0]; }
-
- /// Mapping of path -> Node.
- /// NOTE: This owns all Node instances, but a DepsLog instance contains
- /// pointers to them as well.
- typedef ExternalStringHashMap<Node*>::Type Paths;
- Paths paths_;
-
- /// All the pools used in the graph.
- std::map<std::string, std::unique_ptr<Pool>> pools_;
-
- /// The default and console pools. These points to elements of pools_.
- Pool* default_pool_ = nullptr;
- Pool* console_pool_ = nullptr;
-
- /// All the edges of the graph.
- /// NOTE: This owns all Edge instances.
- std::vector<Edge*> edges_;
-
- Rule* phony_rule_ = nullptr;
-
- /// Note: BindingEnv need pointer stability (as they all include a parent
- /// pointer)
- std::vector<std::unique_ptr<BindingEnv>> bindings_;
-
- /// Points to elements of paths_.
- std::vector<Node*> defaults_;
-};
-
-#endif // NINJA_STATE_H_
diff --git a/src/state_test.cc b/src/state_test.cc
deleted file mode 100644
index 0bc1519..0000000
--- a/src/state_test.cc
+++ /dev/null
@@ -1,48 +0,0 @@
-// Copyright 2011 Google Inc. All Rights Reserved.
-//
-// Licensed under the Apache License, Version 2.0 (the "License");
-// you may not use this file except in compliance with the License.
-// You may obtain a copy of the License at
-//
-// http://www.apache.org/licenses/LICENSE-2.0
-//
-// Unless required by applicable law or agreed to in writing, software
-// distributed under the License is distributed on an "AS IS" BASIS,
-// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-// See the License for the specific language governing permissions and
-// limitations under the License.
-
-#include "graph.h"
-#include "state.h"
-#include "test.h"
-
-using namespace std;
-
-namespace {
-
-TEST(State, Basic) {
- State state;
-
- EvalString command;
- command.AddText("cat ");
- command.AddSpecial("in");
- command.AddText(" > ");
- command.AddSpecial("out");
-
- Rule* rule = new Rule("cat");
- rule->AddBinding("command", command);
- state.bindings().AddRule(rule);
-
- Edge* edge = state.AddEdge(rule);
- state.AddIn(edge, "in1", 0);
- state.AddIn(edge, "in2", 0);
- state.AddOut(edge, "out", 0);
-
- EXPECT_EQ("cat in1 in2 > out", edge->EvaluateCommand());
-
- EXPECT_FALSE(state.GetNode("in1", 0)->dirty());
- EXPECT_FALSE(state.GetNode("in2", 0)->dirty());
- EXPECT_FALSE(state.GetNode("out", 0)->dirty());
-}
-
-} // namespace
diff --git a/src/status.cc b/src/status.cc
deleted file mode 100644
index 378edc7..0000000
--- a/src/status.cc
+++ /dev/null
@@ -1,468 +0,0 @@
-// Copyright 2016 Google Inc. All Rights Reserved.
-//
-// Licensed under the Apache License, Version 2.0 (the "License");
-// you may not use this file except in compliance with the License.
-// You may obtain a copy of the License at
-//
-// http://www.apache.org/licenses/LICENSE-2.0
-//
-// Unless required by applicable law or agreed to in writing, software
-// distributed under the License is distributed on an "AS IS" BASIS,
-// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-// See the License for the specific language governing permissions and
-// limitations under the License.
-
-#include "status.h"
-
-#include <assert.h>
-#include <stdarg.h>
-#include <stdlib.h>
-
-#ifdef _WIN32
-#include <fcntl.h>
-#include <io.h>
-#undef min // min() is defined as a macro in minwindef.h
-#endif
-
-#include "async_loop.h"
-#include "build_config.h"
-#include "debug_flags.h"
-
-using namespace std;
-
-namespace {
-
-void StringAppendRate(std::string& str, double rate) {
- if (rate == -1)
- str.push_back('?');
- else
- StringAppendFormat(str, "%1.f", rate);
-}
-
-} // namespace
-
-StatusPrinter::StatusPrinter(const BuildConfig& config)
- : config_(config), started_edges_(0),
- finished_edges_(0), total_edges_(0), running_edges_(0), time_millis_(0),
- current_rate_(config.parallelism), format_(config_.status_format()) {
- // LinePrinter constructor uses these environment variables to determine
- // properties of the current terminal.
- printer_.Reset(config.environment.Get("TERM"),
- config.environment.Get("CLICOLOR_FORCE"));
-
- // Don't do anything fancy in verbose mode.
- if (config_.verbosity != BuildConfig::NORMAL)
- printer_.set_smart_terminal(false);
-
- if (printer_.is_smart_terminal() && !config_.dry_run) {
- max_pending_height_ = config_.status_max_commands();
-
- // Since elapsed times are displayed to the first decimal digit
- // only, there is no point in using a value smaller than 0.1 seconds
- // for the refresh timeout.
- const int64_t minimal_refresh_timeout_ms = 100;
- int64_t config_refresh = config_.status_refresh_millis();
- if (config_refresh && config_refresh > minimal_refresh_timeout_ms)
- refresh_timeout_ms_ = config_refresh;
- else
- refresh_timeout_ms_ = minimal_refresh_timeout_ms;
- }
-}
-
-StatusPrinter::~StatusPrinter() = default;
-
-void StatusPrinter::PlanHasTotalEdges(int total) {
- total_edges_ = total;
-}
-
-void StatusPrinter::BuildEdgeStarted(const Edge* edge) {
- int64_t start_time_millis = GetCurrentBuildTimeMs();
- ++started_edges_;
- ++running_edges_;
- time_millis_ = start_time_millis;
-
- pending_edges_[edge] = start_time_millis;
-
- if (edge->use_console()) {
- // This command will print its output directly to stdout, so
- // clear the pending edges to let Ninja update the status and
- // lock the line printer.
- DisableTimer();
- ClearPendingEdges();
- PrintStatus(edge, start_time_millis);
- printer_.SetConsoleLocked(true);
- } else if (printer_.is_smart_terminal()) {
- PrintStatus(edge, start_time_millis);
- BuildRefresh(start_time_millis);
- }
-}
-
-void StatusPrinter::BuildEdgeFinished(Edge* edge, bool success,
- const string& output) {
- int64_t end_time_millis = GetCurrentBuildTimeMs();
- time_millis_ = end_time_millis;
- ++finished_edges_;
-
- auto it = pending_edges_.find(edge);
- assert(it != pending_edges_.end());
- pending_edges_.erase(it);
-
- --running_edges_;
-
- if (edge->use_console()) {
- printer_.SetConsoleLocked(false);
- EnableTimer();
- }
-
- if (config_.verbosity == BuildConfig::QUIET)
- return;
-
- if (!edge->use_console()) {
- PrintStatus(edge, end_time_millis);
- if (success && output.empty()) {
- BuildRefresh(end_time_millis);
- } else {
- // Ninja is going to print something so clear
- // any pending edges first.
- ClearPendingEdges();
- }
- }
-
- // Print the command that is spewing before printing its output.
- if (!success) {
- string outputs;
- for (vector<Node*>::const_iterator o = edge->outputs_.begin();
- o != edge->outputs_.end(); ++o)
- outputs += (*o)->path() + " ";
-
- if (printer_.supports_color()) {
- printer_.PrintOnNewLine("\x1B[31m" "FAILED: " "\x1B[0m" + outputs + "\n");
- } else {
- printer_.PrintOnNewLine("FAILED: " + outputs + "\n");
- }
- printer_.PrintOnNewLine(edge->EvaluateCommand() + "\n");
- }
-
- if (!output.empty()) {
- // ninja sets stdout and stderr of subprocesses to a pipe, to be able to
- // check if the output is empty. Some compilers, e.g. clang, check
- // isatty(stderr) to decide if they should print colored output.
- // To make it possible to use colored output with ninja, subprocesses should
- // be run with a flag that forces them to always print color escape codes.
- // To make sure these escape codes don't show up in a file if ninja's output
- // is piped to a file, ninja strips ansi escape codes again if it's not
- // writing to a |smart_terminal_|.
- // (Launching subprocesses in pseudo ttys doesn't work because there are
- // only a few hundred available on some systems, and ninja can launch
- // thousands of parallel compile commands.)
- string final_output;
- if (!printer_.supports_color())
- final_output = StripAnsiEscapeCodes(output);
- else
- final_output = output;
-
-#ifdef _WIN32
- // Fix extra CR being added on Windows, writing out CR CR LF (#773)
- _setmode(_fileno(stdout), _O_BINARY); // Begin Windows extra CR fix
-#endif
-
- printer_.PrintOnNewLine(final_output);
-
-#ifdef _WIN32
- _setmode(_fileno(stdout), _O_TEXT); // End Windows extra CR fix
-#endif
- }
-}
-
-void StatusPrinter::BuildLoadDyndeps() {
- // The DependencyScan calls EXPLAIN() to print lines explaining why
- // it considers a portion of the graph to be out of date. Normally
- // this is done before the build starts, but our caller is about to
- // load a dyndep file during the build. Doing so may generate more
- // explanation lines (via fprintf directly to stderr), but in an
- // interactive console the cursor is currently at the end of a status
- // line. Start a new line so that the first explanation does not
- // append to the status line. After the explanations are done a
- // new build status line will appear.
- if (g_explaining) {
- ClearPendingEdges();
- printer_.PrintOnNewLine("");
- }
-}
-
-void StatusPrinter::DisableTimer() {
- if (timer_)
- timer_.Cancel();
-}
-
-void StatusPrinter::EnableTimer() {
- if (timer_)
- timer_.SetDurationMs(refresh_timeout_ms_);
-}
-
-int64_t StatusPrinter::GetCurrentBuildTimeMs() const {
- return AsyncLoop::NowMs() - start_build_time_ms_;
-}
-
-void StatusPrinter::BuildStarted() {
- started_edges_ = 0;
- finished_edges_ = 0;
- running_edges_ = 0;
-
- if (refresh_timeout_ms_ > 0) {
- if (!timer_) {
- start_build_time_ms_ = AsyncLoop::NowMs();
- timer_ = AsyncTimer::CreateWithDuration(
- refresh_timeout_ms_, AsyncLoop::Get(), [this] {
- int64_t cur_time_ms = GetCurrentBuildTimeMs();
- BuildRefresh(cur_time_ms);
- timer_.SetDurationMs(refresh_timeout_ms_);
- });
- }
- EnableTimer();
- }
-
- // Reset last_update_time_ms_ because this function can be called
- // multiple times, but with different starting epochs, which can
- // confuse the logic in this code. As an example: Ninja starts
- // a build then decides to launch the regenerator, which takes
- // about 5 seconds to generate a new build plan. Ninja then starts
- // another build. Without the reset, pending commands will not be
- // displayed for about 5 seconds after the start of the second
- // build!
- last_update_time_ms_ = -1;
-}
-
-void StatusPrinter::BuildFinished() {
- if (timer_) {
- timer_.Close();
- }
- start_build_time_ms_ = 0;
-
- printer_.SetConsoleLocked(false);
- ClearPendingEdges();
- printer_.PrintOnNewLine("");
-}
-
-string StatusPrinter::FormatProgressStatus(const char* progress_status_format,
- int64_t time_millis) const {
- string out;
- for (const char* s = progress_status_format; *s != '\0'; ++s) {
- if (*s == '%') {
- ++s;
- switch (*s) {
- case '%':
- out.push_back('%');
- break;
-
- // Started edges.
- case 's':
- StringAppendFormat(out, "%d", started_edges_);
- break;
-
- // Total edges.
- case 't':
- StringAppendFormat(out, "%d", total_edges_);
- break;
-
- // Running edges.
- case 'r':
- StringAppendFormat(out, "%d", running_edges_);
- break;
-
- // Unstarted edges.
- case 'u':
- StringAppendFormat(out, "%d", total_edges_ - started_edges_);
- break;
-
- // Finished edges.
- case 'f':
- StringAppendFormat(out, "%d", finished_edges_);
- break;
-
- // Overall finished edges per second.
- case 'o':
- StringAppendRate(out, finished_edges_ / (time_millis_ / 1e3));
- break;
-
- // Current rate, average over the last '-j' jobs.
- case 'c':
- current_rate_.UpdateRate(finished_edges_, time_millis_);
- StringAppendRate(out, current_rate_.rate());
- break;
-
- // Percentage
- case 'p': {
- int percent = (100 * finished_edges_) / total_edges_;
- StringAppendFormat(out, "%3i%%", percent);
- break;
- }
-
- case 'e':
- StringAppendFormat(out, "%.3f", time_millis_ / 1e3);
- break;
-
- default:
- Fatal("unknown placeholder '%%%c' in $NINJA_STATUS", *s);
- return "";
- }
- } else {
- out.push_back(*s);
- }
- }
-
- return out;
-}
-
-void StatusPrinter::PrintStatus(const Edge* edge, int64_t time_millis) {
- if (config_.verbosity == BuildConfig::QUIET
- || config_.verbosity == BuildConfig::NO_STATUS_UPDATE)
- return;
-
- bool force_full_command = config_.verbosity == BuildConfig::VERBOSE;
-
- string to_print = edge->GetBinding("description");
- if (to_print.empty() || force_full_command)
- to_print = edge->GetBinding("command");
-
- to_print = FormatProgressStatus(format_.c_str(), time_millis) +
- to_print;
-
- last_status_ = std::move(to_print);
-
- printer_.Print(last_status_,
- force_full_command ? LinePrinter::FULL : LinePrinter::ELIDE);
-}
-
-void StatusPrinter::BuildRefresh(int64_t cur_time_ms) {
- if (last_update_time_ms_ >= 0) {
- int64_t since_last_ms = cur_time_ms - last_update_time_ms_;
- if (since_last_ms < refresh_timeout_ms_) {
- // No need to update more than necessary when tasks complete
- // really really fast.
- return;
- }
- }
- last_update_time_ms_ = cur_time_ms;
- PrintPendingEdges(cur_time_ms);
-}
-
-void StatusPrinter::ClearPendingEdges() {
- if (last_pending_height_ == 0)
- return;
-
- // repeat "go down 1 line; erase whole line" |last_height_| times.
- for (size_t n = 0; n < last_pending_height_; ++n) {
- printf("\x1B[1B\x1B[2K");
- }
- // move up |last_height_| lines.
- printf("\x1B[%dA", static_cast<int>(last_pending_height_));
- fflush(stdout);
-
- last_pending_height_ = 0;
-}
-
-void StatusPrinter::PrintPendingEdges(int64_t cur_time_ms) {
- if (!max_pending_height_)
- return;
-
- // Find the N-th older running edges, where N is max_height_.
- // Reuse the sorted_pending_edges_ vector between calls.
- auto& sorted_edges = sorted_pending_edges_;
- sorted_edges.assign(pending_edges_.begin(), pending_edges_.end());
-
- auto less = [](const EdgeInfo& a, const EdgeInfo& b) -> bool {
- return a.second < b.second;
- };
- size_t count = std::min(sorted_edges.size(), max_pending_height_);
-
- std::partial_sort(sorted_edges.begin(), sorted_edges.begin() + count,
- sorted_edges.end(), less);
-
- std::string pending_line;
- for (size_t n = 0; n < count; ++n) {
- EdgeInfo& pair = sorted_edges[n];
-
- // Format the elapsed time in a human friendly format.
- std::string elapsed;
- int64_t elapsed_ms = cur_time_ms - pair.second;
- if (elapsed_ms < 0) {
- elapsed = "??????";
- } else {
- if (elapsed_ms < 60000) {
- StringAppendFormat(elapsed, "%d.%ds",
- static_cast<int>((elapsed_ms / 1000)),
- static_cast<int>((elapsed_ms % 1000) / 100));
- } else {
- StringAppendFormat(elapsed, "%dm%ds",
- static_cast<int>((elapsed_ms / 60000)),
- static_cast<int>((elapsed_ms % 60000) / 1000));
- }
- }
-
- // Get edge description or command.
- std::string description = pair.first->GetBinding("description");
- if (description.empty())
- description = pair.first->GetBinding("command");
-
- // Format '<elapsed> | <description>' where <elapsed> is
- // right-justified.
- size_t justification_width = 6;
- size_t justified_elapsed_width =
- std::min(justification_width, elapsed.size());
- size_t needed_capacity = justified_elapsed_width + 3 + description.size();
- if (needed_capacity > pending_line.capacity())
- pending_line.reserve(needed_capacity);
- if (elapsed.size() < justification_width) {
- pending_line.assign(justification_width - elapsed.size(), ' ');
- } else {
- pending_line.clear();
- }
- pending_line.append(elapsed);
- pending_line.append(" | ", 3);
- pending_line.append(description);
-
- printf("\n");
- printer_.Print(pending_line, LinePrinter::ELIDE);
- }
-
- // Clear previous lines that are not needed anymore.
- size_t next_height = count;
- for (; count < last_pending_height_; ++count) {
- // Go to next line + clear entire line.
- printf("\n\x1B[2K");
- }
-
- if (count > 0) {
- // Move up to the top status line. Then print the status
- // again to reposition the cursor to the right position.
- // Note that using ASCII sequences to save/restore the
- // cursor position does not work reliably in all terminals
- // (and terminal emulators like mosh or asciinema).
- printf("\x1B[%dA", static_cast<int>(count));
- printer_.Print(last_status_, LinePrinter::ELIDE);
- }
-
- last_pending_height_ = next_height;
-}
-
-void StatusPrinter::Warning(const char* msg, ...) {
- va_list ap;
- va_start(ap, msg);
- ::Warning(msg, ap);
- va_end(ap);
-}
-
-void StatusPrinter::Error(const char* msg, ...) {
- va_list ap;
- va_start(ap, msg);
- ::Error(msg, ap);
- va_end(ap);
-}
-
-void StatusPrinter::Info(const char* msg, ...) {
- va_list ap;
- va_start(ap, msg);
- ::Info(msg, ap);
- va_end(ap);
-}
diff --git a/src/status.h b/src/status.h
deleted file mode 100644
index 3c6119a..0000000
--- a/src/status.h
+++ /dev/null
@@ -1,147 +0,0 @@
-// Copyright 2016 Google Inc. All Rights Reserved.
-//
-// Licensed under the Apache License, Version 2.0 (the "License");
-// you may not use this file except in compliance with the License.
-// You may obtain a copy of the License at
-//
-// http://www.apache.org/licenses/LICENSE-2.0
-//
-// Unless required by applicable law or agreed to in writing, software
-// distributed under the License is distributed on an "AS IS" BASIS,
-// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-// See the License for the specific language governing permissions and
-// limitations under the License.
-
-#ifndef NINJA_STATUS_H_
-#define NINJA_STATUS_H_
-
-#include <memory>
-#include <queue>
-#include <string>
-#include <unordered_map>
-
-#include "async_loop.h"
-#include "build.h"
-#include "line_printer.h"
-
-/// Abstract interface to object that tracks the status of a build:
-/// completion fraction, printing updates.
-struct Status {
- virtual void PlanHasTotalEdges(int total) = 0;
- virtual void BuildEdgeStarted(const Edge* edge) = 0;
- virtual void BuildEdgeFinished(Edge* edge, bool success,
- const std::string& output) = 0;
- virtual void BuildLoadDyndeps() = 0;
- virtual void BuildStarted() = 0;
- virtual void BuildFinished() = 0;
-
- virtual void Info(const char* msg, ...) = 0;
- virtual void Warning(const char* msg, ...) = 0;
- virtual void Error(const char* msg, ...) = 0;
-
- virtual ~Status() { }
-};
-
-/// Implementation of the Status interface that prints the status as
-/// human-readable strings to stdout
-struct StatusPrinter : Status {
- explicit StatusPrinter(const BuildConfig& config);
- void PlanHasTotalEdges(int total) override;
- void BuildEdgeStarted(const Edge* edge) override;
- void BuildEdgeFinished(Edge* edge, bool success,
- const std::string& output) override;
- void BuildLoadDyndeps() override;
- void BuildStarted() override;
- void BuildFinished() override;
-
- void Info(const char* msg, ...) override;
- void Warning(const char* msg, ...) override;
- void Error(const char* msg, ...) override;
-
- virtual ~StatusPrinter();
-
- /// Format the progress status string by replacing the placeholders.
- /// See the user manual for more information about the available
- /// placeholders.
- /// @param progress_status_format The format of the progress status.
- /// @param status The status of the edge.
- std::string FormatProgressStatus(const char* progress_status_format,
- int64_t time_millis) const;
-
- private:
- void PrintStatus(const Edge* edge, int64_t time_millis);
-
- void BuildRefresh(int64_t current_time_ms);
- void EnableTimer();
- void DisableTimer();
-
- int64_t GetCurrentBuildTimeMs() const;
-
- const BuildConfig& config_;
-
- int started_edges_, finished_edges_, total_edges_, running_edges_;
- int64_t time_millis_;
-
- /// Prints progress output.
- LinePrinter printer_;
-
- /// The custom progress status format to use.
- const char* progress_status_format_;
-
- struct SlidingRateInfo {
- SlidingRateInfo(int n) : rate_(-1), N(n), last_update_(-1) {}
-
- double rate() { return rate_; }
-
- void UpdateRate(int update_hint, int64_t time_millis) {
- if (update_hint == last_update_)
- return;
- last_update_ = update_hint;
-
- if (times_.size() == N)
- times_.pop();
- times_.push(time_millis);
- if (times_.back() != times_.front())
- rate_ = times_.size() / ((times_.back() - times_.front()) / 1e3);
- }
-
- private:
- double rate_;
- const size_t N;
- std::queue<double> times_;
- int last_update_;
- };
-
- /// Called to refresh the pending list if needed.
- void BuildRefresh();
-
- mutable SlidingRateInfo current_rate_;
-
- /// Support for printing pending edges below the status on smart terminals.
- void PrintPendingEdges(int64_t cur_time_millis);
- void ClearPendingEdges();
-
- std::string format_;
- int64_t refresh_timeout_ms_ = -1;
- size_t max_pending_height_ = 0;
- size_t last_pending_height_ = 0;
- int64_t start_build_time_ms_ = 0;
- int64_t last_update_time_ms_ = -1;
- std::string last_status_;
-
- AsyncLoop* async_loop_ = nullptr;
- AsyncTimer timer_;
-
- // Record pending edges
- using EdgeMap = std::unordered_map<const Edge*, int64_t>;
- EdgeMap pending_edges_;
-
- // Used on each PrintPendingEdges() call to minimize heap allocations.
- // Note that EdgeMap::value_type.first has type |const Edge* const| and
- // thus EdgeMap::value_type is not copyable and cannot be used as an
- // std::vector<> item type.
- using EdgeInfo = std::pair<const Edge*, int64_t>;
- std::vector<EdgeInfo> sorted_pending_edges_;
-};
-
-#endif // NINJA_STATUS_H_
diff --git a/src/status_test.cc b/src/status_test.cc
deleted file mode 100644
index 9d94e8b..0000000
--- a/src/status_test.cc
+++ /dev/null
@@ -1,36 +0,0 @@
-// Copyright 2011 Google Inc. All Rights Reserved.
-//
-// Licensed under the Apache License, Version 2.0 (the "License");
-// you may not use this file except in compliance with the License.
-// You may obtain a copy of the License at
-//
-// http://www.apache.org/licenses/LICENSE-2.0
-//
-// Unless required by applicable law or agreed to in writing, software
-// distributed under the License is distributed on an "AS IS" BASIS,
-// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-// See the License for the specific language governing permissions and
-// limitations under the License.
-
-#include "status.h"
-
-#include "build_config.h"
-#include "test.h"
-
-TEST(StatusTest, StatusFormatElapsed) {
- BuildConfig config;
- StatusPrinter status(config);
-
- status.BuildStarted();
- // Before any task is done, the elapsed time must be zero.
- EXPECT_EQ("[%/e0.000]",
- status.FormatProgressStatus("[%%/e%e]", 0));
-}
-
-TEST(StatusTest, StatusFormatReplacePlaceholder) {
- BuildConfig config;
- StatusPrinter status(config);
-
- EXPECT_EQ("[%/s0/t0/r0/u0/f0]",
- status.FormatProgressStatus("[%%/s%s/t%t/r%r/u%u/f%f]", 0));
-}
diff --git a/src/stdio_redirection.cc b/src/stdio_redirection.cc
deleted file mode 100644
index 246a9bb..0000000
--- a/src/stdio_redirection.cc
+++ /dev/null
@@ -1,137 +0,0 @@
-// Copyright 2023 Google Inc. All Rights Reserved.
-//
-// Licensed under the Apache License, Version 2.0 (the "License");
-// you may not use this file except in compliance with the License.
-// You may obtain a copy of the License at
-//
-// http://www.apache.org/licenses/LICENSE-2.0
-//
-// Unless required by applicable law or agreed to in writing, software
-// distributed under the License is distributed on an "AS IS" BASIS,
-// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-// See the License for the specific language governing permissions and
-// limitations under the License.
-
-#include "stdio_redirection.h"
-
-#include <thread>
-
-#include "util.h"
-
-StdioRedirector::StdioRedirector(IpcHandle& connection)
- : connection_(connection) {}
-
-StdioRedirector::~StdioRedirector() {
- auto do_close = [](IpcHandle& old_handle, FILE* stream) {
- if (old_handle) {
- old_handle.CloneIntoStdio(stream);
- old_handle.Close();
- };
- };
- fflush(stderr);
- do_close(old_stderr_, stderr);
-
- fflush(stdout);
- do_close(old_stdout_, stdout);
-
- do_close(old_stdin_, stdin);
-}
-
-bool StdioRedirector::SendStandardDescriptors(std::string* err) {
- auto do_send = [this, err](FILE* stream) -> bool {
- return connection_.SendNativeHandle(IpcHandle::NativeForStdio(stream), err);
- };
- return do_send(stdin) && do_send(stdout) && do_send(stderr);
-}
-
-bool StdioRedirector::ReceiveStandardDescriptors(std::string* err) {
- auto do_receive = [this, err](FILE* stream, IpcHandle& old_handle) {
- IpcHandle new_handle;
- if (!connection_.ReceiveNativeHandle(&new_handle, err))
- return false;
- if (!new_handle) {
- *err = "Received invalid standard descriptor";
- return false;
- }
- old_handle = IpcHandle::CloneFromStdio(stream);
- if (!old_handle) {
- *err = "Could not save current standard descriptor";
- return false;
- }
- if (!new_handle.CloneIntoStdio(stream)) {
- *err = "Could not redirect standard descriptor";
- return false;
- }
- return true;
- };
- return do_receive(stdin, old_stdin_) && do_receive(stdout, old_stdout_) &&
- do_receive(stderr, old_stderr_);
-}
-
-StdioAsyncStringRedirector::StdioAsyncStringRedirector(AsyncLoop& async_loop,
- FILE* stream)
- : stream_(stream), saved_handle_(IpcHandle::CloneFromStdio(stream)),
- async_loop_(async_loop) {
- fflush(stream_);
- IpcHandle read_handle, write_handle;
- std::string error;
- if (!IpcHandle::CreateAsyncPipe(&read_handle, &write_handle, &error))
- Fatal("ScopedBufferingStdio::CreatePipe: %s", error.c_str());
-
- // Ensure the read handle is never copied to remote processes.
- // IpcHandle::Clone() returns a new instance with CLOEXEC on Posix.
- read_handle.SetInheritable(false);
-
- read_handle_ = AsyncHandle::Create(std::move(read_handle), async_loop_,
- [this](AsyncError error, size_t size) {
- if (error || size == 0) {
- Close();
- } else {
- result_.append(buffer_, size);
- read_handle_.StartRead(buffer_, sizeof(buffer_));
- }
- });
- read_handle_.StartRead(buffer_, sizeof(buffer_));
-
-#ifndef _WIN32
- // Ensure the write handle is in blocking mode since it will be
- // used as the new stdio descriptor.
- write_handle.SetNonBlocking(false);
-#endif
- write_handle.CloneIntoStdio(stream_);
- write_handle.Close();
-}
-
-StdioAsyncStringRedirector::~StdioAsyncStringRedirector() {
- Close();
- Restore();
-}
-
-void StdioAsyncStringRedirector::Restore() {
- fflush(stream_);
- if (saved_handle_) {
- saved_handle_.CloneIntoStdio(stream_);
- saved_handle_.Close();
- }
-}
-
-bool StdioAsyncStringRedirector::IsActive() const {
- if (!read_handle_.IsRunning())
- return false;
-
- async_loop_.RunOnce(0);
- return read_handle_.IsRunning();
-}
-
-bool StdioAsyncStringRedirector::WaitForResult(std::string* result,
- int64_t timeout_ms) {
- Restore();
- auto status =
- async_loop_.RunUntil([this]() { return !read_handle_; }, timeout_ms);
- *result = result_;
- return status != AsyncLoop::ExitTimeout;
-}
-
-void StdioAsyncStringRedirector::Close() {
- read_handle_.Close();
-}
diff --git a/src/stdio_redirection.h b/src/stdio_redirection.h
deleted file mode 100644
index 631f76e..0000000
--- a/src/stdio_redirection.h
+++ /dev/null
@@ -1,141 +0,0 @@
-// Copyright 2023 Google Inc. All Rights Reserved.
-//
-// Licensed under the Apache License, Version 2.0 (the "License");
-// you may not use this file except in compliance with the License.
-// You may obtain a copy of the License at
-//
-// http://www.apache.org/licenses/LICENSE-2.0
-//
-// Unless required by applicable law or agreed to in writing, software
-// distributed under the License is distributed on an "AS IS" BASIS,
-// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-// See the License for the specific language governing permissions and
-// limitations under the License.
-
-#ifndef NINJA_STDIO_REDIRECTION_H_
-#define NINJA_STDIO_REDIRECTION_H_
-
-#include <stdio.h>
-
-#include <string>
-
-#include "async_loop.h"
-#include "ipc_handle.h"
-
-/// Multiple classes related to redirecting stdio streams.
-
-/// A class used to manage redirection of stdin/stdout/stderr
-/// between two processes, using an IpcHandle for communication.
-///
-/// IMPORTANT: THIS DOES NOT WORK ON WINDOWS. Due to Win32
-/// technical limitations (i.e. DuplicateHandle() will always
-/// fail to duplicate console handlers from another process,
-/// which happens during ReceiveStandardDescriptors).
-///
-/// Usage is:
-/// 1) Create instance, passing a reference to the handle.
-///
-/// 2) On the client, call SendStandardDescriptors() to send
-/// standard descriptors to the server. This does not change
-/// the current process.
-///
-/// 3) On the server, call ReceiveStandardDescriptors() to
-/// receive them from the handle, and modify the process'
-/// current standard descriptors to use them.
-///
-/// 4) The destructor will restore the previous standard
-/// descriptors, in the case where ReceiveStandardDescriptors()
-/// was called.
-///
-class StdioRedirector {
- public:
- StdioRedirector(IpcHandle& connection);
- ~StdioRedirector();
-
- bool SendStandardDescriptors(std::string* err);
- bool ReceiveStandardDescriptors(std::string* err);
-
- protected:
- IpcHandle& connection_;
- IpcHandle old_stdin_;
- IpcHandle old_stdout_;
- IpcHandle old_stderr_;
-};
-
-/// A class used to redirect an stdout or stderr to a string buffer.
-/// temporarily. Only use this for testing for small outputs, as
-/// its implementation relies on async i/o on an anonymous pipe
-/// for properly reading the data. In practice, a blocking printf()
-/// call will deadlock if the pipe fills up entirely!
-///
-/// Usage is:
-/// - Create instance, passing an AsyncLoop reference and
-/// the stdout or stderr FILE pointer.
-///
-/// - Do small fprintf() or fputs() of the stream, the data
-/// will be sent to the pipe, if this happens on the same
-/// thread than the one running the AsyncLoop, a deadlock
-/// will happen when the pipe is full!
-///
-/// - Call Restore() to restore the stdio stream to its
-/// previous state. This does not destroyed data in the
-/// pipe or in the buffer.
-///
-/// - Call WaitForResult() to receive the result after
-/// draining the pipe completely. This calls Restore()
-/// implicitly.
-///
-class StdioAsyncStringRedirector {
- public:
- /// Constructor flushes |stream|, which must be stdout or stderr,
- /// then redirects its underlying file descriptor / handle to the
- /// write end of a pipe, whose read end is managed by this instance
- /// using asynchronous read operations. |async_loop| is a reference
- /// to the global AsyncLoop instance.
- ///
- /// On Posix, the write end is in blocking mode and does _not_
- /// close on exec(), intentionally, allowing it to be passed
- /// to other processes during fork() + exec().
- StdioAsyncStringRedirector(AsyncLoop& async_loop, FILE* stream);
-
- /// Destructor restores previous stream handle.
- ~StdioAsyncStringRedirector();
-
- /// Flush the stream, close it, then restore its previous handle.
- /// Can be called multiple times safely. Invoked implicitly by
- /// the destructor and by WaitForResult().
- void Restore();
-
- /// Return true if the write end of the pipe has not been closed.
- /// Note that normally Restore() closes it, unless another handle
- /// exists on the system pointing to the pipe's write end
- /// (e.g. when stdout was passed to another process).
- bool IsActive() const;
-
- /// Call Restore() then return buffered result after waiting
- /// at most |timeout_ms| for the pipe's write end to be closed
- /// (which may be prevented by another active file descriptor
- /// pointing to it, e.g. when stdout was passed to another
- /// process before this call).
- ///
- /// Set |*result| to the buffered output. Return true in case of
- /// success, meaning the pipe is closed and the result is
- /// complete, or false in case of timeout, meaning the result
- /// might be incomplete, since there is no guarantee that the
- /// peer has properly flushed its stdout.
- bool WaitForResult(std::string* result, int64_t timeout_ms = 1000);
-
- private:
- void StartRead();
- void Close();
-
- FILE* stream_;
- int stream_fd_;
- IpcHandle saved_handle_;
- AsyncLoop& async_loop_;
- AsyncHandle read_handle_;
- std::string result_;
- char buffer_[256]; // TODO(digit): Read directly into |result_|.
-};
-
-#endif // NINJA_STDIO_REDIRECTION_H_
diff --git a/src/stdio_redirection_test.cc b/src/stdio_redirection_test.cc
deleted file mode 100644
index 80fb941..0000000
--- a/src/stdio_redirection_test.cc
+++ /dev/null
@@ -1,53 +0,0 @@
-// Copyright 2023 Google Inc. All Rights Reserved.
-//
-// Licensed under the Apache License, Version 2.0 (the "License");
-// you may not use this file except in compliance with the License.
-// You may obtain a copy of the License at
-//
-// http://www.apache.org/licenses/LICENSE-2.0
-//
-// Unless required by applicable law or agreed to in writing, software
-// distributed under the License is distributed on an "AS IS" BASIS,
-// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-// See the License for the specific language governing permissions and
-// limitations under the License.
-
-#include "stdio_redirection.h"
-
-#include "async_loop.h"
-#include "test.h"
-
-TEST(StdioAsyncStringRedirector, Test) {
- auto async_loop = AsyncLoop::CreateLocal();
- std::string result;
- {
- StdioAsyncStringRedirector async_stdout(*async_loop, stdout);
- // IMPORTANT: Do not include \n in the input because fprintf()
- // may or may not translate that into \r\n depending on too many
- // factors to handle here.
- fprintf(stdout, "Hello!");
- EXPECT_TRUE(async_stdout.WaitForResult(&result));
- }
- EXPECT_EQ(result, "Hello!");
-}
-
-TEST(StdioAsyncStringRedirector, TestWithTimeout) {
- auto async_loop = AsyncLoop::CreateLocal();
- std::string result;
- bool ret;
- IpcHandle duplicate_stdout_fd;
- {
- StdioAsyncStringRedirector async_stdout(*async_loop, stdout);
- fprintf(stdout, "Hello!");
- fflush(stdout);
-
- // Duplicate stdout handle, which will prevent the internal
- // pipe to be closed properly by WaitForResult() which will
- // timeout after 10ms.
- duplicate_stdout_fd = IpcHandle::CloneFromStdio(stdout);
- ret = async_stdout.WaitForResult(&result, 10LL);
- }
- EXPECT_FALSE(ret);
- EXPECT_TRUE(duplicate_stdout_fd);
- EXPECT_EQ(result, "Hello!");
-}
diff --git a/src/string_piece.h b/src/string_piece.h
deleted file mode 100644
index 1c0bee6..0000000
--- a/src/string_piece.h
+++ /dev/null
@@ -1,70 +0,0 @@
-// Copyright 2011 Google Inc. All Rights Reserved.
-//
-// Licensed under the Apache License, Version 2.0 (the "License");
-// you may not use this file except in compliance with the License.
-// You may obtain a copy of the License at
-//
-// http://www.apache.org/licenses/LICENSE-2.0
-//
-// Unless required by applicable law or agreed to in writing, software
-// distributed under the License is distributed on an "AS IS" BASIS,
-// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-// See the License for the specific language governing permissions and
-// limitations under the License.
-
-#ifndef NINJA_STRINGPIECE_H_
-#define NINJA_STRINGPIECE_H_
-
-#include <string>
-
-#include <string.h>
-
-/// StringPiece represents a slice of a string whose memory is managed
-/// externally. It is useful for reducing the number of std::strings
-/// we need to allocate.
-struct StringPiece {
- typedef const char* const_iterator;
-
- StringPiece() : str_(NULL), len_(0) {}
-
- /// The constructors intentionally allow for implicit conversions.
- StringPiece(const std::string& str) : str_(str.data()), len_(str.size()) {}
- StringPiece(const char* str) : str_(str), len_(strlen(str)) {}
-
- StringPiece(const char* str, size_t len) : str_(str), len_(len) {}
-
- bool operator==(const StringPiece& other) const {
- return len_ == other.len_ && memcmp(str_, other.str_, len_) == 0;
- }
-
- bool operator!=(const StringPiece& other) const {
- return !(*this == other);
- }
-
- /// Convert the slice into a full-fledged std::string, copying the
- /// data into a new string.
- std::string AsString() const {
- return len_ ? std::string(str_, len_) : std::string();
- }
-
- const_iterator begin() const {
- return str_;
- }
-
- const_iterator end() const {
- return str_ + len_;
- }
-
- char operator[](size_t pos) const {
- return str_[pos];
- }
-
- size_t size() const {
- return len_;
- }
-
- const char* str_;
- size_t len_;
-};
-
-#endif // NINJA_STRINGPIECE_H_
diff --git a/src/string_piece_util.cc b/src/string_piece_util.cc
deleted file mode 100644
index 69513f5..0000000
--- a/src/string_piece_util.cc
+++ /dev/null
@@ -1,78 +0,0 @@
-// Copyright 2017 Google Inc. All Rights Reserved.
-//
-// Licensed under the Apache License, Version 2.0 (the "License");
-// you may not use this file except in compliance with the License.
-// You may obtain a copy of the License at
-//
-// http://www.apache.org/licenses/LICENSE-2.0
-//
-// Unless required by applicable law or agreed to in writing, software
-// distributed under the License is distributed on an "AS IS" BASIS,
-// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-// See the License for the specific language governing permissions and
-// limitations under the License.
-
-#include "string_piece_util.h"
-
-#include <algorithm>
-#include <string>
-#include <vector>
-using namespace std;
-
-vector<StringPiece> SplitStringPiece(StringPiece input, char sep) {
- vector<StringPiece> elems;
- elems.reserve(count(input.begin(), input.end(), sep) + 1);
-
- StringPiece::const_iterator pos = input.begin();
-
- for (;;) {
- const char* next_pos = find(pos, input.end(), sep);
- if (next_pos == input.end()) {
- elems.push_back(StringPiece(pos, input.end() - pos));
- break;
- }
- elems.push_back(StringPiece(pos, next_pos - pos));
- pos = next_pos + 1;
- }
-
- return elems;
-}
-
-string JoinStringPiece(const vector<StringPiece>& list, char sep) {
- if (list.empty()) {
- return "";
- }
-
- string ret;
-
- {
- size_t cap = list.size() - 1;
- for (size_t i = 0; i < list.size(); ++i) {
- cap += list[i].len_;
- }
- ret.reserve(cap);
- }
-
- for (size_t i = 0; i < list.size(); ++i) {
- if (i != 0) {
- ret += sep;
- }
- ret.append(list[i].str_, list[i].len_);
- }
-
- return ret;
-}
-
-bool EqualsCaseInsensitiveASCII(StringPiece a, StringPiece b) {
- if (a.len_ != b.len_) {
- return false;
- }
-
- for (size_t i = 0; i < a.len_; ++i) {
- if (ToLowerASCII(a.str_[i]) != ToLowerASCII(b.str_[i])) {
- return false;
- }
- }
-
- return true;
-}
diff --git a/src/string_piece_util.h b/src/string_piece_util.h
deleted file mode 100644
index 28470f1..0000000
--- a/src/string_piece_util.h
+++ /dev/null
@@ -1,33 +0,0 @@
-// Copyright 2017 Google Inc. All Rights Reserved.
-//
-// Licensed under the Apache License, Version 2.0 (the "License");
-// you may not use this file except in compliance with the License.
-// You may obtain a copy of the License at
-//
-// http://www.apache.org/licenses/LICENSE-2.0
-//
-// Unless required by applicable law or agreed to in writing, software
-// distributed under the License is distributed on an "AS IS" BASIS,
-// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-// See the License for the specific language governing permissions and
-// limitations under the License.
-
-#ifndef NINJA_STRINGPIECE_UTIL_H_
-#define NINJA_STRINGPIECE_UTIL_H_
-
-#include <string>
-#include <vector>
-
-#include "string_piece.h"
-
-std::vector<StringPiece> SplitStringPiece(StringPiece input, char sep);
-
-std::string JoinStringPiece(const std::vector<StringPiece>& list, char sep);
-
-inline char ToLowerASCII(char c) {
- return (c >= 'A' && c <= 'Z') ? (c + ('a' - 'A')) : c;
-}
-
-bool EqualsCaseInsensitiveASCII(StringPiece a, StringPiece b);
-
-#endif // NINJA_STRINGPIECE_UTIL_H_
diff --git a/src/string_piece_util_test.cc b/src/string_piece_util_test.cc
deleted file mode 100644
index 61586dd..0000000
--- a/src/string_piece_util_test.cc
+++ /dev/null
@@ -1,131 +0,0 @@
-// Copyright 2017 Google Inc. All Rights Reserved.
-//
-// Licensed under the Apache License, Version 2.0 (the "License");
-// you may not use this file except in compliance with the License.
-// You may obtain a copy of the License at
-//
-// http://www.apache.org/licenses/LICENSE-2.0
-//
-// Unless required by applicable law or agreed to in writing, software
-// distributed under the License is distributed on an "AS IS" BASIS,
-// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-// See the License for the specific language governing permissions and
-// limitations under the License.
-
-#include "string_piece_util.h"
-
-#include "test.h"
-
-using namespace std;
-
-TEST(StringPieceUtilTest, SplitStringPiece) {
- {
- string input("a:b:c");
- vector<StringPiece> list = SplitStringPiece(input, ':');
-
- EXPECT_EQ(list.size(), 3);
-
- EXPECT_EQ(list[0], "a");
- EXPECT_EQ(list[1], "b");
- EXPECT_EQ(list[2], "c");
- }
-
- {
- string empty;
- vector<StringPiece> list = SplitStringPiece(empty, ':');
-
- EXPECT_EQ(list.size(), 1);
-
- EXPECT_EQ(list[0], "");
- }
-
- {
- string one("a");
- vector<StringPiece> list = SplitStringPiece(one, ':');
-
- EXPECT_EQ(list.size(), 1);
-
- EXPECT_EQ(list[0], "a");
- }
-
- {
- string sep_only(":");
- vector<StringPiece> list = SplitStringPiece(sep_only, ':');
-
- EXPECT_EQ(list.size(), 2);
-
- EXPECT_EQ(list[0], "");
- EXPECT_EQ(list[1], "");
- }
-
- {
- string sep(":a:b:c:");
- vector<StringPiece> list = SplitStringPiece(sep, ':');
-
- EXPECT_EQ(list.size(), 5);
-
- EXPECT_EQ(list[0], "");
- EXPECT_EQ(list[1], "a");
- EXPECT_EQ(list[2], "b");
- EXPECT_EQ(list[3], "c");
- EXPECT_EQ(list[4], "");
- }
-}
-
-TEST(StringPieceUtilTest, JoinStringPiece) {
- {
- string input("a:b:c");
- vector<StringPiece> list = SplitStringPiece(input, ':');
-
- EXPECT_EQ("a:b:c", JoinStringPiece(list, ':'));
- EXPECT_EQ("a/b/c", JoinStringPiece(list, '/'));
- }
-
- {
- string empty;
- vector<StringPiece> list = SplitStringPiece(empty, ':');
-
- EXPECT_EQ("", JoinStringPiece(list, ':'));
- }
-
- {
- vector<StringPiece> empty_list;
-
- EXPECT_EQ("", JoinStringPiece(empty_list, ':'));
- }
-
- {
- string one("a");
- vector<StringPiece> single_list = SplitStringPiece(one, ':');
-
- EXPECT_EQ("a", JoinStringPiece(single_list, ':'));
- }
-
- {
- string sep(":a:b:c:");
- vector<StringPiece> list = SplitStringPiece(sep, ':');
-
- EXPECT_EQ(":a:b:c:", JoinStringPiece(list, ':'));
- }
-}
-
-TEST(StringPieceUtilTest, ToLowerASCII) {
- EXPECT_EQ('a', ToLowerASCII('A'));
- EXPECT_EQ('z', ToLowerASCII('Z'));
- EXPECT_EQ('a', ToLowerASCII('a'));
- EXPECT_EQ('z', ToLowerASCII('z'));
- EXPECT_EQ('/', ToLowerASCII('/'));
- EXPECT_EQ('1', ToLowerASCII('1'));
-}
-
-TEST(StringPieceUtilTest, EqualsCaseInsensitiveASCII) {
- EXPECT_TRUE(EqualsCaseInsensitiveASCII("abc", "abc"));
- EXPECT_TRUE(EqualsCaseInsensitiveASCII("abc", "ABC"));
- EXPECT_TRUE(EqualsCaseInsensitiveASCII("abc", "aBc"));
- EXPECT_TRUE(EqualsCaseInsensitiveASCII("AbC", "aBc"));
- EXPECT_TRUE(EqualsCaseInsensitiveASCII("", ""));
-
- EXPECT_FALSE(EqualsCaseInsensitiveASCII("a", "ac"));
- EXPECT_FALSE(EqualsCaseInsensitiveASCII("/", "\\"));
- EXPECT_FALSE(EqualsCaseInsensitiveASCII("1", "10"));
-}
diff --git a/src/subprocess-posix.cc b/src/subprocess-posix.cc
deleted file mode 100644
index 90a5a57..0000000
--- a/src/subprocess-posix.cc
+++ /dev/null
@@ -1,264 +0,0 @@
-// Copyright 2012 Google Inc. All Rights Reserved.
-//
-// Licensed under the Apache License, Version 2.0 (the "License");
-// you may not use this file except in compliance with the License.
-// You may obtain a copy of the License at
-//
-// http://www.apache.org/licenses/LICENSE-2.0
-//
-// Unless required by applicable law or agreed to in writing, software
-// distributed under the License is distributed on an "AS IS" BASIS,
-// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-// See the License for the specific language governing permissions and
-// limitations under the License.
-
-#include <assert.h>
-#include <errno.h>
-#include <fcntl.h>
-#include <spawn.h>
-#include <stdio.h>
-#include <string.h>
-#include <sys/select.h>
-#include <sys/wait.h>
-#include <unistd.h>
-
-#include "process_utils.h"
-#include "subprocess.h"
-
-extern char** environ;
-
-#include "util.h"
-
-using namespace std;
-
-Subprocess::Subprocess(SubprocessSet& subprocess_set, bool use_console)
- : subprocess_set_(subprocess_set), pid_(-1), use_console_(use_console) {}
-
-Subprocess::~Subprocess() {
- Stop();
- // Reap child if forgotten.
- if (pid_ != -1)
- Finish();
-}
-
-void Subprocess::Stop() {
- async_fd_.Close();
-}
-
-bool Subprocess::Start(const string& command) {
- SubprocessSet* set = &subprocess_set_;
- int output_pipe[2];
- if (pipe(output_pipe) < 0)
- ErrnoFatal("pipe");
- IpcHandle fd = IpcHandle(output_pipe[0]);
- fd.SetInheritable(false);
-
- posix_spawn_file_actions_t action;
- int err = posix_spawn_file_actions_init(&action);
- if (err != 0)
- ErrnoFatal("posix_spawn_file_actions_init", err);
-
- err = posix_spawn_file_actions_addclose(&action, output_pipe[0]);
- if (err != 0)
- ErrnoFatal("posix_spawn_file_actions_addclose", err);
-
- posix_spawnattr_t attr;
- err = posix_spawnattr_init(&attr);
- if (err != 0)
- ErrnoFatal("posix_spawnattr_init", err);
-
- short flags = 0;
-
- flags |= POSIX_SPAWN_SETSIGMASK;
- sigset_t old_mask = set->async_loop_.GetOldSignalMask();
-
-#ifndef _NDEBUG
- // Consistency check, ensure that SIGINT/SIGHUP/SIGTERM can reach
- // spawned processes.
- if (sigismember(&old_mask, SIGINT))
- Fatal("SubprocessSet: SIGINT is blocked in current signal mask");
- if (sigismember(&old_mask, SIGHUP))
- Fatal("SubprocessSet: SIGHUP is blocked in current signal mask");
- if (sigismember(&old_mask, SIGTERM))
- Fatal("SubprocessSet: SIGTERM is blocked in current signal mask");
-#endif
-
- err = posix_spawnattr_setsigmask(&attr, &old_mask);
- if (err != 0)
- ErrnoFatal("posix_spawnattr_setsigmask", err);
- // Signals which are set to be caught in the calling process image are set to
- // default action in the new process image, so no explicit
- // POSIX_SPAWN_SETSIGDEF parameter is needed.
-
- if (!use_console_) {
- // Put the child in its own process group, so ctrl-c won't reach it.
- flags |= POSIX_SPAWN_SETPGROUP;
- // No need to posix_spawnattr_setpgroup(&attr, 0), it's the default.
-
- // Open /dev/null over stdin.
- err = posix_spawn_file_actions_addopen(&action, 0, "/dev/null", O_RDONLY,
- 0);
- if (err != 0) {
- ErrnoFatal("posix_spawn_file_actions_addopen", err);
- }
-
- err = posix_spawn_file_actions_adddup2(&action, output_pipe[1], 1);
- if (err != 0)
- ErrnoFatal("posix_spawn_file_actions_adddup2", err);
- err = posix_spawn_file_actions_adddup2(&action, output_pipe[1], 2);
- if (err != 0)
- ErrnoFatal("posix_spawn_file_actions_adddup2", err);
- err = posix_spawn_file_actions_addclose(&action, output_pipe[1]);
- if (err != 0)
- ErrnoFatal("posix_spawn_file_actions_addclose", err);
- // In the console case, output_pipe is still inherited by the child and
- // closed when the subprocess finishes, which then notifies ninja.
- }
-#ifdef POSIX_SPAWN_USEVFORK
- flags |= POSIX_SPAWN_USEVFORK;
-#endif
-
- err = posix_spawnattr_setflags(&attr, flags);
- if (err != 0)
- ErrnoFatal("posix_spawnattr_setflags", err);
-
- char** env = environ;
- if (set->environment_)
- env = set->environment_->AsExecEnvironmentBlock();
-
- const char* spawned_args[] = { "/bin/sh", "-c", command.c_str(), NULL };
- err = posix_spawn(&pid_, "/bin/sh", &action, &attr,
- const_cast<char**>(spawned_args), env);
- if (err != 0)
- ErrnoFatal("posix_spawn", err);
-
- err = posix_spawnattr_destroy(&attr);
- if (err != 0)
- ErrnoFatal("posix_spawnattr_destroy", err);
- err = posix_spawn_file_actions_destroy(&action);
- if (err != 0)
- ErrnoFatal("posix_spawn_file_actions_destroy", err);
-
- close(output_pipe[1]);
-
- async_fd_ = AsyncHandle::Create(std::move(fd), subprocess_set_.async_loop_,
- [this](AsyncError error, size_t size) {
- if (error)
- Fatal("read: %s", strerror(error));
-
- if (size == 0) {
- Stop();
- subprocess_set_.OnProcessCompletion(this);
- return;
- }
- // Append result, continue reading.
- buf_.append(read_buf_, size);
- async_fd_.StartRead(read_buf_, sizeof(read_buf_));
- });
-
- async_fd_.StartRead(read_buf_, sizeof(read_buf_));
- return true;
-}
-
-ExitStatus Subprocess::Finish() {
- assert(pid_ != -1);
- int status;
- if (waitpid(pid_, &status, 0) < 0)
- Fatal("waitpid(%d): %s", pid_, strerror(errno));
-
- pid_ = -1;
-
-#ifdef _AIX
- if (WIFEXITED(status) && WEXITSTATUS(status) & 0x80) {
- // Map the shell's exit code used for signal failure (128 + signal) to the
- // status code expected by AIX WIFSIGNALED and WTERMSIG macros which, unlike
- // other systems, uses a different bit layout.
- int signal = WEXITSTATUS(status) & 0x7f;
- status = (signal << 16) | signal;
- }
-#endif
-
- if (WIFEXITED(status)) {
- int exit = WEXITSTATUS(status);
- if (exit == 0)
- return ExitSuccess;
- } else if (WIFSIGNALED(status)) {
- if (WTERMSIG(status) == SIGINT || WTERMSIG(status) == SIGTERM
- || WTERMSIG(status) == SIGHUP)
- return ExitInterrupted;
- }
- return ExitFailure;
-}
-
-bool Subprocess::Done() const {
- return !async_fd_;
-}
-
-const string& Subprocess::GetOutput() const {
- return buf_;
-}
-
-SubprocessSet::SubprocessSet()
- : async_loop_(AsyncLoop::Get()), interrupt_catcher_(async_loop_) {}
-
-SubprocessSet::SubprocessSet(const EnvironmentBlock& environment)
- : async_loop_(AsyncLoop::Get()), interrupt_catcher_(async_loop_),
- environment_(&environment) {}
-
-SubprocessSet::~SubprocessSet() {
- Clear();
-}
-
-Subprocess* SubprocessSet::Add(const string& command, bool use_console) {
- auto subprocess =
- std::unique_ptr<Subprocess>(new Subprocess(*this, use_console));
- if (!subprocess->Start(command)) {
- return 0;
- }
-
- Subprocess* result = subprocess.get();
- running_.push_back(std::move(subprocess));
- return result;
-}
-
-void SubprocessSet::OnProcessCompletion(Subprocess* subprocess) {
- // Move the subprocess from the running_ vector to the finished_ queue.
- for (auto it = running_.begin(); it != running_.end(); ++it) {
- if (it->get() == subprocess) {
- finished_.emplace(it->release());
- running_.erase(it);
- return;
- }
- }
-}
-
-bool SubprocessSet::DoWork() {
- size_t running_count = running_.size();
- if (!running_count)
- return false;
-
- AsyncLoop::ExitStatus loop_status =
- async_loop_.RunUntil([this, &running_count]() -> bool {
- return running_.size() != running_count;
- });
-
- return loop_status == AsyncLoop::ExitInterrupted;
-}
-
-std::unique_ptr<Subprocess> SubprocessSet::NextFinished() {
- if (finished_.empty())
- return {};
-
- std::unique_ptr<Subprocess> subproc = std::move(finished_.front());
- finished_.pop();
- return subproc;
-}
-
-void SubprocessSet::Clear() {
- int int_signal = async_loop_.GetInterruptSignal();
- for (auto& subproc : running_) {
- if (!subproc->use_console_)
- kill(-subproc->pid_, int_signal);
- }
- running_.clear();
-}
diff --git a/src/subprocess-win32.cc b/src/subprocess-win32.cc
deleted file mode 100644
index 859873a..0000000
--- a/src/subprocess-win32.cc
+++ /dev/null
@@ -1,258 +0,0 @@
-// Copyright 2012 Google Inc. All Rights Reserved.
-//
-// Licensed under the Apache License, Version 2.0 (the "License");
-// you may not use this file except in compliance with the License.
-// You may obtain a copy of the License at
-//
-// http://www.apache.org/licenses/LICENSE-2.0
-//
-// Unless required by applicable law or agreed to in writing, software
-// distributed under the License is distributed on an "AS IS" BASIS,
-// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-// See the License for the specific language governing permissions and
-// limitations under the License.
-
-#include <assert.h>
-#include <stdio.h>
-
-#include <algorithm>
-
-#include "process_utils.h"
-#include "subprocess.h"
-#include "util.h"
-
-using namespace std;
-
-Subprocess::Subprocess(SubprocessSet& subprocess_set, bool use_console)
- : subprocess_set_(subprocess_set), use_console_(use_console) {}
-
-Subprocess::~Subprocess() {
- Stop();
- // Reap child if forgotten.
- if (child_)
- Finish();
-}
-
-void Subprocess::Stop() {
- pipe_.Close();
-}
-
-HANDLE Subprocess::SetupPipe() {
- char pipe_name[100];
- snprintf(pipe_name, sizeof(pipe_name),
- "\\\\.\\pipe\\ninja_pid%lu_sp%p", GetCurrentProcessId(), this);
-
- IpcHandle pipe_handle = ::CreateNamedPipeA(
- pipe_name, PIPE_ACCESS_INBOUND | FILE_FLAG_OVERLAPPED, PIPE_TYPE_BYTE,
- PIPE_UNLIMITED_INSTANCES, 0, 0, INFINITE, NULL);
- if (!pipe_handle)
- Win32Fatal("CreateNamedPipe");
-
- AsyncLoop& async_loop = subprocess_set_.async_loop_;
-
- pipe_ = AsyncHandle::Create(
- std::move(pipe_handle), subprocess_set_.async_loop_,
- [this](AsyncError error, size_t size) {
- if (error) {
- if (error != ERROR_BROKEN_PIPE)
- Win32Fatal("GetOverlappedResult", error);
- Stop();
- subprocess_set_.OnProcessCompletion(this);
- return;
- }
- if (!is_reading_) {
- IpcHandle pipe_handle = pipe_.TakeAcceptedHandle();
- pipe_.ResetHandle(std::move(pipe_handle));
- is_reading_ = true;
- } else {
- buf_.append(read_buf_, size);
- }
- pipe_.StartRead(read_buf_, sizeof(read_buf_));
- });
-
- pipe_.StartAccept();
-
- // Get the write end of the pipe as a handle inheritable across processes.
- HANDLE output_write_handle =
- CreateFileA(pipe_name, GENERIC_WRITE, 0, NULL, OPEN_EXISTING, 0, NULL);
- HANDLE output_write_child;
- if (!DuplicateHandle(GetCurrentProcess(), output_write_handle,
- GetCurrentProcess(), &output_write_child,
- 0, TRUE, DUPLICATE_SAME_ACCESS)) {
- Win32Fatal("DuplicateHandle");
- }
- CloseHandle(output_write_handle);
-
- return output_write_child;
-}
-
-bool Subprocess::Start(const string& command) {
- IpcHandle child_pipe = SetupPipe();
-
- SECURITY_ATTRIBUTES security_attributes = {};
- security_attributes.nLength = sizeof(SECURITY_ATTRIBUTES);
- security_attributes.bInheritHandle = TRUE;
- // Must be inheritable so subprocesses can dup to children.
- IpcHandle nul =
- CreateFileA("NUL", GENERIC_READ,
- FILE_SHARE_READ | FILE_SHARE_WRITE | FILE_SHARE_DELETE,
- &security_attributes, OPEN_EXISTING, 0, NULL);
- if (!nul)
- Fatal("couldn't open nul");
-
- STARTUPINFOA startup_info = {};
- startup_info.cb = sizeof(STARTUPINFO);
- if (!use_console_) {
- startup_info.dwFlags = STARTF_USESTDHANDLES;
- startup_info.hStdInput = nul.native_handle();
- startup_info.hStdOutput = child_pipe.native_handle();
- startup_info.hStdError = child_pipe.native_handle();
- }
- // In the console case, child_pipe is still inherited by the child and closed
- // when the subprocess finishes, which then notifies ninja.
-
- PROCESS_INFORMATION process_info = {};
-
- // Ninja handles ctrl-c, except for subprocesses in console pools.
- DWORD process_flags = use_console_ ? 0 : CREATE_NEW_PROCESS_GROUP;
-
- // Compute environment pointer.
- LPVOID environment = NULL;
- if (subprocess_set_.environment_)
- environment = subprocess_set_.environment_->AsAnsiEnvironmentBlock();
-
- // Do not prepend 'cmd /c' on Windows, this breaks command
- // lines greater than 8,191 chars.
- if (!CreateProcessA(NULL, (char*)command.c_str(), NULL, NULL,
- /* inherit handles */ TRUE, process_flags, environment,
- NULL, &startup_info, &process_info)) {
- DWORD error = GetLastError();
- if (error == ERROR_FILE_NOT_FOUND) {
- // File (program) not found error is treated as a normal build
- // action failure.
- Stop();
- // child_ is already NULL;
- buf_ = "CreateProcess failed: The system cannot find the file "
- "specified.\n";
- return true;
- } else {
- fprintf(stderr, "\nCreateProcess failed. Command attempted:\n\"%s\"\n",
- command.c_str());
- const char* hint = NULL;
- // ERROR_INVALID_PARAMETER means the command line was formatted
- // incorrectly. This can be caused by a command line being too long or
- // leading whitespace in the command. Give extra context for this case.
- if (error == ERROR_INVALID_PARAMETER) {
- if (command.length() > 0 && (command[0] == ' ' || command[0] == '\t'))
- hint = "command contains leading whitespace";
- else
- hint = "is the command line too long?";
- }
- Win32Fatal("CreateProcess", hint);
- }
- }
-
- // Close pipe channel only used by the child.
- CloseHandle(process_info.hThread);
- child_ = IpcHandle(process_info.hProcess);
-
- return true;
-}
-
-ExitStatus Subprocess::Finish() {
- if (!child_)
- return ExitFailure;
-
- // TODO: add error handling for all of these.
- WaitForSingleObject(child_.native_handle(), INFINITE);
-
- DWORD exit_code = 0;
- GetExitCodeProcess(child_.native_handle(), &exit_code);
-
- child_.Close();
-
- return exit_code == 0 ? ExitSuccess :
- exit_code == CONTROL_C_EXIT ? ExitInterrupted :
- ExitFailure;
-}
-
-bool Subprocess::Done() const {
- return !pipe_;
-}
-
-const string& Subprocess::GetOutput() const {
- return buf_;
-}
-
-SubprocessSet::SubprocessSet()
- : async_loop_(AsyncLoop::Get()), interrupt_catcher_(async_loop_) {}
-
-SubprocessSet::SubprocessSet(const EnvironmentBlock& environment)
- : async_loop_(AsyncLoop::Get()), interrupt_catcher_(async_loop_),
- environment_(&environment) {}
-
-SubprocessSet::~SubprocessSet() {
- Clear();
-}
-
-Subprocess *SubprocessSet::Add(const string& command, bool use_console) {
- std::unique_ptr<Subprocess> subprocess(new Subprocess(*this, use_console));
- if (!subprocess->Start(command)) {
- return 0;
- }
- Subprocess* result = subprocess.get();
- if (subprocess->child_)
- running_.push_back(std::move(subprocess));
- else
- finished_.push(std::move(subprocess));
- return result;
-}
-
-void SubprocessSet::OnProcessCompletion(Subprocess* subprocess) {
- // Move the subprocess from the running_ vector to the finished_ queue.
- for (auto it = running_.begin(); it != running_.end(); ++it) {
- if (it->get() == subprocess) {
- finished_.emplace(std::move(*it));
- running_.erase(it);
- return;
- }
- }
- assert(false && "Unknown subprocess pointer!");
-}
-
-bool SubprocessSet::DoWork() {
- size_t running_count = running_.size();
- if (!running_count)
- return false;
-
- AsyncLoop::ExitStatus loop_status =
- async_loop_.RunUntil([this, &running_count]() -> bool {
- return running_.size() != running_count;
- });
-
- return loop_status == AsyncLoop::ExitInterrupted;
-}
-
-std::unique_ptr<Subprocess> SubprocessSet::NextFinished() {
- if (finished_.empty())
- return {};
-
- std::unique_ptr<Subprocess> subproc = std::move(finished_.front());
- finished_.pop();
- return subproc;
-}
-
-void SubprocessSet::Clear() {
- for (auto& subproc : running_) {
- // Since the foreground process is in our process group, it will receive a
- // CTRL_C_EVENT or CTRL_BREAK_EVENT at the same time as us.
- if (subproc->child_ && !subproc->use_console_) {
- if (!GenerateConsoleCtrlEvent(
- CTRL_BREAK_EVENT,
- GetProcessId(subproc->child_.native_handle()))) {
- Win32Fatal("GenerateConsoleCtrlEvent");
- }
- }
- }
- running_.clear();
-}
diff --git a/src/subprocess.h b/src/subprocess.h
deleted file mode 100644
index e6490fd..0000000
--- a/src/subprocess.h
+++ /dev/null
@@ -1,125 +0,0 @@
-// Copyright 2012 Google Inc. All Rights Reserved.
-//
-// Licensed under the Apache License, Version 2.0 (the "License");
-// you may not use this file except in compliance with the License.
-// You may obtain a copy of the License at
-//
-// http://www.apache.org/licenses/LICENSE-2.0
-//
-// Unless required by applicable law or agreed to in writing, software
-// distributed under the License is distributed on an "AS IS" BASIS,
-// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-// See the License for the specific language governing permissions and
-// limitations under the License.
-
-#ifndef NINJA_SUBPROCESS_H_
-#define NINJA_SUBPROCESS_H_
-
-#include <memory>
-#include <queue>
-#include <string>
-#include <vector>
-
-#ifdef _WIN32
-#include <windows.h>
-#else
-#include <signal.h>
-#endif
-
-#include "async_loop.h"
-#include "exit_status.h"
-#include "interrupt_handling.h"
-#include "ipc_handle.h"
-
-class EnvironmentBlock;
-
-struct SubprocessSet;
-
-/// Subprocess wraps a single async subprocess. It is entirely
-/// passive: it expects the caller to notify it when its fds are ready
-/// for reading, as well as call Finish() to reap the child once done()
-/// is true.
-struct Subprocess {
- ~Subprocess();
-
- /// Returns ExitSuccess on successful process exit, ExitInterrupted if
- /// the process was interrupted, ExitFailure if it otherwise failed.
- /// Should only be called on an instance where Done() returns true.
- ExitStatus Finish();
-
- /// Return true if the a subprocess has completed. Only used for testing.
- bool Done() const;
-
- /// Retrieve buffered output (combined stdout/stderr) for a given
- /// subprocess. Will be empty for subprocesses belonging to the 'console'
- /// pool. Only call this when Done() returns true, or after a call to
- /// Finish().
- const std::string& GetOutput() const;
-
- private:
- Subprocess(SubprocessSet& subprocess_set, bool use_console);
- bool Start(const std::string& command);
-
- SubprocessSet& subprocess_set_;
- std::string buf_;
-
-#ifdef _WIN32
- /// Set up pipe_ as the parent-side pipe of the subprocess; return the
- /// other end of the pipe, usable in the child process.
- HANDLE SetupPipe();
-
- IpcHandle child_;
- AsyncHandle pipe_;
- bool is_reading_ = false;
-#else
- AsyncHandle async_fd_;
- pid_t pid_;
-#endif
- bool use_console_;
- char read_buf_[4 << 10];
-
- void Stop();
-
- friend struct SubprocessSet;
-};
-
-/// SubprocessSet runs a ppoll/pselect() loop around a set of Subprocesses.
-/// DoWork() waits for any state change in subprocesses; finished_
-/// is a queue of subprocesses as they finish.
-struct SubprocessSet {
- SubprocessSet();
-
- explicit SubprocessSet(const EnvironmentBlock& environment);
-
- ~SubprocessSet();
-
- /// Start a new subprocess, and return a pointer to the corresponding
- /// instance, which is still owned by the SubprocessSet.
- Subprocess* Add(const std::string& command, bool use_console = false);
-
- /// Wait for any subprocess to complete. Returns true if interrupted
- /// or false otherwise.
- bool DoWork();
-
- /// Return next finished process, or null if there is none.
- /// The returned instance must be destroyed before this SubprocessSet.
- std::unique_ptr<Subprocess> NextFinished();
-
- /// Remove all remaining processes forcibly.
- void Clear();
-
- std::vector<std::unique_ptr<Subprocess>> running_;
- std::queue<std::unique_ptr<Subprocess>> finished_;
-
- private:
- friend struct Subprocess;
-
- AsyncLoop& async_loop_;
- AsyncLoop::ScopedInterruptCatcher interrupt_catcher_;
- const EnvironmentBlock* environment_ = nullptr;
-
- // Called from an asynchronous callback when a subprocess completes.
- void OnProcessCompletion(Subprocess* subprocess);
-};
-
-#endif // NINJA_SUBPROCESS_H_
diff --git a/src/subprocess_test.cc b/src/subprocess_test.cc
deleted file mode 100644
index 3aa4089..0000000
--- a/src/subprocess_test.cc
+++ /dev/null
@@ -1,279 +0,0 @@
-// Copyright 2012 Google Inc. All Rights Reserved.
-//
-// Licensed under the Apache License, Version 2.0 (the "License");
-// you may not use this file except in compliance with the License.
-// You may obtain a copy of the License at
-//
-// http://www.apache.org/licenses/LICENSE-2.0
-//
-// Unless required by applicable law or agreed to in writing, software
-// distributed under the License is distributed on an "AS IS" BASIS,
-// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-// See the License for the specific language governing permissions and
-// limitations under the License.
-
-#include "subprocess.h"
-
-#include "test.h"
-
-#ifndef _WIN32
-// SetWithLots need setrlimit.
-#include <stdio.h>
-#include <sys/time.h>
-#include <sys/resource.h>
-#include <unistd.h>
-#endif
-
-using namespace std;
-
-namespace {
-
-#ifdef _WIN32
-const char* kSimpleCommand = "cmd /c dir \\";
-#else
-const char* kSimpleCommand = "ls /";
-#endif
-
-struct SubprocessTest : public testing::Test {
- void SetUp() { AsyncLoop::ResetForTesting(); }
-
- SubprocessSet subprocs_;
-};
-
-} // anonymous namespace
-
-// Run a command that fails and emits to stderr.
-TEST_F(SubprocessTest, BadCommandStderr) {
- Subprocess* subproc = subprocs_.Add("cmd /c ninja_no_such_command");
- ASSERT_NE((Subprocess *) 0, subproc);
-
- while (!subproc->Done()) {
- // Pretend we discovered that stderr was ready for writing.
- subprocs_.DoWork();
- }
-
- EXPECT_EQ(ExitFailure, subproc->Finish());
- EXPECT_NE("", subproc->GetOutput());
-}
-
-// Run a command that does not exist
-TEST_F(SubprocessTest, NoSuchCommand) {
- Subprocess* subproc = subprocs_.Add("ninja_no_such_command");
- ASSERT_NE((Subprocess *) 0, subproc);
-
- while (!subproc->Done()) {
- // Pretend we discovered that stderr was ready for writing.
- subprocs_.DoWork();
- }
-
- EXPECT_EQ(ExitFailure, subproc->Finish());
- EXPECT_NE("", subproc->GetOutput());
-#ifdef _WIN32
- ASSERT_EQ("CreateProcess failed: The system cannot find the file "
- "specified.\n", subproc->GetOutput());
-#endif
-}
-
-#ifndef _WIN32
-
-TEST_F(SubprocessTest, InterruptChild) {
- Subprocess* subproc = subprocs_.Add("kill -INT $$");
- ASSERT_NE((Subprocess *) 0, subproc);
-
- while (!subproc->Done()) {
- subprocs_.DoWork();
- }
-
- EXPECT_EQ(ExitInterrupted, subproc->Finish());
-}
-
-TEST_F(SubprocessTest, InterruptParent) {
- Subprocess* subproc = subprocs_.Add("kill -INT $PPID ; sleep 1");
- ASSERT_NE((Subprocess *) 0, subproc);
-
- while (!subproc->Done()) {
- bool interrupted = subprocs_.DoWork();
- if (interrupted)
- return;
- }
-
- ASSERT_FALSE("We should have been interrupted");
-}
-
-TEST_F(SubprocessTest, InterruptChildWithSigTerm) {
- Subprocess* subproc = subprocs_.Add("kill -TERM $$");
- ASSERT_NE((Subprocess *) 0, subproc);
-
- while (!subproc->Done()) {
- subprocs_.DoWork();
- }
-
- EXPECT_EQ(ExitInterrupted, subproc->Finish());
-}
-
-TEST_F(SubprocessTest, InterruptParentWithSigTerm) {
- Subprocess* subproc = subprocs_.Add("kill -TERM $PPID ; sleep 1");
- ASSERT_NE((Subprocess *) 0, subproc);
-
- while (!subproc->Done()) {
- bool interrupted = subprocs_.DoWork();
- if (interrupted)
- return;
- }
-
- ASSERT_FALSE("We should have been interrupted");
-}
-
-TEST_F(SubprocessTest, InterruptChildWithSigHup) {
- Subprocess* subproc = subprocs_.Add("kill -HUP $$");
- ASSERT_NE((Subprocess *) 0, subproc);
-
- while (!subproc->Done()) {
- subprocs_.DoWork();
- }
-
- EXPECT_EQ(ExitInterrupted, subproc->Finish());
-}
-
-TEST_F(SubprocessTest, InterruptParentWithSigHup) {
- Subprocess* subproc = subprocs_.Add("kill -HUP $PPID ; sleep 1");
- ASSERT_NE((Subprocess *) 0, subproc);
-
- while (!subproc->Done()) {
- bool interrupted = subprocs_.DoWork();
- if (interrupted)
- return;
- }
-
- ASSERT_FALSE("We should have been interrupted");
-}
-
-TEST_F(SubprocessTest, Timeout) {
- Subprocess* subproc = subprocs_.Add("sleep 1");
- ASSERT_NE((Subprocess*)0, subproc);
-
- int timeout_counter = 0;
- while (!subproc->Done()) {
- bool interrupted = subprocs_.DoWork();
- if (interrupted) {
- ASSERT_GT(timeout_counter, 0);
- break;
- }
- timeout_counter++;
- }
-}
-
-TEST_F(SubprocessTest, Console) {
- // Skip test if we don't have the console ourselves.
- if (isatty(0) && isatty(1) && isatty(2)) {
- Subprocess* subproc =
- subprocs_.Add("test -t 0 -a -t 1 -a -t 2", /*use_console=*/true);
- ASSERT_NE((Subprocess*)0, subproc);
-
- while (!subproc->Done()) {
- subprocs_.DoWork();
- }
-
- EXPECT_EQ(ExitSuccess, subproc->Finish());
- }
-}
-
-#endif
-
-TEST_F(SubprocessTest, SetWithSingle) {
- Subprocess* subproc = subprocs_.Add(kSimpleCommand);
- ASSERT_NE((Subprocess *) 0, subproc);
-
- while (!subproc->Done()) {
- subprocs_.DoWork();
- }
- ASSERT_EQ(ExitSuccess, subproc->Finish());
- ASSERT_NE("", subproc->GetOutput());
-
- ASSERT_EQ(1u, subprocs_.finished_.size());
-}
-
-TEST_F(SubprocessTest, SetWithMulti) {
- Subprocess* processes[3];
- const char* kCommands[3] = {
- kSimpleCommand,
-#ifdef _WIN32
- "cmd /c echo hi",
- "cmd /c time /t",
-#else
- "id -u",
- "pwd",
-#endif
- };
-
- for (int i = 0; i < 3; ++i) {
- processes[i] = subprocs_.Add(kCommands[i]);
- ASSERT_NE((Subprocess *) 0, processes[i]);
- }
-
- ASSERT_EQ(3u, subprocs_.running_.size());
- for (int i = 0; i < 3; ++i) {
- ASSERT_FALSE(processes[i]->Done());
- ASSERT_EQ("", processes[i]->GetOutput());
- }
-
- while (!processes[0]->Done() || !processes[1]->Done() ||
- !processes[2]->Done()) {
- ASSERT_GT(subprocs_.running_.size(), 0u);
- subprocs_.DoWork();
- }
-
- ASSERT_EQ(0u, subprocs_.running_.size());
- ASSERT_EQ(3u, subprocs_.finished_.size());
-
- for (int i = 0; i < 3; ++i) {
- ASSERT_EQ(ExitSuccess, processes[i]->Finish());
- ASSERT_NE("", processes[i]->GetOutput());
- }
-}
-
-#if defined(USE_KQUEUE) || defined(USE_PPOLL)
-TEST_F(SubprocessTest, SetWithLots) {
- // Arbitrary big number; needs to be over 1024 to confirm we're no longer
- // hostage to pselect.
- const unsigned kNumProcs = 1025;
-
- // Make sure [ulimit -n] isn't going to stop us from working.
- rlimit rlim;
- ASSERT_EQ(0, getrlimit(RLIMIT_NOFILE, &rlim));
- if (rlim.rlim_cur < kNumProcs) {
- printf("Raise [ulimit -n] above %u (currently %lu) to make this test go\n",
- kNumProcs, static_cast<unsigned long>(rlim.rlim_cur));
- return;
- }
-
- vector<Subprocess*> procs;
- for (size_t i = 0; i < kNumProcs; ++i) {
- Subprocess* subproc = subprocs_.Add("/bin/echo");
- ASSERT_NE((Subprocess *) 0, subproc);
- procs.push_back(subproc);
- }
- while (!subprocs_.running_.empty())
- subprocs_.DoWork();
- for (size_t i = 0; i < procs.size(); ++i) {
- ASSERT_EQ(ExitSuccess, procs[i]->Finish());
- ASSERT_NE("", procs[i]->GetOutput());
- }
- ASSERT_EQ(kNumProcs, subprocs_.finished_.size());
-}
-#endif // USE_KQUEUE || USE_PPOLL
-
-// TODO: this test could work on Windows, just not sure how to simply
-// read stdin.
-#ifndef _WIN32
-// Verify that a command that attempts to read stdin correctly thinks
-// that stdin is closed.
-TEST_F(SubprocessTest, ReadStdin) {
- Subprocess* subproc = subprocs_.Add("cat -");
- while (!subproc->Done()) {
- subprocs_.DoWork();
- }
- ASSERT_EQ(ExitSuccess, subproc->Finish());
- ASSERT_EQ(1u, subprocs_.finished_.size());
-}
-#endif // _WIN32
diff --git a/src/test.cc b/src/test.cc
deleted file mode 100644
index d64743f..0000000
--- a/src/test.cc
+++ /dev/null
@@ -1,306 +0,0 @@
-// Copyright 2011 Google Inc. All Rights Reserved.
-//
-// Licensed under the Apache License, Version 2.0 (the "License");
-// you may not use this file except in compliance with the License.
-// You may obtain a copy of the License at
-//
-// http://www.apache.org/licenses/LICENSE-2.0
-//
-// Unless required by applicable law or agreed to in writing, software
-// distributed under the License is distributed on an "AS IS" BASIS,
-// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-// See the License for the specific language governing permissions and
-// limitations under the License.
-
-#ifdef _WIN32
-#include <direct.h> // Has to be before util.h is included.
-#endif
-
-#include "test.h"
-
-#include <algorithm>
-
-#include <errno.h>
-#include <stdlib.h>
-#ifdef _WIN32
-#include <io.h>
-#include <sys/stat.h>
-#include <windows.h>
-#else
-#include <unistd.h>
-#endif
-
-#include "build_log.h"
-#include "graph.h"
-#include "manifest_parser.h"
-#include "util.h"
-
-#ifdef _AIX
-extern "C" {
- // GCC "helpfully" strips the definition of mkdtemp out on AIX.
- // The function is still present, so if we define it ourselves
- // it will work perfectly fine.
- extern char* mkdtemp(char* name_template);
-}
-#endif
-
-using namespace std;
-
-namespace {
-
-#ifdef _WIN32
-/// Windows has no mkdtemp. Implement it in terms of _mktemp_s.
-char* mkdtemp(char* name_template) {
- // The mktemp_s() implementation of the Wine C runtime is broken and
- // will consistently fail after 26 calls(!) by returning EEXIST.
- // Reimplement the function in this case.
- const size_t max_tries = 32;
- bool found_one = false;
- size_t len = ::strlen(name_template);
- // Count the number of X's in the template, must be at least 6.
- size_t num_xs = 0;
- while (num_xs < len && name_template[len - 1 - num_xs] == 'X')
- num_xs++;
- if (num_xs < 6) {
- errno = EINVAL;
- perror("_mktemp_s");
- return NULL;
- }
-
- // rand() is really not very random on Wine by default :-/
- // leading to surprising conflicts. Same is true for GetCurrentProcessId()
- // or GetCurrentProcess() so use time
- FILETIME ft = {};
- ::GetSystemTimeAsFileTime(&ft);
- srand(static_cast<unsigned>(ft.dwLowDateTime));
-
- auto get_random_alnum = []() -> char {
- int index = rand() % 62;
- if (index < 26)
- return static_cast<char>('A' + index);
- index -= 26;
- if (index < 26)
- return static_cast<char>('a' + index);
- index -= 26;
- return static_cast<char>('0' + index);
- };
- char* start = name_template + len - num_xs;
- for (size_t tries = 0; tries < max_tries; ++tries) {
- for (size_t n = 0; n < num_xs; ++n)
- start[n] = get_random_alnum();
- struct _stat st = {};
- int ret = _stat(name_template, &st);
- if (ret < 0 && errno == ENOENT) {
- errno = 0;
- found_one = true;
- break;
- }
- }
- if (!found_one) {
- // The Posix mkdtemp() specification does not specify which errno
- // value to use in this case, neither does the Linux manpage, so
- // just select EINVAL, which is what the Win32 _mktemp_s() returns
- // on such failures (note: the Wine version returns EEXIST!).
- errno = EINVAL;
- perror("_mktemp_s");
- return NULL;
- }
-
- int err = _mkdir(name_template);
- if (err < 0) {
- perror("mkdir");
- return NULL;
- }
-
- return name_template;
-}
-#endif // _WIN32
-
-/// Return system temporary directory. Result always has a trailing separator,
-/// except when empty.
-std::string GetSystemTempDir() {
-#ifdef _WIN32
- std::string result;
- result.resize(PATH_MAX);
- DWORD ret = GetTempPath(result.size(), &result[0]);
- result.resize(static_cast<size_t>(ret));
- if (!result.empty()) {
- if (result.back() != '/' && result.back() != '\\')
- result.push_back('\\');
- }
- return result;
-#else
- std::string result = "/tmp/";
- const char* tempdir = getenv("TMPDIR");
- if (tempdir) {
- result = tempdir;
- if (!result.empty() && result.back() != '/')
- result.push_back('/');
- }
- return result;
-#endif
-}
-
-} // anonymous namespace
-
-
-::testing::AsString<void*, void>::AsString(const void* ptr) {
- char temp[32];
- ::snprintf(temp, sizeof(temp), "%p", ptr);
- str_ = temp;
-}
-
-StateTestWithBuiltinRules::StateTestWithBuiltinRules() {
- AddCatRule(&state_);
-}
-
-void StateTestWithBuiltinRules::AddCatRule(State* state) {
- AssertParse(state,
-"rule cat\n"
-" command = cat $in > $out\n");
-}
-
-Node* StateTestWithBuiltinRules::GetNode(const string& path) {
- EXPECT_FALSE(strpbrk(path.c_str(), "/\\"));
- return state_.GetNode(path, 0);
-}
-
-void AssertParse(State* state, const char* input,
- ManifestParserOptions opts) {
- ManifestParser parser(state, NULL, opts);
- string err;
- EXPECT_TRUE(parser.ParseTest(input, &err));
- ASSERT_EQ("", err);
- VerifyGraph(*state);
-}
-
-void AssertHash(const char* expected, uint64_t actual) {
- ASSERT_EQ(BuildLog::LogEntry::HashCommand(expected), actual);
-}
-
-void VerifyGraph(const State& state) {
- for (vector<Edge*>::const_iterator e = state.edges_.begin();
- e != state.edges_.end(); ++e) {
- // All edges need at least one output.
- EXPECT_FALSE((*e)->outputs_.empty());
- // Check that the edge's inputs have the edge as out-edge.
- for (vector<Node*>::const_iterator in_node = (*e)->inputs_.begin();
- in_node != (*e)->inputs_.end(); ++in_node) {
- const vector<Edge*>& out_edges = (*in_node)->out_edges();
- EXPECT_NE(find(out_edges.begin(), out_edges.end(), *e),
- out_edges.end());
- }
- // Check that the edge's outputs have the edge as in-edge.
- for (vector<Node*>::const_iterator out_node = (*e)->outputs_.begin();
- out_node != (*e)->outputs_.end(); ++out_node) {
- EXPECT_EQ((*out_node)->in_edge(), *e);
- }
- }
-
- // The union of all in- and out-edges of each nodes should be exactly edges_.
- set<const Edge*> node_edge_set;
- for (State::Paths::const_iterator p = state.paths_.begin();
- p != state.paths_.end(); ++p) {
- const Node* n = p->second;
- if (n->in_edge())
- node_edge_set.insert(n->in_edge());
- node_edge_set.insert(n->out_edges().begin(), n->out_edges().end());
- }
- set<const Edge*> edge_set(state.edges_.begin(), state.edges_.end());
- EXPECT_EQ(node_edge_set, edge_set);
-}
-
-void VirtualFileSystem::Create(const string& path,
- const string& contents) {
- files_[path].mtime = now_;
- files_[path].contents = contents;
- files_created_.insert(path);
-}
-
-TimeStamp VirtualFileSystem::Stat(const string& path, string* err) const {
- FileMap::const_iterator i = files_.find(path);
- if (i != files_.end()) {
- *err = i->second.stat_error;
- return i->second.mtime;
- }
- return 0;
-}
-
-bool VirtualFileSystem::WriteFile(const string& path, const string& contents) {
- Create(path, contents);
- return true;
-}
-
-bool VirtualFileSystem::MakeDir(const string& path) {
- directories_made_.push_back(path);
- return true; // success
-}
-
-FileReader::Status VirtualFileSystem::ReadFile(const string& path,
- string* contents,
- string* err) {
- files_read_.push_back(path);
- FileMap::iterator i = files_.find(path);
- if (i != files_.end()) {
- *contents = i->second.contents;
- return Okay;
- }
- *err = strerror(ENOENT);
- return NotFound;
-}
-
-int VirtualFileSystem::RemoveFile(const string& path) {
- if (find(directories_made_.begin(), directories_made_.end(), path)
- != directories_made_.end())
- return -1;
- FileMap::iterator i = files_.find(path);
- if (i != files_.end()) {
- files_.erase(i);
- files_removed_.insert(path);
- return 0;
- } else {
- return 1;
- }
-}
-
-ScopedTempDir::ScopedTempDir() : original_dir_(GetCurrentDir()) {}
-
-ScopedTempDir::~ScopedTempDir() {
- Cleanup();
-}
-
-void ScopedTempDir::CreateAndEnter(const string& name) {
- temp_dir_name_ = GetSystemTempDir();
- if (temp_dir_name_.empty())
- Fatal("couldn't get system temp dir");
-
- // Create a temporary subdirectory of that.
- temp_dir_name_ += name;
- temp_dir_name_ += "-XXXXXX";
- char* tempname = mkdtemp(&temp_dir_name_[0]);
- if (!tempname)
- ErrnoFatal("mkdtemp");
-
- // chdir into the new temporary directory.
- if (chdir(temp_dir_name_.c_str()) < 0)
- ErrnoFatal("chdir");
-}
-
-void ScopedTempDir::Cleanup() {
- if (temp_dir_name_.empty())
- return; // Something went wrong earlier or already cleaned.
-
- // Move out of the directory we're about to clobber.
- if (chdir(original_dir_.c_str()) < 0)
- ErrnoFatal("chdir");
-
-#ifdef _WIN32
- string command = "rmdir /s /q " + temp_dir_name_;
-#else
- string command = "rm -rf " + temp_dir_name_;
-#endif
- if (system(command.c_str()) < 0)
- ErrnoFatal("system");
-
- temp_dir_name_.clear();
-}
diff --git a/src/test.h b/src/test.h
deleted file mode 100644
index b03d902..0000000
--- a/src/test.h
+++ /dev/null
@@ -1,384 +0,0 @@
-// Copyright 2011 Google Inc. All Rights Reserved.
-//
-// Licensed under the Apache License, Version 2.0 (the "License");
-// you may not use this file except in compliance with the License.
-// You may obtain a copy of the License at
-//
-// http://www.apache.org/licenses/LICENSE-2.0
-//
-// Unless required by applicable law or agreed to in writing, software
-// distributed under the License is distributed on an "AS IS" BASIS,
-// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-// See the License for the specific language governing permissions and
-// limitations under the License.
-
-#ifndef NINJA_TEST_H_
-#define NINJA_TEST_H_
-
-#include <stddef.h>
-
-#include "disk_interface.h"
-#include "manifest_parser.h"
-#include "state.h"
-#include "util.h"
-
-// A tiny testing framework inspired by googletest, but much simpler and
-// faster to compile. It supports most things commonly used from googltest. The
-// most noticeable things missing: EXPECT_* and ASSERT_* don't support
-// streaming notes to them with operator<<, and for failing tests the lhs and
-// rhs are not printed. That's so that this header does not have to include
-// sstream, which slows down building ninja_test almost 20%.
-namespace testing {
-class Test {
- bool failed_;
- int assertion_failures_;
- public:
- Test() : failed_(false), assertion_failures_(0) {}
- virtual ~Test() {}
- virtual void SetUp() {}
- virtual void TearDown() {}
- virtual void Run() = 0;
-
- bool Failed() const { return failed_; }
- int AssertionFailures() const { return assertion_failures_; }
- void AddAssertionFailure() { assertion_failures_++; }
- bool NullFailure(bool expected, const char* file, int line, const char* error,
- const char* value);
- bool BooleanFailure(bool expected, const char* file, int line,
- const char* error, const char* value);
- bool BinopFailure(const char* file, int line, const char* error, const char* first_value, const char* second_value);
-};
-
-/// std::void_t<T> is only available since C++17, so use
-/// ::testing::Void<T>::type for the same thing. Used by AsString<> below.
-template <class ...>
-struct Void {
- using type = void;
-};
-
-/// Expand to a type expression that is only valid if |expression| compiles
-/// properly. Only useful for C++ SFINAE.
-#define TESTING_ENABLE_IF_EXPRESSION_COMPILES(expression) \
- typename ::testing::Void<decltype(expression)>::type
-
-/// Expand to a type expression that is only valid if type T provides
-/// an AsString() method. Note: for simplicity, there is no check that
-/// the result is convertible into an std::string here.
-#define TESTING_ENABLE_IF_METHOD_AS_STRING_EXISTS_FOR_TYPE(T) \
- TESTING_ENABLE_IF_EXPRESSION_COMPILES(std::declval<T>().AsString())
-
-/// Expand to a type expression that is only valid if type T is supported
-/// as an std::to_string() argument type.
-#define TESTING_ENABLE_IF_STD_TO_STRING_SUPPORTS_TYPE(T) \
- TESTING_ENABLE_IF_EXPRESSION_COMPILES(std::to_string(std::declval<T>()))
-
-/// RemoveCVRef<T> remove references as well as const and volatile modifier.
-/// Used by AsString<> below.
-template <typename T>
-struct RemoveCVRef {
- using type = typename std::remove_cv<typename std::remove_reference<T>::type>::type;
-};
-
-/// Expand to the base type of expression value |v|, which means without
-/// any reference, const or volatile qualifier. This can be used as a
-/// type argument when defining template specializations.
-#define TESTING_BASE_TYPE_FOR_VALUE(v) \
- typename ::testing::RemoveCVRef<decltype(v)>::type
-
-/// ConstRefT<T>::type is a const reference type that binds to a value of type
-/// T.
-template <typename T>
-struct ConstRefT {
- using type = const typename std::remove_const<
- typename std::remove_reference<T>::type>::type&;
-};
-
-#define TESTING_CONST_REF_TYPE_FOR_VALUE(v) \
- typename ::testing::ConstRefT<decltype(v)>::type
-
-/// ::testing::AsString<T> is a helper struct used to convert expression
-/// in EXPECT_XXX and ASSERT_XXX macros into the string representation of
-/// their value. This uses C++11 template metadata magic which can be easily
-/// confusing, so as a short technical note:
-///
-/// - An AsString<T> value is an object that provides a `c_str()` method that
-/// will be used to print it in case of test failure.
-///
-/// - By default, AsString<T>::c_str() will return `"<UNPRINTABLE>"`. This
-/// would happen when T is an std::pair<> or something more complex.
-///
-/// - If type T has an AsString() method, it will be used automatically
-/// to retrieve a printable version of the value. E.g. StringPiece!
-///
-/// - If type T is supported by std::to_string(), the latter is used
-/// automatically as well (so all integral and floating point values).
-///
-/// - AsString<T*>::c_str() will return an hexadecimal address (just like %p)
-///
-
-/// The generic / fallback version.
-template <typename T, typename Enable = void>
-struct AsString {
- AsString(const T& value) {}
- const char* c_str() const { return "<UNPRINTABLE>"; }
-};
-
-/// Print booleans as either "true" or "false".
-template <>
-struct AsString<bool, void> {
- AsString(bool value) : value_(value) {}
- const char* c_str() const { return value_ ? "true" : "false"; }
- bool value_;
-};
-
-/// Print pointers with %p by default. See implementation in ninja_test.cc
-template <>
-struct AsString<void*, void> {
- AsString(const void* ptr);
- const char* c_str() const { return str_.c_str(); }
- std::string str_;
-};
-
-template <typename T>
-struct AsString<T*, void> : public AsString<void*, void> {
- AsString(const T* ptr) : AsString<void*, void>(ptr) {}
-};
-
-/// Anything supported by std::to_string() is supported implicitly too.
-template <typename T>
-struct AsString<T, TESTING_ENABLE_IF_STD_TO_STRING_SUPPORTS_TYPE(T)> {
- AsString(const T value) : str_(std::to_string(value)) {}
- const char* c_str() const { return str_.c_str(); }
- std::string str_;
-};
-
-/// Anything that has an AsString() method is supported implicitly too.
-/// For example, StringPiece!
-template <typename T>
-struct AsString<T, TESTING_ENABLE_IF_METHOD_AS_STRING_EXISTS_FOR_TYPE(T)> {
- AsString(const T& value) : str_(value.AsString()) {}
- const char* c_str() const { return str_.c_str(); }
- std::string str_;
-};
-
-/// Support for std::string, avoids a copy.
-template <>
-struct AsString<std::string> {
- AsString(const std::string& value) : str_(value) {}
- const char* c_str() const { return str_.c_str(); }
- const std::string& str_;
-};
-
-/// Support for literal C strings.
-template <size_t N>
-struct AsString<char [N], void> {
- AsString(const char* value) : value_(value) {}
- const char* c_str() const { return value_; }
- const char* value_;
-};
-
-/// Support for C string pointers.
-template <>
-struct AsString<const char*> {
- AsString(const char* value) : value_(value) {}
- const char* c_str() const { return value_; }
- const char* value_;
-};
-
-template <>
-struct AsString<char*> : public AsString<const char*> {
- AsString(const char* value) : AsString<const char*>(value) {}
-};
-
-}
-
-void RegisterTest(testing::Test* (*)(), const char*);
-
-extern testing::Test* g_current_test;
-#define TEST_F_(x, y, name) \
- struct y : public x { \
- static testing::Test* Create() { return g_current_test = new y; } \
- virtual void Run(); \
- }; \
- struct Register##y { \
- Register##y() { RegisterTest(y::Create, name); } \
- }; \
- Register##y g_register_##y; \
- void y::Run()
-
-#define TEST_F(x, y) TEST_F_(x, x##y, #x "." #y)
-#define TEST(x, y) TEST_F_(testing::Test, x##y, #x "." #y)
-
-/// Generic EXPECT macro for binary operations. The use of a lambda here
-/// is necessary to ensure that the expressions in (a) and (b) are only
-/// evaluated once at runtime in case of failure.
-#define EXPECT_BINARY_OP(a, b, op) \
- ([](TESTING_CONST_REF_TYPE_FOR_VALUE(a) va, \
- TESTING_CONST_REF_TYPE_FOR_VALUE(b) vb) -> bool { \
- return ((va op vb) \
- ? true \
- : g_current_test->BinopFailure( \
- __FILE__, __LINE__, #a " " #op " " #b, \
- ::testing::AsString<TESTING_BASE_TYPE_FOR_VALUE(va)>(va) \
- .c_str(), \
- ::testing::AsString<TESTING_BASE_TYPE_FOR_VALUE(vb)>(vb) \
- .c_str())); \
- }(a, b))
-
-#define EXPECT_EQ(a, b) EXPECT_BINARY_OP(a, b, ==)
-#define EXPECT_NE(a, b) EXPECT_BINARY_OP(a, b, !=)
-#define EXPECT_GT(a, b) EXPECT_BINARY_OP(a, b, >)
-#define EXPECT_LT(a, b) EXPECT_BINARY_OP(a, b, <)
-#define EXPECT_GE(a, b) EXPECT_BINARY_OP(a, b, >=)
-#define EXPECT_LE(a, b) EXPECT_BINARY_OP(a, b, <=)
-
-/// Generic EXPECT macro for boolean comparisons.
-#define EXPECT_BOOLEAN_OP(a, expected) \
- ([](TESTING_CONST_REF_TYPE_FOR_VALUE(a) va) -> bool { \
- return (static_cast<bool>(va) == expected) \
- ? true \
- : g_current_test->BooleanFailure( \
- expected, __FILE__, __LINE__, #a, \
- ::testing::AsString<TESTING_BASE_TYPE_FOR_VALUE(va)>(va) \
- .c_str()); \
- }(a))
-
-#define EXPECT_TRUE(a) EXPECT_BOOLEAN_OP(a, true)
-#define EXPECT_FALSE(a) EXPECT_BOOLEAN_OP(a, false)
-
-/// Generic EXPECT macro for pointer nullptr comparisons.
-/// Note that boolean comparisons should work too, but the message in case
-/// of failure is slightly clearer when using this macro.
-#define EXPECT_NULL_OP(a, expected) \
- ([](TESTING_CONST_REF_TYPE_FOR_VALUE(a) va) -> bool { \
- return (expected == ((va) == nullptr)) \
- ? true \
- : g_current_test->NullFailure( \
- expected, __FILE__, __LINE__, #a, \
- ::testing::AsString<TESTING_BASE_TYPE_FOR_VALUE(va)>(va) \
- .c_str()); \
- }(a))
-
-#define EXPECT_NULL(a) EXPECT_NULL_OP(a, true)
-#define EXPECT_NOT_NULL(a) EXPECT_NULL_OP(a, false)
-
-#define ASSERT_EQ(a, b) \
- if (!EXPECT_EQ(a, b)) { g_current_test->AddAssertionFailure(); return; }
-#define ASSERT_NE(a, b) \
- if (!EXPECT_NE(a, b)) { g_current_test->AddAssertionFailure(); return; }
-#define ASSERT_GT(a, b) \
- if (!EXPECT_GT(a, b)) { g_current_test->AddAssertionFailure(); return; }
-#define ASSERT_LT(a, b) \
- if (!EXPECT_LT(a, b)) { g_current_test->AddAssertionFailure(); return; }
-#define ASSERT_GE(a, b) \
- if (!EXPECT_GE(a, b)) { g_current_test->AddAssertionFailure(); return; }
-#define ASSERT_LE(a, b) \
- if (!EXPECT_LE(a, b)) { g_current_test->AddAssertionFailure(); return; }
-#define ASSERT_TRUE(a) \
- if (!EXPECT_TRUE(a)) { g_current_test->AddAssertionFailure(); return; }
-#define ASSERT_FALSE(a) \
- if (!EXPECT_FALSE(a)) { g_current_test->AddAssertionFailure(); return; }
-#define ASSERT_NULL(a) \
- if (!EXPECT_NULL(a)) { \
- g_current_test->AddAssertionFailure(); \
- return; \
- }
-#define ASSERT_NOT_NULL(a) \
- if (!EXPECT_NOT_NULL(a)) { \
- g_current_test->AddAssertionFailure(); \
- return; \
- }
-#define ASSERT_NO_FATAL_FAILURE(a) \
- { \
- int fail_count = g_current_test->AssertionFailures(); \
- a; \
- if (fail_count != g_current_test->AssertionFailures()) { \
- g_current_test->AddAssertionFailure(); \
- return; \
- } \
- }
-
-// Support utilities for tests.
-
-struct Node;
-
-/// A base test fixture that includes a State object with a
-/// builtin "cat" rule.
-struct StateTestWithBuiltinRules : public testing::Test {
- StateTestWithBuiltinRules();
-
- /// Add a "cat" rule to \a state. Used by some tests; it's
- /// otherwise done by the ctor to state_.
- void AddCatRule(State* state);
-
- /// Short way to get a Node by its path from state_.
- Node* GetNode(const std::string& path);
-
- State state_;
-};
-
-void AssertParse(State* state, const char* input,
- ManifestParserOptions = ManifestParserOptions());
-void AssertHash(const char* expected, uint64_t actual);
-void VerifyGraph(const State& state);
-
-/// An implementation of DiskInterface that uses an in-memory representation
-/// of disk state. It also logs file accesses and directory creations
-/// so it can be used by tests to verify disk access patterns.
-struct VirtualFileSystem : public DiskInterface {
- VirtualFileSystem() : now_(1) {}
-
- /// "Create" a file with contents.
- void Create(const std::string& path, const std::string& contents);
-
- /// Tick "time" forwards; subsequent file operations will be newer than
- /// previous ones.
- int Tick() {
- return ++now_;
- }
-
- // DiskInterface
- virtual TimeStamp Stat(const std::string& path, std::string* err) const;
- virtual bool WriteFile(const std::string& path, const std::string& contents);
- virtual bool MakeDir(const std::string& path);
- virtual Status ReadFile(const std::string& path, std::string* contents,
- std::string* err);
- virtual int RemoveFile(const std::string& path);
-
- /// An entry for a single in-memory file.
- struct Entry {
- int mtime;
- std::string stat_error; // If mtime is -1.
- std::string contents;
- };
-
- std::vector<std::string> directories_made_;
- std::vector<std::string> files_read_;
- typedef std::map<std::string, Entry> FileMap;
- FileMap files_;
- std::set<std::string> files_removed_;
- std::set<std::string> files_created_;
-
- /// A simple fake timestamp for file operations.
- int now_;
-};
-
-struct ScopedTempDir {
- ScopedTempDir();
-
- ~ScopedTempDir();
-
- /// Create a temporary directory and chdir into it.
- void CreateAndEnter(const std::string& name);
-
- /// Clean up the temporary directory.
- void Cleanup();
-
- /// The current directory when creating this instance.
- std::string original_dir_;
-
- /// The subdirectory name for our dir, or empty if it hasn't been set up.
- std::string temp_dir_name_;
-};
-
-#endif // NINJA_TEST_H_
diff --git a/src/timestamp.h b/src/timestamp.h
deleted file mode 100644
index 6a7ccd0..0000000
--- a/src/timestamp.h
+++ /dev/null
@@ -1,33 +0,0 @@
-// Copyright 2011 Google Inc. All Rights Reserved.
-//
-// Licensed under the Apache License, Version 2.0 (the "License");
-// you may not use this file except in compliance with the License.
-// You may obtain a copy of the License at
-//
-// http://www.apache.org/licenses/LICENSE-2.0
-//
-// Unless required by applicable law or agreed to in writing, software
-// distributed under the License is distributed on an "AS IS" BASIS,
-// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-// See the License for the specific language governing permissions and
-// limitations under the License.
-
-#ifndef NINJA_TIMESTAMP_H_
-#define NINJA_TIMESTAMP_H_
-
-#ifdef _WIN32
-#include "win32port.h"
-#else
-#ifndef __STDC_FORMAT_MACROS
-#define __STDC_FORMAT_MACROS
-#endif
-#include <inttypes.h>
-#endif
-
-// When considering file modification times we only care to compare
-// them against one another -- we never convert them to an absolute
-// real time. On POSIX we use timespec (seconds&nanoseconds since epoch)
-// and on Windows we use a different value. Both fit in an int64.
-typedef int64_t TimeStamp;
-
-#endif // NINJA_TIMESTAMP_H_
diff --git a/src/util.cc b/src/util.cc
deleted file mode 100644
index 5b5fbf9..0000000
--- a/src/util.cc
+++ /dev/null
@@ -1,1176 +0,0 @@
-// Copyright 2011 Google Inc. All Rights Reserved.
-//
-// Licensed under the Apache License, Version 2.0 (the "License");
-// you may not use this file except in compliance with the License.
-// You may obtain a copy of the License at
-//
-// http://www.apache.org/licenses/LICENSE-2.0
-//
-// Unless required by applicable law or agreed to in writing, software
-// distributed under the License is distributed on an "AS IS" BASIS,
-// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-// See the License for the specific language governing permissions and
-// limitations under the License.
-
-#include "util.h"
-
-#ifdef __CYGWIN__
-#include <windows.h>
-#include <io.h>
-#elif defined(_WIN32)
-#include <windows.h>
-#include <direct.h>
-#include <io.h>
-#include <share.h>
-#endif
-
-#include <assert.h>
-#include <errno.h>
-#include <fcntl.h>
-#include <limits.h>
-#include <stdarg.h>
-#include <stdio.h>
-#include <stdlib.h>
-#include <string.h>
-#include <sys/stat.h>
-#include <sys/types.h>
-
-#ifndef _WIN32
-#include <unistd.h>
-#include <sys/time.h>
-#endif
-
-#include <vector>
-
-#if defined(__APPLE__)
-#include <mach-o/dyld.h>
-#include <sys/sysctl.h>
-#elif defined(__FreeBSD__)
-#include <sys/sysctl.h>
-#elif defined(__SVR4) && defined(__sun)
-#include <unistd.h>
-#include <sys/loadavg.h>
-#elif defined(_AIX) && !defined(__PASE__)
-#include <libperfstat.h>
-#elif defined(linux) || defined(__GLIBC__)
-#include <sys/sysinfo.h>
-#include <fstream>
-#include <map>
-#include "string_piece_util.h"
-#endif
-
-#if defined(__FreeBSD__)
-#include <sys/cpuset.h>
-#endif
-
-#include "edit_distance.h"
-
-using namespace std;
-
-void Fatal(const char* msg, ...) {
- va_list ap;
- fprintf(stderr, "ninja: fatal: ");
- va_start(ap, msg);
- vfprintf(stderr, msg, ap);
- va_end(ap);
- fprintf(stderr, "\n");
-#ifdef _WIN32
- // On Windows, some tools may inject extra threads.
- // exit() may block on locks held by those threads, so forcibly exit.
- fflush(stderr);
- fflush(stdout);
- ExitProcess(1);
-#else
- exit(1);
-#endif
-}
-
-void Warning(const char* msg, va_list ap) {
- fprintf(stderr, "ninja: warning: ");
- vfprintf(stderr, msg, ap);
- fprintf(stderr, "\n");
-}
-
-void Warning(const char* msg, ...) {
- va_list ap;
- va_start(ap, msg);
- Warning(msg, ap);
- va_end(ap);
-}
-
-void Error(const char* msg, va_list ap) {
- fprintf(stderr, "ninja: error: ");
- vfprintf(stderr, msg, ap);
- fprintf(stderr, "\n");
-}
-
-void Error(const char* msg, ...) {
- va_list ap;
- va_start(ap, msg);
- Error(msg, ap);
- va_end(ap);
-}
-
-void Info(const char* msg, va_list ap) {
- fprintf(stdout, "ninja: ");
- vfprintf(stdout, msg, ap);
- fprintf(stdout, "\n");
-}
-
-void Info(const char* msg, ...) {
- va_list ap;
- va_start(ap, msg);
- Info(msg, ap);
- va_end(ap);
-}
-
-std::string StringFormat(const char* fmt, ...) {
- va_list ap;
- va_start(ap, fmt);
- std::string result;
- StringAppendFormat(result, fmt, ap);
- va_end(ap);
- return result;
-}
-
-std::string StringFormat(const char* fmt, va_list ap) {
- std::string result;
- StringAppendFormat(result, fmt, ap);
- return result;
-}
-
-void StringAppendFormat(std::string& str, const char* fmt, ...) {
- va_list ap;
- va_start(ap, fmt);
- StringAppendFormat(str, fmt, ap);
- va_end(ap);
-}
-
-void StringAppendFormat(std::string& str, const char* fmt, va_list ap) {
- // First try with a small buffer that should cover most cases without
- // heap allocations.
- char buf[32];
- va_list ap2;
- va_copy(ap2, ap);
- int ret = vsnprintf(buf, sizeof(buf), fmt, ap2);
- va_end(ap2);
- if (ret >= 0 && static_cast<size_t>(ret) < sizeof(buf)) {
- str.append(buf, static_cast<size_t>(ret));
- return;
- }
-
- // This did not work, so try with larger buffers in the string itself.
- size_t org_size = str.size();
- str.resize(org_size + 128);
- const int max_retries = 10;
- for (int retries = 0; retries < max_retries; ++retries) {
- size_t available = str.size() - org_size + 1;
- va_copy(ap2, ap);
- int ret = vsnprintf(&str[org_size], available, fmt, ap2);
- va_end(ap2);
-
- if (ret >= 0 && static_cast<size_t>(ret) < available) {
- // Success, shrink to correct size then return.
- str.resize(org_size + static_cast<size_t>(ret));
- return;
- }
-
- if (ret < 0) {
- // Some versions of the MS runtime returned -1 in case of truncation!
- // For these, simply double the buffer size and retry.
- str.resize(org_size + available * 2);
- } else {
- // Ensure correct size for second try.
- str.resize(org_size + static_cast<size_t>(ret));
- }
- }
- Fatal("Could not format string!");
-}
-
-#ifdef _WIN32
-std::wstring ConvertToUnicodeString(const char* str, size_t size) {
- std::wstring result;
- if (size > 0) {
- int int_size = static_cast<int>(size);
- if (static_cast<size_t>(int_size) != size)
- Fatal("Input UTF-8 string is far too long!");
-
- int wide_size = MultiByteToWideChar(CP_UTF8, 0, str, int_size, nullptr, 0);
- if (wide_size <= 0)
- Win32Fatal("MultiByteToWideChar");
-
- result.resize(static_cast<size_t>(wide_size));
- MultiByteToWideChar(CP_UTF8, 0, str, int_size, &result[0], wide_size);
- }
- return result;
-}
-
-std::wstring ConvertToUnicodeString(const std::string& str) {
- return ConvertToUnicodeString(str.c_str(), str.size());
-}
-
-std::string ConvertFromUnicodeString(const wchar_t* str, size_t size) {
- std::string result;
- if (size > 0) {
- int int_size = static_cast<int>(size);
- if (int_size != size)
- Fatal("Input Unicode string is far too long!");
-
- int utf8_size =
- WideCharToMultiByte(CP_UTF8, 0, str, int_size, NULL, 0, NULL, NULL);
- if (utf8_size <= 0)
- Win32Fatal("WideCharToMultiByte");
-
- result.resize(static_cast<size_t>(utf8_size));
- WideCharToMultiByte(CP_UTF8, 0, str, int_size, &result[0], utf8_size, NULL,
- NULL);
- }
- return result;
-}
-
-std::string ConvertFromUnicodeString(const std::wstring& str) {
- return ConvertFromUnicodeString(str.c_str(), str.size());
-}
-
-#endif // _WIN32
-
-void CanonicalizePath(string* path, uint64_t* slash_bits) {
- size_t len = path->size();
- char* str = 0;
- if (len > 0)
- str = &(*path)[0];
- CanonicalizePath(str, &len, slash_bits);
- path->resize(len);
-}
-
-static bool IsPathSeparator(char c) {
-#ifdef _WIN32
- return c == '/' || c == '\\';
-#else
- return c == '/';
-#endif
-}
-
-void CanonicalizePath(char* path, size_t* len, uint64_t* slash_bits) {
- // WARNING: this function is performance-critical; please benchmark
- // any changes you make to it.
- if (*len == 0) {
- return;
- }
-
- const int kMaxPathComponents = 60;
- char* components[kMaxPathComponents];
- int component_count = 0;
-
- char* start = path;
- char* dst = start;
- const char* src = start;
- const char* end = start + *len;
-
- if (IsPathSeparator(*src)) {
-#ifdef _WIN32
-
- // network path starts with //
- if (*len > 1 && IsPathSeparator(*(src + 1))) {
- src += 2;
- dst += 2;
- } else {
- ++src;
- ++dst;
- }
-#else
- ++src;
- ++dst;
-#endif
- }
-
- while (src < end) {
- if (*src == '.') {
- if (src + 1 == end || IsPathSeparator(src[1])) {
- // '.' component; eliminate.
- src += 2;
- continue;
- } else if (src[1] == '.' && (src + 2 == end || IsPathSeparator(src[2]))) {
- // '..' component. Back up if possible.
- if (component_count > 0) {
- dst = components[component_count - 1];
- src += 3;
- --component_count;
- } else {
- *dst++ = *src++;
- *dst++ = *src++;
- *dst++ = *src++;
- }
- continue;
- }
- }
-
- if (IsPathSeparator(*src)) {
- src++;
- continue;
- }
-
- if (component_count == kMaxPathComponents)
- Fatal("path has too many components : %s", path);
- components[component_count] = dst;
- ++component_count;
-
- while (src != end && !IsPathSeparator(*src))
- *dst++ = *src++;
- *dst++ = *src++; // Copy '/' or final \0 character as well.
- }
-
- if (dst == start) {
- *dst++ = '.';
- *dst++ = '\0';
- }
-
- *len = dst - start - 1;
-#ifdef _WIN32
- uint64_t bits = 0;
- uint64_t bits_mask = 1;
-
- for (char* c = start; c < start + *len; ++c) {
- switch (*c) {
- case '\\':
- bits |= bits_mask;
- *c = '/';
- NINJA_FALLTHROUGH;
- case '/':
- bits_mask <<= 1;
- }
- }
-
- *slash_bits = bits;
-#else
- *slash_bits = 0;
-#endif
-}
-
-static inline bool IsKnownShellSafeCharacter(char ch) {
- if ('A' <= ch && ch <= 'Z') return true;
- if ('a' <= ch && ch <= 'z') return true;
- if ('0' <= ch && ch <= '9') return true;
-
- switch (ch) {
- case '_':
- case '+':
- case '-':
- case '.':
- case '/':
- return true;
- default:
- return false;
- }
-}
-
-static inline bool IsKnownWin32SafeCharacter(char ch) {
- switch (ch) {
- case ' ':
- case '"':
- return false;
- default:
- return true;
- }
-}
-
-static inline bool StringNeedsShellEscaping(const string& input) {
- for (size_t i = 0; i < input.size(); ++i) {
- if (!IsKnownShellSafeCharacter(input[i])) return true;
- }
- return false;
-}
-
-static inline bool StringNeedsWin32Escaping(const string& input) {
- for (size_t i = 0; i < input.size(); ++i) {
- if (!IsKnownWin32SafeCharacter(input[i])) return true;
- }
- return false;
-}
-
-void GetShellEscapedString(const string& input, string* result) {
- assert(result);
-
- if (!StringNeedsShellEscaping(input)) {
- result->append(input);
- return;
- }
-
- const char kQuote = '\'';
- const char kEscapeSequence[] = "'\\'";
-
- result->push_back(kQuote);
-
- string::const_iterator span_begin = input.begin();
- for (string::const_iterator it = input.begin(), end = input.end(); it != end;
- ++it) {
- if (*it == kQuote) {
- result->append(span_begin, it);
- result->append(kEscapeSequence);
- span_begin = it;
- }
- }
- result->append(span_begin, input.end());
- result->push_back(kQuote);
-}
-
-
-void GetWin32EscapedString(const string& input, string* result) {
- assert(result);
- if (!StringNeedsWin32Escaping(input)) {
- result->append(input);
- return;
- }
-
- const char kQuote = '"';
- const char kBackslash = '\\';
-
- result->push_back(kQuote);
- size_t consecutive_backslash_count = 0;
- string::const_iterator span_begin = input.begin();
- for (string::const_iterator it = input.begin(), end = input.end(); it != end;
- ++it) {
- switch (*it) {
- case kBackslash:
- ++consecutive_backslash_count;
- break;
- case kQuote:
- result->append(span_begin, it);
- result->append(consecutive_backslash_count + 1, kBackslash);
- span_begin = it;
- consecutive_backslash_count = 0;
- break;
- default:
- consecutive_backslash_count = 0;
- break;
- }
- }
- result->append(span_begin, input.end());
- result->append(consecutive_backslash_count, kBackslash);
- result->push_back(kQuote);
-}
-
-int ReadFile(const string& path, string* contents, string* err) {
-#ifdef _WIN32
- // This makes a ninja run on a set of 1500 manifest files about 4% faster
- // than using the generic fopen code below.
- err->clear();
- HANDLE f = ::CreateFileA(path.c_str(), GENERIC_READ, FILE_SHARE_READ, NULL,
- OPEN_EXISTING, FILE_FLAG_SEQUENTIAL_SCAN, NULL);
- if (f == INVALID_HANDLE_VALUE) {
- err->assign(GetLastErrorString());
- return -ENOENT;
- }
-
- for (;;) {
- DWORD len;
- char buf[64 << 10];
- if (!::ReadFile(f, buf, sizeof(buf), &len, NULL)) {
- err->assign(GetLastErrorString());
- contents->clear();
- ::CloseHandle(f);
- return -EIO;
- }
- if (len == 0)
- break;
- contents->append(buf, len);
- }
- ::CloseHandle(f);
- return 0;
-#else
- FILE* f = fopen(path.c_str(), "rb");
- if (!f) {
- err->assign(strerror(errno));
- return -errno;
- }
-
-#ifdef __USE_LARGEFILE64
- struct stat64 st;
- if (fstat64(fileno(f), &st) < 0) {
-#else
- struct stat st;
- if (fstat(fileno(f), &st) < 0) {
-#endif
- err->assign(strerror(errno));
- fclose(f);
- return -errno;
- }
-
- // +1 is for the resize in ManifestParser::Load
- contents->reserve(st.st_size + 1);
-
- char buf[64 << 10];
- size_t len;
- while (!feof(f) && (len = fread(buf, 1, sizeof(buf), f)) > 0) {
- contents->append(buf, len);
- }
- if (ferror(f)) {
- err->assign(strerror(errno)); // XXX errno?
- contents->clear();
- fclose(f);
- return -errno;
- }
- fclose(f);
- return 0;
-#endif
-}
-
-void SetCloseOnExec(int fd) {
-#ifndef _WIN32
- int flags = fcntl(fd, F_GETFD);
- if (flags < 0) {
- perror("fcntl(F_GETFD)");
- } else {
- if (fcntl(fd, F_SETFD, flags | FD_CLOEXEC) < 0)
- perror("fcntl(F_SETFD)");
- }
-#else
- HANDLE hd = (HANDLE) _get_osfhandle(fd);
- if (! SetHandleInformation(hd, HANDLE_FLAG_INHERIT, 0)) {
- fprintf(stderr, "SetHandleInformation(): %s", GetLastErrorString().c_str());
- }
-#endif // ! _WIN32
-}
-
-
-const char* SpellcheckStringV(const string& text,
- const vector<const char*>& words) {
- const bool kAllowReplacements = true;
- const int kMaxValidEditDistance = 3;
-
- int min_distance = kMaxValidEditDistance + 1;
- const char* result = NULL;
- for (vector<const char*>::const_iterator i = words.begin();
- i != words.end(); ++i) {
- int distance = EditDistance(*i, text, kAllowReplacements,
- kMaxValidEditDistance);
- if (distance < min_distance) {
- min_distance = distance;
- result = *i;
- }
- }
- return result;
-}
-
-const char* SpellcheckString(const char* text, ...) {
- // Note: This takes a const char* instead of a string& because using
- // va_start() with a reference parameter is undefined behavior.
- va_list ap;
- va_start(ap, text);
- vector<const char*> words;
- const char* word;
- while ((word = va_arg(ap, const char*)))
- words.push_back(word);
- va_end(ap);
- return SpellcheckStringV(text, words);
-}
-
-std::string GetCurrentDir() {
- std::string result;
- result.resize(128);
- while (true) {
- if (getcwd(&result[0], result.size()) != nullptr) {
- result.resize(strlen(result.data()));
- return result;
- }
- if (errno != ERANGE)
- ErrnoFatal("Could not get current directory");
-
- result.resize(result.size() * 2);
- }
-}
-
-std::string GetCurrentExecutable() {
- // See
- // https://stackoverflow.com/questions/1023306/finding-current-executables-path-without-proc-self-exe
-#ifdef _WIN32
- wchar_t filename_wide[MAX_PATH];
- DWORD size_wide = GetModuleFileNameW(nullptr, filename_wide, MAX_PATH);
- return ConvertFromUnicodeString(filename_wide, size_wide);
-#elif defined(__APPLE__)
- uint32_t size = 0;
- _NSGetExecutablePath(nullptr, &size);
- std::string result;
- result.resize(size);
- // NOTE: std::string::data() is |char*| since C++17 but
- // was |const char*| before that, so use an explicit const_cast<>
- // below to compile in both modes.
- _NSGetExecutablePath(const_cast<char*>(result.data()), &size);
- return result;
-#elif defined(sun) || defined(__sun) // Solaris
- return std::string(getexename());
-#else // Linux and BSDs
- static const char kProbePath[] =
-#ifdef __linux__
- "/proc/self/exe";
-#elif defined(__FreeBSD__) || defined(__DragonFly__) || defined(__OpenBSD__)
- "/proc/curproc/file";
-#elif defined(__NetBSD__)
- "/proc/curproc/exe";
-#else
-#error "Unknown system!"
-#endif
- char dest_path[PATH_MAX] = {};
- if (readlink(kProbePath, dest_path, PATH_MAX) < 0)
- ErrnoFatal("readlink");
- return std::string(dest_path);
-#endif
-}
-
-std::string GetCurrentExecutableDir() {
- std::string program = GetCurrentExecutable();
-#ifdef _WIN32
- char sep = '\\';
-#else
- char sep = '/';
-#endif
- size_t pos = program.rfind(sep);
- if (pos == std::string::npos || pos == 0)
- Fatal("Could not get path to current executable!");
- return program.substr(0, pos);
-}
-#ifdef _WIN32
-std::string GetLastErrorString(unsigned err) {
- char* msg_buf;
- FormatMessageA(
- FORMAT_MESSAGE_ALLOCATE_BUFFER |
- FORMAT_MESSAGE_FROM_SYSTEM |
- FORMAT_MESSAGE_IGNORE_INSERTS,
- NULL,
- err,
- MAKELANGID(LANG_NEUTRAL, SUBLANG_DEFAULT),
- (char*)&msg_buf,
- 0,
- NULL);
- std::string msg = msg_buf;
- LocalFree(msg_buf);
- return msg;
-}
-
-std::string GetLastErrorString() {
- return GetLastErrorString(GetLastError());
-}
-
-void Win32Fatal(const char* function, const char* hint) {
- Win32Fatal(function, GetLastError(), hint);
-}
-
-void Win32Fatal(const char* function, unsigned long error, const char* hint) {
- if (hint) {
- Fatal("%s: %s (%s)", function, GetLastErrorString(error).c_str(), hint);
- } else {
- Fatal("%s: %s", function, GetLastErrorString(error).c_str());
- }
-}
-#endif // _WIN32
-
-void ErrnoFatal(const char* function, const char* hint) {
- ErrnoFatal(function, errno, hint);
-}
-
-void ErrnoFatal(const char* function, int errnum, const char* hint) {
- if (hint) {
- Fatal("%s: %s (%s)", function, strerror(errnum), hint);
- } else {
- Fatal("%s: %s", function, strerror(errnum));
- }
-}
-
-bool islatinalpha(int c) {
- // isalpha() is locale-dependent.
- return (c >= 'a' && c <= 'z') || (c >= 'A' && c <= 'Z');
-}
-
-string StripAnsiEscapeCodes(const string& in) {
- string stripped;
- stripped.reserve(in.size());
-
- for (size_t i = 0; i < in.size(); ++i) {
- if (in[i] != '\33') {
- // Not an escape code.
- stripped.push_back(in[i]);
- continue;
- }
-
- // Only strip CSIs for now.
- if (i + 1 >= in.size()) break;
- if (in[i + 1] != '[') continue; // Not a CSI.
- i += 2;
-
- // Skip everything up to and including the next [a-zA-Z].
- while (i < in.size() && !islatinalpha(in[i]))
- ++i;
- }
- return stripped;
-}
-
-#if defined(linux) || defined(__GLIBC__)
-std::pair<int64_t, bool> readCount(const std::string& path) {
- std::ifstream file(path.c_str());
- if (!file.is_open())
- return std::make_pair(0, false);
- int64_t n = 0;
- file >> n;
- if (file.good())
- return std::make_pair(n, true);
- return std::make_pair(0, false);
-}
-
-struct MountPoint {
- int mountId;
- int parentId;
- StringPiece deviceId;
- StringPiece root;
- StringPiece mountPoint;
- vector<StringPiece> options;
- vector<StringPiece> optionalFields;
- StringPiece fsType;
- StringPiece mountSource;
- vector<StringPiece> superOptions;
- bool parse(const string& line) {
- vector<StringPiece> pieces = SplitStringPiece(line, ' ');
- if (pieces.size() < 10)
- return false;
- size_t optionalStart = 0;
- for (size_t i = 6; i < pieces.size(); i++) {
- if (pieces[i] == "-") {
- optionalStart = i + 1;
- break;
- }
- }
- if (optionalStart == 0)
- return false;
- if (optionalStart + 3 != pieces.size())
- return false;
- mountId = atoi(pieces[0].AsString().c_str());
- parentId = atoi(pieces[1].AsString().c_str());
- deviceId = pieces[2];
- root = pieces[3];
- mountPoint = pieces[4];
- options = SplitStringPiece(pieces[5], ',');
- optionalFields =
- vector<StringPiece>(&pieces[6], &pieces[optionalStart - 1]);
- fsType = pieces[optionalStart];
- mountSource = pieces[optionalStart + 1];
- superOptions = SplitStringPiece(pieces[optionalStart + 2], ',');
- return true;
- }
- string translate(string& path) const {
- // path must be sub dir of root
- if (path.compare(0, root.len_, root.str_, root.len_) != 0) {
- return string();
- }
- path.erase(0, root.len_);
- if (path == ".." || (path.length() > 2 && path.compare(0, 3, "../") == 0)) {
- return string();
- }
- return mountPoint.AsString() + "/" + path;
- }
-};
-
-struct CGroupSubSys {
- int id;
- string name;
- vector<string> subsystems;
- bool parse(string& line) {
- size_t first = line.find(':');
- if (first == string::npos)
- return false;
- line[first] = '\0';
- size_t second = line.find(':', first + 1);
- if (second == string::npos)
- return false;
- line[second] = '\0';
- id = atoi(line.c_str());
- name = line.substr(second + 1);
- vector<StringPiece> pieces =
- SplitStringPiece(StringPiece(line.c_str() + first + 1), ',');
- for (size_t i = 0; i < pieces.size(); i++) {
- subsystems.push_back(pieces[i].AsString());
- }
- return true;
- }
-};
-
-map<string, string> ParseMountInfo(map<string, CGroupSubSys>& subsystems) {
- map<string, string> cgroups;
- ifstream mountinfo("/proc/self/mountinfo");
- if (!mountinfo.is_open())
- return cgroups;
- while (!mountinfo.eof()) {
- string line;
- getline(mountinfo, line);
- MountPoint mp;
- if (!mp.parse(line))
- continue;
- if (mp.fsType != "cgroup")
- continue;
- for (size_t i = 0; i < mp.superOptions.size(); i++) {
- string opt = mp.superOptions[i].AsString();
- map<string, CGroupSubSys>::iterator subsys = subsystems.find(opt);
- if (subsys == subsystems.end())
- continue;
- string newPath = mp.translate(subsys->second.name);
- if (!newPath.empty())
- cgroups.insert(make_pair(opt, newPath));
- }
- }
- return cgroups;
-}
-
-map<string, CGroupSubSys> ParseSelfCGroup() {
- map<string, CGroupSubSys> cgroups;
- ifstream cgroup("/proc/self/cgroup");
- if (!cgroup.is_open())
- return cgroups;
- string line;
- while (!cgroup.eof()) {
- getline(cgroup, line);
- CGroupSubSys subsys;
- if (!subsys.parse(line))
- continue;
- for (size_t i = 0; i < subsys.subsystems.size(); i++) {
- cgroups.insert(make_pair(subsys.subsystems[i], subsys));
- }
- }
- return cgroups;
-}
-
-int ParseCPUFromCGroup() {
- map<string, CGroupSubSys> subsystems = ParseSelfCGroup();
- map<string, string> cgroups = ParseMountInfo(subsystems);
- map<string, string>::iterator cpu = cgroups.find("cpu");
- if (cpu == cgroups.end())
- return -1;
- std::pair<int64_t, bool> quota = readCount(cpu->second + "/cpu.cfs_quota_us");
- if (!quota.second || quota.first == -1)
- return -1;
- std::pair<int64_t, bool> period =
- readCount(cpu->second + "/cpu.cfs_period_us");
- if (!period.second)
- return -1;
- if (period.first == 0)
- return -1;
- return quota.first / period.first;
-}
-#endif
-
-int GetProcessorCount() {
-#ifdef _WIN32
- DWORD cpuCount = 0;
-#ifndef _WIN64
- // Need to use GetLogicalProcessorInformationEx to get real core count on
- // machines with >64 cores. See https://stackoverflow.com/a/31209344/21475
- DWORD len = 0;
- if (!GetLogicalProcessorInformationEx(RelationProcessorCore, nullptr, &len)
- && GetLastError() == ERROR_INSUFFICIENT_BUFFER) {
- std::vector<char> buf(len);
- int cores = 0;
- if (GetLogicalProcessorInformationEx(RelationProcessorCore,
- reinterpret_cast<PSYSTEM_LOGICAL_PROCESSOR_INFORMATION_EX>(
- buf.data()), &len)) {
- for (DWORD i = 0; i < len; ) {
- auto info = reinterpret_cast<PSYSTEM_LOGICAL_PROCESSOR_INFORMATION_EX>(
- buf.data() + i);
- if (info->Relationship == RelationProcessorCore &&
- info->Processor.GroupCount == 1) {
- for (KAFFINITY core_mask = info->Processor.GroupMask[0].Mask;
- core_mask; core_mask >>= 1) {
- cores += (core_mask & 1);
- }
- }
- i += info->Size;
- }
- if (cores != 0) {
- cpuCount = cores;
- }
- }
- }
-#endif
- if (cpuCount == 0) {
- cpuCount = GetActiveProcessorCount(ALL_PROCESSOR_GROUPS);
- }
- JOBOBJECT_CPU_RATE_CONTROL_INFORMATION info;
- // reference:
- // https://docs.microsoft.com/en-us/windows/win32/api/winnt/ns-winnt-jobobject_cpu_rate_control_information
- if (QueryInformationJobObject(NULL, JobObjectCpuRateControlInformation, &info,
- sizeof(info), NULL)) {
- if (info.ControlFlags & (JOB_OBJECT_CPU_RATE_CONTROL_ENABLE |
- JOB_OBJECT_CPU_RATE_CONTROL_HARD_CAP)) {
- return cpuCount * info.CpuRate / 10000;
- }
- }
- return cpuCount;
-#else
- int cgroupCount = -1;
- int schedCount = -1;
-#if defined(linux) || defined(__GLIBC__)
- cgroupCount = ParseCPUFromCGroup();
-#endif
- // The number of exposed processors might not represent the actual number of
- // processors threads can run on. This happens when a CPU set limitation is
- // active, see https://github.com/ninja-build/ninja/issues/1278
-#if defined(__FreeBSD__)
- cpuset_t mask;
- CPU_ZERO(&mask);
- if (cpuset_getaffinity(CPU_LEVEL_WHICH, CPU_WHICH_TID, -1, sizeof(mask),
- &mask) == 0) {
- return CPU_COUNT(&mask);
- }
-#elif defined(CPU_COUNT)
- cpu_set_t set;
- if (sched_getaffinity(getpid(), sizeof(set), &set) == 0) {
- schedCount = CPU_COUNT(&set);
- }
-#endif
- if (cgroupCount >= 0 && schedCount >= 0) return std::min(cgroupCount, schedCount);
- if (cgroupCount < 0 && schedCount < 0) return sysconf(_SC_NPROCESSORS_ONLN);
- return std::max(cgroupCount, schedCount);
-#endif
-}
-
-#if defined(_WIN32) || defined(__CYGWIN__)
-static double CalculateProcessorLoad(uint64_t idle_ticks, uint64_t total_ticks)
-{
- static uint64_t previous_idle_ticks = 0;
- static uint64_t previous_total_ticks = 0;
- static double previous_load = -0.0;
-
- uint64_t idle_ticks_since_last_time = idle_ticks - previous_idle_ticks;
- uint64_t total_ticks_since_last_time = total_ticks - previous_total_ticks;
-
- bool first_call = (previous_total_ticks == 0);
- bool ticks_not_updated_since_last_call = (total_ticks_since_last_time == 0);
-
- double load;
- if (first_call || ticks_not_updated_since_last_call) {
- load = previous_load;
- } else {
- // Calculate load.
- double idle_to_total_ratio =
- ((double)idle_ticks_since_last_time) / total_ticks_since_last_time;
- double load_since_last_call = 1.0 - idle_to_total_ratio;
-
- // Filter/smooth result when possible.
- if(previous_load > 0) {
- load = 0.9 * previous_load + 0.1 * load_since_last_call;
- } else {
- load = load_since_last_call;
- }
- }
-
- previous_load = load;
- previous_total_ticks = total_ticks;
- previous_idle_ticks = idle_ticks;
-
- return load;
-}
-
-static uint64_t FileTimeToTickCount(const FILETIME & ft)
-{
- uint64_t high = (((uint64_t)(ft.dwHighDateTime)) << 32);
- uint64_t low = ft.dwLowDateTime;
- return (high | low);
-}
-
-double GetLoadAverage() {
- FILETIME idle_time, kernel_time, user_time;
- BOOL get_system_time_succeeded =
- GetSystemTimes(&idle_time, &kernel_time, &user_time);
-
- double posix_compatible_load;
- if (get_system_time_succeeded) {
- uint64_t idle_ticks = FileTimeToTickCount(idle_time);
-
- // kernel_time from GetSystemTimes already includes idle_time.
- uint64_t total_ticks =
- FileTimeToTickCount(kernel_time) + FileTimeToTickCount(user_time);
-
- double processor_load = CalculateProcessorLoad(idle_ticks, total_ticks);
- posix_compatible_load = processor_load * GetProcessorCount();
-
- } else {
- posix_compatible_load = -0.0;
- }
-
- return posix_compatible_load;
-}
-#elif defined(__PASE__)
-double GetLoadAverage() {
- return -0.0f;
-}
-#elif defined(_AIX)
-double GetLoadAverage() {
- perfstat_cpu_total_t cpu_stats;
- if (perfstat_cpu_total(NULL, &cpu_stats, sizeof(cpu_stats), 1) < 0) {
- return -0.0f;
- }
-
- // Calculation taken from comment in libperfstats.h
- return double(cpu_stats.loadavg[0]) / double(1 << SBITS);
-}
-#elif defined(__UCLIBC__) || (defined(__BIONIC__) && __ANDROID_API__ < 29)
-double GetLoadAverage() {
- struct sysinfo si;
- if (sysinfo(&si) != 0)
- return -0.0f;
- return 1.0 / (1 << SI_LOAD_SHIFT) * si.loads[0];
-}
-#elif defined(__HAIKU__)
-double GetLoadAverage() {
- return -0.0f;
-}
-#else
-double GetLoadAverage() {
- double loadavg[3] = { 0.0f, 0.0f, 0.0f };
- if (getloadavg(loadavg, 3) < 0) {
- // Maybe we should return an error here or the availability of
- // getloadavg(3) should be checked when ninja is configured.
- return -0.0f;
- }
- return loadavg[0];
-}
-#endif // _WIN32
-
-string ElideMiddle(const string& str, size_t width) {
- switch (width) {
- case 0: return "";
- case 1: return ".";
- case 2: return "..";
- case 3: return "...";
- }
- const int kMargin = 3; // Space for "...".
- string result = str;
- if (result.size() > width) {
- size_t elide_size = (width - kMargin) / 2;
- result = result.substr(0, elide_size)
- + "..."
- + result.substr(result.size() - elide_size, elide_size);
- }
- return result;
-}
-
-bool Truncate(const string& path, size_t size, string* err) {
-#ifdef _WIN32
- int fh = _sopen(path.c_str(), _O_RDWR | _O_CREAT, _SH_DENYNO,
- _S_IREAD | _S_IWRITE);
- int success = _chsize(fh, size);
- _close(fh);
-#else
- int success = truncate(path.c_str(), size);
-#endif
- // Both truncate() and _chsize() return 0 on success and set errno and return
- // -1 on failure.
- if (success < 0) {
- *err = strerror(errno);
- return false;
- }
- return true;
-}
-
-bool RunsUnderWine() {
-#ifdef _WIN32
- auto probe_wine = []() -> bool {
- HMODULE module = ::GetModuleHandle("ntdll.dll");
- if (!module)
- return false;
- return ::GetProcAddress(module, "wine_get_version") != nullptr;
- };
- static bool runs_under_wine = probe_wine();
- return runs_under_wine;
-#else
- return false;
-#endif
-}
-
-#ifdef _WIN32
-int64_t TimeStampFromFileTime(const FILETIME& filetime) {
- // FILETIME is in 100-nanosecond increments since the Windows epoch.
- // We don't much care about epoch correctness but we do want the
- // resulting value to fit in a 64-bit integer.
- uint64_t mtime = ((uint64_t)filetime.dwHighDateTime << 32) |
- ((uint64_t)filetime.dwLowDateTime);
- // 1600 epoch -> 2000 epoch (subtract 400 years).
- return (int64_t)mtime - 12622770400LL * (1000000000LL / 100);
-}
-#endif // _WIN32
-
-int64_t GetFileTimestamp(const std::string& path, std::string* error) {
-#ifdef _WIN32
- WIN32_FILE_ATTRIBUTE_DATA attrs;
- if (!GetFileAttributesExA(path.c_str(), GetFileExInfoStandard, &attrs)) {
- DWORD win_err = GetLastError();
- if (win_err == ERROR_FILE_NOT_FOUND || win_err == ERROR_PATH_NOT_FOUND)
- return 0;
-
- *error = StringFormat("GetFileAttributesExA(%s): %s", path.c_str(),
- GetLastErrorString(win_err).c_str());
- return -1;
- }
- return TimeStampFromFileTime(attrs.ftLastWriteTime);
-#else // !_WIN32
-#ifdef __USE_LARGEFILE64
- struct stat64 st;
- if (stat64(path.c_str(), &st) < 0) {
-#else
- struct stat st;
- if (stat(path.c_str(), &st) < 0) {
-#endif
- if (errno == ENOENT || errno == ENOTDIR)
- return 0;
- *error = StringFormat("stat(%s): %s", path.c_str(), strerror(errno));
- return -1;
- }
- // Some users (Flatpak) set mtime to 0, this should be harmless
- // and avoids conflicting with our return value of 0 meaning
- // that it doesn't exist.
- if (st.st_mtime == 0)
- return 1;
-#if defined(_AIX)
- return (int64_t)st.st_mtime * 1000000000LL + st.st_mtime_n;
-#elif defined(__APPLE__)
- return ((int64_t)st.st_mtimespec.tv_sec * 1000000000LL +
- st.st_mtimespec.tv_nsec);
-#elif defined(st_mtime) // A macro, so we're likely on modern POSIX.
-return (int64_t)st.st_mtim.tv_sec * 1000000000LL + st.st_mtim.tv_nsec;
-#else // !defined(st_mtime)
-return (int64_t)st.st_mtime * 1000000000LL + st.st_mtimensec;
-#endif // !defined(st_mtime)
-#endif // !_WIN32
-}
-
-void AppendStringFormatDurationMs(std::string& out, int64_t duration_ms) {
- if (duration_ms < 0) {
- out += '-';
- duration_ms = -duration_ms;
- }
- if (duration_ms < 1000) {
- StringAppendFormat(out, "%u ms", static_cast<unsigned>(duration_ms));
- } else if (duration_ms < 10000) {
- StringAppendFormat(out, "%u.%02u s",
- static_cast<unsigned>(duration_ms / 1000),
- static_cast<unsigned>((duration_ms % 1000) / 10));
- } else if (duration_ms < 60000) {
- StringAppendFormat(out, "%u.%01u s",
- static_cast<unsigned>(duration_ms / 1000),
- static_cast<unsigned>((duration_ms % 1000) / 100));
- } else {
- int64_t seconds = duration_ms / 1000;
- if (seconds < 3600) {
- StringAppendFormat(out, "%u:%02u min",
- static_cast<unsigned>(seconds / 60),
- static_cast<unsigned>(seconds % 60));
- } else {
- StringAppendFormat(out, "%u:%02u:%02u hr",
- static_cast<unsigned>(seconds / 3600),
- static_cast<unsigned>((seconds % 3600) / 60),
- static_cast<unsigned>(seconds % 60));
- }
- }
-}
-
-std::string StringFormatDurationMs(int64_t duration_ms) {
- std::string result;
- AppendStringFormatDurationMs(result, duration_ms);
- return result;
-}
diff --git a/src/util.h b/src/util.h
deleted file mode 100644
index c260b76..0000000
--- a/src/util.h
+++ /dev/null
@@ -1,183 +0,0 @@
-// Copyright 2011 Google Inc. All Rights Reserved.
-//
-// Licensed under the Apache License, Version 2.0 (the "License");
-// you may not use this file except in compliance with the License.
-// You may obtain a copy of the License at
-//
-// http://www.apache.org/licenses/LICENSE-2.0
-//
-// Unless required by applicable law or agreed to in writing, software
-// distributed under the License is distributed on an "AS IS" BASIS,
-// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-// See the License for the specific language governing permissions and
-// limitations under the License.
-
-#ifndef NINJA_UTIL_H_
-#define NINJA_UTIL_H_
-
-#ifdef _WIN32
-#include <windows.h>
-#undef ERROR
-#undef min
-#undef max
-#include "win32port.h"
-#else
-#include <stdint.h>
-#endif
-
-#include <stdarg.h>
-
-#include <string>
-#include <vector>
-
-#ifdef _MSC_VER
-#define NORETURN __declspec(noreturn)
-#else
-#define NORETURN __attribute__((noreturn))
-#endif
-
-/// Log a fatal message and exit.
-NORETURN void Fatal(const char* msg, ...);
-
-// Have a generic fall-through for different versions of C/C++.
-#if defined(__cplusplus) && __cplusplus >= 201703L
-#define NINJA_FALLTHROUGH [[fallthrough]]
-#elif defined(__cplusplus) && __cplusplus >= 201103L && defined(__clang__)
-#define NINJA_FALLTHROUGH [[clang::fallthrough]]
-#elif defined(__cplusplus) && __cplusplus >= 201103L && defined(__GNUC__) && \
- __GNUC__ >= 7
-#define NINJA_FALLTHROUGH [[gnu::fallthrough]]
-#elif defined(__GNUC__) && __GNUC__ >= 7 // gcc 7
-#define NINJA_FALLTHROUGH __attribute__ ((fallthrough))
-#else // C++11 on gcc 6, and all other cases
-#define NINJA_FALLTHROUGH
-#endif
-
-/// Log a warning message.
-void Warning(const char* msg, ...);
-void Warning(const char* msg, va_list ap);
-
-/// Log an error message.
-void Error(const char* msg, ...);
-void Error(const char* msg, va_list ap);
-
-/// Log an informational message.
-void Info(const char* msg, ...);
-void Info(const char* msg, va_list ap);
-
-/// Format a string.
-std::string StringFormat(const char* fmt, ...);
-std::string StringFormat(const char* fmt, va_list ap);
-void StringAppendFormat(std::string& str, const char* fmt, ...);
-void StringAppendFormat(std::string& str, const char* fmt, va_list ap);
-
-/// Canonicalize a path like "foo/../bar.h" into just "bar.h".
-/// |slash_bits| has bits set starting from lowest for a backslash that was
-/// normalized to a forward slash. (only used on Windows)
-void CanonicalizePath(std::string* path, uint64_t* slash_bits);
-void CanonicalizePath(char* path, size_t* len, uint64_t* slash_bits);
-
-/// Appends |input| to |*result|, escaping according to the whims of either
-/// Bash, or Win32's CommandLineToArgvW().
-/// Appends the string directly to |result| without modification if we can
-/// determine that it contains no problematic characters.
-void GetShellEscapedString(const std::string& input, std::string* result);
-void GetWin32EscapedString(const std::string& input, std::string* result);
-
-/// Read a file to a string (in text mode: with CRLF conversion
-/// on Windows).
-/// Returns -errno and fills in \a err on error.
-int ReadFile(const std::string& path, std::string* contents, std::string* err);
-
-/// Get the timestamp of a given file. On success return a positive timestamp
-/// in nanoseconds, or 0 if the file is missing. Otherwise, in case of failure,
-/// return -1 after setting |*error|.
-int64_t GetFileTimestamp(const std::string& path, std::string* error);
-
-#ifdef _WIN32
-/// Convert a Win32 FILETIME value into a TimeStamp value.
-int64_t TimeStampFromFileTime(const FILETIME& filetime);
-#endif // _WIN32
-
-/// Mark a file descriptor to not be inherited on exec()s.
-void SetCloseOnExec(int fd);
-
-/// Given a misspelled string and a list of correct spellings, returns
-/// the closest match or NULL if there is no close enough match.
-const char* SpellcheckStringV(const std::string& text,
- const std::vector<const char*>& words);
-
-/// Like SpellcheckStringV, but takes a NULL-terminated list.
-const char* SpellcheckString(const char* text, ...);
-
-bool islatinalpha(int c);
-
-/// Removes all Ansi escape codes (http://www.termsys.demon.co.uk/vtansi.htm).
-std::string StripAnsiEscapeCodes(const std::string& in);
-
-/// @return the number of processors on the machine. Useful for an initial
-/// guess for how many jobs to run in parallel. @return 0 on error.
-int GetProcessorCount();
-
-/// @return the load average of the machine. A negative value is returned
-/// on error.
-double GetLoadAverage();
-
-/// Elide the given string @a str with '...' in the middle if the length
-/// exceeds @a width.
-std::string ElideMiddle(const std::string& str, size_t width);
-
-/// Truncates a file to the given size.
-bool Truncate(const std::string& path, size_t size, std::string* err);
-
-/// Return absolute path of current directory.
-/// NOTE: GetCurrentDirectory() is a macro in Win32.
-std::string GetCurrentDir();
-
-/// Return absolute path of current executable.
-std::string GetCurrentExecutable();
-
-/// Return absolute path of current executable's directory.
-std::string GetCurrentExecutableDir();
-
-#ifdef _MSC_VER
-#define snprintf _snprintf
-#define fileno _fileno
-#define unlink _unlink
-#define chdir _chdir
-#define strtoull _strtoui64
-#define getcwd _getcwd
-#define PATH_MAX _MAX_PATH
-#endif
-
-#ifdef _WIN32
-/// Convert the value returned by GetLastError() into a string.
-std::string GetLastErrorString();
-std::string GetLastErrorString(unsigned error);
-
-/// Calls Fatal() with a function name and GetLastErrorString.
-NORETURN void Win32Fatal(const char* function, const char* hint = NULL);
-NORETURN void Win32Fatal(const char* function, unsigned long error,
- const char* hint = NULL);
-#endif // !_WIN32
-
-NORETURN void ErrnoFatal(const char* function, const char* hint = NULL);
-NORETURN void ErrnoFatal(const char* function, int errnum, const char* hint = NULL);
-
-/// Convert Unide code to Utf8 string.
-std::string ConvertFromUnicodeString(const wchar_t* str, size_t size);
-std::string ConvertFromUnicodeString(const std::wstring& str);
-
-/// Convert UTF8 string to a Win32 unicode string.
-std::wstring ConvertToUnicodeString(const char* str, size_t size);
-std::wstring ConvertToUnicodeString(const std::string& str);
-
-/// Convert a duration in milliseconds into a human-readable string.
-void AppendStringFormatDurationMs(std::string& out, int64_t duration_ms);
-std::string StringFormatDurationMs(int64_t duration_ms);
-
-/// Returns true if this is a Win32 program running under Wine. Only used
-/// to work-around Wine emulation bugs during unit-testing.
-bool RunsUnderWine();
-
-#endif // NINJA_UTIL_H_
diff --git a/src/util_test.cc b/src/util_test.cc
deleted file mode 100644
index a9a7956..0000000
--- a/src/util_test.cc
+++ /dev/null
@@ -1,518 +0,0 @@
-// Copyright 2011 Google Inc. All Rights Reserved.
-//
-// Licensed under the Apache License, Version 2.0 (the "License");
-// you may not use this file except in compliance with the License.
-// You may obtain a copy of the License at
-//
-// http://www.apache.org/licenses/LICENSE-2.0
-//
-// Unless required by applicable law or agreed to in writing, software
-// distributed under the License is distributed on an "AS IS" BASIS,
-// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-// See the License for the specific language governing permissions and
-// limitations under the License.
-
-#include "util.h"
-
-#include "test.h"
-
-using namespace std;
-
-namespace {
-
-void CanonicalizePath(string* path) {
- uint64_t unused;
- ::CanonicalizePath(path, &unused);
-}
-
-} // namespace
-
-TEST(CanonicalizePath, PathSamples) {
- string path;
-
- CanonicalizePath(&path);
- EXPECT_EQ("", path);
-
- path = "foo.h";
- CanonicalizePath(&path);
- EXPECT_EQ("foo.h", path);
-
- path = "./foo.h";
- CanonicalizePath(&path);
- EXPECT_EQ("foo.h", path);
-
- path = "./foo/./bar.h";
- CanonicalizePath(&path);
- EXPECT_EQ("foo/bar.h", path);
-
- path = "./x/foo/../bar.h";
- CanonicalizePath(&path);
- EXPECT_EQ("x/bar.h", path);
-
- path = "./x/foo/../../bar.h";
- CanonicalizePath(&path);
- EXPECT_EQ("bar.h", path);
-
- path = "foo//bar";
- CanonicalizePath(&path);
- EXPECT_EQ("foo/bar", path);
-
- path = "foo//.//..///bar";
- CanonicalizePath(&path);
- EXPECT_EQ("bar", path);
-
- path = "./x/../foo/../../bar.h";
- CanonicalizePath(&path);
- EXPECT_EQ("../bar.h", path);
-
- path = "foo/./.";
- CanonicalizePath(&path);
- EXPECT_EQ("foo", path);
-
- path = "foo/bar/..";
- CanonicalizePath(&path);
- EXPECT_EQ("foo", path);
-
- path = "foo/.hidden_bar";
- CanonicalizePath(&path);
- EXPECT_EQ("foo/.hidden_bar", path);
-
- path = "/foo";
- CanonicalizePath(&path);
- EXPECT_EQ("/foo", path);
-
- path = "//foo";
- CanonicalizePath(&path);
-#ifdef _WIN32
- EXPECT_EQ("//foo", path);
-#else
- EXPECT_EQ("/foo", path);
-#endif
-
- path = "/";
- CanonicalizePath(&path);
- EXPECT_EQ("", path);
-
- path = "/foo/..";
- CanonicalizePath(&path);
- EXPECT_EQ("", path);
-
- path = ".";
- CanonicalizePath(&path);
- EXPECT_EQ(".", path);
-
- path = "./.";
- CanonicalizePath(&path);
- EXPECT_EQ(".", path);
-
- path = "foo/..";
- CanonicalizePath(&path);
- EXPECT_EQ(".", path);
-}
-
-#ifdef _WIN32
-TEST(CanonicalizePath, PathSamplesWindows) {
- string path;
-
- CanonicalizePath(&path);
- EXPECT_EQ("", path);
-
- path = "foo.h";
- CanonicalizePath(&path);
- EXPECT_EQ("foo.h", path);
-
- path = ".\\foo.h";
- CanonicalizePath(&path);
- EXPECT_EQ("foo.h", path);
-
- path = ".\\foo\\.\\bar.h";
- CanonicalizePath(&path);
- EXPECT_EQ("foo/bar.h", path);
-
- path = ".\\x\\foo\\..\\bar.h";
- CanonicalizePath(&path);
- EXPECT_EQ("x/bar.h", path);
-
- path = ".\\x\\foo\\..\\..\\bar.h";
- CanonicalizePath(&path);
- EXPECT_EQ("bar.h", path);
-
- path = "foo\\\\bar";
- CanonicalizePath(&path);
- EXPECT_EQ("foo/bar", path);
-
- path = "foo\\\\.\\\\..\\\\\\bar";
- CanonicalizePath(&path);
- EXPECT_EQ("bar", path);
-
- path = ".\\x\\..\\foo\\..\\..\\bar.h";
- CanonicalizePath(&path);
- EXPECT_EQ("../bar.h", path);
-
- path = "foo\\.\\.";
- CanonicalizePath(&path);
- EXPECT_EQ("foo", path);
-
- path = "foo\\bar\\..";
- CanonicalizePath(&path);
- EXPECT_EQ("foo", path);
-
- path = "foo\\.hidden_bar";
- CanonicalizePath(&path);
- EXPECT_EQ("foo/.hidden_bar", path);
-
- path = "\\foo";
- CanonicalizePath(&path);
- EXPECT_EQ("/foo", path);
-
- path = "\\\\foo";
- CanonicalizePath(&path);
- EXPECT_EQ("//foo", path);
-
- path = "\\";
- CanonicalizePath(&path);
- EXPECT_EQ("", path);
-}
-
-TEST(CanonicalizePath, SlashTracking) {
- string path;
- uint64_t slash_bits;
-
- path = "foo.h";
- CanonicalizePath(&path, &slash_bits);
- EXPECT_EQ("foo.h", path);
- EXPECT_EQ(0, slash_bits);
-
- path = "a\\foo.h";
- CanonicalizePath(&path, &slash_bits);
- EXPECT_EQ("a/foo.h", path);
- EXPECT_EQ(1, slash_bits);
-
- path = "a/bcd/efh\\foo.h";
- CanonicalizePath(&path, &slash_bits);
- EXPECT_EQ("a/bcd/efh/foo.h", path);
- EXPECT_EQ(4, slash_bits);
-
- path = "a\\bcd/efh\\foo.h";
- CanonicalizePath(&path, &slash_bits);
- EXPECT_EQ("a/bcd/efh/foo.h", path);
- EXPECT_EQ(5, slash_bits);
-
- path = "a\\bcd\\efh\\foo.h";
- CanonicalizePath(&path, &slash_bits);
- EXPECT_EQ("a/bcd/efh/foo.h", path);
- EXPECT_EQ(7, slash_bits);
-
- path = "a/bcd/efh/foo.h";
- CanonicalizePath(&path, &slash_bits);
- EXPECT_EQ("a/bcd/efh/foo.h", path);
- EXPECT_EQ(0, slash_bits);
-
- path = "a\\./efh\\foo.h";
- CanonicalizePath(&path, &slash_bits);
- EXPECT_EQ("a/efh/foo.h", path);
- EXPECT_EQ(3, slash_bits);
-
- path = "a\\../efh\\foo.h";
- CanonicalizePath(&path, &slash_bits);
- EXPECT_EQ("efh/foo.h", path);
- EXPECT_EQ(1, slash_bits);
-
- path = "a\\b\\c\\d\\e\\f\\g\\foo.h";
- CanonicalizePath(&path, &slash_bits);
- EXPECT_EQ("a/b/c/d/e/f/g/foo.h", path);
- EXPECT_EQ(127, slash_bits);
-
- path = "a\\b\\c\\..\\..\\..\\g\\foo.h";
- CanonicalizePath(&path, &slash_bits);
- EXPECT_EQ("g/foo.h", path);
- EXPECT_EQ(1, slash_bits);
-
- path = "a\\b/c\\../../..\\g\\foo.h";
- CanonicalizePath(&path, &slash_bits);
- EXPECT_EQ("g/foo.h", path);
- EXPECT_EQ(1, slash_bits);
-
- path = "a\\b/c\\./../..\\g\\foo.h";
- CanonicalizePath(&path, &slash_bits);
- EXPECT_EQ("a/g/foo.h", path);
- EXPECT_EQ(3, slash_bits);
-
- path = "a\\b/c\\./../..\\g/foo.h";
- CanonicalizePath(&path, &slash_bits);
- EXPECT_EQ("a/g/foo.h", path);
- EXPECT_EQ(1, slash_bits);
-
- path = "a\\\\\\foo.h";
- CanonicalizePath(&path, &slash_bits);
- EXPECT_EQ("a/foo.h", path);
- EXPECT_EQ(1, slash_bits);
-
- path = "a/\\\\foo.h";
- CanonicalizePath(&path, &slash_bits);
- EXPECT_EQ("a/foo.h", path);
- EXPECT_EQ(0, slash_bits);
-
- path = "a\\//foo.h";
- CanonicalizePath(&path, &slash_bits);
- EXPECT_EQ("a/foo.h", path);
- EXPECT_EQ(1, slash_bits);
-}
-
-TEST(CanonicalizePath, CanonicalizeNotExceedingLen) {
- // Make sure searching \/ doesn't go past supplied len.
- char buf[] = "foo/bar\\baz.h\\"; // Last \ past end.
- uint64_t slash_bits;
- size_t size = 13;
- ::CanonicalizePath(buf, &size, &slash_bits);
- EXPECT_EQ(0, strncmp("foo/bar/baz.h", buf, size));
- EXPECT_EQ(2, slash_bits); // Not including the trailing one.
-}
-
-TEST(CanonicalizePath, TooManyComponents) {
- string path;
- uint64_t slash_bits;
-
- // 64 is OK.
- path = "a/./a/./a/./a/./a/./a/./a/./a/./a/./a/./a/./a/./a/./a/./a/./a/./"
- "a/./a/./a/./a/./a/./a/./a/./a/./a/./a/./a/./a/./a/./a/./a/./a/./x.h";
- CanonicalizePath(&path, &slash_bits);
- EXPECT_EQ(slash_bits, 0x0);
-
- // Backslashes version.
- path =
- "a\\.\\a\\.\\a\\.\\a\\.\\a\\.\\a\\.\\a\\.\\a\\.\\"
- "a\\.\\a\\.\\a\\.\\a\\.\\a\\.\\a\\.\\a\\.\\a\\.\\"
- "a\\.\\a\\.\\a\\.\\a\\.\\a\\.\\a\\.\\a\\.\\a\\.\\"
- "a\\.\\a\\.\\a\\.\\a\\.\\a\\.\\a\\.\\a\\.\\a\\.\\x.h";
-
- CanonicalizePath(&path, &slash_bits);
- EXPECT_EQ(slash_bits, 0xffffffff);
-
- // 65 is OK if #component is less than 60 after path canonicalization.
- path = "a/./a/./a/./a/./a/./a/./a/./a/./a/./a/./a/./a/./a/./a/./a/./a/./"
- "a/./a/./a/./a/./a/./a/./a/./a/./a/./a/./a/./a/./a/./a/./a/./a/./x/y.h";
- CanonicalizePath(&path, &slash_bits);
- EXPECT_EQ(slash_bits, 0x0);
-
- // Backslashes version.
- path =
- "a\\.\\a\\.\\a\\.\\a\\.\\a\\.\\a\\.\\a\\.\\a\\.\\"
- "a\\.\\a\\.\\a\\.\\a\\.\\a\\.\\a\\.\\a\\.\\a\\.\\"
- "a\\.\\a\\.\\a\\.\\a\\.\\a\\.\\a\\.\\a\\.\\a\\.\\"
- "a\\.\\a\\.\\a\\.\\a\\.\\a\\.\\a\\.\\a\\.\\a\\.\\x\\y.h";
- CanonicalizePath(&path, &slash_bits);
- EXPECT_EQ(slash_bits, 0x1ffffffff);
-
-
- // 59 after canonicalization is OK.
- path = "a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/"
- "a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/x/y.h";
- EXPECT_EQ(58, std::count(path.begin(), path.end(), '/'));
- CanonicalizePath(&path, &slash_bits);
- EXPECT_EQ(slash_bits, 0x0);
-
- // Backslashes version.
- path =
- "a\\a\\a\\a\\a\\a\\a\\a\\a\\a\\a\\a\\a\\a\\a\\a\\"
- "a\\a\\a\\a\\a\\a\\a\\a\\a\\a\\a\\a\\a\\a\\a\\a\\"
- "a\\a\\a\\a\\a\\a\\a\\a\\a\\a\\a\\a\\a\\a\\a\\a\\"
- "a\\a\\a\\a\\a\\a\\a\\a\\a\\x\\y.h";
- EXPECT_EQ(58, std::count(path.begin(), path.end(), '\\'));
- CanonicalizePath(&path, &slash_bits);
- EXPECT_EQ(slash_bits, 0x3ffffffffffffff);
-}
-#endif
-
-TEST(CanonicalizePath, UpDir) {
- string path, err;
- path = "../../foo/bar.h";
- CanonicalizePath(&path);
- EXPECT_EQ("../../foo/bar.h", path);
-
- path = "test/../../foo/bar.h";
- CanonicalizePath(&path);
- EXPECT_EQ("../foo/bar.h", path);
-}
-
-TEST(CanonicalizePath, AbsolutePath) {
- string path = "/usr/include/stdio.h";
- string err;
- CanonicalizePath(&path);
- EXPECT_EQ("/usr/include/stdio.h", path);
-}
-
-TEST(CanonicalizePath, NotNullTerminated) {
- string path;
- size_t len;
- uint64_t unused;
-
- path = "foo/. bar/.";
- len = strlen("foo/."); // Canonicalize only the part before the space.
- CanonicalizePath(&path[0], &len, &unused);
- EXPECT_EQ(strlen("foo"), len);
- EXPECT_EQ("foo/. bar/.", string(path));
-
- path = "foo/../file bar/.";
- len = strlen("foo/../file");
- CanonicalizePath(&path[0], &len, &unused);
- EXPECT_EQ(strlen("file"), len);
- EXPECT_EQ("file ./file bar/.", string(path));
-}
-
-TEST(PathEscaping, TortureTest) {
- string result;
-
- GetWin32EscapedString("foo bar\\\"'$@d!st!c'\\path'\\", &result);
- EXPECT_EQ("\"foo bar\\\\\\\"'$@d!st!c'\\path'\\\\\"", result);
- result.clear();
-
- GetShellEscapedString("foo bar\"/'$@d!st!c'/path'", &result);
- EXPECT_EQ("'foo bar\"/'\\''$@d!st!c'\\''/path'\\'''", result);
-}
-
-TEST(PathEscaping, SensiblePathsAreNotNeedlesslyEscaped) {
- const char* path = "some/sensible/path/without/crazy/characters.c++";
- string result;
-
- GetWin32EscapedString(path, &result);
- EXPECT_EQ(path, result);
- result.clear();
-
- GetShellEscapedString(path, &result);
- EXPECT_EQ(path, result);
-}
-
-TEST(PathEscaping, SensibleWin32PathsAreNotNeedlesslyEscaped) {
- const char* path = "some\\sensible\\path\\without\\crazy\\characters.c++";
- string result;
-
- GetWin32EscapedString(path, &result);
- EXPECT_EQ(path, result);
-}
-
-TEST(StripAnsiEscapeCodes, EscapeAtEnd) {
- string stripped = StripAnsiEscapeCodes("foo\33");
- EXPECT_EQ("foo", stripped);
-
- stripped = StripAnsiEscapeCodes("foo\33[");
- EXPECT_EQ("foo", stripped);
-}
-
-TEST(StripAnsiEscapeCodes, StripColors) {
- // An actual clang warning.
- string input = "\33[1maffixmgr.cxx:286:15: \33[0m\33[0;1;35mwarning: "
- "\33[0m\33[1musing the result... [-Wparentheses]\33[0m";
- string stripped = StripAnsiEscapeCodes(input);
- EXPECT_EQ("affixmgr.cxx:286:15: warning: using the result... [-Wparentheses]",
- stripped);
-}
-
-TEST(ElideMiddle, NothingToElide) {
- string input = "Nothing to elide in this short string.";
- EXPECT_EQ(input, ElideMiddle(input, 80));
- EXPECT_EQ(input, ElideMiddle(input, 38));
- EXPECT_EQ("", ElideMiddle(input, 0));
- EXPECT_EQ(".", ElideMiddle(input, 1));
- EXPECT_EQ("..", ElideMiddle(input, 2));
- EXPECT_EQ("...", ElideMiddle(input, 3));
-}
-
-TEST(ElideMiddle, ElideInTheMiddle) {
- string input = "01234567890123456789";
- string elided = ElideMiddle(input, 10);
- EXPECT_EQ("012...789", elided);
- EXPECT_EQ("01234567...23456789", ElideMiddle(input, 19));
-}
-
-TEST(StringFormat, StringFormatWithVarargs) {
- std::string str = StringFormat("%s %d %s", "foo", 42, "bar");
- EXPECT_EQ("foo 42 bar", str);
-}
-
-TEST(StringFormat, StringFormatWithValist) {
- auto f = [](const char* fmt, ...) {
- va_list args;
- va_start(args, fmt);
- std::string result = StringFormat(fmt, args);
- va_end(args);
- return result;
- };
-
- std::string str = f("%s %d %s", "foo", 42, "bar");
- EXPECT_EQ("foo 42 bar", str);
-}
-
-TEST(StringFormat, StringAppendFormatWithVarargs) {
- std::string str("foo");
- StringAppendFormat(str, " %d %s", 42, "bar");
- EXPECT_EQ("foo 42 bar", str);
-}
-
-TEST(StringFormat, StringAppendFormatWithVarargsAndLongResult) {
- std::string str("foo");
- std::string bar("xxxxxxxx");
- bar += bar;
- bar += bar;
- bar += bar;
- bar += bar;
- bar += bar;
- StringAppendFormat(str, " %d %s --", 42, bar.c_str());
-
- std::string expected = std::string("foo 42 ") + bar + " --";
- EXPECT_EQ(expected, str);
-}
-
-TEST(StringFormat, StringAppendFormatWithValist) {
- std::string str;
- auto f = [&str](const char* fmt, ...) {
- va_list args;
- va_start(args, fmt);
- StringAppendFormat(str, fmt, args);
- va_end(args);
- };
-
- f("%s %d %s", "foo", 42, "bar");
- EXPECT_EQ("foo 42 bar", str);
-}
-
-TEST(RunsUnderWine, Test) {
- // Try to run Determine
- bool expected = false;
-#ifdef _WIN32
- expected = getenv("WINELOADER") || getenv("WINEUSERNAME") ||
- getenv("WINEDEBUG") || getenv("WINEDLLDIR0");
-#endif
- ASSERT_EQ(expected, RunsUnderWine());
-}
-
-#ifdef _WIN32
-TEST(ConvertToUnicodeString, Test) {
- EXPECT_EQ(std::wstring(L"Bébé"), ConvertToUnicodeString("Bébé"));
-}
-
-TEST(ConvertFromUnicodeString, Test) {
- EXPECT_EQ(std::string("Bébé"), ConvertFromUnicodeString(L"Bébé"));
-}
-#endif // _WIN32
-
-TEST(StringFormatDurationMs, Test) {
- EXPECT_EQ(StringFormatDurationMs(0), "0 ms");
- EXPECT_EQ(StringFormatDurationMs(123), "123 ms");
- EXPECT_EQ(StringFormatDurationMs(995), "995 ms");
- EXPECT_EQ(StringFormatDurationMs(1000), "1.00 s");
- EXPECT_EQ(StringFormatDurationMs(3148), "3.14 s");
- EXPECT_EQ(StringFormatDurationMs(9999), "9.99 s");
- EXPECT_EQ(StringFormatDurationMs(10000), "10.0 s");
- EXPECT_EQ(StringFormatDurationMs(59999), "59.9 s");
- EXPECT_EQ(StringFormatDurationMs(60000), "1:00 min");
- EXPECT_EQ(StringFormatDurationMs(157892), "2:37 min");
- EXPECT_EQ(StringFormatDurationMs(3599999), "59:59 min");
- EXPECT_EQ(StringFormatDurationMs(3600000), "1:00:00 hr");
- EXPECT_EQ(StringFormatDurationMs(1000000000), "277:46:40 hr");
-
- EXPECT_EQ(StringFormatDurationMs(-123), "-123 ms");
- EXPECT_EQ(StringFormatDurationMs(-995), "-995 ms");
- EXPECT_EQ(StringFormatDurationMs(-1000), "-1.00 s");
- EXPECT_EQ(StringFormatDurationMs(3148), "3.14 s");
-}
diff --git a/src/version.cc b/src/version.cc
deleted file mode 100644
index d306957..0000000
--- a/src/version.cc
+++ /dev/null
@@ -1,55 +0,0 @@
-// Copyright 2013 Google Inc. All Rights Reserved.
-//
-// Licensed under the Apache License, Version 2.0 (the "License");
-// you may not use this file except in compliance with the License.
-// You may obtain a copy of the License at
-//
-// http://www.apache.org/licenses/LICENSE-2.0
-//
-// Unless required by applicable law or agreed to in writing, software
-// distributed under the License is distributed on an "AS IS" BASIS,
-// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-// See the License for the specific language governing permissions and
-// limitations under the License.
-
-#include "version.h"
-
-#include <stdlib.h>
-
-#include "util.h"
-
-using namespace std;
-
-const char* kNinjaVersion = "1.12.0.git";
-
-void ParseVersion(const string& version, int* major, int* minor) {
- size_t end = version.find('.');
- *major = atoi(version.substr(0, end).c_str());
- *minor = 0;
- if (end != string::npos) {
- size_t start = end + 1;
- end = version.find('.', start);
- *minor = atoi(version.substr(start, end).c_str());
- }
-}
-
-void CheckNinjaVersion(const string& version) {
- int bin_major, bin_minor;
- ParseVersion(kNinjaVersion, &bin_major, &bin_minor);
- int file_major, file_minor;
- ParseVersion(version, &file_major, &file_minor);
-
- if (bin_major > file_major) {
- Warning("ninja executable version (%s) greater than build file "
- "ninja_required_version (%s); versions may be incompatible.",
- kNinjaVersion, version.c_str());
- return;
- }
-
- if ((bin_major == file_major && bin_minor < file_minor) ||
- bin_major < file_major) {
- Fatal("ninja version (%s) incompatible with build file "
- "ninja_required_version version (%s).",
- kNinjaVersion, version.c_str());
- }
-}
diff --git a/src/version.h b/src/version.h
deleted file mode 100644
index 9d84ecb..0000000
--- a/src/version.h
+++ /dev/null
@@ -1,31 +0,0 @@
-// Copyright 2013 Google Inc. All Rights Reserved.
-//
-// Licensed under the Apache License, Version 2.0 (the "License");
-// you may not use this file except in compliance with the License.
-// You may obtain a copy of the License at
-//
-// http://www.apache.org/licenses/LICENSE-2.0
-//
-// Unless required by applicable law or agreed to in writing, software
-// distributed under the License is distributed on an "AS IS" BASIS,
-// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-// See the License for the specific language governing permissions and
-// limitations under the License.
-
-#ifndef NINJA_VERSION_H_
-#define NINJA_VERSION_H_
-
-#include <string>
-
-/// The version number of the current Ninja release. This will always
-/// be "git" on trunk.
-extern const char* kNinjaVersion;
-
-/// Parse the major/minor components of a version string.
-void ParseVersion(const std::string& version, int* major, int* minor);
-
-/// Check whether \a version is compatible with the current Ninja version,
-/// aborting if not.
-void CheckNinjaVersion(const std::string& required_version);
-
-#endif // NINJA_VERSION_H_
diff --git a/src/win32port.h b/src/win32port.h
deleted file mode 100644
index e542536..0000000
--- a/src/win32port.h
+++ /dev/null
@@ -1,39 +0,0 @@
-// Copyright 2012 Google Inc. All Rights Reserved.
-//
-// Licensed under the Apache License, Version 2.0 (the "License");
-// you may not use this file except in compliance with the License.
-// You may obtain a copy of the License at
-//
-// http://www.apache.org/licenses/LICENSE-2.0
-//
-// Unless required by applicable law or agreed to in writing, software
-// distributed under the License is distributed on an "AS IS" BASIS,
-// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-// See the License for the specific language governing permissions and
-// limitations under the License.
-
-#ifndef NINJA_WIN32PORT_H_
-#define NINJA_WIN32PORT_H_
-
-#if defined(__MINGW32__) || defined(__MINGW64__)
-#ifndef __STDC_FORMAT_MACROS
-#define __STDC_FORMAT_MACROS
-#endif
-#include <inttypes.h>
-#endif
-
-typedef signed short int16_t;
-typedef unsigned short uint16_t;
-/// A 64-bit integer type
-typedef signed long long int64_t;
-typedef unsigned long long uint64_t;
-
-// printf format specifier for uint64_t, from C99.
-#ifndef PRIu64
-#define PRId64 "I64d"
-#define PRIu64 "I64u"
-#define PRIx64 "I64x"
-#endif
-
-#endif // NINJA_WIN32PORT_H_
-
diff --git a/windows/ninja.manifest b/windows/ninja.manifest
deleted file mode 100644
index 47949dd..0000000
--- a/windows/ninja.manifest
+++ /dev/null
@@ -1,9 +0,0 @@
-<?xml version="1.0" encoding="UTF-8" standalone="yes"?>
-<assembly manifestVersion="1.0" xmlns="urn:schemas-microsoft-com:asm.v1">
- <application>
- <windowsSettings>
- <activeCodePage xmlns="http://schemas.microsoft.com/SMI/2019/WindowsSettings">UTF-8</activeCodePage>
- <longPathAware xmlns="http://schemas.microsoft.com/SMI/2016/WindowsSettings">true</longPathAware>
- </windowsSettings>
- </application>
-</assembly>
