git.saurik.com Git - wxWidgets.git/blob - src/stc/scintilla/lexers/LexPerl.cxx

1 // Scintilla source code edit control

2 /** @file LexPerl.cxx

3 ** Lexer for Perl.

4 ** Converted to lexer object by "Udo Lechner" <dlchnr(at)gmx(dot)net>

5 **/

7 // Lexical analysis fixes by Kein-Hong Man <mkh@pl.jaring.my>

8 // The License.txt file describes the conditions under which this software may be distributed.

10 #include <stdlib.h>

11 #include <string.h>

12 #include <stdio.h>

13 #include <stdarg.h>

14 #include <assert.h>

15 #include <ctype.h>

17 #include <string>

18 #include <map>

20 #include "ILexer.h"

21 #include "Scintilla.h"

22 #include "SciLexer.h"

24 #include "WordList.h"

25 #include "LexAccessor.h"

26 #include "StyleContext.h"

27 #include "CharacterSet.h"

28 #include "LexerModule.h"

29 #include "OptionSet.h"

31 #ifdef SCI_NAMESPACE

32 using namespace Scintilla;

33 #endif

35 // Info for HERE document handling from perldata.pod (reformatted):

36 // ----------------------------------------------------------------

37 // A line-oriented form of quoting is based on the shell ``here-doc'' syntax.

38 // Following a << you specify a string to terminate the quoted material, and

39 // all lines following the current line down to the terminating string are

40 // the value of the item.

41 // * The terminating string may be either an identifier (a word), or some

42 // quoted text.

43 // * If quoted, the type of quotes you use determines the treatment of the

44 // text, just as in regular quoting.

45 // * An unquoted identifier works like double quotes.

46 // * There must be no space between the << and the identifier.

47 // (If you put a space it will be treated as a null identifier,

48 // which is valid, and matches the first empty line.)

49 // (This is deprecated, -w warns of this syntax)

50 // * The terminating string must appear by itself (unquoted and

51 // with no surrounding whitespace) on the terminating line.

53 #define HERE_DELIM_MAX 256 // maximum length of HERE doc delimiter

55 #define PERLNUM_BINARY 1 // order is significant: 1-4 cannot have a dot

56 #define PERLNUM_HEX 2

57 #define PERLNUM_OCTAL 3

58 #define PERLNUM_FLOAT_EXP 4 // exponent part only

59 #define PERLNUM_DECIMAL 5 // 1-5 are numbers; 6-7 are strings

60 #define PERLNUM_VECTOR 6

61 #define PERLNUM_V_VECTOR 7

62 #define PERLNUM_BAD 8

64 #define BACK_NONE 0 // lookback state for bareword disambiguation:

65 #define BACK_OPERATOR 1 // whitespace/comments are insignificant

66 #define BACK_KEYWORD 2 // operators/keywords are needed for disambiguation

68 // all interpolated styles are different from their parent styles by a constant difference

69 // we also assume SCE_PL_STRING_VAR is the interpolated style with the smallest value

70 #define INTERPOLATE_SHIFT (SCE_PL_STRING_VAR - SCE_PL_STRING)

 static bool isPerlKeyword(unsigned int start, unsigned int end, WordList &keywords, LexAccessor &styler) {

73 // old-style keyword matcher; needed because GetCurrent() needs

74 // current segment to be committed, but we may abandon early...

75 char s[100];

         unsigned int i, len = end - start;

         if (len > 30) { len = 30; }

         for (i = 0; i < len; i++, start++) s[i] = styler[start];

79 s[i] = '\0';

         return keywords.InList(s);

81 }

 static int disambiguateBareword(LexAccessor &styler, unsigned int bk, unsigned int fw,

         int backFlag, unsigned int backPos, unsigned int endPos) {

85 // identifiers are recognized by Perl as barewords under some

86 // conditions, the following attempts to do the disambiguation

87 // by looking backward and forward; result in 2 LSB

88 int result = 0;

         bool moreback = false;          // true if passed newline/comments

         bool brace = false;                     // true if opening brace found

91 // if BACK_NONE, neither operator nor keyword, so skip test

92 if (backFlag == BACK_NONE)

93 return result;

94 // first look backwards past whitespace/comments to set EOL flag

95 // (some disambiguation patterns must be on a single line)

         if (backPos <= static_cast<unsigned int>(styler.LineStart(styler.GetLine(bk))))

97 moreback = true;

98 // look backwards at last significant lexed item for disambiguation

99 bk = backPos - 1;

         int ch = static_cast<unsigned char>(styler.SafeGetCharAt(bk));

         if (ch == '{' && !moreback) {

102 // {bareword: possible variable spec

103 brace = true;

         } else if ((ch == '&' && styler.SafeGetCharAt(bk - 1) != '&')

105 // &bareword: subroutine call

                 || styler.Match(bk - 1, "->")

107 // ->bareword: part of variable spec

                 || styler.Match(bk - 2, "sub")) {

109 // sub bareword: subroutine declaration

110 // (implied BACK_KEYWORD, no keywords end in 'sub'!)

111 result |= 1;

112 }

113 // next, scan forward after word past tab/spaces only;

114 // if ch isn't one of '[{(,' we can skip the test

         if ((ch == '{' || ch == '(' || ch == '['|| ch == ',')

116 && fw < endPos) {

                 while (ch = static_cast<unsigned char>(styler.SafeGetCharAt(fw)),

                         IsASpaceOrTab(ch) && fw < endPos) {

119 fw++;

120 }

                 if ((ch == '}' && brace)

122 // {bareword}: variable spec

                         || styler.Match(fw, "=>")) {

124 // [{(, bareword=>: hash literal

125 result |= 2;

126 }

127 }

128 return result;

129 }

130

 static void skipWhitespaceComment(LexAccessor &styler, unsigned int &p) {

132 // when backtracking, we need to skip whitespace and comments

133 int style;

         while ((p > 0) && (style = styler.StyleAt(p),

135 style == SCE_PL_DEFAULT || style == SCE_PL_COMMENTLINE))

136 p--;

137 }

138

 static int styleBeforeBracePair(LexAccessor &styler, unsigned int bk) {

140 // backtrack to find open '{' corresponding to a '}', balanced

141 // return significant style to be tested for '/' disambiguation

142 int braceCount = 1;

         if (bk == 0)

144 return SCE_PL_DEFAULT;

         while (--bk > 0) {

                 if (styler.StyleAt(bk) == SCE_PL_OPERATOR) {

                         int bkch = static_cast<unsigned char>(styler.SafeGetCharAt(bk));

                         if (bkch == ';') {      // early out

149 break;

                         } else if (bkch == '}') {

151 braceCount++;

                         } else if (bkch == '{') {

                                 if (--braceCount == 0) break;

154 }

155 }

156 }

         if (bk > 0 && braceCount == 0) {

158 // balanced { found, bk > 0, skip more whitespace/comments

159 bk--;

160 skipWhitespaceComment(styler, bk);

                 return styler.StyleAt(bk);

162 }

163 return SCE_PL_DEFAULT;

164 }

165

 static int styleCheckIdentifier(LexAccessor &styler, unsigned int bk) {

167 // backtrack to classify sub-styles of identifier under test

168 // return sub-style to be tested for '/' disambiguation

         if (styler.SafeGetCharAt(bk) == '>')    // inputsymbol, like <foo>

170 return 1;

171 // backtrack to check for possible "->" or "::" before identifier

         while (bk > 0 && styler.StyleAt(bk) == SCE_PL_IDENTIFIER) {

173 bk--;

174 }

         while (bk > 0) {

                 int bkstyle = styler.StyleAt(bk);

177 if (bkstyle == SCE_PL_DEFAULT

178 || bkstyle == SCE_PL_COMMENTLINE) {

179 // skip whitespace, comments

                 } else if (bkstyle == SCE_PL_OPERATOR) {

181 // test for "->" and "::"

                         if (styler.Match(bk - 1, "->") || styler.Match(bk - 1, "::"))

183 return 2;

184 } else

185 return 3; // bare identifier

186 bk--;

187 }

188 return 0;

189 }

190

 static int inputsymbolScan(LexAccessor &styler, unsigned int pos, unsigned int endPos) {

192 // looks forward for matching > on same line; a bit ugly

193 unsigned int fw = pos;

194 while (++fw < endPos) {

                 int fwch = static_cast<unsigned char>(styler.SafeGetCharAt(fw));

                 if (fwch == '\r' || fwch == '\n') {

197 return 0;

                 } else if (fwch == '>') {

                         if (styler.Match(fw - 2, "<=>"))        // '<=>' case

200 return 0;

201 return fw - pos;

202 }

203 }

204 return 0;

205 }

206

 static int podLineScan(LexAccessor &styler, unsigned int &pos, unsigned int endPos) {

208 // forward scan the current line to classify line for POD style

209 int state = -1;

210 while (pos <= endPos) {

                 int ch = static_cast<unsigned char>(styler.SafeGetCharAt(pos));

                 if (ch == '\n' || ch == '\r' || pos >= endPos) {

                         if (ch == '\r' && styler.SafeGetCharAt(pos + 1) == '\n') pos++;

214 break;

215 }

                 if (IsASpaceOrTab(ch)) {        // whitespace, take note

                         if (state == -1)

218 state = SCE_PL_DEFAULT;

                 } else if (state == SCE_PL_DEFAULT) {   // verbatim POD line

220 state = SCE_PL_POD_VERB;

                 } else if (state != SCE_PL_POD_VERB) {  // regular POD line

222 state = SCE_PL_POD;

223 }

224 pos++;

225 }

         if (state == -1)

227 state = SCE_PL_DEFAULT;

228 return state;

229 }

