Create install targets for scan-build-py.

[isthismyaccount]

Summary

Create install targets for scan-build-py and include this target in fuchsia distribution.

Also move lib folder to match the distribution layout.

TESTED=local build. Verify scan-build could execute.

[phosek]

I don't think this is sufficient. First, we want to be explicit and always list individual files to install, we don't use patterns. Second, since libscanbuild is a library, it shouldn't be installed inside the bin directory. I think those should go either into lib or share. libscanbuild/resources should definitely go into share as is already the case for scan-build. Third, libear is a native component so that one needs to be compiled first.

[aabbaabb]

The python script assumes relative directory while finding things. For example, for resources folder, it uses os.path.join(this_dir, 'resources') in report.py, which means resource need to be in the same dir as report.py. Similarly for the libscanbuild. it assumes the library is always at one level up from bin folder. Installing them to different directories would break the script.

In D101139#2713450, @phosek wrote:

I don't think this is sufficient. First, we want to be explicit and always list individual files to install, we don't use patterns. Second, since libscanbuild is a library, it shouldn't be installed inside the bin directory. I think those should go either into lib or share. libscanbuild/resources should definitely go into share as is already the case for scan-build. Third, libear is a native component so that one needs to be compiled first.

[aabbaabb]

In D101139#2713450, @phosek wrote:

I don't think this is sufficient. First, we want to be explicit and always list individual files to install, we don't use patterns. Second, since libscanbuild is a library, it shouldn't be installed inside the bin directory. I think those should go either into lib or share. libscanbuild/resources should definitely go into share as is already the case for scan-build. Third, libear is a native component so that one needs to be compiled first.

libear is built dynamically at runtime from build_libear function in libear/__init__.py which would be called by libscanbuild/analyze.py. It is not built statically.

[phosek]

In D101139#2713530, @aabbaabb wrote:

The python script assumes relative directory while finding things. For example, for resources folder, it uses os.path.join(this_dir, 'resources') in report.py, which means resource need to be in the same dir as report.py. Similarly for the libscanbuild. it assumes the library is always at one level up from bin folder. Installing them to different directories would break the script.

We could reorganize things to match the final layout, that's the strategy that https://github.com/llvm/llvm-project/tree/main/clang/tools/scan-build uses as well.

In D101139#2713551, @aabbaabb wrote:

libear is built dynamically at runtime from build_libear function in libear/__init__.py which would be called by libscanbuild/analyze.py. It is not built statically.

Could we modify the code to avoid building libear at runtime and instead build it with CMake. Is libear even needed when using compilation database?

[aabbaabb]

In D101139#2718057, @phosek wrote:

In D101139#2713530, @aabbaabb wrote:

The python script assumes relative directory while finding things. For example, for resources folder, it uses os.path.join(this_dir, 'resources') in report.py, which means resource need to be in the same dir as report.py. Similarly for the libscanbuild. it assumes the library is always at one level up from bin folder. Installing them to different directories would break the script.

We could reorganize things to match the final layout, that's the strategy that https://github.com/llvm/llvm-project/tree/main/clang/tools/scan-build uses as well.

In D101139#2713551, @aabbaabb wrote:

libear is built dynamically at runtime from build_libear function in libear/__init__.py which would be called by libscanbuild/analyze.py. It is not built statically.

Could we modify the code to avoid building libear at runtime and instead build it with CMake. Is libear even needed when using compilation database?

