New upstream version 9-d36de+ds

// gzstream, C++ iostream classes wrapping the zlib compression library.

// Copyright (C) 2001  Deepak Bandyopadhyay, Lutz Kettner

//

// This library is free software; you can redistribute it and/or

// modify it under the terms of the GNU Lesser General Public

// License as published by the Free Software Foundation; either

// version 2.1 of the License, or (at your option) any later version.

//

// This library is distributed in the hope that it will be useful,

// but WITHOUT ANY WARRANTY; without even the implied warranty of

// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU

// Lesser General Public License for more details.

//

// You should have received a copy of the GNU Lesser General Public

// License along with this library; if not, write to the Free Software

// Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA

//

// File          : gzstream.h

// Revision      : $Revision: 1.5 $

// Revision_date : $Date: 2002/04/26 23:30:15 $

// Author(s)     : Deepak Bandyopadhyay, Lutz Kettner

// 

// Standard streambuf implementation following Nicolai Josuttis, "The 

// Standard C++ Library".

#ifndef GZSTREAM_H

#define GZSTREAM_H

#include <iostream>

#include <fstream>

#include <zlib.h>

#include <string.h>  // for memcpy

// Internal classes to implement gzstream. See below for user classes.

class gzstreambuf : public std::streambuf {

private:

    static const int bufferSize = 47 + 256;    // size of data buff

    // totals 512 bytes under g++ for igzstream at the end.

    gzFile file;               // file handle for compressed file

    char buffer[bufferSize]; // data buffer

    char opened;             // open/close state of stream

    int mode;               // I/O mode

    int flush_buffer() {

        // Separate the writing of the buffer from overflow() and

        // sync() operation.

        int w = pptr() - pbase();

        if (gzwrite(file, pbase(), w) != w)

            return EOF;

        pbump(-w);

        return w;

    }

public:

    gzstreambuf() : opened(0) {

        setp(buffer, buffer + (bufferSize - 1));

        setg(buffer + 4,     // beginning of putback area

             buffer + 4,     // read position

             buffer + 4);    // end position

        // ASSERT: both input & output capabilities will not be used together

    }

    int is_open() { return opened; }

    gzstreambuf *open(const char *name, int open_mode) {

        if (is_open())

            return (gzstreambuf *) 0;

        mode = open_mode;

        // no append nor read/write mode

        if ((mode & std::ios::ate) || (mode & std::ios::app)

            || ((mode & std::ios::in) && (mode & std::ios::out)))

            return (gzstreambuf *) 0;

        char fmode[10];

        char *fmodeptr = fmode;

        if (mode & std::ios::in)

            *fmodeptr++ = 'r';

        else if (mode & std::ios::out)

            *fmodeptr++ = 'w';

        *fmodeptr++ = 'b';

        *fmodeptr = '\0';

        file = gzopen(name, fmode);

        if (file == 0)

            return (gzstreambuf *) 0;

        opened = 1;

        return this;

    }

    gzstreambuf *close() {

        if (is_open()) {

            sync();

            opened = 0;

            if (gzclose(file) == Z_OK)

                return this;

        }

        return (gzstreambuf *) 0;

    }

    ~gzstreambuf() { close(); }

    virtual int overflow(int c = EOF) { // used for output buffer only

        if (!(mode & std::ios::out) || !opened)

            return EOF;

        if (c != EOF) {

            *pptr() = c;

            pbump(1);

        }

        if (flush_buffer() == EOF)

            return EOF;

        return c;

    }

    virtual int underflow() { // used for input buffer only

        if (gptr() && (gptr() < egptr()))

            return *reinterpret_cast<unsigned char *>( gptr());

        if (!(mode & std::ios::in) || !opened)

            return EOF;

        // Josuttis' implementation of inbuf

        int n_putback = gptr() - eback();

        if (n_putback > 4)

            n_putback = 4;

        memcpy(buffer + (4 - n_putback), gptr() - n_putback, n_putback);

        int num = gzread(file, buffer + 4, bufferSize - 4);

        if (num <= 0) // ERROR or EOF

            return EOF;

        // reset buffer pointers

        setg(buffer + (4 - n_putback),   // beginning of putback area

             buffer + 4,                 // read position

             buffer + 4 + num);          // end of buffer

        // return next character

        return *reinterpret_cast<unsigned char *>( gptr());

    }

    virtual int sync() {

        // Changed to use flush_buffer() instead of overflow( EOF)

        // which caused improper behavior with std::endl and flush(),

        // bug reported by Vincent Ricard.

        if (pptr() && pptr() > pbase()) {

            if (flush_buffer() == EOF)

                return -1;

        }

        return 0;

    }

};

class gzstreambase : virtual public std::ios {

protected:

    gzstreambuf buf;

public:

