src/stc/scintilla/src/Document.cxx

   1 // Scintilla source code edit control
   2 /** @file Document.cxx
   3  ** Text document that handles notifications, DBCS, styling, words and end of line.
   4  **/
   5 // Copyright 1998-2003 by Neil Hodgson <neilh@scintilla.org>
   6 // The License.txt file describes the conditions under which this software may be distributed.
   7
   8 #include <stdlib.h>
   9 #include <string.h>
  10 #include <stdio.h>
  11 #include <ctype.h>
  12
  13 #include "Platform.h"
  14
  15 #include "Scintilla.h"
  16 #include "SplitVector.h"
  17 #include "Partitioning.h"
  18 #include "RunStyles.h"
  19 #include "CellBuffer.h"
  20 #include "PerLine.h"
  21 #include "CharClassify.h"
  22 #include "Decoration.h"
  23 #include "Document.h"
  24 #include "RESearch.h"
  25
  26 #ifdef SCI_NAMESPACE
  27 using namespace Scintilla;
  28 #endif
  29
  30 // This is ASCII specific but is safe with chars >= 0x80
  31 static inline bool isspacechar(unsigned char ch) {
  32         return (ch == ' ') || ((ch >= 0x09) && (ch <= 0x0d));
  33 }
  34
  35 static inline bool IsPunctuation(char ch) {
  36         return isascii(ch) && ispunct(ch);
  37 }
  38
  39 static inline bool IsADigit(char ch) {
  40         return isascii(ch) && isdigit(ch);
  41 }
  42
  43 static inline bool IsLowerCase(char ch) {
  44         return isascii(ch) && islower(ch);
  45 }
  46
  47 static inline bool IsUpperCase(char ch) {
  48         return isascii(ch) && isupper(ch);
  49 }
  50
  51 Document::Document() {
  52         refCount = 0;
  53 #ifdef unix
  54         eolMode = SC_EOL_LF;
  55 #else
  56         eolMode = SC_EOL_CRLF;
  57 #endif
  58         dbcsCodePage = 0;
  59         stylingBits = 5;
  60         stylingBitsMask = 0x1F;
  61         stylingMask = 0;
  62         endStyled = 0;
  63         styleClock = 0;
  64         enteredModification = 0;
  65         enteredStyling = 0;
  66         enteredReadOnlyCount = 0;
  67         tabInChars = 8;
  68         indentInChars = 0;
  69         actualIndentInChars = 8;
  70         useTabs = true;
  71         tabIndents = true;
  72         backspaceUnindents = false;
  73         watchers = 0;
  74         lenWatchers = 0;
  75
  76         matchesValid = false;
  77         regex = 0;
  78
  79         perLineData[ldMarkers] = new LineMarkers();
  80         perLineData[ldLevels] = new LineLevels();
  81         perLineData[ldState] = new LineState();
  82         perLineData[ldMargin] = new LineAnnotation();
  83         perLineData[ldAnnotation] = new LineAnnotation();
  84
  85         cb.SetPerLine(this);
  86 }
  87
  88 Document::~Document() {
  89         for (int i = 0; i < lenWatchers; i++) {
  90                 watchers[i].watcher->NotifyDeleted(this, watchers[i].userData);
  91         }
  92         delete []watchers;
  93         for (int j=0; j<ldSize; j++) {
  94                 delete perLineData[j];
  95                 perLineData[j] = 0;
  96         }
  97         watchers = 0;
  98         lenWatchers = 0;
  99         delete regex;
 100         regex = 0;
 101 }
 102
 103 void Document::Init() {
 104         for (int j=0; j<ldSize; j++) {
 105                 if (perLineData[j])
 106                         perLineData[j]->Init();
 107         }
 108 }
 109
 110 void Document::InsertLine(int line) {
 111         for (int j=0; j<ldSize; j++) {
 112                 if (perLineData[j])
 113                         perLineData[j]->InsertLine(line);
 114         }
 115 }
 116
 117 void Document::RemoveLine(int line) {
 118         for (int j=0; j<ldSize; j++) {
 119                 if (perLineData[j])
 120                         perLineData[j]->RemoveLine(line);
 121         }
 122 }
 123
 124 // Increase reference count and return its previous value.
 125 int Document::AddRef() {
 126         return refCount++;
 127 }
 128
 129 // Decrease reference count and return its previous value.
 130 // Delete the document if reference count reaches zero.
 131 int Document::Release() {
 132         int curRefCount = --refCount;
 133         if (curRefCount == 0)
 134                 delete this;
 135         return curRefCount;
 136 }
 137
 138 void Document::SetSavePoint() {
 139         cb.SetSavePoint();
 140         NotifySavePoint(true);
 141 }
 142
 143 int Document::GetMark(int line) {
 144         return static_cast<LineMarkers*>(perLineData[ldMarkers])->MarkValue(line);
 145 }
 146
 147 int Document::AddMark(int line, int markerNum) {
 148         if (line <= LinesTotal()) {
 149                 int prev = static_cast<LineMarkers*>(perLineData[ldMarkers])->
 150                         AddMark(line, markerNum, LinesTotal());
 151                 DocModification mh(SC_MOD_CHANGEMARKER, LineStart(line), 0, 0, 0, line);
 152                 NotifyModified(mh);
 153                 return prev;
 154         } else {
 155                 return 0;
 156         }
 157 }
 158
 159 void Document::AddMarkSet(int line, int valueSet) {
 160         unsigned int m = valueSet;
 161         for (int i = 0; m; i++, m >>= 1)
 162                 if (m & 1)
 163                         static_cast<LineMarkers*>(perLineData[ldMarkers])->
 164                                 AddMark(line, i, LinesTotal());
 165         DocModification mh(SC_MOD_CHANGEMARKER, LineStart(line), 0, 0, 0, line);
 166         NotifyModified(mh);
 167 }
 168
 169 void Document::DeleteMark(int line, int markerNum) {
 170         static_cast<LineMarkers*>(perLineData[ldMarkers])->DeleteMark(line, markerNum, false);
 171         DocModification mh(SC_MOD_CHANGEMARKER, LineStart(line), 0, 0, 0, line);
 172         NotifyModified(mh);
 173 }
 174
 175 void Document::DeleteMarkFromHandle(int markerHandle) {
 176         static_cast<LineMarkers*>(perLineData[ldMarkers])->DeleteMarkFromHandle(markerHandle);
 177         DocModification mh(SC_MOD_CHANGEMARKER, 0, 0, 0, 0);
 178         mh.line = -1;
 179         NotifyModified(mh);
 180 }
 181
 182 void Document::DeleteAllMarks(int markerNum) {
 183         for (int line = 0; line < LinesTotal(); line++) {
 184                 static_cast<LineMarkers*>(perLineData[ldMarkers])->DeleteMark(line, markerNum, true);
 185         }
 186         DocModification mh(SC_MOD_CHANGEMARKER, 0, 0, 0, 0);
 187         mh.line = -1;
 188         NotifyModified(mh);
 189 }
 190
 191 int Document::LineFromHandle(int markerHandle) {
 192         return static_cast<LineMarkers*>(perLineData[ldMarkers])->LineFromHandle(markerHandle);
 193 }
 194
 195 int Document::LineStart(int line) const {
 196         return cb.LineStart(line);
 197 }
 198
 199 int Document::LineEnd(int line) const {
 200         if (line == LinesTotal() - 1) {
 201                 return LineStart(line + 1);
 202         } else {
 203                 int position = LineStart(line + 1) - 1;
 204                 // When line terminator is CR+LF, may need to go back one more
 205                 if ((position > LineStart(line)) && (cb.CharAt(position - 1) == '\r')) {
 206                         position--;
 207                 }
 208                 return position;
 209         }
 210 }
 211
 212 int Document::LineFromPosition(int pos) const {
 213         return cb.LineFromPosition(pos);
 214 }
 215
 216 int Document::LineEndPosition(int position) const {
 217         return LineEnd(LineFromPosition(position));
 218 }
 219
 220 bool Document::IsLineEndPosition(int position) const {
 221         return LineEnd(LineFromPosition(position)) == position;
 222 }
 223
 224 int Document::VCHomePosition(int position) const {
 225         int line = LineFromPosition(position);
 226         int startPosition = LineStart(line);
 227         int endLine = LineEnd(line);
 228         int startText = startPosition;
 229         while (startText < endLine && (cb.CharAt(startText) == ' ' || cb.CharAt(startText) == '\t' ) )
 230                 startText++;
 231         if (position == startText)
 232                 return startPosition;
 233         else
 234                 return startText;
 235 }
 236
 237 int Document::SetLevel(int line, int level) {
 238         int prev = static_cast<LineLevels*>(perLineData[ldLevels])->SetLevel(line, level, LinesTotal());
 239         if (prev != level) {
 240                 DocModification mh(SC_MOD_CHANGEFOLD | SC_MOD_CHANGEMARKER,
 241                                    LineStart(line), 0, 0, 0, line);
 242                 mh.foldLevelNow = level;
 243                 mh.foldLevelPrev = prev;
 244                 NotifyModified(mh);
 245         }
 246         return prev;
 247 }
 248
 249 int Document::GetLevel(int line) {
 250         return static_cast<LineLevels*>(perLineData[ldLevels])->GetLevel(line);
 251 }
 252
 253 void Document::ClearLevels() {
 254         static_cast<LineLevels*>(perLineData[ldLevels])->ClearLevels();
 255 }
 256
 257 static bool IsSubordinate(int levelStart, int levelTry) {
 258         if (levelTry & SC_FOLDLEVELWHITEFLAG)
 259                 return true;
 260         else
 261                 return (levelStart & SC_FOLDLEVELNUMBERMASK) < (levelTry & SC_FOLDLEVELNUMBERMASK);
 262 }
 263
 264 int Document::GetLastChild(int lineParent, int level) {
 265         if (level == -1)
 266                 level = GetLevel(lineParent) & SC_FOLDLEVELNUMBERMASK;
 267         int maxLine = LinesTotal();
 268         int lineMaxSubord = lineParent;
 269         while (lineMaxSubord < maxLine - 1) {
 270                 EnsureStyledTo(LineStart(lineMaxSubord + 2));
 271                 if (!IsSubordinate(level, GetLevel(lineMaxSubord + 1)))
 272                         break;
 273                 lineMaxSubord++;
 274         }
 275         if (lineMaxSubord > lineParent) {
 276                 if (level > (GetLevel(lineMaxSubord + 1) & SC_FOLDLEVELNUMBERMASK)) {
 277                         // Have chewed up some whitespace that belongs to a parent so seek back
 278                         if (GetLevel(lineMaxSubord) & SC_FOLDLEVELWHITEFLAG) {
 279                                 lineMaxSubord--;
 280                         }
 281                 }
 282         }
 283         return lineMaxSubord;
 284 }
 285
 286 int Document::GetFoldParent(int line) {
 287         int level = GetLevel(line) & SC_FOLDLEVELNUMBERMASK;
 288         int lineLook = line - 1;
 289         while ((lineLook > 0) && (
 290                     (!(GetLevel(lineLook) & SC_FOLDLEVELHEADERFLAG)) ||
 291                     ((GetLevel(lineLook) & SC_FOLDLEVELNUMBERMASK) >= level))
 292               ) {
 293                 lineLook--;
 294         }
 295         if ((GetLevel(lineLook) & SC_FOLDLEVELHEADERFLAG) &&
 296                 ((GetLevel(lineLook) & SC_FOLDLEVELNUMBERMASK) < level)) {
 297                 return lineLook;
 298         } else {
 299                 return -1;
 300         }
 301 }
 302
 303 int Document::ClampPositionIntoDocument(int pos) {
 304         return Platform::Clamp(pos, 0, Length());
 305 }
 306
 307 bool Document::IsCrLf(int pos) {
 308         if (pos < 0)
 309                 return false;
 310         if (pos >= (Length() - 1))
 311                 return false;
 312         return (cb.CharAt(pos) == '\r') && (cb.CharAt(pos + 1) == '\n');
 313 }
 314
 315 static const int maxBytesInDBCSCharacter=5;
 316
 317 int Document::LenChar(int pos) {
 318         if (pos < 0) {
 319                 return 1;
 320         } else if (IsCrLf(pos)) {
 321                 return 2;
 322         } else if (SC_CP_UTF8 == dbcsCodePage) {
 323                 unsigned char ch = static_cast<unsigned char>(cb.CharAt(pos));
 324                 if (ch < 0x80)
 325                         return 1;
 326                 int len = 2;
 327                 if (ch >= (0x80 + 0x40 + 0x20 + 0x10))
 328                         len = 4;
 329                 else if (ch >= (0x80 + 0x40 + 0x20))
 330                         len = 3;
 331                 int lengthDoc = Length();
 332                 if ((pos + len) > lengthDoc)
 333                         return lengthDoc -pos;
 334                 else
 335                         return len;
 336         } else if (dbcsCodePage) {
 337                 char mbstr[maxBytesInDBCSCharacter+1];
 338                 int i;
 339                 for (i=0; i<Platform::DBCSCharMaxLength(); i++) {
 340                         mbstr[i] = cb.CharAt(pos+i);
 341                 }
 342                 mbstr[i] = '\0';
 343                 return Platform::DBCSCharLength(dbcsCodePage, mbstr);
 344         } else {
 345                 return 1;
 346         }
 347 }
 348
 349 static bool IsTrailByte(int ch) {
 350         return (ch >= 0x80) && (ch < (0x80 + 0x40));
 351 }
 352
 353 static int BytesFromLead(int leadByte) {
 354         if (leadByte > 0xF4) {
 355                 // Characters longer than 4 bytes not possible in current UTF-8
 356                 return 0;
 357         } else if (leadByte >= 0xF0) {
 358                 return 4;
 359         } else if (leadByte >= 0xE0) {
 360                 return 3;
 361         } else if (leadByte >= 0xC2) {
 362                 return 2;
 363         }
 364         return 0;
 365 }
 366
 367 bool Document::InGoodUTF8(int pos, int &start, int &end) {
 368         int lead = pos;
 369         while ((lead>0) && (pos-lead < 4) && IsTrailByte(static_cast<unsigned char>(cb.CharAt(lead-1))))
 370                 lead--;
 371         start = 0;
 372         if (lead > 0) {
 373                 start = lead-1;
 374         }
 375         int leadByte = static_cast<unsigned char>(cb.CharAt(start));
 376         int bytes = BytesFromLead(leadByte);
 377         if (bytes == 0) {
 378                 return false;
 379         } else {
 380                 int trailBytes = bytes - 1;
 381                 int len = pos - lead + 1;
 382                 if (len > trailBytes)
 383                         // pos too far from lead
 384                         return false;
 385                 // Check that there are enough trails for this lead
 386                 int trail = pos + 1;
 387                 while ((trail-lead<trailBytes) && (trail < Length())) {
 388                         if (!IsTrailByte(static_cast<unsigned char>(cb.CharAt(trail)))) {
 389                                 return false;
 390                         }
 391                         trail++;
 392                 }
 393                 end = start + bytes;
 394                 return true;
 395         }
 396 }
 397
 398 // Normalise a position so that it is not halfway through a two byte character.
 399 // This can occur in two situations -
 400 // When lines are terminated with \r\n pairs which should be treated as one character.
 401 // When displaying DBCS text such as Japanese.
 402 // If moving, move the position in the indicated direction.
 403 int Document::MovePositionOutsideChar(int pos, int moveDir, bool checkLineEnd) {
 404         //Platform::DebugPrintf("NoCRLF %d %d\n", pos, moveDir);
 405         // If out of range, just return minimum/maximum value.
 406         if (pos <= 0)
 407                 return 0;
 408         if (pos >= Length())
 409                 return Length();
 410
 411         // PLATFORM_ASSERT(pos > 0 && pos < Length());
 412         if (checkLineEnd && IsCrLf(pos - 1)) {
 413                 if (moveDir > 0)
 414                         return pos + 1;
 415                 else
 416                         return pos - 1;
 417         }
 418
 419         // Not between CR and LF
 420
 421         if (dbcsCodePage) {
 422                 if (SC_CP_UTF8 == dbcsCodePage) {
 423                         unsigned char ch = static_cast<unsigned char>(cb.CharAt(pos));
 424                         int startUTF = pos;
 425                         int endUTF = pos;
 426                         if (IsTrailByte(ch) && InGoodUTF8(pos, startUTF, endUTF)) {
 427                                 // ch is a trail byte within a UTF-8 character
 428                                 if (moveDir > 0)
 429                                         pos = endUTF;
 430                                 else
 431                                         pos = startUTF;
 432                         }
 433                 } else {
 434                         // Anchor DBCS calculations at start of line because start of line can
 435                         // not be a DBCS trail byte.
 436                         int posCheck = LineStart(LineFromPosition(pos));
 437                         while (posCheck < pos) {
 438                                 char mbstr[maxBytesInDBCSCharacter+1];
 439                                 int i;
 440                                 for(i=0;i<Platform::DBCSCharMaxLength();i++) {
 441                                         mbstr[i] = cb.CharAt(posCheck+i);
 442                                 }
 443                                 mbstr[i] = '\0';
 444
 445                                 int mbsize = Platform::DBCSCharLength(dbcsCodePage, mbstr);
 446                                 if (posCheck + mbsize == pos) {
 447                                         return pos;
 448                                 } else if (posCheck + mbsize > pos) {
 449                                         if (moveDir > 0) {
 450                                                 return posCheck + mbsize;
 451                                         } else {
 452                                                 return posCheck;
 453                                         }
 454                                 }
 455                                 posCheck += mbsize;
 456                         }
 457                 }
 458         }
 459
 460         return pos;
 461 }
 462
 463 void Document::ModifiedAt(int pos) {
 464         if (endStyled > pos)
 465                 endStyled = pos;
 466 }
 467
 468 void Document::CheckReadOnly() {
 469         if (cb.IsReadOnly() && enteredReadOnlyCount == 0) {
 470                 enteredReadOnlyCount++;
 471                 NotifyModifyAttempt();
 472                 enteredReadOnlyCount--;
 473         }
 474 }
 475
 476 // Document only modified by gateways DeleteChars, InsertString, Undo, Redo, and SetStyleAt.
 477 // SetStyleAt does not change the persistent state of a document
 478
 479 bool Document::DeleteChars(int pos, int len) {
 480         if (len == 0)
 481                 return false;
 482         if ((pos + len) > Length())
 483                 return false;
 484         CheckReadOnly();
 485         if (enteredModification != 0) {
 486                 return false;
 487         } else {
 488                 enteredModification++;
 489                 if (!cb.IsReadOnly()) {
 490                         NotifyModified(
 491                             DocModification(
 492                                 SC_MOD_BEFOREDELETE | SC_PERFORMED_USER,
 493                                 pos, len,
 494                                 0, 0));
 495                         int prevLinesTotal = LinesTotal();
 496                         bool startSavePoint = cb.IsSavePoint();
 497                         bool startSequence = false;
 498                         const char *text = cb.DeleteChars(pos, len, startSequence);
 499                         if (startSavePoint && cb.IsCollectingUndo())
 500                                 NotifySavePoint(!startSavePoint);
 501                         if ((pos < Length()) || (pos == 0))
 502                                 ModifiedAt(pos);
 503                         else
 504                                 ModifiedAt(pos-1);
 505                         NotifyModified(
 506                             DocModification(
 507                                 SC_MOD_DELETETEXT | SC_PERFORMED_USER | (startSequence?SC_STARTACTION:0),
 508                                 pos, len,
 509                                 LinesTotal() - prevLinesTotal, text));
 510                 }
 511                 enteredModification--;
 512         }
 513         return !cb.IsReadOnly();
 514 }
 515
 516 /**
 517  * Insert a string with a length.
 518  */
 519 bool Document::InsertString(int position, const char *s, int insertLength) {
 520         if (insertLength <= 0) {
 521                 return false;
 522         }
 523         CheckReadOnly();
 524         if (enteredModification != 0) {
 525                 return false;
 526         } else {
 527                 enteredModification++;
 528                 if (!cb.IsReadOnly()) {
 529                         NotifyModified(
 530                             DocModification(
 531                                 SC_MOD_BEFOREINSERT | SC_PERFORMED_USER,
 532                                 position, insertLength,
 533                                 0, s));
 534                         int prevLinesTotal = LinesTotal();
 535                         bool startSavePoint = cb.IsSavePoint();
 536                         bool startSequence = false;
 537                         const char *text = cb.InsertString(position, s, insertLength, startSequence);
 538                         if (startSavePoint && cb.IsCollectingUndo())
 539                                 NotifySavePoint(!startSavePoint);
 540                         ModifiedAt(position);
 541                         NotifyModified(
 542                             DocModification(
 543                                 SC_MOD_INSERTTEXT | SC_PERFORMED_USER | (startSequence?SC_STARTACTION:0),
 544                                 position, insertLength,
 545                                 LinesTotal() - prevLinesTotal, text));
 546                 }
 547                 enteredModification--;
 548         }
 549         return !cb.IsReadOnly();
 550 }
 551
 552 int Document::Undo() {
 553         int newPos = -1;
 554         CheckReadOnly();
 555         if (enteredModification == 0) {
 556                 enteredModification++;
 557                 if (!cb.IsReadOnly()) {
 558                         bool startSavePoint = cb.IsSavePoint();
 559                         bool multiLine = false;
 560                         int steps = cb.StartUndo();
 561                         //Platform::DebugPrintf("Steps=%d\n", steps);
 562                         for (int step = 0; step < steps; step++) {
 563                                 const int prevLinesTotal = LinesTotal();
 564                                 const Action &action = cb.GetUndoStep();
 565                                 if (action.at == removeAction) {
 566                                         NotifyModified(DocModification(
 567                                                                         SC_MOD_BEFOREINSERT | SC_PERFORMED_UNDO, action));
 568                                 } else if (action.at == containerAction) {
 569                                         DocModification dm(SC_MOD_CONTAINER | SC_PERFORMED_UNDO);
 570                                         dm.token = action.position;
 571                                         NotifyModified(dm);
 572                                 } else {
 573                                         NotifyModified(DocModification(
 574                                                                         SC_MOD_BEFOREDELETE | SC_PERFORMED_UNDO, action));
 575                                 }
 576                                 cb.PerformUndoStep();
 577                                 int cellPosition = action.position;
 578                                 if (action.at != containerAction) {
 579                                         ModifiedAt(cellPosition);
 580                                         newPos = cellPosition;
 581                                 }
 582
 583                                 int modFlags = SC_PERFORMED_UNDO;
 584                                 // With undo, an insertion action becomes a deletion notification
 585                                 if (action.at == removeAction) {
 586                                         newPos += action.lenData;
 587                                         modFlags |= SC_MOD_INSERTTEXT;
 588                                 } else if (action.at == insertAction) {
 589                                         modFlags |= SC_MOD_DELETETEXT;
 590                                 }
 591                                 if (steps > 1)
 592                                         modFlags |= SC_MULTISTEPUNDOREDO;
 593                                 const int linesAdded = LinesTotal() - prevLinesTotal;
 594                                 if (linesAdded != 0)
 595                                         multiLine = true;
 596                                 if (step == steps - 1) {
 597                                         modFlags |= SC_LASTSTEPINUNDOREDO;
 598                                         if (multiLine)
 599                                                 modFlags |= SC_MULTILINEUNDOREDO;
 600                                 }
 601                                 NotifyModified(DocModification(modFlags, cellPosition, action.lenData,
 602                                                                                            linesAdded, action.data));
 603                         }
 604
 605                         bool endSavePoint = cb.IsSavePoint();
 606                         if (startSavePoint != endSavePoint)
 607                                 NotifySavePoint(endSavePoint);
 608                 }
 609                 enteredModification--;
 610         }
 611         return newPos;
 612 }
 613
 614 int Document::Redo() {
 615         int newPos = -1;
 616         CheckReadOnly();
 617         if (enteredModification == 0) {
 618                 enteredModification++;
 619                 if (!cb.IsReadOnly()) {
 620                         bool startSavePoint = cb.IsSavePoint();
 621                         bool multiLine = false;
 622                         int steps = cb.StartRedo();
 623                         for (int step = 0; step < steps; step++) {
 624                                 const int prevLinesTotal = LinesTotal();
 625                                 const Action &action = cb.GetRedoStep();
 626                                 if (action.at == insertAction) {
 627                                         NotifyModified(DocModification(
 628                                                                         SC_MOD_BEFOREINSERT | SC_PERFORMED_REDO, action));
 629                                 } else if (action.at == containerAction) {
 630                                         DocModification dm(SC_MOD_CONTAINER | SC_PERFORMED_REDO);
 631                                         dm.token = action.position;
 632                                         NotifyModified(dm);
 633                                 } else {
 634                                         NotifyModified(DocModification(
 635                                                                         SC_MOD_BEFOREDELETE | SC_PERFORMED_REDO, action));
 636                                 }
 637                                 cb.PerformRedoStep();
 638                                 if (action.at != containerAction) {
 639                                         ModifiedAt(action.position);
 640                                         newPos = action.position;
 641                                 }
 642
 643                                 int modFlags = SC_PERFORMED_REDO;
 644                                 if (action.at == insertAction) {
 645                                         newPos += action.lenData;
 646                                         modFlags |= SC_MOD_INSERTTEXT;
 647                                 } else if (action.at == removeAction) {
 648                                         modFlags |= SC_MOD_DELETETEXT;
 649                                 }
 650                                 if (steps > 1)
 651                                         modFlags |= SC_MULTISTEPUNDOREDO;
 652                                 const int linesAdded = LinesTotal() - prevLinesTotal;
 653                                 if (linesAdded != 0)
 654                                         multiLine = true;
 655                                 if (step == steps - 1) {
 656                                         modFlags |= SC_LASTSTEPINUNDOREDO;
 657                                         if (multiLine)
 658                                                 modFlags |= SC_MULTILINEUNDOREDO;
 659                                 }
 660                                 NotifyModified(
 661                                         DocModification(modFlags, action.position, action.lenData,
 662                                                                         linesAdded, action.data));
 663                         }
 664
 665                         bool endSavePoint = cb.IsSavePoint();
 666                         if (startSavePoint != endSavePoint)
 667                                 NotifySavePoint(endSavePoint);
 668                 }
 669                 enteredModification--;
 670         }
 671         return newPos;
 672 }
 673
 674 /**
 675  * Insert a single character.
 676  */
 677 bool Document::InsertChar(int pos, char ch) {
 678         char chs[1];
 679         chs[0] = ch;
 680         return InsertString(pos, chs, 1);
 681 }
 682
 683 /**
 684  * Insert a null terminated string.
 685  */
 686 bool Document::InsertCString(int position, const char *s) {
 687         return InsertString(position, s, strlen(s));
 688 }
 689
 690 void Document::ChangeChar(int pos, char ch) {
 691         DeleteChars(pos, 1);
 692         InsertChar(pos, ch);
 693 }
 694
 695 void Document::DelChar(int pos) {
 696         DeleteChars(pos, LenChar(pos));
 697 }
 698
 699 void Document::DelCharBack(int pos) {
 700         if (pos <= 0) {
 701                 return;
 702         } else if (IsCrLf(pos - 2)) {
 703                 DeleteChars(pos - 2, 2);
 704         } else if (dbcsCodePage) {
 705                 int startChar = MovePositionOutsideChar(pos - 1, -1, false);
 706                 DeleteChars(startChar, pos - startChar);
 707         } else {
 708                 DeleteChars(pos - 1, 1);
 709         }
 710 }
 711
 712 static bool isindentchar(char ch) {
 713         return (ch == ' ') || (ch == '\t');
 714 }
 715
 716 static int NextTab(int pos, int tabSize) {
 717         return ((pos / tabSize) + 1) * tabSize;
 718 }
 719
 720 static void CreateIndentation(char *linebuf, int length, int indent, int tabSize, bool insertSpaces) {
 721         length--;       // ensure space for \0
 722         if (!insertSpaces) {
 723                 while ((indent >= tabSize) && (length > 0)) {
 724                         *linebuf++ = '\t';
 725                         indent -= tabSize;
 726                         length--;
 727                 }
 728         }
 729         while ((indent > 0) && (length > 0)) {
 730                 *linebuf++ = ' ';
 731                 indent--;
 732                 length--;
 733         }
 734         *linebuf = '\0';
 735 }
 736
 737 int Document::GetLineIndentation(int line) {
 738         int indent = 0;
 739         if ((line >= 0) && (line < LinesTotal())) {
 740                 int lineStart = LineStart(line);
 741                 int length = Length();
 742                 for (int i = lineStart;i < length;i++) {
 743                         char ch = cb.CharAt(i);
 744                         if (ch == ' ')
 745                                 indent++;
 746                         else if (ch == '\t')
 747                                 indent = NextTab(indent, tabInChars);
 748                         else
 749                                 return indent;
 750                 }
 751         }
 752         return indent;
 753 }
 754
 755 void Document::SetLineIndentation(int line, int indent) {
 756         int indentOfLine = GetLineIndentation(line);
 757         if (indent < 0)
 758                 indent = 0;
 759         if (indent != indentOfLine) {
 760                 char linebuf[1000];
 761                 CreateIndentation(linebuf, sizeof(linebuf), indent, tabInChars, !useTabs);
 762                 int thisLineStart = LineStart(line);
 763                 int indentPos = GetLineIndentPosition(line);
 764                 UndoGroup ug(this);
 765                 DeleteChars(thisLineStart, indentPos - thisLineStart);
 766                 InsertCString(thisLineStart, linebuf);
 767         }
 768 }
 769
 770 int Document::GetLineIndentPosition(int line) const {
 771         if (line < 0)
 772                 return 0;
 773         int pos = LineStart(line);
 774         int length = Length();
 775         while ((pos < length) && isindentchar(cb.CharAt(pos))) {
 776                 pos++;
 777         }
 778         return pos;
 779 }
 780
 781 int Document::GetColumn(int pos) {
 782         int column = 0;
 783         int line = LineFromPosition(pos);
 784         if ((line >= 0) && (line < LinesTotal())) {
 785                 for (int i = LineStart(line);i < pos;) {
 786                         char ch = cb.CharAt(i);
 787                         if (ch == '\t') {
 788                                 column = NextTab(column, tabInChars);
 789                                 i++;
 790                         } else if (ch == '\r') {
 791                                 return column;
 792                         } else if (ch == '\n') {
 793                                 return column;
 794                         } else if (i >= Length()) {
 795                                 return column;
 796                         } else {
 797                                 column++;
 798                                 i = MovePositionOutsideChar(i + 1, 1, false);
 799                         }
 800                 }
 801         }
 802         return column;
 803 }
 804
 805 int Document::FindColumn(int line, int column) {
 806         int position = LineStart(line);
 807         if ((line >= 0) && (line < LinesTotal())) {
 808                 int columnCurrent = 0;
 809                 while ((columnCurrent < column) && (position < Length())) {
 810                         char ch = cb.CharAt(position);
 811                         if (ch == '\t') {
 812                                 columnCurrent = NextTab(columnCurrent, tabInChars);
 813                                 position++;
 814                         } else if (ch == '\r') {
 815                                 return position;
 816                         } else if (ch == '\n') {
 817                                 return position;
 818                         } else {
 819                                 columnCurrent++;
 820                                 position = MovePositionOutsideChar(position + 1, 1, false);
 821                         }
 822                 }
 823         }
 824         return position;
 825 }
 826
 827 void Document::Indent(bool forwards, int lineBottom, int lineTop) {
 828         // Dedent - suck white space off the front of the line to dedent by equivalent of a tab
 829         for (int line = lineBottom; line >= lineTop; line--) {
 830                 int indentOfLine = GetLineIndentation(line);
 831                 if (forwards) {
 832                         if (LineStart(line) < LineEnd(line)) {
 833                                 SetLineIndentation(line, indentOfLine + IndentSize());
 834                         }
 835                 } else {
 836                         SetLineIndentation(line, indentOfLine - IndentSize());
 837                 }
 838         }
 839 }
 840
 841 // Convert line endings for a piece of text to a particular mode.
 842 // Stop at len or when a NUL is found.
 843 // Caller must delete the returned pointer.
 844 char *Document::TransformLineEnds(int *pLenOut, const char *s, size_t len, int eolMode) {
 845         char *dest = new char[2 * len + 1];
 846         const char *sptr = s;
 847         char *dptr = dest;
 848         for (size_t i = 0; (i < len) && (*sptr != '\0'); i++) {
 849                 if (*sptr == '\n' || *sptr == '\r') {
 850                         if (eolMode == SC_EOL_CR) {
 851                                 *dptr++ = '\r';
 852                         } else if (eolMode == SC_EOL_LF) {
 853                                 *dptr++ = '\n';
 854                         } else { // eolMode == SC_EOL_CRLF
 855                                 *dptr++ = '\r';
 856                                 *dptr++ = '\n';
 857                         }
 858                         if ((*sptr == '\r') && (i+1 < len) && (*(sptr+1) == '\n')) {
 859                                 i++;
 860                                 sptr++;
 861                         }
 862                         sptr++;
 863                 } else {
 864                         *dptr++ = *sptr++;
 865                 }
 866         }
 867         *dptr++ = '\0';
 868         *pLenOut = (dptr - dest) - 1;
 869         return dest;
 870 }
 871
 872 void Document::ConvertLineEnds(int eolModeSet) {
 873         UndoGroup ug(this);
 874
 875         for (int pos = 0; pos < Length(); pos++) {
 876                 if (cb.CharAt(pos) == '\r') {
 877                         if (cb.CharAt(pos + 1) == '\n') {
 878                                 // CRLF
 879                                 if (eolModeSet == SC_EOL_CR) {
 880                                         DeleteChars(pos + 1, 1); // Delete the LF
 881                                 } else if (eolModeSet == SC_EOL_LF) {
 882                                         DeleteChars(pos, 1); // Delete the CR
 883                                 } else {
 884                                         pos++;
 885                                 }
 886                         } else {
 887                                 // CR
 888                                 if (eolModeSet == SC_EOL_CRLF) {
 889                                         InsertString(pos + 1, "\n", 1); // Insert LF
 890                                         pos++;
 891                                 } else if (eolModeSet == SC_EOL_LF) {
 892                                         InsertString(pos, "\n", 1); // Insert LF
 893                                         DeleteChars(pos + 1, 1); // Delete CR
 894                                 }
 895                         }
 896                 } else if (cb.CharAt(pos) == '\n') {
 897                         // LF
 898                         if (eolModeSet == SC_EOL_CRLF) {
 899                                 InsertString(pos, "\r", 1); // Insert CR
 900                                 pos++;
 901                         } else if (eolModeSet == SC_EOL_CR) {
 902                                 InsertString(pos, "\r", 1); // Insert CR
 903                                 DeleteChars(pos + 1, 1); // Delete LF
 904                         }
 905                 }
 906         }
 907
 908 }
 909
 910 bool Document::IsWhiteLine(int line) const {
 911         int currentChar = LineStart(line);
 912         int endLine = LineEnd(line);
 913         while (currentChar < endLine) {
 914                 if (cb.CharAt(currentChar) != ' ' && cb.CharAt(currentChar) != '\t') {
 915                         return false;
 916                 }
 917                 ++currentChar;
 918         }
 919         return true;
 920 }
 921
 922 int Document::ParaUp(int pos) {
 923         int line = LineFromPosition(pos);
 924         line--;
 925         while (line >= 0 && IsWhiteLine(line)) { // skip empty lines
 926                 line--;
 927         }
 928         while (line >= 0 && !IsWhiteLine(line)) { // skip non-empty lines
 929                 line--;
 930         }
 931         line++;
 932         return LineStart(line);
 933 }
 934
 935 int Document::ParaDown(int pos) {
 936         int line = LineFromPosition(pos);
 937         while (line < LinesTotal() && !IsWhiteLine(line)) { // skip non-empty lines
 938                 line++;
 939         }
 940         while (line < LinesTotal() && IsWhiteLine(line)) { // skip empty lines
 941                 line++;
 942         }
 943         if (line < LinesTotal())
 944                 return LineStart(line);
 945         else // end of a document
 946                 return LineEnd(line-1);
 947 }
 948
 949 CharClassify::cc Document::WordCharClass(unsigned char ch) {
 950         if ((SC_CP_UTF8 == dbcsCodePage) && (ch >= 0x80))
 951                 return CharClassify::ccWord;
 952         return charClass.GetClass(ch);
 953 }
 954
 955 /**
 956  * Used by commmands that want to select whole words.
 957  * Finds the start of word at pos when delta < 0 or the end of the word when delta >= 0.
 958  */
 959 int Document::ExtendWordSelect(int pos, int delta, bool onlyWordCharacters) {
 960         CharClassify::cc ccStart = CharClassify::ccWord;
 961         if (delta < 0) {
 962                 if (!onlyWordCharacters)
 963                         ccStart = WordCharClass(cb.CharAt(pos-1));
 964                 while (pos > 0 && (WordCharClass(cb.CharAt(pos - 1)) == ccStart))
 965                         pos--;
 966         } else {
 967                 if (!onlyWordCharacters && pos < Length())
 968                         ccStart = WordCharClass(cb.CharAt(pos));
 969                 while (pos < (Length()) && (WordCharClass(cb.CharAt(pos)) == ccStart))
 970                         pos++;
 971         }
 972         return MovePositionOutsideChar(pos, delta);
 973 }
 974
 975 /**
 976  * Find the start of the next word in either a forward (delta >= 0) or backwards direction
 977  * (delta < 0).
 978  * This is looking for a transition between character classes although there is also some
 979  * additional movement to transit white space.
 980  * Used by cursor movement by word commands.
 981  */
 982 int Document::NextWordStart(int pos, int delta) {
 983         if (delta < 0) {
 984                 while (pos > 0 && (WordCharClass(cb.CharAt(pos - 1)) == CharClassify::ccSpace))
 985                         pos--;
 986                 if (pos > 0) {
 987                         CharClassify::cc ccStart = WordCharClass(cb.CharAt(pos-1));
 988                         while (pos > 0 && (WordCharClass(cb.CharAt(pos - 1)) == ccStart)) {
 989                                 pos--;
 990                         }
 991                 }
 992         } else {
 993                 CharClassify::cc ccStart = WordCharClass(cb.CharAt(pos));
 994                 while (pos < (Length()) && (WordCharClass(cb.CharAt(pos)) == ccStart))
 995                         pos++;
 996                 while (pos < (Length()) && (WordCharClass(cb.CharAt(pos)) == CharClassify::ccSpace))
 997                         pos++;
 998         }
 999         return pos;
1000 }
1001
1002 /**
1003  * Find the end of the next word in either a forward (delta >= 0) or backwards direction
1004  * (delta < 0).
1005  * This is looking for a transition between character classes although there is also some
1006  * additional movement to transit white space.
1007  * Used by cursor movement by word commands.
1008  */
1009 int Document::NextWordEnd(int pos, int delta) {
1010         if (delta < 0) {
1011                 if (pos > 0) {
1012                         CharClassify::cc ccStart = WordCharClass(cb.CharAt(pos-1));
1013                         if (ccStart != CharClassify::ccSpace) {
1014                                 while (pos > 0 && WordCharClass(cb.CharAt(pos - 1)) == ccStart) {
1015                                         pos--;
1016                                 }
1017                         }
1018                         while (pos > 0 && WordCharClass(cb.CharAt(pos - 1)) == CharClassify::ccSpace) {
1019                                 pos--;
1020                         }
1021                 }
1022         } else {
1023                 while (pos < Length() && WordCharClass(cb.CharAt(pos)) == CharClassify::ccSpace) {
1024                         pos++;
1025                 }
1026                 if (pos < Length()) {
1027                         CharClassify::cc ccStart = WordCharClass(cb.CharAt(pos));
1028                         while (pos < Length() && WordCharClass(cb.CharAt(pos)) == ccStart) {
1029                                 pos++;
1030                         }
1031                 }
1032         }
1033         return pos;
1034 }
1035
1036 /**
1037  * Check that the character at the given position is a word or punctuation character and that
1038  * the previous character is of a different character class.
1039  */
1040 bool Document::IsWordStartAt(int pos) {
1041         if (pos > 0) {
1042                 CharClassify::cc ccPos = WordCharClass(CharAt(pos));
1043                 return (ccPos == CharClassify::ccWord || ccPos == CharClassify::ccPunctuation) &&
1044                         (ccPos != WordCharClass(CharAt(pos - 1)));
1045         }
1046         return true;
1047 }
1048
1049 /**
1050  * Check that the character at the given position is a word or punctuation character and that
1051  * the next character is of a different character class.
1052  */
1053 bool Document::IsWordEndAt(int pos) {
1054         if (pos < Length()) {
1055                 CharClassify::cc ccPrev = WordCharClass(CharAt(pos-1));
1056                 return (ccPrev == CharClassify::ccWord || ccPrev == CharClassify::ccPunctuation) &&
1057                         (ccPrev != WordCharClass(CharAt(pos)));
1058         }
1059         return true;
1060 }
1061
1062 /**
1063  * Check that the given range is has transitions between character classes at both
1064  * ends and where the characters on the inside are word or punctuation characters.
1065  */
1066 bool Document::IsWordAt(int start, int end) {
1067         return IsWordStartAt(start) && IsWordEndAt(end);
1068 }
1069
1070 static inline char MakeLowerCase(char ch) {
1071         if (ch < 'A' || ch > 'Z')
1072                 return ch;
1073         else
1074                 return static_cast<char>(ch - 'A' + 'a');
1075 }
1076
1077 /**
1078  * Find text in document, supporting both forward and backward
1079  * searches (just pass minPos > maxPos to do a backward search)
1080  * Has not been tested with backwards DBCS searches yet.
1081  */
1082 long Document::FindText(int minPos, int maxPos, const char *s,
1083                         bool caseSensitive, bool word, bool wordStart, bool regExp, int flags,
1084                         int *length) {
1085         if (regExp) {
1086                 if (!regex)
1087                         regex = CreateRegexSearch(&charClass);
1088                 return regex->FindText(this, minPos, maxPos, s, caseSensitive, word, wordStart, flags, length);
1089         } else {
1090
1091                 bool forward = minPos <= maxPos;
1092                 int increment = forward ? 1 : -1;
1093
1094                 // Range endpoints should not be inside DBCS characters, but just in case, move them.
1095                 int startPos = MovePositionOutsideChar(minPos, increment, false);
1096                 int endPos = MovePositionOutsideChar(maxPos, increment, false);
1097
1098                 // Compute actual search ranges needed
1099                 int lengthFind = *length;
1100                 if (lengthFind == -1)
1101                         lengthFind = static_cast<int>(strlen(s));
1102                 int endSearch = endPos;
1103                 if (startPos <= endPos) {
1104                         endSearch = endPos - lengthFind + 1;
1105                 }
1106                 //Platform::DebugPrintf("Find %d %d %s %d\n", startPos, endPos, ft->lpstrText, lengthFind);
1107                 char firstChar = s[0];
1108                 if (!caseSensitive)
1109                         firstChar = static_cast<char>(MakeUpperCase(firstChar));
1110                 int pos = forward ? startPos : (startPos - 1);
1111                 while (forward ? (pos < endSearch) : (pos >= endSearch)) {
1112                         char ch = CharAt(pos);
1113                         if (caseSensitive) {
1114                                 if (ch == firstChar) {
1115                                         bool found = true;
1116                                         if (pos + lengthFind > Platform::Maximum(startPos, endPos)) found = false;
1117                                         for (int posMatch = 1; posMatch < lengthFind && found; posMatch++) {
1118                                                 ch = CharAt(pos + posMatch);
1119                                                 if (ch != s[posMatch])
1120                                                         found = false;
1121                                         }
1122                                         if (found) {
1123                                                 if ((!word && !wordStart) ||
1124                                                         (word && IsWordAt(pos, pos + lengthFind)) ||
1125                                                         (wordStart && IsWordStartAt(pos)))
1126                                                         return pos;
1127                                         }
1128                                 }
1129                         } else {
1130                                 if (MakeUpperCase(ch) == firstChar) {
1131                                         bool found = true;
1132                                         if (pos + lengthFind > Platform::Maximum(startPos, endPos)) found = false;
1133                                         for (int posMatch = 1; posMatch < lengthFind && found; posMatch++) {
1134                                                 ch = CharAt(pos + posMatch);
1135                                                 if (MakeUpperCase(ch) != MakeUpperCase(s[posMatch]))
1136                                                         found = false;
1137                                         }
1138                                         if (found) {
1139                                                 if ((!word && !wordStart) ||
1140                                                         (word && IsWordAt(pos, pos + lengthFind)) ||
1141                                                         (wordStart && IsWordStartAt(pos)))
1142                                                         return pos;
1143                                         }
1144                                 }
1145                         }
1146                         pos += increment;
1147                         if (dbcsCodePage && (pos >= 0)) {
1148                                 // Ensure trying to match from start of character
1149                                 pos = MovePositionOutsideChar(pos, increment, false);
1150                         }
1151                 }
1152         }
1153         //Platform::DebugPrintf("Not found\n");
1154         return -1;
1155 }
1156
1157 const char *Document::SubstituteByPosition(const char *text, int *length) {
1158         return regex->SubstituteByPosition(this, text, length);
1159 }
1160
1161 int Document::LinesTotal() const {
1162         return cb.Lines();
1163 }
1164
1165 void Document::ChangeCase(Range r, bool makeUpperCase) {
1166         for (int pos = r.start; pos < r.end;) {
1167                 int len = LenChar(pos);
1168                 if (len == 1) {
1169                         char ch = CharAt(pos);
1170                         if (makeUpperCase) {
1171                                 if (IsLowerCase(ch)) {
1172                                         ChangeChar(pos, static_cast<char>(MakeUpperCase(ch)));
1173                                 }
1174                         } else {
1175                                 if (IsUpperCase(ch)) {
1176                                         ChangeChar(pos, static_cast<char>(MakeLowerCase(ch)));
1177                                 }
1178                         }
1179                 }
1180                 pos += len;
1181         }
1182 }
1183
1184 void Document::SetDefaultCharClasses(bool includeWordClass) {
1185     charClass.SetDefaultCharClasses(includeWordClass);
1186 }
1187
1188 void Document::SetCharClasses(const unsigned char *chars, CharClassify::cc newCharClass) {
1189     charClass.SetCharClasses(chars, newCharClass);
1190 }
1191
1192 void Document::SetStylingBits(int bits) {
1193         stylingBits = bits;
1194         stylingBitsMask = (1 << stylingBits) - 1;
1195 }
1196
1197 void Document::StartStyling(int position, char mask) {
1198         stylingMask = mask;
1199         endStyled = position;
1200 }
1201
1202 bool Document::SetStyleFor(int length, char style) {
1203         if (enteredStyling != 0) {
1204                 return false;
1205         } else {
1206                 enteredStyling++;
1207                 style &= stylingMask;
1208                 int prevEndStyled = endStyled;
1209                 if (cb.SetStyleFor(endStyled, length, style, stylingMask)) {
1210                         DocModification mh(SC_MOD_CHANGESTYLE | SC_PERFORMED_USER,
1211                                            prevEndStyled, length);
1212                         NotifyModified(mh);
1213                 }
1214                 endStyled += length;
1215                 enteredStyling--;
1216                 return true;
1217         }
1218 }
1219
1220 bool Document::SetStyles(int length, const char *styles) {
1221         if (enteredStyling != 0) {
1222                 return false;
1223         } else {
1224                 enteredStyling++;
1225                 bool didChange = false;
1226                 int startMod = 0;
1227                 int endMod = 0;
1228                 for (int iPos = 0; iPos < length; iPos++, endStyled++) {
1229                         PLATFORM_ASSERT(endStyled < Length());
1230                         if (cb.SetStyleAt(endStyled, styles[iPos], stylingMask)) {
1231                                 if (!didChange) {
1232                                         startMod = endStyled;
1233                                 }
1234                                 didChange = true;
1235                                 endMod = endStyled;
1236                         }
1237                 }
1238                 if (didChange) {
1239                         DocModification mh(SC_MOD_CHANGESTYLE | SC_PERFORMED_USER,
1240                                            startMod, endMod - startMod + 1);
1241                         NotifyModified(mh);
1242                 }
1243                 enteredStyling--;
1244                 return true;
1245         }
1246 }
1247
1248 void Document::EnsureStyledTo(int pos) {
1249         if ((enteredStyling == 0) && (pos > GetEndStyled())) {
1250                 IncrementStyleClock();
1251                 // Ask the watchers to style, and stop as soon as one responds.
1252                 for (int i = 0; pos > GetEndStyled() && i < lenWatchers; i++) {
1253                         watchers[i].watcher->NotifyStyleNeeded(this, watchers[i].userData, pos);
1254                 }
1255         }
1256 }
1257
1258 int Document::SetLineState(int line, int state) {
1259         int statePrevious = static_cast<LineState*>(perLineData[ldState])->SetLineState(line, state);
1260         if (state != statePrevious) {
1261                 DocModification mh(SC_MOD_CHANGELINESTATE, 0, 0, 0, 0, line);
1262                 NotifyModified(mh);
1263         }
1264         return statePrevious;
1265 }
1266
1267 int Document::GetLineState(int line) {
1268         return static_cast<LineState*>(perLineData[ldState])->GetLineState(line);
1269 }
1270
1271 int Document::GetMaxLineState() {
1272         return static_cast<LineState*>(perLineData[ldState])->GetMaxLineState();
1273 }
1274
1275 StyledText Document::MarginStyledText(int line) {
1276         LineAnnotation *pla = static_cast<LineAnnotation*>(perLineData[ldMargin]);
1277         return StyledText(pla->Length(line), pla->Text(line),
1278                 pla->MultipleStyles(line), pla->Style(line), pla->Styles(line));
1279 }
1280
1281 void Document::MarginSetText(int line, const char *text) {
1282         static_cast<LineAnnotation*>(perLineData[ldMargin])->SetText(line, text);
1283         DocModification mh(SC_MOD_CHANGEMARGIN, LineStart(line), 0, 0, 0, line);
1284         NotifyModified(mh);
1285 }
1286
1287 void Document::MarginSetStyle(int line, int style) {
1288         static_cast<LineAnnotation*>(perLineData[ldMargin])->SetStyle(line, style);
1289 }
1290
1291 void Document::MarginSetStyles(int line, const unsigned char *styles) {
1292         static_cast<LineAnnotation*>(perLineData[ldMargin])->SetStyles(line, styles);
1293 }
1294
1295 int Document::MarginLength(int line) const {
1296         return static_cast<LineAnnotation*>(perLineData[ldMargin])->Length(line);
1297 }
1298
1299 void Document::MarginClearAll() {
1300         int maxEditorLine = LinesTotal();
1301         for (int l=0;l<maxEditorLine;l++)
1302                 MarginSetText(l, 0);
1303         // Free remaining data
1304         static_cast<LineAnnotation*>(perLineData[ldMargin])->ClearAll();
1305 }
1306
1307 bool Document::AnnotationAny() const {
1308         return static_cast<LineAnnotation*>(perLineData[ldAnnotation])->AnySet();
1309 }
1310
1311 StyledText Document::AnnotationStyledText(int line) {
1312         LineAnnotation *pla = static_cast<LineAnnotation*>(perLineData[ldAnnotation]);
1313         return StyledText(pla->Length(line), pla->Text(line),
1314                 pla->MultipleStyles(line), pla->Style(line), pla->Styles(line));
1315 }
1316
1317 void Document::AnnotationSetText(int line, const char *text) {
1318         const int linesBefore = AnnotationLines(line);
1319         static_cast<LineAnnotation*>(perLineData[ldAnnotation])->SetText(line, text);
1320         const int linesAfter = AnnotationLines(line);
1321         DocModification mh(SC_MOD_CHANGEANNOTATION, LineStart(line), 0, 0, 0, line);
1322         mh.annotationLinesAdded = linesAfter - linesBefore;
1323         NotifyModified(mh);
1324 }
1325
1326 void Document::AnnotationSetStyle(int line, int style) {
1327         static_cast<LineAnnotation*>(perLineData[ldAnnotation])->SetStyle(line, style);
1328 }
1329
1330 void Document::AnnotationSetStyles(int line, const unsigned char *styles) {
1331         static_cast<LineAnnotation*>(perLineData[ldAnnotation])->SetStyles(line, styles);
1332 }
1333
1334 int Document::AnnotationLength(int line) const {
1335         return static_cast<LineAnnotation*>(perLineData[ldAnnotation])->Length(line);
1336 }
1337
1338 int Document::AnnotationLines(int line) const {
1339         return static_cast<LineAnnotation*>(perLineData[ldAnnotation])->Lines(line);
1340 }
1341
1342 void Document::AnnotationClearAll() {
1343         int maxEditorLine = LinesTotal();
1344         for (int l=0;l<maxEditorLine;l++)
1345                 AnnotationSetText(l, 0);
1346         // Free remaining data
1347         static_cast<LineAnnotation*>(perLineData[ldAnnotation])->ClearAll();
1348 }
1349
1350 void Document::IncrementStyleClock() {
1351         styleClock = (styleClock + 1) % 0x100000;
1352 }
1353
1354 void Document::DecorationFillRange(int position, int value, int fillLength) {
1355         if (decorations.FillRange(position, value, fillLength)) {
1356                 DocModification mh(SC_MOD_CHANGEINDICATOR | SC_PERFORMED_USER,
1357                                                         position, fillLength);
1358                 NotifyModified(mh);
1359         }
1360 }
1361
1362 bool Document::AddWatcher(DocWatcher *watcher, void *userData) {
1363         for (int i = 0; i < lenWatchers; i++) {
1364                 if ((watchers[i].watcher == watcher) &&
1365                         (watchers[i].userData == userData))
1366                         return false;
1367         }
1368         WatcherWithUserData *pwNew = new WatcherWithUserData[lenWatchers + 1];
1369         for (int j = 0; j < lenWatchers; j++)
1370                 pwNew[j] = watchers[j];
1371         pwNew[lenWatchers].watcher = watcher;
1372         pwNew[lenWatchers].userData = userData;
1373         delete []watchers;
1374         watchers = pwNew;
1375         lenWatchers++;
1376         return true;
1377 }
1378
1379 bool Document::RemoveWatcher(DocWatcher *watcher, void *userData) {
1380         for (int i = 0; i < lenWatchers; i++) {
1381                 if ((watchers[i].watcher == watcher) &&
1382                         (watchers[i].userData == userData)) {
1383                         if (lenWatchers == 1) {
1384                                 delete []watchers;
1385                                 watchers = 0;
1386                                 lenWatchers = 0;
1387                         } else {
1388                                 WatcherWithUserData *pwNew = new WatcherWithUserData[lenWatchers];
1389                                 for (int j = 0; j < lenWatchers - 1; j++) {
1390                                         pwNew[j] = (j < i) ? watchers[j] : watchers[j + 1];
1391                                 }
1392                                 delete []watchers;
1393                                 watchers = pwNew;
1394                                 lenWatchers--;
1395                         }
1396                         return true;
1397                 }
1398         }
1399         return false;
1400 }
1401
1402 void Document::NotifyModifyAttempt() {
1403         for (int i = 0; i < lenWatchers; i++) {
1404                 watchers[i].watcher->NotifyModifyAttempt(this, watchers[i].userData);
1405         }
1406 }
1407
1408 void Document::NotifySavePoint(bool atSavePoint) {
1409         for (int i = 0; i < lenWatchers; i++) {
1410                 watchers[i].watcher->NotifySavePoint(this, watchers[i].userData, atSavePoint);
1411         }
1412 }
1413
1414 void Document::NotifyModified(DocModification mh) {
1415         if (mh.modificationType & SC_MOD_INSERTTEXT) {
1416                 decorations.InsertSpace(mh.position, mh.length);
1417         } else if (mh.modificationType & SC_MOD_DELETETEXT) {
1418                 decorations.DeleteRange(mh.position, mh.length);
1419         }
1420         for (int i = 0; i < lenWatchers; i++) {
1421                 watchers[i].watcher->NotifyModified(this, mh, watchers[i].userData);
1422         }
1423 }
1424
1425 bool Document::IsWordPartSeparator(char ch) {
1426         return (WordCharClass(ch) == CharClassify::ccWord) && IsPunctuation(ch);
1427 }
1428
1429 int Document::WordPartLeft(int pos) {
1430         if (pos > 0) {
1431                 --pos;
1432                 char startChar = cb.CharAt(pos);
1433                 if (IsWordPartSeparator(startChar)) {
1434                         while (pos > 0 && IsWordPartSeparator(cb.CharAt(pos))) {
1435                                 --pos;
1436                         }
1437                 }
1438                 if (pos > 0) {
1439                         startChar = cb.CharAt(pos);
1440                         --pos;
1441                         if (IsLowerCase(startChar)) {
1442                                 while (pos > 0 && IsLowerCase(cb.CharAt(pos)))
1443                                         --pos;
1444                                 if (!IsUpperCase(cb.CharAt(pos)) && !IsLowerCase(cb.CharAt(pos)))
1445                                         ++pos;
1446                         } else if (IsUpperCase(startChar)) {
1447                                 while (pos > 0 && IsUpperCase(cb.CharAt(pos)))
1448                                         --pos;
1449                                 if (!IsUpperCase(cb.CharAt(pos)))
1450                                         ++pos;
1451                         } else if (IsADigit(startChar)) {
1452                                 while (pos > 0 && IsADigit(cb.CharAt(pos)))
1453                                         --pos;
1454                                 if (!IsADigit(cb.CharAt(pos)))
1455                                         ++pos;
1456                         } else if (IsPunctuation(startChar)) {
1457                                 while (pos > 0 && IsPunctuation(cb.CharAt(pos)))
1458                                         --pos;
1459                                 if (!IsPunctuation(cb.CharAt(pos)))
1460                                         ++pos;
1461                         } else if (isspacechar(startChar)) {
1462                                 while (pos > 0 && isspacechar(cb.CharAt(pos)))
1463                                         --pos;
1464                                 if (!isspacechar(cb.CharAt(pos)))
1465                                         ++pos;
1466                         } else if (!isascii(startChar)) {
1467                                 while (pos > 0 && !isascii(cb.CharAt(pos)))
1468                                         --pos;
1469                                 if (isascii(cb.CharAt(pos)))
1470                                         ++pos;
1471                         } else {
1472                                 ++pos;
1473                         }
1474                 }
1475         }
1476         return pos;
1477 }
1478
1479 int Document::WordPartRight(int pos) {
1480         char startChar = cb.CharAt(pos);
1481         int length = Length();
1482         if (IsWordPartSeparator(startChar)) {
1483                 while (pos < length && IsWordPartSeparator(cb.CharAt(pos)))
1484                         ++pos;
1485                 startChar = cb.CharAt(pos);
1486         }
1487         if (!isascii(startChar)) {
1488                 while (pos < length && !isascii(cb.CharAt(pos)))
1489                         ++pos;
1490         } else if (IsLowerCase(startChar)) {
1491                 while (pos < length && IsLowerCase(cb.CharAt(pos)))
1492                         ++pos;
1493         } else if (IsUpperCase(startChar)) {
1494                 if (IsLowerCase(cb.CharAt(pos + 1))) {
1495                         ++pos;
1496                         while (pos < length && IsLowerCase(cb.CharAt(pos)))
1497                                 ++pos;
1498                 } else {
1499                         while (pos < length && IsUpperCase(cb.CharAt(pos)))
1500                                 ++pos;
1501                 }
1502                 if (IsLowerCase(cb.CharAt(pos)) && IsUpperCase(cb.CharAt(pos - 1)))
1503                         --pos;
1504         } else if (IsADigit(startChar)) {
1505                 while (pos < length && IsADigit(cb.CharAt(pos)))
1506                         ++pos;
1507         } else if (IsPunctuation(startChar)) {
1508                 while (pos < length && IsPunctuation(cb.CharAt(pos)))
1509                         ++pos;
1510         } else if (isspacechar(startChar)) {
1511                 while (pos < length && isspacechar(cb.CharAt(pos)))
1512                         ++pos;
1513         } else {
1514                 ++pos;
1515         }
1516         return pos;
1517 }
1518
1519 bool IsLineEndChar(char c) {
1520         return (c == '\n' || c == '\r');
1521 }
1522
1523 int Document::ExtendStyleRange(int pos, int delta, bool singleLine) {
1524         int sStart = cb.StyleAt(pos);
1525         if (delta < 0) {
1526                 while (pos > 0 && (cb.StyleAt(pos) == sStart) && (!singleLine || !IsLineEndChar(cb.CharAt(pos))) )
1527                         pos--;
1528                 pos++;
1529         } else {
1530                 while (pos < (Length()) && (cb.StyleAt(pos) == sStart) && (!singleLine || !IsLineEndChar(cb.CharAt(pos))) )
1531                         pos++;
1532         }
1533         return pos;
1534 }
1535
1536 static char BraceOpposite(char ch) {
1537         switch (ch) {
1538         case '(':
1539                 return ')';
1540         case ')':
1541                 return '(';
1542         case '[':
1543                 return ']';
1544         case ']':
1545                 return '[';
1546         case '{':
1547                 return '}';
1548         case '}':
1549                 return '{';
1550         case '<':
1551                 return '>';
1552         case '>':
1553                 return '<';
1554         default:
1555                 return '\0';
1556         }
1557 }
1558
1559 // TODO: should be able to extend styled region to find matching brace
1560 int Document::BraceMatch(int position, int /*maxReStyle*/) {
1561         char chBrace = CharAt(position);
1562         char chSeek = BraceOpposite(chBrace);
1563         if (chSeek == '\0')
1564                 return - 1;
1565         char styBrace = static_cast<char>(StyleAt(position) & stylingBitsMask);
1566         int direction = -1;
1567         if (chBrace == '(' || chBrace == '[' || chBrace == '{' || chBrace == '<')
1568                 direction = 1;
1569         int depth = 1;
1570         position = position + direction;
1571         while ((position >= 0) && (position < Length())) {
1572                 position = MovePositionOutsideChar(position, direction);
1573                 char chAtPos = CharAt(position);
1574                 char styAtPos = static_cast<char>(StyleAt(position) & stylingBitsMask);
1575                 if ((position > GetEndStyled()) || (styAtPos == styBrace)) {
1576                         if (chAtPos == chBrace)
1577                                 depth++;
1578                         if (chAtPos == chSeek)
1579                                 depth--;
1580                         if (depth == 0)
1581                                 return position;
1582                 }
1583                 position = position + direction;
1584         }
1585         return - 1;
1586 }
1587
1588 /**
1589  * Implementation of RegexSearchBase for the default built-in regular expression engine
1590  */
1591 class BuiltinRegex : public RegexSearchBase {
1592 public:
1593         BuiltinRegex(CharClassify *charClassTable) : search(charClassTable), substituted(NULL) {}
1594
1595         virtual ~BuiltinRegex() {
1596                 delete substituted;
1597         }
1598
1599         virtual long FindText(Document *doc, int minPos, int maxPos, const char *s,
1600                         bool caseSensitive, bool word, bool wordStart, int flags,
1601                         int *length);
1602
1603         virtual const char *SubstituteByPosition(Document* doc, const char *text, int *length);
1604
1605 private:
1606         RESearch search;
1607         char *substituted;
1608 };
1609
1610 // Define a way for the Regular Expression code to access the document
1611 class DocumentIndexer : public CharacterIndexer {
1612         Document *pdoc;
1613         int end;
1614 public:
1615         DocumentIndexer(Document *pdoc_, int end_) :
1616                 pdoc(pdoc_), end(end_) {
1617         }
1618
1619         virtual ~DocumentIndexer() {
1620         }
1621
1622         virtual char CharAt(int index) {
1623                 if (index < 0 || index >= end)
1624                         return 0;
1625                 else
1626                         return pdoc->CharAt(index);
1627         }
1628 };
1629
1630 long BuiltinRegex::FindText(Document *doc, int minPos, int maxPos, const char *s,
1631                         bool caseSensitive, bool, bool, int flags,
1632                         int *length) {
1633         bool posix = (flags & SCFIND_POSIX) != 0;
1634         int increment = (minPos <= maxPos) ? 1 : -1;
1635
1636         int startPos = minPos;
1637         int endPos = maxPos;
1638
1639         // Range endpoints should not be inside DBCS characters, but just in case, move them.
1640         startPos = doc->MovePositionOutsideChar(startPos, 1, false);
1641         endPos = doc->MovePositionOutsideChar(endPos, 1, false);
1642
1643         const char *errmsg = search.Compile(s, *length, caseSensitive, posix);
1644         if (errmsg) {
1645                 return -1;
1646         }
1647         // Find a variable in a property file: \$(\([A-Za-z0-9_.]+\))
1648         // Replace first '.' with '-' in each property file variable reference:
1649         //     Search: \$(\([A-Za-z0-9_-]+\)\.\([A-Za-z0-9_.]+\))
1650         //     Replace: $(\1-\2)
1651         int lineRangeStart = doc->LineFromPosition(startPos);
1652         int lineRangeEnd = doc->LineFromPosition(endPos);
1653         if ((increment == 1) &&
1654                 (startPos >= doc->LineEnd(lineRangeStart)) &&
1655                 (lineRangeStart < lineRangeEnd)) {
1656                 // the start position is at end of line or between line end characters.
1657                 lineRangeStart++;
1658                 startPos = doc->LineStart(lineRangeStart);
1659         }
1660         int pos = -1;
1661         int lenRet = 0;
1662         char searchEnd = s[*length - 1];
1663         int lineRangeBreak = lineRangeEnd + increment;
1664         for (int line = lineRangeStart; line != lineRangeBreak; line += increment) {
1665                 int startOfLine = doc->LineStart(line);
1666                 int endOfLine = doc->LineEnd(line);
1667                 if (increment == 1) {
1668                         if (line == lineRangeStart) {
1669                                 if ((startPos != startOfLine) && (s[0] == '^'))
1670                                         continue;       // Can't match start of line if start position after start of line
1671                                 startOfLine = startPos;
1672                         }
1673                         if (line == lineRangeEnd) {
1674                                 if ((endPos != endOfLine) && (searchEnd == '$'))
1675                                         continue;       // Can't match end of line if end position before end of line
1676                                 endOfLine = endPos;
1677                         }
1678                 } else {
1679                         if (line == lineRangeEnd) {
1680                                 if ((endPos != startOfLine) && (s[0] == '^'))
1681                                         continue;       // Can't match start of line if end position after start of line
1682                                 startOfLine = endPos;
1683                         }
1684                         if (line == lineRangeStart) {
1685                                 if ((startPos != endOfLine) && (searchEnd == '$'))
1686                                         continue;       // Can't match end of line if start position before end of line
1687                                 endOfLine = startPos;
1688                         }
1689                 }
1690
1691                 DocumentIndexer di(doc, endOfLine);
1692                 int success = search.Execute(di, startOfLine, endOfLine);
1693                 if (success) {
1694                         pos = search.bopat[0];
1695                         lenRet = search.eopat[0] - search.bopat[0];
1696                         if (increment == -1) {
1697                                 // Check for the last match on this line.
1698                                 int repetitions = 1000; // Break out of infinite loop
1699                                 while (success && (search.eopat[0] <= endOfLine) && (repetitions--)) {
1700                                         success = search.Execute(di, pos+1, endOfLine);
1701                                         if (success) {
1702                                                 if (search.eopat[0] <= minPos) {
1703                                                         pos = search.bopat[0];
1704                                                         lenRet = search.eopat[0] - search.bopat[0];
1705                                                 } else {
1706                                                         success = 0;
1707                                                 }
1708                                         }
1709                                 }
1710                         }
1711                         break;
1712                 }
1713         }
1714         *length = lenRet;
1715         return pos;
1716 }
1717
1718 const char *BuiltinRegex::SubstituteByPosition(Document* doc, const char *text, int *length) {
1719         delete []substituted;
1720         substituted = 0;
1721         DocumentIndexer di(doc, doc->Length());
1722         if (!search.GrabMatches(di))
1723                 return 0;
1724         unsigned int lenResult = 0;
1725         for (int i = 0; i < *length; i++) {
1726                 if (text[i] == '\\') {
1727                         if (text[i + 1] >= '1' && text[i + 1] <= '9') {
1728                                 unsigned int patNum = text[i + 1] - '0';
1729                                 lenResult += search.eopat[patNum] - search.bopat[patNum];
1730                                 i++;
1731                         } else {
1732                                 switch (text[i + 1]) {
1733                                 case 'a':
1734                                 case 'b':
1735                                 case 'f':
1736                                 case 'n':
1737                                 case 'r':
1738                                 case 't':
1739                                 case 'v':
1740                                         i++;
1741                                 }
1742                                 lenResult++;
1743                         }
1744                 } else {
1745                         lenResult++;
1746                 }
1747         }
1748         substituted = new char[lenResult + 1];
1749         char *o = substituted;
1750         for (int j = 0; j < *length; j++) {
1751                 if (text[j] == '\\') {
1752                         if (text[j + 1] >= '1' && text[j + 1] <= '9') {
1753                                 unsigned int patNum = text[j + 1] - '0';
1754                                 unsigned int len = search.eopat[patNum] - search.bopat[patNum];
1755                                 if (search.pat[patNum]) // Will be null if try for a match that did not occur
1756                                         memcpy(o, search.pat[patNum], len);
1757                                 o += len;
1758                                 j++;
1759                         } else {
1760                                 j++;
1761                                 switch (text[j]) {
1762                                 case 'a':
1763                                         *o++ = '\a';
1764                                         break;
1765                                 case 'b':
1766                                         *o++ = '\b';
1767                                         break;
1768                                 case 'f':
1769                                         *o++ = '\f';
1770                                         break;
1771                                 case 'n':
1772                                         *o++ = '\n';
1773                                         break;
1774                                 case 'r':
1775                                         *o++ = '\r';
1776                                         break;
1777                                 case 't':
1778                                         *o++ = '\t';
1779                                         break;
1780                                 case 'v':
1781                                         *o++ = '\v';
1782                                         break;
1783                                 default:
1784                                         *o++ = '\\';
1785                                         j--;
1786                                 }
1787                         }
1788                 } else {
1789                         *o++ = text[j];
1790                 }
1791         }
1792         *o = '\0';
1793         *length = lenResult;
1794         return substituted;
1795 }
1796
1797 #ifndef SCI_OWNREGEX
1798
1799 #ifdef SCI_NAMESPACE
1800
1801 RegexSearchBase *Scintilla::CreateRegexSearch(CharClassify *charClassTable) {
1802         return new BuiltinRegex(charClassTable);
1803 }
1804
1805 #else
1806
1807 RegexSearchBase *CreateRegexSearch(CharClassify *charClassTable) {
1808         return new BuiltinRegex(charClassTable);
1809 }
1810
1811 #endif
1812
1813 #endif