"/" L C F(tk::Slash, hi::Operator);
"/=" L C F(tk::SlashEqual, hi::Operator);
":" L C F(tk::Colon, hi::Structure);
"," L C F(tk::Comma, hi::Structure);
"?" L C F(tk::Question, hi::Structure);
";" L C F(tk::SemiColon, hi::Structure);
"(" L C F(tk::OpenParen, hi::Structure);
")" L C F(tk::CloseParen, hi::Structure);
"{" L C F(yyextra->no_.OpenBrace ? tk::OpenBrace__ : yylval->newline_ ? tk::OpenBrace_ : tk::OpenBrace, hi::Structure);
"}" L C F(tk::CloseBrace, hi::Structure);
"[" L C F(tk::OpenBracket, hi::Structure);
"]" L C F(tk::CloseBracket, hi::Structure);
@begin Java
"@class" L C F(tk::AtClass, hi::Meta);
@end
@begin ObjectiveC
"@end" L C F(tk::AtEnd, hi::Meta);
"@implementation" L C F(yyextra->no_.AtImplementation ? tk::AtImplementation_ : tk::AtImplementation, hi::Meta);
"@import" L C F(tk::AtImport, hi::Meta);
"@selector" L C F(tk::AtSelector, hi::Meta);
"nil" L C I(identifier, Identifier("nil"), tk::Identifier_, hi::Constant);
@end
"false" L C I(false, False(), tk::False, hi::Constant);
"null" L C I(null, Null(), tk::Null, hi::Constant);
"true" L C I(true, True(), tk::True, hi::Constant);
"auto" L C I(word, Word("auto"), tk::Auto, hi::Meta);
"break" L R I(word, Word("break"), tk::Break, hi::Control);
"case" L C I(word, Word("case"), tk::Case, hi::Control);
"catch" L C I(word, Word("catch"), tk::Catch, hi::Control);
"continue" L R I(word, Word("continue"), tk::Continue, hi::Control);
"default" L C I(word, Word("default"), tk::Default, hi::Control);
"delete" L C I(word, Word("delete"), tk::Delete, hi::Operator);
"do" L C I(word, Word("do"), tk::Do, hi::Control);
"else" L C I(word, Word("else"), tk::Else, hi::Control);
"finally" L C I(word, Word("finally"), tk::Finally, hi::Control);
"for" L C I(word, Word("for"), tk::For, hi::Control);
"function" L C I(word, Word("function"), yyextra->no_.Function ? tk::Function_ : tk::Function, hi::Meta);
"if" L C I(word, Word("if"), tk::If, hi::Control);
"in" L C I(word, Word("in"), yyextra->in_.top() ? tk::In_ : tk::In, hi::Operator);
"instanceof" L C I(word, Word("instanceof"), tk::InstanceOf, hi::Operator);
"new" L C I(word, Word("new"), tk::New, hi::Operator);
"return" L R I(word, Word("return"), tk::Return, hi::Control);
"switch" L C I(word, Word("switch"), tk::Switch, hi::Control);
"this" L C I(this, This(), tk::This, hi::Constant);
"throw" L R I(word, Word("throw"), tk::Throw, hi::Control);
"try" L C I(word, Word("try"), tk::Try, hi::Control);
"typeof" L C I(word, Word("typeof"), tk::TypeOf, hi::Operator);
"var" L C I(word, Word("var"), tk::Var, hi::Meta);
"void" L C I(word, Word("void"), tk::Void, hi::Operator);
"while" L C I(word, Word("while"), tk::While, hi::Control);
"with" L C I(word, Word("with"), tk::With, hi::Control);
"debugger" L C I(word, Word("debugger"), tk::Debugger, hi::Meta);
"const" L C I(word, Word("const"), tk::Const, hi::Meta);
"class" L C I(word, Word("class"), tk::Class, hi::Meta);
"enum" L C I(word, Word("enum"), tk::Enum, hi::Meta);
"export" L C I(word, Word("export"), tk::Export, hi::Meta);
"extends" L C I(word, Word("extends"), tk::Extends, hi::Meta);
"import" L C I(word, Word("import"), tk::Import, hi::Meta);
"super" L C I(word, Word("super"), tk::Super, hi::Constant);
"implements" L C I(identifier, Identifier("implements"), tk::Implements, hi::Meta);
"interface" L C I(identifier, Identifier("interface"), tk::Interface, hi::Meta);
"package" L C I(identifier, Identifier("package"), tk::Package, hi::Meta);
"private" L C I(identifier, Identifier("private"), tk::Private, hi::Meta);
"protected" L C I(identifier, Identifier("protected"), tk::Protected, hi::Meta);
"public" L C I(identifier, Identifier("public"), tk::Public, hi::Meta);
"static" L C I(identifier, Identifier("static"), tk::Static, hi::Meta);
"abstract" L C I(identifier, Identifier("abstract"), tk::Abstract, hi::Meta);
"boolean" L C I(identifier, Identifier("boolean"), tk::Boolean, hi::Type);
"byte" L C I(identifier, Identifier("byte"), tk::Byte, hi::Type);
"char" L C I(identifier, Identifier("char"), tk::Char, hi::Type);
"double" L C I(identifier, Identifier("double"), tk::Double, hi::Type);
"final" L C I(identifier, Identifier("final"), tk::Final, hi::Meta);
"float" L C I(identifier, Identifier("float"), tk::Float, hi::Type);
"goto" L C I(identifier, Identifier("goto"), tk::Goto, hi::Control);
"int" L C I(identifier, Identifier("int"), tk::Int, hi::Type);
"long" L C I(identifier, Identifier("long"), tk::Long, hi::Type);
"native" L C I(identifier, Identifier("native"), tk::Native, hi::Meta);
"short" L C I(identifier, Identifier("short"), tk::Short, hi::Type);
"synchronized" L C I(identifier, Identifier("synchronized"), tk::Synchronized, hi::Meta);
"throws" L C I(identifier, Identifier("throws"), tk::Throws, hi::Meta);
"transient" L C I(identifier, Identifier("transient"), tk::Transient, hi::Meta);
"volatile" L C I(identifier, Identifier("volatile"), tk::Volatile, hi::Meta);
"let" L C I(identifier, Identifier("let"), tk::Let, hi::Meta);
"yield" L C I(identifier, Identifier("yield"), tk::Yield, hi::Control);
"each" L C I(identifier, Identifier("each"), tk::Each, hi::Control);
"of" L C I(identifier, Identifier("of"), tk::Of, hi::Operator);
@begin E4X
"namespace" L C I(identifier, Identifier("namespace"), tk::Namespace, hi::Meta);
"xml" L C I(identifier, Identifier("xml"), tk::XML, hi::Meta);
@end
{IdentifierStart}{IdentifierPart}* L C I(identifier, Identifier(Y), tk::Identifier_, hi::Identifier);
(\.[0-9]+|(0|[1-9][0-9]*)(\.[0-9]*)?){Exponent}? L C I(number, Number(strtod(yytext, NULL)), tk::NumericLiteral, hi::Constant);
0[xX][0-9a-fA-F]+ L C I(number, Number(strtoull(yytext + 2, NULL, 16)), tk::NumericLiteral, hi::Constant);
0[0-7]+ L C I(number, Number(strtoull(yytext + 1, NULL, 8)), tk::NumericLiteral, hi::Constant);
0[bB][0-1]+ L C I(number, Number(strtoull(yytext + 2, NULL, 2)), tk::NumericLiteral, hi::Constant);
\"([^"\\\n]|{Escape})*\"|'([^'\\\n]|{Escape})*' L C {
char *value(A char[yyleng]);
char *local(value);
for (yy_size_t i(1), e(yyleng - 1); i != e; ++i) {
char next(yytext[i]);
if (yytext[i] == '\\')
switch (next = yytext[++i]) {
case '\n': continue;
case '\\': next = '\\'; break;
case '\'': next = '\''; break;
case '"': next = '"'; break;
case 'b': next = '\b'; break;
case 'f': next = '\f'; break;
case 'n': next = '\n'; break;
case 'r': next = '\r'; break;
case 't': next = '\t'; break;
case 'v': next = '\v'; break;
case '0': next = '\0'; break;
case 'x':
next = H(yytext[i + 1]) << 4 | H(yytext[i + 2]);
i += 2;
break;
}
*local++ = next;
}
*local = '\0';
I(string, String(value, local - value), tk::StringLiteral, hi::Constant);
}
\r?\n|\r|\xe2\x80[\xa8\xa9] yylloc->end.lines(); yylloc->step(); N
[ \t] L
<> if (yyextra->auto_) { yyextra->auto_ = false; F(tk::AutoComplete, hi::Nothing); } L yyterminate();
. L {
CYDriver::Error error;
error.location_ = *yylloc;
error.message_ = "syntax error, unknown token";
yyextra->errors_.push_back(error);
yyterminate();
}
%%
void CYDriver::ScannerInit() {
cylex_init(&scanner_);
cyset_extra(this, scanner_);
}
void CYDriver::ScannerDestroy() {
cylex_destroy(scanner_);
}
CYDriver::Condition CYDriver::GetCondition() {
switch (yy_top_state(scanner_)) {
case RegExp:
return RegExpCondition;
@begin E4X
case XMLContent:
return XMLContentCondition;
case XMLTag:
return XMLTagCondition;
@end
default:
_assert(false);
}
}
void CYDriver::SetCondition(Condition condition) {
struct yyguts_t *yyg(reinterpret_cast(scanner_));
switch (condition) {
case RegExpCondition:
BEGIN(RegExp);
break;
@begin E4X
case XMLContentCondition:
BEGIN(XMLContent);
break;
case XMLTagCondition:
BEGIN(XMLTag);
break;
@end
default:
_assert(false);
}
}
void CYDriver::PushCondition(Condition condition) {
switch (condition) {
case RegExpCondition:
yy_push_state(RegExp, scanner_);
break;
@begin E4X
case XMLContentCondition:
yy_push_state(XMLContent, scanner_);
break;
case XMLTagCondition:
yy_push_state(XMLTag, scanner_);
break;
@end
default:
_assert(false);
}
}
void CYDriver::PopCondition() {
yy_pop_state(scanner_);
}