Create install targets for scan-build-py.

[isthismyaccount]

Summary

A new revision identical to https://reviews.llvm.org/D101139
The parent revision of aforementioned revision seems to cause pre-merge checks to fail opaquely. Seeing if creating a new revision will work.

[isthismyaccount]

Use arc to upload diff.

[phosek]

LGTM

[isthismyaccount]

Rebase on main.

[isthismyaccount]

Readd deleted sorttable.js to avoid clang-tidy incorrectly checking it and causing encoding issues.

[isthismyaccount]

Remove logging.

[isthismyaccount]

Ignore clang-tidy warning in ear.c

[isthismyaccount]

git-clang-format

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):