    gzstreambase() { init(&buf); }

    gzstreambase(const char *name, int open_mode) {

        init(&buf);

        open(name, open_mode);

    }

    ~gzstreambase() {

        buf.close();

    }

    void open(const char *name, int open_mode) {

        if (!buf.open(name, open_mode))

            clear(rdstate() | std::ios::badbit);

    }

    void close() {

        if (buf.is_open()) if (!buf.close())

            clear(rdstate() | std::ios::badbit);

    }

    gzstreambuf *rdbuf() { return &buf; }

};

// User classes. Use igzstream and ogzstream analogously to ifstream and

// ofstream respectively. They read and write files based on the gz* 

// function interface of the zlib. Files are compatible with gzip compression.

class igzstream : public gzstreambase, public std::istream {

public:

    igzstream() : std::istream(&buf) { }

    igzstream(const char *name, int open_mode = std::ios::in)

            : gzstreambase(name, open_mode), std::istream(&buf) { }

    gzstreambuf *rdbuf() { return gzstreambase::rdbuf(); }

    void open(const char *name, int open_mode = std::ios::in) {

        gzstreambase::open(name, open_mode);

    }

};

class ogzstream : public gzstreambase, public std::ostream {

public:

    ogzstream() : std::ostream(&buf) { }

    ogzstream(const char *name, int mode = std::ios::out)

            : gzstreambase(name, mode), std::ostream(&buf) { }

    gzstreambuf *rdbuf() { return gzstreambase::rdbuf(); }

    void open(const char *name, int open_mode = std::ios::out) {

        gzstreambase::open(name, open_mode);

    }

};

#endif

[cxx]

  cppflags = -DXXH_NAMESPACE=ZSTD_ -DZSTD_LEGACY_SUPPORT=4

  cflags = -Wall -Wextra -Wcast-qual -Wcast-align -Wshadow -Wstrict-aliasing=1 -Wswitch-enum -Wdeclaration-after-statement -Wstrict-prototypes -Wundef -Wpointer-arith

  cxxppflags = -DXXH_NAMESPACE=ZSTD_ -DZSTD_LEGACY_SUPPORT=4

  cxxflags = -std=c++11 -Wno-deprecated-declarations

  gtest_dep = //contrib/pzstd:gtest

[httpserver]

  port = 0

c8dec2e8da52d483f6dd7c6cd2ad694e8e6fed2b

version: 2

references:

  # Install the dependencies required for tests.

  # Add the step "- *install-dependencies" to the beginning of your job to run

  # this command.

  install-dependencies: &install-dependencies

    run:

      name: Install dependencies

      # TODO: We can split these dependencies up by job to reduce installation

      # time.

      command: |

        sudo dpkg --add-architecture i386

        sudo apt-get -y -qq update

        sudo apt-get -y install \

            gcc-multilib-powerpc-linux-gnu gcc-arm-linux-gnueabi \

            libc6-dev-armel-cross gcc-aarch64-linux-gnu libc6-dev-arm64-cross \

            libc6-dev-ppc64-powerpc-cross zstd gzip coreutils \

            libcurl4-openssl-dev

