From ae70a180a9b1d9cb4090585a2245d37188f34f2d Mon Sep 17 00:00:00 2001 From: Edward Kimmel Date: Wed, 22 Mar 2017 11:43:21 -0400 Subject: [PATCH 001/338] Clear the environment, ragel might be build for a different architecture --- scripts/harfbuzz/1.4.4-ft/script.sh | 8 ++++++-- 1 file changed, 6 insertions(+), 2 deletions(-) diff --git a/scripts/harfbuzz/1.4.4-ft/script.sh b/scripts/harfbuzz/1.4.4-ft/script.sh index d38df1d22..0771df7ca 100755 --- a/scripts/harfbuzz/1.4.4-ft/script.sh +++ b/scripts/harfbuzz/1.4.4-ft/script.sh @@ -21,8 +21,12 @@ function mason_prepare_compile { FREETYPE_VERSION="2.7.1" ${MASON_DIR}/mason install freetype ${FREETYPE_VERSION} MASON_FREETYPE=$(${MASON_DIR}/mason prefix freetype ${FREETYPE_VERSION}) - MASON_PLATFORM= ${MASON_DIR}/mason install ragel 6.9 - export PATH=$(MASON_PLATFORM= ${MASON_DIR}/mason prefix ragel 6.9)/bin:$PATH + + pushd ${MASON_ROOT}/.. + env -i HOME="$HOME" PATH="$PATH" USER="$USER" ${MASON_DIR}/mason build ragel 6.9 + popd + +export PATH=$(MASON_PLATFORM= ${MASON_DIR}/mason prefix ragel 6.9)/bin:$PATH export PKG_CONFIG_PATH="$(${MASON_DIR}/mason prefix freetype ${FREETYPE_VERSION})/lib/pkgconfig":${PKG_CONFIG_PATH:-} export C_INCLUDE_PATH="${MASON_FREETYPE}/include/freetype2" export CPLUS_INCLUDE_PATH="${MASON_FREETYPE}/include/freetype2" From 80d55f631384e10cedbfceb42544d1410cdc0a2e Mon Sep 17 00:00:00 2001 From: Dane Springmeyer Date: Thu, 22 Mar 2018 18:01:28 -0400 Subject: [PATCH 002/338] Add postgres 10.3 with libedit support enabled --- scripts/postgres/10.3/.travis.yml | 13 +++++ scripts/postgres/10.3/patch.diff | 11 ++++ scripts/postgres/10.3/script.sh | 96 +++++++++++++++++++++++++++++++ scripts/postgres/9.6.5/script.sh | 9 ++- 4 files changed, 128 insertions(+), 1 deletion(-) create mode 100644 scripts/postgres/10.3/.travis.yml create mode 100644 scripts/postgres/10.3/patch.diff create mode 100755 scripts/postgres/10.3/script.sh diff --git a/scripts/postgres/10.3/.travis.yml b/scripts/postgres/10.3/.travis.yml new file mode 100644 index 000000000..8c71516f9 --- /dev/null +++ b/scripts/postgres/10.3/.travis.yml @@ -0,0 +1,13 @@ +language: generic + +matrix: + include: + - os: osx + osx_image: xcode8.2 + compiler: clang + - os: linux + sudo: false + +script: +- ./mason build ${MASON_NAME} ${MASON_VERSION} +- ./mason publish ${MASON_NAME} ${MASON_VERSION} diff --git a/scripts/postgres/10.3/patch.diff b/scripts/postgres/10.3/patch.diff new file mode 100644 index 000000000..ae2f06a46 --- /dev/null +++ b/scripts/postgres/10.3/patch.diff @@ -0,0 +1,11 @@ +--- src/include/pg_config_manual.h 2013-10-07 20:17:38.000000000 -0700 ++++ src/include/pg_config_manual.h 2014-03-08 21:29:48.000000000 -0800 +@@ -144,7 +144,7 @@ + * here's where to twiddle it. You can also override this at runtime + * with the postmaster's -k switch. + */ +-#define DEFAULT_PGSOCKET_DIR "/tmp" ++#define DEFAULT_PGSOCKET_DIR "/var/run/postgresql" + + /* + * The random() function is expected to yield values between 0 and diff --git a/scripts/postgres/10.3/script.sh b/scripts/postgres/10.3/script.sh new file mode 100755 index 000000000..6c8a49f40 --- /dev/null +++ b/scripts/postgres/10.3/script.sh @@ -0,0 +1,96 @@ +#!/usr/bin/env bash + +MASON_NAME=postgres +MASON_VERSION=10.3 +MASON_LIB_FILE=bin/psql +MASON_PKGCONFIG_FILE=lib/pkgconfig/libpq.pc + +. ${MASON_DIR}/mason.sh + +function mason_load_source { + mason_download \ + http://ftp.postgresql.org/pub/source/v${MASON_VERSION}/postgresql-${MASON_VERSION}.tar.bz2 \ + e1590a4b2167dcdf164eb887cf83e7da9e155771 + + mason_extract_tar_bz2 + + export MASON_BUILD_PATH=${MASON_ROOT}/.build/postgresql-${MASON_VERSION} +} + +function mason_prepare_compile { + LIBEDIT_VERSION="3.1" + NCURSES_VERSION="6.1" + CCACHE_VERSION=3.3.1 + ${MASON_DIR}/mason install ccache ${CCACHE_VERSION} + MASON_CCACHE=$(${MASON_DIR}/mason prefix ccache ${CCACHE_VERSION}) + ${MASON_DIR}/mason install libedit ${LIBEDIT_VERSION} + MASON_LIBEDIT=$(${MASON_DIR}/mason prefix libedit ${LIBEDIT_VERSION}) + ${MASON_DIR}/mason install ncurses ${NCURSES_VERSION} + MASON_NCURSES=$(${MASON_DIR}/mason prefix ncurses ${NCURSES_VERSION}) +} + +function mason_compile { + if [[ ${MASON_PLATFORM} == 'linux' ]]; then + mason_step "Loading patch" + patch src/include/pg_config_manual.h ${MASON_DIR}/scripts/${MASON_NAME}/${MASON_VERSION}/patch.diff + fi + + # note CFLAGS overrides defaults (-Wall -Wmissing-prototypes -Wpointer-arith -Wdeclaration-after-statement -Wendif-labels -Wmissing-format-attribute -Wformat-security -fno-strict-aliasing -fwrapv -Wno-unused-command-line-argument) so we need to add optimization flags back + export CFLAGS="${CFLAGS} -O3 -DNDEBUG -Wall -Wmissing-prototypes -Wpointer-arith -Wdeclaration-after-statement -Wendif-labels -Wmissing-format-attribute -Wformat-security -fno-strict-aliasing -fwrapv -Wno-unused-command-line-argument" + export CFLAGS="-I${MASON_LIBEDIT}/include -I${MASON_NCURSES}/include ${CFLAGS}" + export LDFLAGS="-L${MASON_LIBEDIT}/lib -L${MASON_NCURSES}/lib ${LDFLAGS}" + ./configure \ + --prefix=${MASON_PREFIX} \ + ${MASON_HOST_ARG} \ + --enable-thread-safety \ + --enable-largefile \ + --with-python \ + --with-zlib \ + --without-bonjour \ + --without-openssl \ + --without-pam \ + --without-gssapi \ + --without-ossp-uuid \ + --with-readline \ + --with-libedit-preferred \ + --without-ldap \ + --without-libxml \ + --without-libxslt \ + --without-selinux \ + --without-perl \ + --without-tcl \ + --disable-rpath \ + --disable-debug \ + --disable-profiling \ + --disable-coverage \ + --disable-dtrace \ + --disable-depend \ + --disable-cassert + + make -j${MASON_CONCURRENCY} -C src/interfaces/libpq/ install + rm -f src/interfaces/libpq{*.so*,*.dylib} + rm -f ${MASON_PREFIX}/lib/libpq{*.so*,*.dylib} + MASON_LIBPQ_PATH=${MASON_PREFIX}/lib/libpq.a + MASON_LIBPQ_PATH2=${MASON_LIBPQ_PATH////\\/} + MASON_LIBEDIT_PATH=${MASON_LIBEDIT}/lib/libedit.a + MASON_LIBEDIT_PATH=${MASON_LIBEDIT_PATH////\\/} + MASON_NCURSES_PATH=${MASON_NCURSES}/lib/libncurses.a + MASON_NCURSES_PATH=${MASON_NCURSES_PATH////\\/} + perl -i -p -e "s/\-lncurses/${MASON_NCURSES_PATH}/g;" src/backend/Makefile + perl -i -p -e "s/\-lncurses/${MASON_NCURSES_PATH}/g;" src/Makefile.global + perl -i -p -e "s/\-lncurses/${MASON_NCURSES_PATH}/g;" configure + perl -i -p -e "s/\-lncurses/${MASON_NCURSES_PATH}/g;" config/programs.m4 + perl -i -p -e "s/\-ledit/${MASON_LIBEDIT_PATH}/g;" src/Makefile.global.in + perl -i -p -e "s/\-ledit/${MASON_LIBEDIT_PATH}/g;" src/Makefile.global + perl -i -p -e "s/\-lpq/${MASON_LIBPQ_PATH2} -pthread/g;" src/Makefile.global.in + perl -i -p -e "s/\-lpq/${MASON_LIBPQ_PATH2} -pthread/g;" src/Makefile.global + make -j${MASON_CONCURRENCY} install + make -j${MASON_CONCURRENCY} -C contrib install + rm -f ${MASON_PREFIX}/lib/lib{*.so*,*.dylib} +} + +function mason_clean { + make clean +} + +mason_run "$@" diff --git a/scripts/postgres/9.6.5/script.sh b/scripts/postgres/9.6.5/script.sh index a8197eb83..60f15d02b 100755 --- a/scripts/postgres/9.6.5/script.sh +++ b/scripts/postgres/9.6.5/script.sh @@ -18,6 +18,12 @@ function mason_load_source { export MASON_BUILD_PATH=${MASON_ROOT}/.build/postgresql-${MASON_VERSION2} } +function mason_prepare_compile { + LIBEDIT_VERSION="3.1" + ${MASON_DIR}/mason install libedit ${LIBEDIT_VERSION} + MASON_LIBEDIT=$(${MASON_DIR}/mason prefix libedit ${LIBEDIT_VERSION}) +} + function mason_compile { if [[ ${MASON_PLATFORM} == 'linux' ]]; then mason_step "Loading patch" @@ -38,7 +44,8 @@ function mason_compile { --without-pam \ --without-gssapi \ --without-ossp-uuid \ - --without-readline \ + --with-readline \ + --with-libedit-preferred \ --without-ldap \ --without-libxml \ --without-libxslt \ From 04ffd9a85680ec68d554b26ffb799e6783f13208 Mon Sep 17 00:00:00 2001 From: Dane Springmeyer Date: Mon, 2 Apr 2018 10:02:02 -0700 Subject: [PATCH 003/338] perf 4.15.15 --- scripts/perf/4.15.15/.travis.yml | 28 +++++++++++ scripts/perf/4.15.15/readme.md | 51 ++++++++++++++++++++ scripts/perf/4.15.15/script.sh | 82 ++++++++++++++++++++++++++++++++ 3 files changed, 161 insertions(+) create mode 100644 scripts/perf/4.15.15/.travis.yml create mode 100644 scripts/perf/4.15.15/readme.md create mode 100755 scripts/perf/4.15.15/script.sh diff --git a/scripts/perf/4.15.15/.travis.yml b/scripts/perf/4.15.15/.travis.yml new file mode 100644 index 000000000..9c5a0f11b --- /dev/null +++ b/scripts/perf/4.15.15/.travis.yml @@ -0,0 +1,28 @@ +language: generic + +matrix: + include: + - os: linux + sudo: false + addons: + apt: + sources: + - ubuntu-toolchain-r-test + # apt: + # make systemtap-sdt-dev bison flex libperl-dev + # yum: + # make flex bison elfutils-libelf-devel elfutils-devel libunwind-devel xz-devel numactl-devel openssl-devel slang-devel gtk2-devel perl-ExtUtils-Embed python-devel binutils-devel audit-libs-devel + packages: + - bison + - flex + - g++-4.9 + - systemtap-sdt-dev + +# note: perf must be compiled with gcc (see script.sh) +install: + - export CXX=g++-4.9 + - export CC=gcc-4.9 + +script: +- ./mason build ${MASON_NAME} ${MASON_VERSION} +- ./mason publish ${MASON_NAME} ${MASON_VERSION} diff --git a/scripts/perf/4.15.15/readme.md b/scripts/perf/4.15.15/readme.md new file mode 100644 index 000000000..ced489175 --- /dev/null +++ b/scripts/perf/4.15.15/readme.md @@ -0,0 +1,51 @@ +This is the expected/enabled features of this perf build: + +Taken from https://travis-ci.org/mapbox/mason/builds/336964403#L613 + +... dwarf: [ on ] +... dwarf_getlocations: [ on ] +... glibc: [ on ] +... gtk2: [ OFF ] +... libaudit: [ OFF ] +... libbfd: [ on ] +... libelf: [ on ] +... libnuma: [ OFF ] +... numa_num_possible_cpus: [ OFF ] +... libperl: [ OFF ] +... libpython: [ on ] +... libslang: [ on ] +... libcrypto: [ on ] +... libunwind: [ OFF ] +... libdw-dwarf-unwind: [ on ] +... zlib: [ on ] +... lzma: [ on ] +... get_cpuid: [ on ] +... bpf: [ on ] +... backtrace: [ on ] +... fortify-source: [ on ] +... sync-compare-and-swap: [ on ] +... gtk2-infobar: [ OFF ] +... libelf-getphdrnum: [ on ] +... libelf-gelf_getnote: [ on ] +... libelf-getshdrstrndx: [ on ] +... libelf-mmap: [ on ] +... libpython-version: [ on ] +... libunwind-x86: [ OFF ] +... libunwind-x86_64: [ OFF ] +... libunwind-arm: [ OFF ] +... libunwind-aarch64: [ OFF ] +... pthread-attr-setaffinity-np: [ on ] +... stackprotector-all: [ on ] +... timerfd: [ on ] +... sched_getcpu: [ on ] +... sdt: [ on ] +... setns: [ on ] +Makefile.config:613: Python support disabled by user +... prefix: /home/travis/build/mapbox/mason/mason_packages/linux-x86_64/perf/4.15 +... bindir: /home/travis/build/mapbox/mason/mason_packages/linux-x86_64/perf/4.15/bin +... libdir: /home/travis/build/mapbox/mason/mason_packages/linux-x86_64/perf/4.15/lib64 +... sysconfdir: /home/travis/build/mapbox/mason/mason_packages/linux-x86_64/perf/4.15/etc +... LIBUNWIND_DIR: +... LIBDW_DIR: +... JDIR: /usr/lib/jvm/java-1.7.0-openjdk-amd64 +... DWARF post unwind library: libdw \ No newline at end of file diff --git a/scripts/perf/4.15.15/script.sh b/scripts/perf/4.15.15/script.sh new file mode 100755 index 000000000..6c52cb48c --- /dev/null +++ b/scripts/perf/4.15.15/script.sh @@ -0,0 +1,82 @@ +#!/usr/bin/env bash + +MASON_NAME=perf +MASON_VERSION=4.15.15 +MASON_LIB_FILE=bin/perf + +. ${MASON_DIR}/mason.sh + +function mason_load_source { + # https://www.kernel.org/ + # https://git.kernel.org/cgit/linux/kernel/git/stable/linux-stable.git/log/tools/perf + mason_download \ + https://cdn.kernel.org/pub/linux/kernel/v4.x/linux-${MASON_VERSION}.tar.xz \ + 49e83b508ceb634f20d2663ed5028c41d0a5f39a + + mason_extract_tar_xz + + export MASON_BUILD_PATH=${MASON_ROOT}/.build/linux-${MASON_VERSION} +} + +function mason_prepare_compile { + ${MASON_DIR}/mason install zlib 1.2.8 + MASON_ZLIB=$(${MASON_DIR}/mason prefix zlib 1.2.8) + ${MASON_DIR}/mason install xz 5.2.3 + MASON_XZ=$(${MASON_DIR}/mason prefix xz 5.2.3) + ${MASON_DIR}/mason install binutils 2.30 + MASON_BINUTILS=$(${MASON_DIR}/mason prefix binutils 2.30) + ${MASON_DIR}/mason install slang 2.3.1 + MASON_SLANG=$(${MASON_DIR}/mason prefix slang 2.3.1) + ${MASON_DIR}/mason install bzip2 1.0.6 + MASON_BZIP2=$(${MASON_DIR}/mason prefix bzip2 1.0.6) + ${MASON_DIR}/mason install elfutils 0.170 + MASON_ELFUTILS=$(${MASON_DIR}/mason prefix elfutils 0.170) + EXTRA_CFLAGS="-m64 -I${MASON_SLANG}/include -I${MASON_ZLIB}/include -I${MASON_XZ}/include -I${MASON_BINUTILS}/include -I${MASON_BZIP2}/include -I${MASON_ELFUTILS}/include" + EXTRA_LDFLAGS="-L${MASON_BZIP2}/lib -L${MASON_ZLIB}/lib -L${MASON_XZ}/lib -L${MASON_SLANG}/lib -L${MASON_ELFUTILS}/lib -L${MASON_BINUTILS}/lib" +} + +# https://perf.wiki.kernel.org/index.php/Jolsa_Howto_Install_Sources +# https://askubuntu.com/questions/50145/how-to-install-perf-monitoring-tool/306683 +# https://www.spinics.net/lists/linux-perf-users/msg03040.html +# https://software.intel.com/en-us/articles/linux-perf-for-intel-vtune-Amplifier-XE +# see the readme.md in this directory for a log of what perf features are enabled +function mason_compile { + cd tools/perf + # we set NO_LIBUNWIND since libdw is used from elfutils which is faster: https://lwn.net/Articles/579508/ + # note: LIBELF is needed for symbols + node --perf_basic_prof_only_functions + mkdir -p output-dir + rm -rf output-dir/* + make \ + O=output-dir \ + LIBDW_LDFLAGS="-L${MASON_ELFUTILS}/lib -Wl,--start-group -ldw -lelf -lebl -llzma -lz -lbz2 -ldl -L${MASON_BZIP2}/lib -L${MASON_XZ}/lib" \ + LIBDW_CFLAGS="-I${MASON_ELFUTILS}/include/" \ + V=1 VF=1 \ + prefix=${MASON_PREFIX} \ + NO_LIBNUMA=1 \ + NO_LIBAUDIT=1 \ + NO_LIBUNWIND=1 \ + NO_BIONIC=1 \ + NO_BACKTRACE=1 \ + NO_LIBCRYPTO=1 \ + NO_LIBPERL=1 \ + NO_GTK2=1 \ + LDFLAGS="${EXTRA_LDFLAGS} -Wl,--start-group -L${MASON_BINUTILS}/lib -lbfd -lopcodes -lelf -lz" \ + NO_LIBPYTHON=1 \ + WERROR=0 \ + EXTRA_CFLAGS="${EXTRA_CFLAGS}" \ + install +} + +function mason_cflags { + : +} + +function mason_ldflags { + : +} + +function mason_static_libs { + : +} + +mason_run "$@" From 38109cdcacee5a13b3734483302b73ac3678b409 Mon Sep 17 00:00:00 2001 From: Dane Springmeyer Date: Mon, 2 Apr 2018 10:09:16 -0700 Subject: [PATCH 004/338] 4.15.15 update based on features detected in travis triggered build --- scripts/perf/4.15.15/readme.md | 15 ++++++++------- 1 file changed, 8 insertions(+), 7 deletions(-) diff --git a/scripts/perf/4.15.15/readme.md b/scripts/perf/4.15.15/readme.md index ced489175..a5e4ce375 100644 --- a/scripts/perf/4.15.15/readme.md +++ b/scripts/perf/4.15.15/readme.md @@ -2,10 +2,11 @@ This is the expected/enabled features of this perf build: Taken from https://travis-ci.org/mapbox/mason/builds/336964403#L613 +Auto-detecting system features: ... dwarf: [ on ] ... dwarf_getlocations: [ on ] ... glibc: [ on ] -... gtk2: [ OFF ] +... gtk2: [ on ] ... libaudit: [ OFF ] ... libbfd: [ on ] ... libelf: [ on ] @@ -24,7 +25,7 @@ Taken from https://travis-ci.org/mapbox/mason/builds/336964403#L613 ... backtrace: [ on ] ... fortify-source: [ on ] ... sync-compare-and-swap: [ on ] -... gtk2-infobar: [ OFF ] +... gtk2-infobar: [ on ] ... libelf-getphdrnum: [ on ] ... libelf-gelf_getnote: [ on ] ... libelf-getshdrstrndx: [ on ] @@ -41,11 +42,11 @@ Taken from https://travis-ci.org/mapbox/mason/builds/336964403#L613 ... sdt: [ on ] ... setns: [ on ] Makefile.config:613: Python support disabled by user -... prefix: /home/travis/build/mapbox/mason/mason_packages/linux-x86_64/perf/4.15 -... bindir: /home/travis/build/mapbox/mason/mason_packages/linux-x86_64/perf/4.15/bin -... libdir: /home/travis/build/mapbox/mason/mason_packages/linux-x86_64/perf/4.15/lib64 -... sysconfdir: /home/travis/build/mapbox/mason/mason_packages/linux-x86_64/perf/4.15/etc +... prefix: /home/travis/build/mapbox/mason/mason_packages/linux-x86_64/perf/4.15.15 +... bindir: /home/travis/build/mapbox/mason/mason_packages/linux-x86_64/perf/4.15.15/bin +... libdir: /home/travis/build/mapbox/mason/mason_packages/linux-x86_64/perf/4.15.15/lib64 +... sysconfdir: /home/travis/build/mapbox/mason/mason_packages/linux-x86_64/perf/4.15.15/etc ... LIBUNWIND_DIR: ... LIBDW_DIR: -... JDIR: /usr/lib/jvm/java-1.7.0-openjdk-amd64 +... JDIR: /usr/lib/jvm/java-1.6.0-openjdk-amd64 ... DWARF post unwind library: libdw \ No newline at end of file From fd20d5d3b08589869b1e79f64d4941c2562de330 Mon Sep 17 00:00:00 2001 From: Dane Springmeyer Date: Mon, 2 Apr 2018 11:21:14 -0700 Subject: [PATCH 005/338] perf 4.16 [skip ci] --- scripts/perf/4.16/.travis.yml | 28 ++++++++++++ scripts/perf/4.16/readme.md | 51 ++++++++++++++++++++++ scripts/perf/4.16/script.sh | 82 +++++++++++++++++++++++++++++++++++ 3 files changed, 161 insertions(+) create mode 100644 scripts/perf/4.16/.travis.yml create mode 100644 scripts/perf/4.16/readme.md create mode 100755 scripts/perf/4.16/script.sh diff --git a/scripts/perf/4.16/.travis.yml b/scripts/perf/4.16/.travis.yml new file mode 100644 index 000000000..9c5a0f11b --- /dev/null +++ b/scripts/perf/4.16/.travis.yml @@ -0,0 +1,28 @@ +language: generic + +matrix: + include: + - os: linux + sudo: false + addons: + apt: + sources: + - ubuntu-toolchain-r-test + # apt: + # make systemtap-sdt-dev bison flex libperl-dev + # yum: + # make flex bison elfutils-libelf-devel elfutils-devel libunwind-devel xz-devel numactl-devel openssl-devel slang-devel gtk2-devel perl-ExtUtils-Embed python-devel binutils-devel audit-libs-devel + packages: + - bison + - flex + - g++-4.9 + - systemtap-sdt-dev + +# note: perf must be compiled with gcc (see script.sh) +install: + - export CXX=g++-4.9 + - export CC=gcc-4.9 + +script: +- ./mason build ${MASON_NAME} ${MASON_VERSION} +- ./mason publish ${MASON_NAME} ${MASON_VERSION} diff --git a/scripts/perf/4.16/readme.md b/scripts/perf/4.16/readme.md new file mode 100644 index 000000000..ced489175 --- /dev/null +++ b/scripts/perf/4.16/readme.md @@ -0,0 +1,51 @@ +This is the expected/enabled features of this perf build: + +Taken from https://travis-ci.org/mapbox/mason/builds/336964403#L613 + +... dwarf: [ on ] +... dwarf_getlocations: [ on ] +... glibc: [ on ] +... gtk2: [ OFF ] +... libaudit: [ OFF ] +... libbfd: [ on ] +... libelf: [ on ] +... libnuma: [ OFF ] +... numa_num_possible_cpus: [ OFF ] +... libperl: [ OFF ] +... libpython: [ on ] +... libslang: [ on ] +... libcrypto: [ on ] +... libunwind: [ OFF ] +... libdw-dwarf-unwind: [ on ] +... zlib: [ on ] +... lzma: [ on ] +... get_cpuid: [ on ] +... bpf: [ on ] +... backtrace: [ on ] +... fortify-source: [ on ] +... sync-compare-and-swap: [ on ] +... gtk2-infobar: [ OFF ] +... libelf-getphdrnum: [ on ] +... libelf-gelf_getnote: [ on ] +... libelf-getshdrstrndx: [ on ] +... libelf-mmap: [ on ] +... libpython-version: [ on ] +... libunwind-x86: [ OFF ] +... libunwind-x86_64: [ OFF ] +... libunwind-arm: [ OFF ] +... libunwind-aarch64: [ OFF ] +... pthread-attr-setaffinity-np: [ on ] +... stackprotector-all: [ on ] +... timerfd: [ on ] +... sched_getcpu: [ on ] +... sdt: [ on ] +... setns: [ on ] +Makefile.config:613: Python support disabled by user +... prefix: /home/travis/build/mapbox/mason/mason_packages/linux-x86_64/perf/4.15 +... bindir: /home/travis/build/mapbox/mason/mason_packages/linux-x86_64/perf/4.15/bin +... libdir: /home/travis/build/mapbox/mason/mason_packages/linux-x86_64/perf/4.15/lib64 +... sysconfdir: /home/travis/build/mapbox/mason/mason_packages/linux-x86_64/perf/4.15/etc +... LIBUNWIND_DIR: +... LIBDW_DIR: +... JDIR: /usr/lib/jvm/java-1.7.0-openjdk-amd64 +... DWARF post unwind library: libdw \ No newline at end of file diff --git a/scripts/perf/4.16/script.sh b/scripts/perf/4.16/script.sh new file mode 100755 index 000000000..152657d15 --- /dev/null +++ b/scripts/perf/4.16/script.sh @@ -0,0 +1,82 @@ +#!/usr/bin/env bash + +MASON_NAME=perf +MASON_VERSION=4.16 +MASON_LIB_FILE=bin/perf + +. ${MASON_DIR}/mason.sh + +function mason_load_source { + # https://www.kernel.org/ + # https://git.kernel.org/cgit/linux/kernel/git/stable/linux-stable.git/log/tools/perf + mason_download \ + https://cdn.kernel.org/pub/linux/kernel/v4.x/linux-${MASON_VERSION}.tar.xz \ + 86ade902aa77bf25b8a49c3a82e02ea82891b5fd + + mason_extract_tar_xz + + export MASON_BUILD_PATH=${MASON_ROOT}/.build/linux-${MASON_VERSION} +} + +function mason_prepare_compile { + ${MASON_DIR}/mason install zlib 1.2.8 + MASON_ZLIB=$(${MASON_DIR}/mason prefix zlib 1.2.8) + ${MASON_DIR}/mason install xz 5.2.3 + MASON_XZ=$(${MASON_DIR}/mason prefix xz 5.2.3) + ${MASON_DIR}/mason install binutils 2.30 + MASON_BINUTILS=$(${MASON_DIR}/mason prefix binutils 2.30) + ${MASON_DIR}/mason install slang 2.3.1 + MASON_SLANG=$(${MASON_DIR}/mason prefix slang 2.3.1) + ${MASON_DIR}/mason install bzip2 1.0.6 + MASON_BZIP2=$(${MASON_DIR}/mason prefix bzip2 1.0.6) + ${MASON_DIR}/mason install elfutils 0.170 + MASON_ELFUTILS=$(${MASON_DIR}/mason prefix elfutils 0.170) + EXTRA_CFLAGS="-m64 -I${MASON_SLANG}/include -I${MASON_ZLIB}/include -I${MASON_XZ}/include -I${MASON_BINUTILS}/include -I${MASON_BZIP2}/include -I${MASON_ELFUTILS}/include" + EXTRA_LDFLAGS="-L${MASON_BZIP2}/lib -L${MASON_ZLIB}/lib -L${MASON_XZ}/lib -L${MASON_SLANG}/lib -L${MASON_ELFUTILS}/lib -L${MASON_BINUTILS}/lib" +} + +# https://perf.wiki.kernel.org/index.php/Jolsa_Howto_Install_Sources +# https://askubuntu.com/questions/50145/how-to-install-perf-monitoring-tool/306683 +# https://www.spinics.net/lists/linux-perf-users/msg03040.html +# https://software.intel.com/en-us/articles/linux-perf-for-intel-vtune-Amplifier-XE +# see the readme.md in this directory for a log of what perf features are enabled +function mason_compile { + cd tools/perf + # we set NO_LIBUNWIND since libdw is used from elfutils which is faster: https://lwn.net/Articles/579508/ + # note: LIBELF is needed for symbols + node --perf_basic_prof_only_functions + mkdir -p output-dir + rm -rf output-dir/* + make \ + O=output-dir \ + LIBDW_LDFLAGS="-L${MASON_ELFUTILS}/lib -Wl,--start-group -ldw -lelf -lebl -llzma -lz -lbz2 -ldl -L${MASON_BZIP2}/lib -L${MASON_XZ}/lib" \ + LIBDW_CFLAGS="-I${MASON_ELFUTILS}/include/" \ + V=1 VF=1 \ + prefix=${MASON_PREFIX} \ + NO_LIBNUMA=1 \ + NO_LIBAUDIT=1 \ + NO_LIBUNWIND=1 \ + NO_BIONIC=1 \ + NO_BACKTRACE=1 \ + NO_LIBCRYPTO=1 \ + NO_LIBPERL=1 \ + NO_GTK2=1 \ + LDFLAGS="${EXTRA_LDFLAGS} -Wl,--start-group -L${MASON_BINUTILS}/lib -lbfd -lopcodes -lelf -lz" \ + NO_LIBPYTHON=1 \ + WERROR=0 \ + EXTRA_CFLAGS="${EXTRA_CFLAGS}" \ + install +} + +function mason_cflags { + : +} + +function mason_ldflags { + : +} + +function mason_static_libs { + : +} + +mason_run "$@" From 3ccf67008ac3885b936fb50fbdda774ec696e86d Mon Sep 17 00:00:00 2001 From: Dane Springmeyer Date: Mon, 2 Apr 2018 11:29:00 -0700 Subject: [PATCH 006/338] try dist:trusty --- scripts/perf/4.16/.travis.yml | 1 + 1 file changed, 1 insertion(+) diff --git a/scripts/perf/4.16/.travis.yml b/scripts/perf/4.16/.travis.yml index 9c5a0f11b..e978963f7 100644 --- a/scripts/perf/4.16/.travis.yml +++ b/scripts/perf/4.16/.travis.yml @@ -4,6 +4,7 @@ matrix: include: - os: linux sudo: false + dist: trusty addons: apt: sources: From 7ce2d554f44ad331cc97b0743822d593deddbd31 Mon Sep 17 00:00:00 2001 From: Dane Springmeyer Date: Thu, 5 Apr 2018 06:48:21 -0700 Subject: [PATCH 007/338] remove unused postgis tests --- scripts/postgis/2.2.2/test.sh | 68 --------------------------------- scripts/postgis/2.3.2-1/test.sh | 65 ------------------------------- scripts/postgis/2.3.2/test.sh | 65 ------------------------------- scripts/postgis/2.4.0/test.sh | 66 -------------------------------- scripts/postgis/2.4.1/test.sh | 66 -------------------------------- 5 files changed, 330 deletions(-) delete mode 100755 scripts/postgis/2.2.2/test.sh delete mode 100755 scripts/postgis/2.3.2-1/test.sh delete mode 100755 scripts/postgis/2.3.2/test.sh delete mode 100755 scripts/postgis/2.4.0/test.sh delete mode 100755 scripts/postgis/2.4.1/test.sh diff --git a/scripts/postgis/2.2.2/test.sh b/scripts/postgis/2.2.2/test.sh deleted file mode 100755 index 6a92e0697..000000000 --- a/scripts/postgis/2.2.2/test.sh +++ /dev/null @@ -1,68 +0,0 @@ -#!/usr/bin/env bash - -set -ue - -if [[ ${PGDATA:-unset} != "unset" ]] || [[ ${PGHOST:-unset} != "unset" ]] || [[ ${PGTEMP_DIR:-unset} != "unset" ]]; then - echo "ERROR: this script deletes \${PGDATA}, \${PGHOST}, and \${PGTEMP_DIR}." - echo "So it will not run if you have these set in your environment" - exit 1 -fi - -export GDAL_PREFIX=$(../../../mason prefix gdal 2.0.2) -# make sure we can init, start, create db, and stop -export PGDATA=./local-postgres -# PGHOST must start with / so therefore must be absolute path -export PGHOST=$(pwd)/local-unix-socket -export PGTEMP_DIR=$(pwd)/local-tmp -export PGPORT=1111 - -# cleanup -function cleanup() { - if [[ -d ${PGDATA} ]]; then rm -r ${PGDATA}; fi - if [[ -d ${PGTEMP_DIR} ]]; then rm -r ${PGTEMP_DIR}; fi - if [[ -d ${PGHOST} ]]; then rm -r ${PGHOST}; fi - rm -f postgres.log - rm -f seattle_washington_water_coast* - rm -f seattle_washington.water.coast* -} - -function setup() { - mkdir ${PGTEMP_DIR} - mkdir ${PGHOST} -} - -function finish { - ./mason_packages/.link/bin/pg_ctl -w stop - cleanup -} - -function pause(){ - read -p "$*" -} - -trap finish EXIT - -cleanup -setup - -if [[ ! -d ./mason_packages/.link ]]; then - ./script.sh link -fi - -./mason_packages/.link/bin/initdb -export PATH=./mason_packages/.link/bin/:${PATH} -export GDAL_DATA=${GDAL_PREFIX}/share/gdal -postgres -k $PGHOST > postgres.log & -sleep 2 -cat postgres.log -createdb template_postgis -psql -l -psql template_postgis -c "CREATE TABLESPACE temp_disk LOCATION '${PGTEMP_DIR}';" -psql template_postgis -c "SET temp_tablespaces TO 'temp_disk';" -psql template_postgis -c "CREATE EXTENSION postgis;" -psql template_postgis -c "SELECT PostGIS_Full_Version();" -curl -OL "https://s3.amazonaws.com/metro-extracts.mapzen.com/seattle_washington.water.coastline.zip" -unzip -o seattle_washington.water.coastline.zip -createdb test-osm -T template_postgis -shp2pgsql -s 4326 seattle_washington_water_coast.shp coast | psql test-osm -psql test-osm -c "SELECT count(*) from coast;" \ No newline at end of file diff --git a/scripts/postgis/2.3.2-1/test.sh b/scripts/postgis/2.3.2-1/test.sh deleted file mode 100755 index 72fdded88..000000000 --- a/scripts/postgis/2.3.2-1/test.sh +++ /dev/null @@ -1,65 +0,0 @@ -#!/usr/bin/env bash - -set -ue - -: ' -Assumes gdal and postgis have been linked - -' - -if [[ ${PGDATA:-unset} != "unset" ]] || [[ ${PGHOST:-unset} != "unset" ]] || [[ ${PGTEMP_DIR:-unset} != "unset" ]]; then - echo "ERROR: this script deletes \${PGDATA}, \${PGHOST}, and \${PGTEMP_DIR}." - echo "So it will not run if you have these set in your environment" - exit 1 -fi - -# make sure we can init, start, create db, and stop -export PGDATA=./local-postgres -# PGHOST must start with / so therefore must be absolute path -export PGHOST=$(pwd)/local-unix-socket -export PGTEMP_DIR=$(pwd)/local-tmp -export PGPORT=1111 - -# cleanup -function cleanup() { - if [[ -d ${PGDATA} ]]; then rm -r ${PGDATA}; fi - if [[ -d ${PGTEMP_DIR} ]]; then rm -r ${PGTEMP_DIR}; fi - if [[ -d ${PGHOST} ]]; then rm -r ${PGHOST}; fi - rm -f postgres.log - rm -f seattle_washington_water_coast* - rm -f seattle_washington.water.coast* -} - -function setup() { - mkdir ${PGTEMP_DIR} - mkdir ${PGHOST} -} - -function finish { - ./mason_packages/.link/bin/pg_ctl -w stop - cleanup -} - -trap finish EXIT - -cleanup -setup - -./mason_packages/.link/bin/initdb -export PATH=./mason_packages/.link/bin/:${PATH} -# must be absolute -export GDAL_DATA=$(pwd)/mason_packages/.link/share/gdal -postgres -k $PGHOST > postgres.log & -sleep 2 -cat postgres.log -createdb template_postgis -psql -l -psql template_postgis -c "CREATE TABLESPACE temp_disk LOCATION '${PGTEMP_DIR}';" -psql template_postgis -c "SET temp_tablespaces TO 'temp_disk';" -psql template_postgis -c "CREATE EXTENSION postgis;" -psql template_postgis -c "SELECT PostGIS_Full_Version();" -curl -OL "https://s3.amazonaws.com/metro-extracts.mapzen.com/seattle_washington.water.coastline.zip" -unzip -o seattle_washington.water.coastline.zip -createdb test-osm -T template_postgis -shp2pgsql -s 4326 seattle_washington_water_coast.shp coast | psql test-osm -psql test-osm -c "SELECT count(*) from coast;" \ No newline at end of file diff --git a/scripts/postgis/2.3.2/test.sh b/scripts/postgis/2.3.2/test.sh deleted file mode 100755 index 72fdded88..000000000 --- a/scripts/postgis/2.3.2/test.sh +++ /dev/null @@ -1,65 +0,0 @@ -#!/usr/bin/env bash - -set -ue - -: ' -Assumes gdal and postgis have been linked - -' - -if [[ ${PGDATA:-unset} != "unset" ]] || [[ ${PGHOST:-unset} != "unset" ]] || [[ ${PGTEMP_DIR:-unset} != "unset" ]]; then - echo "ERROR: this script deletes \${PGDATA}, \${PGHOST}, and \${PGTEMP_DIR}." - echo "So it will not run if you have these set in your environment" - exit 1 -fi - -# make sure we can init, start, create db, and stop -export PGDATA=./local-postgres -# PGHOST must start with / so therefore must be absolute path -export PGHOST=$(pwd)/local-unix-socket -export PGTEMP_DIR=$(pwd)/local-tmp -export PGPORT=1111 - -# cleanup -function cleanup() { - if [[ -d ${PGDATA} ]]; then rm -r ${PGDATA}; fi - if [[ -d ${PGTEMP_DIR} ]]; then rm -r ${PGTEMP_DIR}; fi - if [[ -d ${PGHOST} ]]; then rm -r ${PGHOST}; fi - rm -f postgres.log - rm -f seattle_washington_water_coast* - rm -f seattle_washington.water.coast* -} - -function setup() { - mkdir ${PGTEMP_DIR} - mkdir ${PGHOST} -} - -function finish { - ./mason_packages/.link/bin/pg_ctl -w stop - cleanup -} - -trap finish EXIT - -cleanup -setup - -./mason_packages/.link/bin/initdb -export PATH=./mason_packages/.link/bin/:${PATH} -# must be absolute -export GDAL_DATA=$(pwd)/mason_packages/.link/share/gdal -postgres -k $PGHOST > postgres.log & -sleep 2 -cat postgres.log -createdb template_postgis -psql -l -psql template_postgis -c "CREATE TABLESPACE temp_disk LOCATION '${PGTEMP_DIR}';" -psql template_postgis -c "SET temp_tablespaces TO 'temp_disk';" -psql template_postgis -c "CREATE EXTENSION postgis;" -psql template_postgis -c "SELECT PostGIS_Full_Version();" -curl -OL "https://s3.amazonaws.com/metro-extracts.mapzen.com/seattle_washington.water.coastline.zip" -unzip -o seattle_washington.water.coastline.zip -createdb test-osm -T template_postgis -shp2pgsql -s 4326 seattle_washington_water_coast.shp coast | psql test-osm -psql test-osm -c "SELECT count(*) from coast;" \ No newline at end of file diff --git a/scripts/postgis/2.4.0/test.sh b/scripts/postgis/2.4.0/test.sh deleted file mode 100755 index 5a9b8da5d..000000000 --- a/scripts/postgis/2.4.0/test.sh +++ /dev/null @@ -1,66 +0,0 @@ -#!/usr/bin/env bash - -set -ue - -: ' -Assumes gdal and postgis have been linked - -' - -if [[ ${PGDATA:-unset} != "unset" ]] || [[ ${PGHOST:-unset} != "unset" ]] || [[ ${PGTEMP_DIR:-unset} != "unset" ]]; then - echo "ERROR: this script deletes \${PGDATA}, \${PGHOST}, and \${PGTEMP_DIR}." - echo "So it will not run if you have these set in your environment" - exit 1 -fi - -# make sure we can init, start, create db, and stop -export PGDATA=./local-postgres -# PGHOST must start with / so therefore must be absolute path -export PGHOST=$(pwd)/local-unix-socket -export PGTEMP_DIR=$(pwd)/local-tmp -export PGPORT=1111 - -# cleanup -function cleanup() { - if [[ -d ${PGDATA} ]]; then rm -r ${PGDATA}; fi - if [[ -d ${PGTEMP_DIR} ]]; then rm -r ${PGTEMP_DIR}; fi - if [[ -d ${PGHOST} ]]; then rm -r ${PGHOST}; fi - rm -f postgres.log - rm -f seattle_washington_water_coast* - rm -f seattle_washington.water.coast* -} - -function setup() { - mkdir ${PGTEMP_DIR} - mkdir ${PGHOST} -} - -function finish { - ./mason_packages/.link/bin/pg_ctl -w stop - cleanup -} - -trap finish EXIT - -cleanup -setup - -./mason_packages/.link/bin/initdb -export PATH=./mason_packages/.link/bin/:${PATH} -# must be absolute -export GDAL_DATA=$(pwd)/mason_packages/.link/share/gdal -postgres -k $PGHOST > postgres.log & -sleep 2 -cat postgres.log -createdb template_postgis -psql -l -psql template_postgis -c "CREATE TABLESPACE temp_disk LOCATION '${PGTEMP_DIR}';" -psql template_postgis -c "SET temp_tablespaces TO 'temp_disk';" -psql template_postgis -c "CREATE EXTENSION postgis;" -psql template_postgis -c "SELECT PostGIS_Full_Version();" -psql template_postgis -c "SELECT ST_AsGeoJSON(ST_GeomFromGeoJSON('{ \"type\": \"Point\", \"coordinates\": [0,0] }'));" -curl -OL "https://s3.amazonaws.com/metro-extracts.mapzen.com/seattle_washington.water.coastline.zip" -unzip -o seattle_washington.water.coastline.zip -createdb test-osm -T template_postgis -shp2pgsql -s 4326 seattle_washington_water_coast.shp coast | psql test-osm -psql test-osm -c "SELECT count(*) from coast;" \ No newline at end of file diff --git a/scripts/postgis/2.4.1/test.sh b/scripts/postgis/2.4.1/test.sh deleted file mode 100755 index 5a9b8da5d..000000000 --- a/scripts/postgis/2.4.1/test.sh +++ /dev/null @@ -1,66 +0,0 @@ -#!/usr/bin/env bash - -set -ue - -: ' -Assumes gdal and postgis have been linked - -' - -if [[ ${PGDATA:-unset} != "unset" ]] || [[ ${PGHOST:-unset} != "unset" ]] || [[ ${PGTEMP_DIR:-unset} != "unset" ]]; then - echo "ERROR: this script deletes \${PGDATA}, \${PGHOST}, and \${PGTEMP_DIR}." - echo "So it will not run if you have these set in your environment" - exit 1 -fi - -# make sure we can init, start, create db, and stop -export PGDATA=./local-postgres -# PGHOST must start with / so therefore must be absolute path -export PGHOST=$(pwd)/local-unix-socket -export PGTEMP_DIR=$(pwd)/local-tmp -export PGPORT=1111 - -# cleanup -function cleanup() { - if [[ -d ${PGDATA} ]]; then rm -r ${PGDATA}; fi - if [[ -d ${PGTEMP_DIR} ]]; then rm -r ${PGTEMP_DIR}; fi - if [[ -d ${PGHOST} ]]; then rm -r ${PGHOST}; fi - rm -f postgres.log - rm -f seattle_washington_water_coast* - rm -f seattle_washington.water.coast* -} - -function setup() { - mkdir ${PGTEMP_DIR} - mkdir ${PGHOST} -} - -function finish { - ./mason_packages/.link/bin/pg_ctl -w stop - cleanup -} - -trap finish EXIT - -cleanup -setup - -./mason_packages/.link/bin/initdb -export PATH=./mason_packages/.link/bin/:${PATH} -# must be absolute -export GDAL_DATA=$(pwd)/mason_packages/.link/share/gdal -postgres -k $PGHOST > postgres.log & -sleep 2 -cat postgres.log -createdb template_postgis -psql -l -psql template_postgis -c "CREATE TABLESPACE temp_disk LOCATION '${PGTEMP_DIR}';" -psql template_postgis -c "SET temp_tablespaces TO 'temp_disk';" -psql template_postgis -c "CREATE EXTENSION postgis;" -psql template_postgis -c "SELECT PostGIS_Full_Version();" -psql template_postgis -c "SELECT ST_AsGeoJSON(ST_GeomFromGeoJSON('{ \"type\": \"Point\", \"coordinates\": [0,0] }'));" -curl -OL "https://s3.amazonaws.com/metro-extracts.mapzen.com/seattle_washington.water.coastline.zip" -unzip -o seattle_washington.water.coastline.zip -createdb test-osm -T template_postgis -shp2pgsql -s 4326 seattle_washington_water_coast.shp coast | psql test-osm -psql test-osm -c "SELECT count(*) from coast;" \ No newline at end of file From ed35f977ebf941e63a7affea90e0434ecb16bec9 Mon Sep 17 00:00:00 2001 From: Artem Pavlenko Date: Thu, 12 Apr 2018 15:12:18 +0200 Subject: [PATCH 008/338] added mapnik 3.0.20 --- scripts/mapnik/3.0.20/.travis.yml | 19 ++++ scripts/mapnik/3.0.20/script.sh | 177 ++++++++++++++++++++++++++++++ 2 files changed, 196 insertions(+) create mode 100644 scripts/mapnik/3.0.20/.travis.yml create mode 100755 scripts/mapnik/3.0.20/script.sh diff --git a/scripts/mapnik/3.0.20/.travis.yml b/scripts/mapnik/3.0.20/.travis.yml new file mode 100644 index 000000000..629abe9b1 --- /dev/null +++ b/scripts/mapnik/3.0.20/.travis.yml @@ -0,0 +1,19 @@ +language: generic + +matrix: + include: + - os: osx + osx_image: xcode8.2 + - os: linux + sudo: false + addons: + apt: + sources: + - ubuntu-toolchain-r-test + packages: + - libstdc++-4.9-dev + - xutils-dev + +script: +- ./mason build ${MASON_NAME} ${MASON_VERSION} +- ./mason publish ${MASON_NAME} ${MASON_VERSION} diff --git a/scripts/mapnik/3.0.20/script.sh b/scripts/mapnik/3.0.20/script.sh new file mode 100755 index 000000000..e03a9c3f7 --- /dev/null +++ b/scripts/mapnik/3.0.20/script.sh @@ -0,0 +1,177 @@ +#!/usr/bin/env bash + +MASON_NAME=mapnik +MASON_VERSION=3.0.20 +MASON_LIB_FILE=lib/libmapnik.${MASON_DYNLIB_SUFFIX} + +. ${MASON_DIR}/mason.sh + +function mason_load_source { + mason_download \ + https://github.com/mapnik/mapnik/releases/download/v${MASON_VERSION}/mapnik-v${MASON_VERSION}.tar.bz2 \ + d75452b32c0376d105f40160432a1f9188fc8326 + mason_extract_tar_bz2 + + export MASON_BUILD_PATH=${MASON_ROOT}/.build/mapnik-v${MASON_VERSION} +} + +function install() { + ${MASON_DIR}/mason install $1 $2 + MASON_PLATFORM_ID=$(${MASON_DIR}/mason env MASON_PLATFORM_ID) + if [[ ! -d ${MASON_ROOT}/${MASON_PLATFORM_ID}/${1}/${2} ]]; then + if [[ ${3:-false} != false ]]; then + LA_FILE=$(${MASON_DIR}/mason prefix $1 $2)/lib/$3.la + if [[ -f ${LA_FILE} ]]; then + perl -i -p -e 's:\Q$ENV{HOME}/build/mapbox/mason\E:$ENV{PWD}:g' ${LA_FILE} + else + echo "$LA_FILE not found" + fi + fi + fi + ${MASON_DIR}/mason link $1 $2 +} + +ICU_VERSION="57.1" + +function mason_prepare_compile { + install jpeg_turbo 1.5.1 libjpeg + install libpng 1.6.28 libpng + install libtiff 4.0.7 libtiff + install libpq 9.6.2 + install sqlite 3.17.0 libsqlite3 + install expat 2.2.0 libexpat + install icu ${ICU_VERSION} + install proj 4.9.3 libproj + install pixman 0.34.0 libpixman-1 + install cairo 1.14.8 libcairo + install webp 0.6.0 libwebp + install libgdal 2.1.3 libgdal + install boost 1.65.1 + install boost_libsystem 1.65.1 + install boost_libfilesystem 1.65.1 + install boost_libprogram_options 1.65.1 + install boost_libregex_icu57 1.65.1 + install freetype 2.7.1 libfreetype + install harfbuzz 1.4.2-ft libharfbuzz +} + +function mason_compile { + export PATH="${MASON_ROOT}/.link/bin:${PATH}" + MASON_LINKED_REL="${MASON_ROOT}/.link" + MASON_LINKED_ABS="${MASON_ROOT}/.link" + + if [[ $(uname -s) == 'Linux' ]]; then + echo "CUSTOM_LDFLAGS = '${LDFLAGS} -Wl,-z,origin -Wl,-rpath=\\\$\$ORIGIN/../lib/ -Wl,-rpath=\\\$\$ORIGIN/../../'" > config.py + echo "CUSTOM_CXXFLAGS = '${CXXFLAGS} -D_GLIBCXX_USE_CXX11_ABI=0'" >> config.py + else + echo "CUSTOM_LDFLAGS = '${LDFLAGS}'" > config.py + echo "CUSTOM_CXXFLAGS = '${CXXFLAGS}'" >> config.py + fi + + # setup `mapnik-settings.env` (like bootstrap.sh does) + # note: we don't use bootstrap.sh to be able to control + # mason versions here and use the mason we are running + echo "export PROJ_LIB=${MASON_LINKED_ABS}/share/proj" > mapnik-settings.env + echo "export ICU_DATA=${MASON_LINKED_ABS}/share/icu/${ICU_VERSION}" >> mapnik-settings.env + echo "export GDAL_DATA=${MASON_LINKED_ABS}/share/gdal" >> mapnik-settings.env + + RESULT=0 + + ./configure \ + CXX="${CXX}" \ + CC="${CC}" \ + PREFIX="${MASON_PREFIX}" \ + RUNTIME_LINK="static" \ + INPUT_PLUGINS="all" \ + ENABLE_GLIBC_WORKAROUND=True \ + ENABLE_SONAME=False \ + PKG_CONFIG_PATH="${MASON_LINKED_REL}/lib/pkgconfig" \ + PATH_REMOVE="/usr:/usr/local" \ + BOOST_INCLUDES="${MASON_LINKED_REL}/include" \ + BOOST_LIBS="${MASON_LINKED_REL}/lib" \ + ICU_INCLUDES="${MASON_LINKED_REL}/include" \ + ICU_LIBS="${MASON_LINKED_REL}/lib" \ + HB_INCLUDES="${MASON_LINKED_REL}/include" \ + HB_LIBS="${MASON_LINKED_REL}/lib" \ + PNG_INCLUDES="${MASON_LINKED_REL}/include/libpng16" \ + PNG_LIBS="${MASON_LINKED_REL}/lib" \ + JPEG_INCLUDES="${MASON_LINKED_REL}/include" \ + JPEG_LIBS="${MASON_LINKED_REL}/lib" \ + TIFF_INCLUDES="${MASON_LINKED_REL}/include" \ + TIFF_LIBS="${MASON_LINKED_REL}/lib" \ + WEBP_INCLUDES="${MASON_LINKED_REL}/include" \ + WEBP_LIBS="${MASON_LINKED_REL}/lib" \ + PROJ_INCLUDES="${MASON_LINKED_REL}/include" \ + PROJ_LIBS="${MASON_LINKED_REL}/lib" \ + PG_INCLUDES="${MASON_LINKED_REL}/include" \ + PG_LIBS="${MASON_LINKED_REL}/lib" \ + FREETYPE_INCLUDES="${MASON_LINKED_REL}/include/freetype2" \ + FREETYPE_LIBS="${MASON_LINKED_REL}/lib" \ + SVG_RENDERER=True \ + CAIRO_INCLUDES="${MASON_LINKED_REL}/include" \ + CAIRO_LIBS="${MASON_LINKED_REL}/lib" \ + SQLITE_INCLUDES="${MASON_LINKED_REL}/include" \ + SQLITE_LIBS="${MASON_LINKED_REL}/lib" \ + GDAL_CONFIG="${MASON_LINKED_REL}/bin/gdal-config" \ + PG_CONFIG="${MASON_LINKED_REL}/bin/pg_config" \ + BENCHMARK=False \ + CPP_TESTS=False \ + PGSQL2SQLITE=True \ + SAMPLE_INPUT_PLUGINS=False \ + DEMO=False \ + XMLPARSER="ptree" \ + NO_ATEXIT=True \ + SVG2PNG=True || RESULT=$? + + # if configure failed, dump out config details before exiting + if [[ ${RESULT} != 0 ]]; then + cat ${MASON_BUILD_PATH}"/config.log" + cat config.py + false # then fail + fi + + # limit concurrency on travis to avoid heavy jobs being killed + if [[ ${TRAVIS_OS_NAME:-} ]]; then + JOBS=4 make + else + JOBS=${MASON_CONCURRENCY} make + fi + + make install + if [[ $(uname -s) == 'Darwin' ]]; then + install_name_tool -id @loader_path/lib/libmapnik.dylib ${MASON_PREFIX}"/lib/libmapnik.dylib"; + PLUGINDIRS=${MASON_PREFIX}"/lib/mapnik/input/*.input"; + for f in $PLUGINDIRS; do + echo $f; + echo `basename $f`; + install_name_tool -id plugins/input/`basename $f` $f; + install_name_tool -change ${MASON_PREFIX}"/lib/libmapnik.dylib" @loader_path/../../../lib/libmapnik.dylib $f; + done; + # command line tools + install_name_tool -change ${MASON_PREFIX}"/lib/libmapnik.dylib" @loader_path/../lib/libmapnik.dylib ${MASON_PREFIX}"/bin/mapnik-index" + install_name_tool -change ${MASON_PREFIX}"/lib/libmapnik.dylib" @loader_path/../lib/libmapnik.dylib ${MASON_PREFIX}"/bin/mapnik-render" + install_name_tool -change ${MASON_PREFIX}"/lib/libmapnik.dylib" @loader_path/../lib/libmapnik.dylib ${MASON_PREFIX}"/bin/shapeindex" + fi + # fix mapnik-config entries for deps + HERE=$(pwd) + python -c "data=open('$MASON_PREFIX/bin/mapnik-config','r').read();open('$MASON_PREFIX/bin/mapnik-config','w').write(data.replace('$HERE','.').replace('${MASON_ROOT}','./mason_packages'))" + cat $MASON_PREFIX/bin/mapnik-config +} + +function mason_cflags { + ${MASON_PREFIX}/bin/mapnik-config --cflags +} + +function mason_ldflags { + ${MASON_PREFIX}/bin/mapnik-config --ldflags +} + +function mason_static_libs { + ${MASON_PREFIX}/bin/mapnik-config --dep-libs +} + +function mason_clean { + make clean +} + +mason_run "$@" From 7aa098efe1b21291d73e60fa98c8309221b0a2c2 Mon Sep 17 00:00:00 2001 From: allieoop Date: Fri, 13 Apr 2018 14:22:07 -0700 Subject: [PATCH 009/338] vtzero 1.0.1 --- scripts/vtzero/1.0.1/.travis.yml | 12 ++++++++++++ scripts/vtzero/1.0.1/script.sh | 33 ++++++++++++++++++++++++++++++++ 2 files changed, 45 insertions(+) create mode 100644 scripts/vtzero/1.0.1/.travis.yml create mode 100644 scripts/vtzero/1.0.1/script.sh diff --git a/scripts/vtzero/1.0.1/.travis.yml b/scripts/vtzero/1.0.1/.travis.yml new file mode 100644 index 000000000..7635baa54 --- /dev/null +++ b/scripts/vtzero/1.0.1/.travis.yml @@ -0,0 +1,12 @@ +language: generic + +matrix: + include: + - os: linux + sudo: false + +script: +- ./mason build ${MASON_NAME} ${MASON_VERSION} + +after_success: +- ./mason publish ${MASON_NAME} ${MASON_VERSION} \ No newline at end of file diff --git a/scripts/vtzero/1.0.1/script.sh b/scripts/vtzero/1.0.1/script.sh new file mode 100644 index 000000000..030da7d84 --- /dev/null +++ b/scripts/vtzero/1.0.1/script.sh @@ -0,0 +1,33 @@ +#!/usr/bin/env bash + +MASON_NAME=vtzero +MASON_VERSION=1.0.1 +MASON_HEADER_ONLY=true + +. ${MASON_DIR}/mason.sh + +function mason_load_source { + mason_download \ + https://github.com/mapbox/vtzero/archive/v${MASON_VERSION}.tar.gz \ + 5492c5177d413f362acf1a166bad43264f21d6f8 + + mason_extract_tar_gz + + export MASON_BUILD_PATH=${MASON_ROOT}/.build/vtzero-${MASON_VERSION} +} + +function mason_compile { + mkdir -p ${MASON_PREFIX}/include/ + cp -r include/vtzero ${MASON_PREFIX}/include/vtzero +} + +function mason_cflags { + echo "-I${MASON_PREFIX}/include" +} + +function mason_ldflags { + : +} + + +mason_run "$@" From d7b7c17d7598fca65c5988297503731dfdcff7e0 Mon Sep 17 00:00:00 2001 From: Sam Matthews Date: Thu, 19 Apr 2018 12:54:52 -0700 Subject: [PATCH 010/338] add protozero 1.6.2 (#597) --- scripts/protozero/1.6.2/.travis.yml | 10 +++++++++ scripts/protozero/1.6.2/script.sh | 32 +++++++++++++++++++++++++++++ 2 files changed, 42 insertions(+) create mode 100644 scripts/protozero/1.6.2/.travis.yml create mode 100644 scripts/protozero/1.6.2/script.sh diff --git a/scripts/protozero/1.6.2/.travis.yml b/scripts/protozero/1.6.2/.travis.yml new file mode 100644 index 000000000..15c3ad555 --- /dev/null +++ b/scripts/protozero/1.6.2/.travis.yml @@ -0,0 +1,10 @@ +language: generic + +matrix: + include: + - os: linux + sudo: false + +script: +- ./mason build ${MASON_NAME} ${MASON_VERSION} +- ./mason publish ${MASON_NAME} ${MASON_VERSION} diff --git a/scripts/protozero/1.6.2/script.sh b/scripts/protozero/1.6.2/script.sh new file mode 100644 index 000000000..e8c0e0a49 --- /dev/null +++ b/scripts/protozero/1.6.2/script.sh @@ -0,0 +1,32 @@ +#!/usr/bin/env bash + +MASON_NAME=protozero +MASON_VERSION=1.6.2 +MASON_HEADER_ONLY=true + +. ${MASON_DIR}/mason.sh + +function mason_load_source { + mason_download \ + https://github.com/mapbox/protozero/archive/v${MASON_VERSION}.tar.gz \ + 6c9cc925fc9aee4285d5bd489c2f3978a3d66b84 + + mason_extract_tar_gz + + export MASON_BUILD_PATH=${MASON_ROOT}/.build/protozero-${MASON_VERSION} +} + +function mason_compile { + mkdir -p ${MASON_PREFIX}/include/ + cp -r include/protozero ${MASON_PREFIX}/include/protozero +} + +function mason_cflags { + echo "-I${MASON_PREFIX}/include" +} + +function mason_ldflags { + : +} + +mason_run "$@" From f6950c9dc80565302a27ffa917c7ef92449ea9e8 Mon Sep 17 00:00:00 2001 From: Sam Matthews Date: Fri, 20 Apr 2018 15:05:41 -0700 Subject: [PATCH 011/338] add tippecanoe 1.27.14 scripts (#598) --- scripts/tippecanoe/1.27.14/.travis.yml | 14 +++++ scripts/tippecanoe/1.27.14/script.sh | 75 ++++++++++++++++++++++++++ 2 files changed, 89 insertions(+) create mode 100644 scripts/tippecanoe/1.27.14/.travis.yml create mode 100644 scripts/tippecanoe/1.27.14/script.sh diff --git a/scripts/tippecanoe/1.27.14/.travis.yml b/scripts/tippecanoe/1.27.14/.travis.yml new file mode 100644 index 000000000..87e5b68e9 --- /dev/null +++ b/scripts/tippecanoe/1.27.14/.travis.yml @@ -0,0 +1,14 @@ +language: generic + +matrix: + include: + - os: osx + osx_image: xcode8 + compiler: clang + - os: linux + compiler: clang + sudo: false + +script: +- ./mason build ${MASON_NAME} ${MASON_VERSION} +- ./mason publish ${MASON_NAME} ${MASON_VERSION} diff --git a/scripts/tippecanoe/1.27.14/script.sh b/scripts/tippecanoe/1.27.14/script.sh new file mode 100644 index 000000000..584da5917 --- /dev/null +++ b/scripts/tippecanoe/1.27.14/script.sh @@ -0,0 +1,75 @@ +#!/usr/bin/env bash + +MASON_NAME=tippecanoe +MASON_VERSION=1.27.14 +MASON_LIB_FILE=bin/tippecanoe + +. ${MASON_DIR}/mason.sh + +function mason_load_source { + mason_download \ + https://github.com/mapbox/tippecanoe/archive/${MASON_VERSION}.tar.gz \ + 4b14cd6ec4bea9afa47f1b15c21a36e5d356dd3e + + mason_extract_tar_gz + + export MASON_BUILD_PATH=${MASON_ROOT}/.build/${MASON_NAME}-${MASON_VERSION} +} + +SQLITE_VERSION=3.16.2 + +function mason_prepare_compile { + LLVM_VERSION="7.0.0" + ${MASON_DIR}/mason install llvm ${LLVM_VERSION} + MASON_LLVM=$(${MASON_DIR}/mason prefix llvm ${LLVM_VERSION}) + ${MASON_DIR}/mason install sqlite ${SQLITE_VERSION} + MASON_SQLITE=$(${MASON_DIR}/mason prefix sqlite ${SQLITE_VERSION}) +} + +function mason_compile { + # Use llvm 7.x to statically link libc++ + # https://github.com/mapbox/mason/pull/545#issuecomment-367082479 + export CXX="${MASON_LLVM}/bin/clang++" + export CC="${MASON_LLVM}/bin/clang" + LDFLAGS="${LDFLAGS} -stdlib=libc++" + if [[ $(uname -s) == 'Linux' ]]; then + CXXFLAGS="-nostdinc++ -I${MASON_LLVM}/include/c++/v1" + LDFLAGS="${LDFLAGS} -nostdlib++ ${MASON_LLVM}/lib/libc++.a" + LDFLAGS="${LDFLAGS} ${MASON_LLVM}/lib/libc++abi.a" + LDFLAGS="${LDFLAGS} ${MASON_LLVM}/lib/libunwind.a -rtlib=compiler-rt" + fi + + # knock out /usr/local to ensure libsqlite without a doubt that + # sqlite from from mason is used + perl -i -p -e "s/-L\/usr\/local\/lib//g;" Makefile + perl -i -p -e "s/-I\/usr\/local\/include//g;" Makefile + + + PREFIX=${MASON_PREFIX} \ + PATH=${MASON_SQLITE}/bin:${PATH} \ + CXXFLAGS="${CXXFLAGS} -I${MASON_SQLITE}/include" \ + LDFLAGS="${LDFLAGS} -L${MASON_SQLITE}/lib -ldl -lpthread" make + + PREFIX=${MASON_PREFIX} \ + PATH=${MASON_SQLITE}/bin:${PATH} \ + CXXFLAGS="${CXXFLAGS} -I${MASON_SQLITE}/include" \ + LDFLAGS="${LDFLAGS} -L${MASON_SQLITE}/lib -ldl -lpthread" make install +} + +function mason_cflags { + : +} + +function mason_ldflags { + : +} + +function mason_static_libs { + : +} + +function mason_clean { + make clean +} + +mason_run "$@" From 95fb364f817a696c8f9d2a1345270751fcd8baa0 Mon Sep 17 00:00:00 2001 From: Dane Springmeyer Date: Sun, 22 Apr 2018 13:19:55 -0700 Subject: [PATCH 012/338] boost 1.67.0 --- scripts/boost/1.67.0/.travis.yml | 10 ++ scripts/boost/1.67.0/base.sh | 12 +++ scripts/boost/1.67.0/common.sh | 64 +++++++++++++ scripts/boost/1.67.0/script.sh | 61 ++++++++++++ scripts/boost_libatomic/1.67.0/.travis.yml | 19 ++++ scripts/boost_libatomic/1.67.0/script.sh | 26 +++++ scripts/boost_libchrono/1.67.0/.travis.yml | 19 ++++ scripts/boost_libchrono/1.67.0/script.sh | 26 +++++ scripts/boost_libdate_time/1.67.0/.travis.yml | 19 ++++ scripts/boost_libdate_time/1.67.0/script.sh | 26 +++++ .../boost_libfilesystem/1.67.0/.travis.yml | 19 ++++ scripts/boost_libfilesystem/1.67.0/script.sh | 26 +++++ scripts/boost_libiostreams/1.67.0/.travis.yml | 19 ++++ scripts/boost_libiostreams/1.67.0/script.sh | 26 +++++ .../1.67.0/.travis.yml | 19 ++++ .../boost_libprogram_options/1.67.0/script.sh | 26 +++++ scripts/boost_libpython/1.67.0/.travis.yml | 19 ++++ scripts/boost_libpython/1.67.0/patch.diff | 12 +++ scripts/boost_libpython/1.67.0/script.sh | 96 +++++++++++++++++++ scripts/boost_libregex/1.67.0/.travis.yml | 19 ++++ scripts/boost_libregex/1.67.0/script.sh | 26 +++++ scripts/boost_libregex_icu/1.67.0/.travis.yml | 19 ++++ scripts/boost_libregex_icu/1.67.0/script.sh | 58 +++++++++++ .../boost_libregex_icu57/1.67.0/.travis.yml | 18 ++++ scripts/boost_libregex_icu57/1.67.0/script.sh | 58 +++++++++++ scripts/boost_libsystem/1.67.0/.travis.yml | 19 ++++ scripts/boost_libsystem/1.67.0/script.sh | 26 +++++ scripts/boost_libtest/1.67.0/.travis.yml | 19 ++++ scripts/boost_libtest/1.67.0/script.sh | 26 +++++ scripts/boost_libthread/1.67.0/.travis.yml | 19 ++++ scripts/boost_libthread/1.67.0/script.sh | 26 +++++ 31 files changed, 877 insertions(+) create mode 100644 scripts/boost/1.67.0/.travis.yml create mode 100644 scripts/boost/1.67.0/base.sh create mode 100644 scripts/boost/1.67.0/common.sh create mode 100755 scripts/boost/1.67.0/script.sh create mode 100644 scripts/boost_libatomic/1.67.0/.travis.yml create mode 100755 scripts/boost_libatomic/1.67.0/script.sh create mode 100644 scripts/boost_libchrono/1.67.0/.travis.yml create mode 100755 scripts/boost_libchrono/1.67.0/script.sh create mode 100644 scripts/boost_libdate_time/1.67.0/.travis.yml create mode 100755 scripts/boost_libdate_time/1.67.0/script.sh create mode 100644 scripts/boost_libfilesystem/1.67.0/.travis.yml create mode 100755 scripts/boost_libfilesystem/1.67.0/script.sh create mode 100644 scripts/boost_libiostreams/1.67.0/.travis.yml create mode 100755 scripts/boost_libiostreams/1.67.0/script.sh create mode 100644 scripts/boost_libprogram_options/1.67.0/.travis.yml create mode 100755 scripts/boost_libprogram_options/1.67.0/script.sh create mode 100644 scripts/boost_libpython/1.67.0/.travis.yml create mode 100644 scripts/boost_libpython/1.67.0/patch.diff create mode 100755 scripts/boost_libpython/1.67.0/script.sh create mode 100644 scripts/boost_libregex/1.67.0/.travis.yml create mode 100755 scripts/boost_libregex/1.67.0/script.sh create mode 100644 scripts/boost_libregex_icu/1.67.0/.travis.yml create mode 100755 scripts/boost_libregex_icu/1.67.0/script.sh create mode 100644 scripts/boost_libregex_icu57/1.67.0/.travis.yml create mode 100755 scripts/boost_libregex_icu57/1.67.0/script.sh create mode 100644 scripts/boost_libsystem/1.67.0/.travis.yml create mode 100755 scripts/boost_libsystem/1.67.0/script.sh create mode 100644 scripts/boost_libtest/1.67.0/.travis.yml create mode 100755 scripts/boost_libtest/1.67.0/script.sh create mode 100644 scripts/boost_libthread/1.67.0/.travis.yml create mode 100755 scripts/boost_libthread/1.67.0/script.sh diff --git a/scripts/boost/1.67.0/.travis.yml b/scripts/boost/1.67.0/.travis.yml new file mode 100644 index 000000000..15c3ad555 --- /dev/null +++ b/scripts/boost/1.67.0/.travis.yml @@ -0,0 +1,10 @@ +language: generic + +matrix: + include: + - os: linux + sudo: false + +script: +- ./mason build ${MASON_NAME} ${MASON_VERSION} +- ./mason publish ${MASON_NAME} ${MASON_VERSION} diff --git a/scripts/boost/1.67.0/base.sh b/scripts/boost/1.67.0/base.sh new file mode 100644 index 000000000..fc5d10b07 --- /dev/null +++ b/scripts/boost/1.67.0/base.sh @@ -0,0 +1,12 @@ +#!/usr/bin/env bash + +# NOTE: use the ./utils/new_boost.sh script to create new versions + +export MASON_VERSION=1.67.0 +export BOOST_VERSION=${MASON_VERSION//./_} +export BOOST_TOOLSET=$(basename ${CC}) +export BOOST_TOOLSET_CXX=$(basename ${CXX}) +export BOOST_ARCH="x86" +export BOOST_SHASUM=6dde6a5f874a5dfa75865e4430ff9248a43cab07 +# special override to ensure each library shares the cached download +export MASON_DOWNLOAD_SLUG="boost-${MASON_VERSION}" diff --git a/scripts/boost/1.67.0/common.sh b/scripts/boost/1.67.0/common.sh new file mode 100644 index 000000000..70c45d38a --- /dev/null +++ b/scripts/boost/1.67.0/common.sh @@ -0,0 +1,64 @@ +#!/usr/bin/env bash + +function mason_load_source { + mason_download \ + http://downloads.sourceforge.net/project/boost/boost/${MASON_VERSION}/boost_${BOOST_VERSION}.tar.bz2 \ + ${BOOST_SHASUM} + + export MASON_BUILD_PATH=${MASON_ROOT}/.build/boost_${BOOST_VERSION} + + mason_extract_tar_bz2 +} + +function gen_config() { + echo "using $1 : : $(which $2)" > user-config.jam + if [[ "${AR:-false}" != false ]] || [[ "${RANLIB:-false}" != false ]]; then + echo ' : ' >> user-config.jam + if [[ "${AR:-false}" != false ]]; then + echo "${AR} " >> user-config.jam + fi + if [[ "${RANLIB:-false}" != false ]]; then + echo "${RANLIB} " >> user-config.jam + fi + fi + echo ' ;' >> user-config.jam +} + +function mason_compile { + gen_config ${BOOST_TOOLSET} ${BOOST_TOOLSET_CXX} + if [[ ! -f ./b2 ]] ; then + ./bootstrap.sh + fi + ./b2 \ + --with-${BOOST_LIBRARY} \ + --prefix=${MASON_PREFIX} \ + -j${MASON_CONCURRENCY} \ + -d0 \ + --ignore-site-config --user-config=user-config.jam \ + architecture="${BOOST_ARCH}" \ + toolset="${BOOST_TOOLSET}" \ + link=static \ + variant=release \ + linkflags="${LDFLAGS:-" "}" \ + cxxflags="${CXXFLAGS:-" "}" \ + stage + mkdir -p $(dirname ${MASON_PREFIX}/${MASON_LIB_FILE}) + mv stage/${MASON_LIB_FILE} ${MASON_PREFIX}/${MASON_LIB_FILE} +} + +function mason_prefix { + echo "${MASON_PREFIX}" +} + +function mason_cflags { + echo "-I${MASON_PREFIX}/include" +} + +function mason_ldflags { + local LOCAL_LDFLAGS + LOCAL_LDFLAGS="-L${MASON_PREFIX}/lib" + if [[ ${BOOST_LIBRARY:-false} != false ]]; then + LOCAL_LDFLAGS="${LOCAL_LDFLAGS} -lboost_${BOOST_LIBRARY}" + fi + echo $LOCAL_LDFLAGS +} diff --git a/scripts/boost/1.67.0/script.sh b/scripts/boost/1.67.0/script.sh new file mode 100755 index 000000000..2790bbe9a --- /dev/null +++ b/scripts/boost/1.67.0/script.sh @@ -0,0 +1,61 @@ +#!/usr/bin/env bash + +HERE="$( cd "$( dirname "${BASH_SOURCE[0]}" )" > /dev/null && pwd )" + +# inherit from boost base (used for all boost library packages) +source ${HERE}/base.sh + +# this package is the one that is header-only +MASON_NAME=boost +MASON_HEADER_ONLY=true + +# setup mason env +. ${MASON_DIR}/mason.sh + +# source common build functions +source ${HERE}/common.sh + +# override default unpacking to just unpack headers +function mason_load_source { + mason_download \ + http://downloads.sourceforge.net/project/boost/boost/${MASON_VERSION}/boost_${BOOST_VERSION}.tar.bz2 \ + ${BOOST_SHASUM} + + mason_extract_tar_bz2 boost_${BOOST_VERSION}/boost + + MASON_BUILD_PATH=${MASON_ROOT}/.build/boost_${BOOST_VERSION} +} + +# override default "compile" target for just the header install +function mason_compile { + mkdir -p ${MASON_PREFIX}/include + cp -r ${MASON_ROOT}/.build/boost_${BOOST_VERSION}/boost ${MASON_PREFIX}/include + + # work around NDK bug https://code.google.com/p/android/issues/detail?id=79483 + + patch ${MASON_PREFIX}/include/boost/core/demangle.hpp <<< "19a20,21 +> #if !defined(__ANDROID__) +> +25a28,29 +> #endif +> +" + + # work around https://github.com/Project-OSRM/node-osrm/issues/191 + patch ${MASON_PREFIX}/include/boost/interprocess/detail/os_file_functions.hpp <<< "471c471 +< return ::open(name, (int)mode); +--- +> return ::open(name, (int)mode,S_IRUSR|S_IWUSR); +" + +} + +function mason_ldflags { + : +} + +function mason_static_libs { + : +} + +mason_run "$@" diff --git a/scripts/boost_libatomic/1.67.0/.travis.yml b/scripts/boost_libatomic/1.67.0/.travis.yml new file mode 100644 index 000000000..69bd2e783 --- /dev/null +++ b/scripts/boost_libatomic/1.67.0/.travis.yml @@ -0,0 +1,19 @@ +language: generic + +matrix: + include: + - os: osx + osx_image: xcode8 + compiler: clang + - os: linux + sudo: false + addons: + apt: + sources: + - ubuntu-toolchain-r-test + packages: + - libstdc++-4.8-dev + +script: +- ./mason build ${MASON_NAME} ${MASON_VERSION} +- ./mason publish ${MASON_NAME} ${MASON_VERSION} diff --git a/scripts/boost_libatomic/1.67.0/script.sh b/scripts/boost_libatomic/1.67.0/script.sh new file mode 100755 index 000000000..24b9c6418 --- /dev/null +++ b/scripts/boost_libatomic/1.67.0/script.sh @@ -0,0 +1,26 @@ +#!/usr/bin/env bash + +# dynamically determine the path to this package +HERE="$( cd "$( dirname "${BASH_SOURCE[0]}" )" > /dev/null && pwd )" + +# key properties unique to this library +THIS_DIR=$(basename $(dirname $HERE)) +BOOST_LIBRARY=${THIS_DIR#boost_lib} +MASON_NAME=boost_lib${BOOST_LIBRARY} +MASON_LIB_FILE=lib/libboost_${BOOST_LIBRARY}.a +# hack for inconsistently named test lib +if [[ ${MASON_LIB_FILE} == "lib/libboost_test.a" ]]; then + MASON_LIB_FILE=lib/libboost_unit_test_framework.a +fi + +# inherit from boost base (used for all boost library packages) +BASE_PATH=${HERE}/../../boost/$(basename $HERE) +source ${BASE_PATH}/base.sh + +# setup mason env +. ${MASON_DIR}/mason.sh + +# source common build functions +source ${BASE_PATH}/common.sh + +mason_run "$@" diff --git a/scripts/boost_libchrono/1.67.0/.travis.yml b/scripts/boost_libchrono/1.67.0/.travis.yml new file mode 100644 index 000000000..69bd2e783 --- /dev/null +++ b/scripts/boost_libchrono/1.67.0/.travis.yml @@ -0,0 +1,19 @@ +language: generic + +matrix: + include: + - os: osx + osx_image: xcode8 + compiler: clang + - os: linux + sudo: false + addons: + apt: + sources: + - ubuntu-toolchain-r-test + packages: + - libstdc++-4.8-dev + +script: +- ./mason build ${MASON_NAME} ${MASON_VERSION} +- ./mason publish ${MASON_NAME} ${MASON_VERSION} diff --git a/scripts/boost_libchrono/1.67.0/script.sh b/scripts/boost_libchrono/1.67.0/script.sh new file mode 100755 index 000000000..24b9c6418 --- /dev/null +++ b/scripts/boost_libchrono/1.67.0/script.sh @@ -0,0 +1,26 @@ +#!/usr/bin/env bash + +# dynamically determine the path to this package +HERE="$( cd "$( dirname "${BASH_SOURCE[0]}" )" > /dev/null && pwd )" + +# key properties unique to this library +THIS_DIR=$(basename $(dirname $HERE)) +BOOST_LIBRARY=${THIS_DIR#boost_lib} +MASON_NAME=boost_lib${BOOST_LIBRARY} +MASON_LIB_FILE=lib/libboost_${BOOST_LIBRARY}.a +# hack for inconsistently named test lib +if [[ ${MASON_LIB_FILE} == "lib/libboost_test.a" ]]; then + MASON_LIB_FILE=lib/libboost_unit_test_framework.a +fi + +# inherit from boost base (used for all boost library packages) +BASE_PATH=${HERE}/../../boost/$(basename $HERE) +source ${BASE_PATH}/base.sh + +# setup mason env +. ${MASON_DIR}/mason.sh + +# source common build functions +source ${BASE_PATH}/common.sh + +mason_run "$@" diff --git a/scripts/boost_libdate_time/1.67.0/.travis.yml b/scripts/boost_libdate_time/1.67.0/.travis.yml new file mode 100644 index 000000000..69bd2e783 --- /dev/null +++ b/scripts/boost_libdate_time/1.67.0/.travis.yml @@ -0,0 +1,19 @@ +language: generic + +matrix: + include: + - os: osx + osx_image: xcode8 + compiler: clang + - os: linux + sudo: false + addons: + apt: + sources: + - ubuntu-toolchain-r-test + packages: + - libstdc++-4.8-dev + +script: +- ./mason build ${MASON_NAME} ${MASON_VERSION} +- ./mason publish ${MASON_NAME} ${MASON_VERSION} diff --git a/scripts/boost_libdate_time/1.67.0/script.sh b/scripts/boost_libdate_time/1.67.0/script.sh new file mode 100755 index 000000000..24b9c6418 --- /dev/null +++ b/scripts/boost_libdate_time/1.67.0/script.sh @@ -0,0 +1,26 @@ +#!/usr/bin/env bash + +# dynamically determine the path to this package +HERE="$( cd "$( dirname "${BASH_SOURCE[0]}" )" > /dev/null && pwd )" + +# key properties unique to this library +THIS_DIR=$(basename $(dirname $HERE)) +BOOST_LIBRARY=${THIS_DIR#boost_lib} +MASON_NAME=boost_lib${BOOST_LIBRARY} +MASON_LIB_FILE=lib/libboost_${BOOST_LIBRARY}.a +# hack for inconsistently named test lib +if [[ ${MASON_LIB_FILE} == "lib/libboost_test.a" ]]; then + MASON_LIB_FILE=lib/libboost_unit_test_framework.a +fi + +# inherit from boost base (used for all boost library packages) +BASE_PATH=${HERE}/../../boost/$(basename $HERE) +source ${BASE_PATH}/base.sh + +# setup mason env +. ${MASON_DIR}/mason.sh + +# source common build functions +source ${BASE_PATH}/common.sh + +mason_run "$@" diff --git a/scripts/boost_libfilesystem/1.67.0/.travis.yml b/scripts/boost_libfilesystem/1.67.0/.travis.yml new file mode 100644 index 000000000..69bd2e783 --- /dev/null +++ b/scripts/boost_libfilesystem/1.67.0/.travis.yml @@ -0,0 +1,19 @@ +language: generic + +matrix: + include: + - os: osx + osx_image: xcode8 + compiler: clang + - os: linux + sudo: false + addons: + apt: + sources: + - ubuntu-toolchain-r-test + packages: + - libstdc++-4.8-dev + +script: +- ./mason build ${MASON_NAME} ${MASON_VERSION} +- ./mason publish ${MASON_NAME} ${MASON_VERSION} diff --git a/scripts/boost_libfilesystem/1.67.0/script.sh b/scripts/boost_libfilesystem/1.67.0/script.sh new file mode 100755 index 000000000..24b9c6418 --- /dev/null +++ b/scripts/boost_libfilesystem/1.67.0/script.sh @@ -0,0 +1,26 @@ +#!/usr/bin/env bash + +# dynamically determine the path to this package +HERE="$( cd "$( dirname "${BASH_SOURCE[0]}" )" > /dev/null && pwd )" + +# key properties unique to this library +THIS_DIR=$(basename $(dirname $HERE)) +BOOST_LIBRARY=${THIS_DIR#boost_lib} +MASON_NAME=boost_lib${BOOST_LIBRARY} +MASON_LIB_FILE=lib/libboost_${BOOST_LIBRARY}.a +# hack for inconsistently named test lib +if [[ ${MASON_LIB_FILE} == "lib/libboost_test.a" ]]; then + MASON_LIB_FILE=lib/libboost_unit_test_framework.a +fi + +# inherit from boost base (used for all boost library packages) +BASE_PATH=${HERE}/../../boost/$(basename $HERE) +source ${BASE_PATH}/base.sh + +# setup mason env +. ${MASON_DIR}/mason.sh + +# source common build functions +source ${BASE_PATH}/common.sh + +mason_run "$@" diff --git a/scripts/boost_libiostreams/1.67.0/.travis.yml b/scripts/boost_libiostreams/1.67.0/.travis.yml new file mode 100644 index 000000000..69bd2e783 --- /dev/null +++ b/scripts/boost_libiostreams/1.67.0/.travis.yml @@ -0,0 +1,19 @@ +language: generic + +matrix: + include: + - os: osx + osx_image: xcode8 + compiler: clang + - os: linux + sudo: false + addons: + apt: + sources: + - ubuntu-toolchain-r-test + packages: + - libstdc++-4.8-dev + +script: +- ./mason build ${MASON_NAME} ${MASON_VERSION} +- ./mason publish ${MASON_NAME} ${MASON_VERSION} diff --git a/scripts/boost_libiostreams/1.67.0/script.sh b/scripts/boost_libiostreams/1.67.0/script.sh new file mode 100755 index 000000000..24b9c6418 --- /dev/null +++ b/scripts/boost_libiostreams/1.67.0/script.sh @@ -0,0 +1,26 @@ +#!/usr/bin/env bash + +# dynamically determine the path to this package +HERE="$( cd "$( dirname "${BASH_SOURCE[0]}" )" > /dev/null && pwd )" + +# key properties unique to this library +THIS_DIR=$(basename $(dirname $HERE)) +BOOST_LIBRARY=${THIS_DIR#boost_lib} +MASON_NAME=boost_lib${BOOST_LIBRARY} +MASON_LIB_FILE=lib/libboost_${BOOST_LIBRARY}.a +# hack for inconsistently named test lib +if [[ ${MASON_LIB_FILE} == "lib/libboost_test.a" ]]; then + MASON_LIB_FILE=lib/libboost_unit_test_framework.a +fi + +# inherit from boost base (used for all boost library packages) +BASE_PATH=${HERE}/../../boost/$(basename $HERE) +source ${BASE_PATH}/base.sh + +# setup mason env +. ${MASON_DIR}/mason.sh + +# source common build functions +source ${BASE_PATH}/common.sh + +mason_run "$@" diff --git a/scripts/boost_libprogram_options/1.67.0/.travis.yml b/scripts/boost_libprogram_options/1.67.0/.travis.yml new file mode 100644 index 000000000..69bd2e783 --- /dev/null +++ b/scripts/boost_libprogram_options/1.67.0/.travis.yml @@ -0,0 +1,19 @@ +language: generic + +matrix: + include: + - os: osx + osx_image: xcode8 + compiler: clang + - os: linux + sudo: false + addons: + apt: + sources: + - ubuntu-toolchain-r-test + packages: + - libstdc++-4.8-dev + +script: +- ./mason build ${MASON_NAME} ${MASON_VERSION} +- ./mason publish ${MASON_NAME} ${MASON_VERSION} diff --git a/scripts/boost_libprogram_options/1.67.0/script.sh b/scripts/boost_libprogram_options/1.67.0/script.sh new file mode 100755 index 000000000..24b9c6418 --- /dev/null +++ b/scripts/boost_libprogram_options/1.67.0/script.sh @@ -0,0 +1,26 @@ +#!/usr/bin/env bash + +# dynamically determine the path to this package +HERE="$( cd "$( dirname "${BASH_SOURCE[0]}" )" > /dev/null && pwd )" + +# key properties unique to this library +THIS_DIR=$(basename $(dirname $HERE)) +BOOST_LIBRARY=${THIS_DIR#boost_lib} +MASON_NAME=boost_lib${BOOST_LIBRARY} +MASON_LIB_FILE=lib/libboost_${BOOST_LIBRARY}.a +# hack for inconsistently named test lib +if [[ ${MASON_LIB_FILE} == "lib/libboost_test.a" ]]; then + MASON_LIB_FILE=lib/libboost_unit_test_framework.a +fi + +# inherit from boost base (used for all boost library packages) +BASE_PATH=${HERE}/../../boost/$(basename $HERE) +source ${BASE_PATH}/base.sh + +# setup mason env +. ${MASON_DIR}/mason.sh + +# source common build functions +source ${BASE_PATH}/common.sh + +mason_run "$@" diff --git a/scripts/boost_libpython/1.67.0/.travis.yml b/scripts/boost_libpython/1.67.0/.travis.yml new file mode 100644 index 000000000..69bd2e783 --- /dev/null +++ b/scripts/boost_libpython/1.67.0/.travis.yml @@ -0,0 +1,19 @@ +language: generic + +matrix: + include: + - os: osx + osx_image: xcode8 + compiler: clang + - os: linux + sudo: false + addons: + apt: + sources: + - ubuntu-toolchain-r-test + packages: + - libstdc++-4.8-dev + +script: +- ./mason build ${MASON_NAME} ${MASON_VERSION} +- ./mason publish ${MASON_NAME} ${MASON_VERSION} diff --git a/scripts/boost_libpython/1.67.0/patch.diff b/scripts/boost_libpython/1.67.0/patch.diff new file mode 100644 index 000000000..f0fa2b156 --- /dev/null +++ b/scripts/boost_libpython/1.67.0/patch.diff @@ -0,0 +1,12 @@ +--- libs/python/src/converter/builtin_converters.cpp 2012-12-07 11:51:06.000000000 -0800 ++++ libs/python/src/converter/builtin_converters.cpp 2014-04-01 17:24:37.000000000 -0700 +@@ -32,7 +32,9 @@ + + void shared_ptr_deleter::operator()(void const*) + { ++ PyGILState_STATE gil = PyGILState_Ensure(); + owner.reset(); ++ PyGILState_Release(gil); + } + + namespace diff --git a/scripts/boost_libpython/1.67.0/script.sh b/scripts/boost_libpython/1.67.0/script.sh new file mode 100755 index 000000000..68c3a223b --- /dev/null +++ b/scripts/boost_libpython/1.67.0/script.sh @@ -0,0 +1,96 @@ +#!/usr/bin/env bash + +# dynamically determine the path to this package +HERE="$( cd "$( dirname "${BASH_SOURCE[0]}" )" > /dev/null && pwd )" + +# key properties unique to this library +THIS_DIR=$(basename $(dirname $HERE)) +BOOST_LIBRARY=${THIS_DIR#boost_lib} +MASON_NAME=boost_lib${BOOST_LIBRARY} +MASON_LIB_FILE=lib/libboost_${BOOST_LIBRARY}.a +# hack for inconsistently named test lib +if [[ ${MASON_LIB_FILE} == "lib/libboost_test.a" ]]; then + MASON_LIB_FILE=lib/libboost_unit_test_framework.a +fi + +# inherit from boost base (used for all boost library packages) +BASE_PATH=${HERE}/../../boost/$(basename $HERE) +source ${BASE_PATH}/base.sh + +# setup mason env +. ${MASON_DIR}/mason.sh + +# source common build functions +source ${BASE_PATH}/common.sh + +function write_python_config() { +# usage: +# write_python_config +PYTHON_VERSION=$2 +# note: apple pythons need '/System' +PYTHON_BASE=$3 +# note: python 3 uses 'm' +PYTHON_VARIANT=$4 +if [[ $(uname -s) == 'Darwin' ]]; then + echo " + using python + : ${PYTHON_VERSION} # version + : ${PYTHON_BASE}/Library/Frameworks/Python.framework/Versions/${PYTHON_VERSION}/bin/python${PYTHON_VERSION}${PYTHON_VARIANT} # cmd-or-prefix + : ${PYTHON_BASE}/Library/Frameworks/Python.framework/Versions/${PYTHON_VERSION}/include/python${PYTHON_VERSION}${PYTHON_VARIANT} # includes + : ${PYTHON_BASE}/Library/Frameworks/Python.framework/Versions/${PYTHON_VERSION}/lib/python${PYTHON_VERSION}/config${PYTHON_VARIANT} # a lib actually symlink + : ${BOOST_TOOLSET} # condition + ; + " >> $1 +else + if [[ $(uname -s) == 'FreeBSD' ]]; then + echo " + using python + : ${PYTHON_VERSION} # version + : /usr/local/bin/python${PYTHON_VERSION}${PYTHON_VARIANT} # cmd-or-prefix + : /usr/local/include/python${PYTHON_VERSION} # includes + : /usr/local/lib/python${PYTHON_VERSION}/config${PYTHON_VARIANT} + : ${BOOST_TOOLSET} # condition + ; + " >> $1 + else + echo " + using python + : ${PYTHON_VERSION} # version + : /usr/bin/python${PYTHON_VERSION}${PYTHON_VARIANT} # cmd-or-prefix + : /usr/include/python${PYTHON_VERSION} # includes + : /usr/lib/python${PYTHON_VERSION}/config${PYTHON_VARIANT} + : ${BOOST_TOOLSET} # condition + ; + " >> $1 + fi +fi +} + +function mason_compile { + # patch to workaround crashes in python.input + # https://github.com/mapnik/mapnik/issues/1968 + mason_step "Loading patch ${MASON_DIR}/scripts/${MASON_NAME}/${MASON_VERSION}/patch.diff" + patch -N -p0 < ${MASON_DIR}/scripts/${MASON_NAME}/${MASON_VERSION}/patch.diff + write_python_config user-config.jam "2.7" "/System" "" + gen_config ${BOOST_TOOLSET} ${BOOST_TOOLSET_CXX} + if [[ ! -f ./b2 ]] ; then + ./bootstrap.sh + fi + ./b2 \ + --with-${BOOST_LIBRARY} \ + --prefix=${MASON_PREFIX} \ + -j${MASON_CONCURRENCY} \ + -d0 \ + --ignore-site-config --user-config=user-config.jam \ + architecture="${BOOST_ARCH}" \ + toolset="${BOOST_TOOLSET}" \ + link=static \ + variant=release \ + linkflags="${LDFLAGS:-" "}" \ + cxxflags="${CXXFLAGS:-" "}" \ + stage + mkdir -p $(dirname ${MASON_PREFIX}/${MASON_LIB_FILE}) + mv stage/${MASON_LIB_FILE} ${MASON_PREFIX}/${MASON_LIB_FILE} +} + +mason_run "$@" diff --git a/scripts/boost_libregex/1.67.0/.travis.yml b/scripts/boost_libregex/1.67.0/.travis.yml new file mode 100644 index 000000000..69bd2e783 --- /dev/null +++ b/scripts/boost_libregex/1.67.0/.travis.yml @@ -0,0 +1,19 @@ +language: generic + +matrix: + include: + - os: osx + osx_image: xcode8 + compiler: clang + - os: linux + sudo: false + addons: + apt: + sources: + - ubuntu-toolchain-r-test + packages: + - libstdc++-4.8-dev + +script: +- ./mason build ${MASON_NAME} ${MASON_VERSION} +- ./mason publish ${MASON_NAME} ${MASON_VERSION} diff --git a/scripts/boost_libregex/1.67.0/script.sh b/scripts/boost_libregex/1.67.0/script.sh new file mode 100755 index 000000000..24b9c6418 --- /dev/null +++ b/scripts/boost_libregex/1.67.0/script.sh @@ -0,0 +1,26 @@ +#!/usr/bin/env bash + +# dynamically determine the path to this package +HERE="$( cd "$( dirname "${BASH_SOURCE[0]}" )" > /dev/null && pwd )" + +# key properties unique to this library +THIS_DIR=$(basename $(dirname $HERE)) +BOOST_LIBRARY=${THIS_DIR#boost_lib} +MASON_NAME=boost_lib${BOOST_LIBRARY} +MASON_LIB_FILE=lib/libboost_${BOOST_LIBRARY}.a +# hack for inconsistently named test lib +if [[ ${MASON_LIB_FILE} == "lib/libboost_test.a" ]]; then + MASON_LIB_FILE=lib/libboost_unit_test_framework.a +fi + +# inherit from boost base (used for all boost library packages) +BASE_PATH=${HERE}/../../boost/$(basename $HERE) +source ${BASE_PATH}/base.sh + +# setup mason env +. ${MASON_DIR}/mason.sh + +# source common build functions +source ${BASE_PATH}/common.sh + +mason_run "$@" diff --git a/scripts/boost_libregex_icu/1.67.0/.travis.yml b/scripts/boost_libregex_icu/1.67.0/.travis.yml new file mode 100644 index 000000000..69bd2e783 --- /dev/null +++ b/scripts/boost_libregex_icu/1.67.0/.travis.yml @@ -0,0 +1,19 @@ +language: generic + +matrix: + include: + - os: osx + osx_image: xcode8 + compiler: clang + - os: linux + sudo: false + addons: + apt: + sources: + - ubuntu-toolchain-r-test + packages: + - libstdc++-4.8-dev + +script: +- ./mason build ${MASON_NAME} ${MASON_VERSION} +- ./mason publish ${MASON_NAME} ${MASON_VERSION} diff --git a/scripts/boost_libregex_icu/1.67.0/script.sh b/scripts/boost_libregex_icu/1.67.0/script.sh new file mode 100755 index 000000000..de94e5385 --- /dev/null +++ b/scripts/boost_libregex_icu/1.67.0/script.sh @@ -0,0 +1,58 @@ +#!/usr/bin/env bash + +# dynamically determine the path to this package +HERE="$( cd "$( dirname "${BASH_SOURCE[0]}" )" > /dev/null && pwd )" + +# key properties unique to this library +THIS_DIR=$(basename $(dirname $HERE)) +# Note: cannot deduce from directory since it is named in a custom way +#BOOST_LIBRARY=${THIS_DIR#boost_lib} +BOOST_LIBRARY=regex +MASON_NAME=boost_lib${BOOST_LIBRARY}_icu +MASON_LIB_FILE=lib/libboost_${BOOST_LIBRARY}.a +# hack for inconsistently named test lib +if [[ ${MASON_LIB_FILE} == "lib/libboost_test.a" ]]; then + MASON_LIB_FILE=lib/libboost_unit_test_framework.a +fi + +# inherit from boost base (used for all boost library packages) +BASE_PATH=${HERE}/../../boost/$(basename $HERE) +source ${BASE_PATH}/base.sh + +# setup mason env +. ${MASON_DIR}/mason.sh + +# source common build functions +source ${BASE_PATH}/common.sh + +function mason_prepare_compile { + ${MASON_DIR}/mason install icu 55.1 + MASON_ICU=$(${MASON_DIR}/mason prefix icu 55.1) +} + +# custom compile that gets icu working +function mason_compile { + gen_config ${BOOST_TOOLSET} ${BOOST_TOOLSET_CXX} + if [[ ! -f ./b2 ]] ; then + ./bootstrap.sh + fi + echo 'int main() { return 0; }' > libs/regex/build/has_icu_test.cpp + ./b2 \ + --with-${BOOST_LIBRARY} \ + --prefix=${MASON_PREFIX} \ + -j${MASON_CONCURRENCY} \ + -sHAVE_ICU=1 -sICU_PATH=${MASON_ICU} --reconfigure --debug-configuration \ + -d0 \ + --ignore-site-config --user-config=user-config.jam \ + architecture="${BOOST_ARCH}" \ + toolset="${BOOST_TOOLSET}" \ + link=static \ + variant=release \ + linkflags="${LDFLAGS:-" "}" \ + cxxflags="${CXXFLAGS:-" "}" \ + stage + mkdir -p $(dirname ${MASON_PREFIX}/${MASON_LIB_FILE}) + mv stage/${MASON_LIB_FILE} ${MASON_PREFIX}/${MASON_LIB_FILE} +} + +mason_run "$@" diff --git a/scripts/boost_libregex_icu57/1.67.0/.travis.yml b/scripts/boost_libregex_icu57/1.67.0/.travis.yml new file mode 100644 index 000000000..a0b3857c0 --- /dev/null +++ b/scripts/boost_libregex_icu57/1.67.0/.travis.yml @@ -0,0 +1,18 @@ +language: generic + +matrix: + include: + - os: osx + osx_image: xcode8.2 + - os: linux + sudo: false + addons: + apt: + sources: + - ubuntu-toolchain-r-test + packages: + - libstdc++-4.8-dev + +script: +- ./mason build ${MASON_NAME} ${MASON_VERSION} +- ./mason publish ${MASON_NAME} ${MASON_VERSION} diff --git a/scripts/boost_libregex_icu57/1.67.0/script.sh b/scripts/boost_libregex_icu57/1.67.0/script.sh new file mode 100755 index 000000000..1f9d09957 --- /dev/null +++ b/scripts/boost_libregex_icu57/1.67.0/script.sh @@ -0,0 +1,58 @@ +#!/usr/bin/env bash + +# dynamically determine the path to this package +HERE="$( cd "$( dirname "${BASH_SOURCE[0]}" )" > /dev/null && pwd )" + +# key properties unique to this library +THIS_DIR=$(basename $(dirname $HERE)) +# Note: cannot deduce from directory since it is named in a custom way +#BOOST_LIBRARY=${THIS_DIR#boost_lib} +BOOST_LIBRARY=regex +MASON_NAME=boost_lib${BOOST_LIBRARY}_icu57 +MASON_LIB_FILE=lib/libboost_${BOOST_LIBRARY}.a +# hack for inconsistently named test lib +if [[ ${MASON_LIB_FILE} == "lib/libboost_test.a" ]]; then + MASON_LIB_FILE=lib/libboost_unit_test_framework.a +fi + +# inherit from boost base (used for all boost library packages) +BASE_PATH=${HERE}/../../boost/$(basename $HERE) +source ${BASE_PATH}/base.sh + +# setup mason env +. ${MASON_DIR}/mason.sh + +# source common build functions +source ${BASE_PATH}/common.sh + +function mason_prepare_compile { + ${MASON_DIR}/mason install icu 57.1 + MASON_ICU=$(${MASON_DIR}/mason prefix icu 57.1) +} + +# custom compile that gets icu working +function mason_compile { + gen_config ${BOOST_TOOLSET} ${BOOST_TOOLSET_CXX} + if [[ ! -f ./b2 ]] ; then + ./bootstrap.sh + fi + echo 'int main() { return 0; }' > libs/regex/build/has_icu_test.cpp + ./b2 \ + --with-${BOOST_LIBRARY} \ + --prefix=${MASON_PREFIX} \ + -j${MASON_CONCURRENCY} \ + -sHAVE_ICU=1 -sICU_PATH=${MASON_ICU} --reconfigure --debug-configuration \ + -d0 -a \ + --ignore-site-config --user-config=user-config.jam \ + architecture="${BOOST_ARCH}" \ + toolset="${BOOST_TOOLSET}" \ + link=static \ + variant=release \ + linkflags="${LDFLAGS:-" "}" \ + cxxflags="-fvisibility=hidden ${CXXFLAGS:-" "}" \ + stage + mkdir -p $(dirname ${MASON_PREFIX}/${MASON_LIB_FILE}) + mv stage/${MASON_LIB_FILE} ${MASON_PREFIX}/${MASON_LIB_FILE} +} + +mason_run "$@" diff --git a/scripts/boost_libsystem/1.67.0/.travis.yml b/scripts/boost_libsystem/1.67.0/.travis.yml new file mode 100644 index 000000000..69bd2e783 --- /dev/null +++ b/scripts/boost_libsystem/1.67.0/.travis.yml @@ -0,0 +1,19 @@ +language: generic + +matrix: + include: + - os: osx + osx_image: xcode8 + compiler: clang + - os: linux + sudo: false + addons: + apt: + sources: + - ubuntu-toolchain-r-test + packages: + - libstdc++-4.8-dev + +script: +- ./mason build ${MASON_NAME} ${MASON_VERSION} +- ./mason publish ${MASON_NAME} ${MASON_VERSION} diff --git a/scripts/boost_libsystem/1.67.0/script.sh b/scripts/boost_libsystem/1.67.0/script.sh new file mode 100755 index 000000000..24b9c6418 --- /dev/null +++ b/scripts/boost_libsystem/1.67.0/script.sh @@ -0,0 +1,26 @@ +#!/usr/bin/env bash + +# dynamically determine the path to this package +HERE="$( cd "$( dirname "${BASH_SOURCE[0]}" )" > /dev/null && pwd )" + +# key properties unique to this library +THIS_DIR=$(basename $(dirname $HERE)) +BOOST_LIBRARY=${THIS_DIR#boost_lib} +MASON_NAME=boost_lib${BOOST_LIBRARY} +MASON_LIB_FILE=lib/libboost_${BOOST_LIBRARY}.a +# hack for inconsistently named test lib +if [[ ${MASON_LIB_FILE} == "lib/libboost_test.a" ]]; then + MASON_LIB_FILE=lib/libboost_unit_test_framework.a +fi + +# inherit from boost base (used for all boost library packages) +BASE_PATH=${HERE}/../../boost/$(basename $HERE) +source ${BASE_PATH}/base.sh + +# setup mason env +. ${MASON_DIR}/mason.sh + +# source common build functions +source ${BASE_PATH}/common.sh + +mason_run "$@" diff --git a/scripts/boost_libtest/1.67.0/.travis.yml b/scripts/boost_libtest/1.67.0/.travis.yml new file mode 100644 index 000000000..69bd2e783 --- /dev/null +++ b/scripts/boost_libtest/1.67.0/.travis.yml @@ -0,0 +1,19 @@ +language: generic + +matrix: + include: + - os: osx + osx_image: xcode8 + compiler: clang + - os: linux + sudo: false + addons: + apt: + sources: + - ubuntu-toolchain-r-test + packages: + - libstdc++-4.8-dev + +script: +- ./mason build ${MASON_NAME} ${MASON_VERSION} +- ./mason publish ${MASON_NAME} ${MASON_VERSION} diff --git a/scripts/boost_libtest/1.67.0/script.sh b/scripts/boost_libtest/1.67.0/script.sh new file mode 100755 index 000000000..24b9c6418 --- /dev/null +++ b/scripts/boost_libtest/1.67.0/script.sh @@ -0,0 +1,26 @@ +#!/usr/bin/env bash + +# dynamically determine the path to this package +HERE="$( cd "$( dirname "${BASH_SOURCE[0]}" )" > /dev/null && pwd )" + +# key properties unique to this library +THIS_DIR=$(basename $(dirname $HERE)) +BOOST_LIBRARY=${THIS_DIR#boost_lib} +MASON_NAME=boost_lib${BOOST_LIBRARY} +MASON_LIB_FILE=lib/libboost_${BOOST_LIBRARY}.a +# hack for inconsistently named test lib +if [[ ${MASON_LIB_FILE} == "lib/libboost_test.a" ]]; then + MASON_LIB_FILE=lib/libboost_unit_test_framework.a +fi + +# inherit from boost base (used for all boost library packages) +BASE_PATH=${HERE}/../../boost/$(basename $HERE) +source ${BASE_PATH}/base.sh + +# setup mason env +. ${MASON_DIR}/mason.sh + +# source common build functions +source ${BASE_PATH}/common.sh + +mason_run "$@" diff --git a/scripts/boost_libthread/1.67.0/.travis.yml b/scripts/boost_libthread/1.67.0/.travis.yml new file mode 100644 index 000000000..69bd2e783 --- /dev/null +++ b/scripts/boost_libthread/1.67.0/.travis.yml @@ -0,0 +1,19 @@ +language: generic + +matrix: + include: + - os: osx + osx_image: xcode8 + compiler: clang + - os: linux + sudo: false + addons: + apt: + sources: + - ubuntu-toolchain-r-test + packages: + - libstdc++-4.8-dev + +script: +- ./mason build ${MASON_NAME} ${MASON_VERSION} +- ./mason publish ${MASON_NAME} ${MASON_VERSION} diff --git a/scripts/boost_libthread/1.67.0/script.sh b/scripts/boost_libthread/1.67.0/script.sh new file mode 100755 index 000000000..24b9c6418 --- /dev/null +++ b/scripts/boost_libthread/1.67.0/script.sh @@ -0,0 +1,26 @@ +#!/usr/bin/env bash + +# dynamically determine the path to this package +HERE="$( cd "$( dirname "${BASH_SOURCE[0]}" )" > /dev/null && pwd )" + +# key properties unique to this library +THIS_DIR=$(basename $(dirname $HERE)) +BOOST_LIBRARY=${THIS_DIR#boost_lib} +MASON_NAME=boost_lib${BOOST_LIBRARY} +MASON_LIB_FILE=lib/libboost_${BOOST_LIBRARY}.a +# hack for inconsistently named test lib +if [[ ${MASON_LIB_FILE} == "lib/libboost_test.a" ]]; then + MASON_LIB_FILE=lib/libboost_unit_test_framework.a +fi + +# inherit from boost base (used for all boost library packages) +BASE_PATH=${HERE}/../../boost/$(basename $HERE) +source ${BASE_PATH}/base.sh + +# setup mason env +. ${MASON_DIR}/mason.sh + +# source common build functions +source ${BASE_PATH}/common.sh + +mason_run "$@" From bb564ee4faf59aab6f447c14371549c691b6d591 Mon Sep 17 00:00:00 2001 From: Dane Springmeyer Date: Sun, 22 Apr 2018 14:21:20 -0700 Subject: [PATCH 013/338] fix python library naming [skip ci] --- scripts/boost_libpython/1.67.0/script.sh | 10 +++++++--- 1 file changed, 7 insertions(+), 3 deletions(-) diff --git a/scripts/boost_libpython/1.67.0/script.sh b/scripts/boost_libpython/1.67.0/script.sh index 68c3a223b..2bf1e1793 100755 --- a/scripts/boost_libpython/1.67.0/script.sh +++ b/scripts/boost_libpython/1.67.0/script.sh @@ -7,6 +7,9 @@ HERE="$( cd "$( dirname "${BASH_SOURCE[0]}" )" > /dev/null && pwd )" THIS_DIR=$(basename $(dirname $HERE)) BOOST_LIBRARY=${THIS_DIR#boost_lib} MASON_NAME=boost_lib${BOOST_LIBRARY} +PYTHON_VERSION="2.7" +PYTHON_VERSION_NO_DOT=${PYTHON_VERSION/.} +# NOTE: as of boost 1.67.0 it appears the static library has the python version embedded MASON_LIB_FILE=lib/libboost_${BOOST_LIBRARY}.a # hack for inconsistently named test lib if [[ ${MASON_LIB_FILE} == "lib/libboost_test.a" ]]; then @@ -26,7 +29,7 @@ source ${BASE_PATH}/common.sh function write_python_config() { # usage: # write_python_config -PYTHON_VERSION=$2 +local PYTHON_VERSION=$2 # note: apple pythons need '/System' PYTHON_BASE=$3 # note: python 3 uses 'm' @@ -71,7 +74,7 @@ function mason_compile { # https://github.com/mapnik/mapnik/issues/1968 mason_step "Loading patch ${MASON_DIR}/scripts/${MASON_NAME}/${MASON_VERSION}/patch.diff" patch -N -p0 < ${MASON_DIR}/scripts/${MASON_NAME}/${MASON_VERSION}/patch.diff - write_python_config user-config.jam "2.7" "/System" "" + write_python_config user-config.jam ${PYTHON_VERSION} "/System" "" gen_config ${BOOST_TOOLSET} ${BOOST_TOOLSET_CXX} if [[ ! -f ./b2 ]] ; then ./bootstrap.sh @@ -90,7 +93,8 @@ function mason_compile { cxxflags="${CXXFLAGS:-" "}" \ stage mkdir -p $(dirname ${MASON_PREFIX}/${MASON_LIB_FILE}) - mv stage/${MASON_LIB_FILE} ${MASON_PREFIX}/${MASON_LIB_FILE} + # NOTE: we strip the python version to make linking easier + mv stage/lib/libboost_${BOOST_LIBRARY}${PYTHON_VERSION_NO_DOT}.a ${MASON_PREFIX}/${MASON_LIB_FILE} } mason_run "$@" From 5f7403257709b627f901ff5aa433e241eaa00b75 Mon Sep 17 00:00:00 2001 From: allieoop Date: Mon, 23 Apr 2018 16:13:02 -0700 Subject: [PATCH 014/338] Provide a way to overwrite a package and its subpackages for LLVM --- utils/llvm.sh | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/utils/llvm.sh b/utils/llvm.sh index a5f99462b..82141b03a 100755 --- a/utils/llvm.sh +++ b/utils/llvm.sh @@ -54,11 +54,11 @@ function create() { echo "ERROR: please provide first arg of new version" exit 1 fi - if [[ -d ./scripts/llvm/${1} ]]; then + if [[ -d ./scripts/llvm/${1} ]] && [[ ${FORCE_LLVM_OVERWRITE:-false} != 1 ]]; then usage echo echo - echo "ERROR: first arg must point to a version of llvm that does not exist" + echo "ERROR: first arg must point to a version of llvm that does not exist (or pass 'FORCE_LLVM_OVERWRITE=1 ./utils/llvm.sh create'" exit 1 fi if [[ ! -d ./scripts/llvm/${2} ]]; then From 087e55fb84ec5c154bd40534b6e0632b00a50669 Mon Sep 17 00:00:00 2001 From: allieoop Date: Mon, 23 Apr 2018 16:14:44 -0700 Subject: [PATCH 015/338] the result of ./utils/llvm.sh create 6.0.0 5.0.1 --- scripts/clang++/6.0.0/script.sh | 2 ++ scripts/clang-format/6.0.0/script.sh | 2 ++ scripts/clang-tidy/6.0.0/script.sh | 2 ++ scripts/include-what-you-use/6.0.0/script.sh | 2 ++ scripts/lldb/6.0.0/script.sh | 2 ++ scripts/llvm-cov/6.0.0/script.sh | 2 ++ scripts/llvm/6.0.0/README.md | 4 +--- scripts/llvm/6.0.0/script.sh | 21 +++++++------------- scripts/llvm/base/common.sh | 21 +++++--------------- 9 files changed, 25 insertions(+), 33 deletions(-) diff --git a/scripts/clang++/6.0.0/script.sh b/scripts/clang++/6.0.0/script.sh index 391259e3c..c21f18d8a 100755 --- a/scripts/clang++/6.0.0/script.sh +++ b/scripts/clang++/6.0.0/script.sh @@ -1,5 +1,7 @@ #!/usr/bin/env bash +# For context on this file see https://github.com/mapbox/mason/blob/master/scripts/llvm/base/README.md + # dynamically determine the path to this package HERE="$( cd "$( dirname "${BASH_SOURCE[0]}" )" > /dev/null && pwd )" diff --git a/scripts/clang-format/6.0.0/script.sh b/scripts/clang-format/6.0.0/script.sh index 391259e3c..c21f18d8a 100755 --- a/scripts/clang-format/6.0.0/script.sh +++ b/scripts/clang-format/6.0.0/script.sh @@ -1,5 +1,7 @@ #!/usr/bin/env bash +# For context on this file see https://github.com/mapbox/mason/blob/master/scripts/llvm/base/README.md + # dynamically determine the path to this package HERE="$( cd "$( dirname "${BASH_SOURCE[0]}" )" > /dev/null && pwd )" diff --git a/scripts/clang-tidy/6.0.0/script.sh b/scripts/clang-tidy/6.0.0/script.sh index 391259e3c..c21f18d8a 100755 --- a/scripts/clang-tidy/6.0.0/script.sh +++ b/scripts/clang-tidy/6.0.0/script.sh @@ -1,5 +1,7 @@ #!/usr/bin/env bash +# For context on this file see https://github.com/mapbox/mason/blob/master/scripts/llvm/base/README.md + # dynamically determine the path to this package HERE="$( cd "$( dirname "${BASH_SOURCE[0]}" )" > /dev/null && pwd )" diff --git a/scripts/include-what-you-use/6.0.0/script.sh b/scripts/include-what-you-use/6.0.0/script.sh index 391259e3c..c21f18d8a 100755 --- a/scripts/include-what-you-use/6.0.0/script.sh +++ b/scripts/include-what-you-use/6.0.0/script.sh @@ -1,5 +1,7 @@ #!/usr/bin/env bash +# For context on this file see https://github.com/mapbox/mason/blob/master/scripts/llvm/base/README.md + # dynamically determine the path to this package HERE="$( cd "$( dirname "${BASH_SOURCE[0]}" )" > /dev/null && pwd )" diff --git a/scripts/lldb/6.0.0/script.sh b/scripts/lldb/6.0.0/script.sh index 391259e3c..c21f18d8a 100755 --- a/scripts/lldb/6.0.0/script.sh +++ b/scripts/lldb/6.0.0/script.sh @@ -1,5 +1,7 @@ #!/usr/bin/env bash +# For context on this file see https://github.com/mapbox/mason/blob/master/scripts/llvm/base/README.md + # dynamically determine the path to this package HERE="$( cd "$( dirname "${BASH_SOURCE[0]}" )" > /dev/null && pwd )" diff --git a/scripts/llvm-cov/6.0.0/script.sh b/scripts/llvm-cov/6.0.0/script.sh index 391259e3c..c21f18d8a 100755 --- a/scripts/llvm-cov/6.0.0/script.sh +++ b/scripts/llvm-cov/6.0.0/script.sh @@ -1,5 +1,7 @@ #!/usr/bin/env bash +# For context on this file see https://github.com/mapbox/mason/blob/master/scripts/llvm/base/README.md + # dynamically determine the path to this package HERE="$( cd "$( dirname "${BASH_SOURCE[0]}" )" > /dev/null && pwd )" diff --git a/scripts/llvm/6.0.0/README.md b/scripts/llvm/6.0.0/README.md index 6ce52d7fd..425bf0d1e 100644 --- a/scripts/llvm/6.0.0/README.md +++ b/scripts/llvm/6.0.0/README.md @@ -1,3 +1 @@ -### llvm v4.x - -Development package of llvm git head \ No newline at end of file +For context on this file see https://github.com/mapbox/mason/blob/master/scripts/llvm/base/README.md diff --git a/scripts/llvm/6.0.0/script.sh b/scripts/llvm/6.0.0/script.sh index 5087ab6d1..ba9913b25 100755 --- a/scripts/llvm/6.0.0/script.sh +++ b/scripts/llvm/6.0.0/script.sh @@ -1,5 +1,7 @@ #!/usr/bin/env bash +# For context on this file see https://github.com/mapbox/mason/blob/master/scripts/llvm/base/README.md + # dynamically determine the path to this package HERE="$( cd "$( dirname "${BASH_SOURCE[0]}" )" > /dev/null && pwd )" # dynamically take name of package from directory @@ -9,19 +11,10 @@ MASON_VERSION=$(basename $HERE) # inherit all functions from llvm base source ${HERE}/../../${MASON_NAME}/base/common.sh -function setup_base_tools() { - get_llvm_project "http://llvm.org/git/llvm.git" ${MASON_BUILD_PATH} - get_llvm_project "http://llvm.org/git/clang.git" ${MASON_BUILD_PATH}/tools/clang - get_llvm_project "http://llvm.org/git/compiler-rt.git" ${MASON_BUILD_PATH}/projects/compiler-rt - if [[ ${BUILD_AND_LINK_LIBCXX} == true ]]; then - get_llvm_project "http://llvm.org/git/libcxx.git" ${MASON_BUILD_PATH}/projects/libcxx - get_llvm_project "http://llvm.org/git/libcxxabi.git" ${MASON_BUILD_PATH}/projects/libcxxabi - get_llvm_project "http://llvm.org/git/libunwind.git" ${MASON_BUILD_PATH}/projects/libunwind - fi - get_llvm_project "http://llvm.org/git/lld.git" ${MASON_BUILD_PATH}/tools/lld - get_llvm_project "http://llvm.org/git/clang-tools-extra.git" ${MASON_BUILD_PATH}/tools/clang/tools/extra - get_llvm_project "http://llvm.org/git/lldb.git" ${MASON_BUILD_PATH}/tools/lldb - get_llvm_project "https://github.com/include-what-you-use/include-what-you-use.git" ${MASON_BUILD_PATH}/tools/clang/tools/include-what-you-use -} +# broken with: +# ../tools/clang/tools/include-what-you-use/iwyu_ast_util.cc:455:3: error: use of undeclared identifier 'printTemplateArgumentList' +# function setup_release() { +# get_llvm_project "https://github.com/include-what-you-use/include-what-you-use.git" ${MASON_BUILD_PATH}/tools/clang/tools/include-what-you-use "" 5788b34c2e22fa97630c4a5b1153d828698f9ac1 +# } mason_run "$@" diff --git a/scripts/llvm/base/common.sh b/scripts/llvm/base/common.sh index 916d0c9e6..779256f12 100755 --- a/scripts/llvm/base/common.sh +++ b/scripts/llvm/base/common.sh @@ -156,22 +156,6 @@ function mason_prepare_compile { } function mason_compile { - if [[ $(uname -s) == 'Darwin' ]]; then - # ensure codesigning is working before starting - # this logic borrowed from homebrew llvm.rb formula - TMPDIR=$(mktemp -d) - (cd $TMPDIR && \ - cp /usr/bin/false llvm_check && \ - RESULT=0 && - /usr/bin/codesign -f -s lldb_codesign --dryrun llvm_check || RESULT=$? && - if [[ ${RESULT} != 0 ]]; then - echo "lldb_codesign identity must be available to build with LLDB." - echo "See: https://llvm.org/svn/llvm-project/lldb/trunk/docs/code-signing.txt" - exit 1 - fi - ) - fi - export CXX="${CUSTOM_CXX:-${MASON_CLANG}/bin/clang++}" export CC="${CUSTOM_CC:-${MASON_CLANG}/bin/clang}" echo "using CXX=${CXX}" @@ -187,6 +171,11 @@ function mason_compile { CMAKE_EXTRA_ARGS="" + if [[ $(uname -s) == 'Darwin' ]]; then + # don't require codesigning for macOS + CMAKE_EXTRA_ARGS="${CMAKE_EXTRA_ARGS} -DLLDB_CODESIGN_IDENTITY=''" + fi + if [[ ${MAJOR_MINOR} == "3.8" ]]; then # workaround https://llvm.org/bugs/show_bug.cgi?id=25565 perl -i -p -e "s/set\(codegen_deps intrinsics_gen\)/set\(codegen_deps intrinsics_gen attributes_inc\)/g;" lib/CodeGen/CMakeLists.txt From 710e69e5eeff0bcd21e61032a82f437a790d3d56 Mon Sep 17 00:00:00 2001 From: allieoop Date: Mon, 23 Apr 2018 19:51:50 -0700 Subject: [PATCH 016/338] FIX 6.0.0 specific libcxx bug: https://github.com/llvm-mirror/libcxx/commit/68b20ca4d9c4bee2c2ad5a9240599b3e4b78d0ba / This will need to be removed in upcoming releases. --- scripts/llvm/6.0.0/libcxx.diff | 51 ++++++++++++++++++++++++++++++++++ 1 file changed, 51 insertions(+) create mode 100644 scripts/llvm/6.0.0/libcxx.diff diff --git a/scripts/llvm/6.0.0/libcxx.diff b/scripts/llvm/6.0.0/libcxx.diff new file mode 100644 index 000000000..348556360 --- /dev/null +++ b/scripts/llvm/6.0.0/libcxx.diff @@ -0,0 +1,51 @@ +diff --git a/src/experimental/filesystem/operations.cpp b/src/experimental/filesystem/operations.cpp +index 2bc28c21d..bd173893c 100644 +--- a/src/experimental/filesystem/operations.cpp ++++ b/src/experimental/filesystem/operations.cpp +@@ -21,7 +21,34 @@ + #include + #include + #include /* values for fchmodat */ +-#if !defined(UTIME_OMIT) ++ ++#if (__APPLE__) ++#if defined(__ENVIRONMENT_MAC_OS_X_VERSION_MIN_REQUIRED__) ++#if __ENVIRONMENT_MAC_OS_X_VERSION_MIN_REQUIRED__ >= 101300 ++#define _LIBCXX_USE_UTIMENSAT ++#endif ++#elif defined(__ENVIRONMENT_IPHONE_OS_VERSION_MIN_REQUIRED__) ++#if __ENVIRONMENT_IPHONE_OS_VERSION_MIN_REQUIRED__ >= 110000 ++#define _LIBCXX_USE_UTIMENSAT ++#endif ++#elif defined(__ENVIRONMENT_TV_OS_VERSION_MIN_REQUIRED__) ++#if __ENVIRONMENT_TV_OS_VERSION_MIN_REQUIRED__ >= 110000 ++#define _LIBCXX_USE_UTIMENSAT ++#endif ++#elif defined(__ENVIRONMENT_WATCH_OS_VERSION_MIN_REQUIRED__) ++#if __ENVIRONMENT_WATCH_OS_VERSION_MIN_REQUIRED__ >= 40000 ++#define _LIBCXX_USE_UTIMENSAT ++#endif ++#endif // __ENVIRONMENT_.*_VERSION_MIN_REQUIRED__ ++#else ++// We can use the presence of UTIME_OMIT to detect platforms that provide ++// utimensat. ++#if defined(UTIME_OMIT) ++#define _LIBCXX_USE_UTIMENSAT ++#endif ++#endif // __APPLE__ ++ ++#if !defined(_LIBCXX_USE_UTIMENSAT) + #include // for ::utimes as used in __last_write_time + #endif + +@@ -560,9 +587,7 @@ void __last_write_time(const path& p, file_time_type new_time, + using namespace std::chrono; + std::error_code m_ec; + +- // We can use the presence of UTIME_OMIT to detect platforms that do not +- // provide utimensat. +-#if !defined(UTIME_OMIT) ++#if !defined(_LIBCXX_USE_UTIMENSAT) + // This implementation has a race condition between determining the + // last access time and attempting to set it to the same value using + // ::utimes From e63f20d9ec408a49f785a5ddce303daa8c5561a4 Mon Sep 17 00:00:00 2001 From: allieoop Date: Tue, 24 Apr 2018 15:31:30 -0700 Subject: [PATCH 017/338] FIX 6.0.0 specific libcxx bug: https://github.com/llvm-mirror/libcxx/commit/68b20ca4d9c4bee2c2ad5a9240599b3e4b78d0ba --- scripts/llvm/6.0.0/script.sh | 8 ++++++++ 1 file changed, 8 insertions(+) diff --git a/scripts/llvm/6.0.0/script.sh b/scripts/llvm/6.0.0/script.sh index ba9913b25..b23b2c26f 100755 --- a/scripts/llvm/6.0.0/script.sh +++ b/scripts/llvm/6.0.0/script.sh @@ -17,4 +17,12 @@ source ${HERE}/../../${MASON_NAME}/base/common.sh # get_llvm_project "https://github.com/include-what-you-use/include-what-you-use.git" ${MASON_BUILD_PATH}/tools/clang/tools/include-what-you-use "" 5788b34c2e22fa97630c4a5b1153d828698f9ac1 # } +function setup_release() { + #get_llvm_project "https://github.com/include-what-you-use/include-what-you-use.git" ${MASON_BUILD_PATH}/tools/clang/tools/include-what-you-use "" f1ec249 + # FIX 6.0.0 specific libcxx bug: https://github.com/llvm-mirror/libcxx/commit/68b20ca4d9c4bee2c2ad5a9240599b3e4b78d0ba + # This will need to be removed in upcoming releases + (cd ${MASON_BUILD_PATH}/projects/libcxx && + patch -N -p1 < ${MASON_DIR}/scripts/${MASON_NAME}/${MASON_VERSION}/libcxx.diff) +} + mason_run "$@" From d1dd14b5bb6fe3633917ef32f5e5c6ba111d2d52 Mon Sep 17 00:00:00 2001 From: Dane Springmeyer Date: Tue, 24 Apr 2018 17:26:50 -0700 Subject: [PATCH 018/338] Add doc on bundled pyyaml --- scripts/clang-tidy/6.0.0/README-yaml.md | 13 +++++++++++++ 1 file changed, 13 insertions(+) create mode 100644 scripts/clang-tidy/6.0.0/README-yaml.md diff --git a/scripts/clang-tidy/6.0.0/README-yaml.md b/scripts/clang-tidy/6.0.0/README-yaml.md new file mode 100644 index 000000000..2cc738ab7 --- /dev/null +++ b/scripts/clang-tidy/6.0.0/README-yaml.md @@ -0,0 +1,13 @@ +This is a copy of `pyyaml-3.12` vendored on april 24, 2018 by @springmeyer. + +https://github.com/mapbox/mason/issues/563 documents why. + +The process to vendor was: + +``` +cd mason +pip install pyyaml --user +cp $(python -m site --user-site)/yaml scripts/clang-tidy/6.0.0/ +``` + +Then the `clang-tidy` package was built and the `yaml` directory was copied beside the `share/run-clang-tidy.py` script (which depends on it). \ No newline at end of file From 8acc114fc6988196939552c4eb121a06efad42b1 Mon Sep 17 00:00:00 2001 From: Dane Springmeyer Date: Tue, 24 Apr 2018 17:27:07 -0700 Subject: [PATCH 019/338] bundle/vendor clang-tidy, actually --- scripts/clang-tidy/6.0.0/yaml/__init__.py | 315 ++++ scripts/clang-tidy/6.0.0/yaml/composer.py | 139 ++ scripts/clang-tidy/6.0.0/yaml/constructor.py | 675 ++++++++ scripts/clang-tidy/6.0.0/yaml/cyaml.py | 85 + scripts/clang-tidy/6.0.0/yaml/dumper.py | 62 + scripts/clang-tidy/6.0.0/yaml/emitter.py | 1140 ++++++++++++++ scripts/clang-tidy/6.0.0/yaml/error.py | 75 + scripts/clang-tidy/6.0.0/yaml/events.py | 86 ++ scripts/clang-tidy/6.0.0/yaml/loader.py | 40 + scripts/clang-tidy/6.0.0/yaml/nodes.py | 49 + scripts/clang-tidy/6.0.0/yaml/parser.py | 589 +++++++ scripts/clang-tidy/6.0.0/yaml/reader.py | 190 +++ scripts/clang-tidy/6.0.0/yaml/representer.py | 486 ++++++ scripts/clang-tidy/6.0.0/yaml/resolver.py | 227 +++ scripts/clang-tidy/6.0.0/yaml/scanner.py | 1453 ++++++++++++++++++ scripts/clang-tidy/6.0.0/yaml/serializer.py | 111 ++ scripts/clang-tidy/6.0.0/yaml/tokens.py | 104 ++ 17 files changed, 5826 insertions(+) create mode 100644 scripts/clang-tidy/6.0.0/yaml/__init__.py create mode 100644 scripts/clang-tidy/6.0.0/yaml/composer.py create mode 100644 scripts/clang-tidy/6.0.0/yaml/constructor.py create mode 100644 scripts/clang-tidy/6.0.0/yaml/cyaml.py create mode 100644 scripts/clang-tidy/6.0.0/yaml/dumper.py create mode 100644 scripts/clang-tidy/6.0.0/yaml/emitter.py create mode 100644 scripts/clang-tidy/6.0.0/yaml/error.py create mode 100644 scripts/clang-tidy/6.0.0/yaml/events.py create mode 100644 scripts/clang-tidy/6.0.0/yaml/loader.py create mode 100644 scripts/clang-tidy/6.0.0/yaml/nodes.py create mode 100644 scripts/clang-tidy/6.0.0/yaml/parser.py create mode 100644 scripts/clang-tidy/6.0.0/yaml/reader.py create mode 100644 scripts/clang-tidy/6.0.0/yaml/representer.py create mode 100644 scripts/clang-tidy/6.0.0/yaml/resolver.py create mode 100644 scripts/clang-tidy/6.0.0/yaml/scanner.py create mode 100644 scripts/clang-tidy/6.0.0/yaml/serializer.py create mode 100644 scripts/clang-tidy/6.0.0/yaml/tokens.py diff --git a/scripts/clang-tidy/6.0.0/yaml/__init__.py b/scripts/clang-tidy/6.0.0/yaml/__init__.py new file mode 100644 index 000000000..87c15d38a --- /dev/null +++ b/scripts/clang-tidy/6.0.0/yaml/__init__.py @@ -0,0 +1,315 @@ + +from error import * + +from tokens import * +from events import * +from nodes import * + +from loader import * +from dumper import * + +__version__ = '3.12' + +try: + from cyaml import * + __with_libyaml__ = True +except ImportError: + __with_libyaml__ = False + +def scan(stream, Loader=Loader): + """ + Scan a YAML stream and produce scanning tokens. + """ + loader = Loader(stream) + try: + while loader.check_token(): + yield loader.get_token() + finally: + loader.dispose() + +def parse(stream, Loader=Loader): + """ + Parse a YAML stream and produce parsing events. + """ + loader = Loader(stream) + try: + while loader.check_event(): + yield loader.get_event() + finally: + loader.dispose() + +def compose(stream, Loader=Loader): + """ + Parse the first YAML document in a stream + and produce the corresponding representation tree. + """ + loader = Loader(stream) + try: + return loader.get_single_node() + finally: + loader.dispose() + +def compose_all(stream, Loader=Loader): + """ + Parse all YAML documents in a stream + and produce corresponding representation trees. + """ + loader = Loader(stream) + try: + while loader.check_node(): + yield loader.get_node() + finally: + loader.dispose() + +def load(stream, Loader=Loader): + """ + Parse the first YAML document in a stream + and produce the corresponding Python object. + """ + loader = Loader(stream) + try: + return loader.get_single_data() + finally: + loader.dispose() + +def load_all(stream, Loader=Loader): + """ + Parse all YAML documents in a stream + and produce corresponding Python objects. + """ + loader = Loader(stream) + try: + while loader.check_data(): + yield loader.get_data() + finally: + loader.dispose() + +def safe_load(stream): + """ + Parse the first YAML document in a stream + and produce the corresponding Python object. + Resolve only basic YAML tags. + """ + return load(stream, SafeLoader) + +def safe_load_all(stream): + """ + Parse all YAML documents in a stream + and produce corresponding Python objects. + Resolve only basic YAML tags. + """ + return load_all(stream, SafeLoader) + +def emit(events, stream=None, Dumper=Dumper, + canonical=None, indent=None, width=None, + allow_unicode=None, line_break=None): + """ + Emit YAML parsing events into a stream. + If stream is None, return the produced string instead. + """ + getvalue = None + if stream is None: + from StringIO import StringIO + stream = StringIO() + getvalue = stream.getvalue + dumper = Dumper(stream, canonical=canonical, indent=indent, width=width, + allow_unicode=allow_unicode, line_break=line_break) + try: + for event in events: + dumper.emit(event) + finally: + dumper.dispose() + if getvalue: + return getvalue() + +def serialize_all(nodes, stream=None, Dumper=Dumper, + canonical=None, indent=None, width=None, + allow_unicode=None, line_break=None, + encoding='utf-8', explicit_start=None, explicit_end=None, + version=None, tags=None): + """ + Serialize a sequence of representation trees into a YAML stream. + If stream is None, return the produced string instead. + """ + getvalue = None + if stream is None: + if encoding is None: + from StringIO import StringIO + else: + from cStringIO import StringIO + stream = StringIO() + getvalue = stream.getvalue + dumper = Dumper(stream, canonical=canonical, indent=indent, width=width, + allow_unicode=allow_unicode, line_break=line_break, + encoding=encoding, version=version, tags=tags, + explicit_start=explicit_start, explicit_end=explicit_end) + try: + dumper.open() + for node in nodes: + dumper.serialize(node) + dumper.close() + finally: + dumper.dispose() + if getvalue: + return getvalue() + +def serialize(node, stream=None, Dumper=Dumper, **kwds): + """ + Serialize a representation tree into a YAML stream. + If stream is None, return the produced string instead. + """ + return serialize_all([node], stream, Dumper=Dumper, **kwds) + +def dump_all(documents, stream=None, Dumper=Dumper, + default_style=None, default_flow_style=None, + canonical=None, indent=None, width=None, + allow_unicode=None, line_break=None, + encoding='utf-8', explicit_start=None, explicit_end=None, + version=None, tags=None): + """ + Serialize a sequence of Python objects into a YAML stream. + If stream is None, return the produced string instead. + """ + getvalue = None + if stream is None: + if encoding is None: + from StringIO import StringIO + else: + from cStringIO import StringIO + stream = StringIO() + getvalue = stream.getvalue + dumper = Dumper(stream, default_style=default_style, + default_flow_style=default_flow_style, + canonical=canonical, indent=indent, width=width, + allow_unicode=allow_unicode, line_break=line_break, + encoding=encoding, version=version, tags=tags, + explicit_start=explicit_start, explicit_end=explicit_end) + try: + dumper.open() + for data in documents: + dumper.represent(data) + dumper.close() + finally: + dumper.dispose() + if getvalue: + return getvalue() + +def dump(data, stream=None, Dumper=Dumper, **kwds): + """ + Serialize a Python object into a YAML stream. + If stream is None, return the produced string instead. + """ + return dump_all([data], stream, Dumper=Dumper, **kwds) + +def safe_dump_all(documents, stream=None, **kwds): + """ + Serialize a sequence of Python objects into a YAML stream. + Produce only basic YAML tags. + If stream is None, return the produced string instead. + """ + return dump_all(documents, stream, Dumper=SafeDumper, **kwds) + +def safe_dump(data, stream=None, **kwds): + """ + Serialize a Python object into a YAML stream. + Produce only basic YAML tags. + If stream is None, return the produced string instead. + """ + return dump_all([data], stream, Dumper=SafeDumper, **kwds) + +def add_implicit_resolver(tag, regexp, first=None, + Loader=Loader, Dumper=Dumper): + """ + Add an implicit scalar detector. + If an implicit scalar value matches the given regexp, + the corresponding tag is assigned to the scalar. + first is a sequence of possible initial characters or None. + """ + Loader.add_implicit_resolver(tag, regexp, first) + Dumper.add_implicit_resolver(tag, regexp, first) + +def add_path_resolver(tag, path, kind=None, Loader=Loader, Dumper=Dumper): + """ + Add a path based resolver for the given tag. + A path is a list of keys that forms a path + to a node in the representation tree. + Keys can be string values, integers, or None. + """ + Loader.add_path_resolver(tag, path, kind) + Dumper.add_path_resolver(tag, path, kind) + +def add_constructor(tag, constructor, Loader=Loader): + """ + Add a constructor for the given tag. + Constructor is a function that accepts a Loader instance + and a node object and produces the corresponding Python object. + """ + Loader.add_constructor(tag, constructor) + +def add_multi_constructor(tag_prefix, multi_constructor, Loader=Loader): + """ + Add a multi-constructor for the given tag prefix. + Multi-constructor is called for a node if its tag starts with tag_prefix. + Multi-constructor accepts a Loader instance, a tag suffix, + and a node object and produces the corresponding Python object. + """ + Loader.add_multi_constructor(tag_prefix, multi_constructor) + +def add_representer(data_type, representer, Dumper=Dumper): + """ + Add a representer for the given type. + Representer is a function accepting a Dumper instance + and an instance of the given data type + and producing the corresponding representation node. + """ + Dumper.add_representer(data_type, representer) + +def add_multi_representer(data_type, multi_representer, Dumper=Dumper): + """ + Add a representer for the given type. + Multi-representer is a function accepting a Dumper instance + and an instance of the given data type or subtype + and producing the corresponding representation node. + """ + Dumper.add_multi_representer(data_type, multi_representer) + +class YAMLObjectMetaclass(type): + """ + The metaclass for YAMLObject. + """ + def __init__(cls, name, bases, kwds): + super(YAMLObjectMetaclass, cls).__init__(name, bases, kwds) + if 'yaml_tag' in kwds and kwds['yaml_tag'] is not None: + cls.yaml_loader.add_constructor(cls.yaml_tag, cls.from_yaml) + cls.yaml_dumper.add_representer(cls, cls.to_yaml) + +class YAMLObject(object): + """ + An object that can dump itself to a YAML stream + and load itself from a YAML stream. + """ + + __metaclass__ = YAMLObjectMetaclass + __slots__ = () # no direct instantiation, so allow immutable subclasses + + yaml_loader = Loader + yaml_dumper = Dumper + + yaml_tag = None + yaml_flow_style = None + + def from_yaml(cls, loader, node): + """ + Convert a representation node to a Python object. + """ + return loader.construct_yaml_object(node, cls) + from_yaml = classmethod(from_yaml) + + def to_yaml(cls, dumper, data): + """ + Convert a Python object to a representation node. + """ + return dumper.represent_yaml_object(cls.yaml_tag, data, cls, + flow_style=cls.yaml_flow_style) + to_yaml = classmethod(to_yaml) + diff --git a/scripts/clang-tidy/6.0.0/yaml/composer.py b/scripts/clang-tidy/6.0.0/yaml/composer.py new file mode 100644 index 000000000..06e5ac782 --- /dev/null +++ b/scripts/clang-tidy/6.0.0/yaml/composer.py @@ -0,0 +1,139 @@ + +__all__ = ['Composer', 'ComposerError'] + +from error import MarkedYAMLError +from events import * +from nodes import * + +class ComposerError(MarkedYAMLError): + pass + +class Composer(object): + + def __init__(self): + self.anchors = {} + + def check_node(self): + # Drop the STREAM-START event. + if self.check_event(StreamStartEvent): + self.get_event() + + # If there are more documents available? + return not self.check_event(StreamEndEvent) + + def get_node(self): + # Get the root node of the next document. + if not self.check_event(StreamEndEvent): + return self.compose_document() + + def get_single_node(self): + # Drop the STREAM-START event. + self.get_event() + + # Compose a document if the stream is not empty. + document = None + if not self.check_event(StreamEndEvent): + document = self.compose_document() + + # Ensure that the stream contains no more documents. + if not self.check_event(StreamEndEvent): + event = self.get_event() + raise ComposerError("expected a single document in the stream", + document.start_mark, "but found another document", + event.start_mark) + + # Drop the STREAM-END event. + self.get_event() + + return document + + def compose_document(self): + # Drop the DOCUMENT-START event. + self.get_event() + + # Compose the root node. + node = self.compose_node(None, None) + + # Drop the DOCUMENT-END event. + self.get_event() + + self.anchors = {} + return node + + def compose_node(self, parent, index): + if self.check_event(AliasEvent): + event = self.get_event() + anchor = event.anchor + if anchor not in self.anchors: + raise ComposerError(None, None, "found undefined alias %r" + % anchor.encode('utf-8'), event.start_mark) + return self.anchors[anchor] + event = self.peek_event() + anchor = event.anchor + if anchor is not None: + if anchor in self.anchors: + raise ComposerError("found duplicate anchor %r; first occurence" + % anchor.encode('utf-8'), self.anchors[anchor].start_mark, + "second occurence", event.start_mark) + self.descend_resolver(parent, index) + if self.check_event(ScalarEvent): + node = self.compose_scalar_node(anchor) + elif self.check_event(SequenceStartEvent): + node = self.compose_sequence_node(anchor) + elif self.check_event(MappingStartEvent): + node = self.compose_mapping_node(anchor) + self.ascend_resolver() + return node + + def compose_scalar_node(self, anchor): + event = self.get_event() + tag = event.tag + if tag is None or tag == u'!': + tag = self.resolve(ScalarNode, event.value, event.implicit) + node = ScalarNode(tag, event.value, + event.start_mark, event.end_mark, style=event.style) + if anchor is not None: + self.anchors[anchor] = node + return node + + def compose_sequence_node(self, anchor): + start_event = self.get_event() + tag = start_event.tag + if tag is None or tag == u'!': + tag = self.resolve(SequenceNode, None, start_event.implicit) + node = SequenceNode(tag, [], + start_event.start_mark, None, + flow_style=start_event.flow_style) + if anchor is not None: + self.anchors[anchor] = node + index = 0 + while not self.check_event(SequenceEndEvent): + node.value.append(self.compose_node(node, index)) + index += 1 + end_event = self.get_event() + node.end_mark = end_event.end_mark + return node + + def compose_mapping_node(self, anchor): + start_event = self.get_event() + tag = start_event.tag + if tag is None or tag == u'!': + tag = self.resolve(MappingNode, None, start_event.implicit) + node = MappingNode(tag, [], + start_event.start_mark, None, + flow_style=start_event.flow_style) + if anchor is not None: + self.anchors[anchor] = node + while not self.check_event(MappingEndEvent): + #key_event = self.peek_event() + item_key = self.compose_node(node, None) + #if item_key in node.value: + # raise ComposerError("while composing a mapping", start_event.start_mark, + # "found duplicate key", key_event.start_mark) + item_value = self.compose_node(node, item_key) + #node.value[item_key] = item_value + node.value.append((item_key, item_value)) + end_event = self.get_event() + node.end_mark = end_event.end_mark + return node + diff --git a/scripts/clang-tidy/6.0.0/yaml/constructor.py b/scripts/clang-tidy/6.0.0/yaml/constructor.py new file mode 100644 index 000000000..635faac3e --- /dev/null +++ b/scripts/clang-tidy/6.0.0/yaml/constructor.py @@ -0,0 +1,675 @@ + +__all__ = ['BaseConstructor', 'SafeConstructor', 'Constructor', + 'ConstructorError'] + +from error import * +from nodes import * + +import datetime + +import binascii, re, sys, types + +class ConstructorError(MarkedYAMLError): + pass + +class BaseConstructor(object): + + yaml_constructors = {} + yaml_multi_constructors = {} + + def __init__(self): + self.constructed_objects = {} + self.recursive_objects = {} + self.state_generators = [] + self.deep_construct = False + + def check_data(self): + # If there are more documents available? + return self.check_node() + + def get_data(self): + # Construct and return the next document. + if self.check_node(): + return self.construct_document(self.get_node()) + + def get_single_data(self): + # Ensure that the stream contains a single document and construct it. + node = self.get_single_node() + if node is not None: + return self.construct_document(node) + return None + + def construct_document(self, node): + data = self.construct_object(node) + while self.state_generators: + state_generators = self.state_generators + self.state_generators = [] + for generator in state_generators: + for dummy in generator: + pass + self.constructed_objects = {} + self.recursive_objects = {} + self.deep_construct = False + return data + + def construct_object(self, node, deep=False): + if node in self.constructed_objects: + return self.constructed_objects[node] + if deep: + old_deep = self.deep_construct + self.deep_construct = True + if node in self.recursive_objects: + raise ConstructorError(None, None, + "found unconstructable recursive node", node.start_mark) + self.recursive_objects[node] = None + constructor = None + tag_suffix = None + if node.tag in self.yaml_constructors: + constructor = self.yaml_constructors[node.tag] + else: + for tag_prefix in self.yaml_multi_constructors: + if node.tag.startswith(tag_prefix): + tag_suffix = node.tag[len(tag_prefix):] + constructor = self.yaml_multi_constructors[tag_prefix] + break + else: + if None in self.yaml_multi_constructors: + tag_suffix = node.tag + constructor = self.yaml_multi_constructors[None] + elif None in self.yaml_constructors: + constructor = self.yaml_constructors[None] + elif isinstance(node, ScalarNode): + constructor = self.__class__.construct_scalar + elif isinstance(node, SequenceNode): + constructor = self.__class__.construct_sequence + elif isinstance(node, MappingNode): + constructor = self.__class__.construct_mapping + if tag_suffix is None: + data = constructor(self, node) + else: + data = constructor(self, tag_suffix, node) + if isinstance(data, types.GeneratorType): + generator = data + data = generator.next() + if self.deep_construct: + for dummy in generator: + pass + else: + self.state_generators.append(generator) + self.constructed_objects[node] = data + del self.recursive_objects[node] + if deep: + self.deep_construct = old_deep + return data + + def construct_scalar(self, node): + if not isinstance(node, ScalarNode): + raise ConstructorError(None, None, + "expected a scalar node, but found %s" % node.id, + node.start_mark) + return node.value + + def construct_sequence(self, node, deep=False): + if not isinstance(node, SequenceNode): + raise ConstructorError(None, None, + "expected a sequence node, but found %s" % node.id, + node.start_mark) + return [self.construct_object(child, deep=deep) + for child in node.value] + + def construct_mapping(self, node, deep=False): + if not isinstance(node, MappingNode): + raise ConstructorError(None, None, + "expected a mapping node, but found %s" % node.id, + node.start_mark) + mapping = {} + for key_node, value_node in node.value: + key = self.construct_object(key_node, deep=deep) + try: + hash(key) + except TypeError, exc: + raise ConstructorError("while constructing a mapping", node.start_mark, + "found unacceptable key (%s)" % exc, key_node.start_mark) + value = self.construct_object(value_node, deep=deep) + mapping[key] = value + return mapping + + def construct_pairs(self, node, deep=False): + if not isinstance(node, MappingNode): + raise ConstructorError(None, None, + "expected a mapping node, but found %s" % node.id, + node.start_mark) + pairs = [] + for key_node, value_node in node.value: + key = self.construct_object(key_node, deep=deep) + value = self.construct_object(value_node, deep=deep) + pairs.append((key, value)) + return pairs + + def add_constructor(cls, tag, constructor): + if not 'yaml_constructors' in cls.__dict__: + cls.yaml_constructors = cls.yaml_constructors.copy() + cls.yaml_constructors[tag] = constructor + add_constructor = classmethod(add_constructor) + + def add_multi_constructor(cls, tag_prefix, multi_constructor): + if not 'yaml_multi_constructors' in cls.__dict__: + cls.yaml_multi_constructors = cls.yaml_multi_constructors.copy() + cls.yaml_multi_constructors[tag_prefix] = multi_constructor + add_multi_constructor = classmethod(add_multi_constructor) + +class SafeConstructor(BaseConstructor): + + def construct_scalar(self, node): + if isinstance(node, MappingNode): + for key_node, value_node in node.value: + if key_node.tag == u'tag:yaml.org,2002:value': + return self.construct_scalar(value_node) + return BaseConstructor.construct_scalar(self, node) + + def flatten_mapping(self, node): + merge = [] + index = 0 + while index < len(node.value): + key_node, value_node = node.value[index] + if key_node.tag == u'tag:yaml.org,2002:merge': + del node.value[index] + if isinstance(value_node, MappingNode): + self.flatten_mapping(value_node) + merge.extend(value_node.value) + elif isinstance(value_node, SequenceNode): + submerge = [] + for subnode in value_node.value: + if not isinstance(subnode, MappingNode): + raise ConstructorError("while constructing a mapping", + node.start_mark, + "expected a mapping for merging, but found %s" + % subnode.id, subnode.start_mark) + self.flatten_mapping(subnode) + submerge.append(subnode.value) + submerge.reverse() + for value in submerge: + merge.extend(value) + else: + raise ConstructorError("while constructing a mapping", node.start_mark, + "expected a mapping or list of mappings for merging, but found %s" + % value_node.id, value_node.start_mark) + elif key_node.tag == u'tag:yaml.org,2002:value': + key_node.tag = u'tag:yaml.org,2002:str' + index += 1 + else: + index += 1 + if merge: + node.value = merge + node.value + + def construct_mapping(self, node, deep=False): + if isinstance(node, MappingNode): + self.flatten_mapping(node) + return BaseConstructor.construct_mapping(self, node, deep=deep) + + def construct_yaml_null(self, node): + self.construct_scalar(node) + return None + + bool_values = { + u'yes': True, + u'no': False, + u'true': True, + u'false': False, + u'on': True, + u'off': False, + } + + def construct_yaml_bool(self, node): + value = self.construct_scalar(node) + return self.bool_values[value.lower()] + + def construct_yaml_int(self, node): + value = str(self.construct_scalar(node)) + value = value.replace('_', '') + sign = +1 + if value[0] == '-': + sign = -1 + if value[0] in '+-': + value = value[1:] + if value == '0': + return 0 + elif value.startswith('0b'): + return sign*int(value[2:], 2) + elif value.startswith('0x'): + return sign*int(value[2:], 16) + elif value[0] == '0': + return sign*int(value, 8) + elif ':' in value: + digits = [int(part) for part in value.split(':')] + digits.reverse() + base = 1 + value = 0 + for digit in digits: + value += digit*base + base *= 60 + return sign*value + else: + return sign*int(value) + + inf_value = 1e300 + while inf_value != inf_value*inf_value: + inf_value *= inf_value + nan_value = -inf_value/inf_value # Trying to make a quiet NaN (like C99). + + def construct_yaml_float(self, node): + value = str(self.construct_scalar(node)) + value = value.replace('_', '').lower() + sign = +1 + if value[0] == '-': + sign = -1 + if value[0] in '+-': + value = value[1:] + if value == '.inf': + return sign*self.inf_value + elif value == '.nan': + return self.nan_value + elif ':' in value: + digits = [float(part) for part in value.split(':')] + digits.reverse() + base = 1 + value = 0.0 + for digit in digits: + value += digit*base + base *= 60 + return sign*value + else: + return sign*float(value) + + def construct_yaml_binary(self, node): + value = self.construct_scalar(node) + try: + return str(value).decode('base64') + except (binascii.Error, UnicodeEncodeError), exc: + raise ConstructorError(None, None, + "failed to decode base64 data: %s" % exc, node.start_mark) + + timestamp_regexp = re.compile( + ur'''^(?P[0-9][0-9][0-9][0-9]) + -(?P[0-9][0-9]?) + -(?P[0-9][0-9]?) + (?:(?:[Tt]|[ \t]+) + (?P[0-9][0-9]?) + :(?P[0-9][0-9]) + :(?P[0-9][0-9]) + (?:\.(?P[0-9]*))? + (?:[ \t]*(?PZ|(?P[-+])(?P[0-9][0-9]?) + (?::(?P[0-9][0-9]))?))?)?$''', re.X) + + def construct_yaml_timestamp(self, node): + value = self.construct_scalar(node) + match = self.timestamp_regexp.match(node.value) + values = match.groupdict() + year = int(values['year']) + month = int(values['month']) + day = int(values['day']) + if not values['hour']: + return datetime.date(year, month, day) + hour = int(values['hour']) + minute = int(values['minute']) + second = int(values['second']) + fraction = 0 + if values['fraction']: + fraction = values['fraction'][:6] + while len(fraction) < 6: + fraction += '0' + fraction = int(fraction) + delta = None + if values['tz_sign']: + tz_hour = int(values['tz_hour']) + tz_minute = int(values['tz_minute'] or 0) + delta = datetime.timedelta(hours=tz_hour, minutes=tz_minute) + if values['tz_sign'] == '-': + delta = -delta + data = datetime.datetime(year, month, day, hour, minute, second, fraction) + if delta: + data -= delta + return data + + def construct_yaml_omap(self, node): + # Note: we do not check for duplicate keys, because it's too + # CPU-expensive. + omap = [] + yield omap + if not isinstance(node, SequenceNode): + raise ConstructorError("while constructing an ordered map", node.start_mark, + "expected a sequence, but found %s" % node.id, node.start_mark) + for subnode in node.value: + if not isinstance(subnode, MappingNode): + raise ConstructorError("while constructing an ordered map", node.start_mark, + "expected a mapping of length 1, but found %s" % subnode.id, + subnode.start_mark) + if len(subnode.value) != 1: + raise ConstructorError("while constructing an ordered map", node.start_mark, + "expected a single mapping item, but found %d items" % len(subnode.value), + subnode.start_mark) + key_node, value_node = subnode.value[0] + key = self.construct_object(key_node) + value = self.construct_object(value_node) + omap.append((key, value)) + + def construct_yaml_pairs(self, node): + # Note: the same code as `construct_yaml_omap`. + pairs = [] + yield pairs + if not isinstance(node, SequenceNode): + raise ConstructorError("while constructing pairs", node.start_mark, + "expected a sequence, but found %s" % node.id, node.start_mark) + for subnode in node.value: + if not isinstance(subnode, MappingNode): + raise ConstructorError("while constructing pairs", node.start_mark, + "expected a mapping of length 1, but found %s" % subnode.id, + subnode.start_mark) + if len(subnode.value) != 1: + raise ConstructorError("while constructing pairs", node.start_mark, + "expected a single mapping item, but found %d items" % len(subnode.value), + subnode.start_mark) + key_node, value_node = subnode.value[0] + key = self.construct_object(key_node) + value = self.construct_object(value_node) + pairs.append((key, value)) + + def construct_yaml_set(self, node): + data = set() + yield data + value = self.construct_mapping(node) + data.update(value) + + def construct_yaml_str(self, node): + value = self.construct_scalar(node) + try: + return value.encode('ascii') + except UnicodeEncodeError: + return value + + def construct_yaml_seq(self, node): + data = [] + yield data + data.extend(self.construct_sequence(node)) + + def construct_yaml_map(self, node): + data = {} + yield data + value = self.construct_mapping(node) + data.update(value) + + def construct_yaml_object(self, node, cls): + data = cls.__new__(cls) + yield data + if hasattr(data, '__setstate__'): + state = self.construct_mapping(node, deep=True) + data.__setstate__(state) + else: + state = self.construct_mapping(node) + data.__dict__.update(state) + + def construct_undefined(self, node): + raise ConstructorError(None, None, + "could not determine a constructor for the tag %r" % node.tag.encode('utf-8'), + node.start_mark) + +SafeConstructor.add_constructor( + u'tag:yaml.org,2002:null', + SafeConstructor.construct_yaml_null) + +SafeConstructor.add_constructor( + u'tag:yaml.org,2002:bool', + SafeConstructor.construct_yaml_bool) + +SafeConstructor.add_constructor( + u'tag:yaml.org,2002:int', + SafeConstructor.construct_yaml_int) + +SafeConstructor.add_constructor( + u'tag:yaml.org,2002:float', + SafeConstructor.construct_yaml_float) + +SafeConstructor.add_constructor( + u'tag:yaml.org,2002:binary', + SafeConstructor.construct_yaml_binary) + +SafeConstructor.add_constructor( + u'tag:yaml.org,2002:timestamp', + SafeConstructor.construct_yaml_timestamp) + +SafeConstructor.add_constructor( + u'tag:yaml.org,2002:omap', + SafeConstructor.construct_yaml_omap) + +SafeConstructor.add_constructor( + u'tag:yaml.org,2002:pairs', + SafeConstructor.construct_yaml_pairs) + +SafeConstructor.add_constructor( + u'tag:yaml.org,2002:set', + SafeConstructor.construct_yaml_set) + +SafeConstructor.add_constructor( + u'tag:yaml.org,2002:str', + SafeConstructor.construct_yaml_str) + +SafeConstructor.add_constructor( + u'tag:yaml.org,2002:seq', + SafeConstructor.construct_yaml_seq) + +SafeConstructor.add_constructor( + u'tag:yaml.org,2002:map', + SafeConstructor.construct_yaml_map) + +SafeConstructor.add_constructor(None, + SafeConstructor.construct_undefined) + +class Constructor(SafeConstructor): + + def construct_python_str(self, node): + return self.construct_scalar(node).encode('utf-8') + + def construct_python_unicode(self, node): + return self.construct_scalar(node) + + def construct_python_long(self, node): + return long(self.construct_yaml_int(node)) + + def construct_python_complex(self, node): + return complex(self.construct_scalar(node)) + + def construct_python_tuple(self, node): + return tuple(self.construct_sequence(node)) + + def find_python_module(self, name, mark): + if not name: + raise ConstructorError("while constructing a Python module", mark, + "expected non-empty name appended to the tag", mark) + try: + __import__(name) + except ImportError, exc: + raise ConstructorError("while constructing a Python module", mark, + "cannot find module %r (%s)" % (name.encode('utf-8'), exc), mark) + return sys.modules[name] + + def find_python_name(self, name, mark): + if not name: + raise ConstructorError("while constructing a Python object", mark, + "expected non-empty name appended to the tag", mark) + if u'.' in name: + module_name, object_name = name.rsplit('.', 1) + else: + module_name = '__builtin__' + object_name = name + try: + __import__(module_name) + except ImportError, exc: + raise ConstructorError("while constructing a Python object", mark, + "cannot find module %r (%s)" % (module_name.encode('utf-8'), exc), mark) + module = sys.modules[module_name] + if not hasattr(module, object_name): + raise ConstructorError("while constructing a Python object", mark, + "cannot find %r in the module %r" % (object_name.encode('utf-8'), + module.__name__), mark) + return getattr(module, object_name) + + def construct_python_name(self, suffix, node): + value = self.construct_scalar(node) + if value: + raise ConstructorError("while constructing a Python name", node.start_mark, + "expected the empty value, but found %r" % value.encode('utf-8'), + node.start_mark) + return self.find_python_name(suffix, node.start_mark) + + def construct_python_module(self, suffix, node): + value = self.construct_scalar(node) + if value: + raise ConstructorError("while constructing a Python module", node.start_mark, + "expected the empty value, but found %r" % value.encode('utf-8'), + node.start_mark) + return self.find_python_module(suffix, node.start_mark) + + class classobj: pass + + def make_python_instance(self, suffix, node, + args=None, kwds=None, newobj=False): + if not args: + args = [] + if not kwds: + kwds = {} + cls = self.find_python_name(suffix, node.start_mark) + if newobj and isinstance(cls, type(self.classobj)) \ + and not args and not kwds: + instance = self.classobj() + instance.__class__ = cls + return instance + elif newobj and isinstance(cls, type): + return cls.__new__(cls, *args, **kwds) + else: + return cls(*args, **kwds) + + def set_python_instance_state(self, instance, state): + if hasattr(instance, '__setstate__'): + instance.__setstate__(state) + else: + slotstate = {} + if isinstance(state, tuple) and len(state) == 2: + state, slotstate = state + if hasattr(instance, '__dict__'): + instance.__dict__.update(state) + elif state: + slotstate.update(state) + for key, value in slotstate.items(): + setattr(object, key, value) + + def construct_python_object(self, suffix, node): + # Format: + # !!python/object:module.name { ... state ... } + instance = self.make_python_instance(suffix, node, newobj=True) + yield instance + deep = hasattr(instance, '__setstate__') + state = self.construct_mapping(node, deep=deep) + self.set_python_instance_state(instance, state) + + def construct_python_object_apply(self, suffix, node, newobj=False): + # Format: + # !!python/object/apply # (or !!python/object/new) + # args: [ ... arguments ... ] + # kwds: { ... keywords ... } + # state: ... state ... + # listitems: [ ... listitems ... ] + # dictitems: { ... dictitems ... } + # or short format: + # !!python/object/apply [ ... arguments ... ] + # The difference between !!python/object/apply and !!python/object/new + # is how an object is created, check make_python_instance for details. + if isinstance(node, SequenceNode): + args = self.construct_sequence(node, deep=True) + kwds = {} + state = {} + listitems = [] + dictitems = {} + else: + value = self.construct_mapping(node, deep=True) + args = value.get('args', []) + kwds = value.get('kwds', {}) + state = value.get('state', {}) + listitems = value.get('listitems', []) + dictitems = value.get('dictitems', {}) + instance = self.make_python_instance(suffix, node, args, kwds, newobj) + if state: + self.set_python_instance_state(instance, state) + if listitems: + instance.extend(listitems) + if dictitems: + for key in dictitems: + instance[key] = dictitems[key] + return instance + + def construct_python_object_new(self, suffix, node): + return self.construct_python_object_apply(suffix, node, newobj=True) + +Constructor.add_constructor( + u'tag:yaml.org,2002:python/none', + Constructor.construct_yaml_null) + +Constructor.add_constructor( + u'tag:yaml.org,2002:python/bool', + Constructor.construct_yaml_bool) + +Constructor.add_constructor( + u'tag:yaml.org,2002:python/str', + Constructor.construct_python_str) + +Constructor.add_constructor( + u'tag:yaml.org,2002:python/unicode', + Constructor.construct_python_unicode) + +Constructor.add_constructor( + u'tag:yaml.org,2002:python/int', + Constructor.construct_yaml_int) + +Constructor.add_constructor( + u'tag:yaml.org,2002:python/long', + Constructor.construct_python_long) + +Constructor.add_constructor( + u'tag:yaml.org,2002:python/float', + Constructor.construct_yaml_float) + +Constructor.add_constructor( + u'tag:yaml.org,2002:python/complex', + Constructor.construct_python_complex) + +Constructor.add_constructor( + u'tag:yaml.org,2002:python/list', + Constructor.construct_yaml_seq) + +Constructor.add_constructor( + u'tag:yaml.org,2002:python/tuple', + Constructor.construct_python_tuple) + +Constructor.add_constructor( + u'tag:yaml.org,2002:python/dict', + Constructor.construct_yaml_map) + +Constructor.add_multi_constructor( + u'tag:yaml.org,2002:python/name:', + Constructor.construct_python_name) + +Constructor.add_multi_constructor( + u'tag:yaml.org,2002:python/module:', + Constructor.construct_python_module) + +Constructor.add_multi_constructor( + u'tag:yaml.org,2002:python/object:', + Constructor.construct_python_object) + +Constructor.add_multi_constructor( + u'tag:yaml.org,2002:python/object/apply:', + Constructor.construct_python_object_apply) + +Constructor.add_multi_constructor( + u'tag:yaml.org,2002:python/object/new:', + Constructor.construct_python_object_new) + diff --git a/scripts/clang-tidy/6.0.0/yaml/cyaml.py b/scripts/clang-tidy/6.0.0/yaml/cyaml.py new file mode 100644 index 000000000..68dcd7519 --- /dev/null +++ b/scripts/clang-tidy/6.0.0/yaml/cyaml.py @@ -0,0 +1,85 @@ + +__all__ = ['CBaseLoader', 'CSafeLoader', 'CLoader', + 'CBaseDumper', 'CSafeDumper', 'CDumper'] + +from _yaml import CParser, CEmitter + +from constructor import * + +from serializer import * +from representer import * + +from resolver import * + +class CBaseLoader(CParser, BaseConstructor, BaseResolver): + + def __init__(self, stream): + CParser.__init__(self, stream) + BaseConstructor.__init__(self) + BaseResolver.__init__(self) + +class CSafeLoader(CParser, SafeConstructor, Resolver): + + def __init__(self, stream): + CParser.__init__(self, stream) + SafeConstructor.__init__(self) + Resolver.__init__(self) + +class CLoader(CParser, Constructor, Resolver): + + def __init__(self, stream): + CParser.__init__(self, stream) + Constructor.__init__(self) + Resolver.__init__(self) + +class CBaseDumper(CEmitter, BaseRepresenter, BaseResolver): + + def __init__(self, stream, + default_style=None, default_flow_style=None, + canonical=None, indent=None, width=None, + allow_unicode=None, line_break=None, + encoding=None, explicit_start=None, explicit_end=None, + version=None, tags=None): + CEmitter.__init__(self, stream, canonical=canonical, + indent=indent, width=width, encoding=encoding, + allow_unicode=allow_unicode, line_break=line_break, + explicit_start=explicit_start, explicit_end=explicit_end, + version=version, tags=tags) + Representer.__init__(self, default_style=default_style, + default_flow_style=default_flow_style) + Resolver.__init__(self) + +class CSafeDumper(CEmitter, SafeRepresenter, Resolver): + + def __init__(self, stream, + default_style=None, default_flow_style=None, + canonical=None, indent=None, width=None, + allow_unicode=None, line_break=None, + encoding=None, explicit_start=None, explicit_end=None, + version=None, tags=None): + CEmitter.__init__(self, stream, canonical=canonical, + indent=indent, width=width, encoding=encoding, + allow_unicode=allow_unicode, line_break=line_break, + explicit_start=explicit_start, explicit_end=explicit_end, + version=version, tags=tags) + SafeRepresenter.__init__(self, default_style=default_style, + default_flow_style=default_flow_style) + Resolver.__init__(self) + +class CDumper(CEmitter, Serializer, Representer, Resolver): + + def __init__(self, stream, + default_style=None, default_flow_style=None, + canonical=None, indent=None, width=None, + allow_unicode=None, line_break=None, + encoding=None, explicit_start=None, explicit_end=None, + version=None, tags=None): + CEmitter.__init__(self, stream, canonical=canonical, + indent=indent, width=width, encoding=encoding, + allow_unicode=allow_unicode, line_break=line_break, + explicit_start=explicit_start, explicit_end=explicit_end, + version=version, tags=tags) + Representer.__init__(self, default_style=default_style, + default_flow_style=default_flow_style) + Resolver.__init__(self) + diff --git a/scripts/clang-tidy/6.0.0/yaml/dumper.py b/scripts/clang-tidy/6.0.0/yaml/dumper.py new file mode 100644 index 000000000..f811d2c91 --- /dev/null +++ b/scripts/clang-tidy/6.0.0/yaml/dumper.py @@ -0,0 +1,62 @@ + +__all__ = ['BaseDumper', 'SafeDumper', 'Dumper'] + +from emitter import * +from serializer import * +from representer import * +from resolver import * + +class BaseDumper(Emitter, Serializer, BaseRepresenter, BaseResolver): + + def __init__(self, stream, + default_style=None, default_flow_style=None, + canonical=None, indent=None, width=None, + allow_unicode=None, line_break=None, + encoding=None, explicit_start=None, explicit_end=None, + version=None, tags=None): + Emitter.__init__(self, stream, canonical=canonical, + indent=indent, width=width, + allow_unicode=allow_unicode, line_break=line_break) + Serializer.__init__(self, encoding=encoding, + explicit_start=explicit_start, explicit_end=explicit_end, + version=version, tags=tags) + Representer.__init__(self, default_style=default_style, + default_flow_style=default_flow_style) + Resolver.__init__(self) + +class SafeDumper(Emitter, Serializer, SafeRepresenter, Resolver): + + def __init__(self, stream, + default_style=None, default_flow_style=None, + canonical=None, indent=None, width=None, + allow_unicode=None, line_break=None, + encoding=None, explicit_start=None, explicit_end=None, + version=None, tags=None): + Emitter.__init__(self, stream, canonical=canonical, + indent=indent, width=width, + allow_unicode=allow_unicode, line_break=line_break) + Serializer.__init__(self, encoding=encoding, + explicit_start=explicit_start, explicit_end=explicit_end, + version=version, tags=tags) + SafeRepresenter.__init__(self, default_style=default_style, + default_flow_style=default_flow_style) + Resolver.__init__(self) + +class Dumper(Emitter, Serializer, Representer, Resolver): + + def __init__(self, stream, + default_style=None, default_flow_style=None, + canonical=None, indent=None, width=None, + allow_unicode=None, line_break=None, + encoding=None, explicit_start=None, explicit_end=None, + version=None, tags=None): + Emitter.__init__(self, stream, canonical=canonical, + indent=indent, width=width, + allow_unicode=allow_unicode, line_break=line_break) + Serializer.__init__(self, encoding=encoding, + explicit_start=explicit_start, explicit_end=explicit_end, + version=version, tags=tags) + Representer.__init__(self, default_style=default_style, + default_flow_style=default_flow_style) + Resolver.__init__(self) + diff --git a/scripts/clang-tidy/6.0.0/yaml/emitter.py b/scripts/clang-tidy/6.0.0/yaml/emitter.py new file mode 100644 index 000000000..e5bcdcccb --- /dev/null +++ b/scripts/clang-tidy/6.0.0/yaml/emitter.py @@ -0,0 +1,1140 @@ + +# Emitter expects events obeying the following grammar: +# stream ::= STREAM-START document* STREAM-END +# document ::= DOCUMENT-START node DOCUMENT-END +# node ::= SCALAR | sequence | mapping +# sequence ::= SEQUENCE-START node* SEQUENCE-END +# mapping ::= MAPPING-START (node node)* MAPPING-END + +__all__ = ['Emitter', 'EmitterError'] + +from error import YAMLError +from events import * + +class EmitterError(YAMLError): + pass + +class ScalarAnalysis(object): + def __init__(self, scalar, empty, multiline, + allow_flow_plain, allow_block_plain, + allow_single_quoted, allow_double_quoted, + allow_block): + self.scalar = scalar + self.empty = empty + self.multiline = multiline + self.allow_flow_plain = allow_flow_plain + self.allow_block_plain = allow_block_plain + self.allow_single_quoted = allow_single_quoted + self.allow_double_quoted = allow_double_quoted + self.allow_block = allow_block + +class Emitter(object): + + DEFAULT_TAG_PREFIXES = { + u'!' : u'!', + u'tag:yaml.org,2002:' : u'!!', + } + + def __init__(self, stream, canonical=None, indent=None, width=None, + allow_unicode=None, line_break=None): + + # The stream should have the methods `write` and possibly `flush`. + self.stream = stream + + # Encoding can be overriden by STREAM-START. + self.encoding = None + + # Emitter is a state machine with a stack of states to handle nested + # structures. + self.states = [] + self.state = self.expect_stream_start + + # Current event and the event queue. + self.events = [] + self.event = None + + # The current indentation level and the stack of previous indents. + self.indents = [] + self.indent = None + + # Flow level. + self.flow_level = 0 + + # Contexts. + self.root_context = False + self.sequence_context = False + self.mapping_context = False + self.simple_key_context = False + + # Characteristics of the last emitted character: + # - current position. + # - is it a whitespace? + # - is it an indention character + # (indentation space, '-', '?', or ':')? + self.line = 0 + self.column = 0 + self.whitespace = True + self.indention = True + + # Whether the document requires an explicit document indicator + self.open_ended = False + + # Formatting details. + self.canonical = canonical + self.allow_unicode = allow_unicode + self.best_indent = 2 + if indent and 1 < indent < 10: + self.best_indent = indent + self.best_width = 80 + if width and width > self.best_indent*2: + self.best_width = width + self.best_line_break = u'\n' + if line_break in [u'\r', u'\n', u'\r\n']: + self.best_line_break = line_break + + # Tag prefixes. + self.tag_prefixes = None + + # Prepared anchor and tag. + self.prepared_anchor = None + self.prepared_tag = None + + # Scalar analysis and style. + self.analysis = None + self.style = None + + def dispose(self): + # Reset the state attributes (to clear self-references) + self.states = [] + self.state = None + + def emit(self, event): + self.events.append(event) + while not self.need_more_events(): + self.event = self.events.pop(0) + self.state() + self.event = None + + # In some cases, we wait for a few next events before emitting. + + def need_more_events(self): + if not self.events: + return True + event = self.events[0] + if isinstance(event, DocumentStartEvent): + return self.need_events(1) + elif isinstance(event, SequenceStartEvent): + return self.need_events(2) + elif isinstance(event, MappingStartEvent): + return self.need_events(3) + else: + return False + + def need_events(self, count): + level = 0 + for event in self.events[1:]: + if isinstance(event, (DocumentStartEvent, CollectionStartEvent)): + level += 1 + elif isinstance(event, (DocumentEndEvent, CollectionEndEvent)): + level -= 1 + elif isinstance(event, StreamEndEvent): + level = -1 + if level < 0: + return False + return (len(self.events) < count+1) + + def increase_indent(self, flow=False, indentless=False): + self.indents.append(self.indent) + if self.indent is None: + if flow: + self.indent = self.best_indent + else: + self.indent = 0 + elif not indentless: + self.indent += self.best_indent + + # States. + + # Stream handlers. + + def expect_stream_start(self): + if isinstance(self.event, StreamStartEvent): + if self.event.encoding and not getattr(self.stream, 'encoding', None): + self.encoding = self.event.encoding + self.write_stream_start() + self.state = self.expect_first_document_start + else: + raise EmitterError("expected StreamStartEvent, but got %s" + % self.event) + + def expect_nothing(self): + raise EmitterError("expected nothing, but got %s" % self.event) + + # Document handlers. + + def expect_first_document_start(self): + return self.expect_document_start(first=True) + + def expect_document_start(self, first=False): + if isinstance(self.event, DocumentStartEvent): + if (self.event.version or self.event.tags) and self.open_ended: + self.write_indicator(u'...', True) + self.write_indent() + if self.event.version: + version_text = self.prepare_version(self.event.version) + self.write_version_directive(version_text) + self.tag_prefixes = self.DEFAULT_TAG_PREFIXES.copy() + if self.event.tags: + handles = self.event.tags.keys() + handles.sort() + for handle in handles: + prefix = self.event.tags[handle] + self.tag_prefixes[prefix] = handle + handle_text = self.prepare_tag_handle(handle) + prefix_text = self.prepare_tag_prefix(prefix) + self.write_tag_directive(handle_text, prefix_text) + implicit = (first and not self.event.explicit and not self.canonical + and not self.event.version and not self.event.tags + and not self.check_empty_document()) + if not implicit: + self.write_indent() + self.write_indicator(u'---', True) + if self.canonical: + self.write_indent() + self.state = self.expect_document_root + elif isinstance(self.event, StreamEndEvent): + if self.open_ended: + self.write_indicator(u'...', True) + self.write_indent() + self.write_stream_end() + self.state = self.expect_nothing + else: + raise EmitterError("expected DocumentStartEvent, but got %s" + % self.event) + + def expect_document_end(self): + if isinstance(self.event, DocumentEndEvent): + self.write_indent() + if self.event.explicit: + self.write_indicator(u'...', True) + self.write_indent() + self.flush_stream() + self.state = self.expect_document_start + else: + raise EmitterError("expected DocumentEndEvent, but got %s" + % self.event) + + def expect_document_root(self): + self.states.append(self.expect_document_end) + self.expect_node(root=True) + + # Node handlers. + + def expect_node(self, root=False, sequence=False, mapping=False, + simple_key=False): + self.root_context = root + self.sequence_context = sequence + self.mapping_context = mapping + self.simple_key_context = simple_key + if isinstance(self.event, AliasEvent): + self.expect_alias() + elif isinstance(self.event, (ScalarEvent, CollectionStartEvent)): + self.process_anchor(u'&') + self.process_tag() + if isinstance(self.event, ScalarEvent): + self.expect_scalar() + elif isinstance(self.event, SequenceStartEvent): + if self.flow_level or self.canonical or self.event.flow_style \ + or self.check_empty_sequence(): + self.expect_flow_sequence() + else: + self.expect_block_sequence() + elif isinstance(self.event, MappingStartEvent): + if self.flow_level or self.canonical or self.event.flow_style \ + or self.check_empty_mapping(): + self.expect_flow_mapping() + else: + self.expect_block_mapping() + else: + raise EmitterError("expected NodeEvent, but got %s" % self.event) + + def expect_alias(self): + if self.event.anchor is None: + raise EmitterError("anchor is not specified for alias") + self.process_anchor(u'*') + self.state = self.states.pop() + + def expect_scalar(self): + self.increase_indent(flow=True) + self.process_scalar() + self.indent = self.indents.pop() + self.state = self.states.pop() + + # Flow sequence handlers. + + def expect_flow_sequence(self): + self.write_indicator(u'[', True, whitespace=True) + self.flow_level += 1 + self.increase_indent(flow=True) + self.state = self.expect_first_flow_sequence_item + + def expect_first_flow_sequence_item(self): + if isinstance(self.event, SequenceEndEvent): + self.indent = self.indents.pop() + self.flow_level -= 1 + self.write_indicator(u']', False) + self.state = self.states.pop() + else: + if self.canonical or self.column > self.best_width: + self.write_indent() + self.states.append(self.expect_flow_sequence_item) + self.expect_node(sequence=True) + + def expect_flow_sequence_item(self): + if isinstance(self.event, SequenceEndEvent): + self.indent = self.indents.pop() + self.flow_level -= 1 + if self.canonical: + self.write_indicator(u',', False) + self.write_indent() + self.write_indicator(u']', False) + self.state = self.states.pop() + else: + self.write_indicator(u',', False) + if self.canonical or self.column > self.best_width: + self.write_indent() + self.states.append(self.expect_flow_sequence_item) + self.expect_node(sequence=True) + + # Flow mapping handlers. + + def expect_flow_mapping(self): + self.write_indicator(u'{', True, whitespace=True) + self.flow_level += 1 + self.increase_indent(flow=True) + self.state = self.expect_first_flow_mapping_key + + def expect_first_flow_mapping_key(self): + if isinstance(self.event, MappingEndEvent): + self.indent = self.indents.pop() + self.flow_level -= 1 + self.write_indicator(u'}', False) + self.state = self.states.pop() + else: + if self.canonical or self.column > self.best_width: + self.write_indent() + if not self.canonical and self.check_simple_key(): + self.states.append(self.expect_flow_mapping_simple_value) + self.expect_node(mapping=True, simple_key=True) + else: + self.write_indicator(u'?', True) + self.states.append(self.expect_flow_mapping_value) + self.expect_node(mapping=True) + + def expect_flow_mapping_key(self): + if isinstance(self.event, MappingEndEvent): + self.indent = self.indents.pop() + self.flow_level -= 1 + if self.canonical: + self.write_indicator(u',', False) + self.write_indent() + self.write_indicator(u'}', False) + self.state = self.states.pop() + else: + self.write_indicator(u',', False) + if self.canonical or self.column > self.best_width: + self.write_indent() + if not self.canonical and self.check_simple_key(): + self.states.append(self.expect_flow_mapping_simple_value) + self.expect_node(mapping=True, simple_key=True) + else: + self.write_indicator(u'?', True) + self.states.append(self.expect_flow_mapping_value) + self.expect_node(mapping=True) + + def expect_flow_mapping_simple_value(self): + self.write_indicator(u':', False) + self.states.append(self.expect_flow_mapping_key) + self.expect_node(mapping=True) + + def expect_flow_mapping_value(self): + if self.canonical or self.column > self.best_width: + self.write_indent() + self.write_indicator(u':', True) + self.states.append(self.expect_flow_mapping_key) + self.expect_node(mapping=True) + + # Block sequence handlers. + + def expect_block_sequence(self): + indentless = (self.mapping_context and not self.indention) + self.increase_indent(flow=False, indentless=indentless) + self.state = self.expect_first_block_sequence_item + + def expect_first_block_sequence_item(self): + return self.expect_block_sequence_item(first=True) + + def expect_block_sequence_item(self, first=False): + if not first and isinstance(self.event, SequenceEndEvent): + self.indent = self.indents.pop() + self.state = self.states.pop() + else: + self.write_indent() + self.write_indicator(u'-', True, indention=True) + self.states.append(self.expect_block_sequence_item) + self.expect_node(sequence=True) + + # Block mapping handlers. + + def expect_block_mapping(self): + self.increase_indent(flow=False) + self.state = self.expect_first_block_mapping_key + + def expect_first_block_mapping_key(self): + return self.expect_block_mapping_key(first=True) + + def expect_block_mapping_key(self, first=False): + if not first and isinstance(self.event, MappingEndEvent): + self.indent = self.indents.pop() + self.state = self.states.pop() + else: + self.write_indent() + if self.check_simple_key(): + self.states.append(self.expect_block_mapping_simple_value) + self.expect_node(mapping=True, simple_key=True) + else: + self.write_indicator(u'?', True, indention=True) + self.states.append(self.expect_block_mapping_value) + self.expect_node(mapping=True) + + def expect_block_mapping_simple_value(self): + self.write_indicator(u':', False) + self.states.append(self.expect_block_mapping_key) + self.expect_node(mapping=True) + + def expect_block_mapping_value(self): + self.write_indent() + self.write_indicator(u':', True, indention=True) + self.states.append(self.expect_block_mapping_key) + self.expect_node(mapping=True) + + # Checkers. + + def check_empty_sequence(self): + return (isinstance(self.event, SequenceStartEvent) and self.events + and isinstance(self.events[0], SequenceEndEvent)) + + def check_empty_mapping(self): + return (isinstance(self.event, MappingStartEvent) and self.events + and isinstance(self.events[0], MappingEndEvent)) + + def check_empty_document(self): + if not isinstance(self.event, DocumentStartEvent) or not self.events: + return False + event = self.events[0] + return (isinstance(event, ScalarEvent) and event.anchor is None + and event.tag is None and event.implicit and event.value == u'') + + def check_simple_key(self): + length = 0 + if isinstance(self.event, NodeEvent) and self.event.anchor is not None: + if self.prepared_anchor is None: + self.prepared_anchor = self.prepare_anchor(self.event.anchor) + length += len(self.prepared_anchor) + if isinstance(self.event, (ScalarEvent, CollectionStartEvent)) \ + and self.event.tag is not None: + if self.prepared_tag is None: + self.prepared_tag = self.prepare_tag(self.event.tag) + length += len(self.prepared_tag) + if isinstance(self.event, ScalarEvent): + if self.analysis is None: + self.analysis = self.analyze_scalar(self.event.value) + length += len(self.analysis.scalar) + return (length < 128 and (isinstance(self.event, AliasEvent) + or (isinstance(self.event, ScalarEvent) + and not self.analysis.empty and not self.analysis.multiline) + or self.check_empty_sequence() or self.check_empty_mapping())) + + # Anchor, Tag, and Scalar processors. + + def process_anchor(self, indicator): + if self.event.anchor is None: + self.prepared_anchor = None + return + if self.prepared_anchor is None: + self.prepared_anchor = self.prepare_anchor(self.event.anchor) + if self.prepared_anchor: + self.write_indicator(indicator+self.prepared_anchor, True) + self.prepared_anchor = None + + def process_tag(self): + tag = self.event.tag + if isinstance(self.event, ScalarEvent): + if self.style is None: + self.style = self.choose_scalar_style() + if ((not self.canonical or tag is None) and + ((self.style == '' and self.event.implicit[0]) + or (self.style != '' and self.event.implicit[1]))): + self.prepared_tag = None + return + if self.event.implicit[0] and tag is None: + tag = u'!' + self.prepared_tag = None + else: + if (not self.canonical or tag is None) and self.event.implicit: + self.prepared_tag = None + return + if tag is None: + raise EmitterError("tag is not specified") + if self.prepared_tag is None: + self.prepared_tag = self.prepare_tag(tag) + if self.prepared_tag: + self.write_indicator(self.prepared_tag, True) + self.prepared_tag = None + + def choose_scalar_style(self): + if self.analysis is None: + self.analysis = self.analyze_scalar(self.event.value) + if self.event.style == '"' or self.canonical: + return '"' + if not self.event.style and self.event.implicit[0]: + if (not (self.simple_key_context and + (self.analysis.empty or self.analysis.multiline)) + and (self.flow_level and self.analysis.allow_flow_plain + or (not self.flow_level and self.analysis.allow_block_plain))): + return '' + if self.event.style and self.event.style in '|>': + if (not self.flow_level and not self.simple_key_context + and self.analysis.allow_block): + return self.event.style + if not self.event.style or self.event.style == '\'': + if (self.analysis.allow_single_quoted and + not (self.simple_key_context and self.analysis.multiline)): + return '\'' + return '"' + + def process_scalar(self): + if self.analysis is None: + self.analysis = self.analyze_scalar(self.event.value) + if self.style is None: + self.style = self.choose_scalar_style() + split = (not self.simple_key_context) + #if self.analysis.multiline and split \ + # and (not self.style or self.style in '\'\"'): + # self.write_indent() + if self.style == '"': + self.write_double_quoted(self.analysis.scalar, split) + elif self.style == '\'': + self.write_single_quoted(self.analysis.scalar, split) + elif self.style == '>': + self.write_folded(self.analysis.scalar) + elif self.style == '|': + self.write_literal(self.analysis.scalar) + else: + self.write_plain(self.analysis.scalar, split) + self.analysis = None + self.style = None + + # Analyzers. + + def prepare_version(self, version): + major, minor = version + if major != 1: + raise EmitterError("unsupported YAML version: %d.%d" % (major, minor)) + return u'%d.%d' % (major, minor) + + def prepare_tag_handle(self, handle): + if not handle: + raise EmitterError("tag handle must not be empty") + if handle[0] != u'!' or handle[-1] != u'!': + raise EmitterError("tag handle must start and end with '!': %r" + % (handle.encode('utf-8'))) + for ch in handle[1:-1]: + if not (u'0' <= ch <= u'9' or u'A' <= ch <= u'Z' or u'a' <= ch <= u'z' \ + or ch in u'-_'): + raise EmitterError("invalid character %r in the tag handle: %r" + % (ch.encode('utf-8'), handle.encode('utf-8'))) + return handle + + def prepare_tag_prefix(self, prefix): + if not prefix: + raise EmitterError("tag prefix must not be empty") + chunks = [] + start = end = 0 + if prefix[0] == u'!': + end = 1 + while end < len(prefix): + ch = prefix[end] + if u'0' <= ch <= u'9' or u'A' <= ch <= u'Z' or u'a' <= ch <= u'z' \ + or ch in u'-;/?!:@&=+$,_.~*\'()[]': + end += 1 + else: + if start < end: + chunks.append(prefix[start:end]) + start = end = end+1 + data = ch.encode('utf-8') + for ch in data: + chunks.append(u'%%%02X' % ord(ch)) + if start < end: + chunks.append(prefix[start:end]) + return u''.join(chunks) + + def prepare_tag(self, tag): + if not tag: + raise EmitterError("tag must not be empty") + if tag == u'!': + return tag + handle = None + suffix = tag + prefixes = self.tag_prefixes.keys() + prefixes.sort() + for prefix in prefixes: + if tag.startswith(prefix) \ + and (prefix == u'!' or len(prefix) < len(tag)): + handle = self.tag_prefixes[prefix] + suffix = tag[len(prefix):] + chunks = [] + start = end = 0 + while end < len(suffix): + ch = suffix[end] + if u'0' <= ch <= u'9' or u'A' <= ch <= u'Z' or u'a' <= ch <= u'z' \ + or ch in u'-;/?:@&=+$,_.~*\'()[]' \ + or (ch == u'!' and handle != u'!'): + end += 1 + else: + if start < end: + chunks.append(suffix[start:end]) + start = end = end+1 + data = ch.encode('utf-8') + for ch in data: + chunks.append(u'%%%02X' % ord(ch)) + if start < end: + chunks.append(suffix[start:end]) + suffix_text = u''.join(chunks) + if handle: + return u'%s%s' % (handle, suffix_text) + else: + return u'!<%s>' % suffix_text + + def prepare_anchor(self, anchor): + if not anchor: + raise EmitterError("anchor must not be empty") + for ch in anchor: + if not (u'0' <= ch <= u'9' or u'A' <= ch <= u'Z' or u'a' <= ch <= u'z' \ + or ch in u'-_'): + raise EmitterError("invalid character %r in the anchor: %r" + % (ch.encode('utf-8'), anchor.encode('utf-8'))) + return anchor + + def analyze_scalar(self, scalar): + + # Empty scalar is a special case. + if not scalar: + return ScalarAnalysis(scalar=scalar, empty=True, multiline=False, + allow_flow_plain=False, allow_block_plain=True, + allow_single_quoted=True, allow_double_quoted=True, + allow_block=False) + + # Indicators and special characters. + block_indicators = False + flow_indicators = False + line_breaks = False + special_characters = False + + # Important whitespace combinations. + leading_space = False + leading_break = False + trailing_space = False + trailing_break = False + break_space = False + space_break = False + + # Check document indicators. + if scalar.startswith(u'---') or scalar.startswith(u'...'): + block_indicators = True + flow_indicators = True + + # First character or preceded by a whitespace. + preceeded_by_whitespace = True + + # Last character or followed by a whitespace. + followed_by_whitespace = (len(scalar) == 1 or + scalar[1] in u'\0 \t\r\n\x85\u2028\u2029') + + # The previous character is a space. + previous_space = False + + # The previous character is a break. + previous_break = False + + index = 0 + while index < len(scalar): + ch = scalar[index] + + # Check for indicators. + if index == 0: + # Leading indicators are special characters. + if ch in u'#,[]{}&*!|>\'\"%@`': + flow_indicators = True + block_indicators = True + if ch in u'?:': + flow_indicators = True + if followed_by_whitespace: + block_indicators = True + if ch == u'-' and followed_by_whitespace: + flow_indicators = True + block_indicators = True + else: + # Some indicators cannot appear within a scalar as well. + if ch in u',?[]{}': + flow_indicators = True + if ch == u':': + flow_indicators = True + if followed_by_whitespace: + block_indicators = True + if ch == u'#' and preceeded_by_whitespace: + flow_indicators = True + block_indicators = True + + # Check for line breaks, special, and unicode characters. + if ch in u'\n\x85\u2028\u2029': + line_breaks = True + if not (ch == u'\n' or u'\x20' <= ch <= u'\x7E'): + if (ch == u'\x85' or u'\xA0' <= ch <= u'\uD7FF' + or u'\uE000' <= ch <= u'\uFFFD') and ch != u'\uFEFF': + unicode_characters = True + if not self.allow_unicode: + special_characters = True + else: + special_characters = True + + # Detect important whitespace combinations. + if ch == u' ': + if index == 0: + leading_space = True + if index == len(scalar)-1: + trailing_space = True + if previous_break: + break_space = True + previous_space = True + previous_break = False + elif ch in u'\n\x85\u2028\u2029': + if index == 0: + leading_break = True + if index == len(scalar)-1: + trailing_break = True + if previous_space: + space_break = True + previous_space = False + previous_break = True + else: + previous_space = False + previous_break = False + + # Prepare for the next character. + index += 1 + preceeded_by_whitespace = (ch in u'\0 \t\r\n\x85\u2028\u2029') + followed_by_whitespace = (index+1 >= len(scalar) or + scalar[index+1] in u'\0 \t\r\n\x85\u2028\u2029') + + # Let's decide what styles are allowed. + allow_flow_plain = True + allow_block_plain = True + allow_single_quoted = True + allow_double_quoted = True + allow_block = True + + # Leading and trailing whitespaces are bad for plain scalars. + if (leading_space or leading_break + or trailing_space or trailing_break): + allow_flow_plain = allow_block_plain = False + + # We do not permit trailing spaces for block scalars. + if trailing_space: + allow_block = False + + # Spaces at the beginning of a new line are only acceptable for block + # scalars. + if break_space: + allow_flow_plain = allow_block_plain = allow_single_quoted = False + + # Spaces followed by breaks, as well as special character are only + # allowed for double quoted scalars. + if space_break or special_characters: + allow_flow_plain = allow_block_plain = \ + allow_single_quoted = allow_block = False + + # Although the plain scalar writer supports breaks, we never emit + # multiline plain scalars. + if line_breaks: + allow_flow_plain = allow_block_plain = False + + # Flow indicators are forbidden for flow plain scalars. + if flow_indicators: + allow_flow_plain = False + + # Block indicators are forbidden for block plain scalars. + if block_indicators: + allow_block_plain = False + + return ScalarAnalysis(scalar=scalar, + empty=False, multiline=line_breaks, + allow_flow_plain=allow_flow_plain, + allow_block_plain=allow_block_plain, + allow_single_quoted=allow_single_quoted, + allow_double_quoted=allow_double_quoted, + allow_block=allow_block) + + # Writers. + + def flush_stream(self): + if hasattr(self.stream, 'flush'): + self.stream.flush() + + def write_stream_start(self): + # Write BOM if needed. + if self.encoding and self.encoding.startswith('utf-16'): + self.stream.write(u'\uFEFF'.encode(self.encoding)) + + def write_stream_end(self): + self.flush_stream() + + def write_indicator(self, indicator, need_whitespace, + whitespace=False, indention=False): + if self.whitespace or not need_whitespace: + data = indicator + else: + data = u' '+indicator + self.whitespace = whitespace + self.indention = self.indention and indention + self.column += len(data) + self.open_ended = False + if self.encoding: + data = data.encode(self.encoding) + self.stream.write(data) + + def write_indent(self): + indent = self.indent or 0 + if not self.indention or self.column > indent \ + or (self.column == indent and not self.whitespace): + self.write_line_break() + if self.column < indent: + self.whitespace = True + data = u' '*(indent-self.column) + self.column = indent + if self.encoding: + data = data.encode(self.encoding) + self.stream.write(data) + + def write_line_break(self, data=None): + if data is None: + data = self.best_line_break + self.whitespace = True + self.indention = True + self.line += 1 + self.column = 0 + if self.encoding: + data = data.encode(self.encoding) + self.stream.write(data) + + def write_version_directive(self, version_text): + data = u'%%YAML %s' % version_text + if self.encoding: + data = data.encode(self.encoding) + self.stream.write(data) + self.write_line_break() + + def write_tag_directive(self, handle_text, prefix_text): + data = u'%%TAG %s %s' % (handle_text, prefix_text) + if self.encoding: + data = data.encode(self.encoding) + self.stream.write(data) + self.write_line_break() + + # Scalar streams. + + def write_single_quoted(self, text, split=True): + self.write_indicator(u'\'', True) + spaces = False + breaks = False + start = end = 0 + while end <= len(text): + ch = None + if end < len(text): + ch = text[end] + if spaces: + if ch is None or ch != u' ': + if start+1 == end and self.column > self.best_width and split \ + and start != 0 and end != len(text): + self.write_indent() + else: + data = text[start:end] + self.column += len(data) + if self.encoding: + data = data.encode(self.encoding) + self.stream.write(data) + start = end + elif breaks: + if ch is None or ch not in u'\n\x85\u2028\u2029': + if text[start] == u'\n': + self.write_line_break() + for br in text[start:end]: + if br == u'\n': + self.write_line_break() + else: + self.write_line_break(br) + self.write_indent() + start = end + else: + if ch is None or ch in u' \n\x85\u2028\u2029' or ch == u'\'': + if start < end: + data = text[start:end] + self.column += len(data) + if self.encoding: + data = data.encode(self.encoding) + self.stream.write(data) + start = end + if ch == u'\'': + data = u'\'\'' + self.column += 2 + if self.encoding: + data = data.encode(self.encoding) + self.stream.write(data) + start = end + 1 + if ch is not None: + spaces = (ch == u' ') + breaks = (ch in u'\n\x85\u2028\u2029') + end += 1 + self.write_indicator(u'\'', False) + + ESCAPE_REPLACEMENTS = { + u'\0': u'0', + u'\x07': u'a', + u'\x08': u'b', + u'\x09': u't', + u'\x0A': u'n', + u'\x0B': u'v', + u'\x0C': u'f', + u'\x0D': u'r', + u'\x1B': u'e', + u'\"': u'\"', + u'\\': u'\\', + u'\x85': u'N', + u'\xA0': u'_', + u'\u2028': u'L', + u'\u2029': u'P', + } + + def write_double_quoted(self, text, split=True): + self.write_indicator(u'"', True) + start = end = 0 + while end <= len(text): + ch = None + if end < len(text): + ch = text[end] + if ch is None or ch in u'"\\\x85\u2028\u2029\uFEFF' \ + or not (u'\x20' <= ch <= u'\x7E' + or (self.allow_unicode + and (u'\xA0' <= ch <= u'\uD7FF' + or u'\uE000' <= ch <= u'\uFFFD'))): + if start < end: + data = text[start:end] + self.column += len(data) + if self.encoding: + data = data.encode(self.encoding) + self.stream.write(data) + start = end + if ch is not None: + if ch in self.ESCAPE_REPLACEMENTS: + data = u'\\'+self.ESCAPE_REPLACEMENTS[ch] + elif ch <= u'\xFF': + data = u'\\x%02X' % ord(ch) + elif ch <= u'\uFFFF': + data = u'\\u%04X' % ord(ch) + else: + data = u'\\U%08X' % ord(ch) + self.column += len(data) + if self.encoding: + data = data.encode(self.encoding) + self.stream.write(data) + start = end+1 + if 0 < end < len(text)-1 and (ch == u' ' or start >= end) \ + and self.column+(end-start) > self.best_width and split: + data = text[start:end]+u'\\' + if start < end: + start = end + self.column += len(data) + if self.encoding: + data = data.encode(self.encoding) + self.stream.write(data) + self.write_indent() + self.whitespace = False + self.indention = False + if text[start] == u' ': + data = u'\\' + self.column += len(data) + if self.encoding: + data = data.encode(self.encoding) + self.stream.write(data) + end += 1 + self.write_indicator(u'"', False) + + def determine_block_hints(self, text): + hints = u'' + if text: + if text[0] in u' \n\x85\u2028\u2029': + hints += unicode(self.best_indent) + if text[-1] not in u'\n\x85\u2028\u2029': + hints += u'-' + elif len(text) == 1 or text[-2] in u'\n\x85\u2028\u2029': + hints += u'+' + return hints + + def write_folded(self, text): + hints = self.determine_block_hints(text) + self.write_indicator(u'>'+hints, True) + if hints[-1:] == u'+': + self.open_ended = True + self.write_line_break() + leading_space = True + spaces = False + breaks = True + start = end = 0 + while end <= len(text): + ch = None + if end < len(text): + ch = text[end] + if breaks: + if ch is None or ch not in u'\n\x85\u2028\u2029': + if not leading_space and ch is not None and ch != u' ' \ + and text[start] == u'\n': + self.write_line_break() + leading_space = (ch == u' ') + for br in text[start:end]: + if br == u'\n': + self.write_line_break() + else: + self.write_line_break(br) + if ch is not None: + self.write_indent() + start = end + elif spaces: + if ch != u' ': + if start+1 == end and self.column > self.best_width: + self.write_indent() + else: + data = text[start:end] + self.column += len(data) + if self.encoding: + data = data.encode(self.encoding) + self.stream.write(data) + start = end + else: + if ch is None or ch in u' \n\x85\u2028\u2029': + data = text[start:end] + self.column += len(data) + if self.encoding: + data = data.encode(self.encoding) + self.stream.write(data) + if ch is None: + self.write_line_break() + start = end + if ch is not None: + breaks = (ch in u'\n\x85\u2028\u2029') + spaces = (ch == u' ') + end += 1 + + def write_literal(self, text): + hints = self.determine_block_hints(text) + self.write_indicator(u'|'+hints, True) + if hints[-1:] == u'+': + self.open_ended = True + self.write_line_break() + breaks = True + start = end = 0 + while end <= len(text): + ch = None + if end < len(text): + ch = text[end] + if breaks: + if ch is None or ch not in u'\n\x85\u2028\u2029': + for br in text[start:end]: + if br == u'\n': + self.write_line_break() + else: + self.write_line_break(br) + if ch is not None: + self.write_indent() + start = end + else: + if ch is None or ch in u'\n\x85\u2028\u2029': + data = text[start:end] + if self.encoding: + data = data.encode(self.encoding) + self.stream.write(data) + if ch is None: + self.write_line_break() + start = end + if ch is not None: + breaks = (ch in u'\n\x85\u2028\u2029') + end += 1 + + def write_plain(self, text, split=True): + if self.root_context: + self.open_ended = True + if not text: + return + if not self.whitespace: + data = u' ' + self.column += len(data) + if self.encoding: + data = data.encode(self.encoding) + self.stream.write(data) + self.whitespace = False + self.indention = False + spaces = False + breaks = False + start = end = 0 + while end <= len(text): + ch = None + if end < len(text): + ch = text[end] + if spaces: + if ch != u' ': + if start+1 == end and self.column > self.best_width and split: + self.write_indent() + self.whitespace = False + self.indention = False + else: + data = text[start:end] + self.column += len(data) + if self.encoding: + data = data.encode(self.encoding) + self.stream.write(data) + start = end + elif breaks: + if ch not in u'\n\x85\u2028\u2029': + if text[start] == u'\n': + self.write_line_break() + for br in text[start:end]: + if br == u'\n': + self.write_line_break() + else: + self.write_line_break(br) + self.write_indent() + self.whitespace = False + self.indention = False + start = end + else: + if ch is None or ch in u' \n\x85\u2028\u2029': + data = text[start:end] + self.column += len(data) + if self.encoding: + data = data.encode(self.encoding) + self.stream.write(data) + start = end + if ch is not None: + spaces = (ch == u' ') + breaks = (ch in u'\n\x85\u2028\u2029') + end += 1 + diff --git a/scripts/clang-tidy/6.0.0/yaml/error.py b/scripts/clang-tidy/6.0.0/yaml/error.py new file mode 100644 index 000000000..577686db5 --- /dev/null +++ b/scripts/clang-tidy/6.0.0/yaml/error.py @@ -0,0 +1,75 @@ + +__all__ = ['Mark', 'YAMLError', 'MarkedYAMLError'] + +class Mark(object): + + def __init__(self, name, index, line, column, buffer, pointer): + self.name = name + self.index = index + self.line = line + self.column = column + self.buffer = buffer + self.pointer = pointer + + def get_snippet(self, indent=4, max_length=75): + if self.buffer is None: + return None + head = '' + start = self.pointer + while start > 0 and self.buffer[start-1] not in u'\0\r\n\x85\u2028\u2029': + start -= 1 + if self.pointer-start > max_length/2-1: + head = ' ... ' + start += 5 + break + tail = '' + end = self.pointer + while end < len(self.buffer) and self.buffer[end] not in u'\0\r\n\x85\u2028\u2029': + end += 1 + if end-self.pointer > max_length/2-1: + tail = ' ... ' + end -= 5 + break + snippet = self.buffer[start:end].encode('utf-8') + return ' '*indent + head + snippet + tail + '\n' \ + + ' '*(indent+self.pointer-start+len(head)) + '^' + + def __str__(self): + snippet = self.get_snippet() + where = " in \"%s\", line %d, column %d" \ + % (self.name, self.line+1, self.column+1) + if snippet is not None: + where += ":\n"+snippet + return where + +class YAMLError(Exception): + pass + +class MarkedYAMLError(YAMLError): + + def __init__(self, context=None, context_mark=None, + problem=None, problem_mark=None, note=None): + self.context = context + self.context_mark = context_mark + self.problem = problem + self.problem_mark = problem_mark + self.note = note + + def __str__(self): + lines = [] + if self.context is not None: + lines.append(self.context) + if self.context_mark is not None \ + and (self.problem is None or self.problem_mark is None + or self.context_mark.name != self.problem_mark.name + or self.context_mark.line != self.problem_mark.line + or self.context_mark.column != self.problem_mark.column): + lines.append(str(self.context_mark)) + if self.problem is not None: + lines.append(self.problem) + if self.problem_mark is not None: + lines.append(str(self.problem_mark)) + if self.note is not None: + lines.append(self.note) + return '\n'.join(lines) + diff --git a/scripts/clang-tidy/6.0.0/yaml/events.py b/scripts/clang-tidy/6.0.0/yaml/events.py new file mode 100644 index 000000000..f79ad389c --- /dev/null +++ b/scripts/clang-tidy/6.0.0/yaml/events.py @@ -0,0 +1,86 @@ + +# Abstract classes. + +class Event(object): + def __init__(self, start_mark=None, end_mark=None): + self.start_mark = start_mark + self.end_mark = end_mark + def __repr__(self): + attributes = [key for key in ['anchor', 'tag', 'implicit', 'value'] + if hasattr(self, key)] + arguments = ', '.join(['%s=%r' % (key, getattr(self, key)) + for key in attributes]) + return '%s(%s)' % (self.__class__.__name__, arguments) + +class NodeEvent(Event): + def __init__(self, anchor, start_mark=None, end_mark=None): + self.anchor = anchor + self.start_mark = start_mark + self.end_mark = end_mark + +class CollectionStartEvent(NodeEvent): + def __init__(self, anchor, tag, implicit, start_mark=None, end_mark=None, + flow_style=None): + self.anchor = anchor + self.tag = tag + self.implicit = implicit + self.start_mark = start_mark + self.end_mark = end_mark + self.flow_style = flow_style + +class CollectionEndEvent(Event): + pass + +# Implementations. + +class StreamStartEvent(Event): + def __init__(self, start_mark=None, end_mark=None, encoding=None): + self.start_mark = start_mark + self.end_mark = end_mark + self.encoding = encoding + +class StreamEndEvent(Event): + pass + +class DocumentStartEvent(Event): + def __init__(self, start_mark=None, end_mark=None, + explicit=None, version=None, tags=None): + self.start_mark = start_mark + self.end_mark = end_mark + self.explicit = explicit + self.version = version + self.tags = tags + +class DocumentEndEvent(Event): + def __init__(self, start_mark=None, end_mark=None, + explicit=None): + self.start_mark = start_mark + self.end_mark = end_mark + self.explicit = explicit + +class AliasEvent(NodeEvent): + pass + +class ScalarEvent(NodeEvent): + def __init__(self, anchor, tag, implicit, value, + start_mark=None, end_mark=None, style=None): + self.anchor = anchor + self.tag = tag + self.implicit = implicit + self.value = value + self.start_mark = start_mark + self.end_mark = end_mark + self.style = style + +class SequenceStartEvent(CollectionStartEvent): + pass + +class SequenceEndEvent(CollectionEndEvent): + pass + +class MappingStartEvent(CollectionStartEvent): + pass + +class MappingEndEvent(CollectionEndEvent): + pass + diff --git a/scripts/clang-tidy/6.0.0/yaml/loader.py b/scripts/clang-tidy/6.0.0/yaml/loader.py new file mode 100644 index 000000000..293ff467b --- /dev/null +++ b/scripts/clang-tidy/6.0.0/yaml/loader.py @@ -0,0 +1,40 @@ + +__all__ = ['BaseLoader', 'SafeLoader', 'Loader'] + +from reader import * +from scanner import * +from parser import * +from composer import * +from constructor import * +from resolver import * + +class BaseLoader(Reader, Scanner, Parser, Composer, BaseConstructor, BaseResolver): + + def __init__(self, stream): + Reader.__init__(self, stream) + Scanner.__init__(self) + Parser.__init__(self) + Composer.__init__(self) + BaseConstructor.__init__(self) + BaseResolver.__init__(self) + +class SafeLoader(Reader, Scanner, Parser, Composer, SafeConstructor, Resolver): + + def __init__(self, stream): + Reader.__init__(self, stream) + Scanner.__init__(self) + Parser.__init__(self) + Composer.__init__(self) + SafeConstructor.__init__(self) + Resolver.__init__(self) + +class Loader(Reader, Scanner, Parser, Composer, Constructor, Resolver): + + def __init__(self, stream): + Reader.__init__(self, stream) + Scanner.__init__(self) + Parser.__init__(self) + Composer.__init__(self) + Constructor.__init__(self) + Resolver.__init__(self) + diff --git a/scripts/clang-tidy/6.0.0/yaml/nodes.py b/scripts/clang-tidy/6.0.0/yaml/nodes.py new file mode 100644 index 000000000..c4f070c41 --- /dev/null +++ b/scripts/clang-tidy/6.0.0/yaml/nodes.py @@ -0,0 +1,49 @@ + +class Node(object): + def __init__(self, tag, value, start_mark, end_mark): + self.tag = tag + self.value = value + self.start_mark = start_mark + self.end_mark = end_mark + def __repr__(self): + value = self.value + #if isinstance(value, list): + # if len(value) == 0: + # value = '' + # elif len(value) == 1: + # value = '<1 item>' + # else: + # value = '<%d items>' % len(value) + #else: + # if len(value) > 75: + # value = repr(value[:70]+u' ... ') + # else: + # value = repr(value) + value = repr(value) + return '%s(tag=%r, value=%s)' % (self.__class__.__name__, self.tag, value) + +class ScalarNode(Node): + id = 'scalar' + def __init__(self, tag, value, + start_mark=None, end_mark=None, style=None): + self.tag = tag + self.value = value + self.start_mark = start_mark + self.end_mark = end_mark + self.style = style + +class CollectionNode(Node): + def __init__(self, tag, value, + start_mark=None, end_mark=None, flow_style=None): + self.tag = tag + self.value = value + self.start_mark = start_mark + self.end_mark = end_mark + self.flow_style = flow_style + +class SequenceNode(CollectionNode): + id = 'sequence' + +class MappingNode(CollectionNode): + id = 'mapping' + diff --git a/scripts/clang-tidy/6.0.0/yaml/parser.py b/scripts/clang-tidy/6.0.0/yaml/parser.py new file mode 100644 index 000000000..f9e3057f3 --- /dev/null +++ b/scripts/clang-tidy/6.0.0/yaml/parser.py @@ -0,0 +1,589 @@ + +# The following YAML grammar is LL(1) and is parsed by a recursive descent +# parser. +# +# stream ::= STREAM-START implicit_document? explicit_document* STREAM-END +# implicit_document ::= block_node DOCUMENT-END* +# explicit_document ::= DIRECTIVE* DOCUMENT-START block_node? DOCUMENT-END* +# block_node_or_indentless_sequence ::= +# ALIAS +# | properties (block_content | indentless_block_sequence)? +# | block_content +# | indentless_block_sequence +# block_node ::= ALIAS +# | properties block_content? +# | block_content +# flow_node ::= ALIAS +# | properties flow_content? +# | flow_content +# properties ::= TAG ANCHOR? | ANCHOR TAG? +# block_content ::= block_collection | flow_collection | SCALAR +# flow_content ::= flow_collection | SCALAR +# block_collection ::= block_sequence | block_mapping +# flow_collection ::= flow_sequence | flow_mapping +# block_sequence ::= BLOCK-SEQUENCE-START (BLOCK-ENTRY block_node?)* BLOCK-END +# indentless_sequence ::= (BLOCK-ENTRY block_node?)+ +# block_mapping ::= BLOCK-MAPPING_START +# ((KEY block_node_or_indentless_sequence?)? +# (VALUE block_node_or_indentless_sequence?)?)* +# BLOCK-END +# flow_sequence ::= FLOW-SEQUENCE-START +# (flow_sequence_entry FLOW-ENTRY)* +# flow_sequence_entry? +# FLOW-SEQUENCE-END +# flow_sequence_entry ::= flow_node | KEY flow_node? (VALUE flow_node?)? +# flow_mapping ::= FLOW-MAPPING-START +# (flow_mapping_entry FLOW-ENTRY)* +# flow_mapping_entry? +# FLOW-MAPPING-END +# flow_mapping_entry ::= flow_node | KEY flow_node? (VALUE flow_node?)? +# +# FIRST sets: +# +# stream: { STREAM-START } +# explicit_document: { DIRECTIVE DOCUMENT-START } +# implicit_document: FIRST(block_node) +# block_node: { ALIAS TAG ANCHOR SCALAR BLOCK-SEQUENCE-START BLOCK-MAPPING-START FLOW-SEQUENCE-START FLOW-MAPPING-START } +# flow_node: { ALIAS ANCHOR TAG SCALAR FLOW-SEQUENCE-START FLOW-MAPPING-START } +# block_content: { BLOCK-SEQUENCE-START BLOCK-MAPPING-START FLOW-SEQUENCE-START FLOW-MAPPING-START SCALAR } +# flow_content: { FLOW-SEQUENCE-START FLOW-MAPPING-START SCALAR } +# block_collection: { BLOCK-SEQUENCE-START BLOCK-MAPPING-START } +# flow_collection: { FLOW-SEQUENCE-START FLOW-MAPPING-START } +# block_sequence: { BLOCK-SEQUENCE-START } +# block_mapping: { BLOCK-MAPPING-START } +# block_node_or_indentless_sequence: { ALIAS ANCHOR TAG SCALAR BLOCK-SEQUENCE-START BLOCK-MAPPING-START FLOW-SEQUENCE-START FLOW-MAPPING-START BLOCK-ENTRY } +# indentless_sequence: { ENTRY } +# flow_collection: { FLOW-SEQUENCE-START FLOW-MAPPING-START } +# flow_sequence: { FLOW-SEQUENCE-START } +# flow_mapping: { FLOW-MAPPING-START } +# flow_sequence_entry: { ALIAS ANCHOR TAG SCALAR FLOW-SEQUENCE-START FLOW-MAPPING-START KEY } +# flow_mapping_entry: { ALIAS ANCHOR TAG SCALAR FLOW-SEQUENCE-START FLOW-MAPPING-START KEY } + +__all__ = ['Parser', 'ParserError'] + +from error import MarkedYAMLError +from tokens import * +from events import * +from scanner import * + +class ParserError(MarkedYAMLError): + pass + +class Parser(object): + # Since writing a recursive-descendant parser is a straightforward task, we + # do not give many comments here. + + DEFAULT_TAGS = { + u'!': u'!', + u'!!': u'tag:yaml.org,2002:', + } + + def __init__(self): + self.current_event = None + self.yaml_version = None + self.tag_handles = {} + self.states = [] + self.marks = [] + self.state = self.parse_stream_start + + def dispose(self): + # Reset the state attributes (to clear self-references) + self.states = [] + self.state = None + + def check_event(self, *choices): + # Check the type of the next event. + if self.current_event is None: + if self.state: + self.current_event = self.state() + if self.current_event is not None: + if not choices: + return True + for choice in choices: + if isinstance(self.current_event, choice): + return True + return False + + def peek_event(self): + # Get the next event. + if self.current_event is None: + if self.state: + self.current_event = self.state() + return self.current_event + + def get_event(self): + # Get the next event and proceed further. + if self.current_event is None: + if self.state: + self.current_event = self.state() + value = self.current_event + self.current_event = None + return value + + # stream ::= STREAM-START implicit_document? explicit_document* STREAM-END + # implicit_document ::= block_node DOCUMENT-END* + # explicit_document ::= DIRECTIVE* DOCUMENT-START block_node? DOCUMENT-END* + + def parse_stream_start(self): + + # Parse the stream start. + token = self.get_token() + event = StreamStartEvent(token.start_mark, token.end_mark, + encoding=token.encoding) + + # Prepare the next state. + self.state = self.parse_implicit_document_start + + return event + + def parse_implicit_document_start(self): + + # Parse an implicit document. + if not self.check_token(DirectiveToken, DocumentStartToken, + StreamEndToken): + self.tag_handles = self.DEFAULT_TAGS + token = self.peek_token() + start_mark = end_mark = token.start_mark + event = DocumentStartEvent(start_mark, end_mark, + explicit=False) + + # Prepare the next state. + self.states.append(self.parse_document_end) + self.state = self.parse_block_node + + return event + + else: + return self.parse_document_start() + + def parse_document_start(self): + + # Parse any extra document end indicators. + while self.check_token(DocumentEndToken): + self.get_token() + + # Parse an explicit document. + if not self.check_token(StreamEndToken): + token = self.peek_token() + start_mark = token.start_mark + version, tags = self.process_directives() + if not self.check_token(DocumentStartToken): + raise ParserError(None, None, + "expected '', but found %r" + % self.peek_token().id, + self.peek_token().start_mark) + token = self.get_token() + end_mark = token.end_mark + event = DocumentStartEvent(start_mark, end_mark, + explicit=True, version=version, tags=tags) + self.states.append(self.parse_document_end) + self.state = self.parse_document_content + else: + # Parse the end of the stream. + token = self.get_token() + event = StreamEndEvent(token.start_mark, token.end_mark) + assert not self.states + assert not self.marks + self.state = None + return event + + def parse_document_end(self): + + # Parse the document end. + token = self.peek_token() + start_mark = end_mark = token.start_mark + explicit = False + if self.check_token(DocumentEndToken): + token = self.get_token() + end_mark = token.end_mark + explicit = True + event = DocumentEndEvent(start_mark, end_mark, + explicit=explicit) + + # Prepare the next state. + self.state = self.parse_document_start + + return event + + def parse_document_content(self): + if self.check_token(DirectiveToken, + DocumentStartToken, DocumentEndToken, StreamEndToken): + event = self.process_empty_scalar(self.peek_token().start_mark) + self.state = self.states.pop() + return event + else: + return self.parse_block_node() + + def process_directives(self): + self.yaml_version = None + self.tag_handles = {} + while self.check_token(DirectiveToken): + token = self.get_token() + if token.name == u'YAML': + if self.yaml_version is not None: + raise ParserError(None, None, + "found duplicate YAML directive", token.start_mark) + major, minor = token.value + if major != 1: + raise ParserError(None, None, + "found incompatible YAML document (version 1.* is required)", + token.start_mark) + self.yaml_version = token.value + elif token.name == u'TAG': + handle, prefix = token.value + if handle in self.tag_handles: + raise ParserError(None, None, + "duplicate tag handle %r" % handle.encode('utf-8'), + token.start_mark) + self.tag_handles[handle] = prefix + if self.tag_handles: + value = self.yaml_version, self.tag_handles.copy() + else: + value = self.yaml_version, None + for key in self.DEFAULT_TAGS: + if key not in self.tag_handles: + self.tag_handles[key] = self.DEFAULT_TAGS[key] + return value + + # block_node_or_indentless_sequence ::= ALIAS + # | properties (block_content | indentless_block_sequence)? + # | block_content + # | indentless_block_sequence + # block_node ::= ALIAS + # | properties block_content? + # | block_content + # flow_node ::= ALIAS + # | properties flow_content? + # | flow_content + # properties ::= TAG ANCHOR? | ANCHOR TAG? + # block_content ::= block_collection | flow_collection | SCALAR + # flow_content ::= flow_collection | SCALAR + # block_collection ::= block_sequence | block_mapping + # flow_collection ::= flow_sequence | flow_mapping + + def parse_block_node(self): + return self.parse_node(block=True) + + def parse_flow_node(self): + return self.parse_node() + + def parse_block_node_or_indentless_sequence(self): + return self.parse_node(block=True, indentless_sequence=True) + + def parse_node(self, block=False, indentless_sequence=False): + if self.check_token(AliasToken): + token = self.get_token() + event = AliasEvent(token.value, token.start_mark, token.end_mark) + self.state = self.states.pop() + else: + anchor = None + tag = None + start_mark = end_mark = tag_mark = None + if self.check_token(AnchorToken): + token = self.get_token() + start_mark = token.start_mark + end_mark = token.end_mark + anchor = token.value + if self.check_token(TagToken): + token = self.get_token() + tag_mark = token.start_mark + end_mark = token.end_mark + tag = token.value + elif self.check_token(TagToken): + token = self.get_token() + start_mark = tag_mark = token.start_mark + end_mark = token.end_mark + tag = token.value + if self.check_token(AnchorToken): + token = self.get_token() + end_mark = token.end_mark + anchor = token.value + if tag is not None: + handle, suffix = tag + if handle is not None: + if handle not in self.tag_handles: + raise ParserError("while parsing a node", start_mark, + "found undefined tag handle %r" % handle.encode('utf-8'), + tag_mark) + tag = self.tag_handles[handle]+suffix + else: + tag = suffix + #if tag == u'!': + # raise ParserError("while parsing a node", start_mark, + # "found non-specific tag '!'", tag_mark, + # "Please check 'http://pyyaml.org/wiki/YAMLNonSpecificTag' and share your opinion.") + if start_mark is None: + start_mark = end_mark = self.peek_token().start_mark + event = None + implicit = (tag is None or tag == u'!') + if indentless_sequence and self.check_token(BlockEntryToken): + end_mark = self.peek_token().end_mark + event = SequenceStartEvent(anchor, tag, implicit, + start_mark, end_mark) + self.state = self.parse_indentless_sequence_entry + else: + if self.check_token(ScalarToken): + token = self.get_token() + end_mark = token.end_mark + if (token.plain and tag is None) or tag == u'!': + implicit = (True, False) + elif tag is None: + implicit = (False, True) + else: + implicit = (False, False) + event = ScalarEvent(anchor, tag, implicit, token.value, + start_mark, end_mark, style=token.style) + self.state = self.states.pop() + elif self.check_token(FlowSequenceStartToken): + end_mark = self.peek_token().end_mark + event = SequenceStartEvent(anchor, tag, implicit, + start_mark, end_mark, flow_style=True) + self.state = self.parse_flow_sequence_first_entry + elif self.check_token(FlowMappingStartToken): + end_mark = self.peek_token().end_mark + event = MappingStartEvent(anchor, tag, implicit, + start_mark, end_mark, flow_style=True) + self.state = self.parse_flow_mapping_first_key + elif block and self.check_token(BlockSequenceStartToken): + end_mark = self.peek_token().start_mark + event = SequenceStartEvent(anchor, tag, implicit, + start_mark, end_mark, flow_style=False) + self.state = self.parse_block_sequence_first_entry + elif block and self.check_token(BlockMappingStartToken): + end_mark = self.peek_token().start_mark + event = MappingStartEvent(anchor, tag, implicit, + start_mark, end_mark, flow_style=False) + self.state = self.parse_block_mapping_first_key + elif anchor is not None or tag is not None: + # Empty scalars are allowed even if a tag or an anchor is + # specified. + event = ScalarEvent(anchor, tag, (implicit, False), u'', + start_mark, end_mark) + self.state = self.states.pop() + else: + if block: + node = 'block' + else: + node = 'flow' + token = self.peek_token() + raise ParserError("while parsing a %s node" % node, start_mark, + "expected the node content, but found %r" % token.id, + token.start_mark) + return event + + # block_sequence ::= BLOCK-SEQUENCE-START (BLOCK-ENTRY block_node?)* BLOCK-END + + def parse_block_sequence_first_entry(self): + token = self.get_token() + self.marks.append(token.start_mark) + return self.parse_block_sequence_entry() + + def parse_block_sequence_entry(self): + if self.check_token(BlockEntryToken): + token = self.get_token() + if not self.check_token(BlockEntryToken, BlockEndToken): + self.states.append(self.parse_block_sequence_entry) + return self.parse_block_node() + else: + self.state = self.parse_block_sequence_entry + return self.process_empty_scalar(token.end_mark) + if not self.check_token(BlockEndToken): + token = self.peek_token() + raise ParserError("while parsing a block collection", self.marks[-1], + "expected , but found %r" % token.id, token.start_mark) + token = self.get_token() + event = SequenceEndEvent(token.start_mark, token.end_mark) + self.state = self.states.pop() + self.marks.pop() + return event + + # indentless_sequence ::= (BLOCK-ENTRY block_node?)+ + + def parse_indentless_sequence_entry(self): + if self.check_token(BlockEntryToken): + token = self.get_token() + if not self.check_token(BlockEntryToken, + KeyToken, ValueToken, BlockEndToken): + self.states.append(self.parse_indentless_sequence_entry) + return self.parse_block_node() + else: + self.state = self.parse_indentless_sequence_entry + return self.process_empty_scalar(token.end_mark) + token = self.peek_token() + event = SequenceEndEvent(token.start_mark, token.start_mark) + self.state = self.states.pop() + return event + + # block_mapping ::= BLOCK-MAPPING_START + # ((KEY block_node_or_indentless_sequence?)? + # (VALUE block_node_or_indentless_sequence?)?)* + # BLOCK-END + + def parse_block_mapping_first_key(self): + token = self.get_token() + self.marks.append(token.start_mark) + return self.parse_block_mapping_key() + + def parse_block_mapping_key(self): + if self.check_token(KeyToken): + token = self.get_token() + if not self.check_token(KeyToken, ValueToken, BlockEndToken): + self.states.append(self.parse_block_mapping_value) + return self.parse_block_node_or_indentless_sequence() + else: + self.state = self.parse_block_mapping_value + return self.process_empty_scalar(token.end_mark) + if not self.check_token(BlockEndToken): + token = self.peek_token() + raise ParserError("while parsing a block mapping", self.marks[-1], + "expected , but found %r" % token.id, token.start_mark) + token = self.get_token() + event = MappingEndEvent(token.start_mark, token.end_mark) + self.state = self.states.pop() + self.marks.pop() + return event + + def parse_block_mapping_value(self): + if self.check_token(ValueToken): + token = self.get_token() + if not self.check_token(KeyToken, ValueToken, BlockEndToken): + self.states.append(self.parse_block_mapping_key) + return self.parse_block_node_or_indentless_sequence() + else: + self.state = self.parse_block_mapping_key + return self.process_empty_scalar(token.end_mark) + else: + self.state = self.parse_block_mapping_key + token = self.peek_token() + return self.process_empty_scalar(token.start_mark) + + # flow_sequence ::= FLOW-SEQUENCE-START + # (flow_sequence_entry FLOW-ENTRY)* + # flow_sequence_entry? + # FLOW-SEQUENCE-END + # flow_sequence_entry ::= flow_node | KEY flow_node? (VALUE flow_node?)? + # + # Note that while production rules for both flow_sequence_entry and + # flow_mapping_entry are equal, their interpretations are different. + # For `flow_sequence_entry`, the part `KEY flow_node? (VALUE flow_node?)?` + # generate an inline mapping (set syntax). + + def parse_flow_sequence_first_entry(self): + token = self.get_token() + self.marks.append(token.start_mark) + return self.parse_flow_sequence_entry(first=True) + + def parse_flow_sequence_entry(self, first=False): + if not self.check_token(FlowSequenceEndToken): + if not first: + if self.check_token(FlowEntryToken): + self.get_token() + else: + token = self.peek_token() + raise ParserError("while parsing a flow sequence", self.marks[-1], + "expected ',' or ']', but got %r" % token.id, token.start_mark) + + if self.check_token(KeyToken): + token = self.peek_token() + event = MappingStartEvent(None, None, True, + token.start_mark, token.end_mark, + flow_style=True) + self.state = self.parse_flow_sequence_entry_mapping_key + return event + elif not self.check_token(FlowSequenceEndToken): + self.states.append(self.parse_flow_sequence_entry) + return self.parse_flow_node() + token = self.get_token() + event = SequenceEndEvent(token.start_mark, token.end_mark) + self.state = self.states.pop() + self.marks.pop() + return event + + def parse_flow_sequence_entry_mapping_key(self): + token = self.get_token() + if not self.check_token(ValueToken, + FlowEntryToken, FlowSequenceEndToken): + self.states.append(self.parse_flow_sequence_entry_mapping_value) + return self.parse_flow_node() + else: + self.state = self.parse_flow_sequence_entry_mapping_value + return self.process_empty_scalar(token.end_mark) + + def parse_flow_sequence_entry_mapping_value(self): + if self.check_token(ValueToken): + token = self.get_token() + if not self.check_token(FlowEntryToken, FlowSequenceEndToken): + self.states.append(self.parse_flow_sequence_entry_mapping_end) + return self.parse_flow_node() + else: + self.state = self.parse_flow_sequence_entry_mapping_end + return self.process_empty_scalar(token.end_mark) + else: + self.state = self.parse_flow_sequence_entry_mapping_end + token = self.peek_token() + return self.process_empty_scalar(token.start_mark) + + def parse_flow_sequence_entry_mapping_end(self): + self.state = self.parse_flow_sequence_entry + token = self.peek_token() + return MappingEndEvent(token.start_mark, token.start_mark) + + # flow_mapping ::= FLOW-MAPPING-START + # (flow_mapping_entry FLOW-ENTRY)* + # flow_mapping_entry? + # FLOW-MAPPING-END + # flow_mapping_entry ::= flow_node | KEY flow_node? (VALUE flow_node?)? + + def parse_flow_mapping_first_key(self): + token = self.get_token() + self.marks.append(token.start_mark) + return self.parse_flow_mapping_key(first=True) + + def parse_flow_mapping_key(self, first=False): + if not self.check_token(FlowMappingEndToken): + if not first: + if self.check_token(FlowEntryToken): + self.get_token() + else: + token = self.peek_token() + raise ParserError("while parsing a flow mapping", self.marks[-1], + "expected ',' or '}', but got %r" % token.id, token.start_mark) + if self.check_token(KeyToken): + token = self.get_token() + if not self.check_token(ValueToken, + FlowEntryToken, FlowMappingEndToken): + self.states.append(self.parse_flow_mapping_value) + return self.parse_flow_node() + else: + self.state = self.parse_flow_mapping_value + return self.process_empty_scalar(token.end_mark) + elif not self.check_token(FlowMappingEndToken): + self.states.append(self.parse_flow_mapping_empty_value) + return self.parse_flow_node() + token = self.get_token() + event = MappingEndEvent(token.start_mark, token.end_mark) + self.state = self.states.pop() + self.marks.pop() + return event + + def parse_flow_mapping_value(self): + if self.check_token(ValueToken): + token = self.get_token() + if not self.check_token(FlowEntryToken, FlowMappingEndToken): + self.states.append(self.parse_flow_mapping_key) + return self.parse_flow_node() + else: + self.state = self.parse_flow_mapping_key + return self.process_empty_scalar(token.end_mark) + else: + self.state = self.parse_flow_mapping_key + token = self.peek_token() + return self.process_empty_scalar(token.start_mark) + + def parse_flow_mapping_empty_value(self): + self.state = self.parse_flow_mapping_key + return self.process_empty_scalar(self.peek_token().start_mark) + + def process_empty_scalar(self, mark): + return ScalarEvent(None, None, (True, False), u'', mark, mark) + diff --git a/scripts/clang-tidy/6.0.0/yaml/reader.py b/scripts/clang-tidy/6.0.0/yaml/reader.py new file mode 100644 index 000000000..3249e6b9f --- /dev/null +++ b/scripts/clang-tidy/6.0.0/yaml/reader.py @@ -0,0 +1,190 @@ +# This module contains abstractions for the input stream. You don't have to +# looks further, there are no pretty code. +# +# We define two classes here. +# +# Mark(source, line, column) +# It's just a record and its only use is producing nice error messages. +# Parser does not use it for any other purposes. +# +# Reader(source, data) +# Reader determines the encoding of `data` and converts it to unicode. +# Reader provides the following methods and attributes: +# reader.peek(length=1) - return the next `length` characters +# reader.forward(length=1) - move the current position to `length` characters. +# reader.index - the number of the current character. +# reader.line, stream.column - the line and the column of the current character. + +__all__ = ['Reader', 'ReaderError'] + +from error import YAMLError, Mark + +import codecs, re + +class ReaderError(YAMLError): + + def __init__(self, name, position, character, encoding, reason): + self.name = name + self.character = character + self.position = position + self.encoding = encoding + self.reason = reason + + def __str__(self): + if isinstance(self.character, str): + return "'%s' codec can't decode byte #x%02x: %s\n" \ + " in \"%s\", position %d" \ + % (self.encoding, ord(self.character), self.reason, + self.name, self.position) + else: + return "unacceptable character #x%04x: %s\n" \ + " in \"%s\", position %d" \ + % (self.character, self.reason, + self.name, self.position) + +class Reader(object): + # Reader: + # - determines the data encoding and converts it to unicode, + # - checks if characters are in allowed range, + # - adds '\0' to the end. + + # Reader accepts + # - a `str` object, + # - a `unicode` object, + # - a file-like object with its `read` method returning `str`, + # - a file-like object with its `read` method returning `unicode`. + + # Yeah, it's ugly and slow. + + def __init__(self, stream): + self.name = None + self.stream = None + self.stream_pointer = 0 + self.eof = True + self.buffer = u'' + self.pointer = 0 + self.raw_buffer = None + self.raw_decode = None + self.encoding = None + self.index = 0 + self.line = 0 + self.column = 0 + if isinstance(stream, unicode): + self.name = "" + self.check_printable(stream) + self.buffer = stream+u'\0' + elif isinstance(stream, str): + self.name = "" + self.raw_buffer = stream + self.determine_encoding() + else: + self.stream = stream + self.name = getattr(stream, 'name', "") + self.eof = False + self.raw_buffer = '' + self.determine_encoding() + + def peek(self, index=0): + try: + return self.buffer[self.pointer+index] + except IndexError: + self.update(index+1) + return self.buffer[self.pointer+index] + + def prefix(self, length=1): + if self.pointer+length >= len(self.buffer): + self.update(length) + return self.buffer[self.pointer:self.pointer+length] + + def forward(self, length=1): + if self.pointer+length+1 >= len(self.buffer): + self.update(length+1) + while length: + ch = self.buffer[self.pointer] + self.pointer += 1 + self.index += 1 + if ch in u'\n\x85\u2028\u2029' \ + or (ch == u'\r' and self.buffer[self.pointer] != u'\n'): + self.line += 1 + self.column = 0 + elif ch != u'\uFEFF': + self.column += 1 + length -= 1 + + def get_mark(self): + if self.stream is None: + return Mark(self.name, self.index, self.line, self.column, + self.buffer, self.pointer) + else: + return Mark(self.name, self.index, self.line, self.column, + None, None) + + def determine_encoding(self): + while not self.eof and len(self.raw_buffer) < 2: + self.update_raw() + if not isinstance(self.raw_buffer, unicode): + if self.raw_buffer.startswith(codecs.BOM_UTF16_LE): + self.raw_decode = codecs.utf_16_le_decode + self.encoding = 'utf-16-le' + elif self.raw_buffer.startswith(codecs.BOM_UTF16_BE): + self.raw_decode = codecs.utf_16_be_decode + self.encoding = 'utf-16-be' + else: + self.raw_decode = codecs.utf_8_decode + self.encoding = 'utf-8' + self.update(1) + + NON_PRINTABLE = re.compile(u'[^\x09\x0A\x0D\x20-\x7E\x85\xA0-\uD7FF\uE000-\uFFFD]') + def check_printable(self, data): + match = self.NON_PRINTABLE.search(data) + if match: + character = match.group() + position = self.index+(len(self.buffer)-self.pointer)+match.start() + raise ReaderError(self.name, position, ord(character), + 'unicode', "special characters are not allowed") + + def update(self, length): + if self.raw_buffer is None: + return + self.buffer = self.buffer[self.pointer:] + self.pointer = 0 + while len(self.buffer) < length: + if not self.eof: + self.update_raw() + if self.raw_decode is not None: + try: + data, converted = self.raw_decode(self.raw_buffer, + 'strict', self.eof) + except UnicodeDecodeError, exc: + character = exc.object[exc.start] + if self.stream is not None: + position = self.stream_pointer-len(self.raw_buffer)+exc.start + else: + position = exc.start + raise ReaderError(self.name, position, character, + exc.encoding, exc.reason) + else: + data = self.raw_buffer + converted = len(data) + self.check_printable(data) + self.buffer += data + self.raw_buffer = self.raw_buffer[converted:] + if self.eof: + self.buffer += u'\0' + self.raw_buffer = None + break + + def update_raw(self, size=1024): + data = self.stream.read(size) + if data: + self.raw_buffer += data + self.stream_pointer += len(data) + else: + self.eof = True + +#try: +# import psyco +# psyco.bind(Reader) +#except ImportError: +# pass + diff --git a/scripts/clang-tidy/6.0.0/yaml/representer.py b/scripts/clang-tidy/6.0.0/yaml/representer.py new file mode 100644 index 000000000..4ea8cb1fe --- /dev/null +++ b/scripts/clang-tidy/6.0.0/yaml/representer.py @@ -0,0 +1,486 @@ + +__all__ = ['BaseRepresenter', 'SafeRepresenter', 'Representer', + 'RepresenterError'] + +from error import * +from nodes import * + +import datetime + +import sys, copy_reg, types + +class RepresenterError(YAMLError): + pass + +class BaseRepresenter(object): + + yaml_representers = {} + yaml_multi_representers = {} + + def __init__(self, default_style=None, default_flow_style=None): + self.default_style = default_style + self.default_flow_style = default_flow_style + self.represented_objects = {} + self.object_keeper = [] + self.alias_key = None + + def represent(self, data): + node = self.represent_data(data) + self.serialize(node) + self.represented_objects = {} + self.object_keeper = [] + self.alias_key = None + + def get_classobj_bases(self, cls): + bases = [cls] + for base in cls.__bases__: + bases.extend(self.get_classobj_bases(base)) + return bases + + def represent_data(self, data): + if self.ignore_aliases(data): + self.alias_key = None + else: + self.alias_key = id(data) + if self.alias_key is not None: + if self.alias_key in self.represented_objects: + node = self.represented_objects[self.alias_key] + #if node is None: + # raise RepresenterError("recursive objects are not allowed: %r" % data) + return node + #self.represented_objects[alias_key] = None + self.object_keeper.append(data) + data_types = type(data).__mro__ + if type(data) is types.InstanceType: + data_types = self.get_classobj_bases(data.__class__)+list(data_types) + if data_types[0] in self.yaml_representers: + node = self.yaml_representers[data_types[0]](self, data) + else: + for data_type in data_types: + if data_type in self.yaml_multi_representers: + node = self.yaml_multi_representers[data_type](self, data) + break + else: + if None in self.yaml_multi_representers: + node = self.yaml_multi_representers[None](self, data) + elif None in self.yaml_representers: + node = self.yaml_representers[None](self, data) + else: + node = ScalarNode(None, unicode(data)) + #if alias_key is not None: + # self.represented_objects[alias_key] = node + return node + + def add_representer(cls, data_type, representer): + if not 'yaml_representers' in cls.__dict__: + cls.yaml_representers = cls.yaml_representers.copy() + cls.yaml_representers[data_type] = representer + add_representer = classmethod(add_representer) + + def add_multi_representer(cls, data_type, representer): + if not 'yaml_multi_representers' in cls.__dict__: + cls.yaml_multi_representers = cls.yaml_multi_representers.copy() + cls.yaml_multi_representers[data_type] = representer + add_multi_representer = classmethod(add_multi_representer) + + def represent_scalar(self, tag, value, style=None): + if style is None: + style = self.default_style + node = ScalarNode(tag, value, style=style) + if self.alias_key is not None: + self.represented_objects[self.alias_key] = node + return node + + def represent_sequence(self, tag, sequence, flow_style=None): + value = [] + node = SequenceNode(tag, value, flow_style=flow_style) + if self.alias_key is not None: + self.represented_objects[self.alias_key] = node + best_style = True + for item in sequence: + node_item = self.represent_data(item) + if not (isinstance(node_item, ScalarNode) and not node_item.style): + best_style = False + value.append(node_item) + if flow_style is None: + if self.default_flow_style is not None: + node.flow_style = self.default_flow_style + else: + node.flow_style = best_style + return node + + def represent_mapping(self, tag, mapping, flow_style=None): + value = [] + node = MappingNode(tag, value, flow_style=flow_style) + if self.alias_key is not None: + self.represented_objects[self.alias_key] = node + best_style = True + if hasattr(mapping, 'items'): + mapping = mapping.items() + mapping.sort() + for item_key, item_value in mapping: + node_key = self.represent_data(item_key) + node_value = self.represent_data(item_value) + if not (isinstance(node_key, ScalarNode) and not node_key.style): + best_style = False + if not (isinstance(node_value, ScalarNode) and not node_value.style): + best_style = False + value.append((node_key, node_value)) + if flow_style is None: + if self.default_flow_style is not None: + node.flow_style = self.default_flow_style + else: + node.flow_style = best_style + return node + + def ignore_aliases(self, data): + return False + +class SafeRepresenter(BaseRepresenter): + + def ignore_aliases(self, data): + if data is None: + return True + if isinstance(data, tuple) and data == (): + return True + if isinstance(data, (str, unicode, bool, int, float)): + return True + + def represent_none(self, data): + return self.represent_scalar(u'tag:yaml.org,2002:null', + u'null') + + def represent_str(self, data): + tag = None + style = None + try: + data = unicode(data, 'ascii') + tag = u'tag:yaml.org,2002:str' + except UnicodeDecodeError: + try: + data = unicode(data, 'utf-8') + tag = u'tag:yaml.org,2002:str' + except UnicodeDecodeError: + data = data.encode('base64') + tag = u'tag:yaml.org,2002:binary' + style = '|' + return self.represent_scalar(tag, data, style=style) + + def represent_unicode(self, data): + return self.represent_scalar(u'tag:yaml.org,2002:str', data) + + def represent_bool(self, data): + if data: + value = u'true' + else: + value = u'false' + return self.represent_scalar(u'tag:yaml.org,2002:bool', value) + + def represent_int(self, data): + return self.represent_scalar(u'tag:yaml.org,2002:int', unicode(data)) + + def represent_long(self, data): + return self.represent_scalar(u'tag:yaml.org,2002:int', unicode(data)) + + inf_value = 1e300 + while repr(inf_value) != repr(inf_value*inf_value): + inf_value *= inf_value + + def represent_float(self, data): + if data != data or (data == 0.0 and data == 1.0): + value = u'.nan' + elif data == self.inf_value: + value = u'.inf' + elif data == -self.inf_value: + value = u'-.inf' + else: + value = unicode(repr(data)).lower() + # Note that in some cases `repr(data)` represents a float number + # without the decimal parts. For instance: + # >>> repr(1e17) + # '1e17' + # Unfortunately, this is not a valid float representation according + # to the definition of the `!!float` tag. We fix this by adding + # '.0' before the 'e' symbol. + if u'.' not in value and u'e' in value: + value = value.replace(u'e', u'.0e', 1) + return self.represent_scalar(u'tag:yaml.org,2002:float', value) + + def represent_list(self, data): + #pairs = (len(data) > 0 and isinstance(data, list)) + #if pairs: + # for item in data: + # if not isinstance(item, tuple) or len(item) != 2: + # pairs = False + # break + #if not pairs: + return self.represent_sequence(u'tag:yaml.org,2002:seq', data) + #value = [] + #for item_key, item_value in data: + # value.append(self.represent_mapping(u'tag:yaml.org,2002:map', + # [(item_key, item_value)])) + #return SequenceNode(u'tag:yaml.org,2002:pairs', value) + + def represent_dict(self, data): + return self.represent_mapping(u'tag:yaml.org,2002:map', data) + + def represent_set(self, data): + value = {} + for key in data: + value[key] = None + return self.represent_mapping(u'tag:yaml.org,2002:set', value) + + def represent_date(self, data): + value = unicode(data.isoformat()) + return self.represent_scalar(u'tag:yaml.org,2002:timestamp', value) + + def represent_datetime(self, data): + value = unicode(data.isoformat(' ')) + return self.represent_scalar(u'tag:yaml.org,2002:timestamp', value) + + def represent_yaml_object(self, tag, data, cls, flow_style=None): + if hasattr(data, '__getstate__'): + state = data.__getstate__() + else: + state = data.__dict__.copy() + return self.represent_mapping(tag, state, flow_style=flow_style) + + def represent_undefined(self, data): + raise RepresenterError("cannot represent an object: %s" % data) + +SafeRepresenter.add_representer(type(None), + SafeRepresenter.represent_none) + +SafeRepresenter.add_representer(str, + SafeRepresenter.represent_str) + +SafeRepresenter.add_representer(unicode, + SafeRepresenter.represent_unicode) + +SafeRepresenter.add_representer(bool, + SafeRepresenter.represent_bool) + +SafeRepresenter.add_representer(int, + SafeRepresenter.represent_int) + +SafeRepresenter.add_representer(long, + SafeRepresenter.represent_long) + +SafeRepresenter.add_representer(float, + SafeRepresenter.represent_float) + +SafeRepresenter.add_representer(list, + SafeRepresenter.represent_list) + +SafeRepresenter.add_representer(tuple, + SafeRepresenter.represent_list) + +SafeRepresenter.add_representer(dict, + SafeRepresenter.represent_dict) + +SafeRepresenter.add_representer(set, + SafeRepresenter.represent_set) + +SafeRepresenter.add_representer(datetime.date, + SafeRepresenter.represent_date) + +SafeRepresenter.add_representer(datetime.datetime, + SafeRepresenter.represent_datetime) + +SafeRepresenter.add_representer(None, + SafeRepresenter.represent_undefined) + +class Representer(SafeRepresenter): + + def represent_str(self, data): + tag = None + style = None + try: + data = unicode(data, 'ascii') + tag = u'tag:yaml.org,2002:str' + except UnicodeDecodeError: + try: + data = unicode(data, 'utf-8') + tag = u'tag:yaml.org,2002:python/str' + except UnicodeDecodeError: + data = data.encode('base64') + tag = u'tag:yaml.org,2002:binary' + style = '|' + return self.represent_scalar(tag, data, style=style) + + def represent_unicode(self, data): + tag = None + try: + data.encode('ascii') + tag = u'tag:yaml.org,2002:python/unicode' + except UnicodeEncodeError: + tag = u'tag:yaml.org,2002:str' + return self.represent_scalar(tag, data) + + def represent_long(self, data): + tag = u'tag:yaml.org,2002:int' + if int(data) is not data: + tag = u'tag:yaml.org,2002:python/long' + return self.represent_scalar(tag, unicode(data)) + + def represent_complex(self, data): + if data.imag == 0.0: + data = u'%r' % data.real + elif data.real == 0.0: + data = u'%rj' % data.imag + elif data.imag > 0: + data = u'%r+%rj' % (data.real, data.imag) + else: + data = u'%r%rj' % (data.real, data.imag) + return self.represent_scalar(u'tag:yaml.org,2002:python/complex', data) + + def represent_tuple(self, data): + return self.represent_sequence(u'tag:yaml.org,2002:python/tuple', data) + + def represent_name(self, data): + name = u'%s.%s' % (data.__module__, data.__name__) + return self.represent_scalar(u'tag:yaml.org,2002:python/name:'+name, u'') + + def represent_module(self, data): + return self.represent_scalar( + u'tag:yaml.org,2002:python/module:'+data.__name__, u'') + + def represent_instance(self, data): + # For instances of classic classes, we use __getinitargs__ and + # __getstate__ to serialize the data. + + # If data.__getinitargs__ exists, the object must be reconstructed by + # calling cls(**args), where args is a tuple returned by + # __getinitargs__. Otherwise, the cls.__init__ method should never be + # called and the class instance is created by instantiating a trivial + # class and assigning to the instance's __class__ variable. + + # If data.__getstate__ exists, it returns the state of the object. + # Otherwise, the state of the object is data.__dict__. + + # We produce either a !!python/object or !!python/object/new node. + # If data.__getinitargs__ does not exist and state is a dictionary, we + # produce a !!python/object node . Otherwise we produce a + # !!python/object/new node. + + cls = data.__class__ + class_name = u'%s.%s' % (cls.__module__, cls.__name__) + args = None + state = None + if hasattr(data, '__getinitargs__'): + args = list(data.__getinitargs__()) + if hasattr(data, '__getstate__'): + state = data.__getstate__() + else: + state = data.__dict__ + if args is None and isinstance(state, dict): + return self.represent_mapping( + u'tag:yaml.org,2002:python/object:'+class_name, state) + if isinstance(state, dict) and not state: + return self.represent_sequence( + u'tag:yaml.org,2002:python/object/new:'+class_name, args) + value = {} + if args: + value['args'] = args + value['state'] = state + return self.represent_mapping( + u'tag:yaml.org,2002:python/object/new:'+class_name, value) + + def represent_object(self, data): + # We use __reduce__ API to save the data. data.__reduce__ returns + # a tuple of length 2-5: + # (function, args, state, listitems, dictitems) + + # For reconstructing, we calls function(*args), then set its state, + # listitems, and dictitems if they are not None. + + # A special case is when function.__name__ == '__newobj__'. In this + # case we create the object with args[0].__new__(*args). + + # Another special case is when __reduce__ returns a string - we don't + # support it. + + # We produce a !!python/object, !!python/object/new or + # !!python/object/apply node. + + cls = type(data) + if cls in copy_reg.dispatch_table: + reduce = copy_reg.dispatch_table[cls](data) + elif hasattr(data, '__reduce_ex__'): + reduce = data.__reduce_ex__(2) + elif hasattr(data, '__reduce__'): + reduce = data.__reduce__() + else: + raise RepresenterError("cannot represent object: %r" % data) + reduce = (list(reduce)+[None]*5)[:5] + function, args, state, listitems, dictitems = reduce + args = list(args) + if state is None: + state = {} + if listitems is not None: + listitems = list(listitems) + if dictitems is not None: + dictitems = dict(dictitems) + if function.__name__ == '__newobj__': + function = args[0] + args = args[1:] + tag = u'tag:yaml.org,2002:python/object/new:' + newobj = True + else: + tag = u'tag:yaml.org,2002:python/object/apply:' + newobj = False + function_name = u'%s.%s' % (function.__module__, function.__name__) + if not args and not listitems and not dictitems \ + and isinstance(state, dict) and newobj: + return self.represent_mapping( + u'tag:yaml.org,2002:python/object:'+function_name, state) + if not listitems and not dictitems \ + and isinstance(state, dict) and not state: + return self.represent_sequence(tag+function_name, args) + value = {} + if args: + value['args'] = args + if state or not isinstance(state, dict): + value['state'] = state + if listitems: + value['listitems'] = listitems + if dictitems: + value['dictitems'] = dictitems + return self.represent_mapping(tag+function_name, value) + +Representer.add_representer(str, + Representer.represent_str) + +Representer.add_representer(unicode, + Representer.represent_unicode) + +Representer.add_representer(long, + Representer.represent_long) + +Representer.add_representer(complex, + Representer.represent_complex) + +Representer.add_representer(tuple, + Representer.represent_tuple) + +Representer.add_representer(type, + Representer.represent_name) + +Representer.add_representer(types.ClassType, + Representer.represent_name) + +Representer.add_representer(types.FunctionType, + Representer.represent_name) + +Representer.add_representer(types.BuiltinFunctionType, + Representer.represent_name) + +Representer.add_representer(types.ModuleType, + Representer.represent_module) + +Representer.add_multi_representer(types.InstanceType, + Representer.represent_instance) + +Representer.add_multi_representer(object, + Representer.represent_object) + diff --git a/scripts/clang-tidy/6.0.0/yaml/resolver.py b/scripts/clang-tidy/6.0.0/yaml/resolver.py new file mode 100644 index 000000000..528fbc0ea --- /dev/null +++ b/scripts/clang-tidy/6.0.0/yaml/resolver.py @@ -0,0 +1,227 @@ + +__all__ = ['BaseResolver', 'Resolver'] + +from error import * +from nodes import * + +import re + +class ResolverError(YAMLError): + pass + +class BaseResolver(object): + + DEFAULT_SCALAR_TAG = u'tag:yaml.org,2002:str' + DEFAULT_SEQUENCE_TAG = u'tag:yaml.org,2002:seq' + DEFAULT_MAPPING_TAG = u'tag:yaml.org,2002:map' + + yaml_implicit_resolvers = {} + yaml_path_resolvers = {} + + def __init__(self): + self.resolver_exact_paths = [] + self.resolver_prefix_paths = [] + + def add_implicit_resolver(cls, tag, regexp, first): + if not 'yaml_implicit_resolvers' in cls.__dict__: + implicit_resolvers = {} + for key in cls.yaml_implicit_resolvers: + implicit_resolvers[key] = cls.yaml_implicit_resolvers[key][:] + cls.yaml_implicit_resolvers = implicit_resolvers + if first is None: + first = [None] + for ch in first: + cls.yaml_implicit_resolvers.setdefault(ch, []).append((tag, regexp)) + add_implicit_resolver = classmethod(add_implicit_resolver) + + def add_path_resolver(cls, tag, path, kind=None): + # Note: `add_path_resolver` is experimental. The API could be changed. + # `new_path` is a pattern that is matched against the path from the + # root to the node that is being considered. `node_path` elements are + # tuples `(node_check, index_check)`. `node_check` is a node class: + # `ScalarNode`, `SequenceNode`, `MappingNode` or `None`. `None` + # matches any kind of a node. `index_check` could be `None`, a boolean + # value, a string value, or a number. `None` and `False` match against + # any _value_ of sequence and mapping nodes. `True` matches against + # any _key_ of a mapping node. A string `index_check` matches against + # a mapping value that corresponds to a scalar key which content is + # equal to the `index_check` value. An integer `index_check` matches + # against a sequence value with the index equal to `index_check`. + if not 'yaml_path_resolvers' in cls.__dict__: + cls.yaml_path_resolvers = cls.yaml_path_resolvers.copy() + new_path = [] + for element in path: + if isinstance(element, (list, tuple)): + if len(element) == 2: + node_check, index_check = element + elif len(element) == 1: + node_check = element[0] + index_check = True + else: + raise ResolverError("Invalid path element: %s" % element) + else: + node_check = None + index_check = element + if node_check is str: + node_check = ScalarNode + elif node_check is list: + node_check = SequenceNode + elif node_check is dict: + node_check = MappingNode + elif node_check not in [ScalarNode, SequenceNode, MappingNode] \ + and not isinstance(node_check, basestring) \ + and node_check is not None: + raise ResolverError("Invalid node checker: %s" % node_check) + if not isinstance(index_check, (basestring, int)) \ + and index_check is not None: + raise ResolverError("Invalid index checker: %s" % index_check) + new_path.append((node_check, index_check)) + if kind is str: + kind = ScalarNode + elif kind is list: + kind = SequenceNode + elif kind is dict: + kind = MappingNode + elif kind not in [ScalarNode, SequenceNode, MappingNode] \ + and kind is not None: + raise ResolverError("Invalid node kind: %s" % kind) + cls.yaml_path_resolvers[tuple(new_path), kind] = tag + add_path_resolver = classmethod(add_path_resolver) + + def descend_resolver(self, current_node, current_index): + if not self.yaml_path_resolvers: + return + exact_paths = {} + prefix_paths = [] + if current_node: + depth = len(self.resolver_prefix_paths) + for path, kind in self.resolver_prefix_paths[-1]: + if self.check_resolver_prefix(depth, path, kind, + current_node, current_index): + if len(path) > depth: + prefix_paths.append((path, kind)) + else: + exact_paths[kind] = self.yaml_path_resolvers[path, kind] + else: + for path, kind in self.yaml_path_resolvers: + if not path: + exact_paths[kind] = self.yaml_path_resolvers[path, kind] + else: + prefix_paths.append((path, kind)) + self.resolver_exact_paths.append(exact_paths) + self.resolver_prefix_paths.append(prefix_paths) + + def ascend_resolver(self): + if not self.yaml_path_resolvers: + return + self.resolver_exact_paths.pop() + self.resolver_prefix_paths.pop() + + def check_resolver_prefix(self, depth, path, kind, + current_node, current_index): + node_check, index_check = path[depth-1] + if isinstance(node_check, basestring): + if current_node.tag != node_check: + return + elif node_check is not None: + if not isinstance(current_node, node_check): + return + if index_check is True and current_index is not None: + return + if (index_check is False or index_check is None) \ + and current_index is None: + return + if isinstance(index_check, basestring): + if not (isinstance(current_index, ScalarNode) + and index_check == current_index.value): + return + elif isinstance(index_check, int) and not isinstance(index_check, bool): + if index_check != current_index: + return + return True + + def resolve(self, kind, value, implicit): + if kind is ScalarNode and implicit[0]: + if value == u'': + resolvers = self.yaml_implicit_resolvers.get(u'', []) + else: + resolvers = self.yaml_implicit_resolvers.get(value[0], []) + resolvers += self.yaml_implicit_resolvers.get(None, []) + for tag, regexp in resolvers: + if regexp.match(value): + return tag + implicit = implicit[1] + if self.yaml_path_resolvers: + exact_paths = self.resolver_exact_paths[-1] + if kind in exact_paths: + return exact_paths[kind] + if None in exact_paths: + return exact_paths[None] + if kind is ScalarNode: + return self.DEFAULT_SCALAR_TAG + elif kind is SequenceNode: + return self.DEFAULT_SEQUENCE_TAG + elif kind is MappingNode: + return self.DEFAULT_MAPPING_TAG + +class Resolver(BaseResolver): + pass + +Resolver.add_implicit_resolver( + u'tag:yaml.org,2002:bool', + re.compile(ur'''^(?:yes|Yes|YES|no|No|NO + |true|True|TRUE|false|False|FALSE + |on|On|ON|off|Off|OFF)$''', re.X), + list(u'yYnNtTfFoO')) + +Resolver.add_implicit_resolver( + u'tag:yaml.org,2002:float', + re.compile(ur'''^(?:[-+]?(?:[0-9][0-9_]*)\.[0-9_]*(?:[eE][-+][0-9]+)? + |\.[0-9_]+(?:[eE][-+][0-9]+)? + |[-+]?[0-9][0-9_]*(?::[0-5]?[0-9])+\.[0-9_]* + |[-+]?\.(?:inf|Inf|INF) + |\.(?:nan|NaN|NAN))$''', re.X), + list(u'-+0123456789.')) + +Resolver.add_implicit_resolver( + u'tag:yaml.org,2002:int', + re.compile(ur'''^(?:[-+]?0b[0-1_]+ + |[-+]?0[0-7_]+ + |[-+]?(?:0|[1-9][0-9_]*) + |[-+]?0x[0-9a-fA-F_]+ + |[-+]?[1-9][0-9_]*(?::[0-5]?[0-9])+)$''', re.X), + list(u'-+0123456789')) + +Resolver.add_implicit_resolver( + u'tag:yaml.org,2002:merge', + re.compile(ur'^(?:<<)$'), + [u'<']) + +Resolver.add_implicit_resolver( + u'tag:yaml.org,2002:null', + re.compile(ur'''^(?: ~ + |null|Null|NULL + | )$''', re.X), + [u'~', u'n', u'N', u'']) + +Resolver.add_implicit_resolver( + u'tag:yaml.org,2002:timestamp', + re.compile(ur'''^(?:[0-9][0-9][0-9][0-9]-[0-9][0-9]-[0-9][0-9] + |[0-9][0-9][0-9][0-9] -[0-9][0-9]? -[0-9][0-9]? + (?:[Tt]|[ \t]+)[0-9][0-9]? + :[0-9][0-9] :[0-9][0-9] (?:\.[0-9]*)? + (?:[ \t]*(?:Z|[-+][0-9][0-9]?(?::[0-9][0-9])?))?)$''', re.X), + list(u'0123456789')) + +Resolver.add_implicit_resolver( + u'tag:yaml.org,2002:value', + re.compile(ur'^(?:=)$'), + [u'=']) + +# The following resolver is only for documentation purposes. It cannot work +# because plain scalars cannot start with '!', '&', or '*'. +Resolver.add_implicit_resolver( + u'tag:yaml.org,2002:yaml', + re.compile(ur'^(?:!|&|\*)$'), + list(u'!&*')) + diff --git a/scripts/clang-tidy/6.0.0/yaml/scanner.py b/scripts/clang-tidy/6.0.0/yaml/scanner.py new file mode 100644 index 000000000..834f662a4 --- /dev/null +++ b/scripts/clang-tidy/6.0.0/yaml/scanner.py @@ -0,0 +1,1453 @@ + +# Scanner produces tokens of the following types: +# STREAM-START +# STREAM-END +# DIRECTIVE(name, value) +# DOCUMENT-START +# DOCUMENT-END +# BLOCK-SEQUENCE-START +# BLOCK-MAPPING-START +# BLOCK-END +# FLOW-SEQUENCE-START +# FLOW-MAPPING-START +# FLOW-SEQUENCE-END +# FLOW-MAPPING-END +# BLOCK-ENTRY +# FLOW-ENTRY +# KEY +# VALUE +# ALIAS(value) +# ANCHOR(value) +# TAG(value) +# SCALAR(value, plain, style) +# +# Read comments in the Scanner code for more details. +# + +__all__ = ['Scanner', 'ScannerError'] + +from error import MarkedYAMLError +from tokens import * + +class ScannerError(MarkedYAMLError): + pass + +class SimpleKey(object): + # See below simple keys treatment. + + def __init__(self, token_number, required, index, line, column, mark): + self.token_number = token_number + self.required = required + self.index = index + self.line = line + self.column = column + self.mark = mark + +class Scanner(object): + + def __init__(self): + """Initialize the scanner.""" + # It is assumed that Scanner and Reader will have a common descendant. + # Reader do the dirty work of checking for BOM and converting the + # input data to Unicode. It also adds NUL to the end. + # + # Reader supports the following methods + # self.peek(i=0) # peek the next i-th character + # self.prefix(l=1) # peek the next l characters + # self.forward(l=1) # read the next l characters and move the pointer. + + # Had we reached the end of the stream? + self.done = False + + # The number of unclosed '{' and '['. `flow_level == 0` means block + # context. + self.flow_level = 0 + + # List of processed tokens that are not yet emitted. + self.tokens = [] + + # Add the STREAM-START token. + self.fetch_stream_start() + + # Number of tokens that were emitted through the `get_token` method. + self.tokens_taken = 0 + + # The current indentation level. + self.indent = -1 + + # Past indentation levels. + self.indents = [] + + # Variables related to simple keys treatment. + + # A simple key is a key that is not denoted by the '?' indicator. + # Example of simple keys: + # --- + # block simple key: value + # ? not a simple key: + # : { flow simple key: value } + # We emit the KEY token before all keys, so when we find a potential + # simple key, we try to locate the corresponding ':' indicator. + # Simple keys should be limited to a single line and 1024 characters. + + # Can a simple key start at the current position? A simple key may + # start: + # - at the beginning of the line, not counting indentation spaces + # (in block context), + # - after '{', '[', ',' (in the flow context), + # - after '?', ':', '-' (in the block context). + # In the block context, this flag also signifies if a block collection + # may start at the current position. + self.allow_simple_key = True + + # Keep track of possible simple keys. This is a dictionary. The key + # is `flow_level`; there can be no more that one possible simple key + # for each level. The value is a SimpleKey record: + # (token_number, required, index, line, column, mark) + # A simple key may start with ALIAS, ANCHOR, TAG, SCALAR(flow), + # '[', or '{' tokens. + self.possible_simple_keys = {} + + # Public methods. + + def check_token(self, *choices): + # Check if the next token is one of the given types. + while self.need_more_tokens(): + self.fetch_more_tokens() + if self.tokens: + if not choices: + return True + for choice in choices: + if isinstance(self.tokens[0], choice): + return True + return False + + def peek_token(self): + # Return the next token, but do not delete if from the queue. + while self.need_more_tokens(): + self.fetch_more_tokens() + if self.tokens: + return self.tokens[0] + + def get_token(self): + # Return the next token. + while self.need_more_tokens(): + self.fetch_more_tokens() + if self.tokens: + self.tokens_taken += 1 + return self.tokens.pop(0) + + # Private methods. + + def need_more_tokens(self): + if self.done: + return False + if not self.tokens: + return True + # The current token may be a potential simple key, so we + # need to look further. + self.stale_possible_simple_keys() + if self.next_possible_simple_key() == self.tokens_taken: + return True + + def fetch_more_tokens(self): + + # Eat whitespaces and comments until we reach the next token. + self.scan_to_next_token() + + # Remove obsolete possible simple keys. + self.stale_possible_simple_keys() + + # Compare the current indentation and column. It may add some tokens + # and decrease the current indentation level. + self.unwind_indent(self.column) + + # Peek the next character. + ch = self.peek() + + # Is it the end of stream? + if ch == u'\0': + return self.fetch_stream_end() + + # Is it a directive? + if ch == u'%' and self.check_directive(): + return self.fetch_directive() + + # Is it the document start? + if ch == u'-' and self.check_document_start(): + return self.fetch_document_start() + + # Is it the document end? + if ch == u'.' and self.check_document_end(): + return self.fetch_document_end() + + # TODO: support for BOM within a stream. + #if ch == u'\uFEFF': + # return self.fetch_bom() <-- issue BOMToken + + # Note: the order of the following checks is NOT significant. + + # Is it the flow sequence start indicator? + if ch == u'[': + return self.fetch_flow_sequence_start() + + # Is it the flow mapping start indicator? + if ch == u'{': + return self.fetch_flow_mapping_start() + + # Is it the flow sequence end indicator? + if ch == u']': + return self.fetch_flow_sequence_end() + + # Is it the flow mapping end indicator? + if ch == u'}': + return self.fetch_flow_mapping_end() + + # Is it the flow entry indicator? + if ch == u',': + return self.fetch_flow_entry() + + # Is it the block entry indicator? + if ch == u'-' and self.check_block_entry(): + return self.fetch_block_entry() + + # Is it the key indicator? + if ch == u'?' and self.check_key(): + return self.fetch_key() + + # Is it the value indicator? + if ch == u':' and self.check_value(): + return self.fetch_value() + + # Is it an alias? + if ch == u'*': + return self.fetch_alias() + + # Is it an anchor? + if ch == u'&': + return self.fetch_anchor() + + # Is it a tag? + if ch == u'!': + return self.fetch_tag() + + # Is it a literal scalar? + if ch == u'|' and not self.flow_level: + return self.fetch_literal() + + # Is it a folded scalar? + if ch == u'>' and not self.flow_level: + return self.fetch_folded() + + # Is it a single quoted scalar? + if ch == u'\'': + return self.fetch_single() + + # Is it a double quoted scalar? + if ch == u'\"': + return self.fetch_double() + + # It must be a plain scalar then. + if self.check_plain(): + return self.fetch_plain() + + # No? It's an error. Let's produce a nice error message. + raise ScannerError("while scanning for the next token", None, + "found character %r that cannot start any token" + % ch.encode('utf-8'), self.get_mark()) + + # Simple keys treatment. + + def next_possible_simple_key(self): + # Return the number of the nearest possible simple key. Actually we + # don't need to loop through the whole dictionary. We may replace it + # with the following code: + # if not self.possible_simple_keys: + # return None + # return self.possible_simple_keys[ + # min(self.possible_simple_keys.keys())].token_number + min_token_number = None + for level in self.possible_simple_keys: + key = self.possible_simple_keys[level] + if min_token_number is None or key.token_number < min_token_number: + min_token_number = key.token_number + return min_token_number + + def stale_possible_simple_keys(self): + # Remove entries that are no longer possible simple keys. According to + # the YAML specification, simple keys + # - should be limited to a single line, + # - should be no longer than 1024 characters. + # Disabling this procedure will allow simple keys of any length and + # height (may cause problems if indentation is broken though). + for level in self.possible_simple_keys.keys(): + key = self.possible_simple_keys[level] + if key.line != self.line \ + or self.index-key.index > 1024: + if key.required: + raise ScannerError("while scanning a simple key", key.mark, + "could not find expected ':'", self.get_mark()) + del self.possible_simple_keys[level] + + def save_possible_simple_key(self): + # The next token may start a simple key. We check if it's possible + # and save its position. This function is called for + # ALIAS, ANCHOR, TAG, SCALAR(flow), '[', and '{'. + + # Check if a simple key is required at the current position. + required = not self.flow_level and self.indent == self.column + + # The next token might be a simple key. Let's save it's number and + # position. + if self.allow_simple_key: + self.remove_possible_simple_key() + token_number = self.tokens_taken+len(self.tokens) + key = SimpleKey(token_number, required, + self.index, self.line, self.column, self.get_mark()) + self.possible_simple_keys[self.flow_level] = key + + def remove_possible_simple_key(self): + # Remove the saved possible key position at the current flow level. + if self.flow_level in self.possible_simple_keys: + key = self.possible_simple_keys[self.flow_level] + + if key.required: + raise ScannerError("while scanning a simple key", key.mark, + "could not find expected ':'", self.get_mark()) + + del self.possible_simple_keys[self.flow_level] + + # Indentation functions. + + def unwind_indent(self, column): + + ## In flow context, tokens should respect indentation. + ## Actually the condition should be `self.indent >= column` according to + ## the spec. But this condition will prohibit intuitively correct + ## constructions such as + ## key : { + ## } + #if self.flow_level and self.indent > column: + # raise ScannerError(None, None, + # "invalid intendation or unclosed '[' or '{'", + # self.get_mark()) + + # In the flow context, indentation is ignored. We make the scanner less + # restrictive then specification requires. + if self.flow_level: + return + + # In block context, we may need to issue the BLOCK-END tokens. + while self.indent > column: + mark = self.get_mark() + self.indent = self.indents.pop() + self.tokens.append(BlockEndToken(mark, mark)) + + def add_indent(self, column): + # Check if we need to increase indentation. + if self.indent < column: + self.indents.append(self.indent) + self.indent = column + return True + return False + + # Fetchers. + + def fetch_stream_start(self): + # We always add STREAM-START as the first token and STREAM-END as the + # last token. + + # Read the token. + mark = self.get_mark() + + # Add STREAM-START. + self.tokens.append(StreamStartToken(mark, mark, + encoding=self.encoding)) + + + def fetch_stream_end(self): + + # Set the current intendation to -1. + self.unwind_indent(-1) + + # Reset simple keys. + self.remove_possible_simple_key() + self.allow_simple_key = False + self.possible_simple_keys = {} + + # Read the token. + mark = self.get_mark() + + # Add STREAM-END. + self.tokens.append(StreamEndToken(mark, mark)) + + # The steam is finished. + self.done = True + + def fetch_directive(self): + + # Set the current intendation to -1. + self.unwind_indent(-1) + + # Reset simple keys. + self.remove_possible_simple_key() + self.allow_simple_key = False + + # Scan and add DIRECTIVE. + self.tokens.append(self.scan_directive()) + + def fetch_document_start(self): + self.fetch_document_indicator(DocumentStartToken) + + def fetch_document_end(self): + self.fetch_document_indicator(DocumentEndToken) + + def fetch_document_indicator(self, TokenClass): + + # Set the current intendation to -1. + self.unwind_indent(-1) + + # Reset simple keys. Note that there could not be a block collection + # after '---'. + self.remove_possible_simple_key() + self.allow_simple_key = False + + # Add DOCUMENT-START or DOCUMENT-END. + start_mark = self.get_mark() + self.forward(3) + end_mark = self.get_mark() + self.tokens.append(TokenClass(start_mark, end_mark)) + + def fetch_flow_sequence_start(self): + self.fetch_flow_collection_start(FlowSequenceStartToken) + + def fetch_flow_mapping_start(self): + self.fetch_flow_collection_start(FlowMappingStartToken) + + def fetch_flow_collection_start(self, TokenClass): + + # '[' and '{' may start a simple key. + self.save_possible_simple_key() + + # Increase the flow level. + self.flow_level += 1 + + # Simple keys are allowed after '[' and '{'. + self.allow_simple_key = True + + # Add FLOW-SEQUENCE-START or FLOW-MAPPING-START. + start_mark = self.get_mark() + self.forward() + end_mark = self.get_mark() + self.tokens.append(TokenClass(start_mark, end_mark)) + + def fetch_flow_sequence_end(self): + self.fetch_flow_collection_end(FlowSequenceEndToken) + + def fetch_flow_mapping_end(self): + self.fetch_flow_collection_end(FlowMappingEndToken) + + def fetch_flow_collection_end(self, TokenClass): + + # Reset possible simple key on the current level. + self.remove_possible_simple_key() + + # Decrease the flow level. + self.flow_level -= 1 + + # No simple keys after ']' or '}'. + self.allow_simple_key = False + + # Add FLOW-SEQUENCE-END or FLOW-MAPPING-END. + start_mark = self.get_mark() + self.forward() + end_mark = self.get_mark() + self.tokens.append(TokenClass(start_mark, end_mark)) + + def fetch_flow_entry(self): + + # Simple keys are allowed after ','. + self.allow_simple_key = True + + # Reset possible simple key on the current level. + self.remove_possible_simple_key() + + # Add FLOW-ENTRY. + start_mark = self.get_mark() + self.forward() + end_mark = self.get_mark() + self.tokens.append(FlowEntryToken(start_mark, end_mark)) + + def fetch_block_entry(self): + + # Block context needs additional checks. + if not self.flow_level: + + # Are we allowed to start a new entry? + if not self.allow_simple_key: + raise ScannerError(None, None, + "sequence entries are not allowed here", + self.get_mark()) + + # We may need to add BLOCK-SEQUENCE-START. + if self.add_indent(self.column): + mark = self.get_mark() + self.tokens.append(BlockSequenceStartToken(mark, mark)) + + # It's an error for the block entry to occur in the flow context, + # but we let the parser detect this. + else: + pass + + # Simple keys are allowed after '-'. + self.allow_simple_key = True + + # Reset possible simple key on the current level. + self.remove_possible_simple_key() + + # Add BLOCK-ENTRY. + start_mark = self.get_mark() + self.forward() + end_mark = self.get_mark() + self.tokens.append(BlockEntryToken(start_mark, end_mark)) + + def fetch_key(self): + + # Block context needs additional checks. + if not self.flow_level: + + # Are we allowed to start a key (not nessesary a simple)? + if not self.allow_simple_key: + raise ScannerError(None, None, + "mapping keys are not allowed here", + self.get_mark()) + + # We may need to add BLOCK-MAPPING-START. + if self.add_indent(self.column): + mark = self.get_mark() + self.tokens.append(BlockMappingStartToken(mark, mark)) + + # Simple keys are allowed after '?' in the block context. + self.allow_simple_key = not self.flow_level + + # Reset possible simple key on the current level. + self.remove_possible_simple_key() + + # Add KEY. + start_mark = self.get_mark() + self.forward() + end_mark = self.get_mark() + self.tokens.append(KeyToken(start_mark, end_mark)) + + def fetch_value(self): + + # Do we determine a simple key? + if self.flow_level in self.possible_simple_keys: + + # Add KEY. + key = self.possible_simple_keys[self.flow_level] + del self.possible_simple_keys[self.flow_level] + self.tokens.insert(key.token_number-self.tokens_taken, + KeyToken(key.mark, key.mark)) + + # If this key starts a new block mapping, we need to add + # BLOCK-MAPPING-START. + if not self.flow_level: + if self.add_indent(key.column): + self.tokens.insert(key.token_number-self.tokens_taken, + BlockMappingStartToken(key.mark, key.mark)) + + # There cannot be two simple keys one after another. + self.allow_simple_key = False + + # It must be a part of a complex key. + else: + + # Block context needs additional checks. + # (Do we really need them? They will be catched by the parser + # anyway.) + if not self.flow_level: + + # We are allowed to start a complex value if and only if + # we can start a simple key. + if not self.allow_simple_key: + raise ScannerError(None, None, + "mapping values are not allowed here", + self.get_mark()) + + # If this value starts a new block mapping, we need to add + # BLOCK-MAPPING-START. It will be detected as an error later by + # the parser. + if not self.flow_level: + if self.add_indent(self.column): + mark = self.get_mark() + self.tokens.append(BlockMappingStartToken(mark, mark)) + + # Simple keys are allowed after ':' in the block context. + self.allow_simple_key = not self.flow_level + + # Reset possible simple key on the current level. + self.remove_possible_simple_key() + + # Add VALUE. + start_mark = self.get_mark() + self.forward() + end_mark = self.get_mark() + self.tokens.append(ValueToken(start_mark, end_mark)) + + def fetch_alias(self): + + # ALIAS could be a simple key. + self.save_possible_simple_key() + + # No simple keys after ALIAS. + self.allow_simple_key = False + + # Scan and add ALIAS. + self.tokens.append(self.scan_anchor(AliasToken)) + + def fetch_anchor(self): + + # ANCHOR could start a simple key. + self.save_possible_simple_key() + + # No simple keys after ANCHOR. + self.allow_simple_key = False + + # Scan and add ANCHOR. + self.tokens.append(self.scan_anchor(AnchorToken)) + + def fetch_tag(self): + + # TAG could start a simple key. + self.save_possible_simple_key() + + # No simple keys after TAG. + self.allow_simple_key = False + + # Scan and add TAG. + self.tokens.append(self.scan_tag()) + + def fetch_literal(self): + self.fetch_block_scalar(style='|') + + def fetch_folded(self): + self.fetch_block_scalar(style='>') + + def fetch_block_scalar(self, style): + + # A simple key may follow a block scalar. + self.allow_simple_key = True + + # Reset possible simple key on the current level. + self.remove_possible_simple_key() + + # Scan and add SCALAR. + self.tokens.append(self.scan_block_scalar(style)) + + def fetch_single(self): + self.fetch_flow_scalar(style='\'') + + def fetch_double(self): + self.fetch_flow_scalar(style='"') + + def fetch_flow_scalar(self, style): + + # A flow scalar could be a simple key. + self.save_possible_simple_key() + + # No simple keys after flow scalars. + self.allow_simple_key = False + + # Scan and add SCALAR. + self.tokens.append(self.scan_flow_scalar(style)) + + def fetch_plain(self): + + # A plain scalar could be a simple key. + self.save_possible_simple_key() + + # No simple keys after plain scalars. But note that `scan_plain` will + # change this flag if the scan is finished at the beginning of the + # line. + self.allow_simple_key = False + + # Scan and add SCALAR. May change `allow_simple_key`. + self.tokens.append(self.scan_plain()) + + # Checkers. + + def check_directive(self): + + # DIRECTIVE: ^ '%' ... + # The '%' indicator is already checked. + if self.column == 0: + return True + + def check_document_start(self): + + # DOCUMENT-START: ^ '---' (' '|'\n') + if self.column == 0: + if self.prefix(3) == u'---' \ + and self.peek(3) in u'\0 \t\r\n\x85\u2028\u2029': + return True + + def check_document_end(self): + + # DOCUMENT-END: ^ '...' (' '|'\n') + if self.column == 0: + if self.prefix(3) == u'...' \ + and self.peek(3) in u'\0 \t\r\n\x85\u2028\u2029': + return True + + def check_block_entry(self): + + # BLOCK-ENTRY: '-' (' '|'\n') + return self.peek(1) in u'\0 \t\r\n\x85\u2028\u2029' + + def check_key(self): + + # KEY(flow context): '?' + if self.flow_level: + return True + + # KEY(block context): '?' (' '|'\n') + else: + return self.peek(1) in u'\0 \t\r\n\x85\u2028\u2029' + + def check_value(self): + + # VALUE(flow context): ':' + if self.flow_level: + return True + + # VALUE(block context): ':' (' '|'\n') + else: + return self.peek(1) in u'\0 \t\r\n\x85\u2028\u2029' + + def check_plain(self): + + # A plain scalar may start with any non-space character except: + # '-', '?', ':', ',', '[', ']', '{', '}', + # '#', '&', '*', '!', '|', '>', '\'', '\"', + # '%', '@', '`'. + # + # It may also start with + # '-', '?', ':' + # if it is followed by a non-space character. + # + # Note that we limit the last rule to the block context (except the + # '-' character) because we want the flow context to be space + # independent. + ch = self.peek() + return ch not in u'\0 \t\r\n\x85\u2028\u2029-?:,[]{}#&*!|>\'\"%@`' \ + or (self.peek(1) not in u'\0 \t\r\n\x85\u2028\u2029' + and (ch == u'-' or (not self.flow_level and ch in u'?:'))) + + # Scanners. + + def scan_to_next_token(self): + # We ignore spaces, line breaks and comments. + # If we find a line break in the block context, we set the flag + # `allow_simple_key` on. + # The byte order mark is stripped if it's the first character in the + # stream. We do not yet support BOM inside the stream as the + # specification requires. Any such mark will be considered as a part + # of the document. + # + # TODO: We need to make tab handling rules more sane. A good rule is + # Tabs cannot precede tokens + # BLOCK-SEQUENCE-START, BLOCK-MAPPING-START, BLOCK-END, + # KEY(block), VALUE(block), BLOCK-ENTRY + # So the checking code is + # if : + # self.allow_simple_keys = False + # We also need to add the check for `allow_simple_keys == True` to + # `unwind_indent` before issuing BLOCK-END. + # Scanners for block, flow, and plain scalars need to be modified. + + if self.index == 0 and self.peek() == u'\uFEFF': + self.forward() + found = False + while not found: + while self.peek() == u' ': + self.forward() + if self.peek() == u'#': + while self.peek() not in u'\0\r\n\x85\u2028\u2029': + self.forward() + if self.scan_line_break(): + if not self.flow_level: + self.allow_simple_key = True + else: + found = True + + def scan_directive(self): + # See the specification for details. + start_mark = self.get_mark() + self.forward() + name = self.scan_directive_name(start_mark) + value = None + if name == u'YAML': + value = self.scan_yaml_directive_value(start_mark) + end_mark = self.get_mark() + elif name == u'TAG': + value = self.scan_tag_directive_value(start_mark) + end_mark = self.get_mark() + else: + end_mark = self.get_mark() + while self.peek() not in u'\0\r\n\x85\u2028\u2029': + self.forward() + self.scan_directive_ignored_line(start_mark) + return DirectiveToken(name, value, start_mark, end_mark) + + def scan_directive_name(self, start_mark): + # See the specification for details. + length = 0 + ch = self.peek(length) + while u'0' <= ch <= u'9' or u'A' <= ch <= u'Z' or u'a' <= ch <= u'z' \ + or ch in u'-_': + length += 1 + ch = self.peek(length) + if not length: + raise ScannerError("while scanning a directive", start_mark, + "expected alphabetic or numeric character, but found %r" + % ch.encode('utf-8'), self.get_mark()) + value = self.prefix(length) + self.forward(length) + ch = self.peek() + if ch not in u'\0 \r\n\x85\u2028\u2029': + raise ScannerError("while scanning a directive", start_mark, + "expected alphabetic or numeric character, but found %r" + % ch.encode('utf-8'), self.get_mark()) + return value + + def scan_yaml_directive_value(self, start_mark): + # See the specification for details. + while self.peek() == u' ': + self.forward() + major = self.scan_yaml_directive_number(start_mark) + if self.peek() != '.': + raise ScannerError("while scanning a directive", start_mark, + "expected a digit or '.', but found %r" + % self.peek().encode('utf-8'), + self.get_mark()) + self.forward() + minor = self.scan_yaml_directive_number(start_mark) + if self.peek() not in u'\0 \r\n\x85\u2028\u2029': + raise ScannerError("while scanning a directive", start_mark, + "expected a digit or ' ', but found %r" + % self.peek().encode('utf-8'), + self.get_mark()) + return (major, minor) + + def scan_yaml_directive_number(self, start_mark): + # See the specification for details. + ch = self.peek() + if not (u'0' <= ch <= u'9'): + raise ScannerError("while scanning a directive", start_mark, + "expected a digit, but found %r" % ch.encode('utf-8'), + self.get_mark()) + length = 0 + while u'0' <= self.peek(length) <= u'9': + length += 1 + value = int(self.prefix(length)) + self.forward(length) + return value + + def scan_tag_directive_value(self, start_mark): + # See the specification for details. + while self.peek() == u' ': + self.forward() + handle = self.scan_tag_directive_handle(start_mark) + while self.peek() == u' ': + self.forward() + prefix = self.scan_tag_directive_prefix(start_mark) + return (handle, prefix) + + def scan_tag_directive_handle(self, start_mark): + # See the specification for details. + value = self.scan_tag_handle('directive', start_mark) + ch = self.peek() + if ch != u' ': + raise ScannerError("while scanning a directive", start_mark, + "expected ' ', but found %r" % ch.encode('utf-8'), + self.get_mark()) + return value + + def scan_tag_directive_prefix(self, start_mark): + # See the specification for details. + value = self.scan_tag_uri('directive', start_mark) + ch = self.peek() + if ch not in u'\0 \r\n\x85\u2028\u2029': + raise ScannerError("while scanning a directive", start_mark, + "expected ' ', but found %r" % ch.encode('utf-8'), + self.get_mark()) + return value + + def scan_directive_ignored_line(self, start_mark): + # See the specification for details. + while self.peek() == u' ': + self.forward() + if self.peek() == u'#': + while self.peek() not in u'\0\r\n\x85\u2028\u2029': + self.forward() + ch = self.peek() + if ch not in u'\0\r\n\x85\u2028\u2029': + raise ScannerError("while scanning a directive", start_mark, + "expected a comment or a line break, but found %r" + % ch.encode('utf-8'), self.get_mark()) + self.scan_line_break() + + def scan_anchor(self, TokenClass): + # The specification does not restrict characters for anchors and + # aliases. This may lead to problems, for instance, the document: + # [ *alias, value ] + # can be interpteted in two ways, as + # [ "value" ] + # and + # [ *alias , "value" ] + # Therefore we restrict aliases to numbers and ASCII letters. + start_mark = self.get_mark() + indicator = self.peek() + if indicator == u'*': + name = 'alias' + else: + name = 'anchor' + self.forward() + length = 0 + ch = self.peek(length) + while u'0' <= ch <= u'9' or u'A' <= ch <= u'Z' or u'a' <= ch <= u'z' \ + or ch in u'-_': + length += 1 + ch = self.peek(length) + if not length: + raise ScannerError("while scanning an %s" % name, start_mark, + "expected alphabetic or numeric character, but found %r" + % ch.encode('utf-8'), self.get_mark()) + value = self.prefix(length) + self.forward(length) + ch = self.peek() + if ch not in u'\0 \t\r\n\x85\u2028\u2029?:,]}%@`': + raise ScannerError("while scanning an %s" % name, start_mark, + "expected alphabetic or numeric character, but found %r" + % ch.encode('utf-8'), self.get_mark()) + end_mark = self.get_mark() + return TokenClass(value, start_mark, end_mark) + + def scan_tag(self): + # See the specification for details. + start_mark = self.get_mark() + ch = self.peek(1) + if ch == u'<': + handle = None + self.forward(2) + suffix = self.scan_tag_uri('tag', start_mark) + if self.peek() != u'>': + raise ScannerError("while parsing a tag", start_mark, + "expected '>', but found %r" % self.peek().encode('utf-8'), + self.get_mark()) + self.forward() + elif ch in u'\0 \t\r\n\x85\u2028\u2029': + handle = None + suffix = u'!' + self.forward() + else: + length = 1 + use_handle = False + while ch not in u'\0 \r\n\x85\u2028\u2029': + if ch == u'!': + use_handle = True + break + length += 1 + ch = self.peek(length) + handle = u'!' + if use_handle: + handle = self.scan_tag_handle('tag', start_mark) + else: + handle = u'!' + self.forward() + suffix = self.scan_tag_uri('tag', start_mark) + ch = self.peek() + if ch not in u'\0 \r\n\x85\u2028\u2029': + raise ScannerError("while scanning a tag", start_mark, + "expected ' ', but found %r" % ch.encode('utf-8'), + self.get_mark()) + value = (handle, suffix) + end_mark = self.get_mark() + return TagToken(value, start_mark, end_mark) + + def scan_block_scalar(self, style): + # See the specification for details. + + if style == '>': + folded = True + else: + folded = False + + chunks = [] + start_mark = self.get_mark() + + # Scan the header. + self.forward() + chomping, increment = self.scan_block_scalar_indicators(start_mark) + self.scan_block_scalar_ignored_line(start_mark) + + # Determine the indentation level and go to the first non-empty line. + min_indent = self.indent+1 + if min_indent < 1: + min_indent = 1 + if increment is None: + breaks, max_indent, end_mark = self.scan_block_scalar_indentation() + indent = max(min_indent, max_indent) + else: + indent = min_indent+increment-1 + breaks, end_mark = self.scan_block_scalar_breaks(indent) + line_break = u'' + + # Scan the inner part of the block scalar. + while self.column == indent and self.peek() != u'\0': + chunks.extend(breaks) + leading_non_space = self.peek() not in u' \t' + length = 0 + while self.peek(length) not in u'\0\r\n\x85\u2028\u2029': + length += 1 + chunks.append(self.prefix(length)) + self.forward(length) + line_break = self.scan_line_break() + breaks, end_mark = self.scan_block_scalar_breaks(indent) + if self.column == indent and self.peek() != u'\0': + + # Unfortunately, folding rules are ambiguous. + # + # This is the folding according to the specification: + + if folded and line_break == u'\n' \ + and leading_non_space and self.peek() not in u' \t': + if not breaks: + chunks.append(u' ') + else: + chunks.append(line_break) + + # This is Clark Evans's interpretation (also in the spec + # examples): + # + #if folded and line_break == u'\n': + # if not breaks: + # if self.peek() not in ' \t': + # chunks.append(u' ') + # else: + # chunks.append(line_break) + #else: + # chunks.append(line_break) + else: + break + + # Chomp the tail. + if chomping is not False: + chunks.append(line_break) + if chomping is True: + chunks.extend(breaks) + + # We are done. + return ScalarToken(u''.join(chunks), False, start_mark, end_mark, + style) + + def scan_block_scalar_indicators(self, start_mark): + # See the specification for details. + chomping = None + increment = None + ch = self.peek() + if ch in u'+-': + if ch == '+': + chomping = True + else: + chomping = False + self.forward() + ch = self.peek() + if ch in u'0123456789': + increment = int(ch) + if increment == 0: + raise ScannerError("while scanning a block scalar", start_mark, + "expected indentation indicator in the range 1-9, but found 0", + self.get_mark()) + self.forward() + elif ch in u'0123456789': + increment = int(ch) + if increment == 0: + raise ScannerError("while scanning a block scalar", start_mark, + "expected indentation indicator in the range 1-9, but found 0", + self.get_mark()) + self.forward() + ch = self.peek() + if ch in u'+-': + if ch == '+': + chomping = True + else: + chomping = False + self.forward() + ch = self.peek() + if ch not in u'\0 \r\n\x85\u2028\u2029': + raise ScannerError("while scanning a block scalar", start_mark, + "expected chomping or indentation indicators, but found %r" + % ch.encode('utf-8'), self.get_mark()) + return chomping, increment + + def scan_block_scalar_ignored_line(self, start_mark): + # See the specification for details. + while self.peek() == u' ': + self.forward() + if self.peek() == u'#': + while self.peek() not in u'\0\r\n\x85\u2028\u2029': + self.forward() + ch = self.peek() + if ch not in u'\0\r\n\x85\u2028\u2029': + raise ScannerError("while scanning a block scalar", start_mark, + "expected a comment or a line break, but found %r" + % ch.encode('utf-8'), self.get_mark()) + self.scan_line_break() + + def scan_block_scalar_indentation(self): + # See the specification for details. + chunks = [] + max_indent = 0 + end_mark = self.get_mark() + while self.peek() in u' \r\n\x85\u2028\u2029': + if self.peek() != u' ': + chunks.append(self.scan_line_break()) + end_mark = self.get_mark() + else: + self.forward() + if self.column > max_indent: + max_indent = self.column + return chunks, max_indent, end_mark + + def scan_block_scalar_breaks(self, indent): + # See the specification for details. + chunks = [] + end_mark = self.get_mark() + while self.column < indent and self.peek() == u' ': + self.forward() + while self.peek() in u'\r\n\x85\u2028\u2029': + chunks.append(self.scan_line_break()) + end_mark = self.get_mark() + while self.column < indent and self.peek() == u' ': + self.forward() + return chunks, end_mark + + def scan_flow_scalar(self, style): + # See the specification for details. + # Note that we loose indentation rules for quoted scalars. Quoted + # scalars don't need to adhere indentation because " and ' clearly + # mark the beginning and the end of them. Therefore we are less + # restrictive then the specification requires. We only need to check + # that document separators are not included in scalars. + if style == '"': + double = True + else: + double = False + chunks = [] + start_mark = self.get_mark() + quote = self.peek() + self.forward() + chunks.extend(self.scan_flow_scalar_non_spaces(double, start_mark)) + while self.peek() != quote: + chunks.extend(self.scan_flow_scalar_spaces(double, start_mark)) + chunks.extend(self.scan_flow_scalar_non_spaces(double, start_mark)) + self.forward() + end_mark = self.get_mark() + return ScalarToken(u''.join(chunks), False, start_mark, end_mark, + style) + + ESCAPE_REPLACEMENTS = { + u'0': u'\0', + u'a': u'\x07', + u'b': u'\x08', + u't': u'\x09', + u'\t': u'\x09', + u'n': u'\x0A', + u'v': u'\x0B', + u'f': u'\x0C', + u'r': u'\x0D', + u'e': u'\x1B', + u' ': u'\x20', + u'\"': u'\"', + u'\\': u'\\', + u'N': u'\x85', + u'_': u'\xA0', + u'L': u'\u2028', + u'P': u'\u2029', + } + + ESCAPE_CODES = { + u'x': 2, + u'u': 4, + u'U': 8, + } + + def scan_flow_scalar_non_spaces(self, double, start_mark): + # See the specification for details. + chunks = [] + while True: + length = 0 + while self.peek(length) not in u'\'\"\\\0 \t\r\n\x85\u2028\u2029': + length += 1 + if length: + chunks.append(self.prefix(length)) + self.forward(length) + ch = self.peek() + if not double and ch == u'\'' and self.peek(1) == u'\'': + chunks.append(u'\'') + self.forward(2) + elif (double and ch == u'\'') or (not double and ch in u'\"\\'): + chunks.append(ch) + self.forward() + elif double and ch == u'\\': + self.forward() + ch = self.peek() + if ch in self.ESCAPE_REPLACEMENTS: + chunks.append(self.ESCAPE_REPLACEMENTS[ch]) + self.forward() + elif ch in self.ESCAPE_CODES: + length = self.ESCAPE_CODES[ch] + self.forward() + for k in range(length): + if self.peek(k) not in u'0123456789ABCDEFabcdef': + raise ScannerError("while scanning a double-quoted scalar", start_mark, + "expected escape sequence of %d hexdecimal numbers, but found %r" % + (length, self.peek(k).encode('utf-8')), self.get_mark()) + code = int(self.prefix(length), 16) + chunks.append(unichr(code)) + self.forward(length) + elif ch in u'\r\n\x85\u2028\u2029': + self.scan_line_break() + chunks.extend(self.scan_flow_scalar_breaks(double, start_mark)) + else: + raise ScannerError("while scanning a double-quoted scalar", start_mark, + "found unknown escape character %r" % ch.encode('utf-8'), self.get_mark()) + else: + return chunks + + def scan_flow_scalar_spaces(self, double, start_mark): + # See the specification for details. + chunks = [] + length = 0 + while self.peek(length) in u' \t': + length += 1 + whitespaces = self.prefix(length) + self.forward(length) + ch = self.peek() + if ch == u'\0': + raise ScannerError("while scanning a quoted scalar", start_mark, + "found unexpected end of stream", self.get_mark()) + elif ch in u'\r\n\x85\u2028\u2029': + line_break = self.scan_line_break() + breaks = self.scan_flow_scalar_breaks(double, start_mark) + if line_break != u'\n': + chunks.append(line_break) + elif not breaks: + chunks.append(u' ') + chunks.extend(breaks) + else: + chunks.append(whitespaces) + return chunks + + def scan_flow_scalar_breaks(self, double, start_mark): + # See the specification for details. + chunks = [] + while True: + # Instead of checking indentation, we check for document + # separators. + prefix = self.prefix(3) + if (prefix == u'---' or prefix == u'...') \ + and self.peek(3) in u'\0 \t\r\n\x85\u2028\u2029': + raise ScannerError("while scanning a quoted scalar", start_mark, + "found unexpected document separator", self.get_mark()) + while self.peek() in u' \t': + self.forward() + if self.peek() in u'\r\n\x85\u2028\u2029': + chunks.append(self.scan_line_break()) + else: + return chunks + + def scan_plain(self): + # See the specification for details. + # We add an additional restriction for the flow context: + # plain scalars in the flow context cannot contain ',', ':' and '?'. + # We also keep track of the `allow_simple_key` flag here. + # Indentation rules are loosed for the flow context. + chunks = [] + start_mark = self.get_mark() + end_mark = start_mark + indent = self.indent+1 + # We allow zero indentation for scalars, but then we need to check for + # document separators at the beginning of the line. + #if indent == 0: + # indent = 1 + spaces = [] + while True: + length = 0 + if self.peek() == u'#': + break + while True: + ch = self.peek(length) + if ch in u'\0 \t\r\n\x85\u2028\u2029' \ + or (not self.flow_level and ch == u':' and + self.peek(length+1) in u'\0 \t\r\n\x85\u2028\u2029') \ + or (self.flow_level and ch in u',:?[]{}'): + break + length += 1 + # It's not clear what we should do with ':' in the flow context. + if (self.flow_level and ch == u':' + and self.peek(length+1) not in u'\0 \t\r\n\x85\u2028\u2029,[]{}'): + self.forward(length) + raise ScannerError("while scanning a plain scalar", start_mark, + "found unexpected ':'", self.get_mark(), + "Please check http://pyyaml.org/wiki/YAMLColonInFlowContext for details.") + if length == 0: + break + self.allow_simple_key = False + chunks.extend(spaces) + chunks.append(self.prefix(length)) + self.forward(length) + end_mark = self.get_mark() + spaces = self.scan_plain_spaces(indent, start_mark) + if not spaces or self.peek() == u'#' \ + or (not self.flow_level and self.column < indent): + break + return ScalarToken(u''.join(chunks), True, start_mark, end_mark) + + def scan_plain_spaces(self, indent, start_mark): + # See the specification for details. + # The specification is really confusing about tabs in plain scalars. + # We just forbid them completely. Do not use tabs in YAML! + chunks = [] + length = 0 + while self.peek(length) in u' ': + length += 1 + whitespaces = self.prefix(length) + self.forward(length) + ch = self.peek() + if ch in u'\r\n\x85\u2028\u2029': + line_break = self.scan_line_break() + self.allow_simple_key = True + prefix = self.prefix(3) + if (prefix == u'---' or prefix == u'...') \ + and self.peek(3) in u'\0 \t\r\n\x85\u2028\u2029': + return + breaks = [] + while self.peek() in u' \r\n\x85\u2028\u2029': + if self.peek() == ' ': + self.forward() + else: + breaks.append(self.scan_line_break()) + prefix = self.prefix(3) + if (prefix == u'---' or prefix == u'...') \ + and self.peek(3) in u'\0 \t\r\n\x85\u2028\u2029': + return + if line_break != u'\n': + chunks.append(line_break) + elif not breaks: + chunks.append(u' ') + chunks.extend(breaks) + elif whitespaces: + chunks.append(whitespaces) + return chunks + + def scan_tag_handle(self, name, start_mark): + # See the specification for details. + # For some strange reasons, the specification does not allow '_' in + # tag handles. I have allowed it anyway. + ch = self.peek() + if ch != u'!': + raise ScannerError("while scanning a %s" % name, start_mark, + "expected '!', but found %r" % ch.encode('utf-8'), + self.get_mark()) + length = 1 + ch = self.peek(length) + if ch != u' ': + while u'0' <= ch <= u'9' or u'A' <= ch <= u'Z' or u'a' <= ch <= u'z' \ + or ch in u'-_': + length += 1 + ch = self.peek(length) + if ch != u'!': + self.forward(length) + raise ScannerError("while scanning a %s" % name, start_mark, + "expected '!', but found %r" % ch.encode('utf-8'), + self.get_mark()) + length += 1 + value = self.prefix(length) + self.forward(length) + return value + + def scan_tag_uri(self, name, start_mark): + # See the specification for details. + # Note: we do not check if URI is well-formed. + chunks = [] + length = 0 + ch = self.peek(length) + while u'0' <= ch <= u'9' or u'A' <= ch <= u'Z' or u'a' <= ch <= u'z' \ + or ch in u'-;/?:@&=+$,_.!~*\'()[]%': + if ch == u'%': + chunks.append(self.prefix(length)) + self.forward(length) + length = 0 + chunks.append(self.scan_uri_escapes(name, start_mark)) + else: + length += 1 + ch = self.peek(length) + if length: + chunks.append(self.prefix(length)) + self.forward(length) + length = 0 + if not chunks: + raise ScannerError("while parsing a %s" % name, start_mark, + "expected URI, but found %r" % ch.encode('utf-8'), + self.get_mark()) + return u''.join(chunks) + + def scan_uri_escapes(self, name, start_mark): + # See the specification for details. + bytes = [] + mark = self.get_mark() + while self.peek() == u'%': + self.forward() + for k in range(2): + if self.peek(k) not in u'0123456789ABCDEFabcdef': + raise ScannerError("while scanning a %s" % name, start_mark, + "expected URI escape sequence of 2 hexdecimal numbers, but found %r" % + (self.peek(k).encode('utf-8')), self.get_mark()) + bytes.append(chr(int(self.prefix(2), 16))) + self.forward(2) + try: + value = unicode(''.join(bytes), 'utf-8') + except UnicodeDecodeError, exc: + raise ScannerError("while scanning a %s" % name, start_mark, str(exc), mark) + return value + + def scan_line_break(self): + # Transforms: + # '\r\n' : '\n' + # '\r' : '\n' + # '\n' : '\n' + # '\x85' : '\n' + # '\u2028' : '\u2028' + # '\u2029 : '\u2029' + # default : '' + ch = self.peek() + if ch in u'\r\n\x85': + if self.prefix(2) == u'\r\n': + self.forward(2) + else: + self.forward() + return u'\n' + elif ch in u'\u2028\u2029': + self.forward() + return ch + return u'' + +#try: +# import psyco +# psyco.bind(Scanner) +#except ImportError: +# pass + diff --git a/scripts/clang-tidy/6.0.0/yaml/serializer.py b/scripts/clang-tidy/6.0.0/yaml/serializer.py new file mode 100644 index 000000000..0bf1e96dc --- /dev/null +++ b/scripts/clang-tidy/6.0.0/yaml/serializer.py @@ -0,0 +1,111 @@ + +__all__ = ['Serializer', 'SerializerError'] + +from error import YAMLError +from events import * +from nodes import * + +class SerializerError(YAMLError): + pass + +class Serializer(object): + + ANCHOR_TEMPLATE = u'id%03d' + + def __init__(self, encoding=None, + explicit_start=None, explicit_end=None, version=None, tags=None): + self.use_encoding = encoding + self.use_explicit_start = explicit_start + self.use_explicit_end = explicit_end + self.use_version = version + self.use_tags = tags + self.serialized_nodes = {} + self.anchors = {} + self.last_anchor_id = 0 + self.closed = None + + def open(self): + if self.closed is None: + self.emit(StreamStartEvent(encoding=self.use_encoding)) + self.closed = False + elif self.closed: + raise SerializerError("serializer is closed") + else: + raise SerializerError("serializer is already opened") + + def close(self): + if self.closed is None: + raise SerializerError("serializer is not opened") + elif not self.closed: + self.emit(StreamEndEvent()) + self.closed = True + + #def __del__(self): + # self.close() + + def serialize(self, node): + if self.closed is None: + raise SerializerError("serializer is not opened") + elif self.closed: + raise SerializerError("serializer is closed") + self.emit(DocumentStartEvent(explicit=self.use_explicit_start, + version=self.use_version, tags=self.use_tags)) + self.anchor_node(node) + self.serialize_node(node, None, None) + self.emit(DocumentEndEvent(explicit=self.use_explicit_end)) + self.serialized_nodes = {} + self.anchors = {} + self.last_anchor_id = 0 + + def anchor_node(self, node): + if node in self.anchors: + if self.anchors[node] is None: + self.anchors[node] = self.generate_anchor(node) + else: + self.anchors[node] = None + if isinstance(node, SequenceNode): + for item in node.value: + self.anchor_node(item) + elif isinstance(node, MappingNode): + for key, value in node.value: + self.anchor_node(key) + self.anchor_node(value) + + def generate_anchor(self, node): + self.last_anchor_id += 1 + return self.ANCHOR_TEMPLATE % self.last_anchor_id + + def serialize_node(self, node, parent, index): + alias = self.anchors[node] + if node in self.serialized_nodes: + self.emit(AliasEvent(alias)) + else: + self.serialized_nodes[node] = True + self.descend_resolver(parent, index) + if isinstance(node, ScalarNode): + detected_tag = self.resolve(ScalarNode, node.value, (True, False)) + default_tag = self.resolve(ScalarNode, node.value, (False, True)) + implicit = (node.tag == detected_tag), (node.tag == default_tag) + self.emit(ScalarEvent(alias, node.tag, implicit, node.value, + style=node.style)) + elif isinstance(node, SequenceNode): + implicit = (node.tag + == self.resolve(SequenceNode, node.value, True)) + self.emit(SequenceStartEvent(alias, node.tag, implicit, + flow_style=node.flow_style)) + index = 0 + for item in node.value: + self.serialize_node(item, node, index) + index += 1 + self.emit(SequenceEndEvent()) + elif isinstance(node, MappingNode): + implicit = (node.tag + == self.resolve(MappingNode, node.value, True)) + self.emit(MappingStartEvent(alias, node.tag, implicit, + flow_style=node.flow_style)) + for key, value in node.value: + self.serialize_node(key, node, None) + self.serialize_node(value, node, key) + self.emit(MappingEndEvent()) + self.ascend_resolver() + diff --git a/scripts/clang-tidy/6.0.0/yaml/tokens.py b/scripts/clang-tidy/6.0.0/yaml/tokens.py new file mode 100644 index 000000000..4d0b48a39 --- /dev/null +++ b/scripts/clang-tidy/6.0.0/yaml/tokens.py @@ -0,0 +1,104 @@ + +class Token(object): + def __init__(self, start_mark, end_mark): + self.start_mark = start_mark + self.end_mark = end_mark + def __repr__(self): + attributes = [key for key in self.__dict__ + if not key.endswith('_mark')] + attributes.sort() + arguments = ', '.join(['%s=%r' % (key, getattr(self, key)) + for key in attributes]) + return '%s(%s)' % (self.__class__.__name__, arguments) + +#class BOMToken(Token): +# id = '' + +class DirectiveToken(Token): + id = '' + def __init__(self, name, value, start_mark, end_mark): + self.name = name + self.value = value + self.start_mark = start_mark + self.end_mark = end_mark + +class DocumentStartToken(Token): + id = '' + +class DocumentEndToken(Token): + id = '' + +class StreamStartToken(Token): + id = '' + def __init__(self, start_mark=None, end_mark=None, + encoding=None): + self.start_mark = start_mark + self.end_mark = end_mark + self.encoding = encoding + +class StreamEndToken(Token): + id = '' + +class BlockSequenceStartToken(Token): + id = '' + +class BlockMappingStartToken(Token): + id = '' + +class BlockEndToken(Token): + id = '' + +class FlowSequenceStartToken(Token): + id = '[' + +class FlowMappingStartToken(Token): + id = '{' + +class FlowSequenceEndToken(Token): + id = ']' + +class FlowMappingEndToken(Token): + id = '}' + +class KeyToken(Token): + id = '?' + +class ValueToken(Token): + id = ':' + +class BlockEntryToken(Token): + id = '-' + +class FlowEntryToken(Token): + id = ',' + +class AliasToken(Token): + id = '' + def __init__(self, value, start_mark, end_mark): + self.value = value + self.start_mark = start_mark + self.end_mark = end_mark + +class AnchorToken(Token): + id = '' + def __init__(self, value, start_mark, end_mark): + self.value = value + self.start_mark = start_mark + self.end_mark = end_mark + +class TagToken(Token): + id = '' + def __init__(self, value, start_mark, end_mark): + self.value = value + self.start_mark = start_mark + self.end_mark = end_mark + +class ScalarToken(Token): + id = '' + def __init__(self, value, plain, start_mark, end_mark, style=None): + self.value = value + self.plain = plain + self.start_mark = start_mark + self.end_mark = end_mark + self.style = style + From 1ba803b998fd9a5bab9a53767c1df1e273185245 Mon Sep 17 00:00:00 2001 From: Allie Crevier Date: Tue, 24 Apr 2018 17:31:51 -0700 Subject: [PATCH 020/338] Update README.md Add a section for creating a dev package of LLVM and its subpackages --- scripts/llvm/base/README.md | 31 +++++++++++++++++++++++++++++++ 1 file changed, 31 insertions(+) diff --git a/scripts/llvm/base/README.md b/scripts/llvm/base/README.md index 3b25630e6..6cb5b8b76 100644 --- a/scripts/llvm/base/README.md +++ b/scripts/llvm/base/README.md @@ -6,6 +6,7 @@ This readme documents: - Which sub-packages depend on the llvm package - How the llvm packages are built - How to create a new llvm package + sub-packages + - How to create a new dev llvm package + sub-packages - How to use the binary packages ## What is llvm? @@ -211,6 +212,36 @@ MASON_PLATFORM=linux ./utils/llvm.sh publish 4.0.2 Note: `MASON_PLATFORM=linux` is only needed if your host is OS X. +## How to create a new dev llvm package + sub-packages + +#### Step 1: Create a mason branch + +`git checkout -b llvm-dev` + +#### Step 2: Create the new package + +Since a version number doesn't exist until LLVM makes a release, you should pick a version number that is one digit higher than the lastest release, e.g. if the latest release is 5.0.1, you would pick 6.0.0. Then create a new llvm package and sub-packages: + +``` +./utils/llvm.sh create 6.0.0 5.0.1 +``` + +#### Step 3: Override `setup_base_tools` + +- Edit the `script.sh` inside the directory of the new package you just created, e.g. from the example above `./scripts/llvm/6.0.0/script.sh` +- Override the `setup_base_tools` function with something like this https://github.com/mapbox/mason/blob/libzip-1.5.1/scripts/llvm/7.0.0/script.sh#L12-L27. This is where you tell mason to grab LLVM directly from http://llvm.org/git/llvm.git. Note: You can also specify a gitsha with `get_llvm_project` and this is currently being considered to become the recommended way of getting a dev version of LLVM since it is reproducible and easier to debug later. + +#### Follow Step 5 and 6 above in the publishing a new package section + +Following steps 5 and 6 above cover: + +- Pushing your new package to github +- Creating a PR +- Building the new package +- Publishing it + +Note: When building your package, e.g. `./mason build llvm 6.0.0`, mason will use the URLS you provided in the `setup_base_tools` override. + ## How to use the binary packages The binary packages will work on: From 741bd4267164d301e7fdb718f146553512213768 Mon Sep 17 00:00:00 2001 From: Dane Springmeyer Date: Tue, 24 Apr 2018 17:35:14 -0700 Subject: [PATCH 021/338] copy the bundled pyyaml into the clang-tidy share/ directory --- scripts/clang-tidy/base/common.sh | 3 +++ 1 file changed, 3 insertions(+) diff --git a/scripts/clang-tidy/base/common.sh b/scripts/clang-tidy/base/common.sh index ea7ead2e4..d9e3e0abb 100755 --- a/scripts/clang-tidy/base/common.sh +++ b/scripts/clang-tidy/base/common.sh @@ -27,6 +27,9 @@ function mason_build { cp -r "${CLANG_PREFIX}/share/clang/run-clang-tidy.py" "${MASON_PREFIX}/share/" cp -r "${CLANG_PREFIX}/share/clang/clang-tidy-diff.py" "${MASON_PREFIX}/share/" cp -r "${CLANG_PREFIX}/share/clang/run-find-all-symbols.py" "${MASON_PREFIX}/share/" + if [[ -d "${MASON_DIR}/scripts/${MASON_NAME}/${MASON_VERSION}/yaml" ]]; then + cp -r "${MASON_DIR}/scripts/${MASON_NAME}/${MASON_VERSION}/yaml" "${MASON_PREFIX}/share/" + fi } From 6c33cb0ebf6f8e144fd275bd517ead8c80161806 Mon Sep 17 00:00:00 2001 From: Allie Crevier Date: Tue, 24 Apr 2018 17:41:33 -0700 Subject: [PATCH 022/338] Update README.md Added a section in the LLVM readme to link our documented workaround for moving from and LLVM dev package to an LLVM release package --- scripts/llvm/base/README.md | 16 ++++++++++++++-- 1 file changed, 14 insertions(+), 2 deletions(-) diff --git a/scripts/llvm/base/README.md b/scripts/llvm/base/README.md index 6cb5b8b76..21a87dad6 100644 --- a/scripts/llvm/base/README.md +++ b/scripts/llvm/base/README.md @@ -6,7 +6,8 @@ This readme documents: - Which sub-packages depend on the llvm package - How the llvm packages are built - How to create a new llvm package + sub-packages - - How to create a new dev llvm package + sub-packages + - How to create a new _dev_ llvm package + sub-packages + - How to create a release package from a dev package (+ sub-packages) - How to use the binary packages ## What is llvm? @@ -212,6 +213,12 @@ MASON_PLATFORM=linux ./utils/llvm.sh publish 4.0.2 Note: `MASON_PLATFORM=linux` is only needed if your host is OS X. +#### Step 7: Test and Merge + +Once you publish, you should check the PR you created earlier to see if CI tests pass and run any other tests necessary to check your new package. Once tests have passed, merge your PR into master. + +You're done! + ## How to create a new dev llvm package + sub-packages #### Step 1: Create a mason branch @@ -231,7 +238,7 @@ Since a version number doesn't exist until LLVM makes a release, you should pick - Edit the `script.sh` inside the directory of the new package you just created, e.g. from the example above `./scripts/llvm/6.0.0/script.sh` - Override the `setup_base_tools` function with something like this https://github.com/mapbox/mason/blob/libzip-1.5.1/scripts/llvm/7.0.0/script.sh#L12-L27. This is where you tell mason to grab LLVM directly from http://llvm.org/git/llvm.git. Note: You can also specify a gitsha with `get_llvm_project` and this is currently being considered to become the recommended way of getting a dev version of LLVM since it is reproducible and easier to debug later. -#### Follow Step 5 and 6 above in the publishing a new package section +#### Step 4: Follow Steps 5 and 7 above in the publishing a new package section Following steps 5 and 6 above cover: @@ -239,9 +246,14 @@ Following steps 5 and 6 above cover: - Creating a PR - Building the new package - Publishing it +- Merging your PR once CI tests pass Note: When building your package, e.g. `./mason build llvm 6.0.0`, mason will use the URLS you provided in the `setup_base_tools` override. +## How to create a release package from a dev package (+ sub-packages) + +Currently this is a WIP, and making this easier to achieve is currently an issue with a documented work-around here: https://github.com/mapbox/mason/issues/578#issuecomment-383735380 + ## How to use the binary packages The binary packages will work on: From efbed353b8865d91d9cdd2602dac6ec8919d8d7a Mon Sep 17 00:00:00 2001 From: Dane Springmeyer Date: Mon, 30 Apr 2018 10:06:09 -0700 Subject: [PATCH 023/338] add jemalloc @ https://github.com/jemalloc/jemalloc/commit/39b1b2049934be5be7e5b1b6f77ff31cd02398c5 --- scripts/jemalloc/39b1b20/.travis.yml | 14 +++++++++ scripts/jemalloc/39b1b20/script.sh | 46 ++++++++++++++++++++++++++++ 2 files changed, 60 insertions(+) create mode 100644 scripts/jemalloc/39b1b20/.travis.yml create mode 100755 scripts/jemalloc/39b1b20/script.sh diff --git a/scripts/jemalloc/39b1b20/.travis.yml b/scripts/jemalloc/39b1b20/.travis.yml new file mode 100644 index 000000000..e5ec5ff23 --- /dev/null +++ b/scripts/jemalloc/39b1b20/.travis.yml @@ -0,0 +1,14 @@ +language: generic + +matrix: + include: + - os: osx + osx_image: xcode8.2 + compiler: clang + - os: linux + compiler: clang + sudo: false + +script: +- ./mason build ${MASON_NAME} ${MASON_VERSION} +- ./mason publish ${MASON_NAME} ${MASON_VERSION} diff --git a/scripts/jemalloc/39b1b20/script.sh b/scripts/jemalloc/39b1b20/script.sh new file mode 100755 index 000000000..05154d034 --- /dev/null +++ b/scripts/jemalloc/39b1b20/script.sh @@ -0,0 +1,46 @@ +#!/usr/bin/env bash + +MASON_NAME=jemalloc +MASON_VERSION=39b1b20 +MASON_LIB_FILE=lib/libjemalloc.${MASON_DYNLIB_SUFFIX} + +. ${MASON_DIR}/mason.sh + +function mason_load_source { + mason_download \ + https://github.com/jemalloc/jemalloc/tarball/${MASON_VERSION}/jemalloc-${MASON_VERSION} \ + 51b9ca5a7fd39562eeff4733dad1f536a39f414a + + mason_extract_tar_gz + + export MASON_BUILD_PATH=${MASON_ROOT}/.build/jemalloc-${MASON_NAME}-${MASON_VERSION} +} + +function mason_compile { + # need to call autogen.sh when building from a gitsha only + ./autogen.sh + # oddly DNDEBUG is not automatically in the jemalloc flags, so we add it here for best perf/just to be safe (to 100% assert asserts are removed) + export CFLAGS="${CFLAGS:-} -DNDEBUG" + # note: as of jemalloc 4.5.0 CFLAGS no longer overwrites but appends. + # so we don't mess with CFLAGS here like previous packages where we needed to manually re-add the jemalloc CFLAGS that were lost + + # note: the below malloc-conf changes are based on reading https://github.com/jemalloc/jemalloc/pull/1179/files + # and noting that fb defaults to background_thread:true: https://github.com/jemalloc/jemalloc/issues/1128#issuecomment-378439640 + ./configure --prefix=${MASON_PREFIX} --disable-stats \ + --with-malloc-conf=background_thread:true,abort_conf:true + make -j${MASON_CONCURRENCY} VERBOSE=1 install_lib +} + +function mason_cflags { + : +} + +function mason_ldflags { + : +} + +function mason_clean { + make clean +} + +mason_run "$@" From 0c84fc292f12ff7a888529de7ec876141147211d Mon Sep 17 00:00:00 2001 From: Carol Hansen Date: Mon, 30 Apr 2018 18:24:23 -0500 Subject: [PATCH 024/338] gzip-hpp 1.0.0 (#605) * gzip-hpp 1.0.0 package --- .../1.0.0}/.travis.yml | 0 scripts/gzip-hpp/1.0.0/script.sh | 33 +++++++++++++++++++ .../.travis.yml | 0 .../script.sh | 0 scripts/gzip-hpp/bb80aac/.travis.yml | 12 +++++++ scripts/{gzip => gzip-hpp}/bb80aac/script.sh | 0 6 files changed, 45 insertions(+) rename scripts/{gzip/a4cfa6a638de351d26834cf2fea373693cdaa927 => gzip-hpp/1.0.0}/.travis.yml (100%) create mode 100644 scripts/gzip-hpp/1.0.0/script.sh rename scripts/{gzip/bb80aac => gzip-hpp/a4cfa6a638de351d26834cf2fea373693cdaa927}/.travis.yml (100%) rename scripts/{gzip => gzip-hpp}/a4cfa6a638de351d26834cf2fea373693cdaa927/script.sh (100%) create mode 100644 scripts/gzip-hpp/bb80aac/.travis.yml rename scripts/{gzip => gzip-hpp}/bb80aac/script.sh (100%) diff --git a/scripts/gzip/a4cfa6a638de351d26834cf2fea373693cdaa927/.travis.yml b/scripts/gzip-hpp/1.0.0/.travis.yml similarity index 100% rename from scripts/gzip/a4cfa6a638de351d26834cf2fea373693cdaa927/.travis.yml rename to scripts/gzip-hpp/1.0.0/.travis.yml diff --git a/scripts/gzip-hpp/1.0.0/script.sh b/scripts/gzip-hpp/1.0.0/script.sh new file mode 100644 index 000000000..e060a72b9 --- /dev/null +++ b/scripts/gzip-hpp/1.0.0/script.sh @@ -0,0 +1,33 @@ +#!/usr/bin/env bash + +MASON_NAME=gzip-hpp +MASON_VERSION=1.0.0 +MASON_HEADER_ONLY=true + +. ${MASON_DIR}/mason.sh + +function mason_load_source { + mason_download \ + https://github.com/mapbox/gzip-hpp/archive/v${MASON_VERSION}.tar.gz \ + 84a777e2b7ea70d07565caa1f1ed820f5721f63d + + mason_extract_tar_gz + + export MASON_BUILD_PATH=${MASON_ROOT}/.build/gzip-hpp-${MASON_VERSION} +} + +function mason_compile { + mkdir -p ${MASON_PREFIX}/include/ + cp -r include/gzip ${MASON_PREFIX}/include/gzip +} + +function mason_cflags { + echo "-I${MASON_PREFIX}/include" +} + +function mason_ldflags { + : +} + + +mason_run "$@" diff --git a/scripts/gzip/bb80aac/.travis.yml b/scripts/gzip-hpp/a4cfa6a638de351d26834cf2fea373693cdaa927/.travis.yml similarity index 100% rename from scripts/gzip/bb80aac/.travis.yml rename to scripts/gzip-hpp/a4cfa6a638de351d26834cf2fea373693cdaa927/.travis.yml diff --git a/scripts/gzip/a4cfa6a638de351d26834cf2fea373693cdaa927/script.sh b/scripts/gzip-hpp/a4cfa6a638de351d26834cf2fea373693cdaa927/script.sh similarity index 100% rename from scripts/gzip/a4cfa6a638de351d26834cf2fea373693cdaa927/script.sh rename to scripts/gzip-hpp/a4cfa6a638de351d26834cf2fea373693cdaa927/script.sh diff --git a/scripts/gzip-hpp/bb80aac/.travis.yml b/scripts/gzip-hpp/bb80aac/.travis.yml new file mode 100644 index 000000000..db27cb38e --- /dev/null +++ b/scripts/gzip-hpp/bb80aac/.travis.yml @@ -0,0 +1,12 @@ +language: generic + +matrix: + include: + - os: linux + sudo: false + +script: +- ./mason build ${MASON_NAME} ${MASON_VERSION} + +after_success: +- ./mason publish ${MASON_NAME} ${MASON_VERSION} diff --git a/scripts/gzip/bb80aac/script.sh b/scripts/gzip-hpp/bb80aac/script.sh similarity index 100% rename from scripts/gzip/bb80aac/script.sh rename to scripts/gzip-hpp/bb80aac/script.sh From a7e35b0f632a8b2f0e338acc9dda0cff04d2f752 Mon Sep 17 00:00:00 2001 From: Carol Hansen Date: Sat, 5 May 2018 17:57:40 -0500 Subject: [PATCH 025/338] Gzip 0.1.0 (#607) * Add gzip v0.1.0 --- scripts/gzip-hpp/{1.0.0 => 0.1.0}/.travis.yml | 0 scripts/gzip-hpp/{1.0.0 => 0.1.0}/script.sh | 4 ++-- 2 files changed, 2 insertions(+), 2 deletions(-) rename scripts/gzip-hpp/{1.0.0 => 0.1.0}/.travis.yml (100%) rename scripts/gzip-hpp/{1.0.0 => 0.1.0}/script.sh (88%) diff --git a/scripts/gzip-hpp/1.0.0/.travis.yml b/scripts/gzip-hpp/0.1.0/.travis.yml similarity index 100% rename from scripts/gzip-hpp/1.0.0/.travis.yml rename to scripts/gzip-hpp/0.1.0/.travis.yml diff --git a/scripts/gzip-hpp/1.0.0/script.sh b/scripts/gzip-hpp/0.1.0/script.sh similarity index 88% rename from scripts/gzip-hpp/1.0.0/script.sh rename to scripts/gzip-hpp/0.1.0/script.sh index e060a72b9..49206b3ca 100644 --- a/scripts/gzip-hpp/1.0.0/script.sh +++ b/scripts/gzip-hpp/0.1.0/script.sh @@ -1,7 +1,7 @@ #!/usr/bin/env bash MASON_NAME=gzip-hpp -MASON_VERSION=1.0.0 +MASON_VERSION=0.1.0 MASON_HEADER_ONLY=true . ${MASON_DIR}/mason.sh @@ -9,7 +9,7 @@ MASON_HEADER_ONLY=true function mason_load_source { mason_download \ https://github.com/mapbox/gzip-hpp/archive/v${MASON_VERSION}.tar.gz \ - 84a777e2b7ea70d07565caa1f1ed820f5721f63d + 7bd14b3b9f63a05a7a09264cdda93c741666e835 mason_extract_tar_gz From b2bad4d63eac0288c498e6bbed018d6dc347aa2c Mon Sep 17 00:00:00 2001 From: Allie Crevier Date: Tue, 8 May 2018 16:01:45 -0700 Subject: [PATCH 026/338] Mason readme refactor (#608) * Restructure, add ToC, Mason functions section, and rewrite some section * Update README.md * Update README.md * reorder and update readme * Add new workflow sections for releasing and using a package. Categorize variables, functions, and scripts under Mason internals. * Update wording around using Mason packages --- README.md | 468 +++++++++++++++++++++++++++++++----------------------- 1 file changed, 271 insertions(+), 197 deletions(-) diff --git a/README.md b/README.md index 53c27b6a1..84b63efd3 100644 --- a/README.md +++ b/README.md @@ -1,40 +1,51 @@ # Mason -Mason can compile C/C++ code, publish packages to S3, and install those packages via binaries. +Mason is a cross-platform, command-line package manager for C/C++ applications. -Mason does all its work locally inside `./mason_packages` and therefore does not require privileges for, or conflict with, system-wide packages. +Mason is like: -Mason works on both OS X and Linux. +* [npm](https://github.com/npm/npm) because it installs packages in the current working directory (`./mason_packages`) rather than globally (and therefore does not require privileges for, or conflict with, system-wide packages) +* [homebrew](http://brew.sh/) because it requires no use of `sudo` to install packages +* [apt-get](https://linux.die.net/man/8/apt-get) or [yum](https://linux.die.net/man/8/yum) because it works on Linux -[![Build Status](https://travis-ci.org/mapbox/mason.svg?branch=master)](https://travis-ci.org/mapbox/mason) - -### Goals - -Mason is a package manager designed for developers who package standalone applications and who need complete control over dependency versions. +Mason is unlike: -Because Mason is developed by Mapbox the default S3 bucket and set of available packages are driven by Mapbox developers. For other developers: 1) fork Mason and ideally rename it to something like `mason-{yourorg}`, 2) configure it against your own s3 bucket, and 3) go ahead an publish your own packages to an S3 bucket of your creation. + * all of the above... -### Comparisons + Mason is a collection of bash scripts and does not depend on any specific runtime language, such as python, node.js, or ruby. It can build and publish a single set of binaries (>= OS X 10.8 and >= Ubuntu Precise), publish header-only files, and install packages. Mason has integrations with [Travis CI](https://travis-ci.org) and [Amazon S3](https://aws.amazon.com/s3) for automated build and deployment. -Mason is like [npm](https://github.com/npm/npm) because it installs packages in the current working directory (`./mason_packages`) rather than globally. + Mason strongly prefers static libraries over shared libraries and has zero understanding of dependency trees: it leaves complete control to the developer for how packages relate. -Mason is like [homebrew](http://brew.sh/) because it requires no use of `sudo` to install packages. +Mason works on both **OS X** and **Linux**. -Mason is like linux package managers like `apt-get` or `yum` because it works on linux. - -Mason is unlike all of the above package managers because: +[![Build Status](https://travis-ci.org/mapbox/mason.svg?branch=master)](https://travis-ci.org/mapbox/mason) - - Mason runs on both Linux and OS X and creates a single set of binaries that work on >= OS X 10.8 and >= Ubuntu Precise (rather than building binaries per version). - - Mason strongly prefers static libraries over shared libraries - - Mason has zero understanding of dependency trees: it leaves complete control to the developer for how packages relate. - - Mason does not depend on any specific runtime language (like python, node.js or ruby). It is a just a few bash scripts. - - Mason depends on [travis.ci](https://travis-ci.org) for creating and publishing binaries. +# Table of Contents + +- [Installation](#installation) +- [Configuration](#configuration) +- [Usage](#usage) +- [Creating a package](#creating-a-package) + - [Prerequisites](#prerequisites) + - [Getting started](#getting-started) + - [System packages](#system-packages) +- [Releasing a package](#releasing-a-package) +- [Using a package](#using-a-package) +- [Mason internals](#mason-internals) + - [Mason scripts](#mason-scripts) + - [Mason variables](#mason-variables) + - [Mason functions](#mason-functions) +- [Troubleshooting](#troubleshooting) ## Installation -There are three recommended ways to install mason: via curl, via a submodule, or via bundling `mason.cmake` +There are three recommended ways to install mason, via: + +* [Curl](#curl) +* [Submodule](#submodule) +* [mason.cmake](#masoncmake) -#### Curl install +#### Curl To install mason locally: @@ -55,7 +66,7 @@ Then you can use the `mason` command like: `/tmp/mason install