?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
sq3: show SQLite error messages on stderr by default
[iv.d.git] / egeditor / highlighters.d
blob305712b9fb9ed91a772b01dea3bf30bd0dead1b0
1 /* Invisible Vector Library
2 * simple FlexBox-based TUI engine
3 *
4 * This program is free software: you can redistribute it and/or modify
5 * it under the terms of the GNU General Public License as published by
6 * the Free Software Foundation, version 3 of the License ONLY.
7 *
8 * This program is distributed in the hope that it will be useful,
9 * but WITHOUT ANY WARRANTY; without even the implied warranty of
10 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
11 * GNU General Public License for more details.
12 *
13 * You should have received a copy of the GNU General Public License
14 * along with this program. If not, see <http://www.gnu.org/licenses/>.
15 */
16 module iv.egeditor.highlighters /*is aliced*/;
17
18 import iv.alice;
19 import iv.strex;
20
21 import iv.egeditor.editor;
22
23
24 // ////////////////////////////////////////////////////////////////////////// //
25 public enum {
26 HiNone = 0,
27 HiText, // dunno what, just a text
28
29 HiCommentOneLine,
30 HiCommentMulti, // kwidx: level; 0: non-nesting
31 HiCommentDirective, // pascal directive
32
33 HiNumber,
34
35 HiChar, // starting, ending, text
36 HiCharSpecial,
37
38 // normal string
39 HiDQString,
40 HiDQStringSpecial,
41 HiSQString,
42 HiSQStringSpecial,
43 // backquoted string
44 HiBQString,
45 // rquoted string
46 HiRQString,
47
48 HiKeyword, // yellow
49 HiKeywordHi, // white
50 HiBuiltin, // red
51 HiType, // olive
52 HiSpecial, // green
53 HiInternal, // red
54 HiPunct, // some punctuation token
55 HiSemi, // semicolon
56 HiUDA, // bluish
57 HiAliced,
58 HiPreprocessor,
59
60 HiRegExp, // js inline regexp
61
62 HiToDoOpen, // [.]
63 HiToDoUrgent, // [!]
64 HiToDoSemi, // [+]
65 HiToDoDone, // [*]
66 HiToDoDont, // [-]
67 HiToDoUnsure, // [?]
68 }
69
70 private enum HiBodySpecialMark = 253; // sorry; end user will never see this
71
72
73 public bool hiIsComment() (in auto ref GapBuffer.HighState hs) nothrow {
74 switch (hs.kwtype) {
75 case HiCommentOneLine:
76 case HiCommentMulti:
77 case HiCommentDirective:
78 return true;
79 default:
80 break;
81 }
82 return false;
83 }
84
85
86 // ////////////////////////////////////////////////////////////////////////// //
87 public class EditorHLExt : EditorHL {
88 private:
89 alias HS = GapBuffer.HighState;
90 alias Opt = EdHiTokens.Opt;
91
92 protected:
93 EdHiTokens tks;
94 int validLines; // how much lines was ever highlighted?
95
96 public:
97 this (EdHiTokens atk) { tks = atk; super(); }
98
99 // return `true` if next line was fucked
100 private final bool redoLine (int ls, int le) {
101 if (gb.hi(ls).kwtype == 0) {
102 auto est = gb.hi(le);
103 if (ls < gb.textsize) rehighlightLine(ls, le);
104 // need to fix next line?
105 if (le+1 < gb.textsize && est != gb.hi(le)) {
106 gb.hi(le+1).kwtype = 0;
107 return true;
108 }
109 }
110 return false;
111 }
112
113 // return true if highlighting for this line was changed
114 override bool fixLine (int line) {
115 if (validLines == 0) {
116 // anyway
117 if (gb.textsize > 0) rehighlightLine(0, lc.lineend(0));
118 validLines = 1;
119 if (line == 0) return true;
120 }
121 bool res = false;
122 if (line >= validLines) {
123 // set sca
124 auto spos = lc.line2pos(validLines);
125 while (line >= validLines) {
126 if (true/*gb.hi(spos).kwtype == 0*/) {
127 if (validLines == line) res = true;
128 auto epos = lc.lineend(validLines);
129 auto est = gb.hi(epos);
130 if (spos < gb.textsize) rehighlightLine(spos, epos);
131 // need to fix next line?
132 if (epos+1 < gb.textsize && est != gb.hi(epos)) gb.hi(epos+1).kwtype = 0;
133 spos = epos+1;
134 } else {
135 spos = lc.line2pos(validLines+1);
136 }
137 ++validLines;
138 }
139 } else {
140 auto ls = lc.line2pos(line);
141 auto stt = gb.hi(ls).kwtype;
142 if (stt == 0) {
143 auto le = lc.lineend(line);
144 if (redoLine(ls, le)) validLines = line+1; // should check next lines
145 res = true;
146 }
147 }
148 return res;
149 }
150
151 // mark line as "need rehighlighting" (and possibly other text too)
152 // wasInsDel: some lines was inserted/deleted down the text
153 override void lineChanged (int line, bool wasInsDel) {
154 if (line >= validLines) return; // nothing to do
155 gb.hi(lc.line2pos(line)).kwtype = 0; // "rehighlight" flag
156 if (wasInsDel) validLines = line; // rehighlight the following text
157 }
158
159 // this is *inclusive* range
160 protected void rehighlightLine (int ls, int le) {
161 auto tks = this.tks;
162 immutable opt = this.tks.options;
163
164 // spos: at char
165 // return: 0: error; 1: normal; >1: escape (length)
166 int skipStrChar(bool allowEol, bool allowEsc) () {
167 import std.ascii : isHexDigit;
168 if (spos >= gb.textsize) return 0;
169 auto ch = gb[spos];
170 if (ch == '\n') { static if (allowEol) return 1; else return 0; }
171 static if (allowEsc) {
172 if (ch == '\\') {
173 ch = gb[spos+1];
174 if (ch == 0) return 1;
175 if (ch == '\n') { static if (allowEol) return 2; else return 1; }
176 int hexd = 0;
177 if (ch == 'x' || ch == 'X') hexd = 2;
178 else if (ch == 'u' || ch == 'U') hexd = 4;
179 if (hexd == 0) return 2; // not a hex escape
180 foreach (immutable n; 0..hexd) {
181 ch = gb[spos+2+n];
182 if (!ch.isHexDigit) return n+2;
183 }
184 return hexd+2;
185 }
186 }
187 return 1;
188 }
189
190 // take ending state for the previous line
191 HS st = (ls > 0 ? gb.hi(ls-1) : HS(HiText));
192
193 char ch;
194 int ofs;
195 int spos = ls;
196 bool seenNonBlank = false; // comments are blanks
197 bool inPreprocessor = false;
198 int basedNumSkip;
199
200 if (st.kwtype == HiPreprocessor) inPreprocessor = true;
201
202 void skipNumMods () {
203 auto ch = gb[spos+ofs];
204 if (ch == 'L') {
205 ++ofs;
206 if (gb[spos+ofs].tolower == 'u') ++ofs;
207 } else if (ch == 'u' || ch == 'U') {
208 ++ofs;
209 if (gb[spos+ofs] == 'L') ++ofs;
210 } else if (ch == 'f') {
211 ++ofs;
212 }
213 }
214
215 mainloop: while (spos <= le) {
216 // in double-quoted string?
217 if (st.kwtype == HiDQString || st.kwtype == HiDQStringSpecial) {
218 seenNonBlank = true;
219 while (spos <= le) {
220 auto len = (opt&Opt.DQStringNoEscape ? skipStrChar!(true, false)() : skipStrChar!(true, true)());
221 if (len == 0) { st = HS(HiText); continue mainloop; }
222 if (len == 1) {
223 // normal
224 gb.hi(spos++) = HS(HiDQString);
225 if (gb[spos-1] == '"') { st = HS(HiText); continue mainloop; }
226 } else {
227 // special
228 foreach (immutable _; 0..len) gb.hi(spos++) = HS(HiDQStringSpecial);
229 }
230 }
231 st = HS(HiDQString);
232 continue mainloop;
233 }
234 // in single-quoted string?
235 if (st.kwtype == HiSQString || st.kwtype == HiSQStringSpecial) {
236 seenNonBlank = true;
237 while (spos <= le) {
238 if ((opt&Opt.NumAsmHex) && gb[spos] == '\n') {
239 gb.hi(spos++) = HS(HiText);
240 st = HS(HiText);
241 continue mainloop;
242 }
243 auto len = (opt&Opt.SQStringNoEscape ? skipStrChar!(true, false)() : skipStrChar!(true, true)());
244 if (len == 0) { st = HS(HiText); continue mainloop; }
245 if (len == 1) {
246 // normal
247 gb.hi(spos++) = HS(HiSQString);
248 if (gb[spos-1] == '\'') { st = HS(HiText); continue mainloop; }
249 } else {
250 // special
251 foreach (immutable _; 0..len) gb.hi(spos++) = HS(HiSQStringSpecial);
252 }
253 }
254 if (opt&Opt.NumAsmHex) st = HS(HiText); else st = HS(HiSQString);
255 continue mainloop;
256 }
257 // in backquoted string?
258 if (st.kwtype == HiBQString) {
259 seenNonBlank = true;
260 while (spos <= le) {
261 auto len = skipStrChar!(true, false)();
262 if (len == 0) { st = HS(HiText); continue mainloop; }
263 assert(len == 1);
264 gb.hi(spos++) = HS(HiBQString);
265 if (gb[spos-1] == '`') { st = HS(HiText); continue mainloop; }
266 }
267 st = HS(HiBQString);
268 continue mainloop;
269 }
270 // in rackquoted string?
271 if (st.kwtype == HiRQString) {
272 seenNonBlank = true;
273 while (spos <= le) {
274 auto len = skipStrChar!(true, false)();
275 if (len == 0) { st = HS(HiText); continue mainloop; }
276 assert(len == 1);
277 gb.hi(spos++) = HS(HiRQString);
278 if (gb[spos-1] == '"') { st = HS(HiText); continue mainloop; }
279 }
280 st = HS(HiRQString);
281 continue mainloop;
282 }
283 // in multiline comment?
284 if ((st.kwtype == HiCommentMulti && (st.kwidx == 0 || (opt&Opt.PascalComments) != 0)) || st.kwtype == HiCommentDirective) {
285 while (spos <= le) {
286 gb.hi(spos++) = st;
287 bool commentEnd = false;
288 if (opt&Opt.PascalComments) {
289 if (st.kwidx == 0) {
290 commentEnd = (gb[spos-1] == '}');
291 } else {
292 commentEnd = (gb[spos-2] == '*' && gb[spos-1] == ')');
293 }
294 } else {
295 commentEnd = (gb[spos-2] == '*' && gb[spos-1] == '/');
296 }
297 if (commentEnd) {
298 st = HS(HiText);
299 continue mainloop;
300 }
301 }
302 continue mainloop;
303 }
304 // in nested multiline comment?
305 if (st.kwtype == HiCommentMulti && st.kwidx > 0 && (opt&Opt.PascalComments) == 0) {
306 //FIXME: more than 255 levels aren't supported
307 ubyte level = st.kwidx;
308 assert(level);
309 while (spos <= le) {
310 ch = gb[spos];
311 if (ch == '+' && gb[spos+1] == '/') {
312 gb.hi(spos++) = HS(HiCommentMulti, level);
313 gb.hi(spos++) = HS(HiCommentMulti, level);
314 if (--level == 0) { st = HS(HiText); continue mainloop; }
315 } else if (ch == '/' && gb[spos+1] == '+') {
316 ++level;
317 gb.hi(spos++) = HS(HiCommentMulti, level);
318 gb.hi(spos++) = HS(HiCommentMulti, level);
319 } else {
320 gb.hi(spos++) = HS(HiCommentMulti, level);
321 }
322 }
323 st = HS(HiCommentMulti, level);
324 continue mainloop;
325 }
326 ch = gb[spos];
327 // single-line comment?
328 if (ch == '/' && (opt&Opt.CSingleComment) && gb[spos+1] == '/') {
329 gb.hi(spos++) = HS(HiCommentOneLine);
330 gb.hi(spos++) = HS(HiCommentOneLine);
331 st = HS(HiCommentOneLine);
332 while (spos <= le) gb.hi(spos++) = st;
333 continue mainloop;
334 }
335 // sql single-line comment?
336 if (ch == '-' && (opt&Opt.SqlSingleComment) && gb[spos+1] == '-') {
337 gb.hi(spos++) = HS(HiCommentOneLine);
338 gb.hi(spos++) = HS(HiCommentOneLine);
339 st = HS(HiCommentOneLine);
340 while (spos <= le) gb.hi(spos++) = st;
341 continue mainloop;
342 }
343 // shell single-line comment?
344 if (ch == '#' && (opt&Opt.ShellSingleComment)) {
345 gb.hi(spos++) = HS(HiCommentOneLine);
346 gb.hi(spos++) = HS(HiCommentOneLine);
347 st = HS(HiCommentOneLine);
348 while (spos <= le) gb.hi(spos++) = st;
349 continue mainloop;
350 }
351 // cougar single-line comment?
352 if (ch == ';' && (opt&Opt.CougarSingleComment)) {
353 gb.hi(spos++) = HS(HiCommentOneLine);
354 gb.hi(spos++) = HS(HiCommentOneLine);
355 st = HS(HiCommentOneLine);
356 while (spos <= le) gb.hi(spos++) = st;
357 continue mainloop;
358 }
359 // C multiline comment?
360 if (ch == '/' && (opt&(Opt.CMultiComment|Opt.PascalComments)) == Opt.CMultiComment && gb[spos+1] == '*') {
361 gb.hi(spos++) = HS(HiCommentMulti);
362 gb.hi(spos++) = HS(HiCommentMulti);
363 st = HS(HiCommentMulti);
364 continue mainloop;
365 }
366 // Pascal multiline comment?
367 if (ch == '(' && (opt&(Opt.CMultiComment|Opt.PascalComments)) == (Opt.CMultiComment|Opt.PascalComments) && gb[spos+1] == '*') {
368 st = HS((gb[spos+2] == '$' ? HiCommentDirective : HiCommentMulti), 1);
369 gb.hi(spos++) = st;
370 gb.hi(spos++) = st;
371 continue mainloop;
372 }
373 // Pascal multiline comment?
374 if (ch == '{' && (opt&(Opt.CMultiComment|Opt.PascalComments)) == (Opt.CMultiComment|Opt.PascalComments)) {
375 st = HS((gb[spos+1] == '$' ? HiCommentDirective : HiCommentMulti), 0);
376 gb.hi(spos++) = st;
377 continue mainloop;
378 }
379 // nested multiline comment?
380 if (ch == '/' && (opt&Opt.DNestedComment) && gb[spos+1] == '+') {
381 st = HS(HiCommentMulti, 1);
382 gb.hi(spos++) = st;
383 gb.hi(spos++) = st;
384 continue mainloop;
385 }
386 // C preprocessor?
387 if (!inPreprocessor && ch == '#' && !seenNonBlank && (opt&Opt.CPreprocessor)) inPreprocessor = true;
388 if (inPreprocessor) {
389 // in preprocessor; eol?
390 if (ch == '\n') {
391 // check for continuation
392 if (spos-1 >= ls && gb[spos-1] == '\\') {
393 // yep
394 st = HS(HiPreprocessor);
395 gb.hi(spos++) = st;
396 } else {
397 // no
398 st = HS(HiText);
399 gb.hi(spos++) = st;
400 }
401 continue mainloop;
402 }
403 // not a EOL, go on
404 st = HS(HiPreprocessor);
405 gb.hi(spos++) = st;
406 continue mainloop;
407 }
408 // non-blank?
409 if (ch > ' ') seenNonBlank = true;
410 // js inline regexp?
411 if (ch == '/' && (opt&Opt.JSRegExp)) {
412 int ep = spos+1;
413 while (ep <= le) {
414 if (gb[ep] == '/') break;
415 if (gb[ep] == '\\' && ep+1 <= le) ++ep;
416 ++ep;
417 }
418 if (ep <= le) {
419 // yep
420 st = HS(HiRegExp);
421 while (spos <= ep) gb.hi(spos++) = st;
422 continue mainloop;
423 }
424 }
425 // EOL?
426 if (ch == '\n') {
427 gb.hi(spos++) = st;
428 continue mainloop;
429 }
430 // control char or non-ascii char?
431 if (ch <= ' ' || ch >= 127) {
432 st = HS(HiText);
433 gb.hi(spos++) = st;
434 continue mainloop;
435 }
436 // string?
437 if (ch == '\'' && (opt&Opt.SQString)) {
438 gb.hi(spos++) = HS(HiSQString);
439 st = HS(HiSQString);
440 continue mainloop;
441 }
442 // string?
443 if (ch == '"' && (opt&Opt.DQString)) {
444 gb.hi(spos++) = HS(HiDQString);
445 st = HS(HiDQString);
446 continue mainloop;
447 }
448 // bqstring?
449 if (ch == '`' && (opt&Opt.BQString)) {
450 gb.hi(spos++) = HS(HiBQString);
451 st = HS(HiBQString);
452 continue mainloop;
453 }
454 // rqstring?
455 if (ch == 'r' && (opt&Opt.RQString) && gb[spos+1] == '"') {
456 gb.hi(spos++) = HS(HiRQString);
457 gb.hi(spos++) = HS(HiRQString);
458 st = HS(HiRQString);
459 continue mainloop;
460 }
461 // char?
462 if (ch == '\'' && (opt&Opt.SQChar)) {
463 auto xsp = spos;
464 ++spos;
465 auto len = skipStrChar!(false, true)();
466 if (len > 0 && gb[spos+len] == '\'') {
467 spos = xsp;
468 gb.hi(spos++) = HS(HiChar);
469 st = HS(len == 1 ? HiChar : HiCharSpecial);
470 while (len--) gb.hi(spos++) = st;
471 gb.hi(spos++) = HS(HiChar);
472 st = HS(HiText);
473 } else {
474 spos = xsp;
475 st = HS(HiText);
476 gb.hi(spos++) = st;
477 for (;;) {
478 if (len == 0 || gb[spos] == '\'') { gb.hi(spos++) = st; continue mainloop; }
479 while (len-- > 0) gb.hi(spos++) = st;
480 len = skipStrChar!(false, true)();
481 }
482 }
483 continue mainloop;
484 }
485 // cougar char?
486 //FIXME
487 if (ch == '#' && (opt&Opt.CougarCharLiteral) /*&& (spos-1 < ls || gb[spos-1] == '\\')*/) {
488 auto xsp = spos;
489 ++spos;
490 auto len = skipStrChar!(true, true)();
491 if (len > 0) {
492 st = HS(HiCharSpecial);
493 spos = xsp;
494 gb.hi(spos++) = st;
495 while (len--) gb.hi(spos++) = st;
496 st = HS(HiText);
497 continue mainloop;
498 }
499 }
500 // "cXr"
501 if ((opt&Opt.MaximumTokens) && gb[spos] == 'c') {
502 auto epos = spos+1;
503 int cnt = 0;
504 while (epos <= le) {
505 ch = gb[epos];
506 if (ch != 'a' && ch != 'd') break;
507 ++epos;
508 ++cnt;
509 }
510 if (epos <= le && cnt > 1 && gb[epos] == 'r') {
511 ch = gb[++epos];
512 if (ch <= ' ' || ch == '(' || ch == ')' || ch == ';' ||
513 (ch == '/' && (gb[epos+1] == '*' || gb[epos+1] == '+' || gb[epos+1] == '/')))
514 {
515 st = HS(HiKeyword);
516 foreach (immutable _; spos..epos) gb.hi(spos++) = st;
517 continue mainloop;
518 }
519 }
520 // nope
521 }
522 // identifier/keyword?
523 if (ch.isalpha || ch == '_') {
524 auto tmach = tks.start();
525 auto epos = spos;
526 ubyte stx = 0;
527 while (epos <= le) {
528 ch = gb[epos];
529 if (!(opt&Opt.MaximumTokens)) {
530 if (ch != '_' && !ch.isalnum) break;
531 } else {
532 if (ch <= ' ' || ch == '(' || ch == ')' || ch == ';' ||
533 (ch == '/' && (gb[epos+1] == '*' || gb[epos+1] == '+' || gb[epos+1] == '/')))
534 {
535 break;
536 }
537 }
538 stx = tmach.advance(ch);
539 ++epos;
540 }
541 if (epos <= spos && spos < le) epos = spos+1;
542 if (stx) {
543 st = HS(stx);
544 // sorry
545 if (stx == HiBodySpecialMark) {
546 st = HS(HiText);
547 int xofs = epos;
548 while (xofs < gb.textsize) {
549 ch = gb[xofs];
550 if (ch == '{') { st = HS(HiSpecial); break; }
551 if (ch > ' ') break;
552 ++xofs;
553 }
554 } else if (opt&Opt.NumAsmHex) {
555 // sorry
556 if (epos-spos == 2 &&
557 (gb[spos] == 'a' || gb[spos] == 'A') &&
558 (gb[spos+1] == 'f' || gb[spos+1] == 'F') &&
559 gb[spos+2] == '\'')
560 {
561 ++epos;
562 } else if (spos > 2 && epos-spos == 1 && (gb[spos] == 'C' || gb[spos] == 'c')) {
563 // "c" can be either condition, or regname
564 // if previous token ends with "r"(jr), "p"(jp), "l"(call), "t"(ret), use condition
565 auto ptp = spos-1;
566 while (ptp > 0 && gb[ptp] != '\n' && gb[ptp] <= ' ') --ptp;
567 if (gb[ptp] == 'r' || gb[ptp] == 'p' || gb[ptp] == 'l' || gb[ptp] == 't' ||
568 gb[ptp] == 'R' || gb[ptp] == 'P' || gb[ptp] == 'L' || gb[ptp] == 'T')
569 {
570 st = HS(HiSpecial);
571 }
572 }
573 }
574 } else {
575 st = HS(HiText);
576 }
577 foreach (immutable _; spos..epos) gb.hi(spos++) = st;
578
579 continue mainloop;
580 }
581 // based number?
582 if (auto base = isBasedStart(spos, basedNumSkip)) {
583 bool au = ((opt&Opt.NumAllowUnder) != 0);
584 ofs = basedNumSkip; //(ch == '+' || ch == '-' ? 3 : 2);
585 while (spos+ofs <= le) {
586 ch = gb[spos+ofs];
587 if (ch.digitInBase(base) >= 0 || (au && ch == '_')) { ++ofs; continue; }
588 break;
589 }
590 skipNumMods();
591 st = HS(HiText);
592 if (gb[spos+ofs].isalnum) { gb.hi(spos++) = st; continue mainloop; }
593 // good number
594 st = HS(HiNumber);
595 foreach (immutable _; 0..ofs) gb.hi(spos++) = st;
596 st = HS(HiText);
597 continue mainloop;
598 }
599 // decimal/floating number
600 if (isDecStart(spos)) {
601 bool au = (opt&Opt.NumAllowUnder) != 0;
602 ofs = 1;
603 while (spos+ofs <= le) {
604 ch = gb[spos+ofs];
605 if (ch.isdigit || (au && ch == '_')) { ++ofs; continue; }
606 break;
607 }
608 if (gb[spos+ofs] == '.' && gb[spos+ofs+1] != '.') {
609 ++ofs;
610 if (isDecStart(spos+ofs)) {
611 ++ofs;
612 while (spos+ofs <= le && (gb[spos+ofs].isdigit || (au && gb[spos+ofs] == '_'))) ++ofs;
613 }
614 if (gb[spos+ofs].tolower == 'e' && isDecStart(spos+ofs+1)) {
615 ofs += 2;
616 while (spos+ofs <= le && (gb[spos+ofs].isdigit || (au && gb[spos+ofs] == '_'))) ++ofs;
617 }
618 }
619 skipNumMods();
620 st = HS(HiText);
621 if (gb[spos+ofs].isalnum) { gb.hi(spos++) = st; continue mainloop; }
622 // good number
623 st = HS(HiNumber);
624 foreach (immutable _; 0..ofs) gb.hi(spos++) = st;
625 st = HS(HiText);
626 continue mainloop;
627 }
628 // punctuation token
629 if (tks.canStartWith(ch)) {
630 bool isdollar = (ch == '$');
631 auto tmach = tks.start();
632 auto epos = spos;
633 uint lastlen = 0;
634 ubyte stx = 0;
635 while (epos <= le && tmach.canContinue) {
636 if (auto tx = tmach.advance(gb[epos++])) {
637 lastlen = cast(uint)(epos-spos);
638 stx = tx;
639 }
640 }
641 if (lastlen == 0 && isdollar && (opt&Opt.ShellSigil) && spos+1 < le) goto sigil;
642 if (lastlen == 0) {
643 lastlen = 1;
644 st = HS(HiPunct);
645 } else {
646 st = HS(stx);
647 }
648 foreach (immutable cp; 0..lastlen) gb.hi(spos++) = st;
649 continue mainloop;
650 }
651 // shell sigils
652 if (ch == '$' && (opt&Opt.ShellSigil) && spos+1 < le) {
653 sigil:
654 st = HS(HiSpecial);
655 gb.hi(spos++) = st;
656 if (gb[spos] == '{') {
657 // complex sigil
658 while (spos < le) {
659 ch = gb[spos];
660 if (ch != '}') {
661 gb.hi(spos++) = st;
662 } else {
663 break;
664 }
665 }
666 } else {
667 // simple sigil
668 while (spos < le) {
669 ch = gb[spos];
670 if (ch.isalnum || ch == '.' || ch == '_') {
671 gb.hi(spos++) = st;
672 } else {
673 break;
674 }
675 }
676 }
677 st = HS(HiText);
678 }
679 // normal text
680 st = HS(HiText);
681 gb.hi(spos++) = st;
682 }
683 }
684
685 private final:
686 // returns either 0 or "skip count"
687 int isGoodChar (int pos) nothrow {
688 if (gb[pos] != '\'') return 0;
689 if (gb[pos+1] == '\\') {
690 auto ch = gb[pos+2];
691 if (ch != 'x' && ch != 'X') return (gb[pos+3] == '\'' ? 4 : 0);
692 if (!gb[pos+3].isxdigit) return 0;
693 ch = gb[pos+4];
694 if (!ch.isxdigit) return (ch == '\'' ? 5 : 0);
695 return (gb[pos+5] == '\'' ? 6 : 0);
696 } else if (gb[pos+2] == '\'') {
697 return 3;
698 } else {
699 return 0;
700 }
701 }
702
703 bool isDecStart (int pos) nothrow {
704 auto ch = gb[pos];
705 if (ch == '-' || ch == '+') {
706 if (!(tks.options&Opt.NumAllowSign)) return false;
707 ch = gb[++pos];
708 }
709 if (ch.isdigit) return true;
710 // floating can start with '.<digit>'
711 return (ch == '.' && gb[pos+1].isdigit);
712 }
713
714 // 0 or base
715 int isBasedStart (int pos, out int basedNumSkip) nothrow {
716 auto ch = gb[pos++];
717 if (ch == '-' || ch == '+') {
718 if (!(tks.options&Opt.NumAllowSign)) return 0;
719 ch = gb[pos++];
720 basedNumSkip = 1; // sign
721 }
722 // pascal $hex literal?
723 if ((tks.options&Opt.NumPasHex) && ch == '$' && gb[pos].digitInBase(16) >= 0) {
724 basedNumSkip += 1; // dollar
725 return 16;
726 }
727 // zas #hex literal?
728 if ((tks.options&Opt.NumAsmHex) && ch == '#' && gb[pos].digitInBase(16) >= 0) {
729 basedNumSkip += 1; // hash
730 return 16;
731 }
732 // zas &X literal?
733 if ((tks.options&Opt.NumAsmHex) && ch == '&' && gb[pos+1].digitInBase(16) >= 0) {
734 immutable char c1 = gb[pos];
735 if (c1 == 'h' || c1 == 'H') { basedNumSkip += 2; return 16; }
736 if (c1 == 'b' || c1 == 'B') { basedNumSkip += 2; return 2; }
737 if (c1 == 'o' || c1 == 'O') { basedNumSkip += 2; return 8; }
738 if (c1 == 'd' || c1 == 'D') { basedNumSkip += 2; return 10; }
739 }
740 if (ch != '0') return 0;
741 ch = gb[pos++];
742 int base = 0;
743 if (ch == 'x' || ch == 'X') base = 16;
744 else if (ch == 'o' || ch == 'O') base = 8;
745 else if (ch == 'b' || ch == 'B') base = 2;
746 else if (ch == 'd' || ch == 'D') base = 10;
747 else return 0;
748 if (!(tks.options&Opt.Num0x) && base == 16) return 0;
749 if (!(tks.options&Opt.Num0o) && base == 8) return 0;
750 if (!(tks.options&Opt.Num0b) && base == 2) return 0;
751 //HACK!
752 if (!(tks.options&Opt.Num0o) && base == 10) return 0;
753 basedNumSkip += 2; // 0n prefix
754 return (gb[pos].digitInBase(base) >= 0 ? base : 0);
755 }
756 }
757
758
759 // ////////////////////////////////////////////////////////////////////////// //
760 public class EditorHLTODO : EditorHLExt {
761 this () { super(null); }
762
763 protected override void rehighlightLine (int ls, int le) {
764 while (ls <= le && gb[ls] <= ' ') gb.hi(ls++) = HS(HiText);
765 if (le-ls+1 >= 3 && gb[ls] == '[' && gb[ls+2] == ']') {
766 auto st = HS(HiNone);
767 switch (gb[ls+1]) {
768 case '.': st = HS(HiToDoOpen); break;
769 case '!': st = HS(HiToDoUrgent); break;
770 case '+': st = HS(HiToDoSemi); break;
771 case '*': st = HS(HiToDoDone); break;
772 case '-': st = HS(HiToDoDont); break;
773 case '?': st = HS(HiToDoUnsure); break;
774 default:
775 }
776 if (st.kwtype != HiNone) {
777 gb.hi(ls++) = st;
778 gb.hi(ls++) = st;
779 gb.hi(ls++) = st;
780 }
781 }
782 while (ls <= le) gb.hi(ls++) = HS(HiText);
783 }
784 }
785
786
787 // ////////////////////////////////////////////////////////////////////////// //
788 public class EditorHLGitCommit : EditorHLExt {
789 this () { super(null); }
790
791 protected override void rehighlightLine (int ls, int le) {
792 while (ls <= le && gb[ls] != '#') gb.hi(ls++) = HS(HiText);
793 while (ls <= le) gb.hi(ls++) = HS(HiCommentOneLine);
794 }
795 }
796
797
798 // ////////////////////////////////////////////////////////////////////////// //
799 struct TokenMachine {
800 public:
801 enum InvalidState = 0;
802
803 private:
804 static struct MachineNode {
805 char ch = 0; // current char
806 ubyte endstate = InvalidState; // if not ubyte.max, this is what we should have if this node is terminal
807 char firstch; // in next array
808 int[] nexta;
809 @property int next (char ch) const pure nothrow @trusted @nogc {
810 pragma(inline, true);
811 return (ch >= firstch && ch < firstch+nexta.length ? nexta.ptr[ch-firstch] : 0);
812 }
813 void setNext (char ch, int n) nothrow @trusted {
814 assert(n != 0);
815 auto optr = nexta.ptr;
816 if (nexta.length == 0) {
817 firstch = ch;
818 nexta.reserve(2);
819 nexta.length = 1;
820 nexta[0] = n;
821 } else if (ch < firstch) {
822 int nfch = ch;
823 auto inclen = firstch-nfch;
824 nexta.length += inclen;
825 foreach_reverse (immutable cc; inclen..nexta.length) nexta.ptr[cc] = nexta.ptr[cc-inclen];
826 nexta[0..inclen] = 0;
827 firstch = ch;
828 } else {
829 if (ch-firstch >= nexta.length) nexta.length = ch-firstch+1;
830 }
831 nexta[ch-firstch] = n;
832 if (nexta.ptr !is optr) {
833 import core.memory : GC;
834 if (nexta.ptr is GC.addrOf(nexta.ptr)) {
835 //conwriteln("resized, fixing flags...");
836 GC.setAttr(nexta.ptr, GC.BlkAttr.NO_SCAN|GC.BlkAttr.NO_INTERIOR); // less false positives
837 }
838 }
839 }
840 }
841
842 private:
843 MachineNode[] mach;
844
845 public:
846 int minlen = 0, maxlen = 0; // token lengthes
847 bool casesens = true;
848
849 private:
850 int addMachineNode (MachineNode node) {
851 if (mach.length >= int.max) assert(0, "too many nodes in mach");
852 auto optr = mach.ptr;
853 auto res = cast(int)mach.length;
854 mach ~= node;
855 if (mach.ptr !is optr) {
856 import core.memory : GC;
857 if (mach.ptr is GC.addrOf(mach.ptr)) {
858 //conwriteln("resized, fixing flags...");
859 GC.setAttr(mach.ptr, GC.BlkAttr.NO_INTERIOR); // less false positives
860 }
861 }
862 return res;
863 }
864
865 public:
866 void addToken (string tok, ubyte estate) {
867 if (tok.length >= int.max/8) assert(0, "wtf?!");
868 if (tok.length == 0) return;
869 if (minlen == 0 || tok.length < minlen) minlen = cast(int)tok.length;
870 if (tok.length > maxlen) maxlen = cast(int)tok.length;
871 assert(estate != InvalidState);
872 if (mach.length == 0) addMachineNode(MachineNode(0));
873
874 auto tst = checkToken(tok);
875 if (tst != InvalidState) {
876 if (tst != estate) {
877 import core.stdc.stdio : stderr, fprintf;
878 stderr.fprintf("WARNING: CONFLICTING TOKEN: '%.*s' (%u:%u)\n", cast(uint)tok.length, tok.ptr, cast(uint)tst, cast(uint)estate);
879 }
880 return;
881 }
882
883 int lastnode = 0;
884 foreach (char ch; tok) {
885 if (!casesens && ch >= 'A' && ch <= 'Z') ch += 32;
886 int nextnode = mach[lastnode].next(ch);
887 if (nextnode == 0) {
888 // new node
889 nextnode = addMachineNode(MachineNode(ch));
890 mach[lastnode].setNext(ch, nextnode);
891 }
892 lastnode = nextnode;
893 }
894 assert(lastnode > 0);
895 char lastch = tok[$-1];
896 assert(mach[lastnode].ch == lastch);
897 assert(mach[lastnode].endstate == InvalidState);
898 mach[lastnode].endstate = estate;
899 }
900
901 ubyte checkToken (const(char)[] tok) const nothrow @trusted @nogc {
902 if (tok.length < minlen || tok.length > maxlen) return InvalidState;
903 int node = 0;
904 if (casesens) {
905 foreach (char ch; tok) if ((node = mach.ptr[node].next(ch)) == 0) return InvalidState;
906 } else {
907 foreach (char ch; tok) {
908 if (ch >= 'A' && ch <= 'Z') ch += 32;
909 if ((node = mach.ptr[node].next(ch)) == 0) return InvalidState;
910 }
911 }
912 return mach.ptr[node].endstate;
913 }
914
915 auto start () const nothrow @trusted @nogc {
916 static struct Checker {
917 private:
918 const(TokenMachine)* tmach;
919 int curnode;
920 public:
921 nothrow @trusted @nogc:
922 @property ubyte state () const { pragma(inline, true); return (curnode >= 0 ? tmach.mach.ptr[curnode].endstate : InvalidState); }
923 @property bool canContinue () const { pragma(inline, true); return (curnode >= 0); }
924 @property int mintklen () const { pragma(inline, true); return tmach.minlen; }
925 @property int maxtklen () const { pragma(inline, true); return tmach.maxlen; }
926 ubyte advance (char ch) {
927 if (curnode >= 0) {
928 if (!tmach.casesens && ch >= 'A' && ch <= 'Z') ch += 32;
929 if ((curnode = tmach.mach.ptr[curnode].next(ch)) == 0) {
930 curnode = -1;
931 return InvalidState;
932 } else {
933 return tmach.mach.ptr[curnode].endstate;
934 }
935 } else {
936 return InvalidState;
937 }
938 }
939 }
940 return Checker(&this, 0);
941 }
942 }
943
944
945 // ////////////////////////////////////////////////////////////////////////// //
946 public abstract class EdHiTokens {
947 public:
948 enum NotFound = 0;
949 static assert(NotFound == TokenMachine.InvalidState);
950
951 // if `SqlSingleComment` is set, strings cannot has escapes
952 // BQString and RQString cannot have escapes, ever
953 // double-quited strings are processed iff NoStrings flag is NOT set
954 enum Opt : uint {
955 // number parsing options
956 Num0b = 1U<<0,
957 Num0o = 1U<<1,
958 Num0x = 1U<<2,
959 NumAllowUnder = 1U<<3,
960 NumAllowSign = 1U<<4,
961 SQString = 1U<<5, // can string be single-quoted?
962 DQString = 1U<<6, // can string be double-quoted?
963 BQString = 1U<<7, // allow D-style `...` strings
964 RQString = 1U<<8, // allow D-style r"..." strings
965 SQChar = 1U<<9, // allow single-quoted chars; escapes always allowed
966 // comment options
967 DNestedComment = 1U<<10, // allow `/+ ... +/` newsted comments
968 ShellSingleComment = 1U<<11, // allow `# ` comments
969 CSingleComment = 1U<<12, // allow `//` comments
970 CMultiComment = 1U<<13, // allow `/* ... */` comments
971 SqlSingleComment = 1U<<14, // allow `--` comments
972 // other options
973 CPreprocessor = 1U<<15, // does this language use C preprocessor?
974 JSRegExp = 1U<<16, // parse JS inline regexps?
975 ShellSigil = 1U<<17, // parse shell sigils?
976 // token machine options
977 CaseInsensitive = 1U<<18, // are tokens case-sensitive?
978 // string options
979 SQStringNoEscape = 1U<<19, // no escapes are allowed in single-quoted strings
980 DQStringNoEscape = 1U<<20, // no escapes are allowed in double-quoted strings
981 // cougar options
982 CougarSingleComment = 1U<<21,
983 CougarCharLiteral = 1U<<22,
984 MaximumTokens = 1U<<23,
985 PascalComments = 1U<<24,
986 NumPasHex = 1U<<25,
987 NumAsmHex = 1U<<26, // this also disables multiline strings
988 }
989 static assert(Opt.max <= uint.max);
990
991 public:
992 uint options;
993 TokenMachine tmach;
994
995 final void setOptions (uint opt) {
996 options = opt;
997 tmach.casesens = ((opt&Opt.CaseInsensitive) == 0);
998 }
999
1000 public:
1001 this (uint opt) { setOptions(opt); }
1002
1003 final:
1004 void addToken (string tok, ubyte estate) {
1005 pragma(inline, true);
1006 tmach.addToken(tok, estate);
1007 }
1008
1009 bool canStartWith (char ch) const nothrow @trusted @nogc {
1010 pragma(inline, true);
1011 return (tmach.mach.ptr[0].next(ch) > 0);
1012 }
1013
1014 auto start () const nothrow @trusted @nogc {
1015 pragma(inline, true);
1016 return tmach.start();
1017 }
1018 }
1019
1020
1021 // ////////////////////////////////////////////////////////////////////////// //
1022 public class EdHiTokensD : EdHiTokens {
1023 this () {
1024 super(
1025 Opt.Num0b|
1026 Opt.Num0o|
1027 Opt.Num0x|
1028 Opt.NumAllowUnder|
1029 //Opt.NumAllowSign|
1030 //Opt.SQString|
1031 Opt.DQString|
1032 Opt.BQString|
1033 Opt.RQString|
1034 Opt.SQChar|
1035 Opt.DNestedComment|
1036 //Opt.ShellSingleComment|
1037 Opt.CSingleComment|
1038 Opt.CMultiComment|
1039 //Opt.SqlSingleComment|
1040 //Opt.CPreprocessor|
1041 //Opt.JSRegExp|
1042 //Opt.ShellSigil|
1043 //Opt.CaseInsensitive|
1044 //Opt.SQStringNoEscape|
1045 //Opt.DQStringNoEscape|
1046 //Opt.CougarSingleComment|
1047 //Opt.CougarCharLiteral|
1048 //Opt.MaximumTokens|
1049 //Opt.PascalComments|
1050 //Opt.NumPasHex|
1051 //Opt.NumAsmHex|
1052 0
1053 );
1054
1055 addToken("body", /*HiSpecial*/HiBodySpecialMark);
1056
1057 addToken("this", HiInternal);
1058 addToken("super", HiInternal);
1059
1060 addToken("assert", HiBuiltin);
1061 addToken("new", HiBuiltin);
1062 addToken("delete", HiBuiltin);
1063
1064 addToken("null", HiKeyword);
1065 addToken("true", HiKeyword);
1066 addToken("false", HiKeyword);
1067 addToken("cast", HiKeyword);
1068 addToken("throw", HiKeyword);
1069 addToken("module", HiKeyword);
1070 addToken("pragma", HiKeyword);
1071 addToken("typeof", HiKeyword);
1072 addToken("typeid", HiKeyword);
1073 addToken("sizeof", HiKeyword);
1074 addToken("template", HiKeyword);
1075
1076 addToken("void", HiType);
1077 addToken("byte", HiType);
1078 addToken("ubyte", HiType);
1079 addToken("short", HiType);
1080 addToken("ushort", HiType);
1081 addToken("int", HiType);
1082 addToken("uint", HiType);
1083 addToken("long", HiType);
1084 addToken("ulong", HiType);
1085 addToken("cent", HiType);
1086 addToken("ucent", HiType);
1087 addToken("float", HiType);
1088 addToken("double", HiType);
1089 addToken("real", HiType);
1090 addToken("bool", HiType);
1091 addToken("char", HiType);
1092 addToken("wchar", HiType);
1093 addToken("dchar", HiType);
1094 addToken("ifloat", HiType);
1095 addToken("idouble", HiType);
1096 addToken("ireal", HiType);
1097 addToken("cfloat", HiType);
1098 addToken("cdouble", HiType);
1099 addToken("creal", HiType);
1100 addToken("string", HiType);
1101 addToken("usize", HiType);
1102 addToken("uhash", HiType);
1103 addToken("ssize", HiType);
1104 addToken("size_t", HiInternal);
1105 addToken("ptrdiff_t", HiInternal);
1106 addToken("cstring", HiType);
1107
1108 addToken("delegate", HiKeyword);
1109 addToken("function", HiKeyword);
1110 addToken("is", HiKeyword);
1111 addToken("if", HiKeyword);
1112 addToken("else", HiKeyword);
1113 addToken("while", HiKeyword);
1114 addToken("for", HiKeyword);
1115 addToken("do", HiKeyword);
1116 addToken("switch", HiKeyword);
1117 addToken("case", HiKeyword);
1118 addToken("default", HiKeyword);
1119 addToken("break", HiKeyword);
1120 addToken("continue", HiKeyword);
1121 addToken("synchronized", HiBuiltin);
1122 addToken("return", HiKeyword);
1123 addToken("goto", HiKeyword);
1124 addToken("try", HiKeyword);
1125 addToken("catch", HiKeyword);
1126 addToken("finally", HiKeyword);
1127 addToken("with", HiKeyword);
1128 addToken("asm", HiKeyword);
1129 addToken("foreach", HiKeyword);
1130 addToken("foreach_reverse", HiKeyword);
1131 addToken("scope", HiKeyword);
1132 addToken("struct", HiKeyword);
1133 addToken("class", HiKeyword);
1134 addToken("interface", HiKeyword);
1135 addToken("union", HiKeyword);
1136 addToken("enum", HiKeyword);
1137 addToken("mixin", HiKeyword);
1138 addToken("static", HiKeyword);
1139 addToken("final", HiKeyword);
1140 addToken("const", HiKeyword);
1141 addToken("alias", HiKeyword);
1142 addToken("override", HiKeyword);
1143 addToken("abstract", HiKeyword);
1144 addToken("debug", HiKeyword);
1145 addToken("deprecated", HiKeyword);
1146
1147 addToken("import", HiInternal);
1148
1149 addToken("in", HiSpecial);
1150 addToken("out", HiSpecial);
1151 addToken("inout", HiSpecial);
1152 addToken("lazy", HiSpecial);
1153
1154 addToken("auto", HiType);
1155
1156 addToken("align", HiSpecial);
1157 addToken("extern", HiSpecial);
1158 addToken("private", HiSpecial);
1159 addToken("package", HiSpecial);
1160 addToken("protected", HiSpecial);
1161 addToken("public", HiSpecial);
1162 addToken("export", HiSpecial);
1163 addToken("invariant", HiSpecial);
1164 addToken("unittest", HiSpecial);
1165 addToken("version", HiSpecial);
1166
1167 addToken("__argTypes", HiInternal);
1168 addToken("__parameters", HiInternal);
1169
1170 addToken("ref", HiSpecial);
1171
1172 addToken("macro", HiInternal);
1173 addToken("pure", HiInternal);
1174 addToken("__gshared", HiInternal);
1175 addToken("__traits", HiInternal);
1176 addToken("__vector", HiInternal);
1177 addToken("__overloadset", HiInternal);
1178 addToken("__FILE__", HiInternal);
1179 addToken("__FILE_FULL_PATH__", HiInternal);
1180 addToken("__LINE__", HiInternal);
1181 addToken("__MODULE__", HiInternal);
1182 addToken("__FUNCTION__", HiInternal);
1183 addToken("__PRETTY_FUNCTION__", HiInternal);
1184 addToken("shared", HiInternal);
1185
1186 addToken("immutable", HiKeyword);
1187
1188 addToken("nothrow", HiUDA);
1189 addToken("@nothrow", HiUDA);
1190 addToken("@nogc", HiUDA);
1191 addToken("@safe", HiUDA);
1192 addToken("@system", HiUDA);
1193 addToken("@trusted", HiUDA);
1194 addToken("@property", HiUDA);
1195 addToken("@disable", HiUDA);
1196
1197 addToken("{", HiPunct);
1198 addToken("}", HiPunct);
1199 addToken("(", HiPunct);
1200 addToken(")", HiPunct);
1201 addToken("[", HiPunct);
1202 addToken("]", HiPunct);
1203 addToken(";", HiSemi);
1204 addToken(":", HiPunct);
1205 addToken(",", HiPunct);
1206 addToken(".", HiPunct);
1207 addToken("^", HiPunct);
1208 addToken("^=", HiPunct);
1209 addToken("=", HiPunct);
1210 addToken("=", HiPunct);
1211 addToken("=", HiPunct);
1212 addToken("<", HiPunct);
1213 addToken(">", HiPunct);
1214 addToken("<=", HiPunct);
1215 addToken(">=", HiPunct);
1216 addToken("==", HiPunct);
1217 addToken("!=", HiPunct);
1218 addToken("!<>=", HiPunct);
1219 addToken("!<>", HiPunct);
1220 addToken("<>", HiPunct);
1221 addToken("<>=", HiPunct);
1222 addToken("!>", HiPunct);
1223 addToken("!>=", HiPunct);
1224 addToken("!<", HiPunct);
1225 addToken("!<=", HiPunct);
1226 addToken("!", HiPunct);
1227 addToken("<<", HiPunct);
1228 addToken(">>", HiPunct);
1229 addToken(">>>", HiPunct);
1230 addToken("+", HiPunct);
1231 addToken("-", HiPunct);
1232 addToken("*", HiPunct);
1233 addToken("/", HiPunct);
1234 addToken("%", HiPunct);
1235 addToken("..", HiPunct);
1236 addToken("...", HiKeywordHi);
1237 addToken("&", HiPunct);
1238 addToken("&&", HiSpecial);
1239 addToken("|", HiPunct);
1240 addToken("||", HiSpecial);
1241 addToken("[]", HiPunct);
1242 addToken("&", HiPunct);
1243 addToken("*", HiPunct);
1244 addToken("~", HiPunct);
1245 addToken("$", HiPunct);
1246 addToken("++", HiPunct);
1247 addToken("--", HiPunct);
1248 addToken("++", HiPunct);
1249 addToken("--", HiPunct);
1250 addToken("?", HiPunct);
1251 addToken("-", HiPunct);
1252 addToken("+", HiPunct);
1253 addToken("+=", HiPunct);
1254 addToken("-=", HiPunct);
1255 addToken("*=", HiPunct);
1256 addToken("/=", HiPunct);
1257 addToken("%=", HiPunct);
1258 addToken("<<=", HiPunct);
1259 addToken(">>=", HiPunct);
1260 addToken(">>>=", HiPunct);
1261 addToken("&=", HiPunct);
1262 addToken("|=", HiPunct);
1263 addToken("~=", HiPunct);
1264 addToken("~", HiPunct);
1265 //addToken("is", HiPunct);
1266 //addToken("!is", HiPunct);
1267 //addToken("@", HiPunct);
1268 addToken("^^", HiPunct);
1269 addToken("^^=", HiPunct);
1270 addToken("=>", HiPunct);
1271
1272 addToken("aliced", HiAliced);
1273 }
1274 }
1275
1276
1277 // ////////////////////////////////////////////////////////////////////////// //
1278 public class EdHiTokensJS : EdHiTokens {
1279 this () {
1280 super(
1281 //Opt.Num0b|
1282 //Opt.Num0o|
1283 Opt.Num0x|
1284 //Opt.NumAllowUnder|
1285 //Opt.NumAllowSign|
1286 Opt.SQString|
1287 Opt.DQString|
1288 //Opt.BQString|
1289 //Opt.RQString|
1290 Opt.SQChar|
1291 //Opt.DNestedComment|
1292 //Opt.ShellSingleComment|
1293 Opt.CSingleComment|
1294 Opt.CMultiComment|
1295 //Opt.SqlSingleComment|
1296 //Opt.CPreprocessor|
1297 Opt.JSRegExp|
1298 //Opt.ShellSigil|
1299 //Opt.CaseInsensitive|
1300 //Opt.SQStringNoEscape|
1301 //Opt.DQStringNoEscape|
1302 //Opt.CougarSingleComment|
1303 //Opt.CougarCharLiteral|
1304 //Opt.MaximumTokens|
1305 //Opt.PascalComments|
1306 //Opt.NumPasHex|
1307 0
1308 );
1309
1310 addToken("arguments", HiKeyword);
1311 addToken("break", HiKeyword);
1312 addToken("callee", HiKeyword);
1313 addToken("caller", HiKeyword);
1314 addToken("case", HiKeyword);
1315 addToken("catch", HiKeyword);
1316 addToken("constructor", HiKeyword);
1317 addToken("const", HiKeywordHi);
1318 addToken("continue", HiKeyword);
1319 addToken("default", HiKeyword);
1320 addToken("delete", HiKeyword);
1321 addToken("do", HiKeyword);
1322 addToken("else", HiKeyword);
1323 addToken("finally", HiKeyword);
1324 addToken("for", HiKeyword);
1325 addToken("function", HiKeyword);
1326 addToken("get", HiKeywordHi);
1327 addToken("if", HiKeyword);
1328 addToken("instanceof", HiKeyword);
1329 addToken("in", HiSpecial);
1330 addToken("let", HiKeywordHi);
1331 addToken("new", HiSpecial);
1332 addToken("prototype", HiSpecial);
1333 addToken("return", HiKeyword);
1334 addToken("switch", HiKeyword);
1335 addToken("this", HiSpecial);
1336 addToken("throw", HiKeyword);
1337 addToken("try", HiKeyword);
1338 addToken("typeof", HiKeyword);
1339 addToken("var", HiKeywordHi);
1340 addToken("while", HiKeyword);
1341 addToken("with", HiKeywordHi);
1342
1343 addToken("Array", HiKeywordHi);
1344 addToken("Boolean", HiKeywordHi);
1345 addToken("Date", HiKeywordHi);
1346 addToken("Function", HiKeywordHi);
1347 addToken("Math", HiKeywordHi);
1348 addToken("Number", HiKeywordHi);
1349 addToken("String", HiKeywordHi);
1350 addToken("Object", HiKeywordHi);
1351 addToken("RegExp", HiKeywordHi);
1352
1353 // Most common functions
1354 addToken("escape", HiBuiltin);
1355 addToken("eval", HiBuiltin);
1356 addToken("indexOf", HiKeywordHi);
1357 addToken("isNaN", HiBuiltin);
1358 addToken("toString", HiBuiltin);
1359 addToken("unescape", HiBuiltin);
1360 addToken("valueOf", HiBuiltin);
1361
1362 // Constants
1363 addToken("false", HiBuiltin);
1364 addToken("null", HiBuiltin);
1365 addToken("true", HiBuiltin);
1366 addToken("undefined", HiBuiltin);
1367
1368 // punct
1369 addToken(".", HiPunct);
1370 addToken("*", HiPunct);
1371 addToken("+", HiPunct);
1372 addToken("-", HiPunct);
1373 addToken("/", HiPunct);
1374 addToken("%", HiPunct);
1375 addToken("=", HiPunct);
1376 addToken("!", HiPunct);
1377 addToken("&", HiPunct);
1378 addToken("|", HiPunct);
1379 addToken("^", HiPunct);
1380 addToken("~", HiPunct);
1381 addToken(">", HiPunct);
1382 addToken("<", HiPunct);
1383
1384 addToken("{", HiPunct);
1385 addToken("}", HiPunct);
1386 addToken("(", HiPunct);
1387 addToken(")", HiPunct);
1388 addToken("[", HiPunct);
1389 addToken("]", HiPunct);
1390 addToken(",", HiPunct);
1391 addToken("?", HiPunct);
1392 addToken(":", HiPunct);
1393 addToken(";", HiSemi);
1394 }
1395 }
1396
1397
1398 // ////////////////////////////////////////////////////////////////////////// //
1399 public class EdHiTokensC : EdHiTokens {
1400 this () {
1401 super(
1402 Opt.Num0b|
1403 Opt.Num0o|
1404 Opt.Num0x|
1405 //Opt.NumAllowUnder|
1406 //Opt.NumAllowSign|
1407 //Opt.SQString|
1408 Opt.DQString|
1409 //Opt.BQString|
1410 //Opt.RQString|
1411 Opt.SQChar|
1412 //Opt.DNestedComment|
1413 //Opt.ShellSingleComment|
1414 Opt.CSingleComment|
1415 Opt.CMultiComment|
1416 //Opt.SqlSingleComment|
1417 Opt.CPreprocessor|
1418 //Opt.JSRegExp|
1419 //Opt.ShellSigil|
1420 //Opt.CaseInsensitive|
1421 //Opt.SQStringNoEscape|
1422 //Opt.DQStringNoEscape|
1423 //Opt.CougarSingleComment|
1424 //Opt.CougarCharLiteral|
1425 //Opt.MaximumTokens|
1426 //Opt.PascalComments|
1427 //Opt.NumPasHex|
1428 0
1429 );
1430
1431 addToken("_Static_assert", HiInternal);
1432 addToken("static_assert", HiInternal);
1433
1434 addToken("const", HiKeywordHi);
1435 addToken("enum", HiKeywordHi);
1436 addToken("static", HiKeywordHi);
1437 addToken("typedef", HiKeywordHi);
1438
1439 addToken("volatile", HiSpecial);
1440
1441 addToken("struct", HiKeyword);
1442 addToken("union", HiKeyword);
1443 addToken("class", HiKeyword);
1444
1445 addToken("break", HiKeyword);
1446 addToken("case", HiKeyword);
1447 addToken("continue", HiKeyword);
1448 addToken("do", HiKeyword);
1449 addToken("else", HiKeyword);
1450 addToken("extern", HiKeyword);
1451 addToken("for", HiKeyword);
1452 addToken("goto", HiKeyword);
1453 addToken("if", HiKeyword);
1454 addToken("return", HiKeyword);
1455 //addToken("short", HiKeyword);
1456 addToken("sizeof", HiKeyword);
1457 addToken("switch", HiKeyword);
1458 addToken("while", HiKeyword);
1459 addToken("asm", HiKeyword);
1460 addToken("inline", HiKeyword);
1461 addToken("...", HiInternal);
1462 addToken("protected", HiKeyword);
1463 addToken("private", HiKeyword);
1464 addToken("public", HiKeyword);
1465 addToken("default", HiKeyword);
1466 addToken("using", HiKeyword);
1467 addToken("try", HiKeyword);
1468 addToken("catch", HiKeyword);
1469 addToken("throw", HiKeyword);
1470 addToken("virtual", HiKeyword);
1471 addToken("override", HiKeyword);
1472
1473 addToken("true", HiKeyword);
1474 addToken("false", HiKeyword);
1475
1476 addToken("register", HiInternal);
1477
1478 addToken("template", HiKeyword);
1479 addToken("typename", HiKeyword);
1480 addToken("const_cast", HiKeywordHi);
1481 addToken("static_cast", HiKeywordHi);
1482 //addToken("static_assert", HiKeywordHi);
1483 addToken("dynamic_cast", HiKeywordHi);
1484 addToken("operator", HiKeywordHi);
1485
1486 addToken("explicit", HiSpecial);
1487 addToken("mutable", HiSpecial);
1488
1489 addToken("!", HiPunct);
1490 addToken("%", HiPunct);
1491 addToken("&&", HiSpecial);
1492 addToken("&", HiPunct);
1493 addToken("(", HiPunct);
1494 addToken(")", HiPunct);
1495 addToken("*", HiPunct);
1496 addToken("+", HiPunct);
1497 addToken(",", HiPunct);
1498 addToken("-", HiPunct);
1499 addToken("/", HiPunct);
1500 addToken(":", HiPunct);
1501 addToken(";", HiSemi);
1502 addToken("<", HiPunct);
1503 addToken("=", HiPunct);
1504 addToken(">", HiPunct);
1505 addToken("?", HiPunct);
1506 addToken("[", HiPunct);
1507 addToken("]", HiPunct);
1508 addToken("^", HiPunct);
1509 addToken("{", HiPunct);
1510 addToken("||", HiSpecial);
1511 addToken("|", HiPunct);
1512 addToken("}", HiPunct);
1513 addToken("~", HiPunct);
1514 addToken(".", HiPunct);
1515 addToken("->", HiInternal);
1516
1517 addToken("nullptr", HiInternal);
1518 addToken("new", HiInternal);
1519 addToken("delete", HiInternal);
1520 addToken("this", HiInternal);
1521
1522 addToken("void", HiType);
1523 addToken("short", HiType);
1524 addToken("int", HiType);
1525 addToken("long", HiType);
1526 addToken("float", HiType);
1527 addToken("double", HiType);
1528 addToken("char", HiType);
1529 addToken("wchar_t", HiType);
1530 addToken("signed", HiType);
1531 addToken("unsigned", HiType);
1532 addToken("auto", HiType);
1533 addToken("bool", HiType);
1534
1535 addToken("size_t", HiType);
1536 addToken("ssize_t", HiType);
1537 addToken("ptrdiff_t", HiType);
1538 addToken("uptrdiff_t", HiType);
1539 addToken("intptr_t", HiType);
1540 addToken("uintptr_t", HiType);
1541
1542 addToken("int8_t", HiType);
1543 addToken("uint8_t", HiType);
1544 addToken("int16_t", HiType);
1545 addToken("uint16_t", HiType);
1546 addToken("int32_t", HiType);
1547 addToken("uint32_t", HiType);
1548 addToken("int64_t", HiType);
1549 addToken("uint64_t", HiType);
1550
1551 // for I.V.A.N.
1552 //addToken("truth", HiType);
1553
1554 // for SXED
1555 addToken("sxed_bool", HiType);
1556 addToken("sxed_status", HiType);
1557 addToken("SXED_DEBUG", HiInternal);
1558 addToken("SXED_PUBLIC", HiSpecial);
1559 }
1560 }
1561
1562
1563 // ////////////////////////////////////////////////////////////////////////// //
1564 public class EdHiTokensZS : EdHiTokens {
1565 this () {
1566 super(
1567 Opt.Num0b|
1568 Opt.Num0o|
1569 Opt.Num0x|
1570 //Opt.NumAllowUnder|
1571 //Opt.NumAllowSign|
1572 Opt.SQString|
1573 Opt.DQString|
1574 //Opt.BQString|
1575 //Opt.RQString|
1576 //Opt.SQChar|
1577 //Opt.DNestedComment|
1578 //Opt.ShellSingleComment|
1579 Opt.CSingleComment|
1580 Opt.CMultiComment|
1581 //Opt.SqlSingleComment|
1582 Opt.CPreprocessor|
1583 //Opt.JSRegExp|
1584 //Opt.ShellSigil|
1585 Opt.CaseInsensitive|
1586 //Opt.SQStringNoEscape|
1587 //Opt.DQStringNoEscape|
1588 //Opt.CougarSingleComment|
1589 //Opt.CougarCharLiteral|
1590 //Opt.MaximumTokens|
1591 //Opt.PascalComments|
1592 //Opt.NumPasHex|
1593 0
1594 );
1595
1596 addToken("break", HiKeyword);
1597 addToken("case", HiKeyword);
1598 addToken("const", HiKeyword);
1599 addToken("continue", HiKeyword);
1600 addToken("do", HiKeyword);
1601 addToken("else", HiKeyword);
1602 addToken("enum", HiKeyword);
1603 addToken("extern", HiKeyword);
1604 addToken("for", HiKeyword);
1605 addToken("goto", HiKeyword);
1606 addToken("if", HiKeyword);
1607 addToken("return", HiKeyword);
1608 //addToken("short", HiKeyword);
1609 addToken("sizeof", HiKeyword);
1610 addToken("static", HiKeyword);
1611 addToken("struct", HiKeyword);
1612 addToken("switch", HiKeyword);
1613 addToken("typedef", HiKeyword);
1614 addToken("union", HiKeyword);
1615 addToken("volatile", HiKeyword);
1616 addToken("while", HiKeyword);
1617 addToken("asm", HiKeyword);
1618 addToken("inline", HiKeyword);
1619 addToken("...", HiKeyword);
1620 addToken("class", HiKeyword);
1621 addToken("protected", HiKeyword);
1622 addToken("private", HiKeyword);
1623 addToken("public", HiKeyword);
1624 addToken("default", HiKeyword);
1625 addToken("using", HiKeyword);
1626 addToken("try", HiKeyword);
1627 addToken("catch", HiKeyword);
1628 addToken("throw", HiKeyword);
1629 addToken("virtual", HiKeyword);
1630 addToken("override", HiKeyword);
1631
1632 addToken("true", HiKeyword);
1633 addToken("false", HiKeyword);
1634
1635 addToken("!", HiPunct);
1636 addToken("%", HiPunct);
1637 addToken("&&", HiSpecial);
1638 addToken("&", HiPunct);
1639 addToken("(", HiPunct);
1640 addToken(")", HiPunct);
1641 addToken("*", HiPunct);
1642 addToken("+", HiPunct);
1643 addToken(",", HiPunct);
1644 addToken("-", HiPunct);
1645 addToken("/", HiPunct);
1646 addToken(":", HiPunct);
1647 addToken(";", HiSemi);
1648 addToken("<", HiPunct);
1649 addToken("=", HiPunct);
1650 addToken(">", HiPunct);
1651 addToken("?", HiPunct);
1652 addToken("[", HiPunct);
1653 addToken("]", HiPunct);
1654 addToken("^", HiPunct);
1655 addToken("{", HiPunct);
1656 addToken("||", HiSpecial);
1657 addToken("|", HiPunct);
1658 addToken("}", HiPunct);
1659 addToken("~", HiPunct);
1660 addToken(".", HiPunct);
1661 addToken("->", HiInternal);
1662
1663 addToken("null", HiInternal);
1664 addToken("new", HiInternal);
1665 addToken("self", HiInternal);
1666 addToken("super", HiInternal);
1667
1668 addToken("void", HiType);
1669 addToken("short", HiType);
1670 addToken("int", HiType);
1671 addToken("long", HiType);
1672 addToken("float", HiType);
1673 addToken("double", HiType);
1674 addToken("char", HiType);
1675 addToken("let", HiType);
1676 addToken("bool", HiType);
1677 addToken("string", HiType);
1678 addToken("name", HiType);
1679 }
1680 }
1681
1682
1683 // ////////////////////////////////////////////////////////////////////////// //
1684 public class EdHiTokensVC : EdHiTokens {
1685 this () {
1686 super(
1687 Opt.Num0b|
1688 Opt.Num0o|
1689 Opt.Num0x|
1690 Opt.NumAllowUnder|
1691 //Opt.NumAllowSign|
1692 Opt.SQString|
1693 Opt.DQString|
1694 //Opt.BQString|
1695 //Opt.RQString|
1696 //Opt.SQChar|
1697 Opt.DNestedComment|
1698 //Opt.ShellSingleComment|
1699 Opt.CSingleComment|
1700 Opt.CMultiComment|
1701 //Opt.SqlSingleComment|
1702 Opt.CPreprocessor|
1703 //Opt.JSRegExp|
1704 //Opt.ShellSigil|
1705 //Opt.CaseInsensitive|
1706 //Opt.SQStringNoEscape|
1707 //Opt.DQStringNoEscape|
1708 //Opt.CougarSingleComment|
1709 //Opt.CougarCharLiteral|
1710 //Opt.MaximumTokens|
1711 //Opt.PascalComments|
1712 //Opt.NumPasHex|
1713 0
1714 );
1715
1716 addToken("assert", HiKeywordHi);
1717
1718 addToken("alias", HiKeyword);
1719 addToken("auto", HiKeyword);
1720 addToken("bitenum", HiKeyword);
1721 addToken("break", HiKeyword);
1722 addToken("case", HiKeyword);
1723 addToken("cast", HiKeywordHi);
1724 addToken("class", HiKeywordHi);
1725 addToken("const", HiKeywordHi);
1726 addToken("continue", HiKeyword);
1727 addToken("default", HiKeyword);
1728 addToken("delegate", HiKeyword);
1729 addToken("do", HiKeyword);
1730 addToken("else", HiKeyword);
1731 addToken("enum", HiKeyword);
1732 addToken("for", HiKeyword);
1733 addToken("foreach", HiKeyword);
1734 addToken("get", HiKeywordHi);
1735 addToken("goto", HiKeyword);
1736 addToken("if", HiKeyword);
1737 addToken("import", HiInternal);
1738 addToken("inline", HiInternal); // not yet, so internal
1739 addToken("isa", HiSpecial);
1740 addToken("return", HiKeyword);
1741 addToken("scope", HiInternal); // not yet, so internal
1742 addToken("set", HiKeywordHi);
1743 addToken("sizeof", HiInternal); // not yet, so internal
1744 addToken("struct", HiKeyword);
1745 addToken("switch", HiKeyword);
1746 addToken("while", HiKeyword);
1747
1748 addToken("abstract", HiInternal);
1749 addToken("final", HiInternal);
1750 addToken("iterator", HiInternal);
1751 addToken("native", HiInternal);
1752 addToken("override", HiKeyword);
1753 addToken("private", HiKeyword);
1754 addToken("protected", HiKeyword);
1755 addToken("public", HiKeyword);
1756 addToken("readonly", HiKeyword);
1757 addToken("spawner", HiKeywordHi);
1758 addToken("static", HiKeyword);
1759
1760 addToken("reliable", HiKeywordHi);
1761 addToken("replication", HiKeywordHi);
1762 addToken("states", HiKeywordHi);
1763 addToken("transient", HiKeywordHi);
1764 addToken("unreliable", HiKeywordHi);
1765 addToken("defaultproperties", HiKeywordHi);
1766
1767
1768 addToken("true", HiKeyword);
1769 addToken("false", HiKeyword);
1770
1771 //addToken("none", HiUDA);
1772
1773 addToken("ref", HiSpecial);
1774 addToken("out", HiSpecial);
1775 addToken("optional", HiSpecial);
1776
1777 addToken("...", HiKeywordHi);
1778 addToken("->", HiInternal);
1779 addToken("&&", HiSpecial);
1780 addToken("||", HiSpecial);
1781 addToken("..", HiPunct);
1782 addToken("!", HiPunct);
1783 addToken("%", HiPunct);
1784 addToken("&", HiPunct);
1785 addToken("$", HiSpecial);
1786 addToken("(", HiPunct);
1787 addToken(")", HiPunct);
1788 addToken("*", HiPunct);
1789 addToken("+", HiPunct);
1790 addToken(",", HiPunct);
1791 addToken("-", HiPunct);
1792 addToken("/", HiPunct);
1793 addToken(":", HiPunct);
1794 addToken(";", HiSemi);
1795 addToken("<", HiPunct);
1796 addToken("=", HiPunct);
1797 addToken(">", HiPunct);
1798 addToken("?", HiPunct);
1799 addToken("[", HiPunct);
1800 addToken("]", HiPunct);
1801 addToken("^", HiPunct);
1802 addToken("{", HiPunct);
1803 addToken("|", HiPunct);
1804 addToken("}", HiPunct);
1805 addToken("~", HiPunct);
1806 addToken(".", HiPunct);
1807
1808 addToken("NULL", HiInternal);
1809 addToken("null", HiInternal);
1810 addToken("nullptr", HiInternal);
1811 addToken("none", HiInternal);
1812 addToken("self", HiInternal);
1813 addToken("delete", HiInternal);
1814
1815
1816 addToken("void", HiType);
1817 addToken("int", HiType);
1818 addToken("float", HiType);
1819 addToken("bool", HiType);
1820 addToken("string", HiType);
1821 addToken("name", HiType);
1822 addToken("vector", HiType);
1823 addToken("ubyte", HiType);
1824 addToken("array", HiType);
1825 addToken("state", HiType);
1826 addToken("dictionary", HiType);
1827
1828 // reserved, unused
1829 addToken("byte", HiInternal);
1830 addToken("uint", HiInternal);
1831 }
1832 }
1833
1834
1835 // ////////////////////////////////////////////////////////////////////////// //
1836 public class EdHiTokensShell : EdHiTokens {
1837 this () {
1838 super(
1839 //Opt.Num0b|
1840 //Opt.Num0o|
1841 //Opt.Num0x|
1842 //Opt.NumAllowUnder|
1843 //Opt.NumAllowSign|
1844 Opt.SQString|
1845 Opt.DQString|
1846 Opt.BQString|
1847 //Opt.RQString|
1848 //Opt.SQChar|
1849 //Opt.DNestedComment|
1850 Opt.ShellSingleComment|
1851 //Opt.CSingleComment|
1852 //Opt.CMultiComment|
1853 //Opt.SqlSingleComment|
1854 //Opt.CPreprocessor|
1855 //Opt.JSRegExp|
1856 Opt.ShellSigil|
1857 //Opt.CaseInsensitive|
1858 Opt.SQStringNoEscape|
1859 //Opt.DQStringNoEscape|
1860 //Opt.CougarSingleComment|
1861 //Opt.CougarCharLiteral|
1862 //Opt.MaximumTokens|
1863 //Opt.PascalComments|
1864 //Opt.NumPasHex|
1865 0
1866 );
1867
1868 addToken("{", HiPunct);
1869 addToken("}", HiPunct);
1870
1871 addToken("$*", HiInternal);
1872 addToken("$@", HiInternal);
1873 addToken("$#", HiInternal);
1874 addToken("$?", HiInternal);
1875 addToken("$-", HiInternal);
1876 addToken("$$", HiInternal);
1877 addToken("$!", HiInternal);
1878 addToken("$_", HiInternal);
1879
1880 addToken("2>&1", HiInternal);
1881 addToken("2>&2", HiInternal);
1882 addToken("2>", HiInternal);
1883 addToken("1>", HiInternal);
1884
1885 addToken(";", HiSemi);
1886
1887 addToken("break", HiKeyword);
1888 addToken("case", HiKeyword);
1889 addToken("clear", HiKeyword);
1890 addToken("continue", HiKeyword);
1891 addToken("declare", HiKeyword);
1892 addToken("done", HiKeyword);
1893 addToken("do", HiKeyword);
1894 addToken("elif", HiKeyword);
1895 addToken("else", HiKeyword);
1896 addToken("esac", HiKeyword);
1897 addToken("exit", HiKeyword);
1898 addToken("export", HiKeyword);
1899 addToken("fi", HiKeyword);
1900 addToken("for", HiKeyword);
1901 addToken("getopts", HiKeyword);
1902 addToken("if", HiKeyword);
1903 addToken("in", HiKeyword);
1904 addToken("read", HiKeyword);
1905 addToken("return", HiKeyword);
1906 addToken("select", HiKeyword);
1907 addToken("shift", HiKeyword);
1908 addToken("source", HiKeyword);
1909 addToken("then", HiKeyword);
1910 addToken("trap", HiKeyword);
1911 addToken("until", HiKeyword);
1912 addToken("unset", HiKeyword);
1913 addToken("wait", HiKeyword);
1914 addToken("while", HiKeyword);
1915 }
1916 }
1917
1918
1919 // ////////////////////////////////////////////////////////////////////////// //
1920 public class EdHiTokensFrag : EdHiTokens {
1921 this () {
1922 super(
1923 Opt.Num0b|
1924 Opt.Num0o|
1925 Opt.Num0x|
1926 //Opt.NumAllowUnder|
1927 //Opt.NumAllowSign|
1928 //Opt.SQString|
1929 Opt.DQString|
1930 //Opt.BQString|
1931 //Opt.RQString|
1932 Opt.SQChar|
1933 //Opt.DNestedComment|
1934 //Opt.ShellSingleComment|
1935 Opt.CSingleComment|
1936 Opt.CMultiComment|
1937 //Opt.SqlSingleComment|
1938 Opt.CPreprocessor|
1939 //Opt.JSRegExp|
1940 //Opt.ShellSigil|
1941 //Opt.CaseInsensitive|
1942 //Opt.SQStringNoEscape|
1943 //Opt.DQStringNoEscape|
1944 //Opt.CougarSingleComment|
1945 //Opt.CougarCharLiteral|
1946 //Opt.MaximumTokens|
1947 //Opt.PascalComments|
1948 //Opt.NumPasHex|
1949 0
1950 );
1951
1952 addToken("break", HiKeyword);
1953 addToken("case", HiKeyword);
1954 addToken("const", HiKeyword);
1955 addToken("continue", HiKeyword);
1956 addToken("do", HiKeyword);
1957 addToken("else", HiKeyword);
1958 addToken("enum", HiKeyword);
1959 addToken("for", HiKeyword);
1960 addToken("goto", HiKeyword);
1961 addToken("if", HiKeyword);
1962 addToken("return", HiKeyword);
1963 addToken("sizeof", HiKeyword);
1964 addToken("struct", HiKeyword);
1965 addToken("switch", HiKeyword);
1966 addToken("union", HiKeyword);
1967 addToken("while", HiKeyword);
1968
1969 addToken("!", HiPunct);
1970 addToken("%", HiPunct);
1971 addToken("&&", HiSpecial);
1972 addToken("&", HiPunct);
1973 addToken("(", HiPunct);
1974 addToken(")", HiPunct);
1975 addToken("*", HiPunct);
1976 addToken("+", HiPunct);
1977 addToken(",", HiPunct);
1978 addToken("-", HiPunct);
1979 addToken("/", HiPunct);
1980 addToken(":", HiPunct);
1981 addToken(";", HiSemi);
1982 addToken("<", HiPunct);
1983 addToken("=", HiPunct);
1984 addToken(">", HiPunct);
1985 addToken("?", HiPunct);
1986 addToken("[", HiPunct);
1987 addToken("]", HiPunct);
1988 addToken("^", HiPunct);
1989 addToken("{", HiPunct);
1990 addToken("||", HiSpecial);
1991 addToken("|", HiPunct);
1992 addToken("}", HiPunct);
1993 addToken("~", HiPunct);
1994 addToken(".", HiPunct);
1995 addToken("->", HiInternal);
1996
1997 addToken("uniform", HiInternal);
1998 addToken("varying", HiInternal);
1999 addToken("attribute", HiInternal);
2000
2001 addToken("precision", HiInternal);
2002
2003 addToken("gl_FragColor", HiInternal);
2004 addToken("gl_FragData", HiInternal);
2005 addToken("gl_FrontFacing", HiInternal);
2006 addToken("gl_PointCoord", HiInternal);
2007 addToken("gl_PointSize", HiInternal);
2008 addToken("gl_Position", HiInternal);
2009 addToken("gl_MaxVertexAttribs", HiInternal);
2010 addToken("gl_MaxVertexUniformVectors", HiInternal);
2011 addToken("gl_MaxVaryingVectors", HiInternal);
2012 addToken("gl_MaxVertexTextureImageUnits", HiInternal);
2013 addToken("gl_MaxCombinedTextureImageUnits", HiInternal);
2014 addToken("gl_MaxFragmentUniformVectors", HiInternal);
2015 addToken("gl_MaxDrawBuffers", HiInternal);
2016 addToken("gl_Vertex", HiInternal);
2017 addToken("gl_Normal", HiInternal);
2018 addToken("gl_Color", HiInternal);
2019 addToken("gl_FogCoodr", HiInternal);
2020 addToken("gl_MultiTexCoord0", HiInternal);
2021 addToken("gl_MultiTexCoord1", HiInternal);
2022 addToken("gl_MultiTexCoord2", HiInternal);
2023 addToken("gl_MultiTexCoord3", HiInternal);
2024 addToken("gl_MultiTexCoord4", HiInternal);
2025 addToken("gl_MultiTexCoord5", HiInternal);
2026 addToken("gl_MultiTexCoord6", HiInternal);
2027 addToken("gl_MultiTexCoord7", HiInternal);
2028
2029 addToken("layout", HiInternal);
2030 addToken("location", HiInternal);
2031
2032 addToken("void", HiType);
2033 addToken("int", HiType);
2034 addToken("bool", HiType);
2035 addToken("unsigneg", HiType);
2036 addToken("float", HiType);
2037 addToken("double", HiType);
2038 addToken("vec1", HiType);
2039 addToken("vec2", HiType);
2040 addToken("vec3", HiType);
2041 addToken("vec4", HiType);
2042 addToken("bvec1", HiType);
2043 addToken("bvec2", HiType);
2044 addToken("bvec3", HiType);
2045 addToken("bvec4", HiType);
2046 addToken("ivec1", HiType);
2047 addToken("ivec2", HiType);
2048 addToken("ivec3", HiType);
2049 addToken("ivec4", HiType);
2050 addToken("uvec1", HiType);
2051 addToken("uvec2", HiType);
2052 addToken("uvec3", HiType);
2053 addToken("uvec4", HiType);
2054 addToken("dvec1", HiType);
2055 addToken("dvec2", HiType);
2056 addToken("dvec3", HiType);
2057 addToken("dvec4", HiType);
2058
2059 addToken("in", HiSpecial);
2060 addToken("out", HiSpecial);
2061 addToken("inout", HiSpecial);
2062 }
2063 }
2064
2065
2066 // ////////////////////////////////////////////////////////////////////////// //
2067 public class EdHiTokensSQL : EdHiTokens {
2068 this () {
2069 super(
2070 Opt.Num0b|
2071 Opt.Num0o|
2072 Opt.Num0x|
2073 //Opt.NumAllowUnder|
2074 //Opt.NumAllowSign|
2075 Opt.SQString|
2076 Opt.DQString|
2077 //Opt.BQString|
2078 //Opt.RQString|
2079 //Opt.SQChar|
2080 //Opt.DNestedComment|
2081 //Opt.ShellSingleComment|
2082 //Opt.CSingleComment|
2083 Opt.SqlSingleComment|
2084 Opt.CMultiComment|
2085 //Opt.CPreprocessor|
2086 //Opt.JSRegExp|
2087 //Opt.ShellSigil|
2088 Opt.CaseInsensitive|
2089 Opt.SQStringNoEscape|
2090 Opt.DQStringNoEscape|
2091 //Opt.CougarSingleComment|
2092 //Opt.CougarCharLiteral|
2093 //Opt.MaximumTokens|
2094 //Opt.PascalComments|
2095 //Opt.NumPasHex|
2096 0
2097 );
2098
2099 addToken("abort", HiKeyword);
2100 addToken("absolute", HiKeyword);
2101 addToken("action", HiKeyword);
2102 addToken("ada", HiKeyword);
2103 addToken("add", HiKeyword);
2104 addToken("all", HiKeyword);
2105 addToken("allocate", HiKeyword);
2106 addToken("alter", HiKeyword);
2107 addToken("and", HiKeyword);
2108 addToken("any", HiKeyword);
2109 addToken("are", HiKeyword);
2110 addToken("as", HiKeyword);
2111 addToken("asc", HiKeyword);
2112 addToken("assertion", HiKeyword);
2113 addToken("at", HiKeyword);
2114 addToken("authorization", HiKeyword);
2115 addToken("auto_increment", HiKeyword);
2116 addToken("begin", HiKeyword);
2117 addToken("between", HiKeyword);
2118 addToken("bigint", HiKeyword);
2119 addToken("bit", HiKeyword);
2120 addToken("bit_length", HiKeyword);
2121 addToken("blob", HiKeyword);
2122 addToken("both", HiKeyword);
2123 addToken("by", HiKeyword);
2124 addToken("cascade", HiKeyword);
2125 addToken("cascaded", HiKeyword);
2126 addToken("case", HiKeyword);
2127 addToken("cast", HiKeyword);
2128 addToken("catalog", HiKeyword);
2129 addToken("char", HiKeyword);
2130 addToken("char_length", HiKeyword);
2131 addToken("character", HiKeyword);
2132 addToken("character_length", HiKeyword);
2133 addToken("check", HiKeyword);
2134 addToken("close", HiKeyword);
2135 addToken("coalesce", HiKeyword);
2136 addToken("collate", HiKeyword);
2137 addToken("collation", HiKeyword);
2138 addToken("column", HiKeyword);
2139 addToken("commit", HiKeyword);
2140 addToken("compile", HiKeyword);
2141 addToken("connect", HiKeyword);
2142 addToken("connection", HiKeyword);
2143 addToken("constraint", HiKeyword);
2144 addToken("constraint", HiKeyword);
2145 addToken("constraints", HiKeyword);
2146 addToken("continue", HiKeyword);
2147 addToken("copy", HiKeyword);
2148 addToken("corresponding", HiKeyword);
2149 addToken("create", HiKeyword);
2150 addToken("cross", HiKeyword);
2151 addToken("current", HiKeyword);
2152 addToken("current_date", HiKeyword);
2153 addToken("current_time", HiKeyword);
2154 addToken("current_timestamp", HiKeyword);
2155 addToken("current_user", HiKeyword);
2156 addToken("cursor", HiKeyword);
2157 addToken("database", HiKeyword);
2158 addToken("date", HiKeyword);
2159 addToken("datetime", HiKeyword);
2160 addToken("day", HiKeyword);
2161 addToken("deallocate", HiKeyword);
2162 addToken("dec", HiKeyword);
2163 addToken("decimal", HiKeyword);
2164 addToken("declare", HiKeyword);
2165 addToken("default", HiKeyword);
2166 addToken("deferrable", HiKeyword);
2167 addToken("deferred", HiKeyword);
2168 addToken("delete", HiKeyword);
2169 addToken("desc", HiKeyword);
2170 addToken("describe", HiKeyword);
2171 addToken("descriptor", HiKeyword);
2172 addToken("diagnostics", HiKeyword);
2173 addToken("disconnect", HiKeyword);
2174 addToken("distinct", HiKeyword);
2175 addToken("domain", HiKeyword);
2176 addToken("double", HiKeyword);
2177 addToken("drop", HiKeyword);
2178 addToken("else", HiKeyword);
2179 addToken("encoding", HiKeyword);
2180 addToken("end", HiKeyword);
2181 addToken("end-exec", HiKeyword);
2182 addToken("enum", HiKeyword);
2183 addToken("escape", HiKeyword);
2184 addToken("except", HiKeyword);
2185 addToken("exception", HiKeyword);
2186 addToken("exec", HiKeyword);
2187 addToken("execute", HiKeyword);
2188 addToken("exists", HiKeyword);
2189 addToken("external", HiKeyword);
2190 addToken("extract", HiKeyword);
2191 addToken("false", HiKeyword);
2192 addToken("fetch", HiKeyword);
2193 addToken("first", HiKeyword);
2194 addToken("float", HiKeyword);
2195 addToken("for", HiKeyword);
2196 addToken("foreign", HiKeyword);
2197 addToken("fortran", HiKeyword);
2198 addToken("found", HiKeyword);
2199 addToken("from", HiKeyword);
2200 addToken("full", HiKeyword);
2201 addToken("get", HiKeyword);
2202 addToken("global", HiKeyword);
2203 addToken("go", HiKeyword);
2204 addToken("goto", HiKeyword);
2205 addToken("grant", HiKeyword);
2206 addToken("group", HiKeyword);
2207 addToken("having", HiKeyword);
2208 addToken("hour", HiKeyword);
2209 addToken("identity", HiKeyword);
2210 addToken("if", HiKeyword);
2211 addToken("immediate", HiKeyword);
2212 addToken("in", HiKeyword);
2213 addToken("include", HiKeyword);
2214 addToken("index", HiKeyword);
2215 addToken("indicator", HiKeyword);
2216 addToken("initially", HiKeyword);
2217 addToken("inner", HiKeyword);
2218 addToken("input", HiKeyword);
2219 addToken("insensitive", HiKeyword);
2220 addToken("insert", HiKeyword);
2221 addToken("int", HiKeyword);
2222 addToken("integer", HiKeyword);
2223 addToken("intersect", HiKeyword);
2224 addToken("interval", HiKeyword);
2225 addToken("into", HiKeyword);
2226 addToken("is", HiKeyword);
2227 addToken("isolation", HiKeyword);
2228 addToken("join", HiKeyword);
2229 addToken("key", HiKeyword);
2230 addToken("key", HiKeyword);
2231 addToken("language", HiKeyword);
2232 addToken("last", HiKeyword);
2233 addToken("leading", HiKeyword);
2234 addToken("left", HiKeyword);
2235 addToken("level", HiKeyword);
2236 addToken("like", HiKeyword);
2237 addToken("local", HiKeyword);
2238 addToken("lock", HiKeyword);
2239 addToken("longblob", HiKeyword);
2240 addToken("longtext", HiKeyword);
2241 addToken("loop", HiKeyword);
2242 addToken("match", HiKeyword);
2243 addToken("mediumblob", HiKeyword);
2244 addToken("mediumint", HiKeyword);
2245 addToken("mediumtext", HiKeyword);
2246 addToken("merge", HiKeyword);
2247 addToken("minute", HiKeyword);
2248 addToken("minus", HiKeyword);
2249 addToken("module", HiKeyword);
2250 addToken("month", HiKeyword);
2251 addToken("names", HiKeyword);
2252 addToken("national", HiKeyword);
2253 addToken("natural", HiKeyword);
2254 addToken("nchar", HiKeyword);
2255 addToken("next", HiKeyword);
2256 addToken("no", HiKeyword);
2257 addToken("none", HiKeyword);
2258 addToken("not", HiKeyword);
2259 addToken("null", HiKeyword);
2260 addToken("nullif", HiKeyword);
2261 addToken("numeric", HiKeyword);
2262 addToken("octet_length", HiKeyword);
2263 addToken("of", HiKeyword);
2264 addToken("offline", HiKeyword);
2265 addToken("on", HiKeyword);
2266 addToken("online", HiKeyword);
2267 addToken("only", HiKeyword);
2268 addToken("open", HiKeyword);
2269 addToken("option", HiKeyword);
2270 addToken("or", HiKeyword);
2271 addToken("order", HiKeyword);
2272 addToken("outer", HiKeyword);
2273 addToken("output", HiKeyword);
2274 addToken("overlaps", HiKeyword);
2275 addToken("pad", HiKeyword);
2276 addToken("partial", HiKeyword);
2277 addToken("pascal", HiKeyword);
2278 addToken("position", HiKeyword);
2279 addToken("precision", HiKeyword);
2280 addToken("prepare", HiKeyword);
2281 addToken("preserve", HiKeyword);
2282 addToken("primary", HiKeyword);
2283 addToken("primary", HiKeyword);
2284 addToken("prior", HiKeyword);
2285 addToken("privileges", HiKeyword);
2286 addToken("procedure", HiKeyword);
2287 addToken("public", HiKeyword);
2288 addToken("read", HiKeyword);
2289 addToken("real", HiKeyword);
2290 addToken("rebuild", HiKeyword);
2291 addToken("references", HiKeyword);
2292 addToken("relative", HiKeyword);
2293 addToken("replace", HiKeyword);
2294 addToken("restrict", HiKeyword);
2295 addToken("revoke", HiKeyword);
2296 addToken("right", HiKeyword);
2297 addToken("rollback", HiKeyword);
2298 addToken("rows", HiKeyword);
2299 addToken("schema", HiKeyword);
2300 addToken("scroll", HiKeyword);
2301 addToken("second", HiKeyword);
2302 addToken("section", HiKeyword);
2303 addToken("select", HiKeyword);
2304 addToken("sequence", HiKeyword);
2305 addToken("session", HiKeyword);
2306 addToken("session_user", HiKeyword);
2307 addToken("set", HiKeyword);
2308 addToken("size", HiKeyword);
2309 addToken("smallint", HiKeyword);
2310 addToken("some", HiKeyword);
2311 addToken("space", HiKeyword);
2312 addToken("sql", HiKeyword);
2313 addToken("sqlca", HiKeyword);
2314 addToken("sqlstate", HiKeyword);
2315 addToken("sqlwarning", HiKeyword);
2316 addToken("substring", HiKeyword);
2317 addToken("system_user", HiKeyword);
2318 addToken("table", HiKeyword);
2319 addToken("tablespace", HiKeyword);
2320 addToken("template", HiKeyword);
2321 addToken("temporary", HiKeyword);
2322 addToken("text", HiKeyword);
2323 addToken("then", HiKeyword);
2324 addToken("time", HiKeyword);
2325 addToken("truncate", HiKeyword);
2326 addToken("timestamp", HiKeyword);
2327 addToken("timezone_hour", HiKeyword);
2328 addToken("timezone_minute", HiKeyword);
2329 addToken("tinyblob", HiKeyword);
2330 addToken("tinyint", HiKeyword);
2331 addToken("tinytext", HiKeyword);
2332 addToken("to", HiKeyword);
2333 addToken("trailing", HiKeyword);
2334 addToken("transaction", HiKeyword);
2335 addToken("translation", HiKeyword);
2336 addToken("trigger", HiKeyword);
2337 addToken("trim", HiKeyword);
2338 addToken("true", HiKeyword);
2339 addToken("type", HiKeyword);
2340 addToken("union", HiKeyword);
2341 addToken("unique", HiKeyword);
2342 addToken("unknown", HiKeyword);
2343 addToken("unsigned", HiKeyword);
2344 addToken("update", HiKeyword);
2345 addToken("usage", HiKeyword);
2346 addToken("use", HiKeyword);
2347 addToken("user", HiKeyword);
2348 addToken("using", HiKeyword);
2349 addToken("value", HiKeyword);
2350 addToken("values", HiKeyword);
2351 addToken("varchar", HiKeyword);
2352 addToken("varying", HiKeyword);
2353 addToken("view", HiKeyword);
2354 addToken("when", HiKeyword);
2355 addToken("whenever", HiKeyword);
2356 addToken("where", HiKeyword);
2357 addToken("while", HiKeyword);
2358 addToken("with", HiKeyword);
2359 addToken("work", HiKeyword);
2360 addToken("write", HiKeyword);
2361 addToken("year", HiKeyword);
2362 addToken("zone", HiKeyword);
2363
2364 // postgres
2365 addToken("cache", HiKeywordHi);
2366 addToken("increment", HiKeywordHi);
2367 addToken("maxvalue", HiKeywordHi);
2368 addToken("minvalue", HiKeywordHi);
2369 addToken("start", HiKeywordHi);
2370
2371 addToken(">", HiPunct);
2372 addToken("<", HiPunct);
2373 addToken("+", HiPunct);
2374 addToken("-", HiPunct);
2375 addToken("*", HiPunct);
2376 addToken("/", HiPunct);
2377 addToken("%", HiPunct);
2378 addToken("=", HiPunct);
2379 addToken("(", HiPunct);
2380 addToken(")", HiPunct);
2381 addToken(",", HiPunct);
2382 addToken(";", HiPunct);
2383 addToken(".", HiPunct); // was white
2384 }
2385 }
2386
2387
2388 // ////////////////////////////////////////////////////////////////////////// //
2389 public class EdHiTokensHtml : EdHiTokens {
2390 this () {
2391 super(
2392 //Opt.Num0b|
2393 //Opt.Num0o|
2394 //Opt.Num0x|
2395 //Opt.NumAllowUnder|
2396 //Opt.NumAllowSign|
2397 Opt.SQString|
2398 Opt.DQString|
2399 //Opt.BQString|
2400 //Opt.RQString|
2401 //Opt.SQChar|
2402 //Opt.DNestedComment|
2403 //Opt.ShellSingleComment|
2404 //Opt.CSingleComment|
2405 //Opt.CMultiComment|
2406 //Opt.SqlSingleComment|
2407 //Opt.CPreprocessor|
2408 //Opt.JSRegExp|
2409 //Opt.ShellSigil|
2410 Opt.CaseInsensitive|
2411 Opt.SQStringNoEscape|
2412 Opt.DQStringNoEscape|
2413 //Opt.CougarSingleComment|
2414 //Opt.CougarCharLiteral|
2415 //Opt.MaximumTokens|
2416 //Opt.PascalComments|
2417 //Opt.NumPasHex|
2418 0
2419 );
2420
2421 addToken("a", HiSpecial);
2422 addToken("abbr", HiSpecial);
2423 addToken("address", HiSpecial);
2424 addToken("applet", HiSpecial);
2425 addToken("area", HiSpecial);
2426 addToken("article", HiSpecial);
2427 addToken("aside", HiSpecial);
2428 addToken("audio", HiSpecial);
2429 addToken("b", HiSpecial);
2430 addToken("base", HiSpecial);
2431 addToken("basefont", HiSpecial);
2432 addToken("bdi", HiSpecial);
2433 addToken("bdo", HiSpecial);
2434 addToken("bgsound", HiSpecial);
2435 addToken("big", HiSpecial);
2436 addToken("blockquote", HiSpecial);
2437 addToken("body", HiSpecial);
2438 addToken("br", HiSpecial);
2439 addToken("button", HiSpecial);
2440 addToken("canvas", HiSpecial);
2441 addToken("caption", HiSpecial);
2442 addToken("center", HiSpecial);
2443 addToken("cite", HiSpecial);
2444 addToken("code", HiSpecial);
2445 addToken("col", HiSpecial);
2446 addToken("colgroup", HiSpecial);
2447 addToken("command", HiSpecial);
2448 addToken("data", HiSpecial);
2449 addToken("datalist", HiSpecial);
2450 addToken("dd", HiSpecial);
2451 addToken("del", HiSpecial);
2452 addToken("details", HiSpecial);
2453 addToken("dfn", HiSpecial);
2454 addToken("dialog", HiSpecial);
2455 addToken("dir", HiSpecial);
2456 addToken("div", HiSpecial);
2457 addToken("dl", HiSpecial);
2458 addToken("dt", HiSpecial);
2459 addToken("em", HiSpecial);
2460 addToken("embed", HiSpecial);
2461 addToken("fieldset", HiSpecial);
2462 addToken("figcaption", HiSpecial);
2463 addToken("figure", HiSpecial);
2464 addToken("font", HiSpecial);
2465 addToken("footer", HiSpecial);
2466 addToken("form", HiSpecial);
2467 addToken("frame", HiSpecial);
2468 addToken("frameset", HiSpecial);
2469 addToken("h1", HiSpecial);
2470 addToken("h2", HiSpecial);
2471 addToken("h3", HiSpecial);
2472 addToken("h4", HiSpecial);
2473 addToken("h5", HiSpecial);
2474 addToken("h6", HiSpecial);
2475 addToken("head", HiSpecial);
2476 addToken("header", HiSpecial);
2477 addToken("hgroup", HiSpecial);
2478 addToken("hr", HiSpecial);
2479 addToken("html", HiSpecial);
2480 addToken("i", HiSpecial);
2481 addToken("iframe", HiSpecial);
2482 addToken("image", HiSpecial);
2483 addToken("img", HiSpecial);
2484 addToken("input", HiSpecial);
2485 addToken("ins", HiSpecial);
2486 addToken("kbd", HiSpecial);
2487 addToken("keygen", HiSpecial);
2488 addToken("label", HiSpecial);
2489 addToken("legend", HiSpecial);
2490 addToken("li", HiSpecial);
2491 addToken("link", HiSpecial);
2492 addToken("listing", HiSpecial);
2493 addToken("main", HiSpecial);
2494 addToken("map", HiSpecial);
2495 addToken("mark", HiSpecial);
2496 addToken("marquee", HiSpecial);
2497 addToken("math", HiSpecial);
2498 addToken("mathml", HiSpecial);
2499 addToken("menu", HiSpecial);
2500 addToken("menuitem", HiSpecial);
2501 addToken("meta", HiSpecial);
2502 addToken("meter", HiSpecial);
2503 addToken("nav", HiSpecial);
2504 addToken("nobr", HiSpecial);
2505 addToken("noembed", HiSpecial);
2506 addToken("noframes", HiSpecial);
2507 addToken("noscript", HiSpecial);
2508 addToken("object", HiSpecial);
2509 addToken("ol", HiSpecial);
2510 addToken("optgroup", HiSpecial);
2511 addToken("option", HiSpecial);
2512 addToken("output", HiSpecial);
2513 addToken("p", HiSpecial);
2514 addToken("param", HiSpecial);
2515 addToken("picture", HiSpecial);
2516 addToken("plaintext", HiSpecial);
2517 addToken("pre", HiSpecial);
2518 addToken("progress", HiSpecial);
2519 addToken("q", HiSpecial);
2520 addToken("rb", HiSpecial);
2521 addToken("rp", HiSpecial);
2522 addToken("rt", HiSpecial);
2523 addToken("rtc", HiSpecial);
2524 addToken("ruby", HiSpecial);
2525 addToken("s", HiSpecial);
2526 addToken("samp", HiSpecial);
2527 addToken("script", HiSpecial);
2528 addToken("section", HiSpecial);
2529 addToken("select", HiSpecial);
2530 addToken("slot", HiSpecial);
2531 addToken("small", HiSpecial);
2532 addToken("source", HiSpecial);
2533 addToken("span", HiSpecial);
2534 addToken("strike", HiSpecial);
2535 addToken("strong", HiSpecial);
2536 addToken("style", HiSpecial);
2537 addToken("sub", HiSpecial);
2538 addToken("summary", HiSpecial);
2539 addToken("sup", HiSpecial);
2540 addToken("svg", HiSpecial);
2541 addToken("table", HiSpecial);
2542 addToken("tbody", HiSpecial);
2543 addToken("td", HiSpecial);
2544 addToken("template", HiSpecial);
2545 addToken("textarea", HiSpecial);
2546 addToken("tfoot", HiSpecial);
2547 addToken("th", HiSpecial);
2548 addToken("thead", HiSpecial);
2549 addToken("time", HiSpecial);
2550 addToken("title", HiSpecial);
2551 addToken("tr", HiSpecial);
2552 addToken("track", HiSpecial);
2553 addToken("tt", HiSpecial);
2554 addToken("u", HiSpecial);
2555 addToken("ul", HiSpecial);
2556 addToken("var", HiSpecial);
2557 addToken("video", HiSpecial);
2558 addToken("wbr", HiSpecial);
2559 addToken("xmp", HiSpecial);
2560 }
2561 }
2562
2563
2564 // ////////////////////////////////////////////////////////////////////////// //
2565 public class EdHiTokensCougar : EdHiTokens {
2566 this () {
2567 super(
2568 //Opt.Num0b|
2569 //Opt.Num0o|
2570 //Opt.Num0x|
2571 //Opt.NumAllowUnder|
2572 //Opt.NumAllowSign|
2573 //Opt.SQString|
2574 Opt.DQString|
2575 //Opt.BQString|
2576 //Opt.RQString|
2577 //Opt.SQChar|
2578 Opt.DNestedComment|
2579 //Opt.ShellSingleComment|
2580 Opt.CSingleComment|
2581 Opt.CMultiComment|
2582 //Opt.SqlSingleComment|
2583 //Opt.CPreprocessor|
2584 //Opt.JSRegExp|
2585 Opt.ShellSigil|
2586 //Opt.CaseInsensitive|
2587 //Opt.SQStringNoEscape|
2588 //Opt.DQStringNoEscape|
2589 Opt.CougarSingleComment|
2590 Opt.CougarCharLiteral|
2591 Opt.MaximumTokens|
2592 //Opt.PascalComments|
2593 //Opt.NumPasHex|
2594 0
2595 );
2596
2597 addToken("nil", HiType);
2598 addToken("true", HiType);
2599 addToken("PI", HiType);
2600
2601 addToken("quote", HiKeyword);
2602 addToken("lambda", HiBuiltin);
2603 addToken("defun", HiKeyword);
2604 addToken("define", HiKeyword);
2605 addToken("car", HiKeyword);
2606 addToken("cdr", HiKeyword);
2607 addToken("mk-list", HiKeyword);
2608 addToken("set-car!", HiInternal);
2609 addToken("set-cdr!", HiInternal);
2610 addToken("cons", HiKeyword);
2611 addToken("while", HiKeyword);
2612 addToken("break", HiKeywordHi);
2613 addToken("continue", HiKeywordHi);
2614 addToken("set!", HiInternal);
2615 addToken("gset!", HiInternal);
2616 addToken("begin", HiKeyword);
2617 addToken("return", HiKeywordHi);
2618 addToken("if", HiKeyword);
2619 addToken("cond", HiKeyword);
2620 addToken("and", HiKeyword);
2621 addToken("or", HiKeyword);
2622 addToken("not", HiKeyword);
2623 addToken("let", HiKeywordHi);
2624 addToken("let*", HiKeywordHi);
2625 addToken("else", HiSpecial);
2626 addToken("case", HiKeyword);
2627
2628 addToken("apply", HiKeyword);
2629 addToken("call", HiKeyword);
2630
2631 addToken("eq?", HiSpecial);
2632 addToken("nil?", HiSpecial);
2633 addToken("number?", HiSpecial);
2634 addToken("symbol?", HiSpecial);
2635 addToken("cons?", HiSpecial);
2636 addToken("lambda?", HiSpecial);
2637 addToken("array?", HiSpecial);
2638 addToken("string?", HiSpecial);
2639 addToken("cons-or-nil?", HiSpecial);
2640
2641
2642 addToken("min", HiKeyword);
2643 addToken("max", HiKeyword);
2644
2645
2646 addToken("sqrt", HiKeyword);
2647 addToken("abs", HiKeyword);
2648
2649 addToken("sin", HiKeyword);
2650 addToken("cos", HiKeyword);
2651 addToken("tan", HiKeyword);
2652 addToken("atan", HiKeyword);
2653 addToken("floor", HiKeyword);
2654 addToken("ceil", HiKeyword);
2655 addToken("trunc", HiKeyword);
2656
2657 addToken("atan2", HiKeyword);
2658
2659 addToken("new-array", HiKeyword);
2660 addToken("new-string", HiKeyword);
2661 addToken("length", HiKeyword);
2662 addToken("slice", HiKeyword);
2663 addToken("a-get", HiKeyword);
2664 addToken("a-set!", HiInternal);
2665
2666
2667 addToken("=", HiPunct);
2668 addToken("==", HiPunct);
2669 addToken("<>", HiPunct);
2670 addToken("!=", HiPunct);
2671 addToken(">", HiPunct);
2672 addToken("<", HiPunct);
2673 addToken(">=", HiPunct);
2674 addToken("<=", HiPunct);
2675
2676 addToken("+", HiPunct);
2677 addToken("-", HiPunct);
2678 addToken("*", HiPunct);
2679 addToken("/", HiPunct);
2680 addToken("%", HiPunct);
2681
2682 addToken("(", HiPunct);
2683 addToken(")", HiPunct);
2684 addToken("{", HiPunct);
2685 addToken("}", HiPunct);
2686 addToken("[", HiPunct);
2687 addToken("]", HiPunct);
2688
2689 addToken(".", HiInternal);
2690 addToken("'", HiInternal);
2691 }
2692 }
2693
2694
2695 // ////////////////////////////////////////////////////////////////////////// //
2696 public class EdHiTokensPas : EdHiTokens {
2697 this () {
2698 super(
2699 //Opt.Num0b|
2700 //Opt.Num0o|
2701 //Opt.Num0x|
2702 //Opt.NumAllowUnder|
2703 //Opt.NumAllowSign|
2704 Opt.SQString|
2705 //Opt.DQString|
2706 //Opt.BQString|
2707 //Opt.RQString|
2708 //Opt.SQChar|
2709 Opt.DNestedComment|
2710 //Opt.ShellSingleComment|
2711 Opt.CSingleComment|
2712 Opt.CMultiComment|
2713 //Opt.SqlSingleComment|
2714 //Opt.CPreprocessor|
2715 //Opt.JSRegExp|
2716 //Opt.ShellSigil|
2717 Opt.CaseInsensitive|
2718 Opt.SQStringNoEscape|
2719 //Opt.DQStringNoEscape|
2720 //Opt.CougarSingleComment|
2721 //Opt.CougarCharLiteral|
2722 //Opt.MaximumTokens|
2723 Opt.PascalComments|
2724 Opt.NumPasHex|
2725 0
2726 );
2727
2728 addToken("absolute", HiKeyword);
2729 addToken("abstract", HiKeyword);
2730 addToken("and", HiSpecial);
2731 addToken("array", HiKeyword);
2732 addToken("as", HiSpecial);
2733 addToken("asm", HiKeyword);
2734 addToken("assembler", HiKeyword);
2735 addToken("begin", HiKeyword);
2736 addToken("break", HiKeyword);
2737 addToken("case", HiKeyword);
2738 addToken("cdecl", HiKeywordHi);
2739 addToken("class", HiKeywordHi);
2740 addToken("const", HiKeywordHi);
2741 addToken("constref", HiSpecial);
2742 addToken("constructor", HiKeywordHi);
2743 addToken("continue", HiKeywordHi);
2744 addToken("destructor", HiKeywordHi);
2745 addToken("dispid", HiKeyword);
2746 addToken("dispinterface", HiKeyword);
2747 addToken("dispose", HiKeyword);
2748 addToken("div", HiSpecial);
2749 addToken("do", HiKeyword);
2750 addToken("downto", HiKeyword);
2751 addToken("dynamic", HiKeyword);
2752 addToken("else", HiKeyword);
2753 addToken("end", HiKeyword);
2754 addToken("except", HiKeyword);
2755 addToken("exit", HiKeywordHi);
2756 addToken("export", HiKeyword);
2757 addToken("exports", HiKeyword);
2758 addToken("external", HiKeywordHi);
2759 addToken("fail", HiKeyword);
2760 addToken("false", HiKeywordHi);
2761 addToken("far", HiKeyword);
2762 addToken("file", HiKeywordHi);
2763 addToken("finalisation", HiKeywordHi);
2764 addToken("finally", HiKeyword);
2765 addToken("for", HiKeyword);
2766 addToken("forward", HiKeywordHi);
2767 addToken("function", HiKeyword);
2768 addToken("generic", HiKeywordHi);
2769 addToken("goto", HiKeyword);
2770 addToken("if", HiKeyword);
2771 addToken("implementation", HiKeywordHi);
2772 addToken("in", HiSpecial);
2773 addToken("inherited", HiSpecial);
2774 addToken("initialization", HiKeywordHi);
2775 addToken("inline", HiKeywordHi);
2776 addToken("interface", HiKeyword);
2777 addToken("interrupt", HiInternal);
2778 addToken("is", HiSpecial);
2779 addToken("label", HiKeywordHi);
2780 addToken("library", HiKeyword);
2781 addToken("mod", HiSpecial);
2782 addToken("near", HiInternal);
2783 addToken("new", HiKeyword);
2784 addToken("nil", HiKeywordHi);
2785 addToken("not", HiSpecial);
2786 addToken("object", HiKeywordHi);
2787 addToken("of", HiKeyword);
2788 addToken("on", HiKeyword);
2789 addToken("operator", HiKeywordHi);
2790 addToken("or", HiSpecial);
2791 addToken("otherwise", HiSpecial);
2792 addToken("out", HiSpecial);
2793 addToken("overload", HiKeywordHi);
2794 addToken("override", HiKeywordHi);
2795 addToken("packed", HiKeyword);
2796 addToken("pascal", HiKeywordHi);
2797 addToken("private", HiKeyword);
2798 addToken("procedure", HiKeyword);
2799 addToken("program", HiKeyword);
2800 addToken("property", HiKeyword);
2801 addToken("protected", HiKeyword);
2802 addToken("public", HiKeyword);
2803 addToken("published", HiKeyword);
2804 addToken("raise", HiKeyword);
2805 addToken("read", HiKeyword);
2806 addToken("readonly", HiKeyword);
2807 addToken("record", HiKeywordHi);
2808 addToken("register", HiKeywordHi);
2809 addToken("repeat", HiKeyword);
2810 addToken("safecall", HiKeywordHi);
2811 addToken("self", HiInternal);
2812 addToken("set", HiSpecial);
2813 addToken("shl", HiSpecial);
2814 addToken("shr", HiSpecial);
2815 addToken("sizeof", HiKeywordHi);
2816 addToken("specialize", HiKeywordHi);
2817 addToken("static", HiKeywordHi);
2818 addToken("stdcall", HiKeywordHi);
2819 addToken("strict", HiKeywordHi);
2820 addToken("then", HiKeyword);
2821 addToken("to", HiKeyword);
2822 addToken("true", HiKeywordHi);
2823 addToken("try", HiKeyword);
2824 addToken("type", HiKeyword);
2825 addToken("unit", HiKeyword);
2826 addToken("until", HiKeyword);
2827 addToken("uses", HiInternal);
2828 addToken("var", HiKeyword);
2829 addToken("virtual", HiKeywordHi);
2830 addToken("while", HiKeyword);
2831 addToken("with", HiKeyword);
2832 addToken("write", HiKeyword);
2833 addToken("writeln", HiKeyword);
2834 addToken("xor", HiSpecial);
2835 addToken("..", HiKeyword);
2836
2837 addToken("result", HiKeywordHi);
2838
2839 addToken(">", HiPunct);
2840 addToken("<", HiPunct);
2841 addToken("+", HiPunct);
2842 addToken("-", HiPunct);
2843 addToken("*", HiPunct);
2844 addToken("/", HiPunct);
2845 addToken("%", HiPunct);
2846 addToken("=", HiPunct);
2847 addToken("[", HiPunct);
2848 addToken("]", HiPunct);
2849 addToken("(", HiPunct);
2850 addToken(")", HiPunct);
2851 addToken(",", HiPunct);
2852 addToken(".", HiPunct);
2853 addToken(":", HiPunct);
2854 addToken(";", HiSemi);
2855 addToken(":=", HiPunct);
2856 addToken("<=", HiPunct);
2857 addToken(">=", HiPunct);
2858 addToken("<>", HiPunct);
2859 addToken("@", HiKeyword);
2860
2861 addToken("Char", HiType);
2862 addToken("AnsiChar", HiType);
2863 addToken("WideChar", HiType);
2864 addToken("Boolean", HiType);
2865
2866 addToken("ShortInt", HiType);
2867 addToken("SmallInt", HiType);
2868 addToken("Integer", HiType);
2869 addToken("LongInt", HiType);
2870 addToken("Int64", HiType);
2871 addToken("UInt64", HiType);
2872
2873 addToken("Byte", HiType);
2874 addToken("Word", HiType);
2875 addToken("LongWord", HiType);
2876 addToken("DWord", HiType);
2877 addToken("Cardinal", HiType);
2878
2879 addToken("Single", HiType);
2880 addToken("Double", HiType);
2881 addToken("Extended", HiType);
2882 addToken("Real", HiType);
2883
2884 addToken("String", HiType);
2885 addToken("ShortString", HiType);
2886 addToken("AnsiString", HiType);
2887 addToken("WideString", HiType);
2888
2889 addToken("Pointer", HiType);
2890 addToken("Variant", HiType);
2891 }
2892 }
2893
2894
2895 // ////////////////////////////////////////////////////////////////////////// //
2896 public class EdHiTokensMES : EdHiTokens {
2897 this () {
2898 super(
2899 Opt.Num0b|
2900 Opt.Num0o|
2901 Opt.Num0x|
2902 Opt.NumAllowUnder|
2903 //Opt.NumAllowSign|
2904 //Opt.SQString|
2905 Opt.DQString|
2906 //Opt.BQString|
2907 //Opt.RQString|
2908 Opt.SQChar|
2909 Opt.DNestedComment|
2910 //Opt.ShellSingleComment|
2911 Opt.CSingleComment|
2912 Opt.CMultiComment|
2913 //Opt.SqlSingleComment|
2914 //Opt.CPreprocessor|
2915 //Opt.JSRegExp|
2916 //Opt.ShellSigil|
2917 //Opt.CaseInsensitive|
2918 //Opt.SQStringNoEscape|
2919 //Opt.DQStringNoEscape|
2920 //Opt.CougarSingleComment|
2921 //Opt.CougarCharLiteral|
2922 //Opt.MaximumTokens|
2923 //Opt.PascalComments|
2924 //Opt.NumPasHex|
2925 0
2926 );
2927
2928 addToken("this", HiInternal);
2929 addToken("method", HiInternal);
2930 addToken("builtin", HiInternal);
2931 addToken("field", HiInternal);
2932
2933 addToken("assert", HiBuiltin);
2934 addToken("new", HiBuiltin);
2935 //addToken("delete", HiBuiltin);
2936
2937 addToken("null", HiKeyword);
2938 addToken("true", HiKeyword);
2939 addToken("false", HiKeyword);
2940 addToken("cast", HiKeyword);
2941 //addToken("throw", HiKeyword);
2942 addToken("module", HiKeyword);
2943 //addToken("typeof", HiKeyword);
2944 //addToken("typeid", HiKeyword);
2945 addToken("sizeof", HiKeyword);
2946
2947 addToken("void", HiType);
2948 addToken("int", HiType);
2949 addToken("bool", HiType);
2950 addToken("string", HiType);
2951 addToken("Actor", HiType);
2952
2953 addToken("function", HiKeyword);
2954 addToken("is", HiKeyword);
2955 addToken("if", HiKeyword);
2956 addToken("else", HiKeyword);
2957 addToken("while", HiKeyword);
2958 addToken("for", HiKeyword);
2959 addToken("default", HiKeyword);
2960 addToken("break", HiKeyword);
2961 addToken("continue", HiKeyword);
2962 addToken("return", HiKeyword);
2963 addToken("struct", HiKeyword);
2964 addToken("enum", HiKeyword);
2965 addToken("const", HiKeyword);
2966 addToken("alias", HiKeyword);
2967 addToken("static", HiKeyword);
2968
2969 addToken("import", HiInternal);
2970
2971 addToken("auto", HiType);
2972
2973 addToken("private", HiSpecial);
2974 addToken("public", HiSpecial);
2975
2976 addToken("__argTypes", HiInternal);
2977 addToken("__parameters", HiInternal);
2978
2979 addToken("ref", HiSpecial);
2980
2981 addToken("{", HiPunct);
2982 addToken("}", HiPunct);
2983 addToken("(", HiPunct);
2984 addToken(")", HiPunct);
2985 addToken("[", HiPunct);
2986 addToken("]", HiPunct);
2987 addToken(";", HiSemi);
2988 addToken(":", HiPunct);
2989 addToken(",", HiPunct);
2990 addToken(".", HiPunct);
2991 addToken("^", HiPunct);
2992 addToken("^=", HiPunct);
2993 addToken("=", HiPunct);
2994 addToken("=", HiPunct);
2995 addToken("=", HiPunct);
2996 addToken("<", HiPunct);
2997 addToken(">", HiPunct);
2998 addToken("<=", HiPunct);
2999 addToken(">=", HiPunct);
3000 addToken("==", HiPunct);
3001 addToken("!=", HiPunct);
3002 addToken("<>", HiPunct);
3003 addToken("<>=", HiPunct);
3004 addToken("<<", HiPunct);
3005 addToken(">>", HiPunct);
3006 //addToken(">>>", HiPunct);
3007 addToken("+", HiPunct);
3008 addToken("-", HiPunct);
3009 addToken("*", HiPunct);
3010 addToken("/", HiPunct);
3011 addToken("%", HiPunct);
3012 addToken("..", HiPunct);
3013 addToken("...", HiPunct);
3014 addToken("&", HiPunct);
3015 addToken("&&", HiSpecial);
3016 addToken("|", HiPunct);
3017 addToken("||", HiSpecial);
3018 addToken("[]", HiPunct);
3019 addToken("&", HiPunct);
3020 addToken("*", HiPunct);
3021 addToken("~", HiPunct);
3022 addToken("$", HiPunct);
3023 addToken("++", HiPunct);
3024 addToken("--", HiPunct);
3025 addToken("++", HiPunct);
3026 addToken("--", HiPunct);
3027 addToken("?", HiPunct);
3028 addToken("-", HiPunct);
3029 addToken("+", HiPunct);
3030 addToken("+=", HiPunct);
3031 addToken("-=", HiPunct);
3032 addToken("*=", HiPunct);
3033 addToken("/=", HiPunct);
3034 addToken("%=", HiPunct);
3035 addToken("<<=", HiPunct);
3036 addToken(">>=", HiPunct);
3037 //addToken(">>>=", HiPunct);
3038 addToken("&=", HiPunct);
3039 addToken("|=", HiPunct);
3040 addToken("~=", HiPunct);
3041 addToken("~", HiPunct);
3042 //addToken("is", HiPunct);
3043 //addToken("!is", HiPunct);
3044 //addToken("@", HiPunct);
3045 }
3046 }
3047
3048
3049 // ////////////////////////////////////////////////////////////////////////// //
3050 public class EdHiTokensZAS : EdHiTokens {
3051 this () {
3052 super(
3053 Opt.Num0b|
3054 Opt.Num0o|
3055 Opt.Num0x|
3056 Opt.NumAllowUnder|
3057 //Opt.NumAllowSign|
3058 Opt.SQString|
3059 Opt.DQString|
3060 Opt.SQChar|
3061 Opt.CaseInsensitive|
3062 Opt.CougarSingleComment|
3063 Opt.NumAsmHex|
3064 //Opt.MaximumTokens|
3065 0
3066 );
3067
3068 addToken("adc", HiKeyword);
3069 addToken("add", HiKeyword);
3070 addToken("and", HiKeyword);
3071 addToken("bit", HiKeyword);
3072 addToken("call", HiKeyword);
3073 addToken("ccf", HiKeyword);
3074 addToken("cp", HiKeyword);
3075 addToken("cpd", HiKeyword);
3076
3077 addToken("cpdr", HiKeyword);
3078 addToken("cpi", HiKeyword);
3079 addToken("cpir", HiKeyword);
3080 addToken("cpl", HiKeyword);
3081 addToken("daa", HiKeyword);
3082 addToken("dec", HiKeyword);
3083 addToken("di", HiKeyword);
3084 addToken("djnz", HiKeyword);
3085
3086 addToken("ei", HiKeyword);
3087 addToken("ex", HiKeyword);
3088 addToken("exx", HiKeyword);
3089 addToken("halt", HiKeyword);
3090 addToken("im", HiKeyword);
3091 addToken("in", HiKeyword);
3092 addToken("inc", HiKeyword);
3093 addToken("ind", HiKeyword);
3094
3095 addToken("indr", HiKeyword);
3096 addToken("ini", HiKeyword);
3097 addToken("inir", HiKeyword);
3098 addToken("jp", HiKeyword);
3099 addToken("jr", HiKeyword);
3100 addToken("ld", HiKeyword);
3101 addToken("ldd", HiKeyword);
3102 addToken("lddr", HiKeyword);
3103
3104 addToken("ldi", HiKeyword);
3105 addToken("ldir", HiKeyword);
3106 addToken("neg", HiKeyword);
3107 addToken("nop", HiKeyword);
3108 addToken("or", HiKeyword);
3109 addToken("otdr", HiKeyword);
3110 addToken("otir", HiKeyword);
3111 addToken("out", HiKeyword);
3112
3113 addToken("outd", HiKeyword);
3114 addToken("outi", HiKeyword);
3115 addToken("pop", HiKeyword);
3116 addToken("push", HiKeyword);
3117 addToken("res", HiKeyword);
3118 addToken("ret", HiKeyword);
3119 addToken("reti", HiKeyword);
3120 addToken("retn", HiKeyword);
3121
3122 addToken("rl", HiKeyword);
3123 addToken("rla", HiKeyword);
3124 addToken("rlc", HiKeyword);
3125 addToken("rlca", HiKeyword);
3126 addToken("rld", HiKeyword);
3127 addToken("rr", HiKeyword);
3128 addToken("rra", HiKeyword);
3129 addToken("rrc", HiKeyword);
3130
3131 addToken("rrca", HiKeyword);
3132 addToken("rrd", HiKeyword);
3133 addToken("rst", HiKeyword);
3134 addToken("sbc", HiKeyword);
3135 addToken("scf", HiKeyword);
3136 addToken("set", HiKeyword);
3137 addToken("sla", HiKeyword);
3138 addToken("sli", HiKeyword);
3139
3140 addToken("sll", HiKeyword);
3141 addToken("sra", HiKeyword);
3142 addToken("srl", HiKeyword);
3143 addToken("sub", HiKeyword);
3144 addToken("xor", HiKeyword);
3145 addToken("xslt", HiKeyword);
3146 addToken("nopx", HiKeyword);
3147 addToken("nopy", HiKeyword);
3148
3149 /* ZXNext */
3150 /*
3151 addToken("ldix", HiKeyword);
3152 addToken("ldws", HiKeyword);
3153 addToken("ldirx", HiKeyword);
3154 addToken("lddx", HiKeyword);
3155
3156 addToken("lddrx", HiKeyword);
3157 addToken("ldpirx", HiKeyword);
3158 addToken("outinb", HiKeyword);
3159 addToken("mul", HiKeyword);
3160
3161 addToken("swapnib", HiKeyword);
3162 addToken("mirror", HiKeyword);
3163 addToken("nextreg", HiKeyword);
3164 addToken("pixeldn", HiKeyword);
3165
3166 addToken("pixelad", HiKeyword);
3167 addToken("setae", HiKeyword);
3168 addToken("test", HiKeyword);
3169 addToken("bsla", HiKeyword);
3170
3171 addToken("bsra", HiKeyword);
3172 addToken("bsrl", HiKeyword);
3173 addToken("bsrf", HiKeyword);
3174 addToken("brlc", HiKeyword);
3175 */
3176
3177 /* registers */
3178 addToken("b", HiKeywordHi);
3179 addToken("c", HiKeywordHi);
3180 addToken("bc", HiKeywordHi);
3181 addToken("d", HiKeywordHi);
3182 addToken("e", HiKeywordHi);
3183 addToken("de", HiKeywordHi);
3184 addToken("h", HiKeywordHi);
3185 addToken("l", HiKeywordHi);
3186 addToken("hl", HiKeywordHi);
3187 addToken("a", HiKeywordHi);
3188 addToken("af", HiKeywordHi);
3189 //addToken("af'", HiKeywordHi); // specially processed
3190 addToken("afx", HiKeywordHi);
3191 addToken("sp", HiKeywordHi);
3192 addToken("(hl)", HiKeywordHi);
3193 addToken("ix", HiKeywordHi);
3194 addToken("iy", HiKeywordHi);
3195 addToken("ixl", HiKeywordHi);
3196 addToken("iyl", HiKeywordHi);
3197 addToken("ixh", HiKeywordHi);
3198 addToken("iyh", HiKeywordHi);
3199
3200 /* jump conditions */
3201 //HiType?
3202 addToken("nz", HiSpecial);
3203 addToken("z", HiSpecial);
3204 addToken("nc", HiSpecial);
3205 //addToken("c", HiSpecial); // conflicts with register name; specially processed
3206 addToken("po", HiSpecial);
3207 addToken("pe", HiSpecial);
3208 addToken("p", HiSpecial);
3209 addToken("m", HiSpecial);
3210
3211 addToken("display", HiInternal);
3212 addToken("display0", HiInternal);
3213 addToken("displaya", HiInternal);
3214 addToken("disphex", HiInternal);
3215 addToken("disphex0", HiInternal);
3216 addToken("disphexa", HiInternal);
3217
3218 addToken("deffmt", HiInternal);
3219 addToken("$model", HiInternal);
3220 addToken("macro", HiInternal);
3221 addToken("endm", HiInternal);
3222 addToken("org", HiInternal);
3223 addToken("disp", HiInternal);
3224 addToken("enddisp", HiInternal);
3225 addToken("phase", HiInternal);
3226 addToken("dephase", HiInternal);
3227 addToken("unphase", HiInternal);
3228 addToken("align", HiInternal);
3229 addToken("dispalign", HiInternal);
3230 addToken("phasealign", HiInternal);
3231 addToken("ent", HiInternal);
3232 addToken("clr", HiInternal);
3233 addToken("reserve", HiInternal);
3234 addToken("include", HiInternal);
3235 addToken("incbin", HiInternal);
3236 addToken("module", HiInternal);
3237 addToken("endmodule", HiInternal);
3238 addToken("dup", HiInternal);
3239 addToken("edup", HiInternal);
3240 addToken("if", HiInternal);
3241 addToken("ifx", HiInternal);
3242 addToken("else", HiInternal);
3243 addToken("elseif", HiInternal);
3244 addToken("elseifx", HiInternal);
3245 addToken("endif", HiInternal);
3246 addToken("defincr", HiInternal);
3247 addToken("defb", HiInternal);
3248 addToken("db", HiInternal);
3249 addToken("defw", HiInternal);
3250 addToken("dw", HiInternal);
3251 addToken("defr", HiInternal);
3252 addToken("dr", HiInternal);
3253 addToken("defs", HiInternal);
3254 addToken("ds", HiInternal);
3255 addToken("defm", HiInternal);
3256 addToken("dm", HiInternal);
3257 addToken("defz", HiInternal);
3258 addToken("dz", HiInternal);
3259 addToken("defx", HiInternal);
3260 addToken("dx", HiInternal);
3261 addToken("defc", HiInternal);
3262 addToken("dc", HiInternal);
3263 addToken("$error", HiInternal);
3264 addToken("$warning", HiInternal);
3265 addToken("$printf", HiInternal);
3266 addToken("$printf0", HiInternal);
3267 addToken("$printfa", HiInternal);
3268 addToken("$mathmode", HiInternal);
3269
3270 addToken("{", HiPunct);
3271 addToken("}", HiPunct);
3272 addToken("(", HiPunct);
3273 addToken(")", HiPunct);
3274 addToken("[", HiPunct);
3275 addToken("]", HiPunct);
3276 addToken(";", HiSemi);
3277 addToken(":", HiPunct);
3278 addToken(",", HiPunct);
3279 addToken(".", HiPunct);
3280 addToken("^", HiPunct);
3281 addToken("^=", HiPunct);
3282 addToken("=", HiPunct);
3283 addToken("=", HiPunct);
3284 addToken("=", HiPunct);
3285 addToken("<", HiPunct);
3286 addToken(">", HiPunct);
3287 addToken("<=", HiPunct);
3288 addToken(">=", HiPunct);
3289 addToken("==", HiPunct);
3290 addToken("!=", HiPunct);
3291 addToken("<>", HiPunct);
3292 addToken("<>=", HiPunct);
3293 addToken("<<", HiPunct);
3294 addToken(">>", HiPunct);
3295 addToken(">>>", HiPunct);
3296 addToken("+", HiPunct);
3297 addToken("-", HiPunct);
3298 addToken("*", HiPunct);
3299 addToken("/", HiPunct);
3300 addToken("%", HiPunct);
3301 addToken("..", HiPunct);
3302 addToken("...", HiPunct);
3303 addToken("&", HiPunct);
3304 addToken("&&", HiSpecial);
3305 addToken("|", HiPunct);
3306 addToken("||", HiSpecial);
3307 addToken("[]", HiPunct);
3308 addToken("&", HiPunct);
3309 addToken("*", HiPunct);
3310 addToken("~", HiPunct);
3311 addToken("$", HiPunct);
3312 addToken("++", HiPunct);
3313 addToken("--", HiPunct);
3314 addToken("++", HiPunct);
3315 addToken("--", HiPunct);
3316 addToken("?", HiPunct);
3317 addToken("-", HiPunct);
3318 addToken("+", HiPunct);
3319 addToken("+=", HiPunct);
3320 addToken("-=", HiPunct);
3321 addToken("*=", HiPunct);
3322 addToken("/=", HiPunct);
3323 addToken("%=", HiPunct);
3324 addToken("<<=", HiPunct);
3325 addToken(">>=", HiPunct);
3326 //addToken(">>>=", HiPunct);
3327 addToken("&=", HiPunct);
3328 addToken("|=", HiPunct);
3329 addToken("~=", HiPunct);
3330 addToken("~", HiPunct);
3331 //addToken("is", HiPunct);
3332 //addToken("!is", HiPunct);
3333 //addToken("@", HiPunct);
3334 }
3335 }
3336
3337
3338 // ////////////////////////////////////////////////////////////////////////// //
3339 // new higlighter instance for the file with the given extension
3340 public EditorHL getHiglighterObjectFor (const(char)[] ext, const(char)[] fullname) {
3341 auto xname = fullname;
3342 auto lslpos = xname.lastIndexOf('/');
3343 if (lslpos >= 0) xname = xname[lslpos+1..$];
3344 if (ext.strEquCI(".d")) {
3345 __gshared EdHiTokensD toksd;
3346 if (toksd is null) toksd = new EdHiTokensD();
3347 return new EditorHLExt(toksd);
3348 }
3349 if (ext.strEquCI(".js") || ext.strEquCI(".jsm")) {
3350 __gshared EdHiTokensJS toksjs;
3351 if (toksjs is null) toksjs = new EdHiTokensJS();
3352 return new EditorHLExt(toksjs);
3353 }
3354 if (ext.strEquCI(".c") || ext.strEquCI(".cpp") ||
3355 ext.strEquCI(".h") || ext.strEquCI(".hpp") ||
3356 ext.strEquCI(".hxx") || ext.strEquCI(".cxx") ||
3357 ext.strEquCI(".cc"))
3358 {
3359 __gshared EdHiTokensC toksc;
3360 if (toksc is null) toksc = new EdHiTokensC();
3361 return new EditorHLExt(toksc);
3362 }
3363 if (xname.strEquCI("zscript.txt") || xname.strEquCI("actor.txt")) {
3364 __gshared EdHiTokensZS tokszs;
3365 if (tokszs is null) tokszs = new EdHiTokensZS();
3366 return new EditorHLExt(tokszs);
3367 }
3368 if (ext.strEquCI(".uc") || ext.strEquCI(".vc")) {
3369 __gshared EdHiTokensVC toksvc;
3370 if (toksvc is null) toksvc = new EdHiTokensVC();
3371 return new EditorHLExt(toksvc);
3372 }
3373 if (ext.strEquCI(".frag") || ext.strEquCI(".vert") ||
3374 ext.strEquCI(".shad") || ext.strEquCI(".shader") ||
3375 ext.strEquCI(".fs") || ext.strEquCI(".vs"))
3376 {
3377 __gshared EdHiTokensFrag tokf;
3378 if (tokf is null) tokf = new EdHiTokensFrag();
3379 return new EditorHLExt(tokf);
3380 }
3381 if (ext.strEquCI(".sh") || ext.strEquCI(".profile")) {
3382 __gshared EdHiTokensShell tokssh;
3383 if (tokssh is null) tokssh = new EdHiTokensShell();
3384 return new EditorHLExt(tokssh);
3385 }
3386 if (ext.strEquCI(".htm") || ext.strEquCI(".html")) {
3387 __gshared EdHiTokensHtml tokshtml;
3388 if (tokshtml is null) tokshtml = new EdHiTokensHtml();
3389 return new EditorHLExt(tokshtml);
3390 }
3391 if (ext.strEquCI(".sql")) {
3392 __gshared EdHiTokensSQL toksql;
3393 if (toksql is null) toksql = new EdHiTokensSQL();
3394 return new EditorHLExt(toksql);
3395 }
3396 if (ext.strEquCI(".lsp") || ext.strEquCI(".cgr")) {
3397 __gshared EdHiTokensCougar tokcougar;
3398 if (tokcougar is null) tokcougar = new EdHiTokensCougar();
3399 return new EditorHLExt(tokcougar);
3400 }
3401 if (ext.strEquCI(".pas") || ext.strEquCI(".pp") || ext.strEquCI(".inc") || ext.strEquCI(".dpr")) {
3402 __gshared EdHiTokensPas tokpas;
3403 if (tokpas is null) tokpas = new EdHiTokensPas();
3404 return new EditorHLExt(tokpas);
3405 }
3406 if (ext.strEquCI(".mes")) {
3407 __gshared EdHiTokensMES toksmes;
3408 if (toksmes is null) toksmes = new EdHiTokensMES();
3409 return new EditorHLExt(toksmes);
3410 }
3411 if (ext.strEquCI(".zas") || ext.strEquCI(".a80")) {
3412 __gshared EdHiTokensZAS tokszas;
3413 if (tokszas is null) tokszas = new EdHiTokensZAS();
3414 return new EditorHLExt(tokszas);
3415 }
3416 auto bnpos = fullname.length;
3417 while (bnpos > 0 && fullname.ptr[bnpos-1] != '/') --bnpos;
3418 auto name = fullname[bnpos..$];
3419 if (name == "TODO") return new EditorHLTODO();
3420 if (name == "COMMIT_EDITMSG") return new EditorHLGitCommit();
3421 if (name.startsWith("ci-comment-")) return new EditorHLGitCommit(); // fossil commit message
3422 return null;
3423 }
various I.V. D modules