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