| 1 | /* Cycript - Optimizing JavaScript Compiler/Runtime |
| 2 | * Copyright (C) 2009-2013 Jay Freeman (saurik) |
| 3 | */ |
| 4 | |
| 5 | /* GNU General Public License, Version 3 {{{ */ |
| 6 | /* |
| 7 | * Cycript is free software: you can redistribute it and/or modify |
| 8 | * it under the terms of the GNU General Public License as published |
| 9 | * by the Free Software Foundation, either version 3 of the License, |
| 10 | * or (at your option) any later version. |
| 11 | * |
| 12 | * Cycript is distributed in the hope that it will be useful, but |
| 13 | * WITHOUT ANY WARRANTY; without even the implied warranty of |
| 14 | * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the |
| 15 | * GNU General Public License for more details. |
| 16 | * |
| 17 | * You should have received a copy of the GNU General Public License |
| 18 | * along with Cycript. If not, see <http://www.gnu.org/licenses/>. |
| 19 | **/ |
| 20 | /* }}} */ |
| 21 | |
| 22 | /* XXX: supposedly I will be screwed on very very long multi-line comments and need to replace these with a manual lexer. http://websrv.cs.fsu.edu/~engelen/courses/COP5621/Pr2.pdf */ |
| 23 | |
| 24 | %{ |
| 25 | #define YYLTYPE cy::location |
| 26 | #include "Cycript.tab.hh" |
| 27 | typedef cy::parser::token tk; |
| 28 | |
| 29 | #include "Highlight.hpp" |
| 30 | |
| 31 | #define YY_EXTRA_TYPE CYDriver * |
| 32 | |
| 33 | // do /not/ fold token to the return: this is a macro and the ordering is dependent |
| 34 | #define F(value, highlight) do { \ |
| 35 | int token(value); \ |
| 36 | @begin ObjectiveC |
| 37 | yyextra->no_.AtImplementation = false; \ |
| 38 | @end |
| 39 | yyextra->no_.Function = false; \ |
| 40 | yyextra->no_.OpenBrace = false; \ |
| 41 | yylval->highlight_ = highlight; \ |
| 42 | return token; \ |
| 43 | } while (false) |
| 44 | |
| 45 | #define A new($pool) |
| 46 | #define Y $pool.strmemdup(yytext, yyleng) |
| 47 | |
| 48 | #define I(type, Type, value, highlight) do { \ |
| 49 | yylval->type ## _ = A CY ## Type; \ |
| 50 | F(value, highlight); \ |
| 51 | } while (false) |
| 52 | |
| 53 | #define T yylval->newline_ = yyextra->state_ == CYNewLine; BEGIN(Div); |
| 54 | #define C T yyextra->state_ = CYClear; |
| 55 | #define R T yyextra->state_ = CYRestricted; |
| 56 | |
| 57 | #define N \ |
| 58 | if (yyextra->state_ != CYNewLine) { \ |
| 59 | if (yyextra->state_ != CYRestricted) \ |
| 60 | yyextra->state_ = CYNewLine; \ |
| 61 | else { \ |
| 62 | yyextra->state_ = CYClear; \ |
| 63 | F(tk::NewLine, hi::Nothing); \ |
| 64 | } \ |
| 65 | } |
| 66 | |
| 67 | #define V(more) { \ |
| 68 | if (const char *nl = reinterpret_cast<const char *>(memchr(yytext, '\n', yyleng))) { \ |
| 69 | unsigned lines(0); \ |
| 70 | size_t left; \ |
| 71 | do { \ |
| 72 | ++lines; \ |
| 73 | left = yyleng - (nl - yytext) - 1; \ |
| 74 | nl = reinterpret_cast<const char *>(memchr(nl + 1, '\n', left)); \ |
| 75 | } while (nl != NULL); \ |
| 76 | yylloc->end.lines(lines); \ |
| 77 | yylloc->end.columns(left); \ |
| 78 | yylloc->step(); \ |
| 79 | more \ |
| 80 | } else L \ |
| 81 | } |
| 82 | |
| 83 | #define L { \ |
| 84 | yylloc->step(); \ |
| 85 | yylloc->columns(yyleng); \ |
| 86 | } |
| 87 | |
| 88 | #define M { \ |
| 89 | if (yyextra->commented_) { \ |
| 90 | I(comment, Comment(Y), tk::Comment, hi::Comment); \ |
| 91 | } \ |
| 92 | } |
| 93 | |
| 94 | int H(char c) { |
| 95 | if (c >= '0' && c <= '9') |
| 96 | return c - '0'; |
| 97 | if (c >= 'a' && c <= 'f') |
| 98 | return c - 'a' + 10; |
| 99 | if (c >= 'A' && c <= 'F') |
| 100 | return c - 'A' + 10; |
| 101 | return -1; |
| 102 | } |
| 103 | |
| 104 | #define YY_INPUT(data, value, size) { \ |
| 105 | if (yyextra->data_.eof()) \ |
| 106 | value = YY_NULL; \ |
| 107 | else { \ |
| 108 | yyextra->data_.read(data, size); \ |
| 109 | size_t copy(yyextra->data_.gcount()); \ |
| 110 | value = copy == 0 ? YY_NULL : copy; \ |
| 111 | } \ |
| 112 | } |
| 113 | |
| 114 | %} |
| 115 | |
| 116 | %option prefix="cy" |
| 117 | %option bison-bridge |
| 118 | %option bison-locations |
| 119 | %option noyywrap |
| 120 | %option yylineno |
| 121 | %option nounput |
| 122 | %option interactive |
| 123 | %option reentrant |
| 124 | %option stack |
| 125 | |
| 126 | Exponent [eE][+-]?[0-9]+ |
| 127 | Escape \\[\\'"bfnrtv]|\\0|\\x[0-9a-fA-F]{2}|\\u[0-9a-fA-F]{4}|\\\n |
| 128 | |
| 129 | IdentifierStart [a-zA-Z$_] |
| 130 | IdentifierPart [a-zA-Z$_0-9] |
| 131 | |
| 132 | NonTerminator [^\n] |
| 133 | BackslashSequence \\{NonTerminator} |
| 134 | RegularExpressionFirstChar [^\n*\\/]|{BackslashSequence} |
| 135 | RegularExpressionChar [^\n\\/]|{BackslashSequence} |
| 136 | RegularExpressionFlags {IdentifierPart}* |
| 137 | RegularExpressionChars {RegularExpressionChar}* |
| 138 | RegularExpressionBody {RegularExpressionFirstChar}{RegularExpressionChars} |
| 139 | |
| 140 | @begin E4X |
| 141 | XMLNameStart [a-zA-Z_:] |
| 142 | XMLNamePart [a-zA-Z0-9.-_:] |
| 143 | XMLName {XMLNameStart}{XMLNamePart}* |
| 144 | @end |
| 145 | |
| 146 | %s Div |
| 147 | %s RegExp |
| 148 | |
| 149 | @begin E4X |
| 150 | %x XMLContent |
| 151 | %x XMLTag |
| 152 | @end |
| 153 | |
| 154 | %% |
| 155 | |
| 156 | <RegExp>\/{RegularExpressionBody}\/{RegularExpressionFlags} L C I(literal, RegEx(Y), tk::RegularExpressionLiteral, hi::Constant); |
| 157 | |
| 158 | \/\/[^\n]* L M |
| 159 | |
| 160 | /* http://ostermiller.org/findcomment.html */ |
| 161 | /* XXX: unify these two rules using !? */ |
| 162 | \/\*!([^*]|[\r\n]|(\*+([^*/]|[\r\n])))*\*+\/ V() C I(comment, Comment(Y), tk::Comment, hi::Comment); |
| 163 | \/\*([^*]|[\r\n]|(\*+([^*/]|[\r\n])))*\*+\/ V(N) M |
| 164 | |
| 165 | @begin E4X |
| 166 | <RegExp>"<>" L F(tk::LeftRight, hi::Structure); |
| 167 | <XMLContent>"</>" L F(tk::LeftSlashRight, hi::Structure); |
| 168 | |
| 169 | <RegExp,XMLContent>\<!\[CDATA\[(\n|[^[]|\[[^[]|\[\[[^>])*]]> V() F(tk::XMLCDATA, hi::Constant); |
| 170 | <RegExp,XMLContent>\<!--(\n|[^-]|-[^-])*--> V() F(tk::XMLComment, hi::Comment); |
| 171 | <RegExp,XMLContent>\<?(\n|[^?]|\?[^>])*?> V() F(tk::XMLPI, hi::Meta); |
| 172 | |
| 173 | <XMLTag>"=" L F(tk::Equal, hi::Structure); |
| 174 | <XMLTag>">" L F(tk::Right, hi::Structure); |
| 175 | <XMLTag>"/>" L F(tk::SlashRight, hi::Structure); |
| 176 | <XMLTag>"{" L F(tk::OpenBrace, hi::Structure); |
| 177 | |
| 178 | <XMLTag>\"(\n|[^"])*\"|'(\n|[^'])*' V() F(tk::XMLAttributeValue, hi::Constant); |
| 179 | <XMLTag>{XMLName} L F(tk::XMLName, hi::Identifier); |
| 180 | <XMLTag>[ \t\r\n] V() F(tk::XMLWhitespace, hi::Nothing); |
| 181 | |
| 182 | <XMLContent>"{" L F(tk::OpenBrace, hi::Structure); |
| 183 | <XMLContent>"<" L F(tk::Left, hi::Structure); |
| 184 | <XMLContent>"</" L F(tk::LeftSlash, hi::Structure); |
| 185 | @end |
| 186 | |
| 187 | "..." L C F(tk::PeriodPeriodPeriod, hi::Meta); |
| 188 | |
| 189 | @begin E4X |
| 190 | "::" L C F(tk::ColonColon, hi::Operator); |
| 191 | ".." L C F(tk::PeriodPeriod, hi::Operator); |
| 192 | @end |
| 193 | |
| 194 | @begin E4X ObjectiveC |
| 195 | "@" L C F(tk::At, hi::Operator); |
| 196 | @end |
| 197 | |
| 198 | "&" L C F(tk::Ampersand, hi::Operator); |
| 199 | "&&" L C F(tk::AmpersandAmpersand, hi::Operator); |
| 200 | "&=" L C F(tk::AmpersandEqual, hi::Operator); |
| 201 | "^" L C F(tk::Carrot, hi::Operator); |
| 202 | "^=" L C F(tk::CarrotEqual, hi::Operator); |
| 203 | "=" L C F(tk::Equal, hi::Operator); |
| 204 | "==" L C F(tk::EqualEqual, hi::Operator); |
| 205 | "===" L C F(tk::EqualEqualEqual, hi::Operator); |
| 206 | "=>" L C F(tk::EqualRight, hi::Operator); |
| 207 | "!" L C F(tk::Exclamation, hi::Operator); |
| 208 | "!=" L C F(tk::ExclamationEqual, hi::Operator); |
| 209 | "!==" L C F(tk::ExclamationEqualEqual, hi::Operator); |
| 210 | "-" L C F(tk::Hyphen, hi::Operator); |
| 211 | "-=" L C F(tk::HyphenEqual, hi::Operator); |
| 212 | "--" L C F(yylval->newline_ ? tk::HyphenHyphen_ : tk::HyphenHyphen, hi::Operator); |
| 213 | "->" L C F(tk::HyphenRight, hi::Operator); |
| 214 | "<" L C F(tk::Left, hi::Operator); |
| 215 | "<=" L C F(tk::LeftEqual, hi::Operator); |
| 216 | "<<" L C F(tk::LeftLeft, hi::Operator); |
| 217 | "<<=" L C F(tk::LeftLeftEqual, hi::Operator); |
| 218 | "%" L C F(tk::Percent, hi::Operator); |
| 219 | "%=" L C F(tk::PercentEqual, hi::Operator); |
| 220 | "." L C F(tk::Period, hi::Operator); |
| 221 | "|" L C F(tk::Pipe, hi::Operator); |
| 222 | "|=" L C F(tk::PipeEqual, hi::Operator); |
| 223 | "||" L C F(tk::PipePipe, hi::Operator); |
| 224 | "+" L C F(tk::Plus, hi::Operator); |
| 225 | "+=" L C F(tk::PlusEqual, hi::Operator); |
| 226 | "++" L C F(yylval->newline_ ? tk::PlusPlus_ : tk::PlusPlus, hi::Operator); |
| 227 | ">" L C F(tk::Right, hi::Operator); |
| 228 | ">=" L C F(tk::RightEqual, hi::Operator); |
| 229 | ">>" L C F(tk::RightRight, hi::Operator); |
| 230 | ">>=" L C F(tk::RightRightEqual, hi::Operator); |
| 231 | ">>>" L C F(tk::RightRightRight, hi::Operator); |
| 232 | ">>>=" L C F(tk::RightRightRightEqual, hi::Operator); |
| 233 | "*" L C F(tk::Star, hi::Operator); |
| 234 | "*=" L C F(tk::StarEqual, hi::Operator); |
| 235 | "~" L C F(tk::Tilde, hi::Operator); |
| 236 | |
| 237 | <Div>"/" L C F(tk::Slash, hi::Operator); |
| 238 | <Div>"/=" L C F(tk::SlashEqual, hi::Operator); |
| 239 | |
| 240 | ":" L C F(tk::Colon, hi::Structure); |
| 241 | "," L C F(tk::Comma, hi::Structure); |
| 242 | "?" L C F(tk::Question, hi::Structure); |
| 243 | ";" L C F(tk::SemiColon, hi::Structure); |
| 244 | |
| 245 | "(" L C F(tk::OpenParen, hi::Structure); |
| 246 | ")" L C F(tk::CloseParen, hi::Structure); |
| 247 | |
| 248 | "{" L C F(yyextra->no_.OpenBrace ? tk::OpenBrace__ : yylval->newline_ ? tk::OpenBrace_ : tk::OpenBrace, hi::Structure); |
| 249 | "}" L C F(tk::CloseBrace, hi::Structure); |
| 250 | |
| 251 | "[" L C F(tk::OpenBracket, hi::Structure); |
| 252 | "]" L C F(tk::CloseBracket, hi::Structure); |
| 253 | |
| 254 | @begin Java |
| 255 | "@class" L C F(tk::AtClass, hi::Meta); |
| 256 | @end |
| 257 | |
| 258 | @begin ObjectiveC |
| 259 | "@encode" L C F(tk::AtEncode, hi::Meta); |
| 260 | "@end" L C F(tk::AtEnd, hi::Meta); |
| 261 | "@implementation" L C F(yyextra->no_.AtImplementation ? tk::AtImplementation_ : tk::AtImplementation, hi::Meta); |
| 262 | "@import" L C F(tk::AtImport, hi::Meta); |
| 263 | "@selector" L C F(tk::AtSelector, hi::Meta); |
| 264 | |
| 265 | "NULL" L C I(identifier, Identifier("NULL"), tk::Identifier_, hi::Constant); |
| 266 | "nil" L C I(identifier, Identifier("nil"), tk::Identifier_, hi::Constant); |
| 267 | "YES" L C I(identifier, Identifier("YES"), tk::Identifier_, hi::Constant); |
| 268 | "NO" L C I(identifier, Identifier("NO"), tk::Identifier_, hi::Constant); |
| 269 | |
| 270 | "bool" L C I(identifier, Identifier("bool"), tk::Identifier_, hi::Type); |
| 271 | "BOOL" L C I(identifier, Identifier("BOOL"), tk::Identifier_, hi::Type); |
| 272 | "id" L C I(identifier, Identifier("id"), tk::Identifier_, hi::Type); |
| 273 | @end |
| 274 | |
| 275 | "undefined" L C I(identifier, Identifier("undefined"), tk::Identifier_, hi::Operator); |
| 276 | |
| 277 | "false" L C I(false, False(), tk::False, hi::Constant); |
| 278 | "null" L C I(null, Null(), tk::Null, hi::Constant); |
| 279 | "true" L C I(true, True(), tk::True, hi::Constant); |
| 280 | |
| 281 | "auto" L C I(word, Word("auto"), tk::Auto, hi::Meta); |
| 282 | "break" L R I(word, Word("break"), tk::Break, hi::Control); |
| 283 | "case" L C I(word, Word("case"), tk::Case, hi::Control); |
| 284 | "catch" L C I(word, Word("catch"), tk::Catch, hi::Control); |
| 285 | "continue" L R I(word, Word("continue"), tk::Continue, hi::Control); |
| 286 | "default" L C I(word, Word("default"), tk::Default, hi::Control); |
| 287 | "delete" L C I(word, Word("delete"), tk::Delete, hi::Operator); |
| 288 | "do" L C I(word, Word("do"), tk::Do, hi::Control); |
| 289 | "else" L C I(word, Word("else"), tk::Else, hi::Control); |
| 290 | "finally" L C I(word, Word("finally"), tk::Finally, hi::Control); |
| 291 | "for" L C I(word, Word("for"), tk::For, hi::Control); |
| 292 | "function" L C I(word, Word("function"), yyextra->no_.Function ? tk::Function_ : tk::Function, hi::Meta); |
| 293 | "if" L C I(word, Word("if"), tk::If, hi::Control); |
| 294 | "in" L C I(word, Word("in"), yyextra->in_.top() ? tk::In_ : tk::In, hi::Operator); |
| 295 | "instanceof" L C I(word, Word("instanceof"), tk::InstanceOf, hi::Operator); |
| 296 | "new" L C I(word, Word("new"), tk::New, hi::Operator); |
| 297 | "return" L R I(word, Word("return"), tk::Return, hi::Control); |
| 298 | "switch" L C I(word, Word("switch"), tk::Switch, hi::Control); |
| 299 | "this" L C I(this, This(), tk::This, hi::Constant); |
| 300 | "throw" L R I(word, Word("throw"), tk::Throw, hi::Control); |
| 301 | "try" L C I(word, Word("try"), tk::Try, hi::Control); |
| 302 | "typeof" L C I(word, Word("typeof"), tk::TypeOf, hi::Operator); |
| 303 | "var" L C I(word, Word("var"), tk::Var, hi::Meta); |
| 304 | "void" L C I(word, Word("void"), tk::Void, hi::Operator); |
| 305 | "while" L C I(word, Word("while"), tk::While, hi::Control); |
| 306 | "with" L C I(word, Word("with"), tk::With, hi::Control); |
| 307 | |
| 308 | "debugger" L C I(word, Word("debugger"), tk::Debugger, hi::Meta); |
| 309 | |
| 310 | "const" L C I(word, Word("const"), tk::Const, hi::Meta); |
| 311 | |
| 312 | "class" L C I(word, Word("class"), tk::Class, hi::Meta); |
| 313 | "enum" L C I(word, Word("enum"), tk::Enum, hi::Meta); |
| 314 | "export" L C I(word, Word("export"), tk::Export, hi::Meta); |
| 315 | "extends" L C I(word, Word("extends"), tk::Extends, hi::Meta); |
| 316 | "import" L C I(word, Word("import"), tk::Import, hi::Meta); |
| 317 | "super" L C I(word, Word("super"), tk::Super, hi::Constant); |
| 318 | |
| 319 | "implements" L C I(identifier, Identifier("implements"), tk::Implements, hi::Meta); |
| 320 | "interface" L C I(identifier, Identifier("interface"), tk::Interface, hi::Meta); |
| 321 | "package" L C I(identifier, Identifier("package"), tk::Package, hi::Meta); |
| 322 | "private" L C I(identifier, Identifier("private"), tk::Private, hi::Meta); |
| 323 | "protected" L C I(identifier, Identifier("protected"), tk::Protected, hi::Meta); |
| 324 | "public" L C I(identifier, Identifier("public"), tk::Public, hi::Meta); |
| 325 | "static" L C I(identifier, Identifier("static"), tk::Static, hi::Meta); |
| 326 | |
| 327 | "abstract" L C I(identifier, Identifier("abstract"), tk::Abstract, hi::Meta); |
| 328 | "boolean" L C I(identifier, Identifier("boolean"), tk::Boolean, hi::Type); |
| 329 | "byte" L C I(identifier, Identifier("byte"), tk::Byte, hi::Type); |
| 330 | "char" L C I(identifier, Identifier("char"), tk::Char, hi::Type); |
| 331 | "double" L C I(identifier, Identifier("double"), tk::Double, hi::Type); |
| 332 | "final" L C I(identifier, Identifier("final"), tk::Final, hi::Meta); |
| 333 | "float" L C I(identifier, Identifier("float"), tk::Float, hi::Type); |
| 334 | "goto" L C I(identifier, Identifier("goto"), tk::Goto, hi::Control); |
| 335 | "int" L C I(identifier, Identifier("int"), tk::Int, hi::Type); |
| 336 | "long" L C I(identifier, Identifier("long"), tk::Long, hi::Type); |
| 337 | "native" L C I(identifier, Identifier("native"), tk::Native, hi::Meta); |
| 338 | "short" L C I(identifier, Identifier("short"), tk::Short, hi::Type); |
| 339 | "synchronized" L C I(identifier, Identifier("synchronized"), tk::Synchronized, hi::Meta); |
| 340 | "throws" L C I(identifier, Identifier("throws"), tk::Throws, hi::Meta); |
| 341 | "transient" L C I(identifier, Identifier("transient"), tk::Transient, hi::Meta); |
| 342 | "volatile" L C I(identifier, Identifier("volatile"), tk::Volatile, hi::Meta); |
| 343 | |
| 344 | "let" L C I(identifier, Identifier("let"), tk::Let, hi::Meta); |
| 345 | "yield" L C I(identifier, Identifier("yield"), tk::Yield, hi::Control); |
| 346 | |
| 347 | "each" L C I(identifier, Identifier("each"), tk::Each, hi::Control); |
| 348 | "of" L C I(identifier, Identifier("of"), tk::Of, hi::Operator); |
| 349 | |
| 350 | @begin E4X |
| 351 | "namespace" L C I(identifier, Identifier("namespace"), tk::Namespace, hi::Meta); |
| 352 | "xml" L C I(identifier, Identifier("xml"), tk::XML, hi::Meta); |
| 353 | @end |
| 354 | |
| 355 | {IdentifierStart}{IdentifierPart}* L C I(identifier, Identifier(Y), tk::Identifier_, hi::Identifier); |
| 356 | |
| 357 | (\.[0-9]+|(0|[1-9][0-9]*)(\.[0-9]*)?){Exponent}? L C I(number, Number(strtod(yytext, NULL)), tk::NumericLiteral, hi::Constant); |
| 358 | |
| 359 | 0[xX][0-9a-fA-F]+ L C I(number, Number(strtoull(yytext + 2, NULL, 16)), tk::NumericLiteral, hi::Constant); |
| 360 | 0[0-7]+ L C I(number, Number(strtoull(yytext + 1, NULL, 8)), tk::NumericLiteral, hi::Constant); |
| 361 | 0[bB][0-1]+ L C I(number, Number(strtoull(yytext + 2, NULL, 2)), tk::NumericLiteral, hi::Constant); |
| 362 | |
| 363 | \"([^"\\\n]|{Escape})*\"|'([^'\\\n]|{Escape})*' L C { |
| 364 | char *value(A char[yyleng]); |
| 365 | char *local(value); |
| 366 | |
| 367 | for (yy_size_t i(1), e(yyleng - 1); i != e; ++i) { |
| 368 | char next(yytext[i]); |
| 369 | |
| 370 | if (yytext[i] == '\\') |
| 371 | switch (next = yytext[++i]) { |
| 372 | case '\n': continue; |
| 373 | case '\\': next = '\\'; break; |
| 374 | case '\'': next = '\''; break; |
| 375 | case '"': next = '"'; break; |
| 376 | case 'b': next = '\b'; break; |
| 377 | case 'f': next = '\f'; break; |
| 378 | case 'n': next = '\n'; break; |
| 379 | case 'r': next = '\r'; break; |
| 380 | case 't': next = '\t'; break; |
| 381 | case 'v': next = '\v'; break; |
| 382 | case '0': next = '\0'; break; |
| 383 | |
| 384 | case 'x': |
| 385 | next = H(yytext[i + 1]) << 4 | H(yytext[i + 2]); |
| 386 | i += 2; |
| 387 | break; |
| 388 | } |
| 389 | |
| 390 | *local++ = next; |
| 391 | } |
| 392 | |
| 393 | *local = '\0'; |
| 394 | I(string, String(value, local - value), tk::StringLiteral, hi::Constant); |
| 395 | } |
| 396 | |
| 397 | \r?\n|\r|\xe2\x80[\xa8\xa9] yylloc->end.lines(); yylloc->step(); N |
| 398 | |
| 399 | [ \t] L |
| 400 | |
| 401 | <<EOF>> if (yyextra->auto_) { yyextra->auto_ = false; F(tk::AutoComplete, hi::Nothing); } L yyterminate(); |
| 402 | |
| 403 | . L { |
| 404 | CYDriver::Error error; |
| 405 | error.location_ = *yylloc; |
| 406 | error.message_ = "syntax error, unknown token"; |
| 407 | yyextra->errors_.push_back(error); |
| 408 | yyterminate(); |
| 409 | } |
| 410 | |
| 411 | %% |
| 412 | |
| 413 | void CYDriver::ScannerInit() { |
| 414 | cylex_init(&scanner_); |
| 415 | cyset_extra(this, scanner_); |
| 416 | } |
| 417 | |
| 418 | void CYDriver::ScannerDestroy() { |
| 419 | cylex_destroy(scanner_); |
| 420 | } |
| 421 | |
| 422 | CYDriver::Condition CYDriver::GetCondition() { |
| 423 | switch (yy_top_state(scanner_)) { |
| 424 | case RegExp: |
| 425 | return RegExpCondition; |
| 426 | @begin E4X |
| 427 | case XMLContent: |
| 428 | return XMLContentCondition; |
| 429 | case XMLTag: |
| 430 | return XMLTagCondition; |
| 431 | @end |
| 432 | default: |
| 433 | _assert(false); |
| 434 | } |
| 435 | } |
| 436 | |
| 437 | void CYDriver::SetCondition(Condition condition) { |
| 438 | struct yyguts_t *yyg(reinterpret_cast<struct yyguts_t *>(scanner_)); |
| 439 | |
| 440 | switch (condition) { |
| 441 | case RegExpCondition: |
| 442 | BEGIN(RegExp); |
| 443 | break; |
| 444 | @begin E4X |
| 445 | case XMLContentCondition: |
| 446 | BEGIN(XMLContent); |
| 447 | break; |
| 448 | case XMLTagCondition: |
| 449 | BEGIN(XMLTag); |
| 450 | break; |
| 451 | @end |
| 452 | default: |
| 453 | _assert(false); |
| 454 | } |
| 455 | } |
| 456 | |
| 457 | void CYDriver::PushCondition(Condition condition) { |
| 458 | switch (condition) { |
| 459 | case RegExpCondition: |
| 460 | yy_push_state(RegExp, scanner_); |
| 461 | break; |
| 462 | @begin E4X |
| 463 | case XMLContentCondition: |
| 464 | yy_push_state(XMLContent, scanner_); |
| 465 | break; |
| 466 | case XMLTagCondition: |
| 467 | yy_push_state(XMLTag, scanner_); |
| 468 | break; |
| 469 | @end |
| 470 | default: |
| 471 | _assert(false); |
| 472 | } |
| 473 | } |
| 474 | |
| 475 | void CYDriver::PopCondition() { |
| 476 | yy_pop_state(scanner_); |
| 477 | } |