]> git.saurik.com Git - wxWidgets.git/blob - src/stc/scintilla/src/LexPerl.cxx
projects / wxWidgets.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
blame | history | raw | HEAD
wxWakeUpIdle seems unnecessary here
[wxWidgets.git] / src / stc / scintilla / src / LexPerl.cxx
1 // Scintilla source code edit control
2 /** @file LexPerl.cxx
3 ** Lexer for subset of Perl.
4 **/
5 // Copyright 1998-2005 by Neil Hodgson <neilh@scintilla.org>
6 // Lexical analysis fixes by Kein-Hong Man <mkh@pl.jaring.my>
7 // The License.txt file describes the conditions under which this software may be distributed.
8
9 #include <stdlib.h>
10 #include <string.h>
11 #include <ctype.h>
12 #include <stdio.h>
13 #include <stdarg.h>
14
15 #include "Platform.h"
16
17 #include "PropSet.h"
18 #include "Accessor.h"
19 #include "KeyWords.h"
20 #include "Scintilla.h"
21 #include "SciLexer.h"
22
23 #define PERLNUM_BINARY 1 // order is significant: 1-4 cannot have a dot
24 #define PERLNUM_HEX 2
25 #define PERLNUM_OCTAL 3
26 #define PERLNUM_FLOAT 4 // actually exponent part
27 #define PERLNUM_DECIMAL 5 // 1-5 are numbers; 6-7 are strings
28 #define PERLNUM_VECTOR 6
29 #define PERLNUM_V_VECTOR 7
30 #define PERLNUM_BAD 8
31
32 #define BACK_NONE 0 // lookback state for bareword disambiguation:
33 #define BACK_OPERATOR 1 // whitespace/comments are insignificant
34 #define BACK_KEYWORD 2 // operators/keywords are needed for disambiguation
35
36 #define HERE_DELIM_MAX 256
37
38 static inline bool isEOLChar(char ch) {
39 return (ch == '\r') || (ch == '\n');
40 }
41
42 static bool isSingleCharOp(char ch) {
43 char strCharSet[2];
44 strCharSet[0] = ch;
45 strCharSet[1] = '\0';
46 return (NULL != strstr("rwxoRWXOezsfdlpSbctugkTBMAC", strCharSet));
47 }
48
49 static inline bool isPerlOperator(char ch) {
50 if (ch == '^' || ch == '&' || ch == '\\' ||
51 ch == '(' || ch == ')' || ch == '-' || ch == '+' ||
52 ch == '=' || ch == '|' || ch == '{' || ch == '}' ||
53 ch == '[' || ch == ']' || ch == ':' || ch == ';' ||
54 ch == '>' || ch == ',' ||
55 ch == '?' || ch == '!' || ch == '.' || ch == '~')
56 return true;
57 // these chars are already tested before this call
58 // ch == '%' || ch == '*' || ch == '<' || ch == '/' ||
59 return false;
60 }
61
62 static bool isPerlKeyword(unsigned int start, unsigned int end, WordList &keywords, Accessor &styler) {
63 char s[100];
64 unsigned int i, len = end - start;
65 if (len > 30) { len = 30; }
66 for (i = 0; i < len; i++, start++) s[i] = styler[start];
67 s[i] = '\0';
68 return keywords.InList(s);
69 }
70
71 static inline bool isEndVar(char ch) {
72 return !isalnum(ch) && ch != '#' && ch != '$' &&
73 ch != '_' && ch != '\'';
74 }
75
76
77 static inline bool isNonQuote(char ch) {
78 return isalnum(ch) || ch == '_';
79 }
80
81 static inline char actualNumStyle(int numberStyle) {
82 if (numberStyle == PERLNUM_VECTOR || numberStyle == PERLNUM_V_VECTOR) {
83 return SCE_PL_STRING;
84 } else if (numberStyle == PERLNUM_BAD) {
85 return SCE_PL_ERROR;
86 }
87 return SCE_PL_NUMBER;
88 }
89
90 static bool isMatch(Accessor &styler, int lengthDoc, int pos, const char *val) {
91 if ((pos + static_cast<int>(strlen(val))) >= lengthDoc) {
92 return false;
93 }
94 while (*val) {
95 if (*val != styler[pos++]) {
96 return false;
97 }
98 val++;
99 }
100 return true;
101 }
102
103 static char opposite(char ch) {
104 if (ch == '(')
105 return ')';
106 if (ch == '[')
107 return ']';
108 if (ch == '{')
109 return '}';
110 if (ch == '<')
111 return '>';
112 return ch;
113 }
114
115 static void ColourisePerlDoc(unsigned int startPos, int length, int initStyle,
116 WordList *keywordlists[], Accessor &styler) {
117
118 // Lexer for perl often has to backtrack to start of current style to determine
119 // which characters are being used as quotes, how deeply nested is the
120 // start position and what the termination string is for here documents
121
122 WordList &keywords = *keywordlists[0];
123
124 class HereDocCls {
125 public:
126 int State; // 0: '<<' encountered
127 // 1: collect the delimiter
128 // 2: here doc text (lines after the delimiter)
129 char Quote; // the char after '<<'
130 bool Quoted; // true if Quote in ('\'','"','`')
131 int DelimiterLength; // strlen(Delimiter)
132 char *Delimiter; // the Delimiter, 256: sizeof PL_tokenbuf
133 HereDocCls() {
134 State = 0;
135 Quote = 0;
136 Quoted = false;
137 DelimiterLength = 0;
138 Delimiter = new char[HERE_DELIM_MAX];
139 Delimiter[0] = '\0';
140 }
141 ~HereDocCls() {
142 delete []Delimiter;
143 }
144 };
145 HereDocCls HereDoc; // TODO: FIFO for stacked here-docs
146
147 class QuoteCls {
148 public:
149 int Rep;
150 int Count;
151 char Up;
152 char Down;
153 QuoteCls() {
154 this->New(1);
155 }
156 void New(int r) {
157 Rep = r;
158 Count = 0;
159 Up = '\0';
160 Down = '\0';
161 }
162 void Open(char u) {
163 Count++;
164 Up = u;
165 Down = opposite(Up);
166 }
167 };
168 QuoteCls Quote;
169
170 int state = initStyle;
171 char numState = PERLNUM_DECIMAL;
172 int dotCount = 0;
173 unsigned int lengthDoc = startPos + length;
174 //int sookedpos = 0; // these have no apparent use, see POD state
175 //char sooked[100];
176 //sooked[sookedpos] = '\0';
177
178 // If in a long distance lexical state, seek to the beginning to find quote characters
179 // Perl strings can be multi-line with embedded newlines, so backtrack.
180 // Perl numbers have additional state during lexing, so backtrack too.
181 if (state == SCE_PL_HERE_Q || state == SCE_PL_HERE_QQ || state == SCE_PL_HERE_QX) {
182 while ((startPos > 1) && (styler.StyleAt(startPos) != SCE_PL_HERE_DELIM)) {
183 startPos--;
184 }
185 startPos = styler.LineStart(styler.GetLine(startPos));
186 state = styler.StyleAt(startPos - 1);
187 }
188 if ( state == SCE_PL_STRING_Q
189 || state == SCE_PL_STRING_QQ
190 || state == SCE_PL_STRING_QX
191 || state == SCE_PL_STRING_QR
192 || state == SCE_PL_STRING_QW
193 || state == SCE_PL_REGEX
194 || state == SCE_PL_REGSUBST
195 || state == SCE_PL_STRING
196 || state == SCE_PL_BACKTICKS
197 || state == SCE_PL_CHARACTER
198 || state == SCE_PL_NUMBER
199 || state == SCE_PL_IDENTIFIER
200 || state == SCE_PL_ERROR
201 ) {
202 while ((startPos > 1) && (styler.StyleAt(startPos - 1) == state)) {
203 startPos--;
204 }
205 state = SCE_PL_DEFAULT;
206 }
207
208 // lookback at start of lexing to set proper state for backflag
209 // after this, they are updated when elements are lexed
210 int backflag = BACK_NONE;
211 unsigned int backPos = startPos;
212 if (backPos > 0) {
213 backPos--;
214 int sty = SCE_PL_DEFAULT;
215 while ((backPos > 0) && (sty = styler.StyleAt(backPos),
216 sty == SCE_PL_DEFAULT || sty == SCE_PL_COMMENTLINE))
217 backPos--;
218 if (sty == SCE_PL_OPERATOR)
219 backflag = BACK_OPERATOR;
220 else if (sty == SCE_PL_WORD)
221 backflag = BACK_KEYWORD;
222 }
223
224 styler.StartAt(startPos);
225 char chPrev = styler.SafeGetCharAt(startPos - 1);
226 if (startPos == 0)
227 chPrev = '\n';
228 char chNext = styler[startPos];
229 styler.StartSegment(startPos);
230
231 for (unsigned int i = startPos; i < lengthDoc; i++) {
232 char ch = chNext;
233 // if the current character is not consumed due to the completion of an
234 // earlier style, lexing can be restarted via a simple goto
235 restartLexer:
236 chNext = styler.SafeGetCharAt(i + 1);
237 char chNext2 = styler.SafeGetCharAt(i + 2);
238
239 if (styler.IsLeadByte(ch)) {
240 chNext = styler.SafeGetCharAt(i + 2);
241 chPrev = ' ';
242 i += 1;
243 continue;
244 }
245 if ((chPrev == '\r' && ch == '\n')) { // skip on DOS/Windows
246 styler.ColourTo(i, state);
247 chPrev = ch;
248 continue;
249 }
250
251 if (HereDoc.State == 1 && isEOLChar(ch)) {
252 // Begin of here-doc (the line after the here-doc delimiter):
253 // Lexically, the here-doc starts from the next line after the >>, but the
254 // first line of here-doc seem to follow the style of the last EOL sequence
255 HereDoc.State = 2;
256 if (HereDoc.Quoted) {
257 if (state == SCE_PL_HERE_DELIM) {
258 // Missing quote at end of string! We are stricter than perl.
259 // Colour here-doc anyway while marking this bit as an error.
260 state = SCE_PL_ERROR;
261 }
262 styler.ColourTo(i - 1, state);
263 switch (HereDoc.Quote) {
264 case '\'':
265 state = SCE_PL_HERE_Q ;
266 break;
267 case '"':
268 state = SCE_PL_HERE_QQ;
269 break;
270 case '`':
271 state = SCE_PL_HERE_QX;
272 break;
273 }
274 } else {
275 styler.ColourTo(i - 1, state);
276 switch (HereDoc.Quote) {
277 case '\\':
278 state = SCE_PL_HERE_Q ;
279 break;
280 default :
281 state = SCE_PL_HERE_QQ;
282 }
283 }
284 }
285
286 if (state == SCE_PL_DEFAULT) {
287 if (isdigit(ch) || (isdigit(chNext) &&
288 (ch == '.' || ch == 'v'))) {
289 state = SCE_PL_NUMBER;
290 backflag = BACK_NONE;
291 numState = PERLNUM_DECIMAL;
292 dotCount = 0;
293 if (ch == '0') { // hex,bin,octal
294 if (chNext == 'x') {
295 numState = PERLNUM_HEX;
296 } else if (chNext == 'b') {
297 numState = PERLNUM_BINARY;
298 } else if (isdigit(chNext)) {
299 numState = PERLNUM_OCTAL;
300 }
301 if (numState != PERLNUM_DECIMAL) {
302 i++;
303 ch = chNext;
304 chNext = chNext2;
305 }
306 } else if (ch == 'v') { // vector
307 numState = PERLNUM_V_VECTOR;
308 }
309 } else if (iswordstart(ch)) {
310 // if immediately prefixed by '::', always a bareword
311 state = SCE_PL_WORD;
312 if (chPrev == ':' && styler.SafeGetCharAt(i - 2) == ':') {
313 state = SCE_PL_IDENTIFIER;
314 }
315 unsigned int kw = i + 1;
316 // first check for possible quote-like delimiter
317 if (ch == 's' && !isNonQuote(chNext)) {
318 state = SCE_PL_REGSUBST;
319 Quote.New(2);
320 } else if (ch == 'm' && !isNonQuote(chNext)) {
321 state = SCE_PL_REGEX;
322 Quote.New(1);
323 } else if (ch == 'q' && !isNonQuote(chNext)) {
324 state = SCE_PL_STRING_Q;
325 Quote.New(1);
326 } else if (ch == 'y' && !isNonQuote(chNext)) {
327 state = SCE_PL_REGSUBST;
328 Quote.New(2);
329 } else if (ch == 't' && chNext == 'r' && !isNonQuote(chNext2)) {
330 state = SCE_PL_REGSUBST;
331 Quote.New(2);
332 kw++;
333 } else if (ch == 'q' && (chNext == 'q' || chNext == 'r' || chNext == 'w' || chNext == 'x') && !isNonQuote(chNext2)) {
334 if (chNext == 'q') state = SCE_PL_STRING_QQ;
335 else if (chNext == 'x') state = SCE_PL_STRING_QX;
336 else if (chNext == 'r') state = SCE_PL_STRING_QR;
337 else if (chNext == 'w') state = SCE_PL_STRING_QW;
338 Quote.New(1);
339 kw++;
340 } else if (ch == 'x' && (chNext == '=' || // repetition
341 (chNext != '_' && !isalnum(chNext)) ||
342 (isdigit(chPrev) && isdigit(chNext)))) {
343 state = SCE_PL_OPERATOR;
344 }
345 // if potentially a keyword, scan forward and grab word, then check
346 // if it's really one; if yes, disambiguation test is performed
347 // otherwise it is always a bareword and we skip a lot of scanning
348 // note: keywords assumed to be limited to [_a-zA-Z] only
349 if (state == SCE_PL_WORD) {
350 while (iswordstart(styler.SafeGetCharAt(kw))) kw++;
351 if (!isPerlKeyword(styler.GetStartSegment(), kw, keywords, styler)) {
352 state = SCE_PL_IDENTIFIER;
353 }
354 }
355 // if already SCE_PL_IDENTIFIER, then no ambiguity, skip this
356 // for quote-like delimiters/keywords, attempt to disambiguate
357 // to select for bareword, change state -> SCE_PL_IDENTIFIER
358 if (state != SCE_PL_IDENTIFIER && i > 0) {
359 unsigned int j = i;
360 bool moreback = false; // true if passed newline/comments
361 bool brace = false; // true if opening brace found
362 char ch2;
363 // first look backwards past whitespace/comments for EOLs
364 // if BACK_NONE, neither operator nor keyword, so skip test
365 if (backflag != BACK_NONE) {
366 while (--j > backPos) {
367 if (isEOLChar(styler.SafeGetCharAt(j)))
368 moreback = true;
369 }
370 ch2 = styler.SafeGetCharAt(j);
371 if (ch2 == '{' && !moreback) {
372 // {bareword: possible variable spec
373 brace = true;
374 } else if ((ch2 == '&')
375 // &bareword: subroutine call
376 || (ch2 == '>' && styler.SafeGetCharAt(j - 1) == '-')
377 // ->bareword: part of variable spec
378 || (ch2 == 'b' && styler.Match(j - 2, "su"))) {
379 // sub bareword: subroutine declaration
380 // (implied BACK_KEYWORD, no keywords end in 'sub'!)
381 state = SCE_PL_IDENTIFIER;
382 }
383 // if status still ambiguous, look forward after word past
384 // tabs/spaces only; if ch2 isn't one of '[{(,' it can never
385 // match anything, so skip the whole thing
386 j = kw;
387 if (state != SCE_PL_IDENTIFIER
388 && (ch2 == '{' || ch2 == '(' || ch2 == '['|| ch2 == ',')
389 && kw < lengthDoc) {
390 while (ch2 = styler.SafeGetCharAt(j),
391 (ch2 == ' ' || ch2 == '\t') && j < lengthDoc) {
392 j++;
393 }
394 if ((ch2 == '}' && brace)
395 // {bareword}: variable spec
396 || (ch2 == '=' && styler.SafeGetCharAt(j + 1) == '>')) {
397 // [{(, bareword=>: hash literal
398 state = SCE_PL_IDENTIFIER;
399 }
400 }
401 }
402 }
403 backflag = BACK_NONE;
404 // an identifier or bareword
405 if (state == SCE_PL_IDENTIFIER) {
406 if ((!iswordchar(chNext) && chNext != '\'')
407 || (chNext == '.' && chNext2 == '.')) {
408 // We need that if length of word == 1!
409 // This test is copied from the SCE_PL_WORD handler.
410 styler.ColourTo(i, SCE_PL_IDENTIFIER);
411 state = SCE_PL_DEFAULT;
412 }
413 // a keyword
414 } else if (state == SCE_PL_WORD) {
415 i = kw - 1;
416 if (ch == '_' && chNext == '_' &&
417 (isMatch(styler, lengthDoc, styler.GetStartSegment(), "__DATA__")
418 || isMatch(styler, lengthDoc, styler.GetStartSegment(), "__END__"))) {
419 styler.ColourTo(i, SCE_PL_DATASECTION);
420 state = SCE_PL_DATASECTION;
421 } else {
422 styler.ColourTo(i, SCE_PL_WORD);
423 state = SCE_PL_DEFAULT;
424 backflag = BACK_KEYWORD;
425 backPos = i;
426 }
427 ch = styler.SafeGetCharAt(i);
428 chNext = styler.SafeGetCharAt(i + 1);
429 // a repetition operator 'x'
430 } else if (state == SCE_PL_OPERATOR) {
431 styler.ColourTo(i, SCE_PL_OPERATOR);
432 state = SCE_PL_DEFAULT;
433 // quote-like delimiter, skip one char if double-char delimiter
434 } else {
435 i = kw - 1;
436 chNext = styler.SafeGetCharAt(i + 1);
437 }
438 } else if (ch == '#') {
439 state = SCE_PL_COMMENTLINE;
440 } else if (ch == '\"') {
441 state = SCE_PL_STRING;
442 Quote.New(1);
443 Quote.Open(ch);
444 backflag = BACK_NONE;
445 } else if (ch == '\'') {
446 if (chPrev == '&') {
447 // Archaic call
448 styler.ColourTo(i, state);
449 } else {
450 state = SCE_PL_CHARACTER;
451 Quote.New(1);
452 Quote.Open(ch);
453 }
454 backflag = BACK_NONE;
455 } else if (ch == '`') {
456 state = SCE_PL_BACKTICKS;
457 Quote.New(1);
458 Quote.Open(ch);
459 backflag = BACK_NONE;
460 } else if (ch == '$') {
461 if ((chNext == '{') || isspacechar(chNext)) {
462 styler.ColourTo(i, SCE_PL_SCALAR);
463 } else {
464 state = SCE_PL_SCALAR;
465 if (chNext == '`' && chNext2 == '`') {
466 i += 2;
467 ch = styler.SafeGetCharAt(i);
468 chNext = styler.SafeGetCharAt(i + 1);
469 } else {
470 i++;
471 ch = chNext;
472 chNext = chNext2;
473 }
474 }
475 backflag = BACK_NONE;
476 } else if (ch == '@') {
477 if (isalpha(chNext) || chNext == '#' || chNext == '$'
478 || chNext == '_' || chNext == '+' || chNext == '-') {
479 state = SCE_PL_ARRAY;
480 } else if (chNext != '{' && chNext != '[') {
481 styler.ColourTo(i, SCE_PL_ARRAY);
482 } else {
483 styler.ColourTo(i, SCE_PL_ARRAY);
484 }
485 backflag = BACK_NONE;
486 } else if (ch == '%') {
487 if (isalpha(chNext) || chNext == '#' || chNext == '$'
488 || chNext == '_' || chNext == '!' || chNext == '^') {
489 state = SCE_PL_HASH;
490 i++;
491 ch = chNext;
492 chNext = chNext2;
493 } else if (chNext == '{') {
494 styler.ColourTo(i, SCE_PL_HASH);
495 } else {
496 styler.ColourTo(i, SCE_PL_OPERATOR);
497 }
498 backflag = BACK_NONE;
499 } else if (ch == '*') {
500 char strch[2];
501 strch[0] = chNext;
502 strch[1] = '\0';
503 if (isalpha(chNext) || chNext == '_' ||
504 NULL != strstr("^/|,\\\";#%^:?<>)[]", strch)) {
505 state = SCE_PL_SYMBOLTABLE;
506 i++;
507 ch = chNext;
508 chNext = chNext2;
509 } else if (chNext == '{') {
510 styler.ColourTo(i, SCE_PL_SYMBOLTABLE);
511 } else {
512 if (chNext == '*') { // exponentiation
513 i++;
514 ch = chNext;
515 chNext = chNext2;
516 }
517 styler.ColourTo(i, SCE_PL_OPERATOR);
518 }
519 backflag = BACK_NONE;
520 } else if (ch == '/' || (ch == '<' && chNext == '<')) {
521 // Explicit backward peeking to set a consistent preferRE for
522 // any slash found, so no longer need to track preferRE state.
523 // Find first previous significant lexed element and interpret.
524 // Test for HERE doc start '<<' shares this code, helps to
525 // determine if it should be an operator.
526 bool preferRE = false;
527 bool isHereDoc = (ch == '<');
528 bool hereDocSpace = false; // these are for corner case:
529 bool hereDocScalar = false; // SCALAR [whitespace] '<<'
530 unsigned int bk = (i > 0)? i - 1: 0;
531 char bkch;
532 styler.Flush();
533 if (styler.StyleAt(bk) == SCE_PL_DEFAULT)
534 hereDocSpace = true;
535 while ((bk > 0) && (styler.StyleAt(bk) == SCE_PL_DEFAULT ||
536 styler.StyleAt(bk) == SCE_PL_COMMENTLINE)) {
537 bk--;
538 }
539 if (bk == 0) {
540 // position 0 won't really be checked; rarely happens
541 // hard to fix due to an unsigned index i
542 preferRE = true;
543 } else {
544 int bkstyle = styler.StyleAt(bk);
545 bkch = styler.SafeGetCharAt(bk);
546 switch(bkstyle) {
547 case SCE_PL_OPERATOR:
548 preferRE = true;
549 if (bkch == ')' || bkch == ']') {
550 preferRE = false;
551 } else if (bkch == '}') {
552 // backtrack further, count balanced brace pairs
553 // if a brace pair found, see if it's a variable
554 int braceCount = 1;
555 while (--bk > 0) {
556 bkstyle = styler.StyleAt(bk);
557 if (bkstyle == SCE_PL_OPERATOR) {
558 bkch = styler.SafeGetCharAt(bk);
559 if (bkch == ';') { // early out
560 break;
561 } else if (bkch == '}') {
562 braceCount++;
563 } else if (bkch == '{') {
564 if (--braceCount == 0)
565 break;
566 }
567 }
568 }
569 if (bk == 0) {
570 // at beginning, true
571 } else if (braceCount == 0) {
572 // balanced { found, bk>0, skip more whitespace
573 if (styler.StyleAt(--bk) == SCE_PL_DEFAULT) {
574 while (bk > 0) {
575 bkstyle = styler.StyleAt(--bk);
576 if (bkstyle != SCE_PL_DEFAULT)
577 break;
578 }
579 }
580 bkstyle = styler.StyleAt(bk);
581 if (bkstyle == SCE_PL_SCALAR
582 || bkstyle == SCE_PL_ARRAY
583 || bkstyle == SCE_PL_HASH
584 || bkstyle == SCE_PL_SYMBOLTABLE
585 || bkstyle == SCE_PL_OPERATOR) {
586 preferRE = false;
587 }
588 }
589 }
590 break;
591 case SCE_PL_IDENTIFIER:
592 preferRE = true;
593 if (bkch == '>') { // inputsymbol
594 preferRE = false;
595 break;
596 }
597 // backtrack to find "->" or "::" before identifier
598 while (bk > 0 && styler.StyleAt(bk) == SCE_PL_IDENTIFIER) {
599 bk--;
600 }
601 while (bk > 0) {
602 bkstyle = styler.StyleAt(bk);
603 if (bkstyle == SCE_PL_DEFAULT ||
604 bkstyle == SCE_PL_COMMENTLINE) {
605 } else if (bkstyle == SCE_PL_OPERATOR) {
606 // gcc 3.2.3 bloats if more compact form used
607 bkch = styler.SafeGetCharAt(bk);
608 if (bkch == '>') { // "->"
609 if (styler.SafeGetCharAt(bk - 1) == '-') {
610 preferRE = false;
611 break;
612 }
613 } else if (bkch == ':') { // "::"
614 if (styler.SafeGetCharAt(bk - 1) == ':') {
615 preferRE = false;
616 break;
617 }
618 }
619 } else {// bare identifier, usually a function call but Perl
620 // optimizes them as pseudo-constants, then the next
621 // '/' will be a divide; favour divide over regex
622 // if there is a whitespace after the '/'
623 if (isspacechar(chNext)) {
624 preferRE = false;
625 }
626 break;
627 }
628 bk--;
629 }
630 break;
631 case SCE_PL_SCALAR: // for $var<< case
632 hereDocScalar = true;
633 break;
634 // other styles uses the default, preferRE=false
635 case SCE_PL_WORD:
636 case SCE_PL_POD:
637 case SCE_PL_POD_VERB:
638 case SCE_PL_HERE_Q:
639 case SCE_PL_HERE_QQ:
640 case SCE_PL_HERE_QX:
641 preferRE = true;
642 break;
643 }
644 }
645 if (isHereDoc) { // handle HERE doc
646 // if SCALAR whitespace '<<', *always* a HERE doc
647 if (preferRE || (hereDocSpace && hereDocScalar)) {
648 state = SCE_PL_HERE_DELIM;
649 HereDoc.State = 0;
650 } else { // << operator
651 i++;
652 ch = chNext;
653 chNext = chNext2;
654 styler.ColourTo(i, SCE_PL_OPERATOR);
655 }
656 } else { // handle regexp
657 if (preferRE) {
658 state = SCE_PL_REGEX;
659 Quote.New(1);
660 Quote.Open(ch);
661 } else { // / operator
662 styler.ColourTo(i, SCE_PL_OPERATOR);
663 }
664 }
665 backflag = BACK_NONE;
666 } else if (ch == '<') {
667 // looks forward for matching > on same line
668 unsigned int fw = i + 1;
669 while (fw < lengthDoc) {
670 char fwch = styler.SafeGetCharAt(fw);
671 if (fwch == ' ') {
672 if (styler.SafeGetCharAt(fw-1) != '\\' ||
673 styler.SafeGetCharAt(fw-2) != '\\')
674 break;
675 } else if (isEOLChar(fwch) || isspacechar(fwch)) {
676 break;
677 } else if (fwch == '>') {
678 if ((fw - i) == 2 && // '<=>' case
679 styler.SafeGetCharAt(fw-1) == '=') {
680 styler.ColourTo(fw, SCE_PL_OPERATOR);
681 } else {
682 styler.ColourTo(fw, SCE_PL_IDENTIFIER);
683 }
684 i = fw;
685 ch = fwch;
686 chNext = styler.SafeGetCharAt(i+1);
687 }
688 fw++;
689 }
690 styler.ColourTo(i, SCE_PL_OPERATOR);
691 backflag = BACK_NONE;
692 } else if (ch == '=' // POD
693 && isalpha(chNext)
694 && (isEOLChar(chPrev))) {
695 state = SCE_PL_POD;
696 backflag = BACK_NONE;
697 //sookedpos = 0;
698 //sooked[sookedpos] = '\0';
699 } else if (ch == '-' // file test operators
700 && isSingleCharOp(chNext)
701 && !isalnum((chNext2 = styler.SafeGetCharAt(i+2)))) {
702 styler.ColourTo(i + 1, SCE_PL_WORD);
703 state = SCE_PL_DEFAULT;
704 i++;
705 ch = chNext;
706 chNext = chNext2;
707 backflag = BACK_NONE;
708 } else if (isPerlOperator(ch)) {
709 if (ch == '.' && chNext == '.') { // .. and ...
710 i++;
711 if (chNext2 == '.') { i++; }
712 state = SCE_PL_DEFAULT;
713 ch = styler.SafeGetCharAt(i);
714 chNext = styler.SafeGetCharAt(i + 1);
715 }
716 styler.ColourTo(i, SCE_PL_OPERATOR);
717 backflag = BACK_OPERATOR;
718 backPos = i;
719 } else {
720 // keep colouring defaults to make restart easier
721 styler.ColourTo(i, SCE_PL_DEFAULT);
722 }
723 } else if (state == SCE_PL_NUMBER) {
724 if (ch == '.') {
725 if (chNext == '.') {
726 // double dot is always an operator
727 goto numAtEnd;
728 } else if (numState <= PERLNUM_FLOAT) {
729 // non-decimal number or float exponent, consume next dot
730 styler.ColourTo(i - 1, SCE_PL_NUMBER);
731 styler.ColourTo(i, SCE_PL_OPERATOR);
732 state = SCE_PL_DEFAULT;
733 } else { // decimal or vectors allows dots
734 dotCount++;
735 if (numState == PERLNUM_DECIMAL) {
736 if (dotCount > 1) {
737 if (isdigit(chNext)) { // really a vector
738 numState = PERLNUM_VECTOR;
739 } else // number then dot
740 goto numAtEnd;
741 }
742 } else { // vectors
743 if (!isdigit(chNext)) // vector then dot
744 goto numAtEnd;
745 }
746 }
747 } else if (ch == '_' && numState == PERLNUM_DECIMAL) {
748 if (!isdigit(chNext)) {
749 goto numAtEnd;
750 }
751 } else if (isalnum(ch)) {
752 if (numState == PERLNUM_VECTOR || numState == PERLNUM_V_VECTOR) {
753 if (isalpha(ch)) {
754 if (dotCount == 0) { // change to word
755 state = SCE_PL_IDENTIFIER;
756 } else { // vector then word
757 goto numAtEnd;
758 }
759 }
760 } else if (numState == PERLNUM_DECIMAL) {
761 if (ch == 'E' || ch == 'e') { // exponent
762 numState = PERLNUM_FLOAT;
763 if (chNext == '+' || chNext == '-') {
764 i++;
765 ch = chNext;
766 chNext = chNext2;
767 }
768 } else if (!isdigit(ch)) { // number then word
769 goto numAtEnd;
770 }
771 } else if (numState == PERLNUM_FLOAT) {
772 if (!isdigit(ch)) { // float then word
773 goto numAtEnd;
774 }
775 } else if (numState == PERLNUM_OCTAL) {
776 if (!isdigit(ch))
777 goto numAtEnd;
778 else if (ch > '7')
779 numState = PERLNUM_BAD;
780 } else if (numState == PERLNUM_BINARY) {
781 if (!isdigit(ch))
782 goto numAtEnd;
783 else if (ch > '1')
784 numState = PERLNUM_BAD;
785 } else if (numState == PERLNUM_HEX) {
786 int ch2 = toupper(ch);
787 if (!isdigit(ch) && !(ch2 >= 'A' && ch2 <= 'F'))
788 goto numAtEnd;
789 } else {//(numState == PERLNUM_BAD) {
790 if (!isdigit(ch))
791 goto numAtEnd;
792 }
793 } else {
794 // complete current number or vector
795 numAtEnd:
796 styler.ColourTo(i - 1, actualNumStyle(numState));
797 state = SCE_PL_DEFAULT;
798 goto restartLexer;
799 }
800 } else if (state == SCE_PL_IDENTIFIER) {
801 if (!iswordstart(chNext) && chNext != '\'') {
802 styler.ColourTo(i, SCE_PL_IDENTIFIER);
803 state = SCE_PL_DEFAULT;
804 ch = ' ';
805 }
806 } else {
807 if (state == SCE_PL_COMMENTLINE) {
808 if (isEOLChar(ch)) {
809 styler.ColourTo(i - 1, state);
810 state = SCE_PL_DEFAULT;
811 goto restartLexer;
812 } else if (isEOLChar(chNext)) {
813 styler.ColourTo(i, state);
814 state = SCE_PL_DEFAULT;
815 }
816 } else if (state == SCE_PL_HERE_DELIM) {
817 //
818 // From perldata.pod:
819 // ------------------
820 // A line-oriented form of quoting is based on the shell ``here-doc''
821 // syntax.
822 // Following a << you specify a string to terminate the quoted material,
823 // and all lines following the current line down to the terminating
824 // string are the value of the item.
825 // The terminating string may be either an identifier (a word),
826 // or some quoted text.
827 // If quoted, the type of quotes you use determines the treatment of
828 // the text, just as in regular quoting.
829 // An unquoted identifier works like double quotes.
830 // There must be no space between the << and the identifier.
831 // (If you put a space it will be treated as a null identifier,
832 // which is valid, and matches the first empty line.)
833 // (This is deprecated, -w warns of this syntax)
834 // The terminating string must appear by itself (unquoted and with no
835 // surrounding whitespace) on the terminating line.
836 //
837 // From Bash info:
838 // ---------------
839 // Specifier format is: <<[-]WORD
840 // Optional '-' is for removal of leading tabs from here-doc.
841 // Whitespace acceptable after <<[-] operator.
842 //
843 if (HereDoc.State == 0) { // '<<' encountered
844 bool gotspace = false;
845 unsigned int oldi = i;
846 if (chNext == ' ' || chNext == '\t') {
847 // skip whitespace; legal for quoted delimiters
848 gotspace = true;
849 do {
850 i++;
851 chNext = styler.SafeGetCharAt(i + 1);
852 } while ((i + 1 < lengthDoc) && (chNext == ' ' || chNext == '\t'));
853 chNext2 = styler.SafeGetCharAt(i + 2);
854 }
855 HereDoc.State = 1;
856 HereDoc.Quote = chNext;
857 HereDoc.Quoted = false;
858 HereDoc.DelimiterLength = 0;
859 HereDoc.Delimiter[HereDoc.DelimiterLength] = '\0';
860 if (chNext == '\'' || chNext == '"' || chNext == '`') {
861 // a quoted here-doc delimiter
862 i++;
863 ch = chNext;
864 chNext = chNext2;
865 HereDoc.Quoted = true;
866 } else if (isspacechar(chNext) || isdigit(chNext) || chNext == '\\'
867 || chNext == '=' || chNext == '$' || chNext == '@'
868 || ((isalpha(chNext) || chNext == '_') && gotspace)) {
869 // left shift << or <<= operator cases
870 // restore position if operator
871 i = oldi;
872 styler.ColourTo(i, SCE_PL_OPERATOR);
873 state = SCE_PL_DEFAULT;
874 HereDoc.State = 0;
875 goto restartLexer;
876 } else {
877 // an unquoted here-doc delimiter, no special handling
878 // (cannot be prefixed by spaces/tabs), or
879 // symbols terminates; deprecated zero-length delimiter
880 }
881
882 } else if (HereDoc.State == 1) { // collect the delimiter
883 backflag = BACK_NONE;
884 if (HereDoc.Quoted) { // a quoted here-doc delimiter
885 if (ch == HereDoc.Quote) { // closing quote => end of delimiter
886 styler.ColourTo(i, state);
887 state = SCE_PL_DEFAULT;
888 } else {
889 if (ch == '\\' && chNext == HereDoc.Quote) { // escaped quote
890 i++;
891 ch = chNext;
892 chNext = chNext2;
893 }
894 HereDoc.Delimiter[HereDoc.DelimiterLength++] = ch;
895 HereDoc.Delimiter[HereDoc.DelimiterLength] = '\0';
896 }
897 } else { // an unquoted here-doc delimiter
898 if (isalnum(ch) || ch == '_') {
899 HereDoc.Delimiter[HereDoc.DelimiterLength++] = ch;
900 HereDoc.Delimiter[HereDoc.DelimiterLength] = '\0';
901 } else {
902 styler.ColourTo(i - 1, state);
903 state = SCE_PL_DEFAULT;
904 goto restartLexer;
905 }
906 }
907 if (HereDoc.DelimiterLength >= HERE_DELIM_MAX - 1) {
908 styler.ColourTo(i - 1, state);
909 state = SCE_PL_ERROR;
910 goto restartLexer;
911 }
912 }
913 } else if (HereDoc.State == 2) {
914 // state == SCE_PL_HERE_Q || state == SCE_PL_HERE_QQ || state == SCE_PL_HERE_QX
915 if (isEOLChar(chPrev) && isMatch(styler, lengthDoc, i, HereDoc.Delimiter)) {
916 i += HereDoc.DelimiterLength;
917 chPrev = styler.SafeGetCharAt(i - 1);
918 ch = styler.SafeGetCharAt(i);
919 if (isEOLChar(ch)) {
920 styler.ColourTo(i - 1, state);
921 state = SCE_PL_DEFAULT;
922 backflag = BACK_NONE;
923 HereDoc.State = 0;
924 goto restartLexer;
925 }
926 chNext = styler.SafeGetCharAt(i + 1);
927 }
928 } else if (state == SCE_PL_POD
929 || state == SCE_PL_POD_VERB) {
930 if (isEOLChar(chPrev)) {
931 if (ch == ' ' || ch == '\t') {
932 styler.ColourTo(i - 1, state);
933 state = SCE_PL_POD_VERB;
934 } else {
935 styler.ColourTo(i - 1, state);
936 state = SCE_PL_POD;
937 if (ch == '=') {
938 if (isMatch(styler, lengthDoc, i, "=cut")) {
939 styler.ColourTo(i - 1 + 4, state);
940 i += 4;
941 state = SCE_PL_DEFAULT;
942 ch = styler.SafeGetCharAt(i);
943 //chNext = styler.SafeGetCharAt(i + 1);
944 goto restartLexer;
945 }
946 }
947 }
948 }
949 } else if (state == SCE_PL_SCALAR // variable names
950 || state == SCE_PL_ARRAY
951 || state == SCE_PL_HASH
952 || state == SCE_PL_SYMBOLTABLE) {
953 if (ch == ':' && chNext == ':') { // skip ::
954 i++;
955 ch = chNext;
956 chNext = chNext2;
957 }
958 else if (isEndVar(ch)) {
959 if (i == (styler.GetStartSegment() + 1)) {
960 // Special variable: $(, $_ etc.
961 styler.ColourTo(i, state);
962 state = SCE_PL_DEFAULT;
963 } else {
964 styler.ColourTo(i - 1, state);
965 state = SCE_PL_DEFAULT;
966 goto restartLexer;
967 }
968 }
969 } else if (state == SCE_PL_REGEX
970 || state == SCE_PL_STRING_QR
971 ) {
972 if (!Quote.Up && !isspacechar(ch)) {
973 Quote.Open(ch);
974 } else if (ch == '\\' && Quote.Up != '\\') {
975 // SG: Is it save to skip *every* escaped char?
976 i++;
977 ch = chNext;
978 chNext = styler.SafeGetCharAt(i + 1);
979 } else {
980 if (ch == Quote.Down /*&& chPrev != '\\'*/) {
981 Quote.Count--;
982 if (Quote.Count == 0) {
983 Quote.Rep--;
984 if (Quote.Up == Quote.Down) {
985 Quote.Count++;
986 }
987 }
988 if (!isalpha(chNext)) {
989 if (Quote.Rep <= 0) {
990 styler.ColourTo(i, state);
991 state = SCE_PL_DEFAULT;
992 ch = ' ';
993 }
994 }
995 } else if (ch == Quote.Up /*&& chPrev != '\\'*/) {
996 Quote.Count++;
997 } else if (!isalpha(chNext)) {
998 if (Quote.Rep <= 0) {
999 styler.ColourTo(i, state);
1000 state = SCE_PL_DEFAULT;
1001 ch = ' ';
1002 }
1003 }
1004 }
1005 } else if (state == SCE_PL_REGSUBST) {
1006 if (!Quote.Up && !isspacechar(ch)) {
1007 Quote.Open(ch);
1008 } else if (ch == '\\' && Quote.Up != '\\') {
1009 // SG: Is it save to skip *every* escaped char?
1010 i++;
1011 ch = chNext;
1012 chNext = styler.SafeGetCharAt(i + 1);
1013 } else {
1014 if (Quote.Count == 0 && Quote.Rep == 1) {
1015 /* We matched something like s(...) or tr{...}
1016 * and are looking for the next matcher characters,
1017 * which could be either bracketed ({...}) or non-bracketed
1018 * (/.../).
1019 *
1020 * Number-signs are problematic. If they occur after
1021 * the close of the first part, treat them like
1022 * a Quote.Up char, even if they actually start comments.
1023 *
1024 * If we find an alnum, we end the regsubst, and punt.
1025 *
1026 * Eric Promislow ericp@activestate.com Aug 9,2000
1027 */
1028 if (isspacechar(ch)) {
1029 // Keep going
1030 }
1031 else if (isalnum(ch)) {
1032 styler.ColourTo(i, state);
1033 state = SCE_PL_DEFAULT;
1034 ch = ' ';
1035 } else {
1036 Quote.Open(ch);
1037 }
1038 } else if (ch == Quote.Down /*&& chPrev != '\\'*/) {
1039 Quote.Count--;
1040 if (Quote.Count == 0) {
1041 Quote.Rep--;
1042 }
1043 if (!isalpha(chNext)) {
1044 if (Quote.Rep <= 0) {
1045 styler.ColourTo(i, state);
1046 state = SCE_PL_DEFAULT;
1047 ch = ' ';
1048 }
1049 }
1050 if (Quote.Up == Quote.Down) {
1051 Quote.Count++;
1052 }
1053 } else if (ch == Quote.Up /*&& chPrev != '\\'*/) {
1054 Quote.Count++;
1055 } else if (!isalpha(chNext)) {
1056 if (Quote.Rep <= 0) {
1057 styler.ColourTo(i, state);
1058 state = SCE_PL_DEFAULT;
1059 ch = ' ';
1060 }
1061 }
1062 }
1063 } else if (state == SCE_PL_STRING_Q
1064 || state == SCE_PL_STRING_QQ
1065 || state == SCE_PL_STRING_QX
1066 || state == SCE_PL_STRING_QW
1067 || state == SCE_PL_STRING
1068 || state == SCE_PL_CHARACTER
1069 || state == SCE_PL_BACKTICKS
1070 ) {
1071 if (!Quote.Down && !isspacechar(ch)) {
1072 Quote.Open(ch);
1073 } else if (ch == '\\' && Quote.Up != '\\') {
1074 i++;
1075 ch = chNext;
1076 chNext = styler.SafeGetCharAt(i + 1);
1077 } else if (ch == Quote.Down) {
1078 Quote.Count--;
1079 if (Quote.Count == 0) {
1080 Quote.Rep--;
1081 if (Quote.Rep <= 0) {
1082 styler.ColourTo(i, state);
1083 state = SCE_PL_DEFAULT;
1084 ch = ' ';
1085 }
1086 if (Quote.Up == Quote.Down) {
1087 Quote.Count++;
1088 }
1089 }
1090 } else if (ch == Quote.Up) {
1091 Quote.Count++;
1092 }
1093 }
1094 }
1095 if (state == SCE_PL_ERROR) {
1096 break;
1097 }
1098 chPrev = ch;
1099 }
1100 styler.ColourTo(lengthDoc - 1, state);
1101 }
1102
1103 static bool IsCommentLine(int line, Accessor &styler) {
1104 int pos = styler.LineStart(line);
1105 int eol_pos = styler.LineStart(line + 1) - 1;
1106 for (int i = pos; i < eol_pos; i++) {
1107 char ch = styler[i];
1108 int style = styler.StyleAt(i);
1109 if (ch == '#' && style == SCE_PL_COMMENTLINE)
1110 return true;
1111 else if (ch != ' ' && ch != '\t')
1112 return false;
1113 }
1114 return false;
1115 }
1116
1117 static void FoldPerlDoc(unsigned int startPos, int length, int, WordList *[],
1118 Accessor &styler) {
1119 bool foldComment = styler.GetPropertyInt("fold.comment") != 0;
1120 bool foldCompact = styler.GetPropertyInt("fold.compact", 1) != 0;
1121 // Custom folding of POD and packages
1122 bool foldPOD = styler.GetPropertyInt("fold.perl.pod", 1) != 0;
1123 bool foldPackage = styler.GetPropertyInt("fold.perl.package", 1) != 0;
1124 unsigned int endPos = startPos + length;
1125 int visibleChars = 0;
1126 int lineCurrent = styler.GetLine(startPos);
1127 int levelPrev = SC_FOLDLEVELBASE;
1128 if (lineCurrent > 0)
1129 levelPrev = styler.LevelAt(lineCurrent - 1) >> 16;
1130 int levelCurrent = levelPrev;
1131 char chNext = styler[startPos];
1132 char chPrev = styler.SafeGetCharAt(startPos - 1);
1133 int styleNext = styler.StyleAt(startPos);
1134 // Used at end of line to determine if the line was a package definition
1135 bool isPackageLine = false;
1136 bool isPodHeading = false;
1137 for (unsigned int i = startPos; i < endPos; i++) {
1138 char ch = chNext;
1139 chNext = styler.SafeGetCharAt(i + 1);
1140 int style = styleNext;
1141 styleNext = styler.StyleAt(i + 1);
1142 bool atEOL = (ch == '\r' && chNext != '\n') || (ch == '\n');
1143 bool atLineStart = isEOLChar(chPrev) || i == 0;
1144 // Comment folding
1145 if (foldComment && atEOL && IsCommentLine(lineCurrent, styler))
1146 {
1147 if (!IsCommentLine(lineCurrent - 1, styler)
1148 && IsCommentLine(lineCurrent + 1, styler))
1149 levelCurrent++;
1150 else if (IsCommentLine(lineCurrent - 1, styler)
1151 && !IsCommentLine(lineCurrent+1, styler))
1152 levelCurrent--;
1153 }
1154 if (style == SCE_C_OPERATOR) {
1155 if (ch == '{') {
1156 levelCurrent++;
1157 } else if (ch == '}') {
1158 levelCurrent--;
1159 }
1160 }
1161 // Custom POD folding
1162 if (foldPOD && atLineStart) {
1163 int stylePrevCh = (i) ? styler.StyleAt(i - 1):SCE_PL_DEFAULT;
1164 if (style == SCE_PL_POD) {
1165 if (stylePrevCh != SCE_PL_POD && stylePrevCh != SCE_PL_POD_VERB)
1166 levelCurrent++;
1167 else if (styler.Match(i, "=cut"))
1168 levelCurrent--;
1169 else if (styler.Match(i, "=head"))
1170 isPodHeading = true;
1171 } else if (style == SCE_PL_DATASECTION) {
1172 if (ch == '=' && isalpha(chNext) && levelCurrent == SC_FOLDLEVELBASE)
1173 levelCurrent++;
1174 else if (styler.Match(i, "=cut") && levelCurrent > SC_FOLDLEVELBASE)
1175 levelCurrent--;
1176 else if (styler.Match(i, "=head"))
1177 isPodHeading = true;
1178 // if package used or unclosed brace, level > SC_FOLDLEVELBASE!
1179 // reset needed as level test is vs. SC_FOLDLEVELBASE
1180 else if (styler.Match(i, "__END__"))
1181 levelCurrent = SC_FOLDLEVELBASE;
1182 }
1183 }
1184 // Custom package folding
1185 if (foldPackage && atLineStart) {
1186 if (style == SCE_PL_WORD && styler.Match(i, "package")) {
1187 isPackageLine = true;
1188 }
1189 }
1190
1191 if (atEOL) {
1192 int lev = levelPrev;
1193 if (isPodHeading) {
1194 lev = levelPrev - 1;
1195 lev |= SC_FOLDLEVELHEADERFLAG;
1196 isPodHeading = false;
1197 }
1198 // Check if line was a package declaration
1199 // because packages need "special" treatment
1200 if (isPackageLine) {
1201 lev = SC_FOLDLEVELBASE | SC_FOLDLEVELHEADERFLAG;
1202 levelCurrent = SC_FOLDLEVELBASE + 1;
1203 isPackageLine = false;
1204 }
1205 lev |= levelCurrent << 16;
1206 if (visibleChars == 0 && foldCompact)
1207 lev |= SC_FOLDLEVELWHITEFLAG;
1208 if ((levelCurrent > levelPrev) && (visibleChars > 0))
1209 lev |= SC_FOLDLEVELHEADERFLAG;
1210 if (lev != styler.LevelAt(lineCurrent)) {
1211 styler.SetLevel(lineCurrent, lev);
1212 }
1213 lineCurrent++;
1214 levelPrev = levelCurrent;
1215 visibleChars = 0;
1216 }
1217 if (!isspacechar(ch))
1218 visibleChars++;
1219 chPrev = ch;
1220 }
1221 // Fill in the real level of the next line, keeping the current flags as they will be filled in later
1222 int flagsNext = styler.LevelAt(lineCurrent) & ~SC_FOLDLEVELNUMBERMASK;
1223 styler.SetLevel(lineCurrent, levelPrev | flagsNext);
1224 }
1225
1226 static const char * const perlWordListDesc[] = {
1227 "Keywords",
1228 0
1229 };
1230
1231 LexerModule lmPerl(SCLEX_PERL, ColourisePerlDoc, "perl", FoldPerlDoc, perlWordListDesc);
1232
wxWidgets (Impactor)