scintilla/lexers/LexPascal.cxx

   1 // Scintilla source code edit control
   2 /** @file LexPascal.cxx
   3  ** Lexer for Pascal.
   4  ** Written by Laurent le Tynevez
   5  ** Updated by Simon Steele <s.steele@pnotepad.org> September 2002
   6  ** Updated by Mathias Rauen <scite@madshi.net> May 2003 (Delphi adjustments)
   7  ** Completely rewritten by Marko Njezic <sf@maxempire.com> October 2008
   8  **/
   9
  10 /*
  11
  12 A few words about features of the new completely rewritten LexPascal...
  13
  14 Generally speaking LexPascal tries to support all available Delphi features (up
  15 to Delphi XE4 at this time).
  16
  17 ~ HIGHLIGHTING:
  18
  19 If you enable "lexer.pascal.smart.highlighting" property, some keywords will
  20 only be highlighted in appropriate context. As implemented those are keywords
  21 related to property and DLL exports declarations (similar to how Delphi IDE
  22 works).
  23
  24 For example, keywords "read" and "write" will only be highlighted if they are in
  25 property declaration:
  26
  27 property MyProperty: boolean read FMyProperty write FMyProperty;
  28
  29 ~ FOLDING:
  30
  31 Folding is supported in the following cases:
  32
  33 - Folding of stream-like comments
  34 - Folding of groups of consecutive line comments
  35 - Folding of preprocessor blocks (the following preprocessor blocks are
  36 supported: IF / IFEND; IFDEF, IFNDEF, IFOPT / ENDIF and REGION / ENDREGION
  37 blocks), including nesting of preprocessor blocks up to 255 levels
  38 - Folding of code blocks on appropriate keywords (the following code blocks are
  39 supported: "begin, asm, record, try, case / end" blocks, class & object
  40 declarations and interface declarations)
  41
  42 Remarks:
  43
  44 - Folding of code blocks tries to handle all special cases in which folding
  45 should not occur. As implemented those are:
  46
  47 1. Structure "record case / end" (there's only one "end" statement and "case" is
  48 ignored as fold point)
  49 2. Forward class declarations ("type TMyClass = class;") and object method
  50 declarations ("TNotifyEvent = procedure(Sender: TObject) of object;") are
  51 ignored as fold points
  52 3. Simplified complete class declarations ("type TMyClass = class(TObject);")
  53 are ignored as fold points
  54 4. Every other situation when class keyword doesn't actually start class
  55 declaration ("class procedure", "class function", "class of", "class var",
  56 "class property" and "class operator")
  57 5. Forward (disp)interface declarations ("type IMyInterface = interface;") are
  58 ignored as fold points
  59
  60 - Folding of code blocks inside preprocessor blocks is disabled (any comments
  61 inside them will be folded fine) because there is no guarantee that complete
  62 code block will be contained inside folded preprocessor block in which case
  63 folded code block could end prematurely at the end of preprocessor block if
  64 there is no closing statement inside. This was done in order to properly process
  65 document that may contain something like this:
  66
  67 type
  68 {$IFDEF UNICODE}
  69   TMyClass = class(UnicodeAncestor)
  70 {$ELSE}
  71   TMyClass = class(AnsiAncestor)
  72 {$ENDIF}
  73   private
  74   ...
  75   public
  76   ...
  77   published
  78   ...
  79 end;
  80
  81 If class declarations were folded, then the second class declaration would end
  82 at "$ENDIF" statement, first class statement would end at "end;" statement and
  83 preprocessor "$IFDEF" block would go all the way to the end of document.
  84 However, having in mind all this, if you want to enable folding of code blocks
  85 inside preprocessor blocks, you can disable folding of preprocessor blocks by
  86 changing "fold.preprocessor" property, in which case everything inside them
  87 would be folded.
  88
  89 ~ KEYWORDS:
  90
  91 The list of keywords that can be used in pascal.properties file (up to Delphi
  92 XE4):
  93
  94 - Keywords: absolute abstract and array as asm assembler automated begin case
  95 cdecl class const constructor delayed deprecated destructor dispid dispinterface
  96 div do downto dynamic else end except experimental export exports external far
  97 file final finalization finally for forward function goto helper if
  98 implementation in inherited initialization inline interface is label library
  99 message mod near nil not object of on operator or out overload override packed
 100 pascal platform private procedure program property protected public published
 101 raise record reference register reintroduce repeat resourcestring safecall
 102 sealed set shl shr static stdcall strict string then threadvar to try type unit
 103 unsafe until uses var varargs virtual while winapi with xor
 104
 105 - Keywords related to the "smart highlithing" feature: add default implements
 106 index name nodefault read readonly remove stored write writeonly
 107
 108 - Keywords related to Delphi packages (in addition to all above): package
 109 contains requires
 110
 111 */
 112
 113 #include <stdlib.h>
 114 #include <string.h>
 115 #include <stdio.h>
 116 #include <stdarg.h>
 117 #include <assert.h>
 118 #include <ctype.h>
 119
 120 #include "ILexer.h"
 121 #include "Scintilla.h"
 122 #include "SciLexer.h"
 123
 124 #include "WordList.h"
 125 #include "LexAccessor.h"
 126 #include "Accessor.h"
 127 #include "StyleContext.h"
 128 #include "CharacterSet.h"
 129 #include "LexerModule.h"
 130
 131 #ifdef SCI_NAMESPACE
 132 using namespace Scintilla;
 133 #endif
 134
 135 static void GetRangeLowered(unsigned int start,
 136                 unsigned int end,
 137                 Accessor &styler,
 138                 char *s,
 139                 unsigned int len) {
 140         unsigned int i = 0;
 141         while ((i < end - start + 1) && (i < len-1)) {
 142                 s[i] = static_cast<char>(tolower(styler[start + i]));
 143                 i++;
 144         }
 145         s[i] = '\0';
 146 }
 147
 148 static void GetForwardRangeLowered(unsigned int start,
 149                 CharacterSet &charSet,
 150                 Accessor &styler,
 151                 char *s,
 152                 unsigned int len) {
 153         unsigned int i = 0;
 154         while ((i < len-1) && charSet.Contains(styler.SafeGetCharAt(start + i))) {
 155                 s[i] = static_cast<char>(tolower(styler.SafeGetCharAt(start + i)));
 156                 i++;
 157         }
 158         s[i] = '\0';
 159
 160 }
 161
 162 enum {
 163         stateInAsm = 0x1000,
 164         stateInProperty = 0x2000,
 165         stateInExport = 0x4000,
 166         stateFoldInPreprocessor = 0x0100,
 167         stateFoldInRecord = 0x0200,
 168         stateFoldInPreprocessorLevelMask = 0x00FF,
 169         stateFoldMaskAll = 0x0FFF
 170 };
 171
 172 static void ClassifyPascalWord(WordList *keywordlists[], StyleContext &sc, int &curLineState, bool bSmartHighlighting) {
 173         WordList& keywords = *keywordlists[0];
 174
 175         char s[100];
 176         sc.GetCurrentLowered(s, sizeof(s));
 177         if (keywords.InList(s)) {
 178                 if (curLineState & stateInAsm) {
 179                         if (strcmp(s, "end") == 0 && sc.GetRelative(-4) != '@') {
 180                                 curLineState &= ~stateInAsm;
 181                                 sc.ChangeState(SCE_PAS_WORD);
 182                         } else {
 183                                 sc.ChangeState(SCE_PAS_ASM);
 184                         }
 185                 } else {
 186                         bool ignoreKeyword = false;
 187                         if (strcmp(s, "asm") == 0) {
 188                                 curLineState |= stateInAsm;
 189                         } else if (bSmartHighlighting) {
 190                                 if (strcmp(s, "property") == 0) {
 191                                         curLineState |= stateInProperty;
 192                                 } else if (strcmp(s, "exports") == 0) {
 193                                         curLineState |= stateInExport;
 194                                 } else if (!(curLineState & (stateInProperty | stateInExport)) && strcmp(s, "index") == 0) {
 195                                         ignoreKeyword = true;
 196                                 } else if (!(curLineState & stateInExport) && strcmp(s, "name") == 0) {
 197                                         ignoreKeyword = true;
 198                                 } else if (!(curLineState & stateInProperty) &&
 199                                         (strcmp(s, "read") == 0 || strcmp(s, "write") == 0 ||
 200                                          strcmp(s, "default") == 0 || strcmp(s, "nodefault") == 0 ||
 201                                          strcmp(s, "stored") == 0 || strcmp(s, "implements") == 0 ||
 202                                          strcmp(s, "readonly") == 0 || strcmp(s, "writeonly") == 0 ||
 203                                          strcmp(s, "add") == 0 || strcmp(s, "remove") == 0)) {
 204                                         ignoreKeyword = true;
 205                                 }
 206                         }
 207                         if (!ignoreKeyword) {
 208                                 sc.ChangeState(SCE_PAS_WORD);
 209                         }
 210                 }
 211         } else if (curLineState & stateInAsm) {
 212                 sc.ChangeState(SCE_PAS_ASM);
 213         }
 214         sc.SetState(SCE_PAS_DEFAULT);
 215 }
 216
 217 static void ColourisePascalDoc(unsigned int startPos, int length, int initStyle, WordList *keywordlists[],
 218                 Accessor &styler) {
 219         bool bSmartHighlighting = styler.GetPropertyInt("lexer.pascal.smart.highlighting", 1) != 0;
 220
 221         CharacterSet setWordStart(CharacterSet::setAlpha, "_", 0x80, true);
 222         CharacterSet setWord(CharacterSet::setAlphaNum, "_", 0x80, true);
 223         CharacterSet setNumber(CharacterSet::setDigits, ".-+eE");
 224         CharacterSet setHexNumber(CharacterSet::setDigits, "abcdefABCDEF");
 225         CharacterSet setOperator(CharacterSet::setNone, "#$&'()*+,-./:;<=>@[]^{}");
 226
 227         int curLine = styler.GetLine(startPos);
 228         int curLineState = curLine > 0 ? styler.GetLineState(curLine - 1) : 0;
 229
 230         StyleContext sc(startPos, length, initStyle, styler);
 231
 232         for (; sc.More(); sc.Forward()) {
 233                 if (sc.atLineEnd) {
 234                         // Update the line state, so it can be seen by next line
 235                         curLine = styler.GetLine(sc.currentPos);
 236                         styler.SetLineState(curLine, curLineState);
 237                 }
 238
 239                 // Determine if the current state should terminate.
 240                 switch (sc.state) {
 241                         case SCE_PAS_NUMBER:
 242                                 if (!setNumber.Contains(sc.ch) || (sc.ch == '.' && sc.chNext == '.')) {
 243                                         sc.SetState(SCE_PAS_DEFAULT);
 244                                 } else if (sc.ch == '-' || sc.ch == '+') {
 245                                         if (sc.chPrev != 'E' && sc.chPrev != 'e') {
 246                                                 sc.SetState(SCE_PAS_DEFAULT);
 247                                         }
 248                                 }
 249                                 break;
 250                         case SCE_PAS_IDENTIFIER:
 251                                 if (!setWord.Contains(sc.ch)) {
 252                                         ClassifyPascalWord(keywordlists, sc, curLineState, bSmartHighlighting);
 253                                 }
 254                                 break;
 255                         case SCE_PAS_HEXNUMBER:
 256                                 if (!setHexNumber.Contains(sc.ch)) {
 257                                         sc.SetState(SCE_PAS_DEFAULT);
 258                                 }
 259                                 break;
 260                         case SCE_PAS_COMMENT:
 261                         case SCE_PAS_PREPROCESSOR:
 262                                 if (sc.ch == '}') {
 263                                         sc.ForwardSetState(SCE_PAS_DEFAULT);
 264                                 }
 265                                 break;
 266                         case SCE_PAS_COMMENT2:
 267                         case SCE_PAS_PREPROCESSOR2:
 268                                 if (sc.Match('*', ')')) {
 269                                         sc.Forward();
 270                                         sc.ForwardSetState(SCE_PAS_DEFAULT);
 271                                 }
 272                                 break;
 273                         case SCE_PAS_COMMENTLINE:
 274                                 if (sc.atLineStart) {
 275                                         sc.SetState(SCE_PAS_DEFAULT);
 276                                 }
 277                                 break;
 278                         case SCE_PAS_STRING:
 279                                 if (sc.atLineEnd) {
 280                                         sc.ChangeState(SCE_PAS_STRINGEOL);
 281                                 } else if (sc.ch == '\'' && sc.chNext == '\'') {
 282                                         sc.Forward();
 283                                 } else if (sc.ch == '\'') {
 284                                         sc.ForwardSetState(SCE_PAS_DEFAULT);
 285                                 }
 286                                 break;
 287                         case SCE_PAS_STRINGEOL:
 288                                 if (sc.atLineStart) {
 289                                         sc.SetState(SCE_PAS_DEFAULT);
 290                                 }
 291                                 break;
 292                         case SCE_PAS_CHARACTER:
 293                                 if (!setHexNumber.Contains(sc.ch) && sc.ch != '$') {
 294                                         sc.SetState(SCE_PAS_DEFAULT);
 295                                 }
 296                                 break;
 297                         case SCE_PAS_OPERATOR:
 298                                 if (bSmartHighlighting && sc.chPrev == ';') {
 299                                         curLineState &= ~(stateInProperty | stateInExport);
 300                                 }
 301                                 sc.SetState(SCE_PAS_DEFAULT);
 302                                 break;
 303                         case SCE_PAS_ASM:
 304                                 sc.SetState(SCE_PAS_DEFAULT);
 305                                 break;
 306                 }
 307
 308                 // Determine if a new state should be entered.
 309                 if (sc.state == SCE_PAS_DEFAULT) {
 310                         if (IsADigit(sc.ch) && !(curLineState & stateInAsm)) {
 311                                 sc.SetState(SCE_PAS_NUMBER);
 312                         } else if (setWordStart.Contains(sc.ch)) {
 313                                 sc.SetState(SCE_PAS_IDENTIFIER);
 314                         } else if (sc.ch == '$' && !(curLineState & stateInAsm)) {
 315                                 sc.SetState(SCE_PAS_HEXNUMBER);
 316                         } else if (sc.Match('{', '$')) {
 317                                 sc.SetState(SCE_PAS_PREPROCESSOR);
 318                         } else if (sc.ch == '{') {
 319                                 sc.SetState(SCE_PAS_COMMENT);
 320                         } else if (sc.Match("(*$")) {
 321                                 sc.SetState(SCE_PAS_PREPROCESSOR2);
 322                         } else if (sc.Match('(', '*')) {
 323                                 sc.SetState(SCE_PAS_COMMENT2);
 324                                 sc.Forward();   // Eat the * so it isn't used for the end of the comment
 325                         } else if (sc.Match('/', '/')) {
 326                                 sc.SetState(SCE_PAS_COMMENTLINE);
 327                         } else if (sc.ch == '\'') {
 328                                 sc.SetState(SCE_PAS_STRING);
 329                         } else if (sc.ch == '#') {
 330                                 sc.SetState(SCE_PAS_CHARACTER);
 331                         } else if (setOperator.Contains(sc.ch) && !(curLineState & stateInAsm)) {
 332                                 sc.SetState(SCE_PAS_OPERATOR);
 333                         } else if (curLineState & stateInAsm) {
 334                                 sc.SetState(SCE_PAS_ASM);
 335                         }
 336                 }
 337         }
 338
 339         if (sc.state == SCE_PAS_IDENTIFIER && setWord.Contains(sc.chPrev)) {
 340                 ClassifyPascalWord(keywordlists, sc, curLineState, bSmartHighlighting);
 341         }
 342
 343         sc.Complete();
 344 }
 345
 346 static bool IsStreamCommentStyle(int style) {
 347         return style == SCE_PAS_COMMENT || style == SCE_PAS_COMMENT2;
 348 }
 349
 350 static bool IsCommentLine(int line, Accessor &styler) {
 351         int pos = styler.LineStart(line);
 352         int eolPos = styler.LineStart(line + 1) - 1;
 353         for (int i = pos; i < eolPos; i++) {
 354                 char ch = styler[i];
 355                 char chNext = styler.SafeGetCharAt(i + 1);
 356                 int style = styler.StyleAt(i);
 357                 if (ch == '/' && chNext == '/' && style == SCE_PAS_COMMENTLINE) {
 358                         return true;
 359                 } else if (!IsASpaceOrTab(ch)) {
 360                         return false;
 361                 }
 362         }
 363         return false;
 364 }
 365
 366 static unsigned int GetFoldInPreprocessorLevelFlag(int lineFoldStateCurrent) {
 367         return lineFoldStateCurrent & stateFoldInPreprocessorLevelMask;
 368 }
 369
 370 static void SetFoldInPreprocessorLevelFlag(int &lineFoldStateCurrent, unsigned int nestLevel) {
 371         lineFoldStateCurrent &= ~stateFoldInPreprocessorLevelMask;
 372         lineFoldStateCurrent |= nestLevel & stateFoldInPreprocessorLevelMask;
 373 }
 374
 375 static void ClassifyPascalPreprocessorFoldPoint(int &levelCurrent, int &lineFoldStateCurrent,
 376                 unsigned int startPos, Accessor &styler) {
 377         CharacterSet setWord(CharacterSet::setAlpha);
 378
 379         char s[11];     // Size of the longest possible keyword + one additional character + null
 380         GetForwardRangeLowered(startPos, setWord, styler, s, sizeof(s));
 381
 382         unsigned int nestLevel = GetFoldInPreprocessorLevelFlag(lineFoldStateCurrent);
 383
 384         if (strcmp(s, "if") == 0 ||
 385                 strcmp(s, "ifdef") == 0 ||
 386                 strcmp(s, "ifndef") == 0 ||
 387                 strcmp(s, "ifopt") == 0 ||
 388                 strcmp(s, "region") == 0) {
 389                 nestLevel++;
 390                 SetFoldInPreprocessorLevelFlag(lineFoldStateCurrent, nestLevel);
 391                 lineFoldStateCurrent |= stateFoldInPreprocessor;
 392                 levelCurrent++;
 393         } else if (strcmp(s, "endif") == 0 ||
 394                 strcmp(s, "ifend") == 0 ||
 395                 strcmp(s, "endregion") == 0) {
 396                 nestLevel--;
 397                 SetFoldInPreprocessorLevelFlag(lineFoldStateCurrent, nestLevel);
 398                 if (nestLevel == 0) {
 399                         lineFoldStateCurrent &= ~stateFoldInPreprocessor;
 400                 }
 401                 levelCurrent--;
 402                 if (levelCurrent < SC_FOLDLEVELBASE) {
 403                         levelCurrent = SC_FOLDLEVELBASE;
 404                 }
 405         }
 406 }
 407
 408 static unsigned int SkipWhiteSpace(unsigned int currentPos, unsigned int endPos,
 409                 Accessor &styler, bool includeChars = false) {
 410         CharacterSet setWord(CharacterSet::setAlphaNum, "_");
 411         unsigned int j = currentPos + 1;
 412         char ch = styler.SafeGetCharAt(j);
 413         while ((j < endPos) && (IsASpaceOrTab(ch) || ch == '\r' || ch == '\n' ||
 414                 IsStreamCommentStyle(styler.StyleAt(j)) || (includeChars && setWord.Contains(ch)))) {
 415                 j++;
 416                 ch = styler.SafeGetCharAt(j);
 417         }
 418         return j;
 419 }
 420
 421 static void ClassifyPascalWordFoldPoint(int &levelCurrent, int &lineFoldStateCurrent,
 422                 int startPos, unsigned int endPos,
 423                 unsigned int lastStart, unsigned int currentPos, Accessor &styler) {
 424         char s[100];
 425         GetRangeLowered(lastStart, currentPos, styler, s, sizeof(s));
 426
 427         if (strcmp(s, "record") == 0) {
 428                 lineFoldStateCurrent |= stateFoldInRecord;
 429                 levelCurrent++;
 430         } else if (strcmp(s, "begin") == 0 ||
 431                 strcmp(s, "asm") == 0 ||
 432                 strcmp(s, "try") == 0 ||
 433                 (strcmp(s, "case") == 0 && !(lineFoldStateCurrent & stateFoldInRecord))) {
 434                 levelCurrent++;
 435         } else if (strcmp(s, "class") == 0 || strcmp(s, "object") == 0) {
 436                 // "class" & "object" keywords require special handling...
 437                 bool ignoreKeyword = false;
 438                 unsigned int j = SkipWhiteSpace(currentPos, endPos, styler);
 439                 if (j < endPos) {
 440                         CharacterSet setWordStart(CharacterSet::setAlpha, "_");
 441                         CharacterSet setWord(CharacterSet::setAlphaNum, "_");
 442
 443                         if (styler.SafeGetCharAt(j) == ';') {
 444                                 // Handle forward class declarations ("type TMyClass = class;")
 445                                 // and object method declarations ("TNotifyEvent = procedure(Sender: TObject) of object;")
 446                                 ignoreKeyword = true;
 447                         } else if (strcmp(s, "class") == 0) {
 448                                 // "class" keyword has a few more special cases...
 449                                 if (styler.SafeGetCharAt(j) == '(') {
 450                                         // Handle simplified complete class declarations ("type TMyClass = class(TObject);")
 451                                         j = SkipWhiteSpace(j, endPos, styler, true);
 452                                         if (j < endPos && styler.SafeGetCharAt(j) == ')') {
 453                                                 j = SkipWhiteSpace(j, endPos, styler);
 454                                                 if (j < endPos && styler.SafeGetCharAt(j) == ';') {
 455                                                         ignoreKeyword = true;
 456                                                 }
 457                                         }
 458                                 } else if (setWordStart.Contains(styler.SafeGetCharAt(j))) {
 459                                         char s2[11];    // Size of the longest possible keyword + one additional character + null
 460                                         GetForwardRangeLowered(j, setWord, styler, s2, sizeof(s2));
 461
 462                                         if (strcmp(s2, "procedure") == 0 ||
 463                                                 strcmp(s2, "function") == 0 ||
 464                                                 strcmp(s2, "of") == 0 ||
 465                                                 strcmp(s2, "var") == 0 ||
 466                                                 strcmp(s2, "property") == 0 ||
 467                                                 strcmp(s2, "operator") == 0) {
 468                                                 ignoreKeyword = true;
 469                                         }
 470                                 }
 471                         }
 472                 }
 473                 if (!ignoreKeyword) {
 474                         levelCurrent++;
 475                 }
 476         } else if (strcmp(s, "interface") == 0) {
 477                 // "interface" keyword requires special handling...
 478                 bool ignoreKeyword = true;
 479                 int j = lastStart - 1;
 480                 char ch = styler.SafeGetCharAt(j);
 481                 while ((j >= startPos) && (IsASpaceOrTab(ch) || ch == '\r' || ch == '\n' ||
 482                         IsStreamCommentStyle(styler.StyleAt(j)))) {
 483                         j--;
 484                         ch = styler.SafeGetCharAt(j);
 485                 }
 486                 if (j >= startPos && styler.SafeGetCharAt(j) == '=') {
 487                         ignoreKeyword = false;
 488                 }
 489                 if (!ignoreKeyword) {
 490                         unsigned int k = SkipWhiteSpace(currentPos, endPos, styler);
 491                         if (k < endPos && styler.SafeGetCharAt(k) == ';') {
 492                                 // Handle forward interface declarations ("type IMyInterface = interface;")
 493                                 ignoreKeyword = true;
 494                         }
 495                 }
 496                 if (!ignoreKeyword) {
 497                         levelCurrent++;
 498                 }
 499         } else if (strcmp(s, "dispinterface") == 0) {
 500                 // "dispinterface" keyword requires special handling...
 501                 bool ignoreKeyword = false;
 502                 unsigned int j = SkipWhiteSpace(currentPos, endPos, styler);
 503                 if (j < endPos && styler.SafeGetCharAt(j) == ';') {
 504                         // Handle forward dispinterface declarations ("type IMyInterface = dispinterface;")
 505                         ignoreKeyword = true;
 506                 }
 507                 if (!ignoreKeyword) {
 508                         levelCurrent++;
 509                 }
 510         } else if (strcmp(s, "end") == 0) {
 511                 lineFoldStateCurrent &= ~stateFoldInRecord;
 512                 levelCurrent--;
 513                 if (levelCurrent < SC_FOLDLEVELBASE) {
 514                         levelCurrent = SC_FOLDLEVELBASE;
 515                 }
 516         }
 517 }
 518
 519 static void FoldPascalDoc(unsigned int startPos, int length, int initStyle, WordList *[],
 520                 Accessor &styler) {
 521         bool foldComment = styler.GetPropertyInt("fold.comment") != 0;
 522         bool foldPreprocessor = styler.GetPropertyInt("fold.preprocessor") != 0;
 523         bool foldCompact = styler.GetPropertyInt("fold.compact", 1) != 0;
 524         unsigned int endPos = startPos + length;
 525         int visibleChars = 0;
 526         int lineCurrent = styler.GetLine(startPos);
 527         int levelPrev = styler.LevelAt(lineCurrent) & SC_FOLDLEVELNUMBERMASK;
 528         int levelCurrent = levelPrev;
 529         int lineFoldStateCurrent = lineCurrent > 0 ? styler.GetLineState(lineCurrent - 1) & stateFoldMaskAll : 0;
 530         char chNext = styler[startPos];
 531         int styleNext = styler.StyleAt(startPos);
 532         int style = initStyle;
 533
 534         int lastStart = 0;
 535         CharacterSet setWord(CharacterSet::setAlphaNum, "_", 0x80, true);
 536
 537         for (unsigned int i = startPos; i < endPos; i++) {
 538                 char ch = chNext;
 539                 chNext = styler.SafeGetCharAt(i + 1);
 540                 int stylePrev = style;
 541                 style = styleNext;
 542                 styleNext = styler.StyleAt(i + 1);
 543                 bool atEOL = (ch == '\r' && chNext != '\n') || (ch == '\n');
 544
 545                 if (foldComment && IsStreamCommentStyle(style)) {
 546                         if (!IsStreamCommentStyle(stylePrev)) {
 547                                 levelCurrent++;
 548                         } else if (!IsStreamCommentStyle(styleNext) && !atEOL) {
 549                                 // Comments don't end at end of line and the next character may be unstyled.
 550                                 levelCurrent--;
 551                         }
 552                 }
 553                 if (foldComment && atEOL && IsCommentLine(lineCurrent, styler))
 554                 {
 555                         if (!IsCommentLine(lineCurrent - 1, styler)
 556                             && IsCommentLine(lineCurrent + 1, styler))
 557                                 levelCurrent++;
 558                         else if (IsCommentLine(lineCurrent - 1, styler)
 559                                  && !IsCommentLine(lineCurrent+1, styler))
 560                                 levelCurrent--;
 561                 }
 562                 if (foldPreprocessor) {
 563                         if (style == SCE_PAS_PREPROCESSOR && ch == '{' && chNext == '$') {
 564                                 ClassifyPascalPreprocessorFoldPoint(levelCurrent, lineFoldStateCurrent, i + 2, styler);
 565                         } else if (style == SCE_PAS_PREPROCESSOR2 && ch == '(' && chNext == '*'
 566                                    && styler.SafeGetCharAt(i + 2) == '$') {
 567                                 ClassifyPascalPreprocessorFoldPoint(levelCurrent, lineFoldStateCurrent, i + 3, styler);
 568                         }
 569                 }
 570
 571                 if (stylePrev != SCE_PAS_WORD && style == SCE_PAS_WORD)
 572                 {
 573                         // Store last word start point.
 574                         lastStart = i;
 575                 }
 576                 if (stylePrev == SCE_PAS_WORD && !(lineFoldStateCurrent & stateFoldInPreprocessor)) {
 577                         if(setWord.Contains(ch) && !setWord.Contains(chNext)) {
 578                                 ClassifyPascalWordFoldPoint(levelCurrent, lineFoldStateCurrent, startPos, endPos, lastStart, i, styler);
 579                         }
 580                 }
 581
 582                 if (!IsASpace(ch))
 583                         visibleChars++;
 584
 585                 if (atEOL) {
 586                         int lev = levelPrev;
 587                         if (visibleChars == 0 && foldCompact)
 588                                 lev |= SC_FOLDLEVELWHITEFLAG;
 589                         if ((levelCurrent > levelPrev) && (visibleChars > 0))
 590                                 lev |= SC_FOLDLEVELHEADERFLAG;
 591                         if (lev != styler.LevelAt(lineCurrent)) {
 592                                 styler.SetLevel(lineCurrent, lev);
 593                         }
 594                         int newLineState = (styler.GetLineState(lineCurrent) & ~stateFoldMaskAll) | lineFoldStateCurrent;
 595                         styler.SetLineState(lineCurrent, newLineState);
 596                         lineCurrent++;
 597                         levelPrev = levelCurrent;
 598                         visibleChars = 0;
 599                 }
 600         }
 601
 602         // If we didn't reach the EOL in previous loop, store line level and whitespace information.
 603         // The rest will be filled in later...
 604         int lev = levelPrev;
 605         if (visibleChars == 0 && foldCompact)
 606                 lev |= SC_FOLDLEVELWHITEFLAG;
 607         styler.SetLevel(lineCurrent, lev);
 608 }
 609
 610 static const char * const pascalWordListDesc[] = {
 611         "Keywords",
 612         0
 613 };
 614
 615 LexerModule lmPascal(SCLEX_PASCAL, ColourisePascalDoc, "pascal", FoldPascalDoc, pascalWordListDesc);