# HG changeset patch # User Neil # Date 1516950278 -39600 # Node ID 3e3bfe29a819c1f7a1761096ec54e9b6ee446a68 # Parent 92c8f0f1b3e64900cbb868a56936898693b9cfcc Extend SplitVector to allow more than 2 billion elements on 64-bit systems. diff -r 92c8f0f1b3e6 -r 3e3bfe29a819 src/CellBuffer.cxx --- a/src/CellBuffer.cxx Fri Jan 26 11:12:10 2018 +1100 +++ b/src/CellBuffer.cxx Fri Jan 26 18:04:38 2018 +1100 @@ -394,7 +394,7 @@ } Sci::Position CellBuffer::GapPosition() const { - return substance.GapPosition(); + return static_cast(substance.GapPosition()); } // The char* returned is to an allocation owned by the undo history @@ -457,7 +457,7 @@ } Sci::Position CellBuffer::Length() const { - return substance.Length(); + return static_cast(substance.Length()); } void CellBuffer::Allocate(Sci::Position newSize) { diff -r 92c8f0f1b3e6 -r 3e3bfe29a819 src/Partitioning.h --- a/src/Partitioning.h Fri Jan 26 11:12:10 2018 +1100 +++ b/src/Partitioning.h Fri Jan 26 18:04:38 2018 +1100 @@ -16,7 +16,7 @@ class SplitVectorWithRangeAdd : public SplitVector { public: - explicit SplitVectorWithRangeAdd(int growSize_) { + explicit SplitVectorWithRangeAdd(ptrdiff_t growSize_) { SetGrowSize(growSize_); ReAllocate(growSize_); } @@ -25,12 +25,12 @@ void operator=(const SplitVectorWithRangeAdd &) = delete; ~SplitVectorWithRangeAdd() { } - void RangeAddDelta(int start, int end, int delta) { + void RangeAddDelta(ptrdiff_t start, ptrdiff_t end, int delta) { // end is 1 past end, so end-start is number of elements to change - int i = 0; - const int rangeLength = end - start; - int range1Length = rangeLength; - const int part1Left = part1Length - start; + ptrdiff_t i = 0; + const ptrdiff_t rangeLength = end - start; + ptrdiff_t range1Length = rangeLength; + const ptrdiff_t part1Left = part1Length - start; if (range1Length > part1Left) range1Length = part1Left; while (i < range1Length) { @@ -67,7 +67,7 @@ } stepPartition = partitionUpTo; if (stepPartition >= body->Length()-1) { - stepPartition = body->Length()-1; + stepPartition = Partitions(); stepLength = 0; } } @@ -80,7 +80,7 @@ stepPartition = partitionDownTo; } - void Allocate(int growSize) { + void Allocate(ptrdiff_t growSize) { body = new SplitVectorWithRangeAdd(growSize); stepPartition = 0; stepLength = 0; @@ -101,7 +101,7 @@ } int Partitions() const { - return body->Length()-1; + return static_cast(body->Length()-1); } void InsertPartition(int partition, int pos) { @@ -132,7 +132,7 @@ BackStep(partitionInsert); stepLength += delta; } else { - ApplyStep(body->Length()-1); + ApplyStep(Partitions()); stepPartition = partitionInsert; stepLength = delta; } @@ -168,10 +168,10 @@ int PartitionFromPosition(int pos) const { if (body->Length() <= 1) return 0; - if (pos >= (PositionFromPartition(body->Length()-1))) - return body->Length() - 1 - 1; + if (pos >= (PositionFromPartition(Partitions()))) + return Partitions() - 1; int lower = 0; - int upper = body->Length()-1; + int upper = Partitions(); do { const int middle = (upper + lower + 1) / 2; // Round high int posMiddle = body->ValueAt(middle); diff -r 92c8f0f1b3e6 -r 3e3bfe29a819 src/PerLine.cxx --- a/src/PerLine.cxx Fri Jan 26 11:12:10 2018 +1100 +++ b/src/PerLine.cxx Fri Jan 26 18:04:38 2018 +1100 @@ -135,7 +135,7 @@ Sci::Line LineMarkers::MarkerNext(Sci::Line lineStart, int mask) const { if (lineStart < 0) lineStart = 0; - const Sci::Line length = markers.Length(); + const Sci::Line length = static_cast(markers.Length()); for (Sci::Line iLine = lineStart; iLine < length; iLine++) { const MarkerHandleSet *onLine = markers[iLine].get(); if (onLine && ((onLine->MarkValue() & mask) != 0)) @@ -281,7 +281,7 @@ } Sci::Line LineState::GetMaxLineState() const { - return lineStates.Length(); + return static_cast(lineStates.Length()); } static int NumberLines(const char *text) { diff -r 92c8f0f1b3e6 -r 3e3bfe29a819 src/SplitVector.h --- a/src/SplitVector.h Fri Jan 26 11:12:10 2018 +1100 +++ b/src/SplitVector.h Fri Jan 26 18:04:38 2018 +1100 @@ -16,15 +16,15 @@ protected: T *body; - int size; - int lengthBody; - int part1Length; - int gapLength; /// invariant: gapLength == size - lengthBody - int growSize; + ptrdiff_t size; + ptrdiff_t lengthBody; + ptrdiff_t part1Length; + ptrdiff_t gapLength; /// invariant: gapLength == size - lengthBody + ptrdiff_t growSize; /// Move the gap to a particular position so that insertion and /// deletion at that point will not require much copying and /// hence be fast. - void GapTo(int position) { + void GapTo(ptrdiff_t position) { if (position != part1Length) { if (position < part1Length) { // Moving the gap towards start so moving elements towards end @@ -45,11 +45,11 @@ /// Check that there is room in the buffer for an insertion, /// reallocating if more space needed. - void RoomFor(int insertionLength) { + void RoomFor(ptrdiff_t insertionLength) { if (gapLength <= insertionLength) { while (growSize < size / 6) growSize *= 2; ReAllocate(size + insertionLength + growSize); } } @@ -75,18 +75,18 @@ ~SplitVector() { } - int GetGrowSize() const { + ptrdiff_t GetGrowSize() const { return growSize; } - - void SetGrowSize(int growSize_) { + + void SetGrowSize(ptrdiff_t growSize_) { growSize = growSize_; } /// Reallocate the storage for the buffer to be newSize and /// copy exisiting contents to the new buffer. /// Must not be used to decrease the size of the buffer. - void ReAllocate(int newSize) { + void ReAllocate(ptrdiff_t newSize) { if (newSize < 0) throw std::runtime_error("SplitVector::ReAllocate: negative size."); @@ -104,9 +104,9 @@ /// Retrieve the character at a particular position. /// Retrieving positions outside the range of the buffer returns 0. /// The assertions here are disabled since calling code can be /// simpler if out of range access works and returns 0. - T ValueAt(int position) const { + T ValueAt(ptrdiff_t position) const { if (position < part1Length) { //PLATFORM_ASSERT(position >= 0); if (position < 0) { @@ -124,7 +124,7 @@ } } - void SetValueAt(int position, T v) { + void SetValueAt(ptrdiff_t position, T v) { if (position < part1Length) { PLATFORM_ASSERT(position >= 0); if (position < 0) { @@ -144,7 +144,7 @@ } } - T &operator[](int position) const { + T &operator[](ptrdiff_t position) const { PLATFORM_ASSERT(position >= 0 && position < lengthBody); if (position < part1Length) { return body[position]; @@ -166,13 +166,13 @@ } /// Retrieve the length of the buffer. - int Length() const { + ptrdiff_t Length() const { return lengthBody; } /// Insert a single value into the buffer. /// Inserting at positions outside the current range fails. - void Insert(int position, T v) { + void Insert(ptrdiff_t position, T v) { PLATFORM_ASSERT((position >= 0) && (position <= lengthBody)); if ((position < 0) || (position > lengthBody)) { return; @@ -187,7 +187,7 @@ /// Insert a number of elements into the buffer setting their value. /// Inserting at positions outside the current range fails. - void InsertValue(int position, int insertLength, T v) { + void InsertValue(ptrdiff_t position, ptrdiff_t insertLength, T v) { PLATFORM_ASSERT((position >= 0) && (position <= lengthBody)); if (insertLength > 0) { if ((position < 0) || (position > lengthBody)) { @@ -225,14 +225,14 @@ /// Ensure at least length elements allocated, /// appending zero valued elements if needed. - void EnsureLength(int wantedLength) { + void EnsureLength(ptrdiff_t wantedLength) { if (Length() < wantedLength) { InsertValue(Length(), wantedLength - Length(), 0); } } /// Insert text into the buffer from an array. - void InsertFromArray(int positionToInsert, const T s[], int positionFrom, int insertLength) { + void InsertFromArray(ptrdiff_t positionToInsert, const T s[], ptrdiff_t positionFrom, ptrdiff_t insertLength) { PLATFORM_ASSERT((positionToInsert >= 0) && (positionToInsert <= lengthBody)); if (insertLength > 0) { if ((positionToInsert < 0) || (positionToInsert > lengthBody)) { @@ -248,7 +248,7 @@ } /// Delete one element from the buffer. - void Delete(int position) { + void Delete(ptrdiff_t position) { PLATFORM_ASSERT((position >= 0) && (position < lengthBody)); if ((position < 0) || (position >= lengthBody)) { return; @@ -258,7 +258,7 @@ /// Delete a range from the buffer. /// Deleting positions outside the current range fails. - void DeleteRange(int position, int deleteLength) { + void DeleteRange(ptrdiff_t position, ptrdiff_t deleteLength) { PLATFORM_ASSERT((position >= 0) && (position + deleteLength <= lengthBody)); if ((position < 0) || ((position + deleteLength) > lengthBody)) { return; @@ -277,17 +277,17 @@ // Retrieve a range of elements into an array - void GetRange(T *buffer, int position, int retrieveLength) const { + void GetRange(T *buffer, ptrdiff_t position, ptrdiff_t retrieveLength) const { // Split into up to 2 ranges, before and after the split then use memcpy on each. - int range1Length = 0; + ptrdiff_t range1Length = 0; if (position < part1Length) { - const int part1AfterPosition = part1Length - position; + const ptrdiff_t part1AfterPosition = part1Length - position; range1Length = retrieveLength; if (range1Length > part1AfterPosition) range1Length = part1AfterPosition; } std::copy(body + position, body + position + range1Length, buffer); buffer += range1Length; position = position + range1Length + gapLength; - int range2Length = retrieveLength - range1Length; + ptrdiff_t range2Length = retrieveLength - range1Length; std::copy(body + position, body + position + range2Length, buffer); } @@ -308,7 +308,7 @@ return body; } - T *RangePointer(int position, int rangeLength) { + T *RangePointer(ptrdiff_t position, ptrdiff_t rangeLength) { if (position < part1Length) { if ((position + rangeLength) > part1Length) { // Range overlaps gap, so move gap to start of range. @@ -323,7 +323,7 @@ } } - int GapPosition() const { + ptrdiff_t GapPosition() const { return part1Length; } };