230

 static bool styleCheckSubPrototype(LexAccessor &styler, unsigned int bk) {

232 // backtrack to identify if we're starting a subroutine prototype

233 // we also need to ignore whitespace/comments:

234 // 'sub' [whitespace|comment] <identifier> [whitespace|comment]

235 styler.Flush();

236 skipWhitespaceComment(styler, bk);

         if (bk == 0 || styler.StyleAt(bk) != SCE_PL_IDENTIFIER) // check identifier

238 return false;

         while (bk > 0 && (styler.StyleAt(bk) == SCE_PL_IDENTIFIER)) {

240 bk--;

241 }

242 skipWhitespaceComment(styler, bk);

         if (bk < 2 || styler.StyleAt(bk) != SCE_PL_WORD // check "sub" keyword

                 || !styler.Match(bk - 2, "sub"))        // assume suffix is unique!

245 return false;

246 return true;

247 }

248

 static int actualNumStyle(int numberStyle) {

         if (numberStyle == PERLNUM_VECTOR || numberStyle == PERLNUM_V_VECTOR) {

251 return SCE_PL_STRING;

         } else if (numberStyle == PERLNUM_BAD) {

253 return SCE_PL_ERROR;

254 }

255 return SCE_PL_NUMBER;

256 }

257

 static int opposite(int ch) {

         if (ch == '(') return ')';

         if (ch == '[') return ']';

         if (ch == '{') return '}';

         if (ch == '<') return '>';

263 return ch;

264 }

265

 static bool IsCommentLine(int line, LexAccessor &styler) {

         int pos = styler.LineStart(line);

         int eol_pos = styler.LineStart(line + 1) - 1;

         for (int i = pos; i < eol_pos; i++) {

270 char ch = styler[i];

                 int style = styler.StyleAt(i);

                 if (ch == '#' && style == SCE_PL_COMMENTLINE)

273 return true;

                 else if (!IsASpaceOrTab(ch))

275 return false;

276 }

277 return false;

278 }

279

 static bool IsPackageLine(int line, LexAccessor &styler) {

         int pos = styler.LineStart(line);

         int style = styler.StyleAt(pos);

         if (style == SCE_PL_WORD && styler.Match(pos, "package")) {

284 return true;

285 }

286 return false;

287 }

288

 static int PodHeadingLevel(int pos, LexAccessor &styler) {

         int lvl = static_cast<unsigned char>(styler.SafeGetCharAt(pos + 5));

         if (lvl >= '1' && lvl <= '4') {

292 return lvl - '0';

293 }

294 return 0;

295 }

296

297 // An individual named option for use in an OptionSet

298

299 // Options used for LexerPerl

300 struct OptionsPerl {

301 bool fold;

302 bool foldComment;

303 bool foldCompact;

304 // Custom folding of POD and packages

305 bool foldPOD; // fold.perl.pod

306 // Enable folding Pod blocks when using the Perl lexer.

307 bool foldPackage; // fold.perl.package

308 // Enable folding packages when using the Perl lexer.

309

310 bool foldCommentExplicit;

311

312 bool foldAtElse;

313

314 OptionsPerl() {

315 fold = false;

316 foldComment = false;

317 foldCompact = true;

318 foldPOD = true;

319 foldPackage = true;

320 foldCommentExplicit = true;

321 foldAtElse = false;

322 }

323 };

324

325 static const char *const perlWordListDesc[] = {

326 "Keywords",

327 0

328 };

329

 struct OptionSetPerl : public OptionSet<OptionsPerl> {

331 OptionSetPerl() {

                 DefineProperty("fold", &OptionsPerl::fold);

333

                 DefineProperty("fold.comment", &OptionsPerl::foldComment);

335

                 DefineProperty("fold.compact", &OptionsPerl::foldCompact);

337

                 DefineProperty("fold.perl.pod", &OptionsPerl::foldPOD,

339 "Set to 0 to disable folding Pod blocks when using the Perl lexer.");

340

                 DefineProperty("fold.perl.package", &OptionsPerl::foldPackage,

342 "Set to 0 to disable folding packages when using the Perl lexer.");

343

                 DefineProperty("fold.perl.comment.explicit", &OptionsPerl::foldCommentExplicit,

345 "Set to 0 to disable explicit folding.");

346

                 DefineProperty("fold.perl.at.else", &OptionsPerl::foldAtElse,

                                "This option enables Perl folding on a \"} else {\" line of an if statement.");

349

350 DefineWordListSets(perlWordListDesc);

351 }

352 };

353

354 class LexerPerl : public ILexer {

355 CharacterSet setWordStart;

356 CharacterSet setWord;

357 CharacterSet setSpecialVar;

358 CharacterSet setControlVar;

359 WordList keywords;

360 OptionsPerl options;

361 OptionSetPerl osPerl;

362 public:

363 LexerPerl() :

                 setWordStart(CharacterSet::setAlpha, "_", 0x80, true),

                 setWord(CharacterSet::setAlphaNum, "_", 0x80, true),

                 setSpecialVar(CharacterSet::setNone, "\"$;<>&`'+,./\\%:=~!?@[]"),

                 setControlVar(CharacterSet::setNone, "ACDEFHILMNOPRSTVWX") {

368 }

369 virtual ~LexerPerl() {

370 }

371 void SCI_METHOD Release() {

372 delete this;

373 }

         int SCI_METHOD Version() const {

375 return lvOriginal;

376 }

377 const char *SCI_METHOD PropertyNames() {

378 return osPerl.PropertyNames();

379 }

         int SCI_METHOD PropertyType(const char *name) {

                 return osPerl.PropertyType(name);

382 }

         const char *SCI_METHOD DescribeProperty(const char *name) {

                 return osPerl.DescribeProperty(name);

385 }

         int SCI_METHOD PropertySet(const char *key, const char *val);

387 const char *SCI_METHOD DescribeWordListSets() {

388 return osPerl.DescribeWordListSets();

389 }

         int SCI_METHOD WordListSet(int n, const char *wl);

         void SCI_METHOD Lex(unsigned int startPos, int length, int initStyle, IDocument *pAccess);

         void SCI_METHOD Fold(unsigned int startPos, int length, int initStyle, IDocument *pAccess);

393

         void *SCI_METHOD PrivateCall(int, void *) {

395 return 0;

396 }

397

398 static ILexer *LexerFactoryPerl() {

399 return new LexerPerl();

400 }

         void InterpolateSegment(StyleContext &sc, int maxSeg, bool isPattern=false);

402 };

403

 int SCI_METHOD LexerPerl::PropertySet(const char *key, const char *val) {

         if (osPerl.PropertySet(&options, key, val)) {

406 return 0;

407 }

408 return -1;

409 }

410

 int SCI_METHOD LexerPerl::WordListSet(int n, const char *wl) {

412 WordList *wordListN = 0;

413 switch (n) {

414 case 0:

415 wordListN = &keywords;

416 break;

417 }

418 int firstModification = -1;

419 if (wordListN) {

420 WordList wlNew;

421 wlNew.Set(wl);

422 if (*wordListN != wlNew) {

423 wordListN->Set(wl);

424 firstModification = 0;

425 }

426 }

427 return firstModification;

428 }