If i copy libscanbuild/resources to out/share/, libscanbuild to out/libscanbuild, bin/* to bin, then resources would be in a different layout than the original src. You mean modifying the original source and move libscanbuild/resources out to share/resources and update the code reference?

We are not using libear, we are only using analyze-build not scan-build. For our usage, I could define a target that only copies analyze-build, not scan-build. However, I am not sure whether this is appropriate. On the other hand, building libear statically might require significant change to the code.

[phosek]

In D101139#2718112, @aabbaabb wrote:

In D101139#2718057, @phosek wrote:

In D101139#2713530, @aabbaabb wrote:

The python script assumes relative directory while finding things. For example, for resources folder, it uses os.path.join(this_dir, 'resources') in report.py, which means resource need to be in the same dir as report.py. Similarly for the libscanbuild. it assumes the library is always at one level up from bin folder. Installing them to different directories would break the script.

We could reorganize things to match the final layout, that's the strategy that https://github.com/llvm/llvm-project/tree/main/clang/tools/scan-build uses as well.

In D101139#2713551, @aabbaabb wrote:

libear is built dynamically at runtime from build_libear function in libear/__init__.py which would be called by libscanbuild/analyze.py. It is not built statically.

Could we modify the code to avoid building libear at runtime and instead build it with CMake. Is libear even needed when using compilation database?

If i copy libscanbuild/resources to out/share/, libscanbuild to out/libscanbuild, bin/* to bin, then resources would be in a different layout than the original src. You mean modifying the original source and move libscanbuild/resources out to share/resources and update the code reference?

Do we still keep the source in sync with https://github.com/rizsotto/scan-build? I was under the impression that the two codebases have already started diverging.

We are not using libear, we are only using analyze-build not scan-build. For our usage, I could define a target that only copies analyze-build, not scan-build. However, I am not sure whether this is appropriate. On the other hand, building libear statically might require significant change to the code.

We may consider introducing a CMake option to control whether to include libear or not (which would also control whether to include scan-build or not).

[aabbaabb]

In D101139#2721880, @phosek wrote:

In D101139#2718112, @aabbaabb wrote:

In D101139#2718057, @phosek wrote:

In D101139#2713530, @aabbaabb wrote:

The python script assumes relative directory while finding things. For example, for resources folder, it uses os.path.join(this_dir, 'resources') in report.py, which means resource need to be in the same dir as report.py. Similarly for the libscanbuild. it assumes the library is always at one level up from bin folder. Installing them to different directories would break the script.

We could reorganize things to match the final layout, that's the strategy that https://github.com/llvm/llvm-project/tree/main/clang/tools/scan-build uses as well.

In D101139#2713551, @aabbaabb wrote:

libear is built dynamically at runtime from build_libear function in libear/__init__.py which would be called by libscanbuild/analyze.py. It is not built statically.

Could we modify the code to avoid building libear at runtime and instead build it with CMake. Is libear even needed when using compilation database?

If i copy libscanbuild/resources to out/share/, libscanbuild to out/libscanbuild, bin/* to bin, then resources would be in a different layout than the original src. You mean modifying the original source and move libscanbuild/resources out to share/resources and update the code reference?

Do we still keep the source in sync with https://github.com/rizsotto/scan-build? I was under the impression that the two codebases have already started diverging.

We are not using libear, we are only using analyze-build not scan-build. For our usage, I could define a target that only copies analyze-build, not scan-build. However, I am not sure whether this is appropriate. On the other hand, building libear statically might require significant change to the code.

We may consider introducing a CMake option to control whether to include libear or not (which would also control whether to include scan-build or not).

Updated the layout and listed individual files.
It is not trivial to separate out scan-build with analyze-build since all the logic is in one python lib file. Furthermore, libear is compiled with the cc compiler that is supplied as an argument to the tool, so i cannot turn that into a prebuilt without a large refactor to the codebase. I added a comment listing the reason.

[wanders]

clang/tools/scan-build-py/CMakeLists.txt

9

This overwrites the "bin/scan-build" that was installed from the scan-build (no -py) subdirectory.

So with this "scan-build" will suddenly mean the python variant instead of the per variant. That might be fine (?), but can't be a good idea to have that done by first installing the perl scan-build and then overwriting it with the python scan-build. Also the man-page that the perl variant installs is not overwritten so "man scan-build" will show manual page for the perl variant.

[aabbaabb]

Rename scan-build to scan-build-py during install to prevent overwriting pearl implementation.

[aabbaabb]

clang/tools/scan-build-py/CMakeLists.txt

9

Thanks for the comment. I have renamed scan-build to scan-build-py during installation.

[phosek]

Looking at libear/__init__.py, it's basically replicating CMake build to the point where it even emulates CMake template expansion, see https://github.com/llvm/llvm-project/blob/a3a8a1a15b524d91b5308db68e9d293b34cd88dd/clang/tools/scan-build-py/libear/__init__.py#L204. Given that we already use CMake, I think we should just build libear with CMake and ship libear as shared library and then modify https://github.com/llvm/llvm-project/blob/a3a8a1a15b524d91b5308db68e9d293b34cd88dd/clang/tools/scan-build-py/libscanbuild/intercept.py#L113 to use the prebuilt version instead of building it every time. However, given that this change is already pretty large, I'm also fine if we do it in a follow up change.

clang/tools/scan-build-py/CMakeLists.txt

2–8

I'd prefer to install all of these into libexec to match Perl scan-build.

28

29

A property we're trying to keep is that the build layout matches the installation layout, so in addition to installing files, we also need a custom target to copy these files into the build output directory. This is what Perl scan-build does as well, see https://github.com/llvm/llvm-project/blob/a3a8a1a15b524d91b5308db68e9d293b34cd88dd/clang/tools/scan-build/CMakeLists.txt#L41

[aabbaabb]

Renamed lib to libexec and add custom rules to copy files to build output.

[phosek]

clang/tools/scan-build-py/CMakeLists.txt

2–8

Shouldn't this list also contain scan-build?

10

22

[wanders]

In D101139#2743346, @aabbaabb wrote:

Renamed lib to libexec and add custom rules to copy files to build output.

That rename was a bit too fast I think.
I would expect the libraries (libear & libscanbuild) to be in lib/.
The internal wrappers analyze-c++,analyze-cc,intercept-c++,intercept-cc to be installed in libexec.
And finally analyze-build, intercept-build, scan-build which are the commands user can execute to be installed in bin/

(I have picked up this patch in our internal toolchain as it gives us a way to generate compilation databases out of the box. It works fine here)

[aabbaabb]

put libs in 'lib' folder, 'analyze-*' and 'scan-*' compiler wrappers to 'libexec', also copy the resources in 'libscanbuild'

Tests:

To install:
DESTDIR=${INSTALL_DIR} ninja install-scan-build-py -j1000

Test at source folder:
PATH=~/llvm-project/build/libexec:~/llvm-project/build/bin:$PATH python -m unittest tests.unit
PATH=~/llvm-project/build/libexec:~/llvm-project/build/bin:$PATH python -m unittest tests.functional.cases

One error in functional test: test_successful_build_on_empty_env
I think this is intended behavior (clang not found?) since the test sets an empty environment for make.

[wanders]

I think this looks good. I can't vouch for the cmake changes.

However there seems like diff is based on something that already has moved parts into libexec. It doesn't apply cleanly here - and buildkite seems to complain too. Make sure you have the complete diff.

[phosek]

LGTM

[isthismyaccount]

Thanks for the reviews. I'll take over this and try to get the merge conflicts resolved.

[isthismyaccount]

Grabbing this revision.

[isthismyaccount]

Rebased to hopefully resolve merge issues.

clang/cmake/caches/Fuchsia-stage2.cmake

set(LLVM_TOOLCHAIN_TOOLS
   llvm-ranlib
   llvm-readelf
   llvm-readobj
   llvm-size
   llvm-strip
   llvm-symbolizer
   llvm-xray
   sancov
+  scan-build-py
   CACHE STRING "")
 
 set(LLVM_DISTRIBUTION_COMPONENTS
   clang
   lld
   LTO
   clang-apply-replacements
   clang-doc

clang/tools/CMakeLists.txt

if(CLANG_ENABLE_ARCMT)
   add_clang_subdirectory(arcmt-test)
   add_clang_subdirectory(c-arcmt-test)
 endif()
 
 if(CLANG_ENABLE_STATIC_ANALYZER)
   add_clang_subdirectory(clang-check)
   add_clang_subdirectory(clang-extdef-mapping)
   add_clang_subdirectory(scan-build)
+  add_clang_subdirectory(scan-build-py)
   add_clang_subdirectory(scan-view)
 endif()
 
 # We support checking out the clang-tools-extra repository into the 'extra'
 # subdirectory. It contains tools developed as part of the Clang/LLVM project
 # on top of the Clang tooling platform. We keep them in a separate repository
 # to keep the primary Clang repository small and focused.
 # It also may be included by LLVM_EXTERNAL_CLANG_TOOLS_EXTRA_SOURCE_DIR.
 add_llvm_external_project(clang-tools-extra extra)
 
 # libclang may require clang-tidy in clang-tools-extra.
 add_clang_subdirectory(libclang)
 
 add_clang_subdirectory(amdgpu-arch)

clang/tools/scan-build-py/CMakeLists.txt

+set (BinFiles
+     "analyze-build"
+     "intercept-build"
+     "scan-build")
+
+set (LibExecs
+     "analyze-c++"
+     "analyze-cc"
+     "intercept-c++"
+     "intercept-cc")
+
+set (LibScanbuild
+     "__init__.py"
+     "analyze.py"
+     "arguments.py"
+     "clang.py"
+     "compilation.py"
+     "intercept.py"
+     "report.py"
+     "shell.py")
+
+set (LibScanbuildResources
+     "scanview.css"
+     "selectable.js"
+     "sorttable.js")
+
+# libear is compiled dynamically in build_libear using the specified cc
+# compiler.
+set (LibEar
+     "__init__.py"
+     "config.h.in"
+     "ear.c")
+
+foreach(BinFile ${BinFiles})
+  if ("${BinFile}" STREQUAL "scan-build")
+    # Need to rename scan-build to scan-build-py to prevent overwriting
+    # scan-build Perl implementation.
+    add_custom_command(OUTPUT ${CMAKE_BINARY_DIR}/bin/scan-build-py
+                       COMMAND ${CMAKE_COMMAND} -E make_directory
+                         ${CMAKE_BINARY_DIR}/bin
+                       COMMAND ${CMAKE_COMMAND} -E copy
+                         ${CMAKE_CURRENT_SOURCE_DIR}/bin/scan-build
+                         ${CMAKE_BINARY_DIR}/bin/scan-build-py
+                       DEPENDS ${CMAKE_CURRENT_SOURCE_DIR}/bin/scan-build)
+    install (PROGRAMS "bin/scan-build"
+             DESTINATION bin
+             RENAME scan-build-py
+             COMPONENT scan-build-py)
+    list(APPEND Depends ${CMAKE_BINARY_DIR}/bin/scan-build-py)
+  else()
+    add_custom_command(OUTPUT ${CMAKE_BINARY_DIR}/bin/${BinFile}
+                       COMMAND ${CMAKE_COMMAND} -E make_directory
+                         ${CMAKE_BINARY_DIR}/bin
+                       COMMAND ${CMAKE_COMMAND} -E copy
+                         ${CMAKE_CURRENT_SOURCE_DIR}/bin/${BinFile}
+                         ${CMAKE_BINARY_DIR}/bin/
+                       DEPENDS ${CMAKE_CURRENT_SOURCE_DIR}/bin/${BinFile})
+    install(PROGRAMS bin/${BinFile}
+            DESTINATION bin
+            COMPONENT scan-build-py)
+    list(APPEND Depends ${CMAKE_BINARY_DIR}/bin/${BinFile})
+  endif()
+endforeach()
+
+foreach(lib ${LibExecs})
+  add_custom_command(OUTPUT ${CMAKE_BINARY_DIR}/libexec/${lib}
+                     COMMAND ${CMAKE_COMMAND} -E make_directory
+                       ${CMAKE_BINARY_DIR}/libexec
+                     COMMAND ${CMAKE_COMMAND} -E copy
+                       ${CMAKE_CURRENT_SOURCE_DIR}/libexec/${lib}
+                       ${CMAKE_BINARY_DIR}/libexec/
+                     DEPENDS ${CMAKE_CURRENT_SOURCE_DIR}/libexec/${lib})
+  list(APPEND Depends ${CMAKE_BINARY_DIR}/libexec/${lib})
+  install(PROGRAMS libexec/${lib}
+          DESTINATION libexec
+          COMPONENT scan-build-py)
+endforeach()
+
+foreach(lib ${LibScanbuild})
+  add_custom_command(OUTPUT ${CMAKE_BINARY_DIR}/lib/libscanbuild/${lib}
+                     COMMAND ${CMAKE_COMMAND} -E make_directory
+                       ${CMAKE_BINARY_DIR}/lib
+                     COMMAND ${CMAKE_COMMAND} -E make_directory
+                       ${CMAKE_BINARY_DIR}/lib/libscanbuild
+                     COMMAND ${CMAKE_COMMAND} -E copy
+                       ${CMAKE_CURRENT_SOURCE_DIR}/lib/libscanbuild/${lib}
+                       ${CMAKE_BINARY_DIR}/lib/libscanbuild/
+                     DEPENDS ${CMAKE_CURRENT_SOURCE_DIR}/lib/libscanbuild/${lib})
+  list(APPEND Depends ${CMAKE_BINARY_DIR}/lib/libscanbuild/${lib})
+  install(PROGRAMS lib/libscanbuild/${lib}
+          DESTINATION lib/libscanbuild
+          COMPONENT scan-build-py)
+endforeach()
+
+foreach(resource ${LibScanbuildResources})
+  add_custom_command(OUTPUT ${CMAKE_BINARY_DIR}/lib/libscanbuild/resources/${resource}
+                     COMMAND ${CMAKE_COMMAND} -E make_directory
+                       ${CMAKE_BINARY_DIR}/lib
+                     COMMAND ${CMAKE_COMMAND} -E make_directory
+                       ${CMAKE_BINARY_DIR}/lib/libscanbuild
+                     COMMAND ${CMAKE_COMMAND} -E make_directory
+                       ${CMAKE_BINARY_DIR}/lib/libscanbuild/resources
+                     COMMAND ${CMAKE_COMMAND} -E copy
+                       ${CMAKE_CURRENT_SOURCE_DIR}/lib/libscanbuild/resources/${resource}
+                       ${CMAKE_BINARY_DIR}/lib/libscanbuild/resources
+                     DEPENDS ${CMAKE_CURRENT_SOURCE_DIR}/lib/libscanbuild/resources/${resource})
+  list(APPEND Depends ${CMAKE_BINARY_DIR}/lib/libscanbuild/resources/${resource})
+  install(PROGRAMS lib/libscanbuild/resources/${resource}
+          DESTINATION lib/libscanbuild/resources
+          COMPONENT scan-build-py)
+endforeach()
+
+foreach(lib ${LibEar})
+  add_custom_command(OUTPUT ${CMAKE_BINARY_DIR}/lib/libear/${lib}
+                     COMMAND ${CMAKE_COMMAND} -E make_directory
+                       ${CMAKE_BINARY_DIR}/lib
+                     COMMAND ${CMAKE_COMMAND} -E make_directory
+                       ${CMAKE_BINARY_DIR}/lib/libear
+                     COMMAND ${CMAKE_COMMAND} -E copy
+                       ${CMAKE_CURRENT_SOURCE_DIR}/lib/libear/${lib}
+                       ${CMAKE_BINARY_DIR}/lib/libear/
+                     DEPENDS ${CMAKE_CURRENT_SOURCE_DIR}/lib/libear/${lib})
+  list(APPEND Depends ${CMAKE_BINARY_DIR}/lib/libear/${lib})
+  install(PROGRAMS lib/libear/${lib}
+          DESTINATION lib/libear
+          COMPONENT scan-build-py)
+endforeach()
+
+add_custom_target(scan-build-py ALL DEPENDS ${Depends})
+add_llvm_install_targets("install-scan-build-py"
+                         DEPENDS scan-build-py
+                         COMPONENT scan-build-py)

clang/tools/scan-build-py/bin/analyze-build

 #!/usr/bin/env python
 # -*- coding: utf-8 -*-
 # Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 # See https://llvm.org/LICENSE.txt for license information.
 # SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 
 import multiprocessing
 import sys
 import os.path
 this_dir = os.path.dirname(os.path.realpath(__file__))
-sys.path.append(os.path.dirname(this_dir))
+sys.path.append(os.path.join(os.path.dirname(this_dir), 'lib'))
 
 from libscanbuild.analyze import analyze_build
 
 if __name__ == '__main__':
     multiprocessing.freeze_support()
     sys.exit(analyze_build())

clang/tools/scan-build-py/bin/intercept-build

 #!/usr/bin/env python
 # -*- coding: utf-8 -*-
 # Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 # See https://llvm.org/LICENSE.txt for license information.
 # SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 
 import multiprocessing
 import sys
 import os.path
 this_dir = os.path.dirname(os.path.realpath(__file__))
-sys.path.append(os.path.dirname(this_dir))
+sys.path.append(os.path.join(os.path.dirname(this_dir), 'lib'))
 
 from libscanbuild.intercept import intercept_build
 
 if __name__ == '__main__':
     multiprocessing.freeze_support()
     sys.exit(intercept_build())

clang/tools/scan-build-py/bin/scan-build

 #!/usr/bin/env python
 # -*- coding: utf-8 -*-
 # Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 # See https://llvm.org/LICENSE.txt for license information.
 # SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 
 import multiprocessing
 import sys
 import os.path
 this_dir = os.path.dirname(os.path.realpath(__file__))
-sys.path.append(os.path.dirname(this_dir))
+sys.path.append(os.path.join(os.path.dirname(this_dir), 'lib'))
 
 from libscanbuild.analyze import scan_build
 
 if __name__ == '__main__':
     multiprocessing.freeze_support()
     sys.exit(scan_build())

clang/tools/scan-build-py/lib/libear/ear.c

+/* -*- coding: utf-8 -*-
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+*/
+
+/**
+ * This file implements a shared library. This library can be pre-loaded by
+ * the dynamic linker of the Operating System (OS). It implements a few function
+ * related to process creation. By pre-load this library the executed process
+ * uses these functions instead of those from the standard library.
+ *
+ * The idea here is to inject a logic before call the real methods. The logic is
+ * to dump the call into a file. To call the real method this library is doing
+ * the job of the dynamic linker.
+ *
+ * The only input for the log writing is about the destination directory.
+ * This is passed as environment variable.
+ */
+
+#include "config.h"
+
+#include <dlfcn.h>
+#include <pthread.h>
+#include <stdarg.h>
+#include <stddef.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <unistd.h>
+
+#if defined HAVE_POSIX_SPAWN || defined HAVE_POSIX_SPAWNP
+#include <spawn.h>
+#endif
+
+#if defined HAVE_NSGETENVIRON
+#include <crt_externs.h>
+#else
+extern char **environ;
+#endif
+
+#define ENV_OUTPUT "INTERCEPT_BUILD_TARGET_DIR"
+#ifdef APPLE
+#define ENV_FLAT "DYLD_FORCE_FLAT_NAMESPACE"
+#define ENV_PRELOAD "DYLD_INSERT_LIBRARIES"
+#define ENV_SIZE 3
+#else
+#define ENV_PRELOAD "LD_PRELOAD"
+#define ENV_SIZE 2
+#endif
+
+#define DLSYM(TYPE_, VAR_, SYMBOL_)                                            \
+  union {                                                                      \
+    void *from;                                                                \
+    TYPE_ to;                                                                  \
+  } cast;                                                                      \
+  if (0 == (cast.from = dlsym(RTLD_NEXT, SYMBOL_))) {                          \
+    perror("bear: dlsym");                                                     \
+    exit(EXIT_FAILURE);                                                        \
+  }                                                                            \
+  TYPE_ const VAR_ = cast.to;
+
+typedef char const *bear_env_t[ENV_SIZE];
+
+static int bear_capture_env_t(bear_env_t *env);
+static int bear_reset_env_t(bear_env_t *env);
+static void bear_release_env_t(bear_env_t *env);
+static char const **bear_update_environment(char *const envp[],
+                                            bear_env_t *env);
+static char const **bear_update_environ(char const **in, char const *key,
+                                        char const *value);
+static char **bear_get_environment();
+static void bear_report_call(char const *fun, char const *const argv[]);
+static char const **bear_strings_build(char const *arg, va_list *ap);
+static char const **bear_strings_copy(char const **const in);
+static char const **bear_strings_append(char const **in, char const *e);
+static size_t bear_strings_length(char const *const *in);
+static void bear_strings_release(char const **);
+
+static bear_env_t env_names = {ENV_OUTPUT, ENV_PRELOAD
+#ifdef ENV_FLAT
+                               ,
+                               ENV_FLAT
+#endif
+};
+
+static bear_env_t initial_env = {0, 0
+#ifdef ENV_FLAT
+                                 ,
+                                 0
+#endif
+};
+
+static int initialized = 0;
+static pthread_mutex_t mutex = PTHREAD_MUTEX_INITIALIZER;
+
+static void on_load(void) __attribute__((constructor));
+static void on_unload(void) __attribute__((destructor));
+
+#ifdef HAVE_EXECVE
+static int call_execve(const char *path, char *const argv[],
+                       char *const envp[]);
+#endif
+#ifdef HAVE_EXECVP
+static int call_execvp(const char *file, char *const argv[]);
+#endif
+#ifdef HAVE_EXECVPE
+static int call_execvpe(const char *file, char *const argv[],
+                        char *const envp[]);
+#endif
+#ifdef HAVE_EXECVP2
+static int call_execvP(const char *file, const char *search_path,
+                       char *const argv[]);
+#endif
+#ifdef HAVE_EXECT
+static int call_exect(const char *path, char *const argv[], char *const envp[]);
+#endif
+#ifdef HAVE_POSIX_SPAWN
+static int call_posix_spawn(pid_t *restrict pid, const char *restrict path,
+                            const posix_spawn_file_actions_t *file_actions,
+                            const posix_spawnattr_t *restrict attrp,
+                            char *const argv[restrict],
+                            char *const envp[restrict]);
+#endif
+#ifdef HAVE_POSIX_SPAWNP
+static int call_posix_spawnp(pid_t *restrict pid, const char *restrict file,
+                             const posix_spawn_file_actions_t *file_actions,
+                             const posix_spawnattr_t *restrict attrp,
+                             char *const argv[restrict],
+                             char *const envp[restrict]);
+#endif
+
+/* Initialization method to Captures the relevant environment variables.
+ */
+
+static void on_load(void) {
+  pthread_mutex_lock(&mutex);
+  if (!initialized)
+    initialized = bear_capture_env_t(&initial_env);
+  pthread_mutex_unlock(&mutex);
+}
+
+static void on_unload(void) {
+  pthread_mutex_lock(&mutex);
+  bear_release_env_t(&initial_env);
+  initialized = 0;
+  pthread_mutex_unlock(&mutex);
+}
+
+/* These are the methods we are try to hijack.
+ */
+
+#ifdef HAVE_EXECVE
+int execve(const char *path, char *const argv[], char *const envp[]) {
+  bear_report_call(__func__, (char const *const *)argv);
+  return call_execve(path, argv, envp);
+}
+#endif
+
+#ifdef HAVE_EXECV
+#ifndef HAVE_EXECVE
+#error can not implement execv without execve
+#endif
+int execv(const char *path, char *const argv[]) {
+  bear_report_call(__func__, (char const *const *)argv);
+  char *const *envp = bear_get_environment();
+  return call_execve(path, argv, envp);
+}
+#endif
+
+#ifdef HAVE_EXECVPE
+int execvpe(const char *file, char *const argv[], char *const envp[]) {
+  bear_report_call(__func__, (char const *const *)argv);
+  return call_execvpe(file, argv, envp);
+}
+#endif
+
+#ifdef HAVE_EXECVP
+int execvp(const char *file, char *const argv[]) {
+  bear_report_call(__func__, (char const *const *)argv);
+  return call_execvp(file, argv);
+}
+#endif
+
+#ifdef HAVE_EXECVP2
+int execvP(const char *file, const char *search_path, char *const argv[]) {
+  bear_report_call(__func__, (char const *const *)argv);
+  return call_execvP(file, search_path, argv);
+}
+#endif
+
+#ifdef HAVE_EXECT
+int exect(const char *path, char *const argv[], char *const envp[]) {
+  bear_report_call(__func__, (char const *const *)argv);
+  return call_exect(path, argv, envp);
+}
+#endif
+
+#ifdef HAVE_EXECL
+#ifndef HAVE_EXECVE
+#error can not implement execl without execve
+#endif
+int execl(const char *path, const char *arg, ...) {
+  va_list args;
+  va_start(args, arg);
+  char const **argv = bear_strings_build(arg, &args);
+  va_end(args);
+
+  bear_report_call(__func__, (char const *const *)argv);
+  char *const *envp = bear_get_environment();
+  int const result = call_execve(path, (char *const *)argv, envp);
+
+  bear_strings_release(argv);
+  return result;
+}
+#endif
+
+#ifdef HAVE_EXECLP
+#ifndef HAVE_EXECVP
+#error can not implement execlp without execvp
+#endif
+int execlp(const char *file, const char *arg, ...) {
+  va_list args;
+  va_start(args, arg);
+  char const **argv = bear_strings_build(arg, &args);
+  va_end(args);
+
+  bear_report_call(__func__, (char const *const *)argv);
+  int const result = call_execvp(file, (char *const *)argv);
+
+  bear_strings_release(argv);
+  return result;
+}
+#endif
+
+#ifdef HAVE_EXECLE
+#ifndef HAVE_EXECVE
+#error can not implement execle without execve
+#endif
+// int execle(const char *path, const char *arg, ..., char * const envp[]);
+int execle(const char *path, const char *arg, ...) {
+  va_list args;
+  va_start(args, arg);
+  char const **argv = bear_strings_build(arg, &args);
+  char const **envp = va_arg(args, char const **);
+  va_end(args);
+
+  bear_report_call(__func__, (char const *const *)argv);
+  int const result =
+      call_execve(path, (char *const *)argv, (char *const *)envp);
+
+  bear_strings_release(argv);
+  return result;
+}
+#endif
+
+#ifdef HAVE_POSIX_SPAWN
+int posix_spawn(pid_t *restrict pid, const char *restrict path,
+                const posix_spawn_file_actions_t *file_actions,
+                const posix_spawnattr_t *restrict attrp,
+                char *const argv[restrict], char *const envp[restrict]) {
+  bear_report_call(__func__, (char const *const *)argv);
+  return call_posix_spawn(pid, path, file_actions, attrp, argv, envp);
+}
+#endif
+
+#ifdef HAVE_POSIX_SPAWNP
+int posix_spawnp(pid_t *restrict pid, const char *restrict file,
+                 const posix_spawn_file_actions_t *file_actions,
+                 const posix_spawnattr_t *restrict attrp,
+                 char *const argv[restrict], char *const envp[restrict]) {
+  bear_report_call(__func__, (char const *const *)argv);
+  return call_posix_spawnp(pid, file, file_actions, attrp, argv, envp);
+}
+#endif
+
+/* These are the methods which forward the call to the standard implementation.
+ */
+
+#ifdef HAVE_EXECVE
+static int call_execve(const char *path, char *const argv[],
+                       char *const envp[]) {
+  typedef int (*func)(const char *, char *const *, char *const *);
+
+  DLSYM(func, fp, "execve");
+
+  char const **const menvp = bear_update_environment(envp, &initial_env);
+  int const result = (*fp)(path, argv, (char *const *)menvp);
+  bear_strings_release(menvp);
+  return result;
+}
+#endif
+
+#ifdef HAVE_EXECVPE
+static int call_execvpe(const char *file, char *const argv[],
+                        char *const envp[]) {
+  typedef int (*func)(const char *, char *const *, char *const *);
+
+  DLSYM(func, fp, "execvpe");
+
+  char const **const menvp = bear_update_environment(envp, &initial_env);
+  int const result = (*fp)(file, argv, (char *const *)menvp);
+  bear_strings_release(menvp);
+  return result;
+}
+#endif
+
+#ifdef HAVE_EXECVP
+static int call_execvp(const char *file, char *const argv[]) {
+  typedef int (*func)(const char *file, char *const argv[]);
+
+  DLSYM(func, fp, "execvp");
+
+  bear_env_t current_env;
+  bear_capture_env_t(&current_env);
+  bear_reset_env_t(&initial_env);
+  int const result = (*fp)(file, argv);
+  bear_reset_env_t(&current_env);
+  bear_release_env_t(&current_env);
+
+  return result;
+}
+#endif
+
+#ifdef HAVE_EXECVP2
+static int call_execvP(const char *file, const char *search_path,
+                       char *const argv[]) {
+  typedef int (*func)(const char *, const char *, char *const *);
+
+  DLSYM(func, fp, "execvP");
+
+  bear_env_t current_env;
+  bear_capture_env_t(&current_env);
+  bear_reset_env_t(&initial_env);
+  int const result = (*fp)(file, search_path, argv);
+  bear_reset_env_t(&current_env);
+  bear_release_env_t(&current_env);
+
+  return result;
+}
+#endif
+
+#ifdef HAVE_EXECT
+static int call_exect(const char *path, char *const argv[],
+                      char *const envp[]) {
+  typedef int (*func)(const char *, char *const *, char *const *);
+
+  DLSYM(func, fp, "exect");
+
+  char const **const menvp = bear_update_environment(envp, &initial_env);
+  int const result = (*fp)(path, argv, (char *const *)menvp);
+  bear_strings_release(menvp);
+  return result;
+}
+#endif
+
+#ifdef HAVE_POSIX_SPAWN
+static int call_posix_spawn(pid_t *restrict pid, const char *restrict path,
+                            const posix_spawn_file_actions_t *file_actions,
+                            const posix_spawnattr_t *restrict attrp,
+                            char *const argv[restrict],
+                            char *const envp[restrict]) {
+  typedef int (*func)(pid_t *restrict, const char *restrict,
+                      const posix_spawn_file_actions_t *,
+                      const posix_spawnattr_t *restrict, char *const *restrict,
+                      char *const *restrict);
+
+  DLSYM(func, fp, "posix_spawn");
+
+  char const **const menvp = bear_update_environment(envp, &initial_env);
+  int const result =
+      (*fp)(pid, path, file_actions, attrp, argv, (char *const *restrict)menvp);
+  bear_strings_release(menvp);
+  return result;
+}
+#endif
+
+#ifdef HAVE_POSIX_SPAWNP
+static int call_posix_spawnp(pid_t *restrict pid, const char *restrict file,
+                             const posix_spawn_file_actions_t *file_actions,
+                             const posix_spawnattr_t *restrict attrp,
+                             char *const argv[restrict],
+                             char *const envp[restrict]) {
+  typedef int (*func)(pid_t *restrict, const char *restrict,
+                      const posix_spawn_file_actions_t *,
+                      const posix_spawnattr_t *restrict, char *const *restrict,
+                      char *const *restrict);
+
+  DLSYM(func, fp, "posix_spawnp");
+
+  char const **const menvp = bear_update_environment(envp, &initial_env);
+  int const result =
+      (*fp)(pid, file, file_actions, attrp, argv, (char *const *restrict)menvp);
+  bear_strings_release(menvp);
+  return result;
+}
+#endif
+
+/* this method is to write log about the process creation. */
+
+static void bear_report_call(char const *fun, char const *const argv[]) {
+  static int const GS = 0x1d;
+  static int const RS = 0x1e;
+  static int const US = 0x1f;
+
+  if (!initialized)
+    return;
+
+  pthread_mutex_lock(&mutex);
+  const char *cwd = getcwd(NULL, 0);
+  if (0 == cwd) {
+    perror("bear: getcwd");
+    exit(EXIT_FAILURE);
+  }
+  char const *const out_dir = initial_env[0];
+  size_t const path_max_length = strlen(out_dir) + 32;
+  char filename[path_max_length];
+  if (-1 ==
+      snprintf(filename, path_max_length, "%s/%d.cmd", out_dir, getpid())) {
+    perror("bear: snprintf");
+    exit(EXIT_FAILURE);
+  }
+  FILE *fd = fopen(filename, "a+");
+  if (0 == fd) {
+    perror("bear: fopen");
+    exit(EXIT_FAILURE);
+  }
+  fprintf(fd, "%d%c", getpid(), RS);
+  fprintf(fd, "%d%c", getppid(), RS);
+  fprintf(fd, "%s%c", fun, RS);
+  fprintf(fd, "%s%c", cwd, RS);
+  size_t const argc = bear_strings_length(argv);
+  for (size_t it = 0; it < argc; ++it) {
+    fprintf(fd, "%s%c", argv[it], US);
+  }
+  fprintf(fd, "%c", GS);
+  if (fclose(fd)) {
+    perror("bear: fclose");
+    exit(EXIT_FAILURE);
+  }
+  free((void *)cwd);
+  pthread_mutex_unlock(&mutex);
+}
+
+/* update environment assure that chilren processes will copy the desired
+ * behaviour */
+
+static int bear_capture_env_t(bear_env_t *env) {
+  int status = 1;
+  for (size_t it = 0; it < ENV_SIZE; ++it) {
+    char const *const env_value = getenv(env_names[it]);
+    char const *const env_copy = (env_value) ? strdup(env_value) : env_value;
+    (*env)[it] = env_copy;
+    status &= (env_copy) ? 1 : 0;
+  }
+  return status;
+}
+
+static int bear_reset_env_t(bear_env_t *env) {
+  int status = 1;
+  for (size_t it = 0; it < ENV_SIZE; ++it) {
+    if ((*env)[it]) {
+      setenv(env_names[it], (*env)[it], 1);
+    } else {
+      unsetenv(env_names[it]);
+    }
+  }
+  return status;
+}
+
+static void bear_release_env_t(bear_env_t *env) {
+  for (size_t it = 0; it < ENV_SIZE; ++it) {
+    free((void *)(*env)[it]);
+    (*env)[it] = 0;
+  }
+}
+
+static char const **bear_update_environment(char *const envp[],
+                                            bear_env_t *env) {
+  char const **result = bear_strings_copy((char const **)envp);
+  for (size_t it = 0; it < ENV_SIZE && (*env)[it]; ++it)
+    result = bear_update_environ(result, env_names[it], (*env)[it]);
+  return result;
+}
+
+static char const **bear_update_environ(char const *envs[], char const *key,
+                                        char const *const value) {
+  // find the key if it's there
+  size_t const key_length = strlen(key);
+  char const **it = envs;
+  for (; (it) && (*it); ++it) {
+    if ((0 == strncmp(*it, key, key_length)) && (strlen(*it) > key_length) &&
+        ('=' == (*it)[key_length]))
+      break;
+  }
+  // allocate a environment entry
+  size_t const value_length = strlen(value);
+  size_t const env_length = key_length + value_length + 2;
+  char *env = malloc(env_length);
+  if (0 == env) {
+    perror("bear: malloc [in env_update]");
+    exit(EXIT_FAILURE);
+  }
+  if (-1 == snprintf(env, env_length, "%s=%s", key, value)) {
+    perror("bear: snprintf");
+    exit(EXIT_FAILURE);
+  }
+  // replace or append the environment entry
+  if (it && *it) {
+    free((void *)*it);
+    *it = env;
+    return envs;
+  }
+  return bear_strings_append(envs, env);
+}
+
+static char **bear_get_environment() {
+#if defined HAVE_NSGETENVIRON
+  return *_NSGetEnviron();
+#else
+  return environ;
+#endif
+}
+
+/* util methods to deal with string arrays. environment and process arguments
+ * are both represented as string arrays. */
+
+static char const **bear_strings_build(char const *const arg, va_list *args) {
+  char const **result = 0;
+  size_t size = 0;
+  for (char const *it = arg; it; it = va_arg(*args, char const *)) {
+    result = realloc(result, (size + 1) * sizeof(char const *));
+    if (0 == result) {
+      perror("bear: realloc");
+      exit(EXIT_FAILURE);
+    }
+    char const *copy = strdup(it);
+    if (0 == copy) {
+      perror("bear: strdup");
+      exit(EXIT_FAILURE);
+    }
+    result[size++] = copy;
+  }
+  result = realloc(result, (size + 1) * sizeof(char const *));
+  if (0 == result) {
+    perror("bear: realloc");
+    exit(EXIT_FAILURE);
+  }
+  result[size++] = 0;
+
+  return result;
+}
+
+static char const **bear_strings_copy(char const **const in) {
+  size_t const size = bear_strings_length(in);
+
+  char const **const result = malloc((size + 1) * sizeof(char const *));
+  if (0 == result) {
+    perror("bear: malloc");
+    exit(EXIT_FAILURE);
+  }
+
+  char const **out_it = result;
+  for (char const *const *in_it = in; (in_it) && (*in_it); ++in_it, ++out_it) {
+    *out_it = strdup(*in_it);
+    if (0 == *out_it) {
+      perror("bear: strdup");
+      exit(EXIT_FAILURE);
+    }
+  }
+  *out_it = 0;
+  return result;
+}
+
+static char const **bear_strings_append(char const **const in,
+                                        char const *const e) {
+  size_t size = bear_strings_length(in);
+  char const **result = realloc(in, (size + 2) * sizeof(char const *));
+  if (0 == result) {
+    perror("bear: realloc");
+    exit(EXIT_FAILURE);
+  }
+  result[size++] = e;
+  result[size++] = 0;
+  return result;
+}
+
+static size_t bear_strings_length(char const *const *const in) {
+  size_t result = 0;
+  for (char const *const *it = in; (it) && (*it); ++it)
+    ++result;
+  return result;
+}
+
+static void bear_strings_release(char const **in) {
+  for (char const *const *it = in; (it) && (*it); ++it) {
+    free((void *)*it);
+  }
+  free((void *)in);
+}
 No newline at end of file