jobs:

  # the first half of the jobs are in this test

  short-tests-0:

    # TODO: Create a small custom docker image with all the dependencies we need

    #       preinstalled to reduce installation time.

    docker:

      - image: circleci/buildpack-deps:bionic

    steps:

      - checkout

      - *install-dependencies

      - run:

          name: Test

          command: |

            cc -v; CFLAGS="-O0 -Werror" make all && make clean

            make c99build         ; make clean

            make c11build         ; make clean

            make aarch64build     ; make clean

            make -j regressiontest; make clean

            make shortest         ; make clean

            make cxxtest          ; make clean

  # the second half of the jobs are in this test

  short-tests-1:

    docker:

      - image: circleci/buildpack-deps:bionic

    steps:

      - checkout

      - *install-dependencies

      - run:

          name: Test

          command: |

            make gnu90build; make clean

            make gnu99build; make clean

            make ppc64build; make clean

            make ppcbuild  ; make clean

            make armbuild  ; make clean

            make -C tests test-legacy test-longmatch test-symbols; make clean

            make -C lib libzstd-nomt; make clean

  # This step is only run on release tags.

  # It publishes the source tarball as artifacts and if the GITHUB_TOKEN

  # environment variable is set it will publish the source tarball to the

  # tagged release.

  publish-github-release:

    docker:

      - image: circleci/buildpack-deps:bionic

    environment:

      CIRCLE_ARTIFACTS: /tmp/circleci-artifacts

    steps:

      - checkout

      - *install-dependencies

      - run:

          name: Publish

          command: |

            export VERSION=$(echo $CIRCLE_TAG | tail -c +2)

            export ZSTD_VERSION=zstd-$VERSION

            git archive $CIRCLE_TAG --prefix $ZSTD_VERSION/ --format tar \

                        -o $ZSTD_VERSION.tar

            sha256sum $ZSTD_VERSION.tar > $ZSTD_VERSION.tar.sha256

            zstd -19 $ZSTD_VERSION.tar

            sha256sum $ZSTD_VERSION.tar.zst > $ZSTD_VERSION.tar.zst.sha256

            gzip -k -9 $ZSTD_VERSION.tar

            sha256sum $ZSTD_VERSION.tar.gz > $ZSTD_VERSION.tar.gz.sha256

            mkdir -p $CIRCLE_ARTIFACTS

            cp $ZSTD_VERSION.tar* $CIRCLE_ARTIFACTS

      - store_artifacts:

          path: /tmp/circleci-artifacts

  # This step should only be run in a cron job

  regression-test:

    docker:

      - image: circleci/buildpack-deps:bionic

    environment:

      CIRCLE_ARTIFACTS: /tmp/circleci-artifacts

    steps:

      - checkout

      - *install-dependencies

      # Restore the cached resources.

      - restore_cache:

          # We try our best to bust the cache when the data changes by hashing

          # data.c. If that doesn't work, simply update the version number here

          # and below. If we fail to bust the cache, the regression testing will

          # still work, since it has its own stamp, but will need to redownload

          # everything.

          keys:

            - regression-cache-{{ checksum "tests/regression/data.c" }}-v0

      - run:

          name: Regression Test

          command: |

            make -C programs zstd

            make -C tests/regression test

            mkdir -p $CIRCLE_ARTIFACTS

            ./tests/regression/test                     \

                --cache  tests/regression/cache         \

                --output $CIRCLE_ARTIFACTS/results.csv  \

                --zstd   programs/zstd

            echo "NOTE: The new results.csv is uploaded as an artifact to this job"

            echo "      If this fails, go to the Artifacts pane in CircleCI, "

            echo "      download /tmp/circleci-artifacts/results.csv, and if they "

            echo "      are still good, copy it into the repo and commit it."

            echo "> diff tests/regression/results.csv $CIRCLE_ARTIFACTS/results.csv"

            diff tests/regression/results.csv $CIRCLE_ARTIFACTS/results.csv

      # Only save the cache on success (default), since if the failure happened

      # before we stamp the data cache, we will have a bad cache for this key.

      - save_cache:

          key: regression-cache-{{ checksum "tests/regression/data.c" }}-v0

          paths:

            - tests/regression/cache

      - store_artifacts:

          path: /tmp/circleci-artifacts

workflows:

  version: 2

  commit:

    jobs:

      # Run the tests in parallel

      - short-tests-0:

          filters:

            tags:

              only: /.*/

      - short-tests-1:

          filters:

            tags:

              only: /.*/

      # Create a branch called regression and set it to dev to force a

      # regression test run

      - regression-test:

          filters:

            branches:

              only:

                - regression

      # Only run on release tags.

      - publish-github-release:

          requires:

            - short-tests-0

            - short-tests-1

          filters:

            branches:

              ignore: /.*/

            tags:

              only: /^v\d+\.\d+\.\d+$/

  nightly:

    triggers:

      - schedule:

          cron: "0 0 * * *"

          filters:

            branches:

              only:

                - master

                - dev

    jobs:

      # Run daily long regression tests

      - regression-test

  # Longer tests

    #- make -C tests test-zstd-nolegacy && make clean

    #- pyenv global 3.4.4; make -C tests versionsTest && make clean

    #- make zlibwrapper         && make clean

    #- gcc -v; make -C tests test32 MOREFLAGS="-I/usr/include/x86_64-linux-gnu" && make clean

    #- make uasan               && make clean

    #- make asan32              && make clean

    #- make -C tests test32 CC=clang MOREFLAGS="-g -fsanitize=address -I/usr/include/x86_64-linux-gnu"

  # Valgrind tests

    #- CFLAGS="-O1 -g" make -C zlibWrapper valgrindTest && make clean

    #- make -C tests valgrindTest && make clean

  # ARM, AArch64, PowerPC, PowerPC64 tests

    #- make ppctest             && make clean

    #- make ppc64test           && make clean

    #- make armtest             && make clean

    #- make aarch64test         && make clean

# Set the default behavior

* text eol=lf

# Explicitly declare source files

*.c text eol=lf

*.h text eol=lf

# Denote files that should not be modified.

*.odt binary

*.png binary

# Visual Studio

*.sln text eol=crlf

*.vcxproj* text eol=crlf

*.vcproj* text eol=crlf

*.suo binary

*.rc text eol=crlf

# Windows

*.bat text eol=crlf

*.cmd text eol=crlf