]> git.saurik.com Git - cycript.git/blob - Scanner.lpp.in
Avoid crash when using toCYON on String.prototype.
[cycript.git] / Scanner.lpp.in
1 /* Cycript - Optimizing JavaScript Compiler/Runtime
2 * Copyright (C) 2009-2015 Jay Freeman (saurik)
3 */
4
5 /* GNU Affero General Public License, Version 3 {{{ */
6 /*
7 * This program is free software: you can redistribute it and/or modify
8 * it under the terms of the GNU Affero General Public License as published by
9 * the Free Software Foundation, either version 3 of the License, or
10 * (at your option) any later version.
11
12 * This program is distributed in the hope that it will be useful,
13 * but WITHOUT ANY WARRANTY; without even the implied warranty of
14 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15 * GNU Affero General Public License for more details.
16
17 * You should have received a copy of the GNU Affero General Public License
18 * along with this program. If not, see <http://www.gnu.org/licenses/>.
19 **/
20 /* }}} */
21
22 %top{
23 #if defined(__clang__)
24 #pragma clang diagnostic push
25 #pragma clang diagnostic ignored "-Wdeprecated-register"
26 #pragma clang diagnostic ignored "-Wunused-function"
27 #pragma clang diagnostic ignored "-Wunused-variable"
28 #else
29 #pragma GCC diagnostic push
30 #pragma GCC diagnostic ignored "-Wsign-compare"
31 #pragma GCC diagnostic ignored "-Wunused-function"
32 #pragma GCC diagnostic ignored "-Wunused-variable"
33 #endif
34 }
35
36 %{
37
38 #define YYLTYPE CYLocation
39 #include "Parser.hpp"
40 typedef cy::parser::token tk;
41
42 #include "Highlight.hpp"
43
44 #include "IdentifierStart.h"
45 #include "IdentifierContinue.h"
46
47 #define YY_EXTRA_TYPE CYDriver *
48
49 #define F(value, highlight) do { \
50 BEGIN(yyextra->template_.top() ? DivOrTemplateTail : Div); \
51 yylval->highlight_ = highlight; \
52 return value; \
53 } while (false)
54
55 #define S(stack) do { \
56 if (yyextra->stack.size() == 1) \
57 E("invalid brace") \
58 yyextra->stack.pop(); \
59 } while (false)
60
61 #define P yyextra->pool_
62 #define A new(P)
63 #define Y P.strmemdup(yytext, yyleng)
64
65 #define I(type, Type, value, highlight) do { \
66 yylval->semantic_.type ## _ = A CY ## Type; \
67 yylval->semantic_.type ## _->location_ = *yylloc; \
68 F(value, highlight); \
69 } while (false)
70
71 #define N \
72 if (yyextra->last_) { \
73 yyextra->last_ = false; \
74 F(tk::NewLine, hi::Nothing); \
75 }
76
77 #define V(more) { \
78 if (const char *nl = reinterpret_cast<const char *>(memchr(yytext, '\n', yyleng))) { \
79 unsigned lines(0); \
80 size_t left; \
81 do { \
82 ++lines; \
83 left = yyleng - (nl - yytext) - 1; \
84 nl = reinterpret_cast<const char *>(memchr(nl + 1, '\n', left)); \
85 } while (nl != NULL); \
86 yylloc->step(); \
87 yylloc->end.Lines(lines); \
88 yylloc->end.Columns(left); \
89 more \
90 } else L \
91 }
92
93 #define R yylloc->end.Columns(yyleng);
94 #define L yylloc->step(); R
95
96 #define H(value, highlight) do { \
97 if (yyextra->highlight_) \
98 F(value, highlight); \
99 } while (false)
100
101 #define M \
102 H(tk::Comment, hi::Comment);
103
104 #define E(message) { \
105 CYDriver::Error error; \
106 error.location_ = *yylloc; \
107 error.message_ = "syntax error, " message; \
108 yyextra->errors_.push_back(error); \
109 yyterminate(); \
110 }
111
112 int X(char c) {
113 if (c >= '0' && c <= '9')
114 return c - '0';
115 if (c >= 'a' && c <= 'f')
116 return c - 'a' + 10;
117 if (c >= 'A' && c <= 'F')
118 return c - 'A' + 10;
119 return -1;
120 }
121
122 template <typename Type_>
123 static void U(Type_ &local, unsigned point) {
124 if (false) {
125 } else if (point < 0x000080) {
126 *local++ = point;
127 } else if (point < 0x000800) {
128 *local++ = 0xc0 | point >> 0x06 & 0x1f;
129 goto one;
130 } else if (point < 0x010000) {
131 *local++ = 0xe0 | point >> 0x0c & 0x0f;
132 goto two;
133 } else if (point < 0x110000) {
134 *local++ = 0xf0 | point >> 0x12 & 0x07;
135 *local++ = 0x80 | point >> 0x0c & 0x3f;
136 two:
137 *local++ = 0x80 | point >> 0x06 & 0x3f;
138 one:
139 *local++ = 0x80 | point >> 0x00 & 0x3f;
140 } else _assert(false);
141 }
142
143 static unsigned U(char *&local, const char *text, yy_size_t &i) {
144 unsigned point;
145
146 char next(text[++i]);
147 if (next != '{') {
148 point = X(text[i + 0]) << 12 | X(text[i + 1]) << 8 | X(text[i + 2]) << 4 | X(text[i + 3]);
149 i += 3;
150 } else {
151 point = 0;
152 for (;;) {
153 next = text[++i];
154 if (next == '}')
155 break;
156 point = (point << 4) | X(next);
157 }
158 }
159
160 U(local, point);
161 return point;
162 }
163
164 #define CYLexBufferPoint(point) do { \
165 std::back_insert_iterator<std::vector<char> > inserter(yyextra->buffer_); \
166 U(inserter, point); \
167 } while (false)
168
169 #define CYLexBufferUnit(value) do { \
170 yyextra->buffer_.push_back(value); \
171 } while (false)
172
173 #define CYLexBufferUnits(data, size) do { \
174 yyextra->buffer_.insert(yyextra->buffer_.end(), data, data + size); \
175 } while (false)
176
177 #define CYLexBufferStart(condition) do { \
178 yyextra->buffer_.clear(); \
179 yy_push_state(condition, yyscanner); \
180 } while (false)
181
182 #define CYLexBufferEnd(type, Type, value, highlight) do { \
183 yy_pop_state(yyscanner); \
184 I(type, Type(P.strmemdup(yyextra->buffer_.data(), yyextra->buffer_.size()), yyextra->buffer_.size()), value, highlight); \
185 } while (false)
186
187 #define YY_INPUT(data, value, size) do { \
188 value = yyextra->data_.sgetn(data, size) ?: YY_NULL; \
189 } while (false)
190
191 %}
192
193 %option prefix="cy"
194 %option bison-bridge
195 %option bison-locations
196 %option nodefault
197 %option noyywrap
198 %option noyylineno
199 %option nounput
200 %option nounistd
201 %option 8bit
202 %option backup
203 %option batch
204 %option never-interactive
205 %option pointer
206 %option reentrant
207 %option stack
208
209 U1 [\x00-\x7f]
210 U0 [\x80-\xbf]
211 U2 [\xc2-\xdf]
212 U3 [\xe0-\xef]
213 U4 [\xf0-\xf4]
214 UN [\xc0-\xc1\xf5-\xff]
215 UE {U1}|{U2}|{U3}|{U4}|{UN}
216
217 HexDigit [0-9a-fA-F]
218 LineTerminatorSequence \r?\n|\r|\xe2\x80[\xa8\xa9]
219 WhiteSpace [\x09\x0b\x0c\x20]|\xc2\xa0|\xef\xbb\xbf
220 UnicodeEscape \\u({HexDigit}{4}|\{{HexDigit}+\})
221
222 @include NotLineTerminator.l
223 NoneTerminatorCharacter [^\r\n\x80-\xff]|{NotLineTerminator}
224 RegExCharacter [^/[\\]{-}[\r\n\x80-\xff]|{NotLineTerminator}
225 RegClsCharacter [^]\\]{-}[\r\n\x80-\xff]|{NotLineTerminator}
226 CommentCharacter [^*/]{-}[\r\n\x80-\xff]|{NotLineTerminator}
227 SingleCharacter [^'\\]{-}[\r\n\x80-\xff]|{NotLineTerminator}
228 DoubleCharacter [^"\\]{-}[\r\n\x80-\xff]|{NotLineTerminator}
229 PlateCharacter [^$`\\]{-}[\r\n\x80-\xff]|{NotLineTerminator}
230
231 @include UnicodeIDStart.l
232 @include UnicodeIDContinue.l
233 IdentifierMore [$_]
234
235 UnicodeStart {IdentifierMore}|{UnicodeIDStart}
236 UnicodePart {IdentifierMore}|\xe2\x80[\x8c\x8d]|{UnicodeIDContinue}
237 UnicodeScrap {U2}|{U3}{U0}{0,1}|{U4}{U0}{0,2}|{UN}|{U0}
238 UnicodeError ({U2}|{U3}{U0}{0,1}|{U4}{U0}{0,2}){UE}|{UN}|{U0}
239
240 IdentifierStart {UnicodeStart}|{UnicodeEscape}
241 IdentifierPart {UnicodePart}|{UnicodeEscape}
242 IdentifierFail {UnicodeError}|\\(u({HexDigit}{0,3}|\{{HexDigit}*))?
243 IdentifierScrap {IdentifierPart}*{IdentifierFail}?
244
245 RegularExpressionBackslashSequence \\{NoneTerminatorCharacter}
246 RegularExpressionClassChars ({RegClsCharacter}|{RegularExpressionBackslashSequence})*
247
248 @begin E4X
249 XMLNameStart [a-zA-Z_:]
250 XMLNamePart [a-zA-Z0-9.-_:]
251 XMLName {XMLNameStart}{XMLNamePart}*
252 @end
253
254 %x RegularExpression
255 %x MultiLine
256
257 %x LegacySingleString
258 %x LegacyDoubleString
259
260 %x StrictSingleString
261 %x StrictDoubleString
262 %x StrictAccentString
263
264 %s Div
265 %s DivOrTemplateTail
266
267 @begin E4X
268 %x XMLContent
269 %x XMLTag
270 @end
271
272 %%
273
274 /* RegEx {{{ */
275 <RegularExpression>{
276 \/{UnicodePart}* R CYLexBufferUnits(yytext, yyleng); CYLexBufferEnd(literal, RegEx, tk::RegularExpressionLiteral_, hi::Constant);
277 \/{UnicodePart}*{UnicodeError} R E("invalid character");
278
279 {RegExCharacter}+ R CYLexBufferUnits(yytext, yyleng);
280
281 {RegularExpressionBackslashSequence} R CYLexBufferUnits(yytext, yyleng);
282 \\ R E("invalid escape")
283
284 (\\|{RegExCharacter}+)?{LineTerminatorSequence} R E("invalid newline");
285 (\\|{RegExCharacter}+)?{UnicodeScrap} R E("invalid character");
286
287 "["{RegularExpressionClassChars}"]" R CYLexBufferUnits(yytext, yyleng);
288 "["{RegularExpressionClassChars}\\? R E("invalid class");
289
290 "["{RegularExpressionClassChars}\\?{LineTerminatorSequence} R E("invalid newline");
291 "["{RegularExpressionClassChars}\\?{UnicodeScrap} R E("invalid character");
292
293 <<EOF>> R E("unterminated regex")
294 }
295 /* }}} */
296 /* Comment {{{ */
297 /* XXX: maybe fold LineTerminatorSequence into these definitions */
298 #!{NoneTerminatorCharacter}* L M
299 \/\/{NoneTerminatorCharacter}* L M
300 (#!|\/\/){NoneTerminatorCharacter}*{UnicodeError} L E("invalid character");
301
302 \/\* L yy_push_state(MultiLine, yyscanner);
303
304 <MultiLine>{
305 \**\*\/ R yy_pop_state(yyscanner); M N
306 \**{LineTerminatorSequence} yylloc->end.Lines(); yyextra->last_ = true;
307 \**{CommentCharacter}|\/ R
308
309 \**{UnicodeScrap} R E("invalid character");
310 \**\* R E("invalid comment");
311
312 <<EOF>> R E("invalid comment")
313 }
314 /* }}} */
315 /* Element {{{ */
316 @begin E4X
317 <RegExp>"<>" L F(tk::LeftRight, hi::Structure);
318 <XMLContent>"</>" L F(tk::LeftSlashRight, hi::Structure);
319
320 <RegExp,XMLContent>\<!\[CDATA\[(\n|[^[]|\[[^[]|\[\[[^>])*]]> V() F(tk::XMLCDATA, hi::Constant);
321 <RegExp,XMLContent>\<!--(\n|[^-]|-[^-])*--> V() F(tk::XMLComment, hi::Comment);
322 <RegExp,XMLContent>\<?(\n|[^?]|\?[^>])*?> V() F(tk::XMLPI, hi::Meta);
323
324 <XMLTag>"=" L F(tk::Equal, hi::Structure);
325 <XMLTag>">" L F(tk::Right, hi::Structure);
326 <XMLTag>"/>" L F(tk::SlashRight, hi::Structure);
327 <XMLTag>"{" L F(tk::OpenBrace, hi::Structure);
328
329 <XMLTag>\"(\n|[^"])*\"|'(\n|[^'])*' V() F(tk::XMLAttributeValue, hi::Constant);
330 <XMLTag>{XMLName} L F(tk::XMLName, hi::Identifier);
331 <XMLTag>[ \t\r\n] V() F(tk::XMLWhitespace, hi::Nothing);
332
333 <XMLContent>"{" L F(tk::OpenBrace, hi::Structure);
334 <XMLContent>"<" L F(tk::Left, hi::Structure);
335 <XMLContent>"</" L F(tk::LeftSlash, hi::Structure);
336 @end
337 /* }}} */
338 /* Operator {{{ */
339 "..." L F(tk::PeriodPeriodPeriod, hi::Meta);
340 ".." L E("invalid operator")
341
342 @begin E4X
343 "::" L F(tk::ColonColon, hi::Operator);
344 ".." L F(tk::PeriodPeriod, hi::Operator);
345 @end
346
347 @begin E4X ObjectiveC
348 "@" L F(tk::At, hi::Operator);
349 "#" L F(tk::Pound, hi::Operator);
350 @end
351
352 "&" L F(tk::Ampersand, hi::Operator);
353 "&&" L F(tk::AmpersandAmpersand, hi::Operator);
354 "&=" L F(tk::AmpersandEqual, hi::Operator);
355 "^" L F(tk::Carrot, hi::Operator);
356 "^=" L F(tk::CarrotEqual, hi::Operator);
357 "=" L F(tk::Equal, hi::Operator);
358 "==" L F(tk::EqualEqual, hi::Operator);
359 "===" L F(tk::EqualEqualEqual, hi::Operator);
360 "=>" L F(tk::EqualRight, hi::Operator);
361 "!" L F(tk::Exclamation, hi::Operator);
362 "!=" L F(tk::ExclamationEqual, hi::Operator);
363 "!==" L F(tk::ExclamationEqualEqual, hi::Operator);
364 "-" L F(tk::Hyphen, hi::Operator);
365 "-=" L F(tk::HyphenEqual, hi::Operator);
366 "--" L F(tk::HyphenHyphen, hi::Operator);
367 "->" L F(tk::HyphenRight, hi::Operator);
368 "<" L F(tk::Left, hi::Operator);
369 "<=" L F(tk::LeftEqual, hi::Operator);
370 "<<" L F(tk::LeftLeft, hi::Operator);
371 "<<=" L F(tk::LeftLeftEqual, hi::Operator);
372 "%" L F(tk::Percent, hi::Operator);
373 "%=" L F(tk::PercentEqual, hi::Operator);
374 "." L F(tk::Period, hi::Operator);
375 "|" L F(tk::Pipe, hi::Operator);
376 "|=" L F(tk::PipeEqual, hi::Operator);
377 "||" L F(tk::PipePipe, hi::Operator);
378 "+" L F(tk::Plus, hi::Operator);
379 "+=" L F(tk::PlusEqual, hi::Operator);
380 "++" L F(tk::PlusPlus, hi::Operator);
381 ">" L F(tk::Right, hi::Operator);
382 ">=" L F(tk::RightEqual, hi::Operator);
383 ">>" L F(tk::RightRight, hi::Operator);
384 ">>=" L F(tk::RightRightEqual, hi::Operator);
385 ">>>" L F(tk::RightRightRight, hi::Operator);
386 ">>>=" L F(tk::RightRightRightEqual, hi::Operator);
387 "*" L F(tk::Star, hi::Operator);
388 "*=" L F(tk::StarEqual, hi::Operator);
389 "~" L F(tk::Tilde, hi::Operator);
390
391 "/" L F(tk::Slash, hi::Operator);
392 "/=" L F(tk::SlashEqual, hi::Operator);
393
394 ":" L F(tk::Colon, hi::Structure);
395 "," L F(tk::Comma, hi::Structure);
396 "?" L F(tk::Question, hi::Structure);
397 ";" L F(tk::SemiColon, hi::Structure);
398
399 "(" L F(tk::OpenParen, hi::Structure);
400 ")" L F(tk::CloseParen, hi::Structure);
401
402 "{" L yyextra->template_.push(false); F(tk::OpenBrace, hi::Structure);
403 <Div>"}" L S(template_); F(tk::CloseBrace, hi::Structure);
404
405 "[" L F(tk::OpenBracket, hi::Structure);
406 "]" L F(tk::CloseBracket, hi::Structure);
407 /* }}} */
408 /* Keyword {{{ */
409 "@error" L F(tk::At_error_, hi::Error);
410
411 @begin Java
412 "@class" L F(tk::At_class_, hi::Meta);
413 @end
414
415 @begin C
416 "@encode" L F(tk::At_encode_, hi::Meta);
417 @end
418
419 @begin ObjectiveC
420 "@end" L F(tk::At_end_, hi::Meta);
421 "@false" L F(tk::At_false_, hi::Constant);
422 "@implementation" L F(tk::At_implementation_, hi::Meta);
423 "@import" L F(tk::At_import_, hi::Special);
424 "@NO" L F(tk::At_NO_, hi::Constant);
425 "@null" L F(tk::At_null_, hi::Constant);
426 "@selector" L F(tk::At_selector_, hi::Meta);
427 "@true" L F(tk::At_true_, hi::Constant);
428 "@YES" L F(tk::At_YES_, hi::Constant);
429 @end
430
431 @({UnicodeStart}{UnicodePart}*{UnicodeError}?|{UnicodeError}) L E("invalid keyword")
432 /* }}} */
433 /* Highlight {{{ */
434 "undefined" L F(tk::_undefined_, hi::Operator);
435
436 @begin ObjectiveC
437 "bool" L F(tk::_bool_, hi::Type);
438 "BOOL" L F(tk::_BOOL_, hi::Type);
439 "id" L F(tk::_id_, hi::Type);
440 "nil" L F(tk::_nil_, hi::Constant);
441 "NULL" L F(tk::_NULL_, hi::Constant);
442 "SEL" L F(tk::_SEL_, hi::Type);
443 @end
444 /* }}} */
445 /* Reserved {{{ */
446 "abstract" L /*FII*/ F(tk::_abstract_, hi::Meta);
447 "as" L /*III*/ F(tk::_as_, hi::Meta);
448 "await" L /*II?*/ F(tk::_await_, hi::Meta);
449 "boolean" L /*FII*/ F(tk::_boolean_, hi::Type);
450 "break" L /*KKK*/ F(tk::_break_, hi::Control);
451 "byte" L /*FII*/ F(tk::_byte_, hi::Type);
452 "case" L /*KKK*/ F(tk::_case_, hi::Control);
453 "catch" L /*KKK*/ F(tk::_catch_, hi::Control);
454 "char" L /*FII*/ F(tk::_char_, hi::Type);
455 "class" L /*FFK*/ F(tk::_class_, hi::Meta);
456 "const" L /*FFK*/ F(tk::_const_, hi::Meta);
457 "constructor" L /*III*/ F(tk::_constructor_, hi::Special);
458 "continue" L /*KKK*/ F(tk::_continue_, hi::Control);
459 "debugger" L /*FKK*/ F(tk::_debugger_, hi::Meta);
460 "default" L /*KKK*/ F(tk::_default_, hi::Control);
461 "delete" L /*KKK*/ F(tk::_delete_, hi::Operator);
462 "do" L /*KKK*/ F(tk::_do_, hi::Control);
463 "double" L /*FII*/ F(tk::_double_, hi::Type);
464 "else" L /*KKK*/ F(tk::_else_, hi::Control);
465 "enum" L /*FFF*/ F(tk::_enum_, hi::Meta);
466 "export" L /*FFK*/ F(tk::_export_, hi::Meta);
467 "extends" L /*FFK*/ F(tk::_extends_, hi::Meta);
468 "eval" L /*III*/ F(tk::_eval_, hi::Special);
469 "false" L /*LLL*/ F(tk::_false_, hi::Constant);
470 "final" L /*FII*/ F(tk::_final_, hi::Meta);
471 "finally" L /*KKK*/ F(tk::_finally_, hi::Control);
472 "float" L /*FII*/ F(tk::_float_, hi::Type);
473 "for" L /*KKK*/ F(tk::_for_, hi::Control);
474 "from" L /*III*/ F(tk::_from_, hi::Meta);
475 "function" L /*KKK*/ F(tk::_function_, hi::Meta);
476 "goto" L /*FII*/ F(tk::_goto_, hi::Control);
477 "get" L /*III*/ F(tk::_get_, hi::Meta);
478 "if" L /*KKK*/ F(tk::_if_, hi::Control);
479 "implements" L /*FSS*/ F(tk::_implements_, hi::Meta);
480 "import" L /*FFK*/ F(tk::_import_, hi::Meta);
481 "in" L /*KKK*/ F(tk::_in_, hi::Operator);
482 "Infinity" L /*III*/ F(tk::_Infinity_, hi::Constant);
483 "instanceof" L /*KKK*/ F(tk::_instanceof_, hi::Operator);
484 "int" L /*FII*/ F(tk::_int_, hi::Type);
485 "interface" L /*FSS*/ F(tk::_interface_, hi::Meta);
486 "let" L /*IS?*/ F(tk::_let_, hi::Meta);
487 "long" L /*FII*/ F(tk::_long_, hi::Type);
488 "native" L /*FII*/ F(tk::_native_, hi::Meta);
489 "new" L /*KKK*/ F(tk::_new_, hi::Operator);
490 "null" L /*LLL*/ F(tk::_null_, hi::Constant);
491 "package" L /*FSS*/ F(tk::_package_, hi::Meta);
492 "private" L /*FSS*/ F(tk::_private_, hi::Meta);
493 "protected" L /*FSS*/ F(tk::_protected_, hi::Meta);
494 "__proto__" L /*III*/ F(tk::___proto___, hi::Special);
495 "prototype" L /*III*/ F(tk::_prototype_, hi::Special);
496 "public" L /*FSS*/ F(tk::_public_, hi::Meta);
497 "__restrict" L /*III*/ F(tk::___restrict_, hi::Meta);
498 "restrict" L /*III*/ F(tk::_restrict_, hi::Meta);
499 "return" L /*KKK*/ F(tk::_return_, hi::Control);
500 "set" L /*III*/ F(tk::_set_, hi::Meta);
501 "short" L /*FII*/ F(tk::_short_, hi::Type);
502 "static" L /*FS?*/ F(tk::_static_, hi::Meta);
503 "super" L /*FFK*/ F(tk::_super_, hi::Constant);
504 "switch" L /*KKK*/ F(tk::_switch_, hi::Control);
505 "synchronized" L /*FII*/ F(tk::_synchronized_, hi::Meta);
506 "target" L /*III*/ F(tk::_target_, hi::Identifier);
507 "this" L /*KKK*/ F(tk::_this_, hi::Constant);
508 "throw" L /*KKK*/ F(tk::_throw_, hi::Control);
509 "throws" L /*FII*/ F(tk::_throws_, hi::Meta);
510 "transient" L /*FII*/ F(tk::_transient_, hi::Meta);
511 "true" L /*LLL*/ F(tk::_true_, hi::Constant);
512 "try" L /*KKK*/ F(tk::_try_, hi::Control);
513 "typeof" L /*KKK*/ F(tk::_typeof_, hi::Operator);
514 "var" L /*KKK*/ F(tk::_var_, hi::Meta);
515 "void" L /*KKK*/ F(tk::_void_, hi::Operator);
516 "volatile" L /*FII*/ F(tk::_volatile_, hi::Meta);
517 "while" L /*KKK*/ F(tk::_while_, hi::Control);
518 "with" L /*KKK*/ F(tk::_with_, hi::Control);
519 "yield" L /*IS?*/ F(tk::_yield_, hi::Control);
520
521 "each" L F(tk::_each_, hi::Control);
522 "of" L F(tk::_of_, hi::Operator);
523
524 @begin C
525 "extern" L F(tk::_extern_, hi::Type);
526 "signed" L F(tk::_signed_, hi::Type);
527 "struct" L F(tk::_struct_, hi::Meta);
528 "typedef" L F(tk::_typedef_, hi::Meta);
529 "unsigned" L F(tk::_unsigned_, hi::Type);
530 @end
531
532 @begin ObjectiveC
533 "NO" L F(tk::_NO_, hi::Constant);
534 "YES" L F(tk::_YES_, hi::Constant);
535 @end
536
537 @begin E4X
538 "namespace" L F(tk::_namespace_, hi::Meta);
539 "xml" L F(tk::_xml_, hi::Meta);
540 @end
541 /* }}} */
542 /* Identifier {{{ */
543 {UnicodeStart}{UnicodePart}* L I(identifier, Identifier(Y), tk::Identifier_, hi::Identifier);
544
545 {IdentifierStart}{IdentifierPart}* L {
546 char *value(A char[yyleng + 1]);
547 char *local(value);
548
549 for (yy_size_t i(0), e(yyleng); i != e; ++i) {
550 char next(yytext[i]);
551 if (next != '\\')
552 *local++ = next;
553 else {
554 bool (*is)(unsigned) = (i == 0 ? &IsIdentifierStart : &IsIdentifierContinue);
555 unsigned point(U(local, yytext, ++i));
556 if (!is(point))
557 E("invalid character");
558 }
559 }
560
561 *local = '\0';
562 I(identifier, Identifier(value), tk::Identifier_, hi::Identifier);
563 }
564
565 ({IdentifierStart}{IdentifierPart}*)?{IdentifierFail} L E("invalid identifier")
566 /* }}} */
567 /* Number {{{ */
568 0[0-7]+ L I(number, Number(strtoull(yytext + 1, NULL, 8)), tk::NumericLiteral, hi::Constant);
569 0[0-9]+ L I(number, Number(strtoull(yytext + 1, NULL, 10)), tk::NumericLiteral, hi::Constant);
570
571 0[xX][0-9a-fA-F]+ L I(number, Number(strtoull(yytext + 2, NULL, 16)), tk::NumericLiteral, hi::Constant);
572 0[oO][0-7]+ L I(number, Number(strtoull(yytext + 2, NULL, 8)), tk::NumericLiteral, hi::Constant);
573 0[bB][0-1]+ L I(number, Number(strtoull(yytext + 2, NULL, 2)), tk::NumericLiteral, hi::Constant);
574
575 (\.[0-9]+|(0|[1-9][0-9]*)(\.[0-9]*)?)([eE][+-]?[0-9]+)? L I(number, Number(strtod(yytext, NULL)), tk::NumericLiteral, hi::Constant);
576 (\.[0-9]+|(0|[1-9][0-9]*)(\.[0-9]*)?)[eE][+-]?{IdentifierScrap} L E("invalid exponent")
577 (\.?[0-9]|(0|[1-9][0-9]*)\.){IdentifierScrap} L E("invalid number")
578 /* }}} */
579 /* String {{{ */
580 \' L CYLexBufferStart(LegacySingleString);
581 <LegacySingleString,StrictSingleString>{
582 \' R CYLexBufferEnd(string, String, tk::StringLiteral, hi::Constant);
583 {SingleCharacter}+ R CYLexBufferUnits(yytext, yyleng);
584 {SingleCharacter}*{LineTerminatorSequence} R E("invalid newline");
585 {SingleCharacter}*{UnicodeScrap} R E("invalid character");
586 }
587
588 \" L CYLexBufferStart(LegacyDoubleString);
589 <LegacyDoubleString,StrictDoubleString>{
590 \" R CYLexBufferEnd(string, String, tk::StringLiteral, hi::Constant);
591 {DoubleCharacter}+ R CYLexBufferUnits(yytext, yyleng);
592 {DoubleCharacter}*{LineTerminatorSequence} R E("invalid newline");
593 {DoubleCharacter}*{UnicodeScrap} R E("invalid character");
594 }
595 /* }}} */
596 /* Template {{{ */
597 "`" L yyextra->tail_ = false; CYLexBufferStart(StrictAccentString);
598 <DivOrTemplateTail>"}" L yyextra->tail_ = true; S(template_); CYLexBufferStart(StrictAccentString);
599
600 <StrictAccentString>{
601 "`" R CYLexBufferEnd(string, String, yyextra->tail_ ? tk::TemplateTail : tk::NoSubstitutionTemplate, hi::Constant);
602 "${" R yyextra->template_.push(true); CYLexBufferEnd(string, String, yyextra->tail_ ? tk::TemplateMiddle : tk::TemplateHead, hi::Constant);
603
604 "$" R CYLexBufferUnit('$');
605
606 {PlateCharacter}+ R CYLexBufferUnits(yytext, yyleng);
607 {PlateCharacter}*{LineTerminatorSequence} R E("invalid newline");
608 {PlateCharacter}*{UnicodeScrap} R E("invalid character");
609 }
610 /* }}} */
611 /* Escapes {{{ */
612 <LegacySingleString,LegacyDoubleString>{
613 \\[0-3][0-7][0-7] R CYLexBufferPoint(X(yytext[1]) << 6 | X(yytext[2]) << 3 | X(yytext[3]));
614 \\[0-7][0-7] R CYLexBufferUnit(X(yytext[1]) << 3 | X(yytext[2]));
615 \\[0-7] R CYLexBufferUnit(X(yytext[1]));
616 }
617
618 <StrictSingleString,StrictDoubleString,StrictAccentString>{
619 \\0[0-7] R E("legacy escape");
620 \\0 R CYLexBufferUnit('\0');
621 }
622
623 <LegacySingleString,LegacyDoubleString,StrictSingleString,StrictDoubleString,StrictAccentString>{
624 \\b R CYLexBufferUnit('\b');
625 \\f R CYLexBufferUnit('\f');
626 \\n R CYLexBufferUnit('\n');
627 \\r R CYLexBufferUnit('\r');
628 \\t R CYLexBufferUnit('\t');
629 \\v R CYLexBufferUnit('\v');
630
631 \\x{HexDigit}{2} R CYLexBufferPoint(X(yytext[2]) << 4 | X(yytext[3]));
632
633 \\u{HexDigit}{4} R CYLexBufferPoint(X(yytext[2]) << 12 | X(yytext[3]) << 8 | X(yytext[4]) << 4 | X(yytext[5]));
634
635 \\u\{{HexDigit}+\} R {
636 unsigned point(0);
637 for (yy_size_t i(3); i != yyleng - 1; ++i)
638 point = point << 4 | X(yytext[i]);
639 CYLexBufferPoint(point);
640 }
641
642 \\{LineTerminatorSequence} yylloc->end.Lines();
643 \\{NoneTerminatorCharacter} R CYLexBufferUnits(yytext + 1, yyleng - 1);
644 \\{UnicodeScrap} R E("invalid character");
645
646 \\(x{HexDigit}{0,1}|u({HexDigit}{0,3}|\{{HexDigit}*))? R E("invalid escape");
647 <<EOF>> R E("invalid string");
648 }
649 /* }}} */
650
651 {LineTerminatorSequence} yylloc->step(); yylloc->end.Lines(); yyextra->last_ = true; N
652 {WhiteSpace} L
653 {U1}|{UnicodeScrap} L E("invalid character");
654
655 <<EOF>> if (yyextra->auto_) { yyextra->auto_ = false; F(tk::AutoComplete, hi::Nothing); } L yyterminate();
656
657 %%
658
659 #undef yyextra
660 #define yyextra this
661 #define yyscanner scanner_
662
663 void CYDriver::ScannerInit() {
664 cylex_init(&scanner_);
665 cyset_extra(this, scanner_);
666 }
667
668 void CYDriver::ScannerDestroy() {
669 cylex_destroy(scanner_);
670 }
671
672 void CYDriver::SetRegEx(bool equal) {
673 CYLexBufferStart(RegularExpression);
674 CYLexBufferUnit('/');
675 if (equal)
676 CYLexBufferUnit('=');
677 }
678
679 void CYDriver::SetCondition(Condition condition) {
680 struct yyguts_t *yyg(reinterpret_cast<struct yyguts_t *>(scanner_));
681
682 switch (condition) {
683 @begin E4X
684 case XMLContentCondition:
685 BEGIN(XMLContent);
686 break;
687 case XMLTagCondition:
688 BEGIN(XMLTag);
689 break;
690 @end
691 default:
692 _assert(false);
693 }
694 }
695
696 void CYDriver::PushCondition(Condition condition) {
697 switch (condition) {
698 @begin E4X
699 case XMLContentCondition:
700 yy_push_state(XMLContent, scanner_);
701 break;
702 case XMLTagCondition:
703 yy_push_state(XMLTag, scanner_);
704 break;
705 @end
706 default:
707 _assert(false);
708 }
709 }
710
711 void CYDriver::PopCondition() {
712 yy_pop_state(scanner_);
713 }
714
715 bool CYLexerHighlight(hi::Value &highlight, CYLocation &location, void *scanner) {
716 YYSTYPE value;
717 if (cylex(&value, &location, scanner) == 0)
718 return false;
719 highlight = value.highlight_;
720 return true;
721 }
722
723 #if defined(__clang__)
724 #pragma clang diagnostic pop
725 #else
726 // must not pop -Wunused-function
727 //#pragma GCC diagnostic pop
728 #endif