clang/tools/scan-build-py/lib/libscanbuild/arguments.py

def parse_args_for_analyze_build():
     logging.debug('Parsed arguments: %s', args)
     return args
 
 
 def parse_args_for_scan_build():
     """ Parse and validate command-line arguments for scan-build. """
 
     from_build_command = True
+    logging.warning("hello")
     parser = create_analyze_parser(from_build_command)
     args = parser.parse_args()
 
     reconfigure_logging(args.verbose)
     logging.debug('Raw arguments %s', sys.argv)
 
     normalize_args_for_analyze(args, from_build_command)
     validate_args_for_analyze(parser, args, from_build_command)

clang/tools/scan-build-py/lib/libscanbuild/report.py

def merge_sarif_files(output_dir, sort_files=False):
 
     with open(os.path.join(output_dir, 'results-merged.sarif'), 'w') as out:
         json.dump(merged, out, indent=4, sort_keys=True)
 
 
 def parse_bug_plist(filename):
     """ Returns the generator of bugs from a single .plist file. """
 
-    content = plistlib.readPlist(filename)
+    with open(filename, 'rb') as fp:
+      content = plistlib.load(fp)
       files = content.get('files')
       for bug in content.get('diagnostics', []):
           if len(files) <= int(bug['location']['file']):
               logging.warning('Parsing bug from "%s" failed', filename)
               continue
 
           yield {
               'result': filename,
               'bug_type': bug['type'],
               'bug_category': bug['category'],
               'bug_line': int(bug['location']['line']),
               'bug_path_length': int(bug['location']['col']),
               'bug_file': files[int(bug['location']['file'])]
           }
 
 
 def parse_bug_html(filename):
     """ Parse out the bug information from HTML output. """
 
     patterns = [re.compile(r'<!-- BUGTYPE (?P<bug_type>.*) -->$'),
                 re.compile(r'<!-- BUGFILE (?P<bug_file>.*) -->$'),
                 re.compile(r'<!-- BUGPATHLENGTH (?P<bug_path_length>.*) -->$'),

clang/tools/scan-build-py/lib/libscanbuild/resources/selectable.js

-function SetDisplay(RowClass, DisplayVal)
-{
+function SetDisplay(RowClass, DisplayVal) {
   var Rows = document.getElementsByTagName("tr");
-  for ( var i = 0 ; i < Rows.length; ++i ) {
+  for (var i = 0; i < Rows.length; ++i) {
     if (Rows[i].className == RowClass) {
       Rows[i].style.display = DisplayVal;
     }
   }
 }
 
 function CopyCheckedStateToCheckButtons(SummaryCheckButton) {
   var Inputs = document.getElementsByTagName("input");
-  for ( var i = 0 ; i < Inputs.length; ++i ) {
+  for (var i = 0; i < Inputs.length; ++i) {
     if (Inputs[i].type == "checkbox") {
-      if(Inputs[i] != SummaryCheckButton) {
+      if (Inputs[i] != SummaryCheckButton) {
         Inputs[i].checked = SummaryCheckButton.checked;
         Inputs[i].onclick();
-    }
+      }
     }
   }
 }
 
-function returnObjById( id ) {
-    if (document.getElementById)
-        var returnVar = document.getElementById(id);
-    else if (document.all)
-        var returnVar = document.all[id];
-    else if (document.layers)
-        var returnVar = document.layers[id];
-    return returnVar;
+function returnObjById(id) {
 }
 
 var NumUnchecked = 0;
 
 function ToggleDisplay(CheckButton, ClassName) {
   if (CheckButton.checked) {
     SetDisplay(ClassName, "");
     if (--NumUnchecked == 0) {
       returnObjById("AllBugsCheck").checked = true;
     }
-  }
-  else {
+  } else {
     SetDisplay(ClassName, "none");
     NumUnchecked++;
     returnObjById("AllBugsCheck").checked = false;
   }
 }

clang/tools/scan-build-py/lib/libscanbuild/resources/sorttable.js

+/*
+  SortTable
+  version 2
+  7th April 2007
+  Stuart Langridge, http://www.kryogenix.org/code/browser/sorttable/
+
+  Instructions:
+  Download this file
+  Add <script src="sorttable.js"></script> to your HTML
+  Add class="sortable" to any table you'd like to make sortable
+  Click on the headers to sort
+
+  Thanks to many, many people for contributions and suggestions.
+  Licenced as X11: http://www.kryogenix.org/code/browser/licence.html
+  This basically means: do what you want with it.
+*/
+
+var stIsIE = /*@cc_on!@*/ false;
+
+sorttable = {
+  init : function() {
+    // quit if this function has already been called
+    if (arguments.callee.done)
+      return;
+    // flag this function so we don't do the same thing twice
+    arguments.callee.done = true;
+    // kill the timer
+    if (_timer)
+      clearInterval(_timer);
+
+    if (!document.createElement || !document.getElementsByTagName)
+      return;
+
+    sorttable.DATE_RE = /^(\d\d?)[\/\.-](\d\d?)[\/\.-]((\d\d)?\d\d)$/;
+
+    forEach(document.getElementsByTagName('table'), function(table) {
+      if (table.className.search(/\bsortable\b/) != -1) {
+        sorttable.makeSortable(table);
+      }
+    });
+  },
+
+  makeSortable : function(table) {
+    if (table.getElementsByTagName('thead').length == 0) {
+      // table doesn't have a tHead. Since it should have, create one and
+      // put the first table row in it.
+      the = document.createElement('thead');
+      the.appendChild(table.rows[0]);
+      table.insertBefore(the, table.firstChild);
+    }
+    // Safari doesn't support table.tHead, sigh
+    if (table.tHead == null)
+      table.tHead = table.getElementsByTagName('thead')[0];
+
+    if (table.tHead.rows.length != 1)
+      return; // can't cope with two header rows
+
+    // Sorttable v1 put rows with a class of "sortbottom" at the bottom (as
+    // "total" rows, for example). This is B&R, since what you're supposed
+    // to do is put them in a tfoot. So, if there are sortbottom rows,
+    // for backward compatibility, move them to tfoot (creating it if needed).
+    sortbottomrows = [];
+    for (var i = 0; i < table.rows.length; i++) {
+      if (table.rows[i].className.search(/\bsortbottom\b/) != -1) {
+        sortbottomrows[sortbottomrows.length] = table.rows[i];
+      }
+    }
+    if (sortbottomrows) {
+      if (table.tFoot == null) {
+        // table doesn't have a tfoot. Create one.
+        tfo = document.createElement('tfoot');
+        table.appendChild(tfo);
+      }
+      for (var i = 0; i < sortbottomrows.length; i++) {
+        tfo.appendChild(sortbottomrows[i]);
+      }
+      delete sortbottomrows;
+    }
+
+    // work through each column and calculate its type
+    headrow = table.tHead.rows[0].cells;
+    for (var i = 0; i < headrow.length; i++) {
+      // manually override the type with a sorttable_type attribute
+      if (!headrow[i].className.match(
+              /\bsorttable_nosort\b/)) { // skip this col
+        mtch = headrow[i].className.match(/\bsorttable_([a-z0-9]+)\b/);
+        if (mtch) {
+          override = mtch[1];
+        }
+        if (mtch && typeof sorttable["sort_" + override] == 'function') {
+          headrow[i].sorttable_sortfunction = sorttable["sort_" + override];
+        } else {
+          headrow[i].sorttable_sortfunction = sorttable.guessType(table, i);
+        }
+        // make it clickable to sort
+        headrow[i].sorttable_columnindex = i;
+        headrow[i].sorttable_tbody = table.tBodies[0];
+        dean_addEvent(headrow[i], "click", function(e) {
+          if (this.className.search(/\bsorttable_sorted\b/) != -1) {
+            // if we're already sorted by this column, just
+            // reverse the table, which is quicker
+            sorttable.reverse(this.sorttable_tbody);
+            this.className = this.className.replace('sorttable_sorted',
+                                                    'sorttable_sorted_reverse');
+            this.removeChild(document.getElementById('sorttable_sortfwdind'));
+            sortrevind = document.createElement('span');
+            sortrevind.id = "sorttable_sortrevind";
+            sortrevind.innerHTML = stIsIE
+                                       ? '&nbsp<font face="webdings">5</font>'
+                                       : '&nbsp;&#x25B4;';
+            this.appendChild(sortrevind);
+            return;
+          }
+          if (this.className.search(/\bsorttable_sorted_reverse\b/) != -1) {
+            // if we're already sorted by this column in reverse, just
+            // re-reverse the table, which is quicker
+            sorttable.reverse(this.sorttable_tbody);
+            this.className = this.className.replace('sorttable_sorted_reverse',
+                                                    'sorttable_sorted');
+            this.removeChild(document.getElementById('sorttable_sortrevind'));
+            sortfwdind = document.createElement('span');
+            sortfwdind.id = "sorttable_sortfwdind";
+            sortfwdind.innerHTML = stIsIE
+                                       ? '&nbsp<font face="webdings">6</font>'
+                                       : '&nbsp;&#x25BE;';
+            this.appendChild(sortfwdind);
+            return;
+          }
+
+          // remove sorttable_sorted classes
+          theadrow = this.parentNode;
+          forEach(theadrow.childNodes, function(cell) {
+            if (cell.nodeType == 1) { // an element
+              cell.className =
+                  cell.className.replace('sorttable_sorted_reverse', '');
+              cell.className = cell.className.replace('sorttable_sorted', '');
+            }
+          });
+          sortfwdind = document.getElementById('sorttable_sortfwdind');
+          if (sortfwdind) {
+            sortfwdind.parentNode.removeChild(sortfwdind);
+          }
+          sortrevind = document.getElementById('sorttable_sortrevind');
+          if (sortrevind) {
+            sortrevind.parentNode.removeChild(sortrevind);
+          }
+
+          this.className += ' sorttable_sorted';
+          sortfwdind = document.createElement('span');
+          sortfwdind.id = "sorttable_sortfwdind";
+          sortfwdind.innerHTML =
+              stIsIE ? '&nbsp<font face="webdings">6</font>' : '&nbsp;&#x25BE;';
+          this.appendChild(sortfwdind);
+
+          // build an array to sort. This is a Schwartzian transform thing,
+          // i.e., we "decorate" each row with the actual sort key,
+          // sort based on the sort keys, and then put the rows back in order
+          // which is a lot faster because you only do getInnerText once per row
+          row_array = [];
+          col = this.sorttable_columnindex;
+          rows = this.sorttable_tbody.rows;
+          for (var j = 0; j < rows.length; j++) {
+            row_array[row_array.length] =
+                [ sorttable.getInnerText(rows[j].cells[col]), rows[j] ];
+          }
+          /* If you want a stable sort, uncomment the following line */
+          sorttable.shaker_sort(row_array, this.sorttable_sortfunction);
+          /* and comment out this one */
+          // row_array.sort(this.sorttable_sortfunction);
+
+          tb = this.sorttable_tbody;
+          for (var j = 0; j < row_array.length; j++) {
+            tb.appendChild(row_array[j][1]);
+          }
+
+          delete row_array;
+        });
+      }
+    }
+  },
+
+  guessType : function(table, column) {
+    // guess the type of a column based on its first non-blank row
+    sortfn = sorttable.sort_alpha;
+    for (var i = 0; i < table.tBodies[0].rows.length; i++) {
+      text = sorttable.getInnerText(table.tBodies[0].rows[i].cells[column]);
+      if (text != '') {
+        if (text.match(/^-?[｣$､]?[\d,.]+%?$/)) {
+          return sorttable.sort_numeric;
+        }
+        // check for a date: dd/mm/yyyy or dd/mm/yy
+        // can have / or . or - as separator
+        // can be mm/dd as well
+        possdate = text.match(sorttable.DATE_RE)
+        if (possdate) {
+          // looks like a date
+          first = parseInt(possdate[1]);
+          second = parseInt(possdate[2]);
+          if (first > 12) {
+            // definitely dd/mm
+            return sorttable.sort_ddmm;
+          } else if (second > 12) {
+            return sorttable.sort_mmdd;
+          } else {
+            // looks like a date, but we can't tell which, so assume
+            // that it's dd/mm (English imperialism!) and keep looking
+            sortfn = sorttable.sort_ddmm;
+          }
+        }
+      }
+    }
+    return sortfn;
+  },
+
+  getInnerText : function(node) {
+    // gets the text we want to use for sorting for a cell.
+    // strips leading and trailing whitespace.
+    // this is *not* a generic getInnerText function; it's special to sorttable.
+    // for example, you can override the cell text with a customkey attribute.
+    // it also gets .value for <input> fields.
+
+    hasInputs = (typeof node.getElementsByTagName == 'function') &&
+                node.getElementsByTagName('input').length;
+
+    if (node.getAttribute("sorttable_customkey") != null) {
+      return node.getAttribute("sorttable_customkey");
+    } else if (typeof node.textContent != 'undefined' && !hasInputs) {
+      return node.textContent.replace(/^\s+|\s+$/g, '');
+    } else if (typeof node.innerText != 'undefined' && !hasInputs) {
+      return node.innerText.replace(/^\s+|\s+$/g, '');
+    } else if (typeof node.text != 'undefined' && !hasInputs) {
+      return node.text.replace(/^\s+|\s+$/g, '');
+    } else {
+      switch (node.nodeType) {
+      case 3:
+        if (node.nodeName.toLowerCase() == 'input') {
+          return node.value.replace(/^\s+|\s+$/g, '');
+        }
+      case 4:
+        return node.nodeValue.replace(/^\s+|\s+$/g, '');
+        break;
+      case 1:
+      case 11:
+        var innerText = '';
+        for (var i = 0; i < node.childNodes.length; i++) {
+          innerText += sorttable.getInnerText(node.childNodes[i]);
+        }
+        return innerText.replace(/^\s+|\s+$/g, '');
+        break;
+      default:
+        return '';
+      }
+    }
+  },
+
+  reverse : function(tbody) {
+    // reverse the rows in a tbody
+    newrows = [];
+    for (var i = 0; i < tbody.rows.length; i++) {
+      newrows[newrows.length] = tbody.rows[i];
+    }
+    for (var i = newrows.length - 1; i >= 0; i--) {
+      tbody.appendChild(newrows[i]);
+    }
+    delete newrows;
+  },
+
+  /* sort functions
+     each sort function takes two parameters, a and b
+     you are comparing a[0] and b[0] */
+  sort_numeric : function(a, b) {
+    aa = parseFloat(a[0].replace(/[^0-9.-]/g, ''));
+    if (isNaN(aa))
+      aa = 0;
+    bb = parseFloat(b[0].replace(/[^0-9.-]/g, ''));
+    if (isNaN(bb))
+      bb = 0;
+    return aa - bb;
+  },
+  sort_alpha : function(a, b) {
+    if (a[0] == b[0])
+      return 0;
+    if (a[0] < b[0])
+      return -1;
+    return 1;
+  },
+  sort_ddmm : function(a, b) {
+    mtch = a[0].match(sorttable.DATE_RE);
+    y = mtch[3];
+    m = mtch[2];
+    d = mtch[1];
+    if (m.length == 1)
+      m = '0' + m;
+    if (d.length == 1)
+      d = '0' + d;
+    dt1 = y + m + d;
+    mtch = b[0].match(sorttable.DATE_RE);
+    y = mtch[3];
+    m = mtch[2];
+    d = mtch[1];
+    if (m.length == 1)
+      m = '0' + m;
+    if (d.length == 1)
+      d = '0' + d;
+    dt2 = y + m + d;
+    if (dt1 == dt2)
+      return 0;
+    if (dt1 < dt2)
+      return -1;
+    return 1;
+  },
+  sort_mmdd : function(a, b) {
+    mtch = a[0].match(sorttable.DATE_RE);
+    y = mtch[3];
+    d = mtch[2];
+    m = mtch[1];
+    if (m.length == 1)
+      m = '0' + m;
+    if (d.length == 1)
+      d = '0' + d;
+    dt1 = y + m + d;
+    mtch = b[0].match(sorttable.DATE_RE);
+    y = mtch[3];
+    d = mtch[2];
+    m = mtch[1];
+    if (m.length == 1)
+      m = '0' + m;
+    if (d.length == 1)
+      d = '0' + d;
+    dt2 = y + m + d;
+    if (dt1 == dt2)
+      return 0;
+    if (dt1 < dt2)
+      return -1;
+    return 1;
+  },
+
+  shaker_sort : function(list, comp_func) {
+    // A stable sort function to allow multi-level sorting of data
+    // see: http://en.wikipedia.org/wiki/Cocktail_sort
+    // thanks to Joseph Nahmias
+    var b = 0;
+    var t = list.length - 1;
+    var swap = true;
+
+    while (swap) {
+      swap = false;
+      for (var i = b; i < t; ++i) {
+        if (comp_func(list[i], list[i + 1]) > 0) {
+          var q = list[i];
+          list[i] = list[i + 1];
+          list[i + 1] = q;
+          swap = true;
+        }
+      } // for
+      t--;
+
+      if (!swap)
+        break;
+
+      for (var i = t; i > b; --i) {
+        if (comp_func(list[i], list[i - 1]) < 0) {
+          var q = list[i];
+          list[i] = list[i - 1];
+          list[i - 1] = q;
+          swap = true;
+        }
+      } // for
+      b++;
+
+    } // while(swap)
+  }
+}
+
+/* ******************************************************************
+   Supporting functions: bundled here to avoid depending on a library
+   ****************************************************************** */
+
+// Dean Edwards/Matthias Miller/John Resig
+
+/* for Mozilla/Opera9 */
+if (document.addEventListener) {
+  document.addEventListener("DOMContentLoaded", sorttable.init, false);
+}
+
+/* for Internet Explorer */
+/*@cc_on @*/
+/*@if (@_win32)
+    document.write("<script id=__ie_onload defer
+src=javascript:void(0)><\/script>"); var script =
+document.getElementById("__ie_onload"); script.onreadystatechange = function() {
+        if (this.readyState == "complete") {
+            sorttable.init(); // call the onload handler
+        }
+    };
+/*@end @*/
+
+/* for Safari */
+if (/WebKit/i.test(navigator.userAgent)) { // sniff
+  var _timer = setInterval(function() {
+    if (/loaded|complete/.test(document.readyState)) {
+      sorttable.init(); // call the onload handler
+    }
+  }, 10);
+}
+
+/* for other browsers */
+window.onload = sorttable.init;
+
+// written by Dean Edwards, 2005
+// with input from Tino Zijdel, Matthias Miller, Diego Perini
+
+// http://dean.edwards.name/weblog/2005/10/add-event/
+
+function dean_addEvent(element, type, handler) {
+  if (element.addEventListener) {
+    element.addEventListener(type, handler, false);
+  } else {
+    // assign each event handler a unique ID
+    if (!handler.$$guid)
+      handler.$$guid = dean_addEvent.guid++;
+    // create a hash table of event types for the element
+    if (!element.events)
+      element.events = {};
+    // create a hash table of event handlers for each element/event pair
+    var handlers = element.events[type];
+    if (!handlers) {
+      handlers = element.events[type] = {};
+      // store the existing event handler (if there is one)
+      if (element["on" + type]) {
+        handlers[0] = element["on" + type];
+      }
+    }
+    // store the event handler in the hash table
+    handlers[handler.$$guid] = handler;
+    // assign a global event handler to do all the work
+    element["on" + type] = handleEvent;
+  }
+};
+// a counter used to create unique IDs
+dean_addEvent.guid = 1;
+
+function removeEvent(element, type, handler) {
+  if (element.removeEventListener) {
+    element.removeEventListener(type, handler, false);
+  } else {
+    // delete the event handler from the hash table
+    if (element.events && element.events[type]) {
+      delete element.events[type][handler.$$guid];
+    }
+  }
+};
+
+function handleEvent(event) {
+  var returnValue = true;
+  // grab the event object (IE uses a global event object)
+  event =
+      event ||
+      fixEvent(
+          ((this.ownerDocument || this.document || this).parentWindow || window)
+              .event);
+  // get a reference to the hash table of event handlers
+  var handlers = this.events[event.type];
+  // execute each event handler
+  for (var i in handlers) {
+    this.$$handleEvent = handlers[i];
+    if (this.$$handleEvent(event) === false) {
+      returnValue = false;
+    }
+  }
+  return returnValue;
+};
+
+function fixEvent(event) {
+  // add W3C standard event methods
+  event.preventDefault = fixEvent.preventDefault;
+  event.stopPropagation = fixEvent.stopPropagation;
+  return event;
+};
+fixEvent.preventDefault = function() { this.returnValue = false; };
+fixEvent.stopPropagation = function() { this.cancelBubble = true; }
+
+// Dean's forEach: http://dean.edwards.name/base/forEach.js
+/*
+        forEach, version 1.0
+        Copyright 2006, Dean Edwards
+        License: http://www.opensource.org/licenses/mit-license.php
+*/
+
+// array-like enumeration
+if (!Array.forEach) { // mozilla already supports this
+  Array.forEach = function(array, block, context) {
+    for (var i = 0; i < array.length; i++) {
+      block.call(context, array[i], i, array);
+    }
+  };
+}
+
+// generic enumeration
+Function.prototype.forEach = function(object, block, context) {
+  for (var key in object) {
+    if (typeof this.prototype[key] == "undefined") {
+      block.call(context, object[key], key, object);
+    }
+  }
+};
+
+// character enumeration
+String.forEach = function(string, block, context) {
+  Array.forEach(
+      string.split(""),
+      function(chr, index) { block.call(context, chr, index, string); });
+};
+
+// globally resolve forEach enumeration
+var forEach = function(object, block, context) {
+  if (object) {
+    var resolve = Object; // default
+    if (object instanceof Function) {
+      // functions have a "length" property
+      resolve = Function;
+    } else if (object.forEach instanceof Function) {
+      // the object implements a custom forEach method so use that
+      object.forEach(block, context);
+      return;
+    } else if (typeof object == "string") {
+      // the object is a string
+      resolve = String;
+    } else if (typeof object.length == "number") {
+      // the object is array-like
+      resolve = Array;
+    }
+    resolve.forEach(object, block, context);
+  }
+};

clang/tools/scan-build-py/libear/ear.c

-/* -*- coding: utf-8 -*-
-// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
-// See https://llvm.org/LICENSE.txt for license information.
-// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
-*/
-
-/**
- * This file implements a shared library. This library can be pre-loaded by
- * the dynamic linker of the Operating System (OS). It implements a few function
- * related to process creation. By pre-load this library the executed process
- * uses these functions instead of those from the standard library.
- *
- * The idea here is to inject a logic before call the real methods. The logic is
- * to dump the call into a file. To call the real method this library is doing
- * the job of the dynamic linker.
- *
- * The only input for the log writing is about the destination directory.
- * This is passed as environment variable.
- */
-
-#include "config.h"
-
-#include <stddef.h>
-#include <stdarg.h>
-#include <stdlib.h>
-#include <stdio.h>
-#include <string.h>
-#include <unistd.h>
-#include <dlfcn.h>
-#include <pthread.h>
-
-#if defined HAVE_POSIX_SPAWN || defined HAVE_POSIX_SPAWNP
-#include <spawn.h>
-#endif
-
-#if defined HAVE_NSGETENVIRON
-# include <crt_externs.h>
-#else
-extern char **environ;
-#endif
-
-#define ENV_OUTPUT "INTERCEPT_BUILD_TARGET_DIR"
-#ifdef APPLE
-# define ENV_FLAT    "DYLD_FORCE_FLAT_NAMESPACE"
-# define ENV_PRELOAD "DYLD_INSERT_LIBRARIES"
-# define ENV_SIZE 3
-#else
-# define ENV_PRELOAD "LD_PRELOAD"
-# define ENV_SIZE 2
-#endif
-
-#define DLSYM(TYPE_, VAR_, SYMBOL_)                                            \
-    union {                                                                    \
-        void *from;                                                            \
-        TYPE_ to;                                                              \
-    } cast;                                                                    \
-    if (0 == (cast.from = dlsym(RTLD_NEXT, SYMBOL_))) {                        \
-        perror("bear: dlsym");                                                 \
-        exit(EXIT_FAILURE);                                                    \
-    }                                                                          \
-    TYPE_ const VAR_ = cast.to;
-
-
-typedef char const * bear_env_t[ENV_SIZE];
-
-static int bear_capture_env_t(bear_env_t *env);
-static int bear_reset_env_t(bear_env_t *env);
-static void bear_release_env_t(bear_env_t *env);
-static char const **bear_update_environment(char *const envp[], bear_env_t *env);
-static char const **bear_update_environ(char const **in, char const *key, char const *value);
-static char **bear_get_environment();
-static void bear_report_call(char const *fun, char const *const argv[]);
-static char const **bear_strings_build(char const *arg, va_list *ap);
-static char const **bear_strings_copy(char const **const in);
-static char const **bear_strings_append(char const **in, char const *e);
-static size_t bear_strings_length(char const *const *in);
-static void bear_strings_release(char const **);
-
-
-static bear_env_t env_names =
-    { ENV_OUTPUT
-    , ENV_PRELOAD
-#ifdef ENV_FLAT
-    , ENV_FLAT
-#endif
-    };
-
-static bear_env_t initial_env =
-    { 0
-    , 0
-#ifdef ENV_FLAT
-    , 0
-#endif
-    };
-
-static int initialized = 0;
-static pthread_mutex_t mutex = PTHREAD_MUTEX_INITIALIZER;
-
-static void on_load(void) __attribute__((constructor));
-static void on_unload(void) __attribute__((destructor));
-
-
-#ifdef HAVE_EXECVE
-static int call_execve(const char *path, char *const argv[],
-                       char *const envp[]);
-#endif
-#ifdef HAVE_EXECVP
-static int call_execvp(const char *file, char *const argv[]);
-#endif
-#ifdef HAVE_EXECVPE
-static int call_execvpe(const char *file, char *const argv[],
-                        char *const envp[]);
-#endif
-#ifdef HAVE_EXECVP2
-static int call_execvP(const char *file, const char *search_path,
-                       char *const argv[]);
-#endif
-#ifdef HAVE_EXECT
-static int call_exect(const char *path, char *const argv[],
-                      char *const envp[]);
-#endif
-#ifdef HAVE_POSIX_SPAWN
-static int call_posix_spawn(pid_t *restrict pid, const char *restrict path,
-                            const posix_spawn_file_actions_t *file_actions,
-                            const posix_spawnattr_t *restrict attrp,
-                            char *const argv[restrict],
-                            char *const envp[restrict]);
-#endif
-#ifdef HAVE_POSIX_SPAWNP
-static int call_posix_spawnp(pid_t *restrict pid, const char *restrict file,
-                             const posix_spawn_file_actions_t *file_actions,
-                             const posix_spawnattr_t *restrict attrp,
-                             char *const argv[restrict],
-                             char *const envp[restrict]);
-#endif
-
-
-/* Initialization method to Captures the relevant environment variables.
- */
-
-static void on_load(void) {
-    pthread_mutex_lock(&mutex);
-    if (!initialized)
-        initialized = bear_capture_env_t(&initial_env);
-    pthread_mutex_unlock(&mutex);
-}
-
-static void on_unload(void) {
-    pthread_mutex_lock(&mutex);
-    bear_release_env_t(&initial_env);
-    initialized = 0;
-    pthread_mutex_unlock(&mutex);
-}
-
-
-/* These are the methods we are try to hijack.
- */
-
-#ifdef HAVE_EXECVE
-int execve(const char *path, char *const argv[], char *const envp[]) {
-    bear_report_call(__func__, (char const *const *)argv);
-    return call_execve(path, argv, envp);
-}
-#endif
-
-#ifdef HAVE_EXECV
-#ifndef HAVE_EXECVE
-#error can not implement execv without execve
-#endif
-int execv(const char *path, char *const argv[]) {
-    bear_report_call(__func__, (char const *const *)argv);
-    char * const * envp = bear_get_environment();
-    return call_execve(path, argv, envp);
-}
-#endif
-
-#ifdef HAVE_EXECVPE
-int execvpe(const char *file, char *const argv[], char *const envp[]) {
-    bear_report_call(__func__, (char const *const *)argv);
-    return call_execvpe(file, argv, envp);
-}
-#endif
-
-#ifdef HAVE_EXECVP
-int execvp(const char *file, char *const argv[]) {
-    bear_report_call(__func__, (char const *const *)argv);
-    return call_execvp(file, argv);
-}
-#endif
-
-#ifdef HAVE_EXECVP2
-int execvP(const char *file, const char *search_path, char *const argv[]) {
-    bear_report_call(__func__, (char const *const *)argv);
-    return call_execvP(file, search_path, argv);
-}
-#endif
-
-#ifdef HAVE_EXECT
-int exect(const char *path, char *const argv[], char *const envp[]) {
-    bear_report_call(__func__, (char const *const *)argv);
-    return call_exect(path, argv, envp);
-}
-#endif
-
-#ifdef HAVE_EXECL
-# ifndef HAVE_EXECVE
-#  error can not implement execl without execve
-# endif
-int execl(const char *path, const char *arg, ...) {
-    va_list args;
-    va_start(args, arg);
-    char const **argv = bear_strings_build(arg, &args);
-    va_end(args);
-
-    bear_report_call(__func__, (char const *const *)argv);
-    char * const * envp = bear_get_environment();
-    int const result = call_execve(path, (char *const *)argv, envp);
-
-    bear_strings_release(argv);
-    return result;
-}
-#endif
-
-#ifdef HAVE_EXECLP
-# ifndef HAVE_EXECVP
-#  error can not implement execlp without execvp
-# endif
-int execlp(const char *file, const char *arg, ...) {
-    va_list args;
-    va_start(args, arg);
-    char const **argv = bear_strings_build(arg, &args);
-    va_end(args);
-
-    bear_report_call(__func__, (char const *const *)argv);
-    int const result = call_execvp(file, (char *const *)argv);
-
-    bear_strings_release(argv);
-    return result;
-}
-#endif
-
-#ifdef HAVE_EXECLE
-# ifndef HAVE_EXECVE
-#  error can not implement execle without execve
-# endif
-// int execle(const char *path, const char *arg, ..., char * const envp[]);
-int execle(const char *path, const char *arg, ...) {
-    va_list args;
-    va_start(args, arg);
-    char const **argv = bear_strings_build(arg, &args);
-    char const **envp = va_arg(args, char const **);
-    va_end(args);
-
-    bear_report_call(__func__, (char const *const *)argv);
-    int const result =
-        call_execve(path, (char *const *)argv, (char *const *)envp);
-
-    bear_strings_release(argv);
-    return result;
-}
-#endif
-
-#ifdef HAVE_POSIX_SPAWN
-int posix_spawn(pid_t *restrict pid, const char *restrict path,
-                const posix_spawn_file_actions_t *file_actions,
-                const posix_spawnattr_t *restrict attrp,
-                char *const argv[restrict], char *const envp[restrict]) {
-    bear_report_call(__func__, (char const *const *)argv);
-    return call_posix_spawn(pid, path, file_actions, attrp, argv, envp);
-}
-#endif
-
-#ifdef HAVE_POSIX_SPAWNP
-int posix_spawnp(pid_t *restrict pid, const char *restrict file,
-                 const posix_spawn_file_actions_t *file_actions,
-                 const posix_spawnattr_t *restrict attrp,
-                 char *const argv[restrict], char *const envp[restrict]) {
-    bear_report_call(__func__, (char const *const *)argv);
-    return call_posix_spawnp(pid, file, file_actions, attrp, argv, envp);
-}
-#endif
-
-/* These are the methods which forward the call to the standard implementation.
- */
-
-#ifdef HAVE_EXECVE
-static int call_execve(const char *path, char *const argv[],
-                       char *const envp[]) {
-    typedef int (*func)(const char *, char *const *, char *const *);
-
-    DLSYM(func, fp, "execve");
-
-    char const **const menvp = bear_update_environment(envp, &initial_env);
-    int const result = (*fp)(path, argv, (char *const *)menvp);
-    bear_strings_release(menvp);
-    return result;
-}
-#endif
-
-#ifdef HAVE_EXECVPE
-static int call_execvpe(const char *file, char *const argv[],
-                        char *const envp[]) {
-    typedef int (*func)(const char *, char *const *, char *const *);
-
-    DLSYM(func, fp, "execvpe");
-
-    char const **const menvp = bear_update_environment(envp, &initial_env);
-    int const result = (*fp)(file, argv, (char *const *)menvp);
-    bear_strings_release(menvp);
-    return result;
-}
-#endif
-
-#ifdef HAVE_EXECVP
-static int call_execvp(const char *file, char *const argv[]) {
-    typedef int (*func)(const char *file, char *const argv[]);
-
-    DLSYM(func, fp, "execvp");
-
-    bear_env_t current_env;
-    bear_capture_env_t(&current_env);
-    bear_reset_env_t(&initial_env);
-    int const result = (*fp)(file, argv);
-    bear_reset_env_t(&current_env);
-    bear_release_env_t(&current_env);
-
-    return result;
-}
-#endif
-
-#ifdef HAVE_EXECVP2
-static int call_execvP(const char *file, const char *search_path,
-                       char *const argv[]) {
-    typedef int (*func)(const char *, const char *, char *const *);
-
-    DLSYM(func, fp, "execvP");
-
-    bear_env_t current_env;
-    bear_capture_env_t(&current_env);
-    bear_reset_env_t(&initial_env);
-    int const result = (*fp)(file, search_path, argv);
-    bear_reset_env_t(&current_env);
-    bear_release_env_t(&current_env);
-
-    return result;
-}
-#endif
-
-#ifdef HAVE_EXECT
-static int call_exect(const char *path, char *const argv[],
-                      char *const envp[]) {
-    typedef int (*func)(const char *, char *const *, char *const *);
-
-    DLSYM(func, fp, "exect");
-
-    char const **const menvp = bear_update_environment(envp, &initial_env);
-    int const result = (*fp)(path, argv, (char *const *)menvp);
-    bear_strings_release(menvp);
-    return result;
-}
-#endif
-
-#ifdef HAVE_POSIX_SPAWN
-static int call_posix_spawn(pid_t *restrict pid, const char *restrict path,
-                            const posix_spawn_file_actions_t *file_actions,
-                            const posix_spawnattr_t *restrict attrp,
-                            char *const argv[restrict],
-                            char *const envp[restrict]) {
-    typedef int (*func)(pid_t *restrict, const char *restrict,
-                        const posix_spawn_file_actions_t *,
-                        const posix_spawnattr_t *restrict,
-                        char *const *restrict, char *const *restrict);
-
-    DLSYM(func, fp, "posix_spawn");
-
-    char const **const menvp = bear_update_environment(envp, &initial_env);
-    int const result =
-        (*fp)(pid, path, file_actions, attrp, argv, (char *const *restrict)menvp);
-    bear_strings_release(menvp);
-    return result;
-}
-#endif
-
-#ifdef HAVE_POSIX_SPAWNP
-static int call_posix_spawnp(pid_t *restrict pid, const char *restrict file,
-                             const posix_spawn_file_actions_t *file_actions,
-                             const posix_spawnattr_t *restrict attrp,
-                             char *const argv[restrict],
-                             char *const envp[restrict]) {
-    typedef int (*func)(pid_t *restrict, const char *restrict,
-                        const posix_spawn_file_actions_t *,
-                        const posix_spawnattr_t *restrict,
-                        char *const *restrict, char *const *restrict);
-
-    DLSYM(func, fp, "posix_spawnp");
-
-    char const **const menvp = bear_update_environment(envp, &initial_env);
-    int const result =
-        (*fp)(pid, file, file_actions, attrp, argv, (char *const *restrict)menvp);
-    bear_strings_release(menvp);
-    return result;
-}
-#endif
-
-/* this method is to write log about the process creation. */
-
-static void bear_report_call(char const *fun, char const *const argv[]) {
-    static int const GS = 0x1d;
-    static int const RS = 0x1e;
-    static int const US = 0x1f;
-
-    if (!initialized)
-        return;
-
-    pthread_mutex_lock(&mutex);
-    const char *cwd = getcwd(NULL, 0);
-    if (0 == cwd) {
-        perror("bear: getcwd");
-        exit(EXIT_FAILURE);
-    }
-    char const * const out_dir = initial_env[0];
-    size_t const path_max_length = strlen(out_dir) + 32;
-    char filename[path_max_length];
-    if (-1 == snprintf(filename, path_max_length, "%s/%d.cmd", out_dir, getpid())) {
-        perror("bear: snprintf");
-        exit(EXIT_FAILURE);
-    }
-    FILE * fd = fopen(filename, "a+");
-    if (0 == fd) {
-        perror("bear: fopen");
-        exit(EXIT_FAILURE);
-    }
-    fprintf(fd, "%d%c", getpid(), RS);
-    fprintf(fd, "%d%c", getppid(), RS);
-    fprintf(fd, "%s%c", fun, RS);
-    fprintf(fd, "%s%c", cwd, RS);
-    size_t const argc = bear_strings_length(argv);
-    for (size_t it = 0; it < argc; ++it) {
-        fprintf(fd, "%s%c", argv[it], US);
-    }
-    fprintf(fd, "%c", GS);
-    if (fclose(fd)) {
-        perror("bear: fclose");
-        exit(EXIT_FAILURE);
-    }
-    free((void *)cwd);
-    pthread_mutex_unlock(&mutex);
-}
-
-/* update environment assure that chilren processes will copy the desired
- * behaviour */
-
-static int bear_capture_env_t(bear_env_t *env) {
-    int status = 1;
-    for (size_t it = 0; it < ENV_SIZE; ++it) {
-        char const * const env_value = getenv(env_names[it]);
-        char const * const env_copy = (env_value) ? strdup(env_value) : env_value;
-        (*env)[it] = env_copy;
-        status &= (env_copy) ? 1 : 0;
-    }
-    return status;
-}
-
-static int bear_reset_env_t(bear_env_t *env) {
-    int status = 1;
-    for (size_t it = 0; it < ENV_SIZE; ++it) {
-        if ((*env)[it]) {
-            setenv(env_names[it], (*env)[it], 1);
-        } else {
-            unsetenv(env_names[it]);
-        }
-    }
-    return status;
-}
-
-static void bear_release_env_t(bear_env_t *env) {
-    for (size_t it = 0; it < ENV_SIZE; ++it) {
-        free((void *)(*env)[it]);
-        (*env)[it] = 0;
-    }
-}
-
-static char const **bear_update_environment(char *const envp[], bear_env_t *env) {
-    char const **result = bear_strings_copy((char const **)envp);
-    for (size_t it = 0; it < ENV_SIZE && (*env)[it]; ++it)
-        result = bear_update_environ(result, env_names[it], (*env)[it]);
-    return result;
-}
-
-static char const **bear_update_environ(char const *envs[], char const *key, char const * const value) {
-    // find the key if it's there
-    size_t const key_length = strlen(key);
-    char const **it = envs;
-    for (; (it) && (*it); ++it) {
-        if ((0 == strncmp(*it, key, key_length)) &&
-            (strlen(*it) > key_length) && ('=' == (*it)[key_length]))
-            break;
-    }
-    // allocate a environment entry
-    size_t const value_length = strlen(value);
-    size_t const env_length = key_length + value_length + 2;
-    char *env = malloc(env_length);
-    if (0 == env) {
-        perror("bear: malloc [in env_update]");
-        exit(EXIT_FAILURE);
-    }
-    if (-1 == snprintf(env, env_length, "%s=%s", key, value)) {
-        perror("bear: snprintf");
-        exit(EXIT_FAILURE);
-    }
-    // replace or append the environment entry
-    if (it && *it) {
-        free((void *)*it);
-        *it = env;
-  return envs;
-    }
-    return bear_strings_append(envs, env);
-}
-
-static char **bear_get_environment() {
-#if defined HAVE_NSGETENVIRON
-    return *_NSGetEnviron();
-#else
-    return environ;
-#endif
-}
-
-/* util methods to deal with string arrays. environment and process arguments
- * are both represented as string arrays. */
-
-static char const **bear_strings_build(char const *const arg, va_list *args) {
-    char const **result = 0;
-    size_t size = 0;
-    for (char const *it = arg; it; it = va_arg(*args, char const *)) {
-        result = realloc(result, (size + 1) * sizeof(char const *));
-        if (0 == result) {
-            perror("bear: realloc");
-            exit(EXIT_FAILURE);
-        }
-        char const *copy = strdup(it);
-        if (0 == copy) {
-            perror("bear: strdup");
-            exit(EXIT_FAILURE);
-        }
-        result[size++] = copy;
-    }
-    result = realloc(result, (size + 1) * sizeof(char const *));
-    if (0 == result) {
-        perror("bear: realloc");
-        exit(EXIT_FAILURE);
-    }
-    result[size++] = 0;
-
-    return result;
-}
-
-static char const **bear_strings_copy(char const **const in) {
-    size_t const size = bear_strings_length(in);
-
-    char const **const result = malloc((size + 1) * sizeof(char const *));
-    if (0 == result) {
-        perror("bear: malloc");
-        exit(EXIT_FAILURE);
-    }
-
-    char const **out_it = result;
-    for (char const *const *in_it = in; (in_it) && (*in_it);
-         ++in_it, ++out_it) {
-        *out_it = strdup(*in_it);
-        if (0 == *out_it) {
-            perror("bear: strdup");
-            exit(EXIT_FAILURE);
-        }
-    }
-    *out_it = 0;
-    return result;
-}
-
-static char const **bear_strings_append(char const **const in,
-                                        char const *const e) {
-    size_t size = bear_strings_length(in);
-    char const **result = realloc(in, (size + 2) * sizeof(char const *));
-    if (0 == result) {
-        perror("bear: realloc");
-        exit(EXIT_FAILURE);
-    }
-    result[size++] = e;
-    result[size++] = 0;
-    return result;
-}
-
-static size_t bear_strings_length(char const *const *const in) {
-    size_t result = 0;
-    for (char const *const *it = in; (it) && (*it); ++it)
-        ++result;
-    return result;
-}
-
-static void bear_strings_release(char const **in) {
-    for (char const *const *it = in; (it) && (*it); ++it) {
-        free((void *)*it);
-    }
-    free((void *)in);
-}

clang/tools/scan-build-py/libexec/analyze-c++

 #!/usr/bin/env python
 # -*- coding: utf-8 -*-
 # Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 # See https://llvm.org/LICENSE.txt for license information.
 # SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 
 import sys
 import os.path
 this_dir = os.path.dirname(os.path.realpath(__file__))
-sys.path.append(os.path.dirname(this_dir))
+sys.path.append(os.path.join(os.path.dirname(this_dir), 'lib'))
+
 
 from libscanbuild.analyze import analyze_compiler_wrapper
 sys.exit(analyze_compiler_wrapper())

clang/tools/scan-build-py/libexec/analyze-cc

 #!/usr/bin/env python
 # -*- coding: utf-8 -*-
 # Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 # See https://llvm.org/LICENSE.txt for license information.
 # SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 
 import sys
 import os.path
 this_dir = os.path.dirname(os.path.realpath(__file__))
-sys.path.append(os.path.dirname(this_dir))
+sys.path.append(os.path.join(os.path.dirname(this_dir), 'lib'))
 
 from libscanbuild.analyze import analyze_compiler_wrapper
 sys.exit(analyze_compiler_wrapper())

clang/tools/scan-build-py/libexec/intercept-c++

 #!/usr/bin/env python
 # -*- coding: utf-8 -*-
 # Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 # See https://llvm.org/LICENSE.txt for license information.
 # SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 
 import sys
 import os.path
 this_dir = os.path.dirname(os.path.realpath(__file__))
-sys.path.append(os.path.dirname(this_dir))
+sys.path.append(os.path.join(os.path.dirname(this_dir), 'lib'))
 
 from libscanbuild.intercept import intercept_compiler_wrapper
 sys.exit(intercept_compiler_wrapper())

clang/tools/scan-build-py/libexec/intercept-cc

 #!/usr/bin/env python
 # -*- coding: utf-8 -*-
 # Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 # See https://llvm.org/LICENSE.txt for license information.
 # SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 
 import sys
 import os.path
 this_dir = os.path.dirname(os.path.realpath(__file__))
-sys.path.append(os.path.dirname(this_dir))
+sys.path.append(os.path.join(os.path.dirname(this_dir), 'lib'))
 
 from libscanbuild.intercept import intercept_compiler_wrapper
 sys.exit(intercept_compiler_wrapper())

clang/tools/scan-build-py/libscanbuild/resources/sorttable.js

-/*
-  SortTable
-  version 2
-  7th April 2007
-  Stuart Langridge, http://www.kryogenix.org/code/browser/sorttable/
-
-  Instructions:
-  Download this file
-  Add <script src="sorttable.js"></script> to your HTML
-  Add class="sortable" to any table you'd like to make sortable
-  Click on the headers to sort
-
-  Thanks to many, many people for contributions and suggestions.
-  Licenced as X11: http://www.kryogenix.org/code/browser/licence.html
-  This basically means: do what you want with it.
-*/
-
-
-var stIsIE = /*@cc_on!@*/false;
-
-sorttable = {
-  init: function() {
-    // quit if this function has already been called
-    if (arguments.callee.done) return;
-    // flag this function so we don't do the same thing twice
-    arguments.callee.done = true;
-    // kill the timer
-    if (_timer) clearInterval(_timer);
-
-    if (!document.createElement || !document.getElementsByTagName) return;
-
-    sorttable.DATE_RE = /^(\d\d?)[\/\.-](\d\d?)[\/\.-]((\d\d)?\d\d)$/;
-
-    forEach(document.getElementsByTagName('table'), function(table) {
-      if (table.className.search(/\bsortable\b/) != -1) {
-        sorttable.makeSortable(table);
-      }
-    });
-
-  },
-
-  makeSortable: function(table) {
-    if (table.getElementsByTagName('thead').length == 0) {
-      // table doesn't have a tHead. Since it should have, create one and
-      // put the first table row in it.
-      the = document.createElement('thead');
-      the.appendChild(table.rows[0]);
-      table.insertBefore(the,table.firstChild);
-    }
-    // Safari doesn't support table.tHead, sigh
-    if (table.tHead == null) table.tHead = table.getElementsByTagName('thead')[0];
-
-    if (table.tHead.rows.length != 1) return; // can't cope with two header rows
-
-    // Sorttable v1 put rows with a class of "sortbottom" at the bottom (as
-    // "total" rows, for example). This is B&R, since what you're supposed
-    // to do is put them in a tfoot. So, if there are sortbottom rows,
-    // for backward compatibility, move them to tfoot (creating it if needed).
-    sortbottomrows = [];
-    for (var i=0; i<table.rows.length; i++) {
-      if (table.rows[i].className.search(/\bsortbottom\b/) != -1) {
-        sortbottomrows[sortbottomrows.length] = table.rows[i];
-      }
-    }
-    if (sortbottomrows) {
-      if (table.tFoot == null) {
-        // table doesn't have a tfoot. Create one.
-        tfo = document.createElement('tfoot');
-        table.appendChild(tfo);
-      }
-      for (var i=0; i<sortbottomrows.length; i++) {
-        tfo.appendChild(sortbottomrows[i]);
-      }
-      delete sortbottomrows;
-    }
-
-    // work through each column and calculate its type
-    headrow = table.tHead.rows[0].cells;
-    for (var i=0; i<headrow.length; i++) {
-      // manually override the type with a sorttable_type attribute
-      if (!headrow[i].className.match(/\bsorttable_nosort\b/)) { // skip this col
-        mtch = headrow[i].className.match(/\bsorttable_([a-z0-9]+)\b/);
-        if (mtch) { override = mtch[1]; }
-        if (mtch && typeof sorttable["sort_"+override] == 'function') {
-          headrow[i].sorttable_sortfunction = sorttable["sort_"+override];
-        } else {
-          headrow[i].sorttable_sortfunction = sorttable.guessType(table,i);
-        }
-        // make it clickable to sort
-        headrow[i].sorttable_columnindex = i;
-        headrow[i].sorttable_tbody = table.tBodies[0];
-        dean_addEvent(headrow[i],"click", function(e) {
-
-          if (this.className.search(/\bsorttable_sorted\b/) != -1) {
-            // if we're already sorted by this column, just
-            // reverse the table, which is quicker
-            sorttable.reverse(this.sorttable_tbody);
-            this.className = this.className.replace('sorttable_sorted',
-                                                    'sorttable_sorted_reverse');
-            this.removeChild(document.getElementById('sorttable_sortfwdind'));
-            sortrevind = document.createElement('span');
-            sortrevind.id = "sorttable_sortrevind";
-            sortrevind.innerHTML = stIsIE ? '&nbsp<font face="webdings">5</font>' : '&nbsp;&#x25B4;';
-            this.appendChild(sortrevind);
-            return;
-          }
-          if (this.className.search(/\bsorttable_sorted_reverse\b/) != -1) {
-            // if we're already sorted by this column in reverse, just
-            // re-reverse the table, which is quicker
-            sorttable.reverse(this.sorttable_tbody);
-            this.className = this.className.replace('sorttable_sorted_reverse',
-                                                    'sorttable_sorted');
-            this.removeChild(document.getElementById('sorttable_sortrevind'));
-            sortfwdind = document.createElement('span');
-            sortfwdind.id = "sorttable_sortfwdind";
-            sortfwdind.innerHTML = stIsIE ? '&nbsp<font face="webdings">6</font>' : '&nbsp;&#x25BE;';
-            this.appendChild(sortfwdind);
-            return;
-          }
-
-          // remove sorttable_sorted classes
-          theadrow = this.parentNode;
-          forEach(theadrow.childNodes, function(cell) {
-            if (cell.nodeType == 1) { // an element
-              cell.className = cell.className.replace('sorttable_sorted_reverse','');
-              cell.className = cell.className.replace('sorttable_sorted','');
-            }
-          });
-          sortfwdind = document.getElementById('sorttable_sortfwdind');
-          if (sortfwdind) { sortfwdind.parentNode.removeChild(sortfwdind); }
-          sortrevind = document.getElementById('sorttable_sortrevind');
-          if (sortrevind) { sortrevind.parentNode.removeChild(sortrevind); }
-
-          this.className += ' sorttable_sorted';
-          sortfwdind = document.createElement('span');
-          sortfwdind.id = "sorttable_sortfwdind";
-          sortfwdind.innerHTML = stIsIE ? '&nbsp<font face="webdings">6</font>' : '&nbsp;&#x25BE;';
-          this.appendChild(sortfwdind);
-
-          // build an array to sort. This is a Schwartzian transform thing,
-          // i.e., we "decorate" each row with the actual sort key,
-          // sort based on the sort keys, and then put the rows back in order
-          // which is a lot faster because you only do getInnerText once per row
-          row_array = [];
-          col = this.sorttable_columnindex;
-          rows = this.sorttable_tbody.rows;
-          for (var j=0; j<rows.length; j++) {
-            row_array[row_array.length] = [sorttable.getInnerText(rows[j].cells[col]), rows[j]];
-          }
-          /* If you want a stable sort, uncomment the following line */
-          sorttable.shaker_sort(row_array, this.sorttable_sortfunction);
-          /* and comment out this one */
-          //row_array.sort(this.sorttable_sortfunction);
-
-          tb = this.sorttable_tbody;
-          for (var j=0; j<row_array.length; j++) {
-            tb.appendChild(row_array[j][1]);
-          }
-
-          delete row_array;
-        });
-      }
-    }
-  },
-
-  guessType: function(table, column) {
-    // guess the type of a column based on its first non-blank row
-    sortfn = sorttable.sort_alpha;
-    for (var i=0; i<table.tBodies[0].rows.length; i++) {
-      text = sorttable.getInnerText(table.tBodies[0].rows[i].cells[column]);
-      if (text != '') {
-        if (text.match(/^-?[｣$､]?[\d,.]+%?$/)) {
-          return sorttable.sort_numeric;
-        }
-        // check for a date: dd/mm/yyyy or dd/mm/yy
-        // can have / or . or - as separator
-        // can be mm/dd as well
-        possdate = text.match(sorttable.DATE_RE)
-        if (possdate) {
-          // looks like a date
-          first = parseInt(possdate[1]);
-          second = parseInt(possdate[2]);
-          if (first > 12) {
-            // definitely dd/mm
-            return sorttable.sort_ddmm;
-          } else if (second > 12) {
-            return sorttable.sort_mmdd;
-          } else {
-            // looks like a date, but we can't tell which, so assume
-            // that it's dd/mm (English imperialism!) and keep looking
-            sortfn = sorttable.sort_ddmm;
-          }
-        }
-      }
-    }
-    return sortfn;
-  },
-
-  getInnerText: function(node) {
-    // gets the text we want to use for sorting for a cell.
-    // strips leading and trailing whitespace.
-    // this is *not* a generic getInnerText function; it's special to sorttable.
-    // for example, you can override the cell text with a customkey attribute.
-    // it also gets .value for <input> fields.
-
-    hasInputs = (typeof node.getElementsByTagName == 'function') &&
-                 node.getElementsByTagName('input').length;
-
-    if (node.getAttribute("sorttable_customkey") != null) {
-      return node.getAttribute("sorttable_customkey");
-    }
-    else if (typeof node.textContent != 'undefined' && !hasInputs) {
-      return node.textContent.replace(/^\s+|\s+$/g, '');
-    }
-    else if (typeof node.innerText != 'undefined' && !hasInputs) {
-      return node.innerText.replace(/^\s+|\s+$/g, '');
-    }
-    else if (typeof node.text != 'undefined' && !hasInputs) {
-      return node.text.replace(/^\s+|\s+$/g, '');
-    }
-    else {
-      switch (node.nodeType) {
-        case 3:
-          if (node.nodeName.toLowerCase() == 'input') {
-            return node.value.replace(/^\s+|\s+$/g, '');
-          }
-        case 4:
-          return node.nodeValue.replace(/^\s+|\s+$/g, '');
-          break;
-        case 1:
-        case 11:
-          var innerText = '';
-          for (var i = 0; i < node.childNodes.length; i++) {
-            innerText += sorttable.getInnerText(node.childNodes[i]);
-          }
-          return innerText.replace(/^\s+|\s+$/g, '');
-          break;
-        default:
-          return '';
-      }
-    }
-  },
-
-  reverse: function(tbody) {
-    // reverse the rows in a tbody
-    newrows = [];
-    for (var i=0; i<tbody.rows.length; i++) {
-      newrows[newrows.length] = tbody.rows[i];
-    }
-    for (var i=newrows.length-1; i>=0; i--) {
-       tbody.appendChild(newrows[i]);
-    }
-    delete newrows;
-  },
-
-  /* sort functions
-     each sort function takes two parameters, a and b
-     you are comparing a[0] and b[0] */
-  sort_numeric: function(a,b) {
-    aa = parseFloat(a[0].replace(/[^0-9.-]/g,''));
-    if (isNaN(aa)) aa = 0;
-    bb = parseFloat(b[0].replace(/[^0-9.-]/g,''));
-    if (isNaN(bb)) bb = 0;
-    return aa-bb;
-  },
-  sort_alpha: function(a,b) {
-    if (a[0]==b[0]) return 0;
-    if (a[0]<b[0]) return -1;
-    return 1;
-  },
-  sort_ddmm: function(a,b) {
-    mtch = a[0].match(sorttable.DATE_RE);
-    y = mtch[3]; m = mtch[2]; d = mtch[1];
-    if (m.length == 1) m = '0'+m;
-    if (d.length == 1) d = '0'+d;
-    dt1 = y+m+d;
-    mtch = b[0].match(sorttable.DATE_RE);
-    y = mtch[3]; m = mtch[2]; d = mtch[1];
-    if (m.length == 1) m = '0'+m;
-    if (d.length == 1) d = '0'+d;
-    dt2 = y+m+d;
-    if (dt1==dt2) return 0;
-    if (dt1<dt2) return -1;
-    return 1;
-  },
-  sort_mmdd: function(a,b) {
-    mtch = a[0].match(sorttable.DATE_RE);
-    y = mtch[3]; d = mtch[2]; m = mtch[1];
-    if (m.length == 1) m = '0'+m;
-    if (d.length == 1) d = '0'+d;
-    dt1 = y+m+d;
-    mtch = b[0].match(sorttable.DATE_RE);
-    y = mtch[3]; d = mtch[2]; m = mtch[1];
-    if (m.length == 1) m = '0'+m;
-    if (d.length == 1) d = '0'+d;
-    dt2 = y+m+d;
-    if (dt1==dt2) return 0;
-    if (dt1<dt2) return -1;
-    return 1;
-  },
-
-  shaker_sort: function(list, comp_func) {
-    // A stable sort function to allow multi-level sorting of data
-    // see: http://en.wikipedia.org/wiki/Cocktail_sort
-    // thanks to Joseph Nahmias
-    var b = 0;
-    var t = list.length - 1;
-    var swap = true;
-
-    while(swap) {
-        swap = false;
-        for(var i = b; i < t; ++i) {
-            if ( comp_func(list[i], list[i+1]) > 0 ) {
-                var q = list[i]; list[i] = list[i+1]; list[i+1] = q;
-                swap = true;
-            }
-        } // for
-        t--;
-
-        if (!swap) break;
-
-        for(var i = t; i > b; --i) {
-            if ( comp_func(list[i], list[i-1]) < 0 ) {
-                var q = list[i]; list[i] = list[i-1]; list[i-1] = q;
-                swap = true;
-            }
-        } // for
-        b++;
-
-    } // while(swap)
-  }
-}
-
-/* ******************************************************************
-   Supporting functions: bundled here to avoid depending on a library
-   ****************************************************************** */
-
-// Dean Edwards/Matthias Miller/John Resig
-
-/* for Mozilla/Opera9 */
-if (document.addEventListener) {
-    document.addEventListener("DOMContentLoaded", sorttable.init, false);
-}
-
-/* for Internet Explorer */
-/*@cc_on @*/
-/*@if (@_win32)
-    document.write("<script id=__ie_onload defer src=javascript:void(0)><\/script>");
-    var script = document.getElementById("__ie_onload");
-    script.onreadystatechange = function() {
-        if (this.readyState == "complete") {
-            sorttable.init(); // call the onload handler
-        }
-    };
-/*@end @*/
-
-/* for Safari */
-if (/WebKit/i.test(navigator.userAgent)) { // sniff
-    var _timer = setInterval(function() {
-        if (/loaded|complete/.test(document.readyState)) {
-            sorttable.init(); // call the onload handler
-        }
-    }, 10);
-}
-
-/* for other browsers */
-window.onload = sorttable.init;
-
-// written by Dean Edwards, 2005
-// with input from Tino Zijdel, Matthias Miller, Diego Perini
-
-// http://dean.edwards.name/weblog/2005/10/add-event/
-
-function dean_addEvent(element, type, handler) {
-  if (element.addEventListener) {
-    element.addEventListener(type, handler, false);
-  } else {
-    // assign each event handler a unique ID
-    if (!handler.$$guid) handler.$$guid = dean_addEvent.guid++;
-    // create a hash table of event types for the element
-    if (!element.events) element.events = {};
-    // create a hash table of event handlers for each element/event pair
-    var handlers = element.events[type];
-    if (!handlers) {
-      handlers = element.events[type] = {};
-      // store the existing event handler (if there is one)
-      if (element["on" + type]) {
-        handlers[0] = element["on" + type];
-      }
-    }
-    // store the event handler in the hash table
-    handlers[handler.$$guid] = handler;
-    // assign a global event handler to do all the work
-    element["on" + type] = handleEvent;
-  }
-};
-// a counter used to create unique IDs
-dean_addEvent.guid = 1;
-
-function removeEvent(element, type, handler) {
-  if (element.removeEventListener) {
-    element.removeEventListener(type, handler, false);
-  } else {
-    // delete the event handler from the hash table
-    if (element.events && element.events[type]) {
-      delete element.events[type][handler.$$guid];
-    }
-  }
-};
-
-function handleEvent(event) {
-  var returnValue = true;
-  // grab the event object (IE uses a global event object)
-  event = event || fixEvent(((this.ownerDocument || this.document || this).parentWindow || window).event);
-  // get a reference to the hash table of event handlers
-  var handlers = this.events[event.type];
-  // execute each event handler
-  for (var i in handlers) {
-    this.$$handleEvent = handlers[i];
-    if (this.$$handleEvent(event) === false) {
-      returnValue = false;
-    }
-  }
-  return returnValue;
-};
-
-function fixEvent(event) {
-  // add W3C standard event methods
-  event.preventDefault = fixEvent.preventDefault;
-  event.stopPropagation = fixEvent.stopPropagation;
-  return event;
-};
-fixEvent.preventDefault = function() {
-  this.returnValue = false;
-};
-fixEvent.stopPropagation = function() {
-  this.cancelBubble = true;
-}
-
-// Dean's forEach: http://dean.edwards.name/base/forEach.js
-/*
-  forEach, version 1.0
-  Copyright 2006, Dean Edwards
-  License: http://www.opensource.org/licenses/mit-license.php
-*/
-
-// array-like enumeration
-if (!Array.forEach) { // mozilla already supports this
-  Array.forEach = function(array, block, context) {
-    for (var i = 0; i < array.length; i++) {
-      block.call(context, array[i], i, array);
-    }
-  };
-}
-
-// generic enumeration
-Function.prototype.forEach = function(object, block, context) {
-  for (var key in object) {
-    if (typeof this.prototype[key] == "undefined") {
-      block.call(context, object[key], key, object);
-    }
-  }
-};
-
-// character enumeration
-String.forEach = function(string, block, context) {
-  Array.forEach(string.split(""), function(chr, index) {
-    block.call(context, chr, index, string);
-  });
-};
-
-// globally resolve forEach enumeration
-var forEach = function(object, block, context) {
-  if (object) {
-    var resolve = Object; // default
-    if (object instanceof Function) {
-      // functions have a "length" property
-      resolve = Function;
-    } else if (object.forEach instanceof Function) {
-      // the object implements a custom forEach method so use that
-      object.forEach(block, context);
-      return;
-    } else if (typeof object == "string") {
-      // the object is a string
-      resolve = String;
-    } else if (typeof object.length == "number") {
-      // the object is array-like
-      resolve = Array;
-    }
-    resolve.forEach(object, block, context);
-  }
-};

clang/tools/scan-build-py/tests/__init__.py

 # -*- coding: utf-8 -*-
 # Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 # See https://llvm.org/LICENSE.txt for license information.
 # SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 
+import os
+import sys
+
+this_dir = os.path.dirname(os.path.realpath(__file__))
+sys.path.append(os.path.join(os.path.dirname(this_dir), 'lib'))
+
 import unittest
 
 import tests.unit
 import tests.functional.cases
 
 
 def suite():
     loader = unittest.TestLoader()
     suite = unittest.TestSuite()
     suite.addTests(loader.loadTestsFromModule(tests.unit))
     suite.addTests(loader.loadTestsFromModule(tests.functional.cases))
     return suite

clang/tools/scan-build-py/tests/functional/cases/__init__.py

def load_tests(loader, suite, pattern):
     suite.addTests(loader.loadTestsFromModule(test_create_cdb))
     from . import test_exec_anatomy
     suite.addTests(loader.loadTestsFromModule(test_exec_anatomy))
     return suite
 
 
 def make_args(target):
     this_dir, _ = os.path.split(__file__)
-    path = os.path.normpath(os.path.join(this_dir, '..', 'src'))
+    path = os.path.abspath(os.path.join(this_dir, '..', 'src'))
     return ['make', 'SRCDIR={}'.format(path), 'OBJDIR={}'.format(target), '-f',
             os.path.join(path, 'build', 'Makefile')]
 
 
 def silent_call(cmd, *args, **kwargs):
     kwargs.update({'stdout': subprocess.PIPE, 'stderr': subprocess.STDOUT})
     return subprocess.call(cmd, *args, **kwargs)
 
 
 def silent_check_call(cmd, *args, **kwargs):
     kwargs.update({'stdout': subprocess.PIPE, 'stderr': subprocess.STDOUT})
-    return subprocess.check_call(cmd, *args, **kwargs)
+    # return subprocess.check_call(cmd, *args, **kwargs)
+    child = subprocess.Popen(cmd, *args, **kwargs)
+    for line in child.stdout.readlines():
+      print(line)
+    child.stdout.close()
+    child.wait()
+    import time
+    time.sleep(120)
+    if child.returncode == 0:
+      return
+    else:
+      raise subprocess.CalledProcessError(returncode=child.returncode, cmd=cmd)
 
 
 def call_and_report(analyzer_cmd, build_cmd):
     child = subprocess.Popen(analyzer_cmd + ['-v'] + build_cmd,
                              universal_newlines=True,
                              stdout=subprocess.PIPE,
                              stderr=subprocess.STDOUT)
 
     pattern = re.compile('Report directory created: (.+)')
     directory = None
     for line in child.stdout.readlines():
+        print(line)
         match = pattern.search(line)
         if match and match.lastindex == 1:
             directory = match.group(1)
             break
     child.stdout.close()
     child.wait()
 
     return (child.returncode, directory)

clang/tools/scan-build-py/tests/functional/cases/test_exec_anatomy.py

def assertEqualJson(self, expected, result):
         rhs = read_json(result)
         for item in lhs:
             self.assertTrue(rhs.count(item))
         for item in rhs:
             self.assertTrue(lhs.count(item))
 
     def test_all_exec_calls(self):
         this_dir, _ = os.path.split(__file__)
-        source_dir = os.path.normpath(os.path.join(this_dir, '..', 'exec'))
+        source_dir = os.path.abspath(os.path.join(this_dir, '..', 'exec'))
         with libear.TemporaryDirectory() as tmp_dir:
             expected, result = run(source_dir, tmp_dir)
             self.assertEqualJson(expected, result)

clang/tools/scan-build-py/tests/functional/cases/test_from_cdb.py

 import os.path
 import string
 import glob
 
 
 def prepare_cdb(name, target_dir):
     target_file = 'build_{0}.json'.format(name)
     this_dir, _ = os.path.split(__file__)
-    path = os.path.normpath(os.path.join(this_dir, '..', 'src'))
+    path = os.path.abspath(os.path.join(this_dir, '..', 'src'))
     source_dir = os.path.join(path, 'compilation_database')
     source_file = os.path.join(source_dir, target_file + '.in')
     target_file = os.path.join(target_dir, 'compile_commands.json')
     with open(source_file, 'r') as in_handle:
         with open(target_file, 'w') as out_handle:
             for line in in_handle:
                 temp = string.Template(line)
                 out_handle.write(temp.substitute(path=path))
     return target_file
 
 
 def run_analyzer(directory, cdb, args):
     cmd = ['analyze-build', '--cdb', cdb, '--output', directory] \
         + args
     return call_and_report(cmd, [])
 
 
 class OutputDirectoryTest(unittest.TestCase):
     def test_regular_keeps_report_dir(self):
         with libear.TemporaryDirectory() as tmpdir:
             cdb = prepare_cdb('regular', tmpdir)
             exit_code, reportdir = run_analyzer(tmpdir, cdb, [])
             self.assertTrue(os.path.isdir(reportdir))
 
-    def test_clear_deletes_report_dir(self):
+    def test_clean_deletes_report_dir(self):
         with libear.TemporaryDirectory() as tmpdir:
             cdb = prepare_cdb('clean', tmpdir)
             exit_code, reportdir = run_analyzer(tmpdir, cdb, [])
             self.assertFalse(os.path.isdir(reportdir))
 
-    def test_clear_keeps_report_dir_when_asked(self):
+    def test_clean_keeps_report_dir_when_asked(self):
         with libear.TemporaryDirectory() as tmpdir:
             cdb = prepare_cdb('clean', tmpdir)
             exit_code, reportdir = run_analyzer(tmpdir, cdb, ['--keep-empty'])
             self.assertTrue(os.path.isdir(reportdir))
 
 
 class ExitCodeTest(unittest.TestCase):
     def test_regular_does_not_set_exit_code(self):
         with libear.TemporaryDirectory() as tmpdir:
             cdb = prepare_cdb('regular', tmpdir)
             exit_code, __ = run_analyzer(tmpdir, cdb, [])
             self.assertFalse(exit_code)
 
-    def test_clear_does_not_set_exit_code(self):
+    def test_clean_does_not_set_exit_code(self):
         with libear.TemporaryDirectory() as tmpdir:
             cdb = prepare_cdb('clean', tmpdir)
             exit_code, __ = run_analyzer(tmpdir, cdb, [])
             self.assertFalse(exit_code)
 
     def test_regular_sets_exit_code_if_asked(self):
         with libear.TemporaryDirectory() as tmpdir:
             cdb = prepare_cdb('regular', tmpdir)
             exit_code, __ = run_analyzer(tmpdir, cdb, ['--status-bugs'])
             self.assertTrue(exit_code)
 
-    def test_clear_does_not_set_exit_code_if_asked(self):
+    def test_clean_does_not_set_exit_code_if_asked(self):
         with libear.TemporaryDirectory() as tmpdir:
             cdb = prepare_cdb('clean', tmpdir)
             exit_code, __ = run_analyzer(tmpdir, cdb, ['--status-bugs'])
             self.assertFalse(exit_code)
 
     def test_regular_sets_exit_code_if_asked_from_plist(self):
         with libear.TemporaryDirectory() as tmpdir:
             cdb = prepare_cdb('regular', tmpdir)
             exit_code, __ = run_analyzer(
                 tmpdir, cdb, ['--status-bugs', '--plist'])
             self.assertTrue(exit_code)
 
-    def test_clear_does_not_set_exit_code_if_asked_from_plist(self):
+    def test_clean_does_not_set_exit_code_if_asked_from_plist(self):
         with libear.TemporaryDirectory() as tmpdir:
             cdb = prepare_cdb('clean', tmpdir)
-            exit_code, __ = run_analyzer(
+            exit_code, out_dir = run_analyzer(
                 tmpdir, cdb, ['--status-bugs', '--plist'])
+            print(out_dir)
             self.assertFalse(exit_code)
 
 
 class OutputFormatTest(unittest.TestCase):
     @staticmethod
     def get_html_count(directory):
         return len(glob.glob(os.path.join(directory, 'report-*.html')))
 

clang/tools/scan-build-py/tests/functional/cases/test_from_cmd.py

 import glob
 
 
 class OutputDirectoryTest(unittest.TestCase):
 
     @staticmethod
     def run_analyzer(outdir, args, cmd):
         return check_call_and_report(
-            ['scan-build', '--intercept-first', '-o', outdir] + args,
+            ['scan-build-py', '--intercept-first', '-o', outdir] + args,
             cmd)
 
     def test_regular_keeps_report_dir(self):
         with libear.TemporaryDirectory() as tmpdir:
             make = make_args(tmpdir) + ['build_regular']
             outdir = self.run_analyzer(tmpdir, [], make)
             self.assertTrue(os.path.isdir(outdir))
 
class RunAnalyzerTest(unittest.TestCase):
     @staticmethod
     def get_plist_count(directory):
         return len(glob.glob(os.path.join(directory, 'report-*.plist')))
 
     def test_interposition_works(self):
         with libear.TemporaryDirectory() as tmpdir:
             make = make_args(tmpdir) + ['build_regular']
             outdir = check_call_and_report(
-                ['scan-build', '--plist', '-o', tmpdir, '--override-compiler'],
+                ['scan-build-py', '--plist', '-o', tmpdir, '--override-compiler'],
                 make)
 
             self.assertTrue(os.path.isdir(outdir))
             self.assertEqual(self.get_plist_count(outdir), 5)
 
     def test_intercept_wrapper_works(self):
         with libear.TemporaryDirectory() as tmpdir:
             make = make_args(tmpdir) + ['build_regular']
             outdir = check_call_and_report(
-                ['scan-build', '--plist', '-o', tmpdir, '--intercept-first',
+                ['scan-build-py', '--plist', '-o', tmpdir, '--intercept-first',
                  '--override-compiler'],
                 make)
 
             self.assertTrue(os.path.isdir(outdir))
             self.assertEqual(self.get_plist_count(outdir), 5)
 
     def test_intercept_library_works(self):
         with libear.TemporaryDirectory() as tmpdir:
             make = make_args(tmpdir) + ['build_regular']
             outdir = check_call_and_report(
-                ['scan-build', '--plist', '-o', tmpdir, '--intercept-first'],
+                ['scan-build-py', '--plist', '-o', tmpdir, '--intercept-first'],
                 make)
 
             self.assertTrue(os.path.isdir(outdir))
             self.assertEqual(self.get_plist_count(outdir), 5)
 
     @staticmethod
     def compile_empty_source_file(target_dir, is_cxx):
         compiler = '$CXX' if is_cxx else '$CC'
         src_file_name = 'test.cxx' if is_cxx else 'test.c'
         src_file = os.path.join(target_dir, src_file_name)
         obj_file = os.path.join(target_dir, 'test.o')
         create_empty_file(src_file)
         command = ' '.join([compiler, '-c', src_file, '-o', obj_file])
         return ['sh', '-c', command]
 
     def test_interposition_cc_works(self):
         with libear.TemporaryDirectory() as tmpdir:
             outdir = check_call_and_report(
-                ['scan-build', '--plist', '-o', tmpdir, '--override-compiler'],
+                ['scan-build-py', '--plist', '-o', tmpdir, '--override-compiler'],
                 self.compile_empty_source_file(tmpdir, False))
             self.assertEqual(self.get_plist_count(outdir), 1)
 
     def test_interposition_cxx_works(self):
         with libear.TemporaryDirectory() as tmpdir:
             outdir = check_call_and_report(
-                ['scan-build', '--plist', '-o', tmpdir, '--override-compiler'],
+                ['scan-build-py', '--plist', '-o', tmpdir, '--override-compiler'],
                 self.compile_empty_source_file(tmpdir, True))
             self.assertEqual(self.get_plist_count(outdir), 1)
 
     def test_intercept_cc_works(self):
         with libear.TemporaryDirectory() as tmpdir:
             outdir = check_call_and_report(
-                ['scan-build', '--plist', '-o', tmpdir, '--override-compiler',
+                ['scan-build-py', '--plist', '-o', tmpdir, '--override-compiler',
                  '--intercept-first'],
                 self.compile_empty_source_file(tmpdir, False))
             self.assertEqual(self.get_plist_count(outdir), 1)
 
     def test_intercept_cxx_works(self):
         with libear.TemporaryDirectory() as tmpdir:
             outdir = check_call_and_report(
-                ['scan-build', '--plist', '-o', tmpdir, '--override-compiler',
+                ['scan-build-py', '--plist', '-o', tmpdir, '--override-compiler',
                  '--intercept-first'],
                 self.compile_empty_source_file(tmpdir, True))
             self.assertEqual(self.get_plist_count(outdir), 1)

clang/tools/scan-build-py/tests/unit/test_analyze.py

 
 class ReportDirectoryTest(unittest.TestCase):
 
     # Test that successive report directory names ascend in lexicographic
     # order. This is required so that report directories from two runs of
     # scan-build can be easily matched up to compare results.
     def test_directory_name_comparison(self):
         with libear.TemporaryDirectory() as tmpdir, \
-             sut.report_directory(tmpdir, False) as report_dir1, \
-             sut.report_directory(tmpdir, False) as report_dir2, \
-             sut.report_directory(tmpdir, False) as report_dir3:
+             sut.report_directory(tmpdir, False, 'html') as report_dir1, \
+             sut.report_directory(tmpdir, False, 'html') as report_dir2, \
+             sut.report_directory(tmpdir, False, 'html') as report_dir3:
             self.assertLess(report_dir1, report_dir2)
             self.assertLess(report_dir2, report_dir3)
 
 
 class FilteringFlagsTest(unittest.TestCase):
 
     def test_language_captured(self):
         def test(flags):