From bcf2365f6d4744f3b0be6854e098f280f41b5c1b Mon Sep 17 00:00:00 2001 From: Jakub Jirutka Date: Sat, 22 Apr 2017 01:53:04 +0200 Subject: testing/lldb: move from unmaintained --- unmaintained/lldb/APKBUILD | 71 - unmaintained/lldb/D15067.id41365.patch | 3810 -------------------- unmaintained/lldb/lldb-3.8-alpine.patch | 27 - .../lldb/musl-include-ptrace.aarch64.patch | 17 - 4 files changed, 3925 deletions(-) delete mode 100644 unmaintained/lldb/APKBUILD delete mode 100644 unmaintained/lldb/D15067.id41365.patch delete mode 100644 unmaintained/lldb/lldb-3.8-alpine.patch delete mode 100644 unmaintained/lldb/musl-include-ptrace.aarch64.patch (limited to 'unmaintained') diff --git a/unmaintained/lldb/APKBUILD b/unmaintained/lldb/APKBUILD deleted file mode 100644 index 789ba80d0f..0000000000 --- a/unmaintained/lldb/APKBUILD +++ /dev/null @@ -1,71 +0,0 @@ -# Contributor: BartÅ‚omiej Piotrowski -# Maintainer: - -pkgname=lldb -pkgver=3.8.1 -pkgrel=0 -pkgdesc="Next generation, high-performance debugger" -arch="all" -url="http://llvm.org/" -license="UOI-NCSA" -makedepends="clang clang-libs clang-dev cmake doxygen libedit-dev libffi-dev - libxml2-dev linux-headers llvm llvm-libs llvm-dev llvm-static ncurses-dev - ninja python2-dev swig" -subpackages="$pkgname-dev py-$pkgname:py $pkgname-libs" -source="http://llvm.org/releases/$pkgver/lldb-$pkgver.src.tar.xz - lldb-3.8-alpine.patch - D15067.id41365.patch - musl-include-ptrace.aarch64.patch" -builddir="$srcdir/build" - -_srcdir="$srcdir/lldb-$pkgver.src" - -prepare() { - local builddir="$_srcdir" - default_prepare -} - -build() { - mkdir -p "$builddir" - cd "$builddir" - - cmake -G Ninja -Wno-dev \ - -DCMAKE_BUILD_TYPE=Release \ - -DCMAKE_INSTALL_PREFIX=/usr \ - -DLLVM_LINK_LLVM_DYLIB:BOOL=ON \ - "$_srcdir" || return 1 - - ninja || return 1 -} - -package() { - cd "$builddir" - DESTDIR="$pkgdir" ninja install || return 1 -} - -py() { - depends="py-six" - - mkdir -p "$subpkgdir/usr/lib" - mv "$pkgdir/usr/lib/python2.7" "$subpkgdir/usr/lib" || return 1 - - rm "$subpkgdir/usr/lib/python2.7/site-packages/six.py" - - python2 -m compileall \ - "$subpkgdir/usr/lib/python2.7/site-packages/lldb" || return 1 - python2 -O -m compileall \ - "$subpkgdir/usr/lib/python2.7/site-packages/lldb" || return 1 -} - -md5sums="9e4787b71be8e432fffd31e13ac87623 lldb-3.8.1.src.tar.xz -985443fb4b6ad8742743ff8ea4856ac1 lldb-3.8-alpine.patch -78785ba3c6a19b3f805abd261109a595 D15067.id41365.patch -f13ad6da35dba8fe7bc299b2465f1456 musl-include-ptrace.aarch64.patch" -sha256sums="349148116a47e39dcb5d5042f10d8a6357d2c865034563283ca512f81cdce8a3 lldb-3.8.1.src.tar.xz -bc9c8ba97e5ee9f9e29946b1cc611a75a3a8ba4fa4e2727e4514b5c8b0c6ca14 lldb-3.8-alpine.patch -c6dd7dee0856f2ea20bd697f8aa3b09cef04fd32ff2daa9e3625ef69f5bab61f D15067.id41365.patch -6038588b2089bfdbf1a0168208a443d8832622188076e79f3d2c2545eb73fc53 musl-include-ptrace.aarch64.patch" -sha512sums="d73c55daed6ef5e5ca784c7010f2d75be26024b14fa61a2861a8a6cbe129e417fb7be2a3b532e17e9d7de98ae38ce6a689d8166049eff365fb04f4bd772758f3 lldb-3.8.1.src.tar.xz -b935be858c45958018ed79557f8061dee18d0949beaff4c717233497f86432c7811960c5a656772a9858e314122049121985cd8333758c508a806653b9200c1b lldb-3.8-alpine.patch -3c10e8b059d5db12776f066b679c328e54bc40d139830c4a49ec35acfa6b9775b1544fd1cb83cc1c0f449b28657c57c2d3d92d08f4c373d4ea413aed5bb3a4f9 D15067.id41365.patch -1613a1cb042edd430aba6b86e4971ebb01f7d2bc3f13a5a1264cb94da7612188897e9dcaaa9233be8af5c8f4bad013dd0cfb821e323cd73dfe07fe125869ccef musl-include-ptrace.aarch64.patch" diff --git a/unmaintained/lldb/D15067.id41365.patch b/unmaintained/lldb/D15067.id41365.patch deleted file mode 100644 index 5217ffc717..0000000000 --- a/unmaintained/lldb/D15067.id41365.patch +++ /dev/null @@ -1,3810 +0,0 @@ -diff -up lldb-3.8.0rc2.src/cmake/modules/LLDBStandalone.cmake.dave lldb-3.8.0rc2.src/cmake/modules/LLDBStandalone.cmake ---- lldb-3.8.0rc2.src/cmake/modules/LLDBStandalone.cmake.dave 2015-11-10 13:09:14.000000000 -0500 -+++ lldb-3.8.0rc2.src/cmake/modules/LLDBStandalone.cmake 2016-02-17 23:19:05.371675721 -0500 -@@ -6,57 +6,77 @@ if (CMAKE_SOURCE_DIR STREQUAL CMAKE_CURR - - option(LLVM_INSTALL_TOOLCHAIN_ONLY "Only include toolchain files in the 'install' target." OFF) - -- set(LLDB_PATH_TO_LLVM_SOURCE "" CACHE PATH -- "Path to LLVM source code. Not necessary if using an installed LLVM.") -- set(LLDB_PATH_TO_LLVM_BUILD "" CACHE PATH -- "Path to the directory where LLVM was built or installed.") -- -- set(LLDB_PATH_TO_CLANG_SOURCE "" CACHE PATH -- "Path to Clang source code. Not necessary if using an installed Clang.") -- set(LLDB_PATH_TO_CLANG_BUILD "" CACHE PATH -- "Path to the directory where Clang was built or installed.") -- -- if (LLDB_PATH_TO_LLVM_SOURCE) -- if (NOT EXISTS "${LLDB_PATH_TO_LLVM_SOURCE}/cmake/config-ix.cmake") -- message(FATAL_ERROR "Please set LLDB_PATH_TO_LLVM_SOURCE to the root " -- "directory of LLVM source code.") -+ # Rely on llvm-config. -+ set(CONFIG_OUTPUT) -+ find_program(LLVM_CONFIG "llvm-config") -+ if(LLVM_CONFIG) -+ message(STATUS "Found LLVM_CONFIG as ${LLVM_CONFIG}") -+ set(CONFIG_COMMAND ${LLVM_CONFIG} -+ "--assertion-mode" -+ "--bindir" -+ "--libdir" -+ "--includedir" -+ "--prefix" -+ "--src-root") -+ execute_process( -+ COMMAND ${CONFIG_COMMAND} -+ RESULT_VARIABLE HAD_ERROR -+ OUTPUT_VARIABLE CONFIG_OUTPUT -+ ) -+ if(NOT HAD_ERROR) -+ string(REGEX REPLACE -+ "[ \t]*[\r\n]+[ \t]*" ";" -+ CONFIG_OUTPUT ${CONFIG_OUTPUT}) - else() -- get_filename_component(LLVM_MAIN_SRC_DIR ${LLDB_PATH_TO_LLVM_SOURCE} -- ABSOLUTE) -- set(LLVM_MAIN_INCLUDE_DIR "${LLVM_MAIN_SRC_DIR}/include") -- list(APPEND CMAKE_MODULE_PATH "${LLVM_MAIN_SRC_DIR}/cmake/modules") -+ string(REPLACE ";" " " CONFIG_COMMAND_STR "${CONFIG_COMMAND}") -+ message(STATUS "${CONFIG_COMMAND_STR}") -+ message(FATAL_ERROR "llvm-config failed with status ${HAD_ERROR}") - endif() -- endif() -- -- if (LLDB_PATH_TO_CLANG_SOURCE) -- get_filename_component(CLANG_MAIN_SRC_DIR ${LLDB_PATH_TO_CLANG_SOURCE} -- ABSOLUTE) -- set(CLANG_MAIN_INCLUDE_DIR "${CLANG_MAIN_SRC_DIR}/include") -- endif() -- -- list(APPEND CMAKE_MODULE_PATH "${LLDB_PATH_TO_LLVM_BUILD}/share/llvm/cmake") -- -- if (LLDB_PATH_TO_LLVM_BUILD) -- get_filename_component(PATH_TO_LLVM_BUILD ${LLDB_PATH_TO_LLVM_BUILD} -- ABSOLUTE) - else() -- message(FATAL_ERROR "Please set LLDB_PATH_TO_LLVM_BUILD to the root " -- "directory of LLVM build or install site.") -+ message(FATAL_ERROR "llvm-config not found -- ${LLVM_CONFIG}") - endif() - -- if (LLDB_PATH_TO_CLANG_BUILD) -- get_filename_component(PATH_TO_CLANG_BUILD ${LLDB_PATH_TO_CLANG_BUILD} -- ABSOLUTE) -+ list(GET CONFIG_OUTPUT 0 ENABLE_ASSERTIONS) -+ list(GET CONFIG_OUTPUT 1 TOOLS_BINARY_DIR) -+ list(GET CONFIG_OUTPUT 2 LIBRARY_DIR) -+ list(GET CONFIG_OUTPUT 3 INCLUDE_DIR) -+ list(GET CONFIG_OUTPUT 4 LLVM_OBJ_ROOT) -+ list(GET CONFIG_OUTPUT 5 MAIN_SRC_DIR) -+ -+ if(NOT MSVC_IDE) -+ set(LLVM_ENABLE_ASSERTIONS ${ENABLE_ASSERTIONS} -+ CACHE BOOL "Enable assertions") -+ # Assertions should follow llvm-config's. -+ mark_as_advanced(LLVM_ENABLE_ASSERTIONS) -+ endif() -+ -+ set(LLVM_TOOLS_BINARY_DIR ${TOOLS_BINARY_DIR} CACHE PATH "Path to llvm/bin") -+ set(LLVM_LIBRARY_DIR ${LIBRARY_DIR} CACHE PATH "Path to llvm/lib") -+ set(LLVM_MAIN_INCLUDE_DIR ${INCLUDE_DIR} CACHE PATH "Path to llvm/include") -+ set(LLVM_BINARY_DIR ${LLVM_OBJ_ROOT} CACHE PATH "Path to LLVM build tree") -+ set(LLVM_MAIN_SRC_DIR ${MAIN_SRC_DIR} CACHE PATH "Path to LLVM source tree") -+ -+ find_program(LLVM_TABLEGEN_EXE "llvm-tblgen" ${LLVM_TOOLS_BINARY_DIR} -+ NO_DEFAULT_PATH) -+ -+ set(LLVM_CMAKE_PATH "${LLVM_BINARY_DIR}/share/llvm/cmake") -+ set(LLVMCONFIG_FILE "${LLVM_CMAKE_PATH}/LLVMConfig.cmake") -+ if(EXISTS ${LLVMCONFIG_FILE}) -+ list(APPEND CMAKE_MODULE_PATH "${LLVM_CMAKE_PATH}") -+ include(${LLVMCONFIG_FILE}) - else() -- message(FATAL_ERROR "Please set LLDB_PATH_TO_CLANG_BUILD to the root " -- "directory of Clang build or install site.") -+ message(FATAL_ERROR "Not found: ${LLVMCONFIG_FILE}") - endif() - -- -- # These variables are used by add_llvm_library. -+ # They are used as destination of target generators. - set(LLVM_RUNTIME_OUTPUT_INTDIR ${CMAKE_BINARY_DIR}/${CMAKE_CFG_INTDIR}/bin) - set(LLVM_LIBRARY_OUTPUT_INTDIR ${CMAKE_BINARY_DIR}/${CMAKE_CFG_INTDIR}/lib${LLVM_LIBDIR_SUFFIX}) -- set(LLVM_LIBRARY_DIR ${LLVM_LIBRARY_OUTPUT_INTDIR}) -+ if(WIN32 OR CYGWIN) -+ # DLL platform -- put DLLs into bin. -+ set(LLVM_SHLIB_OUTPUT_INTDIR ${LLVM_RUNTIME_OUTPUT_INTDIR}) -+ else() -+ set(LLVM_SHLIB_OUTPUT_INTDIR ${LLVM_LIBRARY_OUTPUT_INTDIR}) -+ endif() - - include(AddLLVM) - include(HandleLLVMOptions) -@@ -73,9 +93,9 @@ if (CMAKE_SOURCE_DIR STREQUAL CMAKE_CURR - message("-- Found PythonInterp: ${PYTHON_EXECUTABLE}") - endif() - # Import CMake library targets from LLVM and Clang. -- include("${LLDB_PATH_TO_LLVM_BUILD}/share/llvm/cmake/LLVMConfig.cmake") -- if (EXISTS "${LLDB_PATH_TO_CLANG_BUILD}/share/clang/cmake/ClangConfig.cmake") -- include("${LLDB_PATH_TO_CLANG_BUILD}/share/clang/cmake/ClangConfig.cmake") -+ include("${LLVM_OBJ_ROOT}/share/llvm/cmake/LLVMConfig.cmake") -+ if (EXISTS "${LLVM_OBJ_ROOT}/share/clang/cmake/ClangConfig.cmake") -+ include("${LLVM_OBJ_ROOT}/share/clang/cmake/ClangConfig.cmake") - endif() - - set(PACKAGE_VERSION "${LLVM_PACKAGE_VERSION}") -@@ -83,13 +103,8 @@ if (CMAKE_SOURCE_DIR STREQUAL CMAKE_CURR - set(LLVM_BINARY_DIR ${CMAKE_BINARY_DIR}) - - set(CMAKE_INCLUDE_CURRENT_DIR ON) -- include_directories("${PATH_TO_LLVM_BUILD}/include" -- "${LLVM_MAIN_INCLUDE_DIR}" -- "${PATH_TO_CLANG_BUILD}/include" -- "${CLANG_MAIN_INCLUDE_DIR}" -- "${CMAKE_CURRENT_SOURCE_DIR}/source") -- link_directories("${PATH_TO_LLVM_BUILD}/lib${LLVM_LIBDIR_SUFFIX}" -- "${PATH_TO_CLANG_BUILD}/lib${LLVM_LIBDIR_SUFFIX}") -+ include_directories("${LLVM_BINARY_DIR}/include" "${LLVM_MAIN_INCLUDE_DIR}") -+ link_directories("${LLVM_LIBRARY_DIR}") - - set(CMAKE_RUNTIME_OUTPUT_DIRECTORY ${CMAKE_BINARY_DIR}/bin) - set(CMAKE_LIBRARY_OUTPUT_DIRECTORY ${CMAKE_BINARY_DIR}/lib${LLVM_LIBDIR_SUFFIX}) -diff -up lldb-3.8.0rc2.src/include/lldb/Utility/regcclass.h.dave lldb-3.8.0rc2.src/include/lldb/Utility/regcclass.h ---- lldb-3.8.0rc2.src/include/lldb/Utility/regcclass.h.dave 2016-02-17 23:19:05.371675721 -0500 -+++ lldb-3.8.0rc2.src/include/lldb/Utility/regcclass.h 2016-02-17 23:19:05.371675721 -0500 -@@ -0,0 +1,75 @@ -+/*- -+ * This code is derived from OpenBSD's libc/regex, original license follows: -+ * -+ * This code is derived from OpenBSD's libc/regex, original license follows: -+ * -+ * Copyright (c) 1992, 1993, 1994 Henry Spencer. -+ * Copyright (c) 1992, 1993, 1994 -+ * The Regents of the University of California. All rights reserved. -+ * -+ * This code is derived from software contributed to Berkeley by -+ * Henry Spencer. -+ * -+ * Redistribution and use in source and binary forms, with or without -+ * modification, are permitted provided that the following conditions -+ * are met: -+ * 1. Redistributions of source code must retain the above copyright -+ * notice, this list of conditions and the following disclaimer. -+ * 2. Redistributions in binary form must reproduce the above copyright -+ * notice, this list of conditions and the following disclaimer in the -+ * documentation and/or other materials provided with the distribution. -+ * 3. Neither the name of the University nor the names of its contributors -+ * may be used to endorse or promote products derived from this software -+ * without specific prior written permission. -+ * -+ * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND -+ * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE -+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE -+ * ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE -+ * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL -+ * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS -+ * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) -+ * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT -+ * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY -+ * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF -+ * SUCH DAMAGE. -+ * -+ * @(#)cclass.h 8.3 (Berkeley) 3/20/94 -+ */ -+ -+#ifndef LLVM_SUPPORT_REGCCLASS_H -+#define LLVM_SUPPORT_REGCCLASS_H -+ -+/* character-class table */ -+static struct cclass { -+ const char *name; -+ const char *chars; -+ const char *multis; -+} cclasses[] = { -+ { "alnum", "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz\ -+0123456789", ""} , -+ { "alpha", "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz", -+ ""} , -+ { "blank", " \t", ""} , -+ { "cntrl", "\007\b\t\n\v\f\r\1\2\3\4\5\6\16\17\20\21\22\23\24\ -+\25\26\27\30\31\32\33\34\35\36\37\177", ""} , -+ { "digit", "0123456789", ""} , -+ { "graph", "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz\ -+0123456789!\"#$%&'()*+,-./:;<=>?@[\\]^_`{|}~", -+ ""} , -+ { "lower", "abcdefghijklmnopqrstuvwxyz", -+ ""} , -+ { "print", "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz\ -+0123456789!\"#$%&'()*+,-./:;<=>?@[\\]^_`{|}~ ", -+ ""} , -+ { "punct", "!\"#$%&'()*+,-./:;<=>?@[\\]^_`{|}~", -+ ""} , -+ { "space", "\t\n\v\f\r ", ""} , -+ { "upper", "ABCDEFGHIJKLMNOPQRSTUVWXYZ", -+ ""} , -+ { "xdigit", "0123456789ABCDEFabcdef", -+ ""} , -+ { NULL, 0, "" } -+}; -+ -+#endif -diff -up lldb-3.8.0rc2.src/include/lldb/Utility/regcname.h.dave lldb-3.8.0rc2.src/include/lldb/Utility/regcname.h ---- lldb-3.8.0rc2.src/include/lldb/Utility/regcname.h.dave 2016-02-17 23:19:05.371675721 -0500 -+++ lldb-3.8.0rc2.src/include/lldb/Utility/regcname.h 2016-02-17 23:19:05.371675721 -0500 -@@ -0,0 +1,144 @@ -+/*- -+ * This code is derived from OpenBSD's libc/regex, original license follows: -+ * -+ * Copyright (c) 1992, 1993, 1994 Henry Spencer. -+ * Copyright (c) 1992, 1993, 1994 -+ * The Regents of the University of California. All rights reserved. -+ * -+ * This code is derived from software contributed to Berkeley by -+ * Henry Spencer. -+ * -+ * Redistribution and use in source and binary forms, with or without -+ * modification, are permitted provided that the following conditions -+ * are met: -+ * 1. Redistributions of source code must retain the above copyright -+ * notice, this list of conditions and the following disclaimer. -+ * 2. Redistributions in binary form must reproduce the above copyright -+ * notice, this list of conditions and the following disclaimer in the -+ * documentation and/or other materials provided with the distribution. -+ * 3. Neither the name of the University nor the names of its contributors -+ * may be used to endorse or promote products derived from this software -+ * without specific prior written permission. -+ * -+ * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND -+ * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE -+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE -+ * ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE -+ * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL -+ * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS -+ * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) -+ * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT -+ * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY -+ * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF -+ * SUCH DAMAGE. -+ * -+ * @(#)cname.h 8.3 (Berkeley) 3/20/94 -+ */ -+ -+#ifndef LLVM_SUPPORT_REGCNAME_H -+#define LLVM_SUPPORT_REGCNAME_H -+ -+/* character-name table */ -+static struct cname { -+ const char *name; -+ char code; -+} cnames[] = { -+ { "NUL", '\0' }, -+ { "SOH", '\001' }, -+ { "STX", '\002' }, -+ { "ETX", '\003' }, -+ { "EOT", '\004' }, -+ { "ENQ", '\005' }, -+ { "ACK", '\006' }, -+ { "BEL", '\007' }, -+ { "alert", '\007' }, -+ { "BS", '\010' }, -+ { "backspace", '\b' }, -+ { "HT", '\011' }, -+ { "tab", '\t' }, -+ { "LF", '\012' }, -+ { "newline", '\n' }, -+ { "VT", '\013' }, -+ { "vertical-tab", '\v' }, -+ { "FF", '\014' }, -+ { "form-feed", '\f' }, -+ { "CR", '\015' }, -+ { "carriage-return", '\r' }, -+ { "SO", '\016' }, -+ { "SI", '\017' }, -+ { "DLE", '\020' }, -+ { "DC1", '\021' }, -+ { "DC2", '\022' }, -+ { "DC3", '\023' }, -+ { "DC4", '\024' }, -+ { "NAK", '\025' }, -+ { "SYN", '\026' }, -+ { "ETB", '\027' }, -+ { "CAN", '\030' }, -+ { "EM", '\031' }, -+ { "SUB", '\032' }, -+ { "ESC", '\033' }, -+ { "IS4", '\034' }, -+ { "FS", '\034' }, -+ { "IS3", '\035' }, -+ { "GS", '\035' }, -+ { "IS2", '\036' }, -+ { "RS", '\036' }, -+ { "IS1", '\037' }, -+ { "US", '\037' }, -+ { "space", ' ' }, -+ { "exclamation-mark", '!' }, -+ { "quotation-mark", '"' }, -+ { "number-sign", '#' }, -+ { "dollar-sign", '$' }, -+ { "percent-sign", '%' }, -+ { "ampersand", '&' }, -+ { "apostrophe", '\'' }, -+ { "left-parenthesis", '(' }, -+ { "right-parenthesis", ')' }, -+ { "asterisk", '*' }, -+ { "plus-sign", '+' }, -+ { "comma", ',' }, -+ { "hyphen", '-' }, -+ { "hyphen-minus", '-' }, -+ { "period", '.' }, -+ { "full-stop", '.' }, -+ { "slash", '/' }, -+ { "solidus", '/' }, -+ { "zero", '0' }, -+ { "one", '1' }, -+ { "two", '2' }, -+ { "three", '3' }, -+ { "four", '4' }, -+ { "five", '5' }, -+ { "six", '6' }, -+ { "seven", '7' }, -+ { "eight", '8' }, -+ { "nine", '9' }, -+ { "colon", ':' }, -+ { "semicolon", ';' }, -+ { "less-than-sign", '<' }, -+ { "equals-sign", '=' }, -+ { "greater-than-sign", '>' }, -+ { "question-mark", '?' }, -+ { "commercial-at", '@' }, -+ { "left-square-bracket", '[' }, -+ { "backslash", '\\' }, -+ { "reverse-solidus", '\\' }, -+ { "right-square-bracket", ']' }, -+ { "circumflex", '^' }, -+ { "circumflex-accent", '^' }, -+ { "underscore", '_' }, -+ { "low-line", '_' }, -+ { "grave-accent", '`' }, -+ { "left-brace", '{' }, -+ { "left-curly-bracket", '{' }, -+ { "vertical-line", '|' }, -+ { "right-brace", '}' }, -+ { "right-curly-bracket", '}' }, -+ { "tilde", '~' }, -+ { "DEL", '\177' }, -+ { NULL, 0 } -+}; -+ -+#endif -diff -up lldb-3.8.0rc2.src/include/lldb/Utility/regengine.inc.dave lldb-3.8.0rc2.src/include/lldb/Utility/regengine.inc ---- lldb-3.8.0rc2.src/include/lldb/Utility/regengine.inc.dave 2016-02-17 23:19:05.371675721 -0500 -+++ lldb-3.8.0rc2.src/include/lldb/Utility/regengine.inc 2016-02-17 23:19:05.371675721 -0500 -@@ -0,0 +1,1034 @@ -+/*- -+ * This code is derived from OpenBSD's libc/regex, original license follows: -+ * -+ * Copyright (c) 1992, 1993, 1994 Henry Spencer. -+ * Copyright (c) 1992, 1993, 1994 -+ * The Regents of the University of California. All rights reserved. -+ * -+ * This code is derived from software contributed to Berkeley by -+ * Henry Spencer. -+ * -+ * Redistribution and use in source and binary forms, with or without -+ * modification, are permitted provided that the following conditions -+ * are met: -+ * 1. Redistributions of source code must retain the above copyright -+ * notice, this list of conditions and the following disclaimer. -+ * 2. Redistributions in binary form must reproduce the above copyright -+ * notice, this list of conditions and the following disclaimer in the -+ * documentation and/or other materials provided with the distribution. -+ * 3. Neither the name of the University nor the names of its contributors -+ * may be used to endorse or promote products derived from this software -+ * without specific prior written permission. -+ * -+ * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND -+ * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE -+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE -+ * ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE -+ * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL -+ * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS -+ * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) -+ * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT -+ * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY -+ * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF -+ * SUCH DAMAGE. -+ * -+ * @(#)engine.c 8.5 (Berkeley) 3/20/94 -+ */ -+ -+/* -+ * The matching engine and friends. This file is #included by regexec.c -+ * after suitable #defines of a variety of macros used herein, so that -+ * different state representations can be used without duplicating masses -+ * of code. -+ */ -+ -+#ifdef SNAMES -+#define matcher smatcher -+#define fast sfast -+#define slow sslow -+#define dissect sdissect -+#define backref sbackref -+#define step sstep -+#define print sprint -+#define at sat -+#define match smat -+#define nope snope -+#endif -+#ifdef LNAMES -+#define matcher lmatcher -+#define fast lfast -+#define slow lslow -+#define dissect ldissect -+#define backref lbackref -+#define step lstep -+#define print lprint -+#define at lat -+#define match lmat -+#define nope lnope -+#endif -+ -+/* another structure passed up and down to avoid zillions of parameters */ -+struct match { -+ struct re_guts *g; -+ int eflags; -+ llvm_regmatch_t *pmatch; /* [nsub+1] (0 element unused) */ -+ const char *offp; /* offsets work from here */ -+ const char *beginp; /* start of string -- virtual NUL precedes */ -+ const char *endp; /* end of string -- virtual NUL here */ -+ const char *coldp; /* can be no match starting before here */ -+ const char **lastpos; /* [nplus+1] */ -+ STATEVARS; -+ states st; /* current states */ -+ states fresh; /* states for a fresh start */ -+ states tmp; /* temporary */ -+ states empty; /* empty set of states */ -+}; -+ -+static int matcher(struct re_guts *, const char *, size_t, -+ llvm_regmatch_t[], int); -+static const char *dissect(struct match *, const char *, const char *, sopno, -+ sopno); -+static const char *backref(struct match *, const char *, const char *, sopno, -+ sopno, sopno, int); -+static const char *fast(struct match *, const char *, const char *, sopno, sopno); -+static const char *slow(struct match *, const char *, const char *, sopno, sopno); -+static states step(struct re_guts *, sopno, sopno, states, int, states); -+#define MAX_RECURSION 100 -+#define BOL (OUT+1) -+#define EOL (BOL+1) -+#define BOLEOL (BOL+2) -+#define NOTHING (BOL+3) -+#define BOW (BOL+4) -+#define EOW (BOL+5) -+#define CODEMAX (BOL+5) /* highest code used */ -+#define NONCHAR(c) ((c) > CHAR_MAX) -+#define NNONCHAR (CODEMAX-CHAR_MAX) -+#ifdef REDEBUG -+static void print(struct match *, char *, states, int, FILE *); -+#endif -+#ifdef REDEBUG -+static void at(struct match *, char *, char *, char *, sopno, sopno); -+#endif -+#ifdef REDEBUG -+static char *pchar(int); -+#endif -+ -+#ifdef REDEBUG -+#define SP(t, s, c) print(m, t, s, c, stdout) -+#define AT(t, p1, p2, s1, s2) at(m, t, p1, p2, s1, s2) -+#define NOTE(str) { if (m->eflags®_TRACE) (void)printf("=%s\n", (str)); } -+static int nope = 0; -+#else -+#define SP(t, s, c) /* nothing */ -+#define AT(t, p1, p2, s1, s2) /* nothing */ -+#define NOTE(s) /* nothing */ -+#endif -+ -+/* -+ - matcher - the actual matching engine -+ */ -+static int /* 0 success, REG_NOMATCH failure */ -+matcher(struct re_guts *g, const char *string, size_t nmatch, -+ llvm_regmatch_t pmatch[], -+ int eflags) -+{ -+ const char *endp; -+ size_t i; -+ struct match mv; -+ struct match *m = &mv; -+ const char *dp; -+ const sopno gf = g->firststate+1; /* +1 for OEND */ -+ const sopno gl = g->laststate; -+ const char *start; -+ const char *stop; -+ -+ /* simplify the situation where possible */ -+ if (g->cflags®_NOSUB) -+ nmatch = 0; -+ if (eflags®_STARTEND) { -+ start = string + pmatch[0].rm_so; -+ stop = string + pmatch[0].rm_eo; -+ } else { -+ start = string; -+ stop = start + strlen(start); -+ } -+ if (stop < start) -+ return(REG_INVARG); -+ -+ /* prescreening; this does wonders for this rather slow code */ -+ if (g->must != NULL) { -+ for (dp = start; dp < stop; dp++) -+ if (*dp == g->must[0] && stop - dp >= g->mlen && -+ memcmp(dp, g->must, (size_t)g->mlen) == 0) -+ break; -+ if (dp == stop) /* we didn't find g->must */ -+ return(REG_NOMATCH); -+ } -+ -+ /* match struct setup */ -+ m->g = g; -+ m->eflags = eflags; -+ m->pmatch = NULL; -+ m->lastpos = NULL; -+ m->offp = string; -+ m->beginp = start; -+ m->endp = stop; -+ STATESETUP(m, 4); -+ SETUP(m->st); -+ SETUP(m->fresh); -+ SETUP(m->tmp); -+ SETUP(m->empty); -+ CLEAR(m->empty); -+ -+ /* this loop does only one repetition except for backrefs */ -+ for (;;) { -+ endp = fast(m, start, stop, gf, gl); -+ if (endp == NULL) { /* a miss */ -+ free(m->pmatch); -+ free((void*)m->lastpos); -+ STATETEARDOWN(m); -+ return(REG_NOMATCH); -+ } -+ if (nmatch == 0 && !g->backrefs) -+ break; /* no further info needed */ -+ -+ /* where? */ -+ assert(m->coldp != NULL); -+ for (;;) { -+ NOTE("finding start"); -+ endp = slow(m, m->coldp, stop, gf, gl); -+ if (endp != NULL) -+ break; -+ assert(m->coldp < m->endp); -+ m->coldp++; -+ } -+ if (nmatch == 1 && !g->backrefs) -+ break; /* no further info needed */ -+ -+ /* oh my, they want the subexpressions... */ -+ if (m->pmatch == NULL) -+ m->pmatch = (llvm_regmatch_t *)malloc((m->g->nsub + 1) * -+ sizeof(llvm_regmatch_t)); -+ if (m->pmatch == NULL) { -+ STATETEARDOWN(m); -+ return(REG_ESPACE); -+ } -+ for (i = 1; i <= m->g->nsub; i++) -+ m->pmatch[i].rm_so = m->pmatch[i].rm_eo = -1; -+ if (!g->backrefs && !(m->eflags®_BACKR)) { -+ NOTE("dissecting"); -+ dp = dissect(m, m->coldp, endp, gf, gl); -+ } else { -+ if (g->nplus > 0 && m->lastpos == NULL) -+ m->lastpos = (const char **)malloc((g->nplus+1) * -+ sizeof(char *)); -+ if (g->nplus > 0 && m->lastpos == NULL) { -+ free(m->pmatch); -+ STATETEARDOWN(m); -+ return(REG_ESPACE); -+ } -+ NOTE("backref dissect"); -+ dp = backref(m, m->coldp, endp, gf, gl, (sopno)0, 0); -+ } -+ if (dp != NULL) -+ break; -+ -+ /* uh-oh... we couldn't find a subexpression-level match */ -+ assert(g->backrefs); /* must be back references doing it */ -+ assert(g->nplus == 0 || m->lastpos != NULL); -+ for (;;) { -+ if (dp != NULL || endp <= m->coldp) -+ break; /* defeat */ -+ NOTE("backoff"); -+ endp = slow(m, m->coldp, endp-1, gf, gl); -+ if (endp == NULL) -+ break; /* defeat */ -+ /* try it on a shorter possibility */ -+#ifndef NDEBUG -+ for (i = 1; i <= m->g->nsub; i++) { -+ assert(m->pmatch[i].rm_so == -1); -+ assert(m->pmatch[i].rm_eo == -1); -+ } -+#endif -+ NOTE("backoff dissect"); -+ dp = backref(m, m->coldp, endp, gf, gl, (sopno)0, 0); -+ } -+ assert(dp == NULL || dp == endp); -+ if (dp != NULL) /* found a shorter one */ -+ break; -+ -+ /* despite initial appearances, there is no match here */ -+ NOTE("false alarm"); -+ if (m->coldp == stop) -+ break; -+ start = m->coldp + 1; /* recycle starting later */ -+ } -+ -+ /* fill in the details if requested */ -+ if (nmatch > 0) { -+ pmatch[0].rm_so = m->coldp - m->offp; -+ pmatch[0].rm_eo = endp - m->offp; -+ } -+ if (nmatch > 1) { -+ assert(m->pmatch != NULL); -+ for (i = 1; i < nmatch; i++) -+ if (i <= m->g->nsub) -+ pmatch[i] = m->pmatch[i]; -+ else { -+ pmatch[i].rm_so = -1; -+ pmatch[i].rm_eo = -1; -+ } -+ } -+ -+ if (m->pmatch != NULL) -+ free((char *)m->pmatch); -+ if (m->lastpos != NULL) -+ free((char *)m->lastpos); -+ STATETEARDOWN(m); -+ return(0); -+} -+ -+/* -+ - dissect - figure out what matched what, no back references -+ */ -+static const char * /* == stop (success) always */ -+dissect(struct match *m, const char *start, const char *stop, sopno startst, -+ sopno stopst) -+{ -+ int i; -+ sopno ss; /* start sop of current subRE */ -+ sopno es; /* end sop of current subRE */ -+ const char *sp; /* start of string matched by it */ -+ const char *stp; /* string matched by it cannot pass here */ -+ const char *rest; /* start of rest of string */ -+ const char *tail; /* string unmatched by rest of RE */ -+ sopno ssub; /* start sop of subsubRE */ -+ sopno esub; /* end sop of subsubRE */ -+ const char *ssp; /* start of string matched by subsubRE */ -+ const char *sep; /* end of string matched by subsubRE */ -+ const char *oldssp; /* previous ssp */ -+ -+ AT("diss", start, stop, startst, stopst); -+ sp = start; -+ for (ss = startst; ss < stopst; ss = es) { -+ /* identify end of subRE */ -+ es = ss; -+ switch (OP(m->g->strip[es])) { -+ case OPLUS_: -+ case OQUEST_: -+ es += OPND(m->g->strip[es]); -+ break; -+ case OCH_: -+ while (OP(m->g->strip[es]) != O_CH) -+ es += OPND(m->g->strip[es]); -+ break; -+ } -+ es++; -+ -+ /* figure out what it matched */ -+ switch (OP(m->g->strip[ss])) { -+ case OEND: -+ assert(nope); -+ break; -+ case OCHAR: -+ sp++; -+ break; -+ case OBOL: -+ case OEOL: -+ case OBOW: -+ case OEOW: -+ break; -+ case OANY: -+ case OANYOF: -+ sp++; -+ break; -+ case OBACK_: -+ case O_BACK: -+ assert(nope); -+ break; -+ /* cases where length of match is hard to find */ -+ case OQUEST_: -+ stp = stop; -+ for (;;) { -+ /* how long could this one be? */ -+ rest = slow(m, sp, stp, ss, es); -+ assert(rest != NULL); /* it did match */ -+ /* could the rest match the rest? */ -+ tail = slow(m, rest, stop, es, stopst); -+ if (tail == stop) -+ break; /* yes! */ -+ /* no -- try a shorter match for this one */ -+ stp = rest - 1; -+ assert(stp >= sp); /* it did work */ -+ } -+ ssub = ss + 1; -+ esub = es - 1; -+ /* did innards match? */ -+ if (slow(m, sp, rest, ssub, esub) != NULL) { -+ const char *dp = dissect(m, sp, rest, ssub, esub); -+ (void)dp; /* avoid warning if assertions off */ -+ assert(dp == rest); -+ } else /* no */ -+ assert(sp == rest); -+ sp = rest; -+ break; -+ case OPLUS_: -+ stp = stop; -+ for (;;) { -+ /* how long could this one be? */ -+ rest = slow(m, sp, stp, ss, es); -+ assert(rest != NULL); /* it did match */ -+ /* could the rest match the rest? */ -+ tail = slow(m, rest, stop, es, stopst); -+ if (tail == stop) -+ break; /* yes! */ -+ /* no -- try a shorter match for this one */ -+ stp = rest - 1; -+ assert(stp >= sp); /* it did work */ -+ } -+ ssub = ss + 1; -+ esub = es - 1; -+ ssp = sp; -+ oldssp = ssp; -+ for (;;) { /* find last match of innards */ -+ sep = slow(m, ssp, rest, ssub, esub); -+ if (sep == NULL || sep == ssp) -+ break; /* failed or matched null */ -+ oldssp = ssp; /* on to next try */ -+ ssp = sep; -+ } -+ if (sep == NULL) { -+ /* last successful match */ -+ sep = ssp; -+ ssp = oldssp; -+ } -+ assert(sep == rest); /* must exhaust substring */ -+ assert(slow(m, ssp, sep, ssub, esub) == rest); -+ { -+ const char *dp = dissect(m, ssp, sep, ssub, esub); -+ (void)dp; /* avoid warning if assertions off */ -+ assert(dp == sep); -+ } -+ sp = rest; -+ break; -+ case OCH_: -+ stp = stop; -+ for (;;) { -+ /* how long could this one be? */ -+ rest = slow(m, sp, stp, ss, es); -+ assert(rest != NULL); /* it did match */ -+ /* could the rest match the rest? */ -+ tail = slow(m, rest, stop, es, stopst); -+ if (tail == stop) -+ break; /* yes! */ -+ /* no -- try a shorter match for this one */ -+ stp = rest - 1; -+ assert(stp >= sp); /* it did work */ -+ } -+ ssub = ss + 1; -+ esub = ss + OPND(m->g->strip[ss]) - 1; -+ assert(OP(m->g->strip[esub]) == OOR1); -+ for (;;) { /* find first matching branch */ -+ if (slow(m, sp, rest, ssub, esub) == rest) -+ break; /* it matched all of it */ -+ /* that one missed, try next one */ -+ assert(OP(m->g->strip[esub]) == OOR1); -+ esub++; -+ assert(OP(m->g->strip[esub]) == OOR2); -+ ssub = esub + 1; -+ esub += OPND(m->g->strip[esub]); -+ if (OP(m->g->strip[esub]) == OOR2) -+ esub--; -+ else -+ assert(OP(m->g->strip[esub]) == O_CH); -+ } -+ { -+ const char *dp = dissect(m, sp, rest, ssub, esub); -+ (void)dp; /* avoid warning if assertions off */ -+ assert(dp == rest); -+ } -+ sp = rest; -+ break; -+ case O_PLUS: -+ case O_QUEST: -+ case OOR1: -+ case OOR2: -+ case O_CH: -+ assert(nope); -+ break; -+ case OLPAREN: -+ i = OPND(m->g->strip[ss]); -+ assert(0 < i && i <= m->g->nsub); -+ m->pmatch[i].rm_so = sp - m->offp; -+ break; -+ case ORPAREN: -+ i = OPND(m->g->strip[ss]); -+ assert(0 < i && i <= m->g->nsub); -+ m->pmatch[i].rm_eo = sp - m->offp; -+ break; -+ default: /* uh oh */ -+ assert(nope); -+ break; -+ } -+ } -+ -+ assert(sp == stop); -+ return(sp); -+} -+ -+/* -+ - backref - figure out what matched what, figuring in back references -+ */ -+static const char * /* == stop (success) or NULL (failure) */ -+backref(struct match *m, const char *start, const char *stop, sopno startst, -+ sopno stopst, sopno lev, int rec) /* PLUS nesting level */ -+{ -+ int i; -+ sopno ss; /* start sop of current subRE */ -+ const char *sp; /* start of string matched by it */ -+ sopno ssub; /* start sop of subsubRE */ -+ sopno esub; /* end sop of subsubRE */ -+ const char *ssp; /* start of string matched by subsubRE */ -+ const char *dp; -+ size_t len; -+ int hard; -+ sop s; -+ llvm_regoff_t offsave; -+ cset *cs; -+ -+ AT("back", start, stop, startst, stopst); -+ sp = start; -+ -+ /* get as far as we can with easy stuff */ -+ hard = 0; -+ for (ss = startst; !hard && ss < stopst; ss++) -+ switch (OP(s = m->g->strip[ss])) { -+ case OCHAR: -+ if (sp == stop || *sp++ != (char)OPND(s)) -+ return(NULL); -+ break; -+ case OANY: -+ if (sp == stop) -+ return(NULL); -+ sp++; -+ break; -+ case OANYOF: -+ cs = &m->g->sets[OPND(s)]; -+ if (sp == stop || !CHIN(cs, *sp++)) -+ return(NULL); -+ break; -+ case OBOL: -+ if ( (sp == m->beginp && !(m->eflags®_NOTBOL)) || -+ (sp < m->endp && *(sp-1) == '\n' && -+ (m->g->cflags®_NEWLINE)) ) -+ { /* yes */ } -+ else -+ return(NULL); -+ break; -+ case OEOL: -+ if ( (sp == m->endp && !(m->eflags®_NOTEOL)) || -+ (sp < m->endp && *sp == '\n' && -+ (m->g->cflags®_NEWLINE)) ) -+ { /* yes */ } -+ else -+ return(NULL); -+ break; -+ case OBOW: -+ if (( (sp == m->beginp && !(m->eflags®_NOTBOL)) || -+ (sp < m->endp && *(sp-1) == '\n' && -+ (m->g->cflags®_NEWLINE)) || -+ (sp > m->beginp && -+ !ISWORD(*(sp-1))) ) && -+ (sp < m->endp && ISWORD(*sp)) ) -+ { /* yes */ } -+ else -+ return(NULL); -+ break; -+ case OEOW: -+ if (( (sp == m->endp && !(m->eflags®_NOTEOL)) || -+ (sp < m->endp && *sp == '\n' && -+ (m->g->cflags®_NEWLINE)) || -+ (sp < m->endp && !ISWORD(*sp)) ) && -+ (sp > m->beginp && ISWORD(*(sp-1))) ) -+ { /* yes */ } -+ else -+ return(NULL); -+ break; -+ case O_QUEST: -+ break; -+ case OOR1: /* matches null but needs to skip */ -+ ss++; -+ s = m->g->strip[ss]; -+ do { -+ assert(OP(s) == OOR2); -+ ss += OPND(s); -+ } while (OP(s = m->g->strip[ss]) != O_CH); -+ /* note that the ss++ gets us past the O_CH */ -+ break; -+ default: /* have to make a choice */ -+ hard = 1; -+ break; -+ } -+ if (!hard) { /* that was it! */ -+ if (sp != stop) -+ return(NULL); -+ return(sp); -+ } -+ ss--; /* adjust for the for's final increment */ -+ -+ /* the hard stuff */ -+ AT("hard", sp, stop, ss, stopst); -+ s = m->g->strip[ss]; -+ switch (OP(s)) { -+ case OBACK_: /* the vilest depths */ -+ i = OPND(s); -+ assert(0 < i && i <= m->g->nsub); -+ if (m->pmatch[i].rm_eo == -1) -+ return(NULL); -+ assert(m->pmatch[i].rm_so != -1); -+ len = m->pmatch[i].rm_eo - m->pmatch[i].rm_so; -+ if (len == 0 && rec++ > MAX_RECURSION) -+ return(NULL); -+ assert(stop - m->beginp >= len); -+ if (sp > stop - len) -+ return(NULL); /* not enough left to match */ -+ ssp = m->offp + m->pmatch[i].rm_so; -+ if (memcmp(sp, ssp, len) != 0) -+ return(NULL); -+ while (m->g->strip[ss] != SOP(O_BACK, i)) -+ ss++; -+ return(backref(m, sp+len, stop, ss+1, stopst, lev, rec)); -+ break; -+ case OQUEST_: /* to null or not */ -+ dp = backref(m, sp, stop, ss+1, stopst, lev, rec); -+ if (dp != NULL) -+ return(dp); /* not */ -+ return(backref(m, sp, stop, ss+OPND(s)+1, stopst, lev, rec)); -+ break; -+ case OPLUS_: -+ assert(m->lastpos != NULL); -+ assert(lev+1 <= m->g->nplus); -+ m->lastpos[lev+1] = sp; -+ return(backref(m, sp, stop, ss+1, stopst, lev+1, rec)); -+ break; -+ case O_PLUS: -+ if (sp == m->lastpos[lev]) /* last pass matched null */ -+ return(backref(m, sp, stop, ss+1, stopst, lev-1, rec)); -+ /* try another pass */ -+ m->lastpos[lev] = sp; -+ dp = backref(m, sp, stop, ss-OPND(s)+1, stopst, lev, rec); -+ if (dp == NULL) -+ return(backref(m, sp, stop, ss+1, stopst, lev-1, rec)); -+ else -+ return(dp); -+ break; -+ case OCH_: /* find the right one, if any */ -+ ssub = ss + 1; -+ esub = ss + OPND(s) - 1; -+ assert(OP(m->g->strip[esub]) == OOR1); -+ for (;;) { /* find first matching branch */ -+ dp = backref(m, sp, stop, ssub, esub, lev, rec); -+ if (dp != NULL) -+ return(dp); -+ /* that one missed, try next one */ -+ if (OP(m->g->strip[esub]) == O_CH) -+ return(NULL); /* there is none */ -+ esub++; -+ assert(OP(m->g->strip[esub]) == OOR2); -+ ssub = esub + 1; -+ esub += OPND(m->g->strip[esub]); -+ if (OP(m->g->strip[esub]) == OOR2) -+ esub--; -+ else -+ assert(OP(m->g->strip[esub]) == O_CH); -+ } -+ break; -+ case OLPAREN: /* must undo assignment if rest fails */ -+ i = OPND(s); -+ assert(0 < i && i <= m->g->nsub); -+ offsave = m->pmatch[i].rm_so; -+ m->pmatch[i].rm_so = sp - m->offp; -+ dp = backref(m, sp, stop, ss+1, stopst, lev, rec); -+ if (dp != NULL) -+ return(dp); -+ m->pmatch[i].rm_so = offsave; -+ return(NULL); -+ break; -+ case ORPAREN: /* must undo assignment if rest fails */ -+ i = OPND(s); -+ assert(0 < i && i <= m->g->nsub); -+ offsave = m->pmatch[i].rm_eo; -+ m->pmatch[i].rm_eo = sp - m->offp; -+ dp = backref(m, sp, stop, ss+1, stopst, lev, rec); -+ if (dp != NULL) -+ return(dp); -+ m->pmatch[i].rm_eo = offsave; -+ return(NULL); -+ break; -+ default: /* uh oh */ -+ assert(nope); -+ break; -+ } -+ -+ /* "can't happen" */ -+ assert(nope); -+ /* NOTREACHED */ -+ return NULL; -+} -+ -+/* -+ - fast - step through the string at top speed -+ */ -+static const char * /* where tentative match ended, or NULL */ -+fast(struct match *m, const char *start, const char *stop, sopno startst, -+ sopno stopst) -+{ -+ states st = m->st; -+ states fresh = m->fresh; -+ states tmp = m->tmp; -+ const char *p = start; -+ int c = (start == m->beginp) ? OUT : *(start-1); -+ int lastc; /* previous c */ -+ int flagch; -+ int i; -+ const char *coldp; /* last p after which no match was underway */ -+ -+ CLEAR(st); -+ SET1(st, startst); -+ st = step(m->g, startst, stopst, st, NOTHING, st); -+ ASSIGN(fresh, st); -+ SP("start", st, *p); -+ coldp = NULL; -+ for (;;) { -+ /* next character */ -+ lastc = c; -+ c = (p == m->endp) ? OUT : *p; -+ if (EQ(st, fresh)) -+ coldp = p; -+ -+ /* is there an EOL and/or BOL between lastc and c? */ -+ flagch = '\0'; -+ i = 0; -+ if ( (lastc == '\n' && m->g->cflags®_NEWLINE) || -+ (lastc == OUT && !(m->eflags®_NOTBOL)) ) { -+ flagch = BOL; -+ i = m->g->nbol; -+ } -+ if ( (c == '\n' && m->g->cflags®_NEWLINE) || -+ (c == OUT && !(m->eflags®_NOTEOL)) ) { -+ flagch = (flagch == BOL) ? BOLEOL : EOL; -+ i += m->g->neol; -+ } -+ if (i != 0) { -+ for (; i > 0; i--) -+ st = step(m->g, startst, stopst, st, flagch, st); -+ SP("boleol", st, c); -+ } -+ -+ /* how about a word boundary? */ -+ if ( (flagch == BOL || (lastc != OUT && !ISWORD(lastc))) && -+ (c != OUT && ISWORD(c)) ) { -+ flagch = BOW; -+ } -+ if ( (lastc != OUT && ISWORD(lastc)) && -+ (flagch == EOL || (c != OUT && !ISWORD(c))) ) { -+ flagch = EOW; -+ } -+ if (flagch == BOW || flagch == EOW) { -+ st = step(m->g, startst, stopst, st, flagch, st); -+ SP("boweow", st, c); -+ } -+ -+ /* are we done? */ -+ if (ISSET(st, stopst) || p == stop) -+ break; /* NOTE BREAK OUT */ -+ -+ /* no, we must deal with this character */ -+ ASSIGN(tmp, st); -+ ASSIGN(st, fresh); -+ assert(c != OUT); -+ st = step(m->g, startst, stopst, tmp, c, st); -+ SP("aft", st, c); -+ assert(EQ(step(m->g, startst, stopst, st, NOTHING, st), st)); -+ p++; -+ } -+ -+ assert(coldp != NULL); -+ m->coldp = coldp; -+ if (ISSET(st, stopst)) -+ return(p+1); -+ else -+ return(NULL); -+} -+ -+/* -+ - slow - step through the string more deliberately -+ */ -+static const char * /* where it ended */ -+slow(struct match *m, const char *start, const char *stop, sopno startst, -+ sopno stopst) -+{ -+ states st = m->st; -+ states empty = m->empty; -+ states tmp = m->tmp; -+ const char *p = start; -+ int c = (start == m->beginp) ? OUT : *(start-1); -+ int lastc; /* previous c */ -+ int flagch; -+ int i; -+ const char *matchp; /* last p at which a match ended */ -+ -+ AT("slow", start, stop, startst, stopst); -+ CLEAR(st); -+ SET1(st, startst); -+ SP("sstart", st, *p); -+ st = step(m->g, startst, stopst, st, NOTHING, st); -+ matchp = NULL; -+ for (;;) { -+ /* next character */ -+ lastc = c; -+ c = (p == m->endp) ? OUT : *p; -+ -+ /* is there an EOL and/or BOL between lastc and c? */ -+ flagch = '\0'; -+ i = 0; -+ if ( (lastc == '\n' && m->g->cflags®_NEWLINE) || -+ (lastc == OUT && !(m->eflags®_NOTBOL)) ) { -+ flagch = BOL; -+ i = m->g->nbol; -+ } -+ if ( (c == '\n' && m->g->cflags®_NEWLINE) || -+ (c == OUT && !(m->eflags®_NOTEOL)) ) { -+ flagch = (flagch == BOL) ? BOLEOL : EOL; -+ i += m->g->neol; -+ } -+ if (i != 0) { -+ for (; i > 0; i--) -+ st = step(m->g, startst, stopst, st, flagch, st); -+ SP("sboleol", st, c); -+ } -+ -+ /* how about a word boundary? */ -+ if ( (flagch == BOL || (lastc != OUT && !ISWORD(lastc))) && -+ (c != OUT && ISWORD(c)) ) { -+ flagch = BOW; -+ } -+ if ( (lastc != OUT && ISWORD(lastc)) && -+ (flagch == EOL || (c != OUT && !ISWORD(c))) ) { -+ flagch = EOW; -+ } -+ if (flagch == BOW || flagch == EOW) { -+ st = step(m->g, startst, stopst, st, flagch, st); -+ SP("sboweow", st, c); -+ } -+ -+ /* are we done? */ -+ if (ISSET(st, stopst)) -+ matchp = p; -+ if (EQ(st, empty) || p == stop) -+ break; /* NOTE BREAK OUT */ -+ -+ /* no, we must deal with this character */ -+ ASSIGN(tmp, st); -+ ASSIGN(st, empty); -+ assert(c != OUT); -+ st = step(m->g, startst, stopst, tmp, c, st); -+ SP("saft", st, c); -+ assert(EQ(step(m->g, startst, stopst, st, NOTHING, st), st)); -+ p++; -+ } -+ -+ return(matchp); -+} -+ -+ -+/* -+ - step - map set of states reachable before char to set reachable after -+ */ -+static states -+step(struct re_guts *g, -+ sopno start, /* start state within strip */ -+ sopno stop, /* state after stop state within strip */ -+ states bef, /* states reachable before */ -+ int ch, /* character or NONCHAR code */ -+ states aft) /* states already known reachable after */ -+{ -+ cset *cs; -+ sop s; -+ sopno pc; -+ onestate here; /* note, macros know this name */ -+ sopno look; -+ int i; -+ -+ for (pc = start, INIT(here, pc); pc != stop; pc++, INC(here)) { -+ s = g->strip[pc]; -+ switch (OP(s)) { -+ case OEND: -+ assert(pc == stop-1); -+ break; -+ case OCHAR: -+ /* only characters can match */ -+ assert(!NONCHAR(ch) || ch != (char)OPND(s)); -+ if (ch == (char)OPND(s)) -+ FWD(aft, bef, 1); -+ break; -+ case OBOL: -+ if (ch == BOL || ch == BOLEOL) -+ FWD(aft, bef, 1); -+ break; -+ case OEOL: -+ if (ch == EOL || ch == BOLEOL) -+ FWD(aft, bef, 1); -+ break; -+ case OBOW: -+ if (ch == BOW) -+ FWD(aft, bef, 1); -+ break; -+ case OEOW: -+ if (ch == EOW) -+ FWD(aft, bef, 1); -+ break; -+ case OANY: -+ if (!NONCHAR(ch)) -+ FWD(aft, bef, 1); -+ break; -+ case OANYOF: -+ cs = &g->sets[OPND(s)]; -+ if (!NONCHAR(ch) && CHIN(cs, ch)) -+ FWD(aft, bef, 1); -+ break; -+ case OBACK_: /* ignored here */ -+ case O_BACK: -+ FWD(aft, aft, 1); -+ break; -+ case OPLUS_: /* forward, this is just an empty */ -+ FWD(aft, aft, 1); -+ break; -+ case O_PLUS: /* both forward and back */ -+ FWD(aft, aft, 1); -+ i = ISSETBACK(aft, OPND(s)); -+ BACK(aft, aft, OPND(s)); -+ if (!i && ISSETBACK(aft, OPND(s))) { -+ /* oho, must reconsider loop body */ -+ pc -= OPND(s) + 1; -+ INIT(here, pc); -+ } -+ break; -+ case OQUEST_: /* two branches, both forward */ -+ FWD(aft, aft, 1); -+ FWD(aft, aft, OPND(s)); -+ break; -+ case O_QUEST: /* just an empty */ -+ FWD(aft, aft, 1); -+ break; -+ case OLPAREN: /* not significant here */ -+ case ORPAREN: -+ FWD(aft, aft, 1); -+ break; -+ case OCH_: /* mark the first two branches */ -+ FWD(aft, aft, 1); -+ assert(OP(g->strip[pc+OPND(s)]) == OOR2); -+ FWD(aft, aft, OPND(s)); -+ break; -+ case OOR1: /* done a branch, find the O_CH */ -+ if (ISSTATEIN(aft, here)) { -+ for (look = 1; -+ OP(s = g->strip[pc+look]) != O_CH; -+ look += OPND(s)) -+ assert(OP(s) == OOR2); -+ FWD(aft, aft, look); -+ } -+ break; -+ case OOR2: /* propagate OCH_'s marking */ -+ FWD(aft, aft, 1); -+ if (OP(g->strip[pc+OPND(s)]) != O_CH) { -+ assert(OP(g->strip[pc+OPND(s)]) == OOR2); -+ FWD(aft, aft, OPND(s)); -+ } -+ break; -+ case O_CH: /* just empty */ -+ FWD(aft, aft, 1); -+ break; -+ default: /* ooooops... */ -+ assert(nope); -+ break; -+ } -+ } -+ -+ return(aft); -+} -+ -+#ifdef REDEBUG -+/* -+ - print - print a set of states -+ */ -+static void -+print(struct match *m, char *caption, states st, int ch, FILE *d) -+{ -+ struct re_guts *g = m->g; -+ int i; -+ int first = 1; -+ -+ if (!(m->eflags®_TRACE)) -+ return; -+ -+ (void)fprintf(d, "%s", caption); -+ if (ch != '\0') -+ (void)fprintf(d, " %s", pchar(ch)); -+ for (i = 0; i < g->nstates; i++) -+ if (ISSET(st, i)) { -+ (void)fprintf(d, "%s%d", (first) ? "\t" : ", ", i); -+ first = 0; -+ } -+ (void)fprintf(d, "\n"); -+} -+ -+/* -+ - at - print current situation -+ */ -+static void -+at(struct match *m, char *title, char *start, char *stop, sopno startst, -+ sopno stopst) -+{ -+ if (!(m->eflags®_TRACE)) -+ return; -+ -+ (void)printf("%s %s-", title, pchar(*start)); -+ (void)printf("%s ", pchar(*stop)); -+ (void)printf("%ld-%ld\n", (long)startst, (long)stopst); -+} -+ -+#ifndef PCHARDONE -+#define PCHARDONE /* never again */ -+/* -+ - pchar - make a character printable -+ * -+ * Is this identical to regchar() over in debug.c? Well, yes. But a -+ * duplicate here avoids having a debugging-capable regexec.o tied to -+ * a matching debug.o, and this is convenient. It all disappears in -+ * the non-debug compilation anyway, so it doesn't matter much. -+ */ -+static char * /* -> representation */ -+pchar(int ch) -+{ -+ static char pbuf[10]; -+ -+ if (isprint(ch) || ch == ' ') -+ (void)snprintf(pbuf, sizeof pbuf, "%c", ch); -+ else -+ (void)snprintf(pbuf, sizeof pbuf, "\\%o", ch); -+ return(pbuf); -+} -+#endif -+#endif -+ -+#undef matcher -+#undef fast -+#undef slow -+#undef dissect -+#undef backref -+#undef step -+#undef print -+#undef at -+#undef match -+#undef nope -diff -up lldb-3.8.0rc2.src/include/lldb/Utility/regex2.h.dave lldb-3.8.0rc2.src/include/lldb/Utility/regex2.h ---- lldb-3.8.0rc2.src/include/lldb/Utility/regex2.h.dave 2016-02-17 23:19:05.372675749 -0500 -+++ lldb-3.8.0rc2.src/include/lldb/Utility/regex2.h 2016-02-17 23:19:05.372675749 -0500 -@@ -0,0 +1,162 @@ -+/*- -+ * This code is derived from OpenBSD's libc/regex, original license follows: -+ * -+ * Copyright (c) 1992, 1993, 1994 Henry Spencer. -+ * Copyright (c) 1992, 1993, 1994 -+ * The Regents of the University of California. All rights reserved. -+ * -+ * This code is derived from software contributed to Berkeley by -+ * Henry Spencer. -+ * -+ * Redistribution and use in source and binary forms, with or without -+ * modification, are permitted provided that the following conditions -+ * are met: -+ * 1. Redistributions of source code must retain the above copyright -+ * notice, this list of conditions and the following disclaimer. -+ * 2. Redistributions in binary form must reproduce the above copyright -+ * notice, this list of conditions and the following disclaimer in the -+ * documentation and/or other materials provided with the distribution. -+ * 3. Neither the name of the University nor the names of its contributors -+ * may be used to endorse or promote products derived from this software -+ * without specific prior written permission. -+ * -+ * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND -+ * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE -+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE -+ * ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE -+ * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL -+ * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS -+ * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) -+ * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT -+ * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY -+ * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF -+ * SUCH DAMAGE. -+ * -+ * @(#)regex2.h 8.4 (Berkeley) 3/20/94 -+ */ -+ -+#ifndef LLVM_SUPPORT_REGEX2_H -+#define LLVM_SUPPORT_REGEX2_H -+ -+/* -+ * internals of regex_t -+ */ -+#define MAGIC1 ((('r'^0200)<<8) | 'e') -+ -+/* -+ * The internal representation is a *strip*, a sequence of -+ * operators ending with an endmarker. (Some terminology etc. is a -+ * historical relic of earlier versions which used multiple strips.) -+ * Certain oddities in the representation are there to permit running -+ * the machinery backwards; in particular, any deviation from sequential -+ * flow must be marked at both its source and its destination. Some -+ * fine points: -+ * -+ * - OPLUS_ and O_PLUS are *inside* the loop they create. -+ * - OQUEST_ and O_QUEST are *outside* the bypass they create. -+ * - OCH_ and O_CH are *outside* the multi-way branch they create, while -+ * OOR1 and OOR2 are respectively the end and the beginning of one of -+ * the branches. Note that there is an implicit OOR2 following OCH_ -+ * and an implicit OOR1 preceding O_CH. -+ * -+ * In state representations, an operator's bit is on to signify a state -+ * immediately *preceding* "execution" of that operator. -+ */ -+typedef unsigned long sop; /* strip operator */ -+typedef long sopno; -+#define OPRMASK 0xf8000000LU -+#define OPDMASK 0x07ffffffLU -+#define OPSHIFT ((unsigned)27) -+#define OP(n) ((n)&OPRMASK) -+#define OPND(n) ((n)&OPDMASK) -+#define SOP(op, opnd) ((op)|(opnd)) -+/* operators meaning operand */ -+/* (back, fwd are offsets) */ -+#define OEND (1LU< uch [csetsize] */ -+ uch mask; /* bit within array */ -+ uch hash; /* hash code */ -+ size_t smultis; -+ char *multis; /* -> char[smulti] ab\0cd\0ef\0\0 */ -+} cset; -+/* note that CHadd and CHsub are unsafe, and CHIN doesn't yield 0/1 */ -+#define CHadd(cs, c) ((cs)->ptr[(uch)(c)] |= (cs)->mask, (cs)->hash += (c)) -+#define CHsub(cs, c) ((cs)->ptr[(uch)(c)] &= ~(cs)->mask, (cs)->hash -= (c)) -+#define CHIN(cs, c) ((cs)->ptr[(uch)(c)] & (cs)->mask) -+#define MCadd(p, cs, cp) mcadd(p, cs, cp) /* llvm_regcomp() internal fns */ -+#define MCsub(p, cs, cp) mcsub(p, cs, cp) -+#define MCin(p, cs, cp) mcin(p, cs, cp) -+ -+/* stuff for character categories */ -+typedef unsigned char cat_t; -+ -+/* -+ * main compiled-expression structure -+ */ -+struct re_guts { -+ int magic; -+# define MAGIC2 ((('R'^0200)<<8)|'E') -+ sop *strip; /* malloced area for strip */ -+ int csetsize; /* number of bits in a cset vector */ -+ int ncsets; /* number of csets in use */ -+ cset *sets; /* -> cset [ncsets] */ -+ uch *setbits; /* -> uch[csetsize][ncsets/CHAR_BIT] */ -+ int cflags; /* copy of llvm_regcomp() cflags argument */ -+ sopno nstates; /* = number of sops */ -+ sopno firststate; /* the initial OEND (normally 0) */ -+ sopno laststate; /* the final OEND */ -+ int iflags; /* internal flags */ -+# define USEBOL 01 /* used ^ */ -+# define USEEOL 02 /* used $ */ -+# define REGEX_BAD 04 /* something wrong */ -+ int nbol; /* number of ^ used */ -+ int neol; /* number of $ used */ -+ int ncategories; /* how many character categories */ -+ cat_t *categories; /* ->catspace[-CHAR_MIN] */ -+ char *must; /* match must contain this string */ -+ int mlen; /* length of must */ -+ size_t nsub; /* copy of re_nsub */ -+ int backrefs; /* does it use back references? */ -+ sopno nplus; /* how deep does it nest +s? */ -+ /* catspace must be last */ -+ cat_t catspace[1]; /* actually [NC] */ -+}; -+ -+/* misc utilities */ -+#define OUT (CHAR_MAX+1) /* a non-character value */ -+#define ISWORD(c) (isalnum(c&0xff) || (c) == '_') -+ -+#endif -diff -up lldb-3.8.0rc2.src/include/lldb/Utility/regex_impl.h.dave lldb-3.8.0rc2.src/include/lldb/Utility/regex_impl.h ---- lldb-3.8.0rc2.src/include/lldb/Utility/regex_impl.h.dave 2016-02-17 23:19:05.372675749 -0500 -+++ lldb-3.8.0rc2.src/include/lldb/Utility/regex_impl.h 2016-02-17 23:19:05.372675749 -0500 -@@ -0,0 +1,108 @@ -+/*- -+ * This code is derived from OpenBSD's libc/regex, original license follows: -+ * -+ * Copyright (c) 1992 Henry Spencer. -+ * Copyright (c) 1992, 1993 -+ * The Regents of the University of California. All rights reserved. -+ * -+ * This code is derived from software contributed to Berkeley by -+ * Henry Spencer of the University of Toronto. -+ * -+ * Redistribution and use in source and binary forms, with or without -+ * modification, are permitted provided that the following conditions -+ * are met: -+ * 1. Redistributions of source code must retain the above copyright -+ * notice, this list of conditions and the following disclaimer. -+ * 2. Redistributions in binary form must reproduce the above copyright -+ * notice, this list of conditions and the following disclaimer in the -+ * documentation and/or other materials provided with the distribution. -+ * 3. Neither the name of the University nor the names of its contributors -+ * may be used to endorse or promote products derived from this software -+ * without specific prior written permission. -+ * -+ * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND -+ * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE -+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE -+ * ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE -+ * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL -+ * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS -+ * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) -+ * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT -+ * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY -+ * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF -+ * SUCH DAMAGE. -+ * -+ * @(#)regex.h 8.1 (Berkeley) 6/2/93 -+ */ -+ -+#ifndef _REGEX_H_ -+#define _REGEX_H_ -+ -+#include -+typedef off_t llvm_regoff_t; -+typedef struct { -+ llvm_regoff_t rm_so; /* start of match */ -+ llvm_regoff_t rm_eo; /* end of match */ -+} llvm_regmatch_t; -+ -+typedef struct llvm_regex { -+ int re_magic; -+ size_t re_nsub; /* number of parenthesized subexpressions */ -+ const char *re_endp; /* end pointer for REG_PEND */ -+ struct re_guts *re_g; /* none of your business :-) */ -+} llvm_regex_t; -+ -+/* llvm_regcomp() flags */ -+#define REG_BASIC 0000 -+#define REG_EXTENDED 0001 -+#define REG_ICASE 0002 -+#define REG_NOSUB 0004 -+#define REG_NEWLINE 0010 -+#define REG_NOSPEC 0020 -+#define REG_PEND 0040 -+#define REG_DUMP 0200 -+ -+/* llvm_regerror() flags */ -+#define REG_NOMATCH 1 -+#define REG_BADPAT 2 -+#define REG_ECOLLATE 3 -+#define REG_ECTYPE 4 -+#define REG_EESCAPE 5 -+#define REG_ESUBREG 6 -+#define REG_EBRACK 7 -+#define REG_EPAREN 8 -+#define REG_EBRACE 9 -+#define REG_BADBR 10 -+#define REG_ERANGE 11 -+#define REG_ESPACE 12 -+#define REG_BADRPT 13 -+#define REG_EMPTY 14 -+#define REG_ASSERT 15 -+#define REG_INVARG 16 -+#define REG_ATOI 255 /* convert name to number (!) */ -+#define REG_ITOA 0400 /* convert number to name (!) */ -+ -+/* llvm_regexec() flags */ -+#define REG_NOTBOL 00001 -+#define REG_NOTEOL 00002 -+#define REG_STARTEND 00004 -+#define REG_TRACE 00400 /* tracing of execution */ -+#define REG_LARGE 01000 /* force large representation */ -+#define REG_BACKR 02000 /* force use of backref code */ -+ -+#ifdef __cplusplus -+extern "C" { -+#endif -+ -+int llvm_regcomp(llvm_regex_t *, const char *, int); -+size_t llvm_regerror(int, const llvm_regex_t *, char *, size_t); -+int llvm_regexec(const llvm_regex_t *, const char *, size_t, -+ llvm_regmatch_t [], int); -+void llvm_regfree(llvm_regex_t *); -+size_t llvm_strlcpy(char *dst, const char *src, size_t siz); -+ -+#ifdef __cplusplus -+} -+#endif -+ -+#endif /* !_REGEX_H_ */ -diff -up lldb-3.8.0rc2.src/include/lldb/Utility/regutils.h.dave lldb-3.8.0rc2.src/include/lldb/Utility/regutils.h ---- lldb-3.8.0rc2.src/include/lldb/Utility/regutils.h.dave 2016-02-17 23:19:05.372675749 -0500 -+++ lldb-3.8.0rc2.src/include/lldb/Utility/regutils.h 2016-02-17 23:19:05.372675749 -0500 -@@ -0,0 +1,58 @@ -+/*- -+ * This code is derived from OpenBSD's libc/regex, original license follows: -+ * -+ * Copyright (c) 1992, 1993, 1994 Henry Spencer. -+ * Copyright (c) 1992, 1993, 1994 -+ * The Regents of the University of California. All rights reserved. -+ * -+ * This code is derived from software contributed to Berkeley by -+ * Henry Spencer. -+ * -+ * Redistribution and use in source and binary forms, with or without -+ * modification, are permitted provided that the following conditions -+ * are met: -+ * 1. Redistributions of source code must retain the above copyright -+ * notice, this list of conditions and the following disclaimer. -+ * 2. Redistributions in binary form must reproduce the above copyright -+ * notice, this list of conditions and the following disclaimer in the -+ * documentation and/or other materials provided with the distribution. -+ * 3. Neither the name of the University nor the names of its contributors -+ * may be used to endorse or promote products derived from this software -+ * without specific prior written permission. -+ * -+ * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND -+ * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE -+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE -+ * ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE -+ * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL -+ * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS -+ * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) -+ * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT -+ * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY -+ * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF -+ * SUCH DAMAGE. -+ * -+ * @(#)utils.h 8.3 (Berkeley) 3/20/94 -+ */ -+ -+#ifndef LLVM_SUPPORT_REGUTILS_H -+#define LLVM_SUPPORT_REGUTILS_H -+ -+/* utility definitions */ -+#define NC (CHAR_MAX - CHAR_MIN + 1) -+typedef unsigned char uch; -+ -+/* switch off assertions (if not already off) if no REDEBUG */ -+#ifndef REDEBUG -+#ifndef NDEBUG -+#define NDEBUG /* no assertions please */ -+#endif -+#endif -+#include -+ -+/* for old systems with bcopy() but no memmove() */ -+#ifdef USEBCOPY -+#define memmove(d, s, c) bcopy(s, d, c) -+#endif -+ -+#endif -diff -up lldb-3.8.0rc2.src/scripts/CMakeLists.txt.dave lldb-3.8.0rc2.src/scripts/CMakeLists.txt ---- lldb-3.8.0rc2.src/scripts/CMakeLists.txt.dave 2015-11-18 17:21:47.000000000 -0500 -+++ lldb-3.8.0rc2.src/scripts/CMakeLists.txt 2016-02-17 23:19:05.372675749 -0500 -@@ -9,6 +9,8 @@ set(SWIG_HEADERS - ${LLDB_SOURCE_DIR}/include/lldb/lldb-versioning.h - ) - -+include(FindPythonInterp) -+ - find_package(SWIG REQUIRED) - add_custom_command( - OUTPUT ${CMAKE_CURRENT_BINARY_DIR}/LLDBWrapPython.cpp -diff -up lldb-3.8.0rc2.src/source/Utility/CMakeLists.txt.dave lldb-3.8.0rc2.src/source/Utility/CMakeLists.txt ---- lldb-3.8.0rc2.src/source/Utility/CMakeLists.txt.dave 2015-10-20 08:42:05.000000000 -0400 -+++ lldb-3.8.0rc2.src/source/Utility/CMakeLists.txt 2016-02-17 23:19:05.372675749 -0500 -@@ -1,3 +1,5 @@ -+include_directories(../../include/lldb/Utility) -+ - add_lldb_library(lldbUtility - ARM_DWARF_Registers.cpp - ARM64_DWARF_Registers.cpp -@@ -17,4 +19,9 @@ add_lldb_library(lldbUtility - TaskPool.cpp - TimeSpecTimeout.cpp - UriParser.cpp -+ regcomp.c -+ regerror.c -+ regexec.c -+ regfree.c -+ regstrlcpy.c - ) -diff -up lldb-3.8.0rc2.src/source/Utility/regcomp.c.dave lldb-3.8.0rc2.src/source/Utility/regcomp.c ---- lldb-3.8.0rc2.src/source/Utility/regcomp.c.dave 2016-02-17 23:19:05.372675749 -0500 -+++ lldb-3.8.0rc2.src/source/Utility/regcomp.c 2016-02-17 23:19:05.372675749 -0500 -@@ -0,0 +1,1570 @@ -+/*- -+ * This code is derived from OpenBSD's libc/regex, original license follows: -+ * -+ * Copyright (c) 1992, 1993, 1994 Henry Spencer. -+ * Copyright (c) 1992, 1993, 1994 -+ * The Regents of the University of California. All rights reserved. -+ * -+ * This code is derived from software contributed to Berkeley by -+ * Henry Spencer. -+ * -+ * Redistribution and use in source and binary forms, with or without -+ * modification, are permitted provided that the following conditions -+ * are met: -+ * 1. Redistributions of source code must retain the above copyright -+ * notice, this list of conditions and the following disclaimer. -+ * 2. Redistributions in binary form must reproduce the above copyright -+ * notice, this list of conditions and the following disclaimer in the -+ * documentation and/or other materials provided with the distribution. -+ * 3. Neither the name of the University nor the names of its contributors -+ * may be used to endorse or promote products derived from this software -+ * without specific prior written permission. -+ * -+ * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND -+ * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE -+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE -+ * ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE -+ * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL -+ * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS -+ * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) -+ * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT -+ * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY -+ * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF -+ * SUCH DAMAGE. -+ * -+ * @(#)regcomp.c 8.5 (Berkeley) 3/20/94 -+ */ -+ -+#include -+#include -+#include -+#include -+#include -+#include -+#include "regex_impl.h" -+ -+#include "regutils.h" -+#include "regex2.h" -+ -+#include "regcclass.h" -+#include "regcname.h" -+ -+#include -+/* Pessimistically bound memory use */ -+#define SIZE_MAX UINT_MAX -+ -+/* -+ * parse structure, passed up and down to avoid global variables and -+ * other clumsinesses -+ */ -+struct parse { -+ char *next; /* next character in RE */ -+ char *end; /* end of string (-> NUL normally) */ -+ int error; /* has an error been seen? */ -+ sop *strip; /* malloced strip */ -+ sopno ssize; /* malloced strip size (allocated) */ -+ sopno slen; /* malloced strip length (used) */ -+ int ncsalloc; /* number of csets allocated */ -+ struct re_guts *g; -+# define NPAREN 10 /* we need to remember () 1-9 for back refs */ -+ sopno pbegin[NPAREN]; /* -> ( ([0] unused) */ -+ sopno pend[NPAREN]; /* -> ) ([0] unused) */ -+}; -+ -+static void p_ere(struct parse *, int); -+static void p_ere_exp(struct parse *); -+static void p_str(struct parse *); -+static void p_bre(struct parse *, int, int); -+static int p_simp_re(struct parse *, int); -+static int p_count(struct parse *); -+static void p_bracket(struct parse *); -+static void p_b_term(struct parse *, cset *); -+static void p_b_cclass(struct parse *, cset *); -+static void p_b_eclass(struct parse *, cset *); -+static char p_b_symbol(struct parse *); -+static char p_b_coll_elem(struct parse *, int); -+static char othercase(int); -+static void bothcases(struct parse *, int); -+static void ordinary(struct parse *, int); -+static void nonnewline(struct parse *); -+static void repeat(struct parse *, sopno, int, int); -+static int seterr(struct parse *, int); -+static cset *allocset(struct parse *); -+static void freeset(struct parse *, cset *); -+static int freezeset(struct parse *, cset *); -+static int firstch(struct parse *, cset *); -+static int nch(struct parse *, cset *); -+static void mcadd(struct parse *, cset *, const char *); -+static void mcinvert(struct parse *, cset *); -+static void mccase(struct parse *, cset *); -+static int isinsets(struct re_guts *, int); -+static int samesets(struct re_guts *, int, int); -+static void categorize(struct parse *, struct re_guts *); -+static sopno dupl(struct parse *, sopno, sopno); -+static void doemit(struct parse *, sop, size_t); -+static void doinsert(struct parse *, sop, size_t, sopno); -+static void dofwd(struct parse *, sopno, sop); -+static void enlarge(struct parse *, sopno); -+static void stripsnug(struct parse *, struct re_guts *); -+static void findmust(struct parse *, struct re_guts *); -+static sopno pluscount(struct parse *, struct re_guts *); -+ -+static char nuls[10]; /* place to point scanner in event of error */ -+ -+/* -+ * macros for use with parse structure -+ * BEWARE: these know that the parse structure is named `p' !!! -+ */ -+#define PEEK() (*p->next) -+#define PEEK2() (*(p->next+1)) -+#define MORE() (p->next < p->end) -+#define MORE2() (p->next+1 < p->end) -+#define SEE(c) (MORE() && PEEK() == (c)) -+#define SEETWO(a, b) (MORE() && MORE2() && PEEK() == (a) && PEEK2() == (b)) -+#define EAT(c) ((SEE(c)) ? (NEXT(), 1) : 0) -+#define EATTWO(a, b) ((SEETWO(a, b)) ? (NEXT2(), 1) : 0) -+#define NEXT() (p->next++) -+#define NEXT2() (p->next += 2) -+#define NEXTn(n) (p->next += (n)) -+#define GETNEXT() (*p->next++) -+#define SETERROR(e) seterr(p, (e)) -+#define REQUIRE(co, e) (void)((co) || SETERROR(e)) -+#define MUSTSEE(c, e) (REQUIRE(MORE() && PEEK() == (c), e)) -+#define MUSTEAT(c, e) (REQUIRE(MORE() && GETNEXT() == (c), e)) -+#define MUSTNOTSEE(c, e) (REQUIRE(!MORE() || PEEK() != (c), e)) -+#define EMIT(op, sopnd) doemit(p, (sop)(op), (size_t)(sopnd)) -+#define INSERT(op, pos) doinsert(p, (sop)(op), HERE()-(pos)+1, pos) -+#define AHEAD(pos) dofwd(p, pos, HERE()-(pos)) -+#define ASTERN(sop, pos) EMIT(sop, HERE()-pos) -+#define HERE() (p->slen) -+#define THERE() (p->slen - 1) -+#define THERETHERE() (p->slen - 2) -+#define DROP(n) (p->slen -= (n)) -+ -+#ifdef _POSIX2_RE_DUP_MAX -+#define DUPMAX _POSIX2_RE_DUP_MAX -+#else -+#define DUPMAX 255 -+#endif -+#define INFINITY (DUPMAX + 1) -+ -+#ifndef NDEBUG -+static int never = 0; /* for use in asserts; shuts lint up */ -+#else -+#define never 0 /* some s have bugs too */ -+#endif -+ -+/* -+ - llvm_regcomp - interface for parser and compilation -+ */ -+int /* 0 success, otherwise REG_something */ -+llvm_regcomp(llvm_regex_t *preg, const char *pattern, int cflags) -+{ -+ struct parse pa; -+ struct re_guts *g; -+ struct parse *p = &pa; -+ int i; -+ size_t len; -+#ifdef REDEBUG -+# define GOODFLAGS(f) (f) -+#else -+# define GOODFLAGS(f) ((f)&~REG_DUMP) -+#endif -+ -+ cflags = GOODFLAGS(cflags); -+ if ((cflags®_EXTENDED) && (cflags®_NOSPEC)) -+ return(REG_INVARG); -+ -+ if (cflags®_PEND) { -+ if (preg->re_endp < pattern) -+ return(REG_INVARG); -+ len = preg->re_endp - pattern; -+ } else -+ len = strlen((const char *)pattern); -+ -+ /* do the mallocs early so failure handling is easy */ -+ g = (struct re_guts *)malloc(sizeof(struct re_guts) + -+ (NC-1)*sizeof(cat_t)); -+ if (g == NULL) -+ return(REG_ESPACE); -+ p->ssize = len/(size_t)2*(size_t)3 + (size_t)1; /* ugh */ -+ p->strip = (sop *)calloc(p->ssize, sizeof(sop)); -+ p->slen = 0; -+ if (p->strip == NULL) { -+ free((char *)g); -+ return(REG_ESPACE); -+ } -+ -+ /* set things up */ -+ p->g = g; -+ p->next = (char *)pattern; /* convenience; we do not modify it */ -+ p->end = p->next + len; -+ p->error = 0; -+ p->ncsalloc = 0; -+ for (i = 0; i < NPAREN; i++) { -+ p->pbegin[i] = 0; -+ p->pend[i] = 0; -+ } -+ g->csetsize = NC; -+ g->sets = NULL; -+ g->setbits = NULL; -+ g->ncsets = 0; -+ g->cflags = cflags; -+ g->iflags = 0; -+ g->nbol = 0; -+ g->neol = 0; -+ g->must = NULL; -+ g->mlen = 0; -+ g->nsub = 0; -+ g->ncategories = 1; /* category 0 is "everything else" */ -+ g->categories = &g->catspace[-(CHAR_MIN)]; -+ (void) memset((char *)g->catspace, 0, NC*sizeof(cat_t)); -+ g->backrefs = 0; -+ -+ /* do it */ -+ EMIT(OEND, 0); -+ g->firststate = THERE(); -+ if (cflags®_EXTENDED) -+ p_ere(p, OUT); -+ else if (cflags®_NOSPEC) -+ p_str(p); -+ else -+ p_bre(p, OUT, OUT); -+ EMIT(OEND, 0); -+ g->laststate = THERE(); -+ -+ /* tidy up loose ends and fill things in */ -+ categorize(p, g); -+ stripsnug(p, g); -+ findmust(p, g); -+ g->nplus = pluscount(p, g); -+ g->magic = MAGIC2; -+ preg->re_nsub = g->nsub; -+ preg->re_g = g; -+ preg->re_magic = MAGIC1; -+#ifndef REDEBUG -+ /* not debugging, so can't rely on the assert() in llvm_regexec() */ -+ if (g->iflags®EX_BAD) -+ SETERROR(REG_ASSERT); -+#endif -+ -+ /* win or lose, we're done */ -+ if (p->error != 0) /* lose */ -+ llvm_regfree(preg); -+ return(p->error); -+} -+ -+/* -+ - p_ere - ERE parser top level, concatenation and alternation -+ */ -+static void -+p_ere(struct parse *p, int stop) /* character this ERE should end at */ -+{ -+ char c; -+ sopno prevback = 0; -+ sopno prevfwd = 0; -+ sopno conc; -+ int first = 1; /* is this the first alternative? */ -+ -+ for (;;) { -+ /* do a bunch of concatenated expressions */ -+ conc = HERE(); -+ while (MORE() && (c = PEEK()) != '|' && c != stop) -+ p_ere_exp(p); -+ REQUIRE(HERE() != conc, REG_EMPTY); /* require nonempty */ -+ -+ if (!EAT('|')) -+ break; /* NOTE BREAK OUT */ -+ -+ if (first) { -+ INSERT(OCH_, conc); /* offset is wrong */ -+ prevfwd = conc; -+ prevback = conc; -+ first = 0; -+ } -+ ASTERN(OOR1, prevback); -+ prevback = THERE(); -+ AHEAD(prevfwd); /* fix previous offset */ -+ prevfwd = HERE(); -+ EMIT(OOR2, 0); /* offset is very wrong */ -+ } -+ -+ if (!first) { /* tail-end fixups */ -+ AHEAD(prevfwd); -+ ASTERN(O_CH, prevback); -+ } -+ -+ assert(!MORE() || SEE(stop)); -+} -+ -+/* -+ - p_ere_exp - parse one subERE, an atom possibly followed by a repetition op -+ */ -+static void -+p_ere_exp(struct parse *p) -+{ -+ char c; -+ sopno pos; -+ int count; -+ int count2; -+ int backrefnum; -+ sopno subno; -+ int wascaret = 0; -+ -+ assert(MORE()); /* caller should have ensured this */ -+ c = GETNEXT(); -+ -+ pos = HERE(); -+ switch (c) { -+ case '(': -+ REQUIRE(MORE(), REG_EPAREN); -+ p->g->nsub++; -+ subno = p->g->nsub; -+ if (subno < NPAREN) -+ p->pbegin[subno] = HERE(); -+ EMIT(OLPAREN, subno); -+ if (!SEE(')')) -+ p_ere(p, ')'); -+ if (subno < NPAREN) { -+ p->pend[subno] = HERE(); -+ assert(p->pend[subno] != 0); -+ } -+ EMIT(ORPAREN, subno); -+ MUSTEAT(')', REG_EPAREN); -+ break; -+#ifndef POSIX_MISTAKE -+ case ')': /* happens only if no current unmatched ( */ -+ /* -+ * You may ask, why the ifndef? Because I didn't notice -+ * this until slightly too late for 1003.2, and none of the -+ * other 1003.2 regular-expression reviewers noticed it at -+ * all. So an unmatched ) is legal POSIX, at least until -+ * we can get it fixed. -+ */ -+ SETERROR(REG_EPAREN); -+ break; -+#endif -+ case '^': -+ EMIT(OBOL, 0); -+ p->g->iflags |= USEBOL; -+ p->g->nbol++; -+ wascaret = 1; -+ break; -+ case '$': -+ EMIT(OEOL, 0); -+ p->g->iflags |= USEEOL; -+ p->g->neol++; -+ break; -+ case '|': -+ SETERROR(REG_EMPTY); -+ break; -+ case '*': -+ case '+': -+ case '?': -+ SETERROR(REG_BADRPT); -+ break; -+ case '.': -+ if (p->g->cflags®_NEWLINE) -+ nonnewline(p); -+ else -+ EMIT(OANY, 0); -+ break; -+ case '[': -+ p_bracket(p); -+ break; -+ case '\\': -+ REQUIRE(MORE(), REG_EESCAPE); -+ c = GETNEXT(); -+ if (c >= '1' && c <= '9') { -+ /* \[0-9] is taken to be a back-reference to a previously specified -+ * matching group. backrefnum will hold the number. The matching -+ * group must exist (i.e. if \4 is found there must have been at -+ * least 4 matching groups specified in the pattern previously). -+ */ -+ backrefnum = c - '0'; -+ if (p->pend[backrefnum] == 0) { -+ SETERROR(REG_ESUBREG); -+ break; -+ } -+ -+ /* Make sure everything checks out and emit the sequence -+ * that marks a back-reference to the parse structure. -+ */ -+ assert(backrefnum <= p->g->nsub); -+ EMIT(OBACK_, backrefnum); -+ assert(p->pbegin[backrefnum] != 0); -+ assert(OP(p->strip[p->pbegin[backrefnum]]) != OLPAREN); -+ assert(OP(p->strip[p->pend[backrefnum]]) != ORPAREN); -+ (void) dupl(p, p->pbegin[backrefnum]+1, p->pend[backrefnum]); -+ EMIT(O_BACK, backrefnum); -+ p->g->backrefs = 1; -+ } else { -+ /* Other chars are simply themselves when escaped with a backslash. -+ */ -+ ordinary(p, c); -+ } -+ break; -+ case '{': /* okay as ordinary except if digit follows */ -+ REQUIRE(!MORE() || !isdigit((uch)PEEK()), REG_BADRPT); -+ /* FALLTHROUGH */ -+ default: -+ ordinary(p, c); -+ break; -+ } -+ -+ if (!MORE()) -+ return; -+ c = PEEK(); -+ /* we call { a repetition if followed by a digit */ -+ if (!( c == '*' || c == '+' || c == '?' || -+ (c == '{' && MORE2() && isdigit((uch)PEEK2())) )) -+ return; /* no repetition, we're done */ -+ NEXT(); -+ -+ REQUIRE(!wascaret, REG_BADRPT); -+ switch (c) { -+ case '*': /* implemented as +? */ -+ /* this case does not require the (y|) trick, noKLUDGE */ -+ INSERT(OPLUS_, pos); -+ ASTERN(O_PLUS, pos); -+ INSERT(OQUEST_, pos); -+ ASTERN(O_QUEST, pos); -+ break; -+ case '+': -+ INSERT(OPLUS_, pos); -+ ASTERN(O_PLUS, pos); -+ break; -+ case '?': -+ /* KLUDGE: emit y? as (y|) until subtle bug gets fixed */ -+ INSERT(OCH_, pos); /* offset slightly wrong */ -+ ASTERN(OOR1, pos); /* this one's right */ -+ AHEAD(pos); /* fix the OCH_ */ -+ EMIT(OOR2, 0); /* offset very wrong... */ -+ AHEAD(THERE()); /* ...so fix it */ -+ ASTERN(O_CH, THERETHERE()); -+ break; -+ case '{': -+ count = p_count(p); -+ if (EAT(',')) { -+ if (isdigit((uch)PEEK())) { -+ count2 = p_count(p); -+ REQUIRE(count <= count2, REG_BADBR); -+ } else /* single number with comma */ -+ count2 = INFINITY; -+ } else /* just a single number */ -+ count2 = count; -+ repeat(p, pos, count, count2); -+ if (!EAT('}')) { /* error heuristics */ -+ while (MORE() && PEEK() != '}') -+ NEXT(); -+ REQUIRE(MORE(), REG_EBRACE); -+ SETERROR(REG_BADBR); -+ } -+ break; -+ } -+ -+ if (!MORE()) -+ return; -+ c = PEEK(); -+ if (!( c == '*' || c == '+' || c == '?' || -+ (c == '{' && MORE2() && isdigit((uch)PEEK2())) ) ) -+ return; -+ SETERROR(REG_BADRPT); -+} -+ -+/* -+ - p_str - string (no metacharacters) "parser" -+ */ -+static void -+p_str(struct parse *p) -+{ -+ REQUIRE(MORE(), REG_EMPTY); -+ while (MORE()) -+ ordinary(p, GETNEXT()); -+} -+ -+/* -+ - p_bre - BRE parser top level, anchoring and concatenation -+ * Giving end1 as OUT essentially eliminates the end1/end2 check. -+ * -+ * This implementation is a bit of a kludge, in that a trailing $ is first -+ * taken as an ordinary character and then revised to be an anchor. The -+ * only undesirable side effect is that '$' gets included as a character -+ * category in such cases. This is fairly harmless; not worth fixing. -+ * The amount of lookahead needed to avoid this kludge is excessive. -+ */ -+static void -+p_bre(struct parse *p, -+ int end1, /* first terminating character */ -+ int end2) /* second terminating character */ -+{ -+ sopno start = HERE(); -+ int first = 1; /* first subexpression? */ -+ int wasdollar = 0; -+ -+ if (EAT('^')) { -+ EMIT(OBOL, 0); -+ p->g->iflags |= USEBOL; -+ p->g->nbol++; -+ } -+ while (MORE() && !SEETWO(end1, end2)) { -+ wasdollar = p_simp_re(p, first); -+ first = 0; -+ } -+ if (wasdollar) { /* oops, that was a trailing anchor */ -+ DROP(1); -+ EMIT(OEOL, 0); -+ p->g->iflags |= USEEOL; -+ p->g->neol++; -+ } -+ -+ REQUIRE(HERE() != start, REG_EMPTY); /* require nonempty */ -+} -+ -+/* -+ - p_simp_re - parse a simple RE, an atom possibly followed by a repetition -+ */ -+static int /* was the simple RE an unbackslashed $? */ -+p_simp_re(struct parse *p, -+ int starordinary) /* is a leading * an ordinary character? */ -+{ -+ int c; -+ int count; -+ int count2; -+ sopno pos; -+ int i; -+ sopno subno; -+# define BACKSL (1<g->cflags®_NEWLINE) -+ nonnewline(p); -+ else -+ EMIT(OANY, 0); -+ break; -+ case '[': -+ p_bracket(p); -+ break; -+ case BACKSL|'{': -+ SETERROR(REG_BADRPT); -+ break; -+ case BACKSL|'(': -+ p->g->nsub++; -+ subno = p->g->nsub; -+ if (subno < NPAREN) -+ p->pbegin[subno] = HERE(); -+ EMIT(OLPAREN, subno); -+ /* the MORE here is an error heuristic */ -+ if (MORE() && !SEETWO('\\', ')')) -+ p_bre(p, '\\', ')'); -+ if (subno < NPAREN) { -+ p->pend[subno] = HERE(); -+ assert(p->pend[subno] != 0); -+ } -+ EMIT(ORPAREN, subno); -+ REQUIRE(EATTWO('\\', ')'), REG_EPAREN); -+ break; -+ case BACKSL|')': /* should not get here -- must be user */ -+ case BACKSL|'}': -+ SETERROR(REG_EPAREN); -+ break; -+ case BACKSL|'1': -+ case BACKSL|'2': -+ case BACKSL|'3': -+ case BACKSL|'4': -+ case BACKSL|'5': -+ case BACKSL|'6': -+ case BACKSL|'7': -+ case BACKSL|'8': -+ case BACKSL|'9': -+ i = (c&~BACKSL) - '0'; -+ assert(i < NPAREN); -+ if (p->pend[i] != 0) { -+ assert(i <= p->g->nsub); -+ EMIT(OBACK_, i); -+ assert(p->pbegin[i] != 0); -+ assert(OP(p->strip[p->pbegin[i]]) == OLPAREN); -+ assert(OP(p->strip[p->pend[i]]) == ORPAREN); -+ (void) dupl(p, p->pbegin[i]+1, p->pend[i]); -+ EMIT(O_BACK, i); -+ } else -+ SETERROR(REG_ESUBREG); -+ p->g->backrefs = 1; -+ break; -+ case '*': -+ REQUIRE(starordinary, REG_BADRPT); -+ /* FALLTHROUGH */ -+ default: -+ ordinary(p, (char)c); -+ break; -+ } -+ -+ if (EAT('*')) { /* implemented as +? */ -+ /* this case does not require the (y|) trick, noKLUDGE */ -+ INSERT(OPLUS_, pos); -+ ASTERN(O_PLUS, pos); -+ INSERT(OQUEST_, pos); -+ ASTERN(O_QUEST, pos); -+ } else if (EATTWO('\\', '{')) { -+ count = p_count(p); -+ if (EAT(',')) { -+ if (MORE() && isdigit((uch)PEEK())) { -+ count2 = p_count(p); -+ REQUIRE(count <= count2, REG_BADBR); -+ } else /* single number with comma */ -+ count2 = INFINITY; -+ } else /* just a single number */ -+ count2 = count; -+ repeat(p, pos, count, count2); -+ if (!EATTWO('\\', '}')) { /* error heuristics */ -+ while (MORE() && !SEETWO('\\', '}')) -+ NEXT(); -+ REQUIRE(MORE(), REG_EBRACE); -+ SETERROR(REG_BADBR); -+ } -+ } else if (c == '$') /* $ (but not \$) ends it */ -+ return(1); -+ -+ return(0); -+} -+ -+/* -+ - p_count - parse a repetition count -+ */ -+static int /* the value */ -+p_count(struct parse *p) -+{ -+ int count = 0; -+ int ndigits = 0; -+ -+ while (MORE() && isdigit((uch)PEEK()) && count <= DUPMAX) { -+ count = count*10 + (GETNEXT() - '0'); -+ ndigits++; -+ } -+ -+ REQUIRE(ndigits > 0 && count <= DUPMAX, REG_BADBR); -+ return(count); -+} -+ -+/* -+ - p_bracket - parse a bracketed character list -+ * -+ * Note a significant property of this code: if the allocset() did SETERROR, -+ * no set operations are done. -+ */ -+static void -+p_bracket(struct parse *p) -+{ -+ cset *cs; -+ int invert = 0; -+ -+ /* Dept of Truly Sickening Special-Case Kludges */ -+ if (p->next + 5 < p->end && strncmp(p->next, "[:<:]]", 6) == 0) { -+ EMIT(OBOW, 0); -+ NEXTn(6); -+ return; -+ } -+ if (p->next + 5 < p->end && strncmp(p->next, "[:>:]]", 6) == 0) { -+ EMIT(OEOW, 0); -+ NEXTn(6); -+ return; -+ } -+ -+ if ((cs = allocset(p)) == NULL) { -+ /* allocset did set error status in p */ -+ return; -+ } -+ -+ if (EAT('^')) -+ invert++; /* make note to invert set at end */ -+ if (EAT(']')) -+ CHadd(cs, ']'); -+ else if (EAT('-')) -+ CHadd(cs, '-'); -+ while (MORE() && PEEK() != ']' && !SEETWO('-', ']')) -+ p_b_term(p, cs); -+ if (EAT('-')) -+ CHadd(cs, '-'); -+ MUSTEAT(']', REG_EBRACK); -+ -+ if (p->error != 0) { /* don't mess things up further */ -+ freeset(p, cs); -+ return; -+ } -+ -+ if (p->g->cflags®_ICASE) { -+ int i; -+ int ci; -+ -+ for (i = p->g->csetsize - 1; i >= 0; i--) -+ if (CHIN(cs, i) && isalpha(i)) { -+ ci = othercase(i); -+ if (ci != i) -+ CHadd(cs, ci); -+ } -+ if (cs->multis != NULL) -+ mccase(p, cs); -+ } -+ if (invert) { -+ int i; -+ -+ for (i = p->g->csetsize - 1; i >= 0; i--) -+ if (CHIN(cs, i)) -+ CHsub(cs, i); -+ else -+ CHadd(cs, i); -+ if (p->g->cflags®_NEWLINE) -+ CHsub(cs, '\n'); -+ if (cs->multis != NULL) -+ mcinvert(p, cs); -+ } -+ -+ assert(cs->multis == NULL); /* xxx */ -+ -+ if (nch(p, cs) == 1) { /* optimize singleton sets */ -+ ordinary(p, firstch(p, cs)); -+ freeset(p, cs); -+ } else -+ EMIT(OANYOF, freezeset(p, cs)); -+} -+ -+/* -+ - p_b_term - parse one term of a bracketed character list -+ */ -+static void -+p_b_term(struct parse *p, cset *cs) -+{ -+ char c; -+ char start, finish; -+ int i; -+ -+ /* classify what we've got */ -+ switch ((MORE()) ? PEEK() : '\0') { -+ case '[': -+ c = (MORE2()) ? PEEK2() : '\0'; -+ break; -+ case '-': -+ SETERROR(REG_ERANGE); -+ return; /* NOTE RETURN */ -+ break; -+ default: -+ c = '\0'; -+ break; -+ } -+ -+ switch (c) { -+ case ':': /* character class */ -+ NEXT2(); -+ REQUIRE(MORE(), REG_EBRACK); -+ c = PEEK(); -+ REQUIRE(c != '-' && c != ']', REG_ECTYPE); -+ p_b_cclass(p, cs); -+ REQUIRE(MORE(), REG_EBRACK); -+ REQUIRE(EATTWO(':', ']'), REG_ECTYPE); -+ break; -+ case '=': /* equivalence class */ -+ NEXT2(); -+ REQUIRE(MORE(), REG_EBRACK); -+ c = PEEK(); -+ REQUIRE(c != '-' && c != ']', REG_ECOLLATE); -+ p_b_eclass(p, cs); -+ REQUIRE(MORE(), REG_EBRACK); -+ REQUIRE(EATTWO('=', ']'), REG_ECOLLATE); -+ break; -+ default: /* symbol, ordinary character, or range */ -+/* xxx revision needed for multichar stuff */ -+ start = p_b_symbol(p); -+ if (SEE('-') && MORE2() && PEEK2() != ']') { -+ /* range */ -+ NEXT(); -+ if (EAT('-')) -+ finish = '-'; -+ else -+ finish = p_b_symbol(p); -+ } else -+ finish = start; -+/* xxx what about signed chars here... */ -+ REQUIRE(start <= finish, REG_ERANGE); -+ for (i = start; i <= finish; i++) -+ CHadd(cs, i); -+ break; -+ } -+} -+ -+/* -+ - p_b_cclass - parse a character-class name and deal with it -+ */ -+static void -+p_b_cclass(struct parse *p, cset *cs) -+{ -+ char *sp = p->next; -+ struct cclass *cp; -+ size_t len; -+ const char *u; -+ char c; -+ -+ while (MORE() && isalpha((uch)PEEK())) -+ NEXT(); -+ len = p->next - sp; -+ for (cp = cclasses; cp->name != NULL; cp++) -+ if (strncmp(cp->name, sp, len) == 0 && cp->name[len] == '\0') -+ break; -+ if (cp->name == NULL) { -+ /* oops, didn't find it */ -+ SETERROR(REG_ECTYPE); -+ return; -+ } -+ -+ u = cp->chars; -+ while ((c = *u++) != '\0') -+ CHadd(cs, c); -+ for (u = cp->multis; *u != '\0'; u += strlen(u) + 1) -+ MCadd(p, cs, u); -+} -+ -+/* -+ - p_b_eclass - parse an equivalence-class name and deal with it -+ * -+ * This implementation is incomplete. xxx -+ */ -+static void -+p_b_eclass(struct parse *p, cset *cs) -+{ -+ char c; -+ -+ c = p_b_coll_elem(p, '='); -+ CHadd(cs, c); -+} -+ -+/* -+ - p_b_symbol - parse a character or [..]ed multicharacter collating symbol -+ */ -+static char /* value of symbol */ -+p_b_symbol(struct parse *p) -+{ -+ char value; -+ -+ REQUIRE(MORE(), REG_EBRACK); -+ if (!EATTWO('[', '.')) -+ return(GETNEXT()); -+ -+ /* collating symbol */ -+ value = p_b_coll_elem(p, '.'); -+ REQUIRE(EATTWO('.', ']'), REG_ECOLLATE); -+ return(value); -+} -+ -+/* -+ - p_b_coll_elem - parse a collating-element name and look it up -+ */ -+static char /* value of collating element */ -+p_b_coll_elem(struct parse *p, -+ int endc) /* name ended by endc,']' */ -+{ -+ char *sp = p->next; -+ struct cname *cp; -+ int len; -+ -+ while (MORE() && !SEETWO(endc, ']')) -+ NEXT(); -+ if (!MORE()) { -+ SETERROR(REG_EBRACK); -+ return(0); -+ } -+ len = p->next - sp; -+ for (cp = cnames; cp->name != NULL; cp++) -+ if (strncmp(cp->name, sp, len) == 0 && cp->name[len] == '\0') -+ return(cp->code); /* known name */ -+ if (len == 1) -+ return(*sp); /* single character */ -+ SETERROR(REG_ECOLLATE); /* neither */ -+ return(0); -+} -+ -+/* -+ - othercase - return the case counterpart of an alphabetic -+ */ -+static char /* if no counterpart, return ch */ -+othercase(int ch) -+{ -+ ch = (uch)ch; -+ assert(isalpha(ch)); -+ if (isupper(ch)) -+ return ((uch)tolower(ch)); -+ else if (islower(ch)) -+ return ((uch)toupper(ch)); -+ else /* peculiar, but could happen */ -+ return(ch); -+} -+ -+/* -+ - bothcases - emit a dualcase version of a two-case character -+ * -+ * Boy, is this implementation ever a kludge... -+ */ -+static void -+bothcases(struct parse *p, int ch) -+{ -+ char *oldnext = p->next; -+ char *oldend = p->end; -+ char bracket[3]; -+ -+ ch = (uch)ch; -+ assert(othercase(ch) != ch); /* p_bracket() would recurse */ -+ p->next = bracket; -+ p->end = bracket+2; -+ bracket[0] = ch; -+ bracket[1] = ']'; -+ bracket[2] = '\0'; -+ p_bracket(p); -+ assert(p->next == bracket+2); -+ p->next = oldnext; -+ p->end = oldend; -+} -+ -+/* -+ - ordinary - emit an ordinary character -+ */ -+static void -+ordinary(struct parse *p, int ch) -+{ -+ cat_t *cap = p->g->categories; -+ -+ if ((p->g->cflags®_ICASE) && isalpha((uch)ch) && othercase(ch) != ch) -+ bothcases(p, ch); -+ else { -+ EMIT(OCHAR, (uch)ch); -+ if (cap[ch] == 0) -+ cap[ch] = p->g->ncategories++; -+ } -+} -+ -+/* -+ - nonnewline - emit REG_NEWLINE version of OANY -+ * -+ * Boy, is this implementation ever a kludge... -+ */ -+static void -+nonnewline(struct parse *p) -+{ -+ char *oldnext = p->next; -+ char *oldend = p->end; -+ char bracket[4]; -+ -+ p->next = bracket; -+ p->end = bracket+3; -+ bracket[0] = '^'; -+ bracket[1] = '\n'; -+ bracket[2] = ']'; -+ bracket[3] = '\0'; -+ p_bracket(p); -+ assert(p->next == bracket+3); -+ p->next = oldnext; -+ p->end = oldend; -+} -+ -+/* -+ - repeat - generate code for a bounded repetition, recursively if needed -+ */ -+static void -+repeat(struct parse *p, -+ sopno start, /* operand from here to end of strip */ -+ int from, /* repeated from this number */ -+ int to) /* to this number of times (maybe INFINITY) */ -+{ -+ sopno finish = HERE(); -+# define N 2 -+# define INF 3 -+# define REP(f, t) ((f)*8 + (t)) -+# define MAP(n) (((n) <= 1) ? (n) : ((n) == INFINITY) ? INF : N) -+ sopno copy; -+ -+ if (p->error != 0) /* head off possible runaway recursion */ -+ return; -+ -+ assert(from <= to); -+ -+ switch (REP(MAP(from), MAP(to))) { -+ case REP(0, 0): /* must be user doing this */ -+ DROP(finish-start); /* drop the operand */ -+ break; -+ case REP(0, 1): /* as x{1,1}? */ -+ case REP(0, N): /* as x{1,n}? */ -+ case REP(0, INF): /* as x{1,}? */ -+ /* KLUDGE: emit y? as (y|) until subtle bug gets fixed */ -+ INSERT(OCH_, start); /* offset is wrong... */ -+ repeat(p, start+1, 1, to); -+ ASTERN(OOR1, start); -+ AHEAD(start); /* ... fix it */ -+ EMIT(OOR2, 0); -+ AHEAD(THERE()); -+ ASTERN(O_CH, THERETHERE()); -+ break; -+ case REP(1, 1): /* trivial case */ -+ /* done */ -+ break; -+ case REP(1, N): /* as x?x{1,n-1} */ -+ /* KLUDGE: emit y? as (y|) until subtle bug gets fixed */ -+ INSERT(OCH_, start); -+ ASTERN(OOR1, start); -+ AHEAD(start); -+ EMIT(OOR2, 0); /* offset very wrong... */ -+ AHEAD(THERE()); /* ...so fix it */ -+ ASTERN(O_CH, THERETHERE()); -+ copy = dupl(p, start+1, finish+1); -+ assert(copy == finish+4); -+ repeat(p, copy, 1, to-1); -+ break; -+ case REP(1, INF): /* as x+ */ -+ INSERT(OPLUS_, start); -+ ASTERN(O_PLUS, start); -+ break; -+ case REP(N, N): /* as xx{m-1,n-1} */ -+ copy = dupl(p, start, finish); -+ repeat(p, copy, from-1, to-1); -+ break; -+ case REP(N, INF): /* as xx{n-1,INF} */ -+ copy = dupl(p, start, finish); -+ repeat(p, copy, from-1, to); -+ break; -+ default: /* "can't happen" */ -+ SETERROR(REG_ASSERT); /* just in case */ -+ break; -+ } -+} -+ -+/* -+ - seterr - set an error condition -+ */ -+static int /* useless but makes type checking happy */ -+seterr(struct parse *p, int e) -+{ -+ if (p->error == 0) /* keep earliest error condition */ -+ p->error = e; -+ p->next = nuls; /* try to bring things to a halt */ -+ p->end = nuls; -+ return(0); /* make the return value well-defined */ -+} -+ -+/* -+ - allocset - allocate a set of characters for [] -+ */ -+static cset * -+allocset(struct parse *p) -+{ -+ int no = p->g->ncsets++; -+ size_t nc; -+ size_t nbytes; -+ cset *cs; -+ size_t css = (size_t)p->g->csetsize; -+ int i; -+ -+ if (no >= p->ncsalloc) { /* need another column of space */ -+ void *ptr; -+ -+ p->ncsalloc += CHAR_BIT; -+ nc = p->ncsalloc; -+ if (nc > SIZE_MAX / sizeof(cset)) -+ goto nomem; -+ assert(nc % CHAR_BIT == 0); -+ nbytes = nc / CHAR_BIT * css; -+ -+ ptr = (cset *)realloc((char *)p->g->sets, nc * sizeof(cset)); -+ if (ptr == NULL) -+ goto nomem; -+ p->g->sets = ptr; -+ -+ ptr = (uch *)realloc((char *)p->g->setbits, nbytes); -+ if (ptr == NULL) -+ goto nomem; -+ p->g->setbits = ptr; -+ -+ for (i = 0; i < no; i++) -+ p->g->sets[i].ptr = p->g->setbits + css*(i/CHAR_BIT); -+ -+ (void) memset((char *)p->g->setbits + (nbytes - css), 0, css); -+ } -+ /* XXX should not happen */ -+ if (p->g->sets == NULL || p->g->setbits == NULL) -+ goto nomem; -+ -+ cs = &p->g->sets[no]; -+ cs->ptr = p->g->setbits + css*((no)/CHAR_BIT); -+ cs->mask = 1 << ((no) % CHAR_BIT); -+ cs->hash = 0; -+ cs->smultis = 0; -+ cs->multis = NULL; -+ -+ return(cs); -+nomem: -+ free(p->g->sets); -+ p->g->sets = NULL; -+ free(p->g->setbits); -+ p->g->setbits = NULL; -+ -+ SETERROR(REG_ESPACE); -+ /* caller's responsibility not to do set ops */ -+ return(NULL); -+} -+ -+/* -+ - freeset - free a now-unused set -+ */ -+static void -+freeset(struct parse *p, cset *cs) -+{ -+ size_t i; -+ cset *top = &p->g->sets[p->g->ncsets]; -+ size_t css = (size_t)p->g->csetsize; -+ -+ for (i = 0; i < css; i++) -+ CHsub(cs, i); -+ if (cs == top-1) /* recover only the easy case */ -+ p->g->ncsets--; -+} -+ -+/* -+ - freezeset - final processing on a set of characters -+ * -+ * The main task here is merging identical sets. This is usually a waste -+ * of time (although the hash code minimizes the overhead), but can win -+ * big if REG_ICASE is being used. REG_ICASE, by the way, is why the hash -+ * is done using addition rather than xor -- all ASCII [aA] sets xor to -+ * the same value! -+ */ -+static int /* set number */ -+freezeset(struct parse *p, cset *cs) -+{ -+ uch h = cs->hash; -+ size_t i; -+ cset *top = &p->g->sets[p->g->ncsets]; -+ cset *cs2; -+ size_t css = (size_t)p->g->csetsize; -+ -+ /* look for an earlier one which is the same */ -+ for (cs2 = &p->g->sets[0]; cs2 < top; cs2++) -+ if (cs2->hash == h && cs2 != cs) { -+ /* maybe */ -+ for (i = 0; i < css; i++) -+ if (!!CHIN(cs2, i) != !!CHIN(cs, i)) -+ break; /* no */ -+ if (i == css) -+ break; /* yes */ -+ } -+ -+ if (cs2 < top) { /* found one */ -+ freeset(p, cs); -+ cs = cs2; -+ } -+ -+ return((int)(cs - p->g->sets)); -+} -+ -+/* -+ - firstch - return first character in a set (which must have at least one) -+ */ -+static int /* character; there is no "none" value */ -+firstch(struct parse *p, cset *cs) -+{ -+ size_t i; -+ size_t css = (size_t)p->g->csetsize; -+ -+ for (i = 0; i < css; i++) -+ if (CHIN(cs, i)) -+ return((char)i); -+ assert(never); -+ return(0); /* arbitrary */ -+} -+ -+/* -+ - nch - number of characters in a set -+ */ -+static int -+nch(struct parse *p, cset *cs) -+{ -+ size_t i; -+ size_t css = (size_t)p->g->csetsize; -+ int n = 0; -+ -+ for (i = 0; i < css; i++) -+ if (CHIN(cs, i)) -+ n++; -+ return(n); -+} -+ -+/* -+ - mcadd - add a collating element to a cset -+ */ -+static void -+mcadd( struct parse *p, cset *cs, const char *cp) -+{ -+ size_t oldend = cs->smultis; -+ void *np; -+ -+ cs->smultis += strlen(cp) + 1; -+ np = realloc(cs->multis, cs->smultis); -+ if (np == NULL) { -+ if (cs->multis) -+ free(cs->multis); -+ cs->multis = NULL; -+ SETERROR(REG_ESPACE); -+ return; -+ } -+ cs->multis = np; -+ -+ llvm_strlcpy(cs->multis + oldend - 1, cp, cs->smultis - oldend + 1); -+} -+ -+/* -+ - mcinvert - invert the list of collating elements in a cset -+ * -+ * This would have to know the set of possibilities. Implementation -+ * is deferred. -+ */ -+/* ARGSUSED */ -+static void -+mcinvert(struct parse *p, cset *cs) -+{ -+ assert(cs->multis == NULL); /* xxx */ -+} -+ -+/* -+ - mccase - add case counterparts of the list of collating elements in a cset -+ * -+ * This would have to know the set of possibilities. Implementation -+ * is deferred. -+ */ -+/* ARGSUSED */ -+static void -+mccase(struct parse *p, cset *cs) -+{ -+ assert(cs->multis == NULL); /* xxx */ -+} -+ -+/* -+ - isinsets - is this character in any sets? -+ */ -+static int /* predicate */ -+isinsets(struct re_guts *g, int c) -+{ -+ uch *col; -+ int i; -+ int ncols = (g->ncsets+(CHAR_BIT-1)) / CHAR_BIT; -+ unsigned uc = (uch)c; -+ -+ for (i = 0, col = g->setbits; i < ncols; i++, col += g->csetsize) -+ if (col[uc] != 0) -+ return(1); -+ return(0); -+} -+ -+/* -+ - samesets - are these two characters in exactly the same sets? -+ */ -+static int /* predicate */ -+samesets(struct re_guts *g, int c1, int c2) -+{ -+ uch *col; -+ int i; -+ int ncols = (g->ncsets+(CHAR_BIT-1)) / CHAR_BIT; -+ unsigned uc1 = (uch)c1; -+ unsigned uc2 = (uch)c2; -+ -+ for (i = 0, col = g->setbits; i < ncols; i++, col += g->csetsize) -+ if (col[uc1] != col[uc2]) -+ return(0); -+ return(1); -+} -+ -+/* -+ - categorize - sort out character categories -+ */ -+static void -+categorize(struct parse *p, struct re_guts *g) -+{ -+ cat_t *cats = g->categories; -+ int c; -+ int c2; -+ cat_t cat; -+ -+ /* avoid making error situations worse */ -+ if (p->error != 0) -+ return; -+ -+ for (c = CHAR_MIN; c <= CHAR_MAX; c++) -+ if (cats[c] == 0 && isinsets(g, c)) { -+ cat = g->ncategories++; -+ cats[c] = cat; -+ for (c2 = c+1; c2 <= CHAR_MAX; c2++) -+ if (cats[c2] == 0 && samesets(g, c, c2)) -+ cats[c2] = cat; -+ } -+} -+ -+/* -+ - dupl - emit a duplicate of a bunch of sops -+ */ -+static sopno /* start of duplicate */ -+dupl(struct parse *p, -+ sopno start, /* from here */ -+ sopno finish) /* to this less one */ -+{ -+ sopno ret = HERE(); -+ sopno len = finish - start; -+ -+ assert(finish >= start); -+ if (len == 0) -+ return(ret); -+ enlarge(p, p->ssize + len); /* this many unexpected additions */ -+ assert(p->ssize >= p->slen + len); -+ (void) memmove((char *)(p->strip + p->slen), -+ (char *)(p->strip + start), (size_t)len*sizeof(sop)); -+ p->slen += len; -+ return(ret); -+} -+ -+/* -+ - doemit - emit a strip operator -+ * -+ * It might seem better to implement this as a macro with a function as -+ * hard-case backup, but it's just too big and messy unless there are -+ * some changes to the data structures. Maybe later. -+ */ -+static void -+doemit(struct parse *p, sop op, size_t opnd) -+{ -+ /* avoid making error situations worse */ -+ if (p->error != 0) -+ return; -+ -+ /* deal with oversize operands ("can't happen", more or less) */ -+ assert(opnd < 1<slen >= p->ssize) -+ enlarge(p, (p->ssize+1) / 2 * 3); /* +50% */ -+ assert(p->slen < p->ssize); -+ -+ /* finally, it's all reduced to the easy case */ -+ p->strip[p->slen++] = SOP(op, opnd); -+} -+ -+/* -+ - doinsert - insert a sop into the strip -+ */ -+static void -+doinsert(struct parse *p, sop op, size_t opnd, sopno pos) -+{ -+ sopno sn; -+ sop s; -+ int i; -+ -+ /* avoid making error situations worse */ -+ if (p->error != 0) -+ return; -+ -+ sn = HERE(); -+ EMIT(op, opnd); /* do checks, ensure space */ -+ assert(HERE() == sn+1); -+ s = p->strip[sn]; -+ -+ /* adjust paren pointers */ -+ assert(pos > 0); -+ for (i = 1; i < NPAREN; i++) { -+ if (p->pbegin[i] >= pos) { -+ p->pbegin[i]++; -+ } -+ if (p->pend[i] >= pos) { -+ p->pend[i]++; -+ } -+ } -+ -+ memmove((char *)&p->strip[pos+1], (char *)&p->strip[pos], -+ (HERE()-pos-1)*sizeof(sop)); -+ p->strip[pos] = s; -+} -+ -+/* -+ - dofwd - complete a forward reference -+ */ -+static void -+dofwd(struct parse *p, sopno pos, sop value) -+{ -+ /* avoid making error situations worse */ -+ if (p->error != 0) -+ return; -+ -+ assert(value < 1<strip[pos] = OP(p->strip[pos]) | value; -+} -+ -+/* -+ - enlarge - enlarge the strip -+ */ -+static void -+enlarge(struct parse *p, sopno size) -+{ -+ sop *sp; -+ -+ if (p->ssize >= size) -+ return; -+ -+ if ((uintptr_t)size > SIZE_MAX / sizeof(sop)) { -+ SETERROR(REG_ESPACE); -+ return; -+ } -+ -+ sp = (sop *)realloc(p->strip, size*sizeof(sop)); -+ if (sp == NULL) { -+ SETERROR(REG_ESPACE); -+ return; -+ } -+ p->strip = sp; -+ p->ssize = size; -+} -+ -+/* -+ - stripsnug - compact the strip -+ */ -+static void -+stripsnug(struct parse *p, struct re_guts *g) -+{ -+ g->nstates = p->slen; -+ if ((uintptr_t)p->slen > SIZE_MAX / sizeof(sop)) { -+ g->strip = p->strip; -+ SETERROR(REG_ESPACE); -+ return; -+ } -+ -+ g->strip = (sop *)realloc((char *)p->strip, p->slen * sizeof(sop)); -+ if (g->strip == NULL) { -+ SETERROR(REG_ESPACE); -+ g->strip = p->strip; -+ } -+} -+ -+/* -+ - findmust - fill in must and mlen with longest mandatory literal string -+ * -+ * This algorithm could do fancy things like analyzing the operands of | -+ * for common subsequences. Someday. This code is simple and finds most -+ * of the interesting cases. -+ * -+ * Note that must and mlen got initialized during setup. -+ */ -+static void -+findmust(struct parse *p, struct re_guts *g) -+{ -+ sop *scan; -+ sop *start = 0; /* start initialized in the default case, after that */ -+ sop *newstart = 0; /* newstart was initialized in the OCHAR case */ -+ sopno newlen; -+ sop s; -+ char *cp; -+ sopno i; -+ -+ /* avoid making error situations worse */ -+ if (p->error != 0) -+ return; -+ -+ /* find the longest OCHAR sequence in strip */ -+ newlen = 0; -+ scan = g->strip + 1; -+ do { -+ s = *scan++; -+ switch (OP(s)) { -+ case OCHAR: /* sequence member */ -+ if (newlen == 0) /* new sequence */ -+ newstart = scan - 1; -+ newlen++; -+ break; -+ case OPLUS_: /* things that don't break one */ -+ case OLPAREN: -+ case ORPAREN: -+ break; -+ case OQUEST_: /* things that must be skipped */ -+ case OCH_: -+ scan--; -+ do { -+ scan += OPND(s); -+ s = *scan; -+ /* assert() interferes w debug printouts */ -+ if (OP(s) != O_QUEST && OP(s) != O_CH && -+ OP(s) != OOR2) { -+ g->iflags |= REGEX_BAD; -+ return; -+ } -+ } while (OP(s) != O_QUEST && OP(s) != O_CH); -+ /* fallthrough */ -+ default: /* things that break a sequence */ -+ if (newlen > g->mlen) { /* ends one */ -+ start = newstart; -+ g->mlen = newlen; -+ } -+ newlen = 0; -+ break; -+ } -+ } while (OP(s) != OEND); -+ -+ if (g->mlen == 0) /* there isn't one */ -+ return; -+ -+ /* turn it into a character string */ -+ g->must = malloc((size_t)g->mlen + 1); -+ if (g->must == NULL) { /* argh; just forget it */ -+ g->mlen = 0; -+ return; -+ } -+ cp = g->must; -+ scan = start; -+ for (i = g->mlen; i > 0; i--) { -+ while (OP(s = *scan++) != OCHAR) -+ continue; -+ assert(cp < g->must + g->mlen); -+ *cp++ = (char)OPND(s); -+ } -+ assert(cp == g->must + g->mlen); -+ *cp++ = '\0'; /* just on general principles */ -+} -+ -+/* -+ - pluscount - count + nesting -+ */ -+static sopno /* nesting depth */ -+pluscount(struct parse *p, struct re_guts *g) -+{ -+ sop *scan; -+ sop s; -+ sopno plusnest = 0; -+ sopno maxnest = 0; -+ -+ if (p->error != 0) -+ return(0); /* there may not be an OEND */ -+ -+ scan = g->strip + 1; -+ do { -+ s = *scan++; -+ switch (OP(s)) { -+ case OPLUS_: -+ plusnest++; -+ break; -+ case O_PLUS: -+ if (plusnest > maxnest) -+ maxnest = plusnest; -+ plusnest--; -+ break; -+ } -+ } while (OP(s) != OEND); -+ if (plusnest != 0) -+ g->iflags |= REGEX_BAD; -+ return(maxnest); -+} -diff -up lldb-3.8.0rc2.src/source/Utility/regerror.c.dave lldb-3.8.0rc2.src/source/Utility/regerror.c ---- lldb-3.8.0rc2.src/source/Utility/regerror.c.dave 2016-02-17 23:19:05.373675777 -0500 -+++ lldb-3.8.0rc2.src/source/Utility/regerror.c 2016-02-17 23:19:05.373675777 -0500 -@@ -0,0 +1,135 @@ -+/*- -+ * This code is derived from OpenBSD's libc/regex, original license follows: -+ * -+ * Copyright (c) 1992, 1993, 1994 Henry Spencer. -+ * Copyright (c) 1992, 1993, 1994 -+ * The Regents of the University of California. All rights reserved. -+ * -+ * This code is derived from software contributed to Berkeley by -+ * Henry Spencer. -+ * -+ * Redistribution and use in source and binary forms, with or without -+ * modification, are permitted provided that the following conditions -+ * are met: -+ * 1. Redistributions of source code must retain the above copyright -+ * notice, this list of conditions and the following disclaimer. -+ * 2. Redistributions in binary form must reproduce the above copyright -+ * notice, this list of conditions and the following disclaimer in the -+ * documentation and/or other materials provided with the distribution. -+ * 3. Neither the name of the University nor the names of its contributors -+ * may be used to endorse or promote products derived from this software -+ * without specific prior written permission. -+ * -+ * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND -+ * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE -+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE -+ * ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE -+ * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL -+ * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS -+ * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) -+ * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT -+ * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY -+ * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF -+ * SUCH DAMAGE. -+ * -+ * @(#)regerror.c 8.4 (Berkeley) 3/20/94 -+ */ -+ -+#include -+#include -+#include -+#include -+#include -+#include -+#include "regex_impl.h" -+ -+#include "regutils.h" -+ -+#ifdef _MSC_VER -+#define snprintf _snprintf -+#endif -+ -+static const char *regatoi(const llvm_regex_t *, char *, int); -+ -+static struct rerr { -+ int code; -+ const char *name; -+ const char *explain; -+} rerrs[] = { -+ { REG_NOMATCH, "REG_NOMATCH", "llvm_regexec() failed to match" }, -+ { REG_BADPAT, "REG_BADPAT", "invalid regular expression" }, -+ { REG_ECOLLATE, "REG_ECOLLATE", "invalid collating element" }, -+ { REG_ECTYPE, "REG_ECTYPE", "invalid character class" }, -+ { REG_EESCAPE, "REG_EESCAPE", "trailing backslash (\\)" }, -+ { REG_ESUBREG, "REG_ESUBREG", "invalid backreference number" }, -+ { REG_EBRACK, "REG_EBRACK", "brackets ([ ]) not balanced" }, -+ { REG_EPAREN, "REG_EPAREN", "parentheses not balanced" }, -+ { REG_EBRACE, "REG_EBRACE", "braces not balanced" }, -+ { REG_BADBR, "REG_BADBR", "invalid repetition count(s)" }, -+ { REG_ERANGE, "REG_ERANGE", "invalid character range" }, -+ { REG_ESPACE, "REG_ESPACE", "out of memory" }, -+ { REG_BADRPT, "REG_BADRPT", "repetition-operator operand invalid" }, -+ { REG_EMPTY, "REG_EMPTY", "empty (sub)expression" }, -+ { REG_ASSERT, "REG_ASSERT", "\"can't happen\" -- you found a bug" }, -+ { REG_INVARG, "REG_INVARG", "invalid argument to regex routine" }, -+ { 0, "", "*** unknown regexp error code ***" } -+}; -+ -+/* -+ - llvm_regerror - the interface to error numbers -+ = extern size_t llvm_regerror(int, const llvm_regex_t *, char *, size_t); -+ */ -+/* ARGSUSED */ -+size_t -+llvm_regerror(int errcode, const llvm_regex_t *preg, char *errbuf, size_t errbuf_size) -+{ -+ struct rerr *r; -+ size_t len; -+ int target = errcode &~ REG_ITOA; -+ const char *s; -+ char convbuf[50]; -+ -+ if (errcode == REG_ATOI) -+ s = regatoi(preg, convbuf, sizeof convbuf); -+ else { -+ for (r = rerrs; r->code != 0; r++) -+ if (r->code == target) -+ break; -+ -+ if (errcode®_ITOA) { -+ if (r->code != 0) { -+ assert(strlen(r->name) < sizeof(convbuf)); -+ (void) llvm_strlcpy(convbuf, r->name, sizeof convbuf); -+ } else -+ (void)snprintf(convbuf, sizeof convbuf, -+ "REG_0x%x", target); -+ s = convbuf; -+ } else -+ s = r->explain; -+ } -+ -+ len = strlen(s) + 1; -+ if (errbuf_size > 0) { -+ llvm_strlcpy(errbuf, s, errbuf_size); -+ } -+ -+ return(len); -+} -+ -+/* -+ - regatoi - internal routine to implement REG_ATOI -+ */ -+static const char * -+regatoi(const llvm_regex_t *preg, char *localbuf, int localbufsize) -+{ -+ struct rerr *r; -+ -+ for (r = rerrs; r->code != 0; r++) -+ if (strcmp(r->name, preg->re_endp) == 0) -+ break; -+ if (r->code == 0) -+ return("0"); -+ -+ (void)snprintf(localbuf, localbufsize, "%d", r->code); -+ return(localbuf); -+} -diff -up lldb-3.8.0rc2.src/source/Utility/regexec.c.dave lldb-3.8.0rc2.src/source/Utility/regexec.c ---- lldb-3.8.0rc2.src/source/Utility/regexec.c.dave 2016-02-17 23:19:05.373675777 -0500 -+++ lldb-3.8.0rc2.src/source/Utility/regexec.c 2016-02-17 23:19:05.373675777 -0500 -@@ -0,0 +1,162 @@ -+/*- -+ * This code is derived from OpenBSD's libc/regex, original license follows: -+ * -+ * Copyright (c) 1992, 1993, 1994 Henry Spencer. -+ * Copyright (c) 1992, 1993, 1994 -+ * The Regents of the University of California. All rights reserved. -+ * -+ * This code is derived from software contributed to Berkeley by -+ * Henry Spencer. -+ * -+ * Redistribution and use in source and binary forms, with or without -+ * modification, are permitted provided that the following conditions -+ * are met: -+ * 1. Redistributions of source code must retain the above copyright -+ * notice, this list of conditions and the following disclaimer. -+ * 2. Redistributions in binary form must reproduce the above copyright -+ * notice, this list of conditions and the following disclaimer in the -+ * documentation and/or other materials provided with the distribution. -+ * 3. Neither the name of the University nor the names of its contributors -+ * may be used to endorse or promote products derived from this software -+ * without specific prior written permission. -+ * -+ * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND -+ * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE -+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE -+ * ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE -+ * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL -+ * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS -+ * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) -+ * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT -+ * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY -+ * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF -+ * SUCH DAMAGE. -+ * -+ * @(#)regexec.c 8.3 (Berkeley) 3/20/94 -+ */ -+ -+/* -+ * the outer shell of llvm_regexec() -+ * -+ * This file includes engine.inc *twice*, after muchos fiddling with the -+ * macros that code uses. This lets the same code operate on two different -+ * representations for state sets. -+ */ -+#include -+#include -+#include -+#include -+#include -+#include -+#include "regex_impl.h" -+ -+#include "regutils.h" -+#include "regex2.h" -+ -+/* macros for manipulating states, small version */ -+/* FIXME: 'states' is assumed as 'long' on small version. */ -+#define states1 long /* for later use in llvm_regexec() decision */ -+#define states states1 -+#define CLEAR(v) ((v) = 0) -+#define SET0(v, n) ((v) &= ~((unsigned long)1 << (n))) -+#define SET1(v, n) ((v) |= (unsigned long)1 << (n)) -+#define ISSET(v, n) (((v) & ((unsigned long)1 << (n))) != 0) -+#define ASSIGN(d, s) ((d) = (s)) -+#define EQ(a, b) ((a) == (b)) -+#define STATEVARS long dummy /* dummy version */ -+#define STATESETUP(m, n) /* nothing */ -+#define STATETEARDOWN(m) /* nothing */ -+#define SETUP(v) ((v) = 0) -+#define onestate long -+#define INIT(o, n) ((o) = (unsigned long)1 << (n)) -+#define INC(o) ((o) = (unsigned long)(o) << 1) -+#define ISSTATEIN(v, o) (((v) & (o)) != 0) -+/* some abbreviations; note that some of these know variable names! */ -+/* do "if I'm here, I can also be there" etc without branches */ -+#define FWD(dst, src, n) ((dst) |= ((unsigned long)(src)&(here)) << (n)) -+#define BACK(dst, src, n) ((dst) |= ((unsigned long)(src)&(here)) >> (n)) -+#define ISSETBACK(v, n) (((v) & ((unsigned long)here >> (n))) != 0) -+/* function names */ -+#define SNAMES /* engine.inc looks after details */ -+ -+#include "regengine.inc" -+ -+/* now undo things */ -+#undef states -+#undef CLEAR -+#undef SET0 -+#undef SET1 -+#undef ISSET -+#undef ASSIGN -+#undef EQ -+#undef STATEVARS -+#undef STATESETUP -+#undef STATETEARDOWN -+#undef SETUP -+#undef onestate -+#undef INIT -+#undef INC -+#undef ISSTATEIN -+#undef FWD -+#undef BACK -+#undef ISSETBACK -+#undef SNAMES -+ -+/* macros for manipulating states, large version */ -+#define states char * -+#define CLEAR(v) memset(v, 0, m->g->nstates) -+#define SET0(v, n) ((v)[n] = 0) -+#define SET1(v, n) ((v)[n] = 1) -+#define ISSET(v, n) ((v)[n]) -+#define ASSIGN(d, s) memmove(d, s, m->g->nstates) -+#define EQ(a, b) (memcmp(a, b, m->g->nstates) == 0) -+#define STATEVARS long vn; char *space -+#define STATESETUP(m, nv) { (m)->space = malloc((nv)*(m)->g->nstates); \ -+ if ((m)->space == NULL) return(REG_ESPACE); \ -+ (m)->vn = 0; } -+#define STATETEARDOWN(m) { free((m)->space); } -+#define SETUP(v) ((v) = &m->space[m->vn++ * m->g->nstates]) -+#define onestate long -+#define INIT(o, n) ((o) = (n)) -+#define INC(o) ((o)++) -+#define ISSTATEIN(v, o) ((v)[o]) -+/* some abbreviations; note that some of these know variable names! */ -+/* do "if I'm here, I can also be there" etc without branches */ -+#define FWD(dst, src, n) ((dst)[here+(n)] |= (src)[here]) -+#define BACK(dst, src, n) ((dst)[here-(n)] |= (src)[here]) -+#define ISSETBACK(v, n) ((v)[here - (n)]) -+/* function names */ -+#define LNAMES /* flag */ -+ -+#include "regengine.inc" -+ -+/* -+ - llvm_regexec - interface for matching -+ * -+ * We put this here so we can exploit knowledge of the state representation -+ * when choosing which matcher to call. Also, by this point the matchers -+ * have been prototyped. -+ */ -+int /* 0 success, REG_NOMATCH failure */ -+llvm_regexec(const llvm_regex_t *preg, const char *string, size_t nmatch, -+ llvm_regmatch_t pmatch[], int eflags) -+{ -+ struct re_guts *g = preg->re_g; -+#ifdef REDEBUG -+# define GOODFLAGS(f) (f) -+#else -+# define GOODFLAGS(f) ((f)&(REG_NOTBOL|REG_NOTEOL|REG_STARTEND)) -+#endif -+ -+ if (preg->re_magic != MAGIC1 || g->magic != MAGIC2) -+ return(REG_BADPAT); -+ assert(!(g->iflags®EX_BAD)); -+ if (g->iflags®EX_BAD) /* backstop for no-debug case */ -+ return(REG_BADPAT); -+ eflags = GOODFLAGS(eflags); -+ -+ if (g->nstates <= (long)(CHAR_BIT*sizeof(states1)) && !(eflags®_LARGE)) -+ return(smatcher(g, string, nmatch, pmatch, eflags)); -+ else -+ return(lmatcher(g, string, nmatch, pmatch, eflags)); -+} -diff -up lldb-3.8.0rc2.src/source/Utility/regfree.c.dave lldb-3.8.0rc2.src/source/Utility/regfree.c ---- lldb-3.8.0rc2.src/source/Utility/regfree.c.dave 2016-02-17 23:19:05.373675777 -0500 -+++ lldb-3.8.0rc2.src/source/Utility/regfree.c 2016-02-17 23:19:05.373675777 -0500 -@@ -0,0 +1,72 @@ -+/*- -+ * This code is derived from OpenBSD's libc/regex, original license follows: -+ * -+ * Copyright (c) 1992, 1993, 1994 Henry Spencer. -+ * Copyright (c) 1992, 1993, 1994 -+ * The Regents of the University of California. All rights reserved. -+ * -+ * This code is derived from software contributed to Berkeley by -+ * Henry Spencer. -+ * -+ * Redistribution and use in source and binary forms, with or without -+ * modification, are permitted provided that the following conditions -+ * are met: -+ * 1. Redistributions of source code must retain the above copyright -+ * notice, this list of conditions and the following disclaimer. -+ * 2. Redistributions in binary form must reproduce the above copyright -+ * notice, this list of conditions and the following disclaimer in the -+ * documentation and/or other materials provided with the distribution. -+ * 3. Neither the name of the University nor the names of its contributors -+ * may be used to endorse or promote products derived from this software -+ * without specific prior written permission. -+ * -+ * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND -+ * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE -+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE -+ * ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE -+ * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL -+ * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS -+ * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) -+ * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT -+ * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY -+ * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF -+ * SUCH DAMAGE. -+ * -+ * @(#)regfree.c 8.3 (Berkeley) 3/20/94 -+ */ -+ -+#include -+#include -+#include -+#include "regex_impl.h" -+ -+#include "regutils.h" -+#include "regex2.h" -+ -+/* -+ - llvm_regfree - free everything -+ */ -+void -+llvm_regfree(llvm_regex_t *preg) -+{ -+ struct re_guts *g; -+ -+ if (preg->re_magic != MAGIC1) /* oops */ -+ return; /* nice to complain, but hard */ -+ -+ g = preg->re_g; -+ if (g == NULL || g->magic != MAGIC2) /* oops again */ -+ return; -+ preg->re_magic = 0; /* mark it invalid */ -+ g->magic = 0; /* mark it invalid */ -+ -+ if (g->strip != NULL) -+ free((char *)g->strip); -+ if (g->sets != NULL) -+ free((char *)g->sets); -+ if (g->setbits != NULL) -+ free((char *)g->setbits); -+ if (g->must != NULL) -+ free(g->must); -+ free((char *)g); -+} -diff -up lldb-3.8.0rc2.src/source/Utility/regstrlcpy.c.dave lldb-3.8.0rc2.src/source/Utility/regstrlcpy.c ---- lldb-3.8.0rc2.src/source/Utility/regstrlcpy.c.dave 2016-02-17 23:19:05.373675777 -0500 -+++ lldb-3.8.0rc2.src/source/Utility/regstrlcpy.c 2016-02-17 23:19:05.373675777 -0500 -@@ -0,0 +1,52 @@ -+/* -+ * This code is derived from OpenBSD's libc, original license follows: -+ * -+ * Copyright (c) 1998 Todd C. Miller -+ * -+ * Permission to use, copy, modify, and distribute this software for any -+ * purpose with or without fee is hereby granted, provided that the above -+ * copyright notice and this permission notice appear in all copies. -+ * -+ * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES -+ * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF -+ * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR -+ * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES -+ * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN -+ * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF -+ * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE. -+ */ -+ -+#include -+#include -+ -+#include "regex_impl.h" -+/* -+ * Copy src to string dst of size siz. At most siz-1 characters -+ * will be copied. Always NUL terminates (unless siz == 0). -+ * Returns strlen(src); if retval >= siz, truncation occurred. -+ */ -+size_t -+llvm_strlcpy(char *dst, const char *src, size_t siz) -+{ -+ char *d = dst; -+ const char *s = src; -+ size_t n = siz; -+ -+ /* Copy as many bytes as will fit */ -+ if (n != 0) { -+ while (--n != 0) { -+ if ((*d++ = *s++) == '\0') -+ break; -+ } -+ } -+ -+ /* Not enough room in dst, add NUL and traverse rest of src */ -+ if (n == 0) { -+ if (siz != 0) -+ *d = '\0'; /* NUL-terminate dst */ -+ while (*s++) -+ ; -+ } -+ -+ return(s - src - 1); /* count does not include NUL */ -+} -diff -up lldb-3.8.0rc2.src/tools/lldb-mi/MIUtilParse.h.dave lldb-3.8.0rc2.src/tools/lldb-mi/MIUtilParse.h ---- lldb-3.8.0rc2.src/tools/lldb-mi/MIUtilParse.h.dave 2016-02-17 23:27:41.706021170 -0500 -+++ lldb-3.8.0rc2.src/tools/lldb-mi/MIUtilParse.h 2016-02-17 23:29:13.806580026 -0500 -@@ -10,7 +10,7 @@ - #pragma once - - // Third party headers: --#include "../lib/Support/regex_impl.h" -+#include "../include/lldb/Utility/regex_impl.h" - - // In-house headers: - #include "MIUtilString.h" diff --git a/unmaintained/lldb/lldb-3.8-alpine.patch b/unmaintained/lldb/lldb-3.8-alpine.patch deleted file mode 100644 index 97c56fd026..0000000000 --- a/unmaintained/lldb/lldb-3.8-alpine.patch +++ /dev/null @@ -1,27 +0,0 @@ -diff --git a/include/lldb/Host/android/Android.h b/include/lldb/Host/android/Android.h -index 8efc1a5..6e38d0d 100644 ---- a/include/lldb/Host/android/Android.h -+++ b/include/lldb/Host/android/Android.h -@@ -15,7 +15,9 @@ - #include - - #define _isatty isatty -+#ifndef SYS_tgkill - #define SYS_tgkill __NR_tgkill -+#endif - - namespace std - { -diff --git a/include/lldb/Host/linux/Ptrace.h b/include/lldb/Host/linux/Ptrace.h -index b28bb37..3b70602 100644 ---- a/include/lldb/Host/linux/Ptrace.h -+++ b/include/lldb/Host/linux/Ptrace.h -@@ -14,7 +14,7 @@ - - #include - --#ifdef __ANDROID_NDK__ -+#ifndef __GLIBC__ - #define PT_DETACH PTRACE_DETACH - typedef int __ptrace_request; - #endif diff --git a/unmaintained/lldb/musl-include-ptrace.aarch64.patch b/unmaintained/lldb/musl-include-ptrace.aarch64.patch deleted file mode 100644 index f6ec2cc34b..0000000000 --- a/unmaintained/lldb/musl-include-ptrace.aarch64.patch +++ /dev/null @@ -1,17 +0,0 @@ -From: Jakub Jirutka -Date: Mon, 29 Aug 2016 00:18:00 +0200 -Subject: [PATCH] Fix compile error on aarch64 - -NativeRegisterContextLinux_arm64 uses user_pt_regs and user_fpsimd_state -which are defined in asm/ptrace.h. - ---- a/source/Plugins/Process/Linux/NativeRegisterContextLinux_arm64.cpp -+++ b/source/Plugins/Process/Linux/NativeRegisterContextLinux_arm64.cpp -@@ -29,6 +29,7 @@ - - // System includes - They have to be included after framework includes because they define some - // macros which collide with variable names in other modules -+#include - #include - // NT_PRSTATUS and NT_FPREGSET definition - #include -- cgit v1.2.3