429

 void LexerPerl::InterpolateSegment(StyleContext &sc, int maxSeg, bool isPattern) {

431 // interpolate a segment (with no active backslashes or delimiters within)

432 // switch in or out of an interpolation style or continue current style

433 // commit variable patterns if found, trim segment, repeat until done

         while (maxSeg > 0) {

435 bool isVar = false;

436 int sLen = 0;

                 if ((maxSeg > 1) && (sc.ch == '$' || sc.ch == '@')) {

438 // $#[$]*word [$@][$]*word (where word or {word} is always present)

439 bool braces = false;

440 sLen = 1;

                         if (sc.ch == '$' && sc.chNext == '#') { // starts with $#

442 sLen++;

443 }

                         while ((maxSeg > sLen) && (sc.GetRelative(sLen) == '$'))        // >0 $ dereference within

445 sLen++;

                         if ((maxSeg > sLen) && (sc.GetRelative(sLen) == '{')) { // { start for {word}

447 sLen++;

448 braces = true;

449 }

450 if (maxSeg > sLen) {

                                 int c = sc.GetRelative(sLen);

                                 if (setWordStart.Contains(c)) { // word (various)

453 sLen++;

454 isVar = true;

                                         while ((maxSeg > sLen) && setWord.Contains(sc.GetRelative(sLen)))

456 sLen++;

                                 } else if (braces && IsADigit(c) && (sLen == 2)) {      // digit for ${digit}

458 sLen++;

459 isVar = true;

460 }

461 }

462 if (braces) {

                                 if ((maxSeg > sLen) && (sc.GetRelative(sLen) == '}')) { // } end for {word}

464 sLen++;

465 } else

466 isVar = false;

467 }

468 }

                 if (!isVar && (maxSeg > 1)) {   // $- or @-specific variable patterns

470 sLen = 1;

471 int c = sc.chNext;

                         if (sc.ch == '$') {

                                 if (IsADigit(c)) {      // $[0-9] and slurp trailing digits

474 sLen++;

475 isVar = true;

                                         while ((maxSeg > sLen) && IsADigit(sc.GetRelative(sLen)))

477 sLen++;

                                 } else if (setSpecialVar.Contains(c)) { // $ special variables

479 sLen++;

480 isVar = true;

                                 } else if (!isPattern && ((c == '(') || (c == ')') || (c == '|'))) {    // $ additional

482 sLen++;

483 isVar = true;

                                 } else if (c == '^') {  // $^A control-char style

485 sLen++;

                                         if ((maxSeg > sLen) && setControlVar.Contains(sc.GetRelative(sLen))) {

487 sLen++;

488 isVar = true;

489 }

490 }

                         } else if (sc.ch == '@') {

                                 if (!isPattern && ((c == '+') || (c == '-'))) { // @ specials non-pattern

493 sLen++;

494 isVar = true;

495 }

496 }

497 }

498 if (isVar) { // commit as interpolated variable or normal character

                         if (sc.state < SCE_PL_STRING_VAR)

                                 sc.SetState(sc.state + INTERPOLATE_SHIFT);

501 sc.Forward(sLen);

502 maxSeg -= sLen;

503 } else {

                         if (sc.state >= SCE_PL_STRING_VAR)

                                 sc.SetState(sc.state - INTERPOLATE_SHIFT);

506 sc.Forward();

507 maxSeg--;

508 }

509 }

         if (sc.state >= SCE_PL_STRING_VAR)

                 sc.SetState(sc.state - INTERPOLATE_SHIFT);

512 }

513

 void SCI_METHOD LexerPerl::Lex(unsigned int startPos, int length, int initStyle, IDocument *pAccess) {

515 LexAccessor styler(pAccess);

516

517 // keywords that forces /PATTERN/ at all times; should track vim's behaviour

518 WordList reWords;

         reWords.Set("elsif if split while");

520

521 // charset classes

         CharacterSet setSingleCharOp(CharacterSet::setNone, "rwxoRWXOezsfdlpSbctugkTBMAC");

523 // lexing of "%*</" operators is non-trivial; these are missing in the set below

         CharacterSet setPerlOperator(CharacterSet::setNone, "^&\\()-+=|{}[]:;>,?!.~");

         CharacterSet setQDelim(CharacterSet::setNone, "qrwx");

         CharacterSet setModifiers(CharacterSet::setAlpha);

         CharacterSet setPreferRE(CharacterSet::setNone, "*/<%");

528 // setArray and setHash also accepts chars for special vars like $_,

529 // which are then truncated when the next char does not match setVar

         CharacterSet setVar(CharacterSet::setAlphaNum, "#$_'", 0x80, true);

         CharacterSet setArray(CharacterSet::setAlpha, "#$_+-", 0x80, true);

         CharacterSet setHash(CharacterSet::setAlpha, "#$_!^+-", 0x80, true);

533 CharacterSet &setPOD = setModifiers;

         CharacterSet setNonHereDoc(CharacterSet::setDigits, "=$@");

         CharacterSet setHereDocDelim(CharacterSet::setAlphaNum, "_");

         CharacterSet setSubPrototype(CharacterSet::setNone, "\\[$@%&*+];");

537 // for format identifiers

         CharacterSet setFormatStart(CharacterSet::setAlpha, "_=");

539 CharacterSet &setFormat = setHereDocDelim;

540

541 // Lexer for perl often has to backtrack to start of current style to determine

542 // which characters are being used as quotes, how deeply nested is the

543 // start position and what the termination string is for HERE documents.

544

545 class HereDocCls { // Class to manage HERE doc sequence

546 public:

547 int State;

548 // 0: '<<' encountered

549 // 1: collect the delimiter

550 // 2: here doc text (lines after the delimiter)

551 int Quote; // the char after '<<'

552 bool Quoted; // true if Quote in ('\'','"','`')

553 int DelimiterLength; // strlen(Delimiter)

554 char *Delimiter; // the Delimiter, 256: sizeof PL_tokenbuf

555 HereDocCls() {

556 State = 0;

557 Quote = 0;

558 Quoted = false;

559 DelimiterLength = 0;

                         Delimiter = new char[HERE_DELIM_MAX];

                         Delimiter[0] = '\0';

562 }

                 void Append(int ch) {

                         Delimiter[DelimiterLength++] = static_cast<char>(ch);

565 Delimiter[DelimiterLength] = '\0';

566 }

567 ~HereDocCls() {

568 delete []Delimiter;

569 }

570 };

571 HereDocCls HereDoc; // TODO: FIFO for stacked here-docs

572

573 class QuoteCls { // Class to manage quote pairs

574 public:

575 int Rep;

576 int Count;

577 int Up, Down;

578 QuoteCls() {

                         this->New(1);

580 }

                 void New(int r = 1) {

582 Rep = r;

583 Count = 0;

584 Up = '\0';

585 Down = '\0';

586 }

                 void Open(int u) {

588 Count++;

589 Up = u;

590 Down = opposite(Up);

591 }

592 };

593 QuoteCls Quote;

594

595 // additional state for number lexing

596 int numState = PERLNUM_DECIMAL;

597 int dotCount = 0;

598

599 unsigned int endPos = startPos + length;

600

601 // Backtrack to beginning of style if required...

602 // If in a long distance lexical state, backtrack to find quote characters.

603 // Includes strings (may be multi-line), numbers (additional state), format

604 // bodies, as well as POD sections.

605 if (initStyle == SCE_PL_HERE_Q

606 || initStyle == SCE_PL_HERE_QQ

607 || initStyle == SCE_PL_HERE_QX

608 || initStyle == SCE_PL_FORMAT

609 || initStyle == SCE_PL_HERE_QQ_VAR

610 || initStyle == SCE_PL_HERE_QX_VAR

611 ) {

612 // backtrack through multiple styles to reach the delimiter start

                 int delim = (initStyle == SCE_PL_FORMAT) ? SCE_PL_FORMAT_IDENT:SCE_PL_HERE_DELIM;

                 while ((startPos > 1) && (styler.StyleAt(startPos) != delim)) {

615 startPos--;

616 }

                 startPos = styler.LineStart(styler.GetLine(startPos));

                 initStyle = styler.StyleAt(startPos - 1);

619 }

620 if (initStyle == SCE_PL_STRING

621 || initStyle == SCE_PL_STRING_QQ

622 || initStyle == SCE_PL_BACKTICKS

623 || initStyle == SCE_PL_STRING_QX

624 || initStyle == SCE_PL_REGEX

625 || initStyle == SCE_PL_STRING_QR

626 || initStyle == SCE_PL_REGSUBST

627 || initStyle == SCE_PL_STRING_VAR

628 || initStyle == SCE_PL_STRING_QQ_VAR

629 || initStyle == SCE_PL_BACKTICKS_VAR

630 || initStyle == SCE_PL_STRING_QX_VAR

631 || initStyle == SCE_PL_REGEX_VAR

632 || initStyle == SCE_PL_STRING_QR_VAR

633 || initStyle == SCE_PL_REGSUBST_VAR

634 ) {

635 // for interpolation, must backtrack through a mix of two different styles

636 int otherStyle = (initStyle >= SCE_PL_STRING_VAR) ?

637 initStyle - INTERPOLATE_SHIFT : initStyle + INTERPOLATE_SHIFT;

                 while (startPos > 1) {

                         int st = styler.StyleAt(startPos - 1);

                         if ((st != initStyle) && (st != otherStyle))

641 break;

642 startPos--;

643 }

644 initStyle = SCE_PL_DEFAULT;

645 } else if (initStyle == SCE_PL_STRING_Q

646 || initStyle == SCE_PL_STRING_QW

647 || initStyle == SCE_PL_XLAT

648 || initStyle == SCE_PL_CHARACTER

649 || initStyle == SCE_PL_NUMBER

650 || initStyle == SCE_PL_IDENTIFIER

651 || initStyle == SCE_PL_ERROR

652 || initStyle == SCE_PL_SUB_PROTOTYPE

653 ) {

                 while ((startPos > 1) && (styler.StyleAt(startPos - 1) == initStyle)) {

655 startPos--;

656 }

657 initStyle = SCE_PL_DEFAULT;

658 } else if (initStyle == SCE_PL_POD

659 || initStyle == SCE_PL_POD_VERB

660 ) {

661 // POD backtracking finds preceeding blank lines and goes back past them

                 int ln = styler.GetLine(startPos);

                 if (ln > 0) {

                         initStyle = styler.StyleAt(styler.LineStart(--ln));

                         if (initStyle == SCE_PL_POD || initStyle == SCE_PL_POD_VERB) {

                                 while (ln > 0 && styler.GetLineState(ln) == SCE_PL_DEFAULT)

667 ln--;

668 }

                         startPos = styler.LineStart(++ln);

                         initStyle = styler.StyleAt(startPos - 1);

671 } else {

672 startPos = 0;

673 initStyle = SCE_PL_DEFAULT;

674 }

675 }

676

677 // backFlag, backPos are additional state to aid identifier corner cases.

678 // Look backwards past whitespace and comments in order to detect either

679 // operator or keyword. Later updated as we go along.

680 int backFlag = BACK_NONE;

681 unsigned int backPos = startPos;

         if (backPos > 0) {

683 backPos--;

684 skipWhitespaceComment(styler, backPos);

                 if (styler.StyleAt(backPos) == SCE_PL_OPERATOR)

686 backFlag = BACK_OPERATOR;

                 else if (styler.StyleAt(backPos) == SCE_PL_WORD)

688 backFlag = BACK_KEYWORD;

689 backPos++;

690 }

691

         StyleContext sc(startPos, endPos - startPos, initStyle, styler, static_cast<char>(STYLE_MAX));

693

         for (; sc.More(); sc.Forward()) {

695

696 // Determine if the current state should terminate.

697 switch (sc.state) {

698 case SCE_PL_OPERATOR:

699 sc.SetState(SCE_PL_DEFAULT);

700 backFlag = BACK_OPERATOR;

701 backPos = sc.currentPos;

702 break;

703 case SCE_PL_IDENTIFIER: // identifier, bareword, inputsymbol

                         if ((!setWord.Contains(sc.ch) && sc.ch != '\'')

                                 || sc.Match('.', '.')

                                 || sc.chPrev == '>') {  // end of inputsymbol

707 sc.SetState(SCE_PL_DEFAULT);

708 }

709 break;

710 case SCE_PL_WORD: // keyword, plus special cases

                         if (!setWord.Contains(sc.ch)) {

712 char s[100];

                                 sc.GetCurrent(s, sizeof(s));

                                 if ((strcmp(s, "__DATA__") == 0) || (strcmp(s, "__END__") == 0)) {

715 sc.ChangeState(SCE_PL_DATASECTION);

716 } else {

                                         if ((strcmp(s, "format") == 0)) {

718 sc.SetState(SCE_PL_FORMAT_IDENT);

719 HereDoc.State = 0;

720 } else {

721 sc.SetState(SCE_PL_DEFAULT);

722 }

723 backFlag = BACK_KEYWORD;

724 backPos = sc.currentPos;

725 }

726 }

727 break;

728 case SCE_PL_SCALAR:

729 case SCE_PL_ARRAY:

730 case SCE_PL_HASH:

731 case SCE_PL_SYMBOLTABLE:

                         if (sc.Match(':', ':')) {       // skip ::

733 sc.Forward();

                         } else if (!setVar.Contains(sc.ch)) {

                                 if (sc.LengthCurrent() == 1) {

736 // Special variable: $(, $_ etc.

737 sc.Forward();

738 }

739 sc.SetState(SCE_PL_DEFAULT);

740 }

741 break;

742 case SCE_PL_NUMBER:

743 // if no early break, number style is terminated at "(go through)"

                         if (sc.ch == '.') {

                                 if (sc.chNext == '.') {

746 // double dot is always an operator (go through)

                                 } else if (numState <= PERLNUM_FLOAT_EXP) {

748 // non-decimal number or float exponent, consume next dot

749 sc.SetState(SCE_PL_OPERATOR);

750 break;

751 } else { // decimal or vectors allows dots

752 dotCount++;

753 if (numState == PERLNUM_DECIMAL) {

                                                 if (dotCount <= 1)      // number with one dot in it

755 break;

                                                 if (IsADigit(sc.chNext)) {      // really a vector

757 numState = PERLNUM_VECTOR;

758 break;

759 }

760 // number then dot (go through)

                                         } else if (IsADigit(sc.chNext)) // vectors

762 break;

763 // vector then dot (go through)

764 }

                         } else if (sc.ch == '_') {

766 // permissive underscoring for number and vector literals

767 break;

                         } else if (numState == PERLNUM_DECIMAL) {

                                 if (sc.ch == 'E' || sc.ch == 'e') {     // exponent, sign

770 numState = PERLNUM_FLOAT_EXP;

                                         if (sc.chNext == '+' || sc.chNext == '-') {

772 sc.Forward();

773 }

774 break;

                                 } else if (IsADigit(sc.ch))

776 break;

777 // number then word (go through)

                         } else if (numState == PERLNUM_HEX) {

                                 if (IsADigit(sc.ch, 16))

780 break;

                         } else if (numState == PERLNUM_VECTOR || numState == PERLNUM_V_VECTOR) {

                                 if (IsADigit(sc.ch))    // vector

783 break;

                                 if (setWord.Contains(sc.ch) && dotCount == 0) { // change to word

785 sc.ChangeState(SCE_PL_IDENTIFIER);

786 break;

787 }

788 // vector then word (go through)

                         } else if (IsADigit(sc.ch)) {

790 if (numState == PERLNUM_FLOAT_EXP) {

791 break;

                                 } else if (numState == PERLNUM_OCTAL) {

                                         if (sc.ch <= '7') break;

                                 } else if (numState == PERLNUM_BINARY) {

                                         if (sc.ch <= '1') break;

796 }

797 // mark invalid octal, binary numbers (go through)

798 numState = PERLNUM_BAD;

799 break;

800 }

801 // complete current number or vector

                         sc.ChangeState(actualNumStyle(numState));

803 sc.SetState(SCE_PL_DEFAULT);

804 break;

805 case SCE_PL_COMMENTLINE:

806 if (sc.atLineEnd) {

807 sc.SetState(SCE_PL_DEFAULT);

808 }

809 break;

810 case SCE_PL_HERE_DELIM:

                         if (HereDoc.State == 0) { // '<<' encountered

812 int delim_ch = sc.chNext;

813 int ws_skip = 0;

                                 HereDoc.State = 1;      // pre-init HERE doc class

815 HereDoc.Quote = sc.chNext;

816 HereDoc.Quoted = false;

817 HereDoc.DelimiterLength = 0;

                                 HereDoc.Delimiter[HereDoc.DelimiterLength] = '\0';

                                 if (IsASpaceOrTab(delim_ch)) {

820 // skip whitespace; legal only for quoted delimiters

                                         unsigned int i = sc.currentPos + 1;

                                         while ((i < endPos) && IsASpaceOrTab(delim_ch)) {

823 i++;

                                                 delim_ch = static_cast<unsigned char>(styler.SafeGetCharAt(i));

825 }

                                         ws_skip = i - sc.currentPos - 1;

827 }

                                 if (delim_ch == '\'' || delim_ch == '"' || delim_ch == '`') {

829 // a quoted here-doc delimiter; skip any whitespace

                                         sc.Forward(ws_skip + 1);

831 HereDoc.Quote = delim_ch;

832 HereDoc.Quoted = true;

                                 } else if ((ws_skip == 0 && setNonHereDoc.Contains(sc.chNext))

834 || ws_skip > 0) {

835 // left shift << or <<= operator cases

836 // restore position if operator

837 sc.ChangeState(SCE_PL_OPERATOR);

838 sc.ForwardSetState(SCE_PL_DEFAULT);

839 backFlag = BACK_OPERATOR;

840 backPos = sc.currentPos;

841 HereDoc.State = 0;

842 } else {

843 // specially handle initial '\' for identifier

                                         if (ws_skip == 0 && HereDoc.Quote == '\\')

845 sc.Forward();

846 // an unquoted here-doc delimiter, no special handling

847 // (cannot be prefixed by spaces/tabs), or

848 // symbols terminates; deprecated zero-length delimiter

849 }

                         } else if (HereDoc.State == 1) { // collect the delimiter

851 backFlag = BACK_NONE;

                                 if (HereDoc.Quoted) { // a quoted here-doc delimiter

                                         if (sc.ch == HereDoc.Quote) { // closing quote => end of delimiter

854 sc.ForwardSetState(SCE_PL_DEFAULT);

                                         } else if (!sc.atLineEnd) {

                                                 if (sc.Match('\\', static_cast<char>(HereDoc.Quote))) { // escaped quote

857 sc.Forward();

858 }

                                                 if (sc.ch != '\r') {    // skip CR if CRLF

                                                         HereDoc.Append(sc.ch);

861 }

862 }

863 } else { // an unquoted here-doc delimiter

                                         if (setHereDocDelim.Contains(sc.ch)) {

                                                 HereDoc.Append(sc.ch);

866 } else {

867 sc.SetState(SCE_PL_DEFAULT);

868 }

869 }

                                 if (HereDoc.DelimiterLength >= HERE_DELIM_MAX - 1) {

871 sc.SetState(SCE_PL_ERROR);

872 HereDoc.State = 0;

873 }

874 }

875 break;

876 case SCE_PL_HERE_Q:

877 case SCE_PL_HERE_QQ:

878 case SCE_PL_HERE_QX:

879 // also implies HereDoc.State == 2

880 sc.Complete();

                         if (HereDoc.DelimiterLength == 0 || sc.Match(HereDoc.Delimiter)) {

                                 int c = sc.GetRelative(HereDoc.DelimiterLength);

                                 if (c == '\r' || c == '\n') {   // peek first, do not consume match

                                         sc.Forward(HereDoc.DelimiterLength);

885 sc.SetState(SCE_PL_DEFAULT);

886 backFlag = BACK_NONE;

887 HereDoc.State = 0;

888 if (!sc.atLineEnd)

889 sc.Forward();

890 break;

891 }

892 }

                         if (sc.state == SCE_PL_HERE_Q) {        // \EOF and 'EOF' non-interpolated

894 while (!sc.atLineEnd)

895 sc.Forward();

896 break;

897 }

                         while (!sc.atLineEnd) {         // "EOF" and `EOF` interpolated

                                 int s = 0, endType = 0;

                                 int maxSeg = endPos - sc.currentPos;

                                 while (s < maxSeg) {    // scan to break string into segments

                                         int c = sc.GetRelative(s);

                                         if (c == '\\') {

                                                 endType = 1; break;

                                         } else if (c == '\r' || c == '\n') {

                                                 endType = 2; break;

907 }

908 s++;

909 }

                                 if (s > 0)      // process non-empty segments

911 InterpolateSegment(sc, s);

                                 if (endType == 1) {

913 sc.Forward();

914 // \ at end-of-line does not appear to have any effect, skip

                                         if (sc.ch != '\r' && sc.ch != '\n')

916 sc.Forward();

                                 } else if (endType == 2) {

918 if (!sc.atLineEnd)

919 sc.Forward();

920 }

921 }

922 break;

923 case SCE_PL_POD:

924 case SCE_PL_POD_VERB: {

925 unsigned int fw = sc.currentPos;

                                 int ln = styler.GetLine(fw);

                                 if (sc.atLineStart && sc.Match("=cut")) {       // end of POD

928 sc.SetState(SCE_PL_POD);

                                         sc.Forward(4);

930 sc.SetState(SCE_PL_DEFAULT);

                                         styler.SetLineState(ln, SCE_PL_POD);

932 break;

933 }

                                 int pod = podLineScan(styler, fw, endPos);      // classify POD line

                                 styler.SetLineState(ln, pod);

936 if (pod == SCE_PL_DEFAULT) {

                                         if (sc.state == SCE_PL_POD_VERB) {

938 unsigned int fw2 = fw;

                                                 while (fw2 <= endPos && pod == SCE_PL_DEFAULT) {

940 fw = fw2++; // penultimate line (last blank line)

                                                         pod = podLineScan(styler, fw2, endPos);

                                                         styler.SetLineState(styler.GetLine(fw2), pod);

943 }

                                                 if (pod == SCE_PL_POD) {        // truncate verbatim POD early

945 sc.SetState(SCE_PL_POD);

946 } else

947 fw = fw2;

948 }

949 } else {

950 if (pod == SCE_PL_POD_VERB // still part of current paragraph

                                                 && (styler.GetLineState(ln - 1) == SCE_PL_POD)) {

952 pod = SCE_PL_POD;

                                                 styler.SetLineState(ln, pod);

954 } else if (pod == SCE_PL_POD

                                                 && (styler.GetLineState(ln - 1) == SCE_PL_POD_VERB)) {

956 pod = SCE_PL_POD_VERB;

                                                 styler.SetLineState(ln, pod);

958 }

959 sc.SetState(pod);

960 }

                                 sc.Forward(fw - sc.currentPos); // commit style

962 }

963 break;

964 case SCE_PL_REGEX:

965 case SCE_PL_STRING_QR:

                         if (Quote.Rep <= 0) {

                                 if (!setModifiers.Contains(sc.ch))

968 sc.SetState(SCE_PL_DEFAULT);

                         } else if (!Quote.Up && !IsASpace(sc.ch)) {

                                 Quote.Open(sc.ch);

971 } else {

                                 int s = 0, endType = 0;

                                 int maxSeg = endPos - sc.currentPos;

                                 while (s < maxSeg) {    // scan to break string into segments

                                         int c = sc.GetRelative(s);

                                         if (IsASpace(c)) {

977 break;

                                         } else if (c == '\\' && Quote.Up != '\\') {

                                                 endType = 1; break;

                                         } else if (c == Quote.Down) {

981 Quote.Count--;

                                                 if (Quote.Count == 0) {

983 Quote.Rep--;

984 break;

985 }

                                         } else if (c == Quote.Up)

987 Quote.Count++;

988 s++;

989 }

                                 if (s > 0) {    // process non-empty segments

                                         if (Quote.Up != '\'') {

                                                 InterpolateSegment(sc, s, true);

993 } else // non-interpolated path

994 sc.Forward(s);

995 }

                                 if (endType == 1)

997 sc.Forward();

998 }

999 break;

1000 case SCE_PL_REGSUBST:

1001 case SCE_PL_XLAT:

                         if (Quote.Rep <= 0) {

                                 if (!setModifiers.Contains(sc.ch))

1004 sc.SetState(SCE_PL_DEFAULT);

                         } else if (!Quote.Up && !IsASpace(sc.ch)) {

                                 Quote.Open(sc.ch);

1007 } else {

                                 int s = 0, endType = 0;

                                 int maxSeg = endPos - sc.currentPos;

                                 bool isPattern = (Quote.Rep == 2);

                                 while (s < maxSeg) {    // scan to break string into segments

                                         int c = sc.GetRelative(s);

                                         if (c == '\\' && Quote.Up != '\\') {

                                                 endType = 2; break;

                                         } else if (Quote.Count == 0 && Quote.Rep == 1) {

1016 // We matched something like s(...) or tr{...}, Perl 5.10

1017 // appears to allow almost any character for use as the

1018 // next delimiters. Whitespace and comments are accepted in

1019 // between, but we'll limit to whitespace here.

1020 // For '#', if no whitespace in between, it's a delimiter.

                                                 if (IsASpace(c)) {

1022 // Keep going

                                                 } else if (c == '#' && IsASpaceOrTab(sc.GetRelative(s - 1))) {

1024 endType = 3;

1025 } else

1026 Quote.Open(c);

1027 break;

                                         } else if (c == Quote.Down) {

1029 Quote.Count--;

                                                 if (Quote.Count == 0) {

1031 Quote.Rep--;

1032 endType = 1;

1033 }

                                                 if (Quote.Up == Quote.Down)

1035 Quote.Count++;

                                                 if (endType == 1)

1037 break;

                                         } else if (c == Quote.Up) {

1039 Quote.Count++;

                                         } else if (IsASpace(c))

1041 break;

1042 s++;

1043 }

                                 if (s > 0) {    // process non-empty segments

                                         if (sc.state == SCE_PL_REGSUBST && Quote.Up != '\'') {

                                                 InterpolateSegment(sc, s, isPattern);

1047 } else // non-interpolated path

1048 sc.Forward(s);

1049 }

                                 if (endType == 2) {

1051 sc.Forward();

                                 } else if (endType == 3)

1053 sc.SetState(SCE_PL_DEFAULT);

1054 }

1055 break;

1056 case SCE_PL_STRING_Q:

1057 case SCE_PL_STRING_QQ:

1058 case SCE_PL_STRING_QX:

1059 case SCE_PL_STRING_QW:

1060 case SCE_PL_STRING:

1061 case SCE_PL_CHARACTER:

1062 case SCE_PL_BACKTICKS:

                         if (!Quote.Down && !IsASpace(sc.ch)) {

                                 Quote.Open(sc.ch);

1065 } else {

                                 int s = 0, endType = 0;

                                 int maxSeg = endPos - sc.currentPos;

                                 while (s < maxSeg) {    // scan to break string into segments

                                         int c = sc.GetRelative(s);

                                         if (IsASpace(c)) {

1071 break;

                                         } else if (c == '\\' && Quote.Up != '\\') {

                                                 endType = 2; break;

                                         } else if (c == Quote.Down) {

1075 Quote.Count--;

                                                 if (Quote.Count == 0) {

                                                         endType = 3; break;

1078 }

                                         } else if (c == Quote.Up)

1080 Quote.Count++;

1081 s++;

1082 }

                                 if (s > 0) {    // process non-empty segments

1084 switch (sc.state) {

1085 case SCE_PL_STRING:

1086 case SCE_PL_STRING_QQ:

1087 case SCE_PL_BACKTICKS:

1088 InterpolateSegment(sc, s);

1089 break;

1090 case SCE_PL_STRING_QX:

                                                 if (Quote.Up != '\'') {

1092 InterpolateSegment(sc, s);

1093 break;

1094 }

1095 // (continued for ' delim)

1096 default: // non-interpolated path

1097 sc.Forward(s);

1098 }

1099 }

                                 if (endType == 2) {

1101 sc.Forward();

                                 } else if (endType == 3)

1103 sc.ForwardSetState(SCE_PL_DEFAULT);

1104 }

1105 break;

1106 case SCE_PL_SUB_PROTOTYPE: {

1107 int i = 0;

1108 // forward scan; must all be valid proto characters

                                 while (setSubPrototype.Contains(sc.GetRelative(i)))

1110 i++;

                                 if (sc.GetRelative(i) == ')') { // valid sub prototype

1112 sc.Forward(i);

1113 sc.ForwardSetState(SCE_PL_DEFAULT);

1114 } else {

1115 // abandon prototype, restart from '('

1116 sc.ChangeState(SCE_PL_OPERATOR);

1117 sc.SetState(SCE_PL_DEFAULT);

1118 }

1119 }

1120 break;

1121 case SCE_PL_FORMAT: {

1122 sc.Complete();

                                 if (sc.Match('.')) {

1124 sc.Forward();

                                         if (sc.atLineEnd || ((sc.ch == '\r' && sc.chNext == '\n')))

1126 sc.SetState(SCE_PL_DEFAULT);

1127 }

1128 while (!sc.atLineEnd)

1129 sc.Forward();

1130 }

1131 break;

1132 case SCE_PL_ERROR:

1133 break;

1134 }

1135 // Needed for specific continuation styles (one follows the other)

1136 switch (sc.state) {

1137 // continued from SCE_PL_WORD

1138 case SCE_PL_FORMAT_IDENT:

1139 // occupies HereDoc state 3 to avoid clashing with HERE docs

                         if (IsASpaceOrTab(sc.ch)) {             // skip whitespace

1141 sc.ChangeState(SCE_PL_DEFAULT);

                                 while (IsASpaceOrTab(sc.ch) && !sc.atLineEnd)

1143 sc.Forward();

1144 sc.SetState(SCE_PL_FORMAT_IDENT);

1145 }

                         if (setFormatStart.Contains(sc.ch)) {   // identifier or '='

                                 if (sc.ch != '=') {

1148 do {

1149 sc.Forward();

                                         } while (setFormat.Contains(sc.ch));

1151 }

                                 while (IsASpaceOrTab(sc.ch) && !sc.atLineEnd)

1153 sc.Forward();

                                 if (sc.ch == '=') {

1155 sc.ForwardSetState(SCE_PL_DEFAULT);

1156 HereDoc.State = 3;

1157 } else {

1158 // invalid indentifier; inexact fallback, but hey

1159 sc.ChangeState(SCE_PL_IDENTIFIER);

1160 sc.SetState(SCE_PL_DEFAULT);

1161 }

1162 } else {

                                 sc.ChangeState(SCE_PL_DEFAULT); // invalid indentifier

1164 }

1165 backFlag = BACK_NONE;

1166 break;

1167 }

1168

1169 // Must check end of HereDoc states here before default state is handled

                 if (HereDoc.State == 1 && sc.atLineEnd) {

1171 // Begin of here-doc (the line after the here-doc delimiter):

1172 // Lexically, the here-doc starts from the next line after the >>, but the

1173 // first line of here-doc seem to follow the style of the last EOL sequence

1174 int st_new = SCE_PL_HERE_QQ;

1175 HereDoc.State = 2;

1176 if (HereDoc.Quoted) {

                                 if (sc.state == SCE_PL_HERE_DELIM) {

1178 // Missing quote at end of string! We are stricter than perl.

1179 // Colour here-doc anyway while marking this bit as an error.

1180 sc.ChangeState(SCE_PL_ERROR);

1181 }

1182 switch (HereDoc.Quote) {

                                 case '\'':

1184 st_new = SCE_PL_HERE_Q ;

1185 break;

1186 case '"' :

1187 st_new = SCE_PL_HERE_QQ;

1188 break;

1189 case '`' :

1190 st_new = SCE_PL_HERE_QX;

1191 break;

1192 }

1193 } else {

                                 if (HereDoc.Quote == '\\')

1195 st_new = SCE_PL_HERE_Q;

1196 }

1197 sc.SetState(st_new);

1198 }

                 if (HereDoc.State == 3 && sc.atLineEnd) {

1200 // Start of format body.

1201 HereDoc.State = 0;

1202 sc.SetState(SCE_PL_FORMAT);

1203 }

1204

1205 // Determine if a new state should be entered.

                 if (sc.state == SCE_PL_DEFAULT) {

                         if (IsADigit(sc.ch) ||

                                 (IsADigit(sc.chNext) && (sc.ch == '.' || sc.ch == 'v'))) {

1209 sc.SetState(SCE_PL_NUMBER);

1210 backFlag = BACK_NONE;

1211 numState = PERLNUM_DECIMAL;

1212 dotCount = 0;

                                 if (sc.ch == '0') {             // hex,bin,octal

                                         if (sc.chNext == 'x' || sc.chNext == 'X') {

1215 numState = PERLNUM_HEX;

                                         } else if (sc.chNext == 'b' || sc.chNext == 'B') {

1217 numState = PERLNUM_BINARY;

                                         } else if (IsADigit(sc.chNext)) {

1219 numState = PERLNUM_OCTAL;

1220 }

1221 if (numState != PERLNUM_DECIMAL) {

1222 sc.Forward();

1223 }

                                 } else if (sc.ch == 'v') {              // vector

1225 numState = PERLNUM_V_VECTOR;

1226 }

                         } else if (setWord.Contains(sc.ch)) {

1228 // if immediately prefixed by '::', always a bareword

1229 sc.SetState(SCE_PL_WORD);

                                 if (sc.chPrev == ':' && sc.GetRelative(-2) == ':') {

1231 sc.ChangeState(SCE_PL_IDENTIFIER);

1232 }

1233 unsigned int bk = sc.currentPos;

                                 unsigned int fw = sc.currentPos + 1;

1235 // first check for possible quote-like delimiter

                                 if (sc.ch == 's' && !setWord.Contains(sc.chNext)) {

1237 sc.ChangeState(SCE_PL_REGSUBST);

                                         Quote.New(2);

                                 } else if (sc.ch == 'm' && !setWord.Contains(sc.chNext)) {

1240 sc.ChangeState(SCE_PL_REGEX);

1241 Quote.New();

                                 } else if (sc.ch == 'q' && !setWord.Contains(sc.chNext)) {

1243 sc.ChangeState(SCE_PL_STRING_Q);

1244 Quote.New();

                                 } else if (sc.ch == 'y' && !setWord.Contains(sc.chNext)) {

1246 sc.ChangeState(SCE_PL_XLAT);

                                         Quote.New(2);

                                 } else if (sc.Match('t', 'r') && !setWord.Contains(sc.GetRelative(2))) {

1249 sc.ChangeState(SCE_PL_XLAT);

                                         Quote.New(2);

1251 sc.Forward();

1252 fw++;

                                 } else if (sc.ch == 'q' && setQDelim.Contains(sc.chNext)

                                         && !setWord.Contains(sc.GetRelative(2))) {

                                         if (sc.chNext == 'q') sc.ChangeState(SCE_PL_STRING_QQ);

                                         else if (sc.chNext == 'x') sc.ChangeState(SCE_PL_STRING_QX);

                                         else if (sc.chNext == 'r') sc.ChangeState(SCE_PL_STRING_QR);

                                         else sc.ChangeState(SCE_PL_STRING_QW);  // sc.chNext == 'w'

1259 Quote.New();

1260 sc.Forward();

1261 fw++;

                                 } else if (sc.ch == 'x' && (sc.chNext == '=' || // repetition

                                         !setWord.Contains(sc.chNext) ||

                                         (IsADigit(sc.chPrev) && IsADigit(sc.chNext)))) {

1265 sc.ChangeState(SCE_PL_OPERATOR);

1266 }

1267 // if potentially a keyword, scan forward and grab word, then check

1268 // if it's really one; if yes, disambiguation test is performed

1269 // otherwise it is always a bareword and we skip a lot of scanning

                                 if (sc.state == SCE_PL_WORD) {

                                         while (setWord.Contains(static_cast<unsigned char>(styler.SafeGetCharAt(fw))))

1272 fw++;

                                         if (!isPerlKeyword(styler.GetStartSegment(), fw, keywords, styler)) {

1274 sc.ChangeState(SCE_PL_IDENTIFIER);

1275 }

1276 }

1277 // if already SCE_PL_IDENTIFIER, then no ambiguity, skip this

1278 // for quote-like delimiters/keywords, attempt to disambiguate

1279 // to select for bareword, change state -> SCE_PL_IDENTIFIER

                                 if (sc.state != SCE_PL_IDENTIFIER && bk > 0) {

                                         if (disambiguateBareword(styler, bk, fw, backFlag, backPos, endPos))

1282 sc.ChangeState(SCE_PL_IDENTIFIER);

1283 }

1284 backFlag = BACK_NONE;

                         } else if (sc.ch == '#') {

1286 sc.SetState(SCE_PL_COMMENTLINE);

                         } else if (sc.ch == '\"') {

1288 sc.SetState(SCE_PL_STRING);

1289 Quote.New();

                                 Quote.Open(sc.ch);

1291 backFlag = BACK_NONE;

                         } else if (sc.ch == '\'') {

                                 if (sc.chPrev == '&' && setWordStart.Contains(sc.chNext)) {

1294 // Archaic call

1295 sc.SetState(SCE_PL_IDENTIFIER);

1296 } else {

1297 sc.SetState(SCE_PL_CHARACTER);

1298 Quote.New();

                                         Quote.Open(sc.ch);

1300 }

1301 backFlag = BACK_NONE;

                         } else if (sc.ch == '`') {

1303 sc.SetState(SCE_PL_BACKTICKS);

1304 Quote.New();

                                 Quote.Open(sc.ch);

1306 backFlag = BACK_NONE;

                         } else if (sc.ch == '$') {

1308 sc.SetState(SCE_PL_SCALAR);

                                 if (sc.chNext == '{') {

1310 sc.ForwardSetState(SCE_PL_OPERATOR);

                                 } else if (IsASpace(sc.chNext)) {

1312 sc.ForwardSetState(SCE_PL_DEFAULT);

1313 } else {

1314 sc.Forward();

                                         if (sc.Match('`', '`') || sc.Match(':', ':')) {

1316 sc.Forward();

1317 }

1318 }

1319 backFlag = BACK_NONE;

                         } else if (sc.ch == '@') {

1321 sc.SetState(SCE_PL_ARRAY);

                                 if (setArray.Contains(sc.chNext)) {

1323 // no special treatment

                                 } else if (sc.chNext == ':' && sc.GetRelative(2) == ':') {

                                         sc.Forward(2);

                                 } else if (sc.chNext == '{' || sc.chNext == '[') {

1327 sc.ForwardSetState(SCE_PL_OPERATOR);

1328 } else {

1329 sc.ChangeState(SCE_PL_OPERATOR);

1330 }

1331 backFlag = BACK_NONE;

                         } else if (setPreferRE.Contains(sc.ch)) {

1333 // Explicit backward peeking to set a consistent preferRE for

1334 // any slash found, so no longer need to track preferRE state.

1335 // Find first previous significant lexed element and interpret.

1336 // A few symbols shares this code for disambiguation.

1337 bool preferRE = false;

                                 bool isHereDoc = sc.Match('<', '<');

                                 bool hereDocSpace = false;              // for: SCALAR [whitespace] '<<'

                                 unsigned int bk = (sc.currentPos > 0) ? sc.currentPos - 1: 0;

1341 sc.Complete();

1342 styler.Flush();

                                 if (styler.StyleAt(bk) == SCE_PL_DEFAULT)

1344 hereDocSpace = true;

1345 skipWhitespaceComment(styler, bk);

                                 if (bk == 0) {

1347 // avoid backward scanning breakage

1348 preferRE = true;

1349 } else {

                                         int bkstyle = styler.StyleAt(bk);

                                         int bkch = static_cast<unsigned char>(styler.SafeGetCharAt(bk));

1352 switch (bkstyle) {

1353 case SCE_PL_OPERATOR:

1354 preferRE = true;

                                                 if (bkch == ')' || bkch == ']') {

1356 preferRE = false;

                                                 } else if (bkch == '}') {

1358 // backtrack by counting balanced brace pairs

1359 // needed to test for variables like ${}, @{} etc.

                                                         bkstyle = styleBeforeBracePair(styler, bk);

1361 if (bkstyle == SCE_PL_SCALAR

1362 || bkstyle == SCE_PL_ARRAY

1363 || bkstyle == SCE_PL_HASH

1364 || bkstyle == SCE_PL_SYMBOLTABLE

1365 || bkstyle == SCE_PL_OPERATOR) {

1366 preferRE = false;

1367 }

                                                 } else if (bkch == '+' || bkch == '-') {

                                                         if (bkch == static_cast<unsigned char>(styler.SafeGetCharAt(bk - 1))

                                                                 && bkch != static_cast<unsigned char>(styler.SafeGetCharAt(bk - 2)))

1371 // exceptions for operators: unary suffixes ++, --

1372 preferRE = false;

1373 }

1374 break;

1375 case SCE_PL_IDENTIFIER:

1376 preferRE = true;

                                                 bkstyle = styleCheckIdentifier(styler, bk);

                                                 if ((bkstyle == 1) || (bkstyle == 2)) {

1379 // inputsymbol or var with "->" or "::" before identifier

1380 preferRE = false;

                                                 } else if (bkstyle == 3) {

1382 // bare identifier, test cases follows:

                                                         if (sc.ch == '/') {

1384 // if '/', /PATTERN/ unless digit/space immediately after '/'

1385 // if '//', always expect defined-or operator to follow identifier

                                                                 if (IsASpace(sc.chNext) || IsADigit(sc.chNext) || sc.chNext == '/')

1387 preferRE = false;

                                                         } else if (sc.ch == '*' || sc.ch == '%') {

                                                                 if (IsASpace(sc.chNext) || IsADigit(sc.chNext) || sc.Match('*', '*'))

1390 preferRE = false;

                                                         } else if (sc.ch == '<') {

                                                                 if (IsASpace(sc.chNext) || sc.chNext == '=')

1393 preferRE = false;

1394 }

1395 }

1396 break;

1397 case SCE_PL_SCALAR: // for $var<< case:

                                                 if (isHereDoc && hereDocSpace)  // if SCALAR whitespace '<<', *always* a HERE doc

1399 preferRE = true;

1400 break;

1401 case SCE_PL_WORD:

1402 preferRE = true;

1403 // for HERE docs, always true

                                                 if (sc.ch == '/') {

1405 // adopt heuristics similar to vim-style rules:

1406 // keywords always forced as /PATTERN/: split, if, elsif, while

1407 // everything else /PATTERN/ unless digit/space immediately after '/'

1408 // for '//', defined-or favoured unless special keywords

                                                         unsigned int bkend = bk + 1;

                                                         while (bk > 0 && styler.StyleAt(bk - 1) == SCE_PL_WORD) {

1411 bk--;

1412 }

                                                         if (isPerlKeyword(bk, bkend, reWords, styler))

1414 break;

                                                         if (IsASpace(sc.chNext) || IsADigit(sc.chNext) || sc.chNext == '/')

1416 preferRE = false;

                                                 } else if (sc.ch == '*' || sc.ch == '%') {

                                                         if (IsASpace(sc.chNext) || IsADigit(sc.chNext) || sc.Match('*', '*'))

1419 preferRE = false;

                                                 } else if (sc.ch == '<') {

                                                         if (IsASpace(sc.chNext) || sc.chNext == '=')

1422 preferRE = false;

1423 }

1424 break;

1425

1426 // other styles uses the default, preferRE=false

1427 case SCE_PL_POD:

1428 case SCE_PL_HERE_Q:

1429 case SCE_PL_HERE_QQ:

1430 case SCE_PL_HERE_QX:

1431 preferRE = true;

1432 break;

1433 }

1434 }

1435 backFlag = BACK_NONE;

1436 if (isHereDoc) { // handle '<<', HERE doc

1437 if (preferRE) {

1438 sc.SetState(SCE_PL_HERE_DELIM);

1439 HereDoc.State = 0;

1440 } else { // << operator

1441 sc.SetState(SCE_PL_OPERATOR);

1442 sc.Forward();

1443 }

                                 } else if (sc.ch == '*') {      // handle '*', typeglob

1445 if (preferRE) {

1446 sc.SetState(SCE_PL_SYMBOLTABLE);

                                                 if (sc.chNext == ':' && sc.GetRelative(2) == ':') {

                                                         sc.Forward(2);

                                                 } else if (sc.chNext == '{') {

1450 sc.ForwardSetState(SCE_PL_OPERATOR);

1451 } else {

1452 sc.Forward();

1453 }

1454 } else {

1455 sc.SetState(SCE_PL_OPERATOR);

                                                 if (sc.chNext == '*')   // exponentiation

1457 sc.Forward();

1458 }

                                 } else if (sc.ch == '%') {      // handle '%', hash

1460 if (preferRE) {

1461 sc.SetState(SCE_PL_HASH);

                                                 if (setHash.Contains(sc.chNext)) {

1463 sc.Forward();

                                                 } else if (sc.chNext == ':' && sc.GetRelative(2) == ':') {

                                                         sc.Forward(2);

                                                 } else if (sc.chNext == '{') {

1467 sc.ForwardSetState(SCE_PL_OPERATOR);

1468 } else {

1469 sc.ChangeState(SCE_PL_OPERATOR);

1470 }

1471 } else {

1472 sc.SetState(SCE_PL_OPERATOR);

1473 }

                                 } else if (sc.ch == '<') {      // handle '<', inputsymbol

1475 if (preferRE) {

1476 // forward scan

                                                 int i = inputsymbolScan(styler, sc.currentPos, endPos);

                                                 if (i > 0) {

1479 sc.SetState(SCE_PL_IDENTIFIER);

1480 sc.Forward(i);

1481 } else {

1482 sc.SetState(SCE_PL_OPERATOR);

1483 }

1484 } else {

1485 sc.SetState(SCE_PL_OPERATOR);

1486 }

1487 } else { // handle '/', regexp

1488 if (preferRE) {

1489 sc.SetState(SCE_PL_REGEX);

1490 Quote.New();

                                                 Quote.Open(sc.ch);

1492 } else { // / and // operators

1493 sc.SetState(SCE_PL_OPERATOR);

                                                 if (sc.chNext == '/') {

1495 sc.Forward();

1496 }

1497 }

1498 }

                         } else if (sc.ch == '='         // POD

                                 && setPOD.Contains(sc.chNext)

1501 && sc.atLineStart) {

1502 sc.SetState(SCE_PL_POD);

1503 backFlag = BACK_NONE;

                         } else if (sc.ch == '-' && setWordStart.Contains(sc.chNext)) {  // extended '-' cases

1505 unsigned int bk = sc.currentPos;

1506 unsigned int fw = 2;

                                 if (setSingleCharOp.Contains(sc.chNext) &&      // file test operators

                                         !setWord.Contains(sc.GetRelative(2))) {

1509 sc.SetState(SCE_PL_WORD);

1510 } else {

1511 // nominally a minus and bareword; find extent of bareword

                                         while (setWord.Contains(sc.GetRelative(fw)))

1513 fw++;

1514 sc.SetState(SCE_PL_OPERATOR);

1515 }

1516 // force to bareword for hash key => or {variable literal} cases

                                 if (disambiguateBareword(styler, bk, bk + fw, backFlag, backPos, endPos) & 2) {

1518 sc.ChangeState(SCE_PL_IDENTIFIER);

1519 }

1520 backFlag = BACK_NONE;

                         } else if (sc.ch == '(' && sc.currentPos > 0) { // '(' or subroutine prototype

1522 sc.Complete();

                                 if (styleCheckSubPrototype(styler, sc.currentPos - 1)) {

1524 sc.SetState(SCE_PL_SUB_PROTOTYPE);

1525 backFlag = BACK_NONE;

1526 } else {

1527 sc.SetState(SCE_PL_OPERATOR);

1528 }

                         } else if (setPerlOperator.Contains(sc.ch)) {   // operators

1530 sc.SetState(SCE_PL_OPERATOR);

                                 if (sc.Match('.', '.')) {       // .. and ...

1532 sc.Forward();

                                         if (sc.chNext == '.') sc.Forward();

1534 }

                         } else if (sc.ch == 4 || sc.ch == 26) {         // ^D and ^Z ends valid perl source

1536 sc.SetState(SCE_PL_DATASECTION);

1537 } else {

1538 // keep colouring defaults

1539 sc.Complete();

1540 }

1541 }

1542 }

1543 sc.Complete();

1544 if (sc.state == SCE_PL_HERE_Q

1545 || sc.state == SCE_PL_HERE_QQ

1546 || sc.state == SCE_PL_HERE_QX

1547 || sc.state == SCE_PL_FORMAT) {

                 styler.ChangeLexerState(sc.currentPos, styler.Length());

1549 }

1550 sc.Complete();

1551 }

1552

1553 #define PERL_HEADFOLD_SHIFT 4

1554 #define PERL_HEADFOLD_MASK 0xF0

1555

 void SCI_METHOD LexerPerl::Fold(unsigned int startPos, int length, int /* initStyle */, IDocument *pAccess) {

1557

1558 if (!options.fold)

1559 return;

1560

1561 LexAccessor styler(pAccess);

1562

1563 unsigned int endPos = startPos + length;

1564 int visibleChars = 0;

         int lineCurrent = styler.GetLine(startPos);

1566

1567 // Backtrack to previous line in case need to fix its fold status

         if (startPos > 0) {

                 if (lineCurrent > 0) {

1570 lineCurrent--;

                         startPos = styler.LineStart(lineCurrent);

1572 }

1573 }

1574

1575 int levelPrev = SC_FOLDLEVELBASE;

         if (lineCurrent > 0)

                 levelPrev = styler.LevelAt(lineCurrent - 1) >> 16;

1578 int levelCurrent = levelPrev;

1579 char chNext = styler[startPos];

         char chPrev = styler.SafeGetCharAt(startPos - 1);

         int styleNext = styler.StyleAt(startPos);

1582 // Used at end of line to determine if the line was a package definition

1583 bool isPackageLine = false;

1584 int podHeading = 0;

         for (unsigned int i = startPos; i < endPos; i++) {

1586 char ch = chNext;

                 chNext = styler.SafeGetCharAt(i + 1);

1588 int style = styleNext;

                 styleNext = styler.StyleAt(i + 1);

                 int stylePrevCh = (i) ? styler.StyleAt(i - 1):SCE_PL_DEFAULT;

                 bool atEOL = (ch == '\r' && chNext != '\n') || (ch == '\n');

                 bool atLineStart = ((chPrev == '\r') || (chPrev == '\n')) || i == 0;

1593 // Comment folding

                 if (options.foldComment && atEOL && IsCommentLine(lineCurrent, styler)) {

                         if (!IsCommentLine(lineCurrent - 1, styler)

                                 && IsCommentLine(lineCurrent + 1, styler))

1597 levelCurrent++;

                         else if (IsCommentLine(lineCurrent - 1, styler)

                                 && !IsCommentLine(lineCurrent + 1, styler))

1600 levelCurrent--;

1601 }

1602 // {} [] block folding

1603 if (style == SCE_PL_OPERATOR) {

                         if (ch == '{') {

                                 if (options.foldAtElse && levelCurrent < levelPrev)

1606 --levelPrev;

1607 levelCurrent++;

                         } else if (ch == '}') {

1609 levelCurrent--;

1610 }

                         if (ch == '[') {

                                 if (options.foldAtElse && levelCurrent < levelPrev)

1613 --levelPrev;

1614 levelCurrent++;

                         } else if (ch == ']') {

1616 levelCurrent--;

1617 }

1618 }

1619 // POD folding

                 if (options.foldPOD && atLineStart) {

1621 if (style == SCE_PL_POD) {

                                 if (stylePrevCh != SCE_PL_POD && stylePrevCh != SCE_PL_POD_VERB)

1623 levelCurrent++;

                                 else if (styler.Match(i, "=cut"))

                                         levelCurrent = (levelCurrent & ~PERL_HEADFOLD_MASK) - 1;

                                 else if (styler.Match(i, "=head"))

                                         podHeading = PodHeadingLevel(i, styler);

                         } else if (style == SCE_PL_DATASECTION) {

                                 if (ch == '=' && isascii(chNext) && isalpha(chNext) && levelCurrent == SC_FOLDLEVELBASE)

1630 levelCurrent++;

                                 else if (styler.Match(i, "=cut") && levelCurrent > SC_FOLDLEVELBASE)

                                         levelCurrent = (levelCurrent & ~PERL_HEADFOLD_MASK) - 1;

                                 else if (styler.Match(i, "=head"))

                                         podHeading = PodHeadingLevel(i, styler);

1635 // if package used or unclosed brace, level > SC_FOLDLEVELBASE!

1636 // reset needed as level test is vs. SC_FOLDLEVELBASE

1637 else if (stylePrevCh != SCE_PL_DATASECTION)

1638 levelCurrent = SC_FOLDLEVELBASE;

1639 }

1640 }

1641 // package folding

                 if (options.foldPackage && atLineStart) {

                         if (IsPackageLine(lineCurrent, styler)

                                 && !IsPackageLine(lineCurrent + 1, styler))

1645 isPackageLine = true;

1646 }

1647

1648 //heredoc folding

1649 switch (style) {

1650 case SCE_PL_HERE_QQ :

1651 case SCE_PL_HERE_Q :

1652 case SCE_PL_HERE_QX :

1653 switch (stylePrevCh) {

1654 case SCE_PL_HERE_QQ :

1655 case SCE_PL_HERE_Q :

1656 case SCE_PL_HERE_QX :

1657 //do nothing;

1658 break;

1659 default :

1660 levelCurrent++;

1661 break;

1662 }

1663 break;

1664 default:

1665 switch (stylePrevCh) {

1666 case SCE_PL_HERE_QQ :

1667 case SCE_PL_HERE_Q :

1668 case SCE_PL_HERE_QX :

1669 levelCurrent--;

1670 break;

1671 default :

1672 //do nothing;

1673 break;

1674 }

1675 break;

1676 }

1677

1678 //explicit folding

                 if (options.foldCommentExplicit && style == SCE_PL_COMMENTLINE && ch == '#') {

                         if (chNext == '{') {

1681 levelCurrent++;

                         } else if (levelCurrent > SC_FOLDLEVELBASE  && chNext == '}') {

1683 levelCurrent--;

1684 }

1685 }

1686

1687 if (atEOL) {

1688 int lev = levelPrev;

1689 // POD headings occupy bits 7-4, leaving some breathing room for

1690 // non-standard practice -- POD sections stuck in blocks, etc.

                         if (podHeading > 0) {

                                 levelCurrent = (lev & ~PERL_HEADFOLD_MASK) | (podHeading << PERL_HEADFOLD_SHIFT);

1693 lev = levelCurrent - 1;

1694 lev |= SC_FOLDLEVELHEADERFLAG;

1695 podHeading = 0;

1696 }

1697 // Check if line was a package declaration

1698 // because packages need "special" treatment

1699 if (isPackageLine) {

1700 lev = SC_FOLDLEVELBASE | SC_FOLDLEVELHEADERFLAG;

1701 levelCurrent = SC_FOLDLEVELBASE + 1;

1702 isPackageLine = false;

1703 }

1704 lev |= levelCurrent << 16;

                         if (visibleChars == 0 && options.foldCompact)

1706 lev |= SC_FOLDLEVELWHITEFLAG;

                         if ((levelCurrent > levelPrev) && (visibleChars > 0))

1708 lev |= SC_FOLDLEVELHEADERFLAG;

                         if (lev != styler.LevelAt(lineCurrent)) {

                                 styler.SetLevel(lineCurrent, lev);

1711 }

1712 lineCurrent++;

1713 levelPrev = levelCurrent;

1714 visibleChars = 0;

1715 }

                 if (!isspacechar(ch))

1717 visibleChars++;

1718 chPrev = ch;

1719 }

1720 // Fill in the real level of the next line, keeping the current flags as they will be filled in later

         int flagsNext = styler.LevelAt(lineCurrent) & ~SC_FOLDLEVELNUMBERMASK;

         styler.SetLevel(lineCurrent, levelPrev | flagsNext);

1723 }

1724

 LexerModule lmPerl(SCLEX_PERL, LexerPerl::LexerFactoryPerl, "perl", perlWordListDesc, 8);