diff --git a/3party/bsdiff-courgette/CMakeLists.txt b/3party/bsdiff-courgette/CMakeLists.txt new file mode 100644 index 0000000000..d2e13fb5f1 --- /dev/null +++ b/3party/bsdiff-courgette/CMakeLists.txt @@ -0,0 +1,22 @@ +project(bsdiff) + +set(CMAKE_PREFIX_PATH ./) + +add_clang_compile_options("-Wno-shorten-64-to-32") + +include_directories(bsdiff divsufsort) + +set( + SRC + bsdiff/bsdiff.h + bsdiff/bsdiff_common.h + bsdiff/bsdiff_search.h + bsdiff/paged_array.h + divsufsort/divsufsort.cc + divsufsort/divsufsort.h + divsufsort/divsufsort_private.h + divsufsort/sssort.cc + divsufsort/trsort.cc +) + +add_library(${PROJECT_NAME} ${SRC}) diff --git a/3party/bsdiff-courgette/bsdiff/bsdiff.h b/3party/bsdiff-courgette/bsdiff/bsdiff.h index c1d26c728a..cce2a4420a 100644 --- a/3party/bsdiff-courgette/bsdiff/bsdiff.h +++ b/3party/bsdiff-courgette/bsdiff/bsdiff.h @@ -35,6 +35,33 @@ // 2013-04-10 - Added wrapper to apply a patch directly to files. // --Joshua Pawlicki +// Changelog for bsdiff_apply: +// 2009-03-31 - Change to use Streams. Move CRC code to crc.{h,cc} +// --Stephen Adams +// 2013-04-10 - Add wrapper method to apply a patch to files directly. +// --Joshua Pawlicki + +// Changelog for bsdiff_create: +// 2005-05-05 - Use the modified header struct from bspatch.h; use 32-bit +// values throughout. +// --Benjamin Smedberg +// 2005-05-18 - Use the same CRC algorithm as bzip2, and leverage the CRC table +// provided by libbz2. +// --Darin Fisher +// 2007-11-14 - Changed to use Crc from Lzma library instead of Bzip library +// --Rahul Kuchhal +// 2009-03-31 - Change to use Streams. Added lots of comments. +// --Stephen Adams +// 2010-05-26 - Use a paged array for V and I. The address space may be too +// fragmented for these big arrays to be contiguous. +// --Stephen Adams +// 2015-08-03 - Extract qsufsort portion to a separate file. +// --Samuel Huang +// 2015-08-12 - Interface change to search(). +// --Samuel Huang +// 2016-07-29 - Replacing qsufsort with divsufsort. +// --Samuel Huang + // Copyright 2016 The Chromium Authors. All rights reserved. // Use of this source code is governed by a BSD-style license that can be // found in the LICENSE file. @@ -42,66 +69,427 @@ #ifndef COURGETTE_THIRD_PARTY_BSDIFF_BSDIFF_H_ #define COURGETTE_THIRD_PARTY_BSDIFF_BSDIFF_H_ -#include +#include "coding/varint.hpp" +#include "coding/writer.hpp" -#include "base/files/file.h" -#include "base/files/file_util.h" +#include "base/checked_cast.hpp" +#include "base/logging.hpp" +#include "base/string_utils.hpp" +#include "base/timer.hpp" -namespace courgette { -class SourceStream; -class SinkStream; -} // namespace courgette +#include +#include +#include +#include + +#include "3party/bsdiff-courgette/bsdiff/bsdiff_common.h" +#include "3party/bsdiff-courgette/bsdiff/bsdiff_search.h" +#include "3party/bsdiff-courgette/bsdiff/paged_array.h" +#include "3party/bsdiff-courgette/divsufsort/divsufsort.h" + +#include "zlib.h" namespace bsdiff { +// A MemWriter with its own buffer. +struct MemStream { + MemStream(): m_writer(m_buf) {} -enum BSDiffStatus { - OK = 0, - MEM_ERROR = 1, - CRC_ERROR = 2, - READ_ERROR = 3, - UNEXPECTED_ERROR = 4, - WRITE_ERROR = 5 + MemWriter> & GetWriter() { return m_writer; } + size_t const Size() const { return m_buf.size(); } + std::vector const & GetBuf() const { return m_buf; } + +private: + std::vector m_buf; + MemWriter> m_writer; }; +inline uint32_t CalculateCrc(const uint8_t* buffer, size_t size) { + // Calculate Crc by calling CRC method in zlib + const auto size32 = base::checked_cast(size); + const uint32_t crc = base::checked_cast(crc32(0, buffer, size32)); + return ~crc; +} + // Creates a binary patch. -// -BSDiffStatus CreateBinaryPatch(courgette::SourceStream* old_stream, - courgette::SourceStream* new_stream, - courgette::SinkStream* patch_stream); +template +BSDiffStatus CreateBinaryPatch(OldReader & old_reader, + NewReader & new_reader, + PatchSink & patch_sink) { + ReaderSource old_source(old_reader); + ReaderSource new_source(new_reader); + + auto initial_patch_sink_pos = patch_sink.Pos(); + + my::Timer bsdiff_timer; + + std::array mem_streams; + auto & control_stream_copy_counts = mem_streams[0]; + auto & control_stream_extra_counts = mem_streams[1]; + auto & control_stream_seeks = mem_streams[2]; + auto & diff_skips = mem_streams[3]; + auto & diff_bytes = mem_streams[4]; + auto & extra_bytes = mem_streams[5]; + + const int old_size = static_cast(old_source.Size()); + std::vector old_buf(old_size); + old_source.Read(old_buf.data(), old_buf.size()); + const uint8_t * old = old_buf.data(); + + courgette::PagedArray I; + + if (!I.Allocate(old_size + 1)) { + LOG(LERROR, ("Could not allocate I[], ", ((old_size + 1) * sizeof(int)), "bytes")); + return MEM_ERROR; + } + + my::Timer suf_sort_timer; + divsuf::saint_t result = divsuf::divsufsort_include_empty( + old, I.begin(), old_size); + LOG(LINFO, ("Done divsufsort", suf_sort_timer.ElapsedSeconds())); + if (result != 0) + return UNEXPECTED_ERROR; + + const int new_size = static_cast(new_source.Size()); + std::vector new_buf(new_size); + new_source.Read(new_buf.data(), new_buf.size()); + const uint8_t * newbuf = new_buf.data(); + + int control_length = 0; + int diff_bytes_length = 0; + int diff_bytes_nonzero = 0; + int extra_bytes_length = 0; + + // The patch format is a sequence of triples where 'copy' is + // the number of bytes to copy from the old file (possibly with mistakes), + // 'extra' is the number of bytes to copy from a stream of fresh bytes, and + // 'seek' is an offset to move to the position to copy for the next triple. + // + // The invariant at the top of this loop is that we are committed to emitting + // a triple for the part of |newbuf| surrounding a 'seed' match near + // |lastscan|. We are searching for a second match that will be the 'seed' of + // the next triple. As we scan through |newbuf|, one of four things can + // happen at the current position |scan|: + // + // 1. We find a nice match that appears to be consistent with the current + // seed. Continue scanning. It is likely that this match will become + // part of the 'copy'. + // + // 2. We find match which does much better than extending the current seed + // old match. Emit a triple for the current seed and take this match as + // the new seed for a new triple. By 'much better' we remove 8 mismatched + // bytes by taking the new seed. + // + // 3. There is not a good match. Continue scanning. These bytes will likely + // become part of the 'extra'. + // + // 4. There is no match because we reached the end of the input, |newbuf|. + + // This is how the loop advances through the bytes of |newbuf|: + // + // ...012345678901234567890123456789... + // ssssssssss Seed at |lastscan| + // xxyyyxxyyxy |scan| forward, cases (3)(x) & (1)(y) + // mmmmmmmm New match will start new seed case (2). + // fffffffffffffff |lenf| = scan forward from |lastscan| + // bbbb |lenb| = scan back from new seed |scan|. + // ddddddddddddddd Emit diff bytes for the 'copy'. + // xx Emit extra bytes. + // ssssssssssss |lastscan = scan - lenb| is new seed. + // x Cases (1) and (3) .... + + int lastscan = 0, lastpos = 0, lastoffset = 0; + int scan = 0; + SearchResult match(0, 0); + uint32_t pending_diff_zeros = 0; + + while (scan < new_size) { + int oldscore = 0; // Count of how many bytes of the current match at |scan| + // extend the match at |lastscan|. + match.pos = 0; + + scan += match.size; + for (int scsc = scan; scan < new_size; ++scan) { + match = search&>( + I, old, old_size, newbuf + scan, new_size - scan); + + for (; scsc < scan + match.size; scsc++) + if ((scsc + lastoffset < old_size) && + (old[scsc + lastoffset] == newbuf[scsc])) + oldscore++; + + if ((match.size == oldscore) && (match.size != 0)) + break; // Good continuing match, case (1) + if (match.size > oldscore + 8) + break; // New seed match, case (2) + + if ((scan + lastoffset < old_size) && + (old[scan + lastoffset] == newbuf[scan])) + oldscore--; + // Case (3) continues in this loop until we fall out of the loop (4). + } + + if ((match.size != oldscore) || (scan == new_size)) { // Cases (2) and (4) + // This next chunk of code finds the boundary between the bytes to be + // copied as part of the current triple, and the bytes to be copied as + // part of the next triple. The |lastscan| match is extended forwards as + // far as possible provided doing to does not add too many mistakes. The + // |scan| match is extended backwards in a similar way. + + // Extend the current match (if any) backwards. |lenb| is the maximal + // extension for which less than half the byte positions in the extension + // are wrong. + int lenb = 0; + if (scan < new_size) { // i.e. not case (4); there is a match to extend. + int score = 0, Sb = 0; + for (int i = 1; (scan >= lastscan + i) && (match.pos >= i); i++) { + if (old[match.pos - i] == newbuf[scan - i]) + score++; + if (score * 2 - i > Sb * 2 - lenb) { + Sb = score; + lenb = i; + } + } + } + + // Extend the lastscan match forward; |lenf| is the maximal extension for + // which less than half of the byte positions in entire lastscan match are + // wrong. There is a subtle point here: |lastscan| points to before the + // seed match by |lenb| bytes from the previous iteration. This is why + // the loop measures the total number of mistakes in the the match, not + // just the from the match. + int lenf = 0; + { + int score = 0, Sf = 0; + for (int i = 0; (lastscan + i < scan) && (lastpos + i < old_size);) { + if (old[lastpos + i] == newbuf[lastscan + i]) + score++; + i++; + if (score * 2 - i > Sf * 2 - lenf) { + Sf = score; + lenf = i; + } + } + } + + // If the extended scans overlap, pick a position in the overlap region + // that maximizes the exact matching bytes. + if (lastscan + lenf > scan - lenb) { + int overlap = (lastscan + lenf) - (scan - lenb); + int score = 0; + int Ss = 0, lens = 0; + for (int i = 0; i < overlap; i++) { + if (newbuf[lastscan + lenf - overlap + i] == + old[lastpos + lenf - overlap + i]) { + score++; + } + if (newbuf[scan - lenb + i] == old[match.pos - lenb + i]) { + score--; + } + if (score > Ss) { + Ss = score; + lens = i + 1; + } + } + + lenf += lens - overlap; + lenb -= lens; + }; + + for (int i = 0; i < lenf; i++) { + uint8_t diff_byte = newbuf[lastscan + i] - old[lastpos + i]; + if (diff_byte) { + ++diff_bytes_nonzero; + WriteVarUint(diff_skips.GetWriter(), pending_diff_zeros); + pending_diff_zeros = 0; + diff_bytes.GetWriter().Write(&diff_byte, 1); + } else { + ++pending_diff_zeros; + } + } + int gap = (scan - lenb) - (lastscan + lenf); + for (int i = 0; i < gap; i++) { + extra_bytes.GetWriter().Write(&newbuf[lastscan + lenf + i], 1); + } + + diff_bytes_length += lenf; + extra_bytes_length += gap; + + uint32_t copy_count = lenf; + uint32_t extra_count = gap; + int32_t seek_adjustment = ((match.pos - lenb) - (lastpos + lenf)); + + WriteVarUint(control_stream_copy_counts.GetWriter(), copy_count); + WriteVarUint(control_stream_extra_counts.GetWriter(), extra_count); + WriteVarInt(control_stream_seeks.GetWriter(), seek_adjustment); + + ++control_length; + +#ifdef DEBUG_bsmedberg + LOG(LDEBUG, ("Writing a block: copy:", copy_count, "extra:", extra_count, "seek:", seek_adjustment)); +#endif + + lastscan = scan - lenb; // Include the backward extension in seed. + lastpos = match.pos - lenb; // ditto. + lastoffset = lastpos - lastscan; + } + } + + WriteVarUint(diff_skips.GetWriter(), pending_diff_zeros); + + I.clear(); + + MBSPatchHeader header; + // The string will have a null terminator that we don't use, hence '-1'. + static_assert(sizeof(MBS_PATCH_HEADER_TAG) - 1 == sizeof(header.tag), + "MBS_PATCH_HEADER_TAG must match header field size"); + memcpy(header.tag, MBS_PATCH_HEADER_TAG, sizeof(header.tag)); + header.slen = old_size; + header.scrc32 = CalculateCrc(old, old_size); + header.dlen = new_size; + + WriteHeader(patch_sink, &header); + for (auto const & s : mem_streams) + { + uint32_t const sz = base::checked_cast(s.Size()); + WriteToSink(patch_sink, sz); + } + + for (auto const & s : mem_streams) + patch_sink.Write(s.GetBuf().data(), s.GetBuf().size()); + + size_t diff_skips_length = diff_skips.Size(); + + std::ostringstream log_stream; + log_stream << "Control tuples: " << control_length + << " copy bytes: " << diff_bytes_length + << " mistakes: " << diff_bytes_nonzero + << " (skips: " << diff_skips_length << ")" + << " extra bytes: " << extra_bytes_length + << "\nUncompressed bsdiff patch size " + << patch_sink.Pos() - initial_patch_sink_pos + << "\nEnd bsdiff " + << bsdiff_timer.ElapsedSeconds(); + + LOG(LINFO, (log_stream.str())); + + return OK; +} // Applies the given patch file to a given source file. This method validates // the CRC of the original file stored in the patch file, before applying the // patch to it. -// -BSDiffStatus ApplyBinaryPatch(courgette::SourceStream* old_stream, - courgette::SourceStream* patch_stream, - courgette::SinkStream* new_stream); +template +BSDiffStatus ApplyBinaryPatch(OldReader & old_reader, + NewSink & new_sink, + PatchReader & patch_reader) { + ReaderSource old_source(old_reader); + ReaderSource patch_source(patch_reader); -// As above, but simply takes base::Files. -BSDiffStatus ApplyBinaryPatch(base::File old_stream, - base::File patch_stream, - base::File new_stream); + MBSPatchHeader header; + BSDiffStatus ret = MBS_ReadHeader(patch_source, &header); + if (ret != OK) + return ret; -// As above, but simply takes the file paths. -BSDiffStatus ApplyBinaryPatch(const base::FilePath& old_stream, - const base::FilePath& patch_stream, - const base::FilePath& new_stream); + const size_t old_size = old_source.Size(); + std::vector old_buf(old_size); + old_source.Read(old_buf.data(), old_buf.size()); -// The following declarations are common to the patch-creation and -// patch-application code. + const uint8_t* old_start = old_buf.data(); + const uint8_t* old_end = old_buf.data() + old_buf.size(); + const uint8_t* old_position = old_start; -// The patch stream starts with a MBSPatchHeader. -typedef struct MBSPatchHeader_ { - char tag[8]; // Contains MBS_PATCH_HEADER_TAG. - uint32_t slen; // Length of the file to be patched. - uint32_t scrc32; // CRC32 of the file to be patched. - uint32_t dlen; // Length of the result file. -} MBSPatchHeader; + if (old_size != header.slen) + return UNEXPECTED_ERROR; -// This is the value for the tag field. Must match length exactly, not counting -// null at end of string. -#define MBS_PATCH_HEADER_TAG "GBSDIF42" + if (CalculateCrc(old_start, old_size) != header.scrc32) + return CRC_ERROR; + vector stream_sizes(kNumStreams); + for (auto & s : stream_sizes) + s = ReadPrimitiveFromSource(patch_source); + + std::vector> patch_streams; + patch_streams.reserve(kNumStreams); + for (size_t i = 0; i < kNumStreams; ++i) { + uint64_t size = static_cast(stream_sizes[i]); + patch_streams.emplace_back(ReaderSource(patch_source.SubReader(size))); + } + + auto & control_stream_copy_counts = patch_streams[0]; + auto & control_stream_extra_counts = patch_streams[1]; + auto & control_stream_seeks = patch_streams[2]; + auto & diff_skips = patch_streams[3]; + auto & diff_bytes = patch_streams[4]; + auto & extra_bytes = patch_streams[5]; + + std::vector extra_bytes_buf(extra_bytes.Size()); + extra_bytes.Read(extra_bytes_buf.data(), extra_bytes_buf.size()); + + const uint8_t* extra_start = extra_bytes_buf.data(); + const uint8_t* extra_end = extra_bytes_buf.data() + extra_bytes_buf.size(); + const uint8_t* extra_position = extra_start; + +// if (header->dlen && !new_sink->Reserve(header->dlen)) +// return MEM_ERROR; + + auto pending_diff_zeros = ReadVarUint(diff_skips); + + while (control_stream_copy_counts.Size() > 0) { + auto copy_count = ReadVarUint(control_stream_copy_counts); + auto extra_count = ReadVarUint(control_stream_extra_counts); + auto seek_adjustment = ReadVarInt(control_stream_seeks); + +#ifdef DEBUG_bsmedberg + LOG(LDEBUG, ("Applying block: copy:", copy_count, "extra:", extra_count, "seek:", seek_adjustment)); +#endif + + // Byte-wise arithmetically add bytes from old file to bytes from the diff + // block. + if (copy_count > static_cast(old_end - old_position)) + return UNEXPECTED_ERROR; + + // Add together bytes from the 'old' file and the 'diff' stream. + for (size_t i = 0; i < copy_count; ++i) { + uint8_t diff_byte = 0; + if (pending_diff_zeros) { + --pending_diff_zeros; + } else { + pending_diff_zeros = ReadVarUint(diff_skips); + diff_byte = ReadPrimitiveFromSource(diff_bytes); + } + uint8_t byte = old_position[i] + diff_byte; + WriteToSink(new_sink, byte); + } + old_position += copy_count; + + // Copy bytes from the extra block. + if (extra_count > static_cast(extra_end - extra_position)) + return UNEXPECTED_ERROR; + + new_sink.Write(extra_position, extra_count); + + extra_position += extra_count; + + // "seek" forwards (or backwards) in oldfile. + if (old_position + seek_adjustment < old_start || + old_position + seek_adjustment > old_end) + return UNEXPECTED_ERROR; + + old_position += seek_adjustment; + } + + if (control_stream_copy_counts.Size() > 0 || + control_stream_extra_counts.Size() > 0 || + control_stream_seeks.Size() > 0 || + diff_skips.Size() > 0 || + diff_bytes.Size() > 0 || + extra_bytes.Size() > 0) + { + return UNEXPECTED_ERROR; + } + + return OK; +} } // namespace bsdiff #endif // COURGETTE_THIRD_PARTY_BSDIFF_BSDIFF_H_ diff --git a/3party/bsdiff-courgette/bsdiff/bsdiff_apply.cc b/3party/bsdiff-courgette/bsdiff/bsdiff_apply.cc deleted file mode 100644 index ab7b623e9d..0000000000 --- a/3party/bsdiff-courgette/bsdiff/bsdiff_apply.cc +++ /dev/null @@ -1,249 +0,0 @@ -// Copyright 2003, 2004 Colin Percival -// All rights reserved -// -// Redistribution and use in source and binary forms, with or without -// modification, are permitted providing that the following conditions -// are met: -// 1. Redistributions of source code must retain the above copyright -// notice, this list of conditions and the following disclaimer. -// 2. Redistributions in binary form must reproduce the above copyright -// notice, this list of conditions and the following disclaimer in the -// documentation and/or other materials provided with the distribution. -// -// THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR -// IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED -// WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE -// ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY -// DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL -// DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS -// OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) -// HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, -// STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING -// IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE -// POSSIBILITY OF SUCH DAMAGE. -// -// For the terms under which this work may be distributed, please see -// the adjoining file "LICENSE". -// -// ChangeLog: -// 2009-03-31 - Change to use Streams. Move CRC code to crc.{h,cc} -// --Stephen Adams -// 2013-04-10 - Add wrapper method to apply a patch to files directly. -// --Joshua Pawlicki - -// Copyright (c) 2009 The Chromium Authors. All rights reserved. -// Use of this source code is governed by a BSD-style license that can be -// found in the LICENSE file. - -#include "courgette/third_party/bsdiff/bsdiff.h" - -#include -#include - -#include "base/files/file_util.h" -#include "base/files/memory_mapped_file.h" -#include "courgette/crc.h" -#include "courgette/streams.h" - -namespace { - -using courgette::CalculateCrc; -using courgette::SinkStream; -using courgette::SinkStreamSet; -using courgette::SourceStream; -using courgette::SourceStreamSet; - -} // namespace - -namespace bsdiff { - -BSDiffStatus MBS_ReadHeader(SourceStream* stream, MBSPatchHeader* header) { - if (!stream->Read(header->tag, sizeof(header->tag))) - return READ_ERROR; - if (!stream->ReadVarint32(&header->slen)) - return READ_ERROR; - if (!stream->ReadVarint32(&header->scrc32)) - return READ_ERROR; - if (!stream->ReadVarint32(&header->dlen)) - return READ_ERROR; - - // The string will have a NUL terminator that we don't use, hence '-1'. - static_assert(sizeof(MBS_PATCH_HEADER_TAG) - 1 == sizeof(header->tag), - "MBS_PATCH_HEADER_TAG must match header field size"); - if (memcmp(header->tag, MBS_PATCH_HEADER_TAG, 8) != 0) - return UNEXPECTED_ERROR; - - return OK; -} - -BSDiffStatus MBS_ApplyPatch(const MBSPatchHeader* header, - SourceStream* patch_stream, - const uint8_t* old_start, - size_t old_size, - SinkStream* new_stream) { - const uint8_t* old_end = old_start + old_size; - - SourceStreamSet patch_streams; - if (!patch_streams.Init(patch_stream)) - return READ_ERROR; - - SourceStream* control_stream_copy_counts = patch_streams.stream(0); - SourceStream* control_stream_extra_counts = patch_streams.stream(1); - SourceStream* control_stream_seeks = patch_streams.stream(2); - SourceStream* diff_skips = patch_streams.stream(3); - SourceStream* diff_bytes = patch_streams.stream(4); - SourceStream* extra_bytes = patch_streams.stream(5); - - const uint8_t* extra_start = extra_bytes->Buffer(); - const uint8_t* extra_end = extra_start + extra_bytes->Remaining(); - const uint8_t* extra_position = extra_start; - extra_bytes->Skip(extra_bytes->Remaining()); - - const uint8_t* old_position = old_start; - - if (header->dlen && !new_stream->Reserve(header->dlen)) - return MEM_ERROR; - - uint32_t pending_diff_zeros = 0; - if (!diff_skips->ReadVarint32(&pending_diff_zeros)) - return UNEXPECTED_ERROR; - - while (!control_stream_copy_counts->Empty()) { - uint32_t copy_count, extra_count; - int32_t seek_adjustment; - if (!control_stream_copy_counts->ReadVarint32(©_count)) - return UNEXPECTED_ERROR; - if (!control_stream_extra_counts->ReadVarint32(&extra_count)) - return UNEXPECTED_ERROR; - if (!control_stream_seeks->ReadVarint32Signed(&seek_adjustment)) - return UNEXPECTED_ERROR; - -#ifdef DEBUG_bsmedberg - printf("Applying block: copy: %-8u extra: %-8u seek: %+i\n", copy_count, - extra_count, seek_adjustment); -#endif - // Byte-wise arithmetically add bytes from old file to bytes from the diff - // block. - if (copy_count > static_cast(old_end - old_position)) - return UNEXPECTED_ERROR; - - // Add together bytes from the 'old' file and the 'diff' stream. - for (size_t i = 0; i < copy_count; ++i) { - uint8_t diff_byte = 0; - if (pending_diff_zeros) { - --pending_diff_zeros; - } else { - if (!diff_skips->ReadVarint32(&pending_diff_zeros)) - return UNEXPECTED_ERROR; - if (!diff_bytes->Read(&diff_byte, 1)) - return UNEXPECTED_ERROR; - } - uint8_t byte = old_position[i] + diff_byte; - if (!new_stream->Write(&byte, 1)) - return MEM_ERROR; - } - old_position += copy_count; - - // Copy bytes from the extra block. - if (extra_count > static_cast(extra_end - extra_position)) - return UNEXPECTED_ERROR; - - if (!new_stream->Write(extra_position, extra_count)) - return MEM_ERROR; - - extra_position += extra_count; - - // "seek" forwards (or backwards) in oldfile. - if (old_position + seek_adjustment < old_start || - old_position + seek_adjustment > old_end) - return UNEXPECTED_ERROR; - - old_position += seek_adjustment; - } - - if (!control_stream_copy_counts->Empty() || - !control_stream_extra_counts->Empty() || !control_stream_seeks->Empty() || - !diff_skips->Empty() || !diff_bytes->Empty() || !extra_bytes->Empty()) - return UNEXPECTED_ERROR; - - return OK; -} - -BSDiffStatus ApplyBinaryPatch(SourceStream* old_stream, - SourceStream* patch_stream, - SinkStream* new_stream) { - MBSPatchHeader header; - BSDiffStatus ret = MBS_ReadHeader(patch_stream, &header); - if (ret != OK) - return ret; - - const uint8_t* old_start = old_stream->Buffer(); - size_t old_size = old_stream->Remaining(); - - if (old_size != header.slen) - return UNEXPECTED_ERROR; - - if (CalculateCrc(old_start, old_size) != header.scrc32) - return CRC_ERROR; - - return MBS_ApplyPatch(&header, patch_stream, old_start, old_size, new_stream); -} - -BSDiffStatus ApplyBinaryPatch(base::File old_file, - base::File patch_file, - base::File new_file) { - // Set up the old stream. - base::MemoryMappedFile old_file_mem; - if (!old_file_mem.Initialize(std::move(old_file))) { - return READ_ERROR; - } - SourceStream old_file_stream; - old_file_stream.Init(old_file_mem.data(), old_file_mem.length()); - - // Set up the patch stream. - base::MemoryMappedFile patch_file_mem; - if (!patch_file_mem.Initialize(std::move(patch_file))) { - return READ_ERROR; - } - SourceStream patch_file_stream; - patch_file_stream.Init(patch_file_mem.data(), patch_file_mem.length()); - - // Set up the new stream and apply the patch. - SinkStream new_sink_stream; - BSDiffStatus status = - ApplyBinaryPatch(&old_file_stream, &patch_file_stream, &new_sink_stream); - if (status != OK) { - return status; - } - - // Write the stream to disk. - int written = new_file.Write( - 0, - reinterpret_cast(new_sink_stream.Buffer()), - static_cast(new_sink_stream.Length())); - if (written != static_cast(new_sink_stream.Length())) - return WRITE_ERROR; - return OK; -} - -BSDiffStatus ApplyBinaryPatch(const base::FilePath& old_file_path, - const base::FilePath& patch_file_path, - const base::FilePath& new_file_path) { - BSDiffStatus result = ApplyBinaryPatch( - base::File( - old_file_path, - base::File::FLAG_OPEN | base::File::FLAG_READ), - base::File( - patch_file_path, - base::File::FLAG_OPEN | base::File::FLAG_READ), - base::File( - new_file_path, - base::File::FLAG_CREATE_ALWAYS | - base::File::FLAG_WRITE | - base::File::FLAG_EXCLUSIVE_WRITE)); - if (result != OK) - base::DeleteFile(new_file_path, false); - return result; -} - -} // namespace bsdiff diff --git a/3party/bsdiff-courgette/bsdiff/bsdiff_common.h b/3party/bsdiff-courgette/bsdiff/bsdiff_common.h new file mode 100644 index 0000000000..a1aeecbf07 --- /dev/null +++ b/3party/bsdiff-courgette/bsdiff/bsdiff_common.h @@ -0,0 +1,73 @@ +#ifndef COURGETTE_THIRD_PARTY_BSDIFF_BSDIFF_HEADER_H_ +#define COURGETTE_THIRD_PARTY_BSDIFF_BSDIFF_HEADER_H_ + +#include "coding/reader.hpp" +#include "coding/varint.hpp" + +#include + +namespace bsdiff { +// The following declarations are common to the patch-creation and +// patch-application code. + +int constexpr kNumStreams = 6; + +enum BSDiffStatus { + OK = 0, + MEM_ERROR = 1, + CRC_ERROR = 2, + READ_ERROR = 3, + UNEXPECTED_ERROR = 4, + WRITE_ERROR = 5 +}; + +// The patch stream starts with a MBSPatchHeader. +typedef struct MBSPatchHeader_ { + char tag[8]; // Contains MBS_PATCH_HEADER_TAG. + uint32_t slen; // Length of the file to be patched. + uint32_t scrc32; // CRC32 of the file to be patched. + uint32_t dlen; // Length of the result file. +} MBSPatchHeader; + +// This is the value for the tag field. Must match length exactly, not counting +// null at end of string. +#define MBS_PATCH_HEADER_TAG "GBSDIF42" + +template +void WriteHeader(Sink & sink, MBSPatchHeader* header) { + sink.Write(header->tag, sizeof(header->tag)); + WriteVarUint(sink, header->slen); + WriteVarUint(sink, header->scrc32); + WriteVarUint(sink, header->dlen); +} + +template +BSDiffStatus MBS_ReadHeader(Source & src, MBSPatchHeader* header) { + src.Read(header->tag, sizeof(header->tag)); + header->slen = ReadVarUint(src); + header->scrc32 = ReadVarUint(src); + header->dlen = ReadVarUint(src); + + // The string will have a NUL terminator that we don't use, hence '-1'. + static_assert(sizeof(MBS_PATCH_HEADER_TAG) - 1 == sizeof(header->tag), + "MBS_PATCH_HEADER_TAG must match header field size"); + if (memcmp(header->tag, MBS_PATCH_HEADER_TAG, 8) != 0) + return UNEXPECTED_ERROR; + + return OK; +} + +std::string DebugPrint(BSDiffStatus status) { + switch (status) { + case OK: return "OK"; + case MEM_ERROR: return "MEM_ERROR"; + case CRC_ERROR: return "CRC_ERROR"; + case READ_ERROR: return "READ_ERROR"; + case UNEXPECTED_ERROR: return "UNEXPECTED_ERROR"; + case WRITE_ERROR: return "WRITE_ERROR"; + } + return "Unknown status"; +} +} // namespace bsdiff + +#endif // COURGETTE_THIRD_PARTY_BSDIFF_BSDIFF_HEADER_H_ diff --git a/3party/bsdiff-courgette/bsdiff/bsdiff_create.cc b/3party/bsdiff-courgette/bsdiff/bsdiff_create.cc deleted file mode 100644 index 289476f360..0000000000 --- a/3party/bsdiff-courgette/bsdiff/bsdiff_create.cc +++ /dev/null @@ -1,351 +0,0 @@ -// Copyright 2003, 2004 Colin Percival -// All rights reserved -// -// Redistribution and use in source and binary forms, with or without -// modification, are permitted providing that the following conditions -// are met: -// 1. Redistributions of source code must retain the above copyright -// notice, this list of conditions and the following disclaimer. -// 2. Redistributions in binary form must reproduce the above copyright -// notice, this list of conditions and the following disclaimer in the -// documentation and/or other materials provided with the distribution. -// -// THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR -// IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED -// WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE -// ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY -// DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL -// DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS -// OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) -// HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, -// STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING -// IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE -// POSSIBILITY OF SUCH DAMAGE. -// -// For the terms under which this work may be distributed, please see -// the adjoining file "LICENSE". -// -// ChangeLog: -// 2005-05-05 - Use the modified header struct from bspatch.h; use 32-bit -// values throughout. -// --Benjamin Smedberg -// 2005-05-18 - Use the same CRC algorithm as bzip2, and leverage the CRC table -// provided by libbz2. -// --Darin Fisher -// 2007-11-14 - Changed to use Crc from Lzma library instead of Bzip library -// --Rahul Kuchhal -// 2009-03-31 - Change to use Streams. Added lots of comments. -// --Stephen Adams -// 2010-05-26 - Use a paged array for V and I. The address space may be too -// fragmented for these big arrays to be contiguous. -// --Stephen Adams -// 2015-08-03 - Extract qsufsort portion to a separate file. -// --Samuel Huang -// 2015-08-12 - Interface change to search(). -// --Samuel Huang -// 2016-07-29 - Replacing qsufsort with divsufsort. -// --Samuel Huang - -// Copyright 2016 The Chromium Authors. All rights reserved. -// Use of this source code is governed by a BSD-style license that can be -// found in the LICENSE file. - -#include "courgette/third_party/bsdiff/bsdiff.h" - -#include -#include -#include - -#include - -#include "base/logging.h" -#include "base/strings/string_util.h" -#include "base/time/time.h" - -#include "courgette/crc.h" -#include "courgette/streams.h" -#include "courgette/third_party/bsdiff/bsdiff_search.h" -#include "courgette/third_party/bsdiff/paged_array.h" -#include "courgette/third_party/divsufsort/divsufsort.h" - -namespace { - -using courgette::CalculateCrc; -using courgette::PagedArray; -using courgette::SinkStream; -using courgette::SinkStreamSet; -using courgette::SourceStream; -using courgette::SourceStreamSet; - -} // namespace - -namespace bsdiff { - -static CheckBool WriteHeader(SinkStream* stream, MBSPatchHeader* header) { - bool ok = stream->Write(header->tag, sizeof(header->tag)); - ok &= stream->WriteVarint32(header->slen); - ok &= stream->WriteVarint32(header->scrc32); - ok &= stream->WriteVarint32(header->dlen); - return ok; -} - -BSDiffStatus CreateBinaryPatch(SourceStream* old_stream, - SourceStream* new_stream, - SinkStream* patch_stream) { - base::Time start_bsdiff_time = base::Time::Now(); - VLOG(1) << "Start bsdiff"; - size_t initial_patch_stream_length = patch_stream->Length(); - - SinkStreamSet patch_streams; - SinkStream* control_stream_copy_counts = patch_streams.stream(0); - SinkStream* control_stream_extra_counts = patch_streams.stream(1); - SinkStream* control_stream_seeks = patch_streams.stream(2); - SinkStream* diff_skips = patch_streams.stream(3); - SinkStream* diff_bytes = patch_streams.stream(4); - SinkStream* extra_bytes = patch_streams.stream(5); - - const uint8_t* old = old_stream->Buffer(); - const int oldsize = static_cast(old_stream->Remaining()); - - uint32_t pending_diff_zeros = 0; - - PagedArray I; - - if (!I.Allocate(oldsize + 1)) { - LOG(ERROR) << "Could not allocate I[], " << ((oldsize + 1) * sizeof(int)) - << " bytes"; - return MEM_ERROR; - } - - base::Time q_start_time = base::Time::Now(); - divsuf::saint_t result = divsuf::divsufsort_include_empty( - old, I.begin(), oldsize); - VLOG(1) << " done divsufsort " - << (base::Time::Now() - q_start_time).InSecondsF(); - if (result != 0) - return UNEXPECTED_ERROR; - - const uint8_t* newbuf = new_stream->Buffer(); - const int newsize = static_cast(new_stream->Remaining()); - - int control_length = 0; - int diff_bytes_length = 0; - int diff_bytes_nonzero = 0; - int extra_bytes_length = 0; - - // The patch format is a sequence of triples where 'copy' is - // the number of bytes to copy from the old file (possibly with mistakes), - // 'extra' is the number of bytes to copy from a stream of fresh bytes, and - // 'seek' is an offset to move to the position to copy for the next triple. - // - // The invariant at the top of this loop is that we are committed to emitting - // a triple for the part of |newbuf| surrounding a 'seed' match near - // |lastscan|. We are searching for a second match that will be the 'seed' of - // the next triple. As we scan through |newbuf|, one of four things can - // happen at the current position |scan|: - // - // 1. We find a nice match that appears to be consistent with the current - // seed. Continue scanning. It is likely that this match will become - // part of the 'copy'. - // - // 2. We find match which does much better than extending the current seed - // old match. Emit a triple for the current seed and take this match as - // the new seed for a new triple. By 'much better' we remove 8 mismatched - // bytes by taking the new seed. - // - // 3. There is not a good match. Continue scanning. These bytes will likely - // become part of the 'extra'. - // - // 4. There is no match because we reached the end of the input, |newbuf|. - - // This is how the loop advances through the bytes of |newbuf|: - // - // ...012345678901234567890123456789... - // ssssssssss Seed at |lastscan| - // xxyyyxxyyxy |scan| forward, cases (3)(x) & (1)(y) - // mmmmmmmm New match will start new seed case (2). - // fffffffffffffff |lenf| = scan forward from |lastscan| - // bbbb |lenb| = scan back from new seed |scan|. - // ddddddddddddddd Emit diff bytes for the 'copy'. - // xx Emit extra bytes. - // ssssssssssss |lastscan = scan - lenb| is new seed. - // x Cases (1) and (3) .... - - int lastscan = 0, lastpos = 0, lastoffset = 0; - - int scan = 0; - SearchResult match(0, 0); - - while (scan < newsize) { - int oldscore = 0; // Count of how many bytes of the current match at |scan| - // extend the match at |lastscan|. - match.pos = 0; - - scan += match.size; - for (int scsc = scan; scan < newsize; ++scan) { - match = search&>( - I, old, oldsize, newbuf + scan, newsize - scan); - - for (; scsc < scan + match.size; scsc++) - if ((scsc + lastoffset < oldsize) && - (old[scsc + lastoffset] == newbuf[scsc])) - oldscore++; - - if ((match.size == oldscore) && (match.size != 0)) - break; // Good continuing match, case (1) - if (match.size > oldscore + 8) - break; // New seed match, case (2) - - if ((scan + lastoffset < oldsize) && - (old[scan + lastoffset] == newbuf[scan])) - oldscore--; - // Case (3) continues in this loop until we fall out of the loop (4). - } - - if ((match.size != oldscore) || (scan == newsize)) { // Cases (2) and (4) - // This next chunk of code finds the boundary between the bytes to be - // copied as part of the current triple, and the bytes to be copied as - // part of the next triple. The |lastscan| match is extended forwards as - // far as possible provided doing to does not add too many mistakes. The - // |scan| match is extended backwards in a similar way. - - // Extend the current match (if any) backwards. |lenb| is the maximal - // extension for which less than half the byte positions in the extension - // are wrong. - int lenb = 0; - if (scan < newsize) { // i.e. not case (4); there is a match to extend. - int score = 0, Sb = 0; - for (int i = 1; (scan >= lastscan + i) && (match.pos >= i); i++) { - if (old[match.pos - i] == newbuf[scan - i]) - score++; - if (score * 2 - i > Sb * 2 - lenb) { - Sb = score; - lenb = i; - } - } - } - - // Extend the lastscan match forward; |lenf| is the maximal extension for - // which less than half of the byte positions in entire lastscan match are - // wrong. There is a subtle point here: |lastscan| points to before the - // seed match by |lenb| bytes from the previous iteration. This is why - // the loop measures the total number of mistakes in the the match, not - // just the from the match. - int lenf = 0; - { - int score = 0, Sf = 0; - for (int i = 0; (lastscan + i < scan) && (lastpos + i < oldsize);) { - if (old[lastpos + i] == newbuf[lastscan + i]) - score++; - i++; - if (score * 2 - i > Sf * 2 - lenf) { - Sf = score; - lenf = i; - } - } - } - - // If the extended scans overlap, pick a position in the overlap region - // that maximizes the exact matching bytes. - if (lastscan + lenf > scan - lenb) { - int overlap = (lastscan + lenf) - (scan - lenb); - int score = 0; - int Ss = 0, lens = 0; - for (int i = 0; i < overlap; i++) { - if (newbuf[lastscan + lenf - overlap + i] == - old[lastpos + lenf - overlap + i]) { - score++; - } - if (newbuf[scan - lenb + i] == old[match.pos - lenb + i]) { - score--; - } - if (score > Ss) { - Ss = score; - lens = i + 1; - } - } - - lenf += lens - overlap; - lenb -= lens; - }; - - for (int i = 0; i < lenf; i++) { - uint8_t diff_byte = newbuf[lastscan + i] - old[lastpos + i]; - if (diff_byte) { - ++diff_bytes_nonzero; - if (!diff_skips->WriteVarint32(pending_diff_zeros)) - return MEM_ERROR; - pending_diff_zeros = 0; - if (!diff_bytes->Write(&diff_byte, 1)) - return MEM_ERROR; - } else { - ++pending_diff_zeros; - } - } - int gap = (scan - lenb) - (lastscan + lenf); - for (int i = 0; i < gap; i++) { - if (!extra_bytes->Write(&newbuf[lastscan + lenf + i], 1)) - return MEM_ERROR; - } - - diff_bytes_length += lenf; - extra_bytes_length += gap; - - uint32_t copy_count = lenf; - uint32_t extra_count = gap; - int32_t seek_adjustment = ((match.pos - lenb) - (lastpos + lenf)); - - if (!control_stream_copy_counts->WriteVarint32(copy_count) || - !control_stream_extra_counts->WriteVarint32(extra_count) || - !control_stream_seeks->WriteVarint32Signed(seek_adjustment)) { - return MEM_ERROR; - } - - ++control_length; -#ifdef DEBUG_bsmedberg - VLOG(1) << StringPrintf( - "Writing a block: copy: %-8u extra: %-8u seek: %+-9d", copy_count, - extra_count, seek_adjustment); -#endif - - lastscan = scan - lenb; // Include the backward extension in seed. - lastpos = match.pos - lenb; // ditto. - lastoffset = lastpos - lastscan; - } - } - - if (!diff_skips->WriteVarint32(pending_diff_zeros)) - return MEM_ERROR; - - I.clear(); - - MBSPatchHeader header; - // The string will have a null terminator that we don't use, hence '-1'. - static_assert(sizeof(MBS_PATCH_HEADER_TAG) - 1 == sizeof(header.tag), - "MBS_PATCH_HEADER_TAG must match header field size"); - memcpy(header.tag, MBS_PATCH_HEADER_TAG, sizeof(header.tag)); - header.slen = oldsize; - header.scrc32 = CalculateCrc(old, oldsize); - header.dlen = newsize; - - if (!WriteHeader(patch_stream, &header)) - return MEM_ERROR; - - size_t diff_skips_length = diff_skips->Length(); - if (!patch_streams.CopyTo(patch_stream)) - return MEM_ERROR; - - VLOG(1) << "Control tuples: " << control_length - << " copy bytes: " << diff_bytes_length - << " mistakes: " << diff_bytes_nonzero - << " (skips: " << diff_skips_length << ")" - << " extra bytes: " << extra_bytes_length - << "\nUncompressed bsdiff patch size " - << patch_stream->Length() - initial_patch_stream_length - << "\nEnd bsdiff " - << (base::Time::Now() - start_bsdiff_time).InSecondsF(); - - return OK; -} - -} // namespace bsdiff diff --git a/3party/bsdiff-courgette/bsdiff/paged_array.h b/3party/bsdiff-courgette/bsdiff/paged_array.h index 251ea973c6..5574584824 100644 --- a/3party/bsdiff-courgette/bsdiff/paged_array.h +++ b/3party/bsdiff-courgette/bsdiff/paged_array.h @@ -12,12 +12,11 @@ #define COURGETTE_THIRD_PARTY_BSDIFF_PAGED_ARRAY_H_ #include +#include #include #include -#include "base/logging.h" -#include "base/macros.h" -#include "base/process/memory.h" +#include "base/macros.hpp" namespace courgette { @@ -102,7 +101,7 @@ class PagedArray_iterator { template bool operator<(const PagedArray_iterator& it) const { -#ifndef NDEBUG +#ifdef DEBUG // For performance, skip the |array_| check in Release builds. if (array_ != it.array_) return false; @@ -111,7 +110,7 @@ class PagedArray_iterator { } template bool operator<=(const PagedArray_iterator& it) const { -#ifndef NDEBUG +#ifdef DEBUG // For performance, skip the |array_| check in Release builds. if (array_ != it.array_) return false; @@ -120,7 +119,7 @@ class PagedArray_iterator { } template bool operator>(const PagedArray_iterator& it) const { -#ifndef NDEBUG +#ifdef DEBUG // For performance, skip the |array_| check in Release builds. if (array_ != it.array_) return false; @@ -129,7 +128,7 @@ class PagedArray_iterator { } template bool operator>=(const PagedArray_iterator& it) const { -#ifndef NDEBUG +#ifdef DEBUG // For performance, skip the |array_| check in Release builds. if (array_ != it.array_) return false; @@ -176,11 +175,11 @@ class PagedArray { T& operator[](size_t i) { size_t page = i >> kLogPageSize; size_t offset = i & (kPageSize - 1); -#ifndef NDEBUG - // Without the #ifndef, DCHECK() will significaltly slow down bsdiff_create + + // *NOTE* CHECK() would significaltly slow down bsdiff_create // even in optimized Release build (about 1.4x). - DCHECK(page < page_count_); -#endif + ASSERT_LESS(page, page_count_, ()); + return pages_[page][offset]; } @@ -189,11 +188,11 @@ class PagedArray { // then bsdiff_create slows down by ~5% in optimized Release build. size_t page = i >> kLogPageSize; size_t offset = i & (kPageSize - 1); -#ifndef NDEBUG - // Without the #ifndef, DCHECK() will significaltly slow down bsdiff_create + + // *NOTE* CHECK() would significaltly slow down bsdiff_create // even in optimized Release build (about 1.4x). - DCHECK(page < page_count_); -#endif + ASSERT_LESS(page, page_count_, ()); + return pages_[page][offset]; } @@ -203,14 +202,14 @@ class PagedArray { clear(); size_ = size; size_t pages_needed = (size_ + kPageSize - 1) >> kLogPageSize; - if (!base::UncheckedMalloc(sizeof(T*) * pages_needed, + if (!UncheckedMalloc(sizeof(T*) * pages_needed, reinterpret_cast(&pages_))) { return false; } for (page_count_ = 0; page_count_ < pages_needed; ++page_count_) { T* block = nullptr; - if (!base::UncheckedMalloc(sizeof(T) * kPageSize, + if (!UncheckedMalloc(sizeof(T) * kPageSize, reinterpret_cast(&block))) { clear(); return false; @@ -237,7 +236,12 @@ class PagedArray { size_t size_ = 0U; size_t page_count_ = 0U; - DISALLOW_COPY_AND_ASSIGN(PagedArray); + bool UncheckedMalloc(size_t size, void** result) { + *result = malloc(size); + return *result != NULL; + } + + DISALLOW_COPY_AND_MOVE(PagedArray); }; } // namespace courgette diff --git a/3party/bsdiff-courgette/divsufsort/divsufsort.cc b/3party/bsdiff-courgette/divsufsort/divsufsort.cc index 297153427d..c41fc962d1 100644 --- a/3party/bsdiff-courgette/divsufsort/divsufsort.cc +++ b/3party/bsdiff-courgette/divsufsort/divsufsort.cc @@ -25,7 +25,7 @@ // 2016-07-22 - Initial commit and adaption to use PagedArray. // --Samuel Huang -#include "courgette/third_party/divsufsort/divsufsort_private.h" +#include "3party/bsdiff-courgette/divsufsort/divsufsort_private.h" #include diff --git a/3party/bsdiff-courgette/divsufsort/divsufsort.h b/3party/bsdiff-courgette/divsufsort/divsufsort.h index e1119f92bc..68a585992f 100644 --- a/3party/bsdiff-courgette/divsufsort/divsufsort.h +++ b/3party/bsdiff-courgette/divsufsort/divsufsort.h @@ -30,7 +30,7 @@ #include -#include "courgette/third_party/bsdiff/paged_array.h" +#include "3party/bsdiff-courgette/bsdiff/paged_array.h" namespace divsuf { diff --git a/3party/bsdiff-courgette/divsufsort/divsufsort_private.h b/3party/bsdiff-courgette/divsufsort/divsufsort_private.h index 4552a5ad6a..2f70252cee 100644 --- a/3party/bsdiff-courgette/divsufsort/divsufsort_private.h +++ b/3party/bsdiff-courgette/divsufsort/divsufsort_private.h @@ -32,7 +32,7 @@ #include #include -#include "courgette/third_party/divsufsort/divsufsort.h" +#include "3party/bsdiff-courgette/divsufsort/divsufsort.h" namespace divsuf { diff --git a/3party/bsdiff-courgette/divsufsort/sssort.cc b/3party/bsdiff-courgette/divsufsort/sssort.cc index 1c92a53cf3..1b184423d2 100644 --- a/3party/bsdiff-courgette/divsufsort/sssort.cc +++ b/3party/bsdiff-courgette/divsufsort/sssort.cc @@ -25,7 +25,7 @@ // 2016-07-22 - Initial commit and adaption to use PagedArray. // --Samuel Huang -#include "courgette/third_party/divsufsort/divsufsort_private.h" +#include "3party/bsdiff-courgette/divsufsort/divsufsort_private.h" #if defined(SS_INSERTIONSORT_THRESHOLD) # if SS_INSERTIONSORT_THRESHOLD < 1 diff --git a/3party/bsdiff-courgette/divsufsort/trsort.cc b/3party/bsdiff-courgette/divsufsort/trsort.cc index daf3b8afa0..62691e8ab8 100644 --- a/3party/bsdiff-courgette/divsufsort/trsort.cc +++ b/3party/bsdiff-courgette/divsufsort/trsort.cc @@ -25,7 +25,7 @@ // 2016-07-22 - Initial commit and adaption to use PagedArray. // --Samuel Huang -#include "courgette/third_party/divsufsort/divsufsort_private.h" +#include "3party/bsdiff-courgette/divsufsort/divsufsort_private.h" #define TR_INSERTIONSORT_THRESHOLD (8) #define TR_STACKSIZE (64) diff --git a/CMakeLists.txt b/CMakeLists.txt index 7d0ae30b37..5dcdd96f64 100644 --- a/CMakeLists.txt +++ b/CMakeLists.txt @@ -310,6 +310,7 @@ add_subdirectory(3party/pugixml) add_subdirectory(3party/succinct) add_subdirectory(3party/osrm) add_subdirectory(3party/gflags) +add_subdirectory(3party/bsdiff-courgette) add_subdirectory(base) add_subdirectory(coding) add_subdirectory(geometry)