From: Jay Freeman (saurik) Date: Wed, 2 Dec 2015 08:58:31 +0000 (-0800) Subject: The grammar and lexer should not share a filename. X-Git-Tag: v0.9.590~249 X-Git-Url: https://git.saurik.com/cycript.git/commitdiff_plain/20052ff75c224699725da0f8e096053009c62741 The grammar and lexer should not share a filename. --- diff --git a/.gitignore b/.gitignore index 6d37fe1..8433dae 100644 --- a/.gitignore +++ b/.gitignore @@ -15,15 +15,17 @@ control.tmp config.log config.status Makefile -Cycript.yy -Cycript.l -Cycript.tab.* -Cycript.output +Parser.ypp +Parser.cpp +Parser.hpp +Parser.output +Scanner.lpp +Scanner.cpp +Scanner.output Bridge.gperf stack.hh sysroot.ios sysroot.sim -lex.cy.cpp lex.backup /cycript Bridge.hpp diff --git a/Bridge.cpp b/Bridge.cpp index 096de79..f3d1b6c 100644 --- a/Bridge.cpp +++ b/Bridge.cpp @@ -20,6 +20,7 @@ /* }}} */ #include + #include "Bridge.hpp" extern "C" struct CYBridgeEntry *CYBridgeHash(const char *data, size_t size) { diff --git a/Console.cpp b/Console.cpp index 57f4375..e2cf364 100644 --- a/Console.cpp +++ b/Console.cpp @@ -69,7 +69,7 @@ #include "Display.hpp" #include "Driver.hpp" #include "Highlight.hpp" -#include "Parser.hpp" +#include "Syntax.hpp" static volatile enum { Working, diff --git a/Cycript.l.in b/Cycript.l.in deleted file mode 100644 index 114b19a..0000000 --- a/Cycript.l.in +++ /dev/null @@ -1,707 +0,0 @@ -/* Cycript - Optimizing JavaScript Compiler/Runtime - * Copyright (C) 2009-2015 Jay Freeman (saurik) -*/ - -/* GNU Affero General Public License, Version 3 {{{ */ -/* - * This program is free software: you can redistribute it and/or modify - * it under the terms of the GNU Affero General Public License as published by - * the Free Software Foundation, either version 3 of the License, or - * (at your option) any later version. - - * This program is distributed in the hope that it will be useful, - * but WITHOUT ANY WARRANTY; without even the implied warranty of - * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the - * GNU Affero General Public License for more details. - - * You should have received a copy of the GNU Affero General Public License - * along with this program. If not, see . -**/ -/* }}} */ - -%top{ -#if defined(__clang__) -#pragma clang diagnostic push -#pragma clang diagnostic ignored "-Wdeprecated-register" -#pragma clang diagnostic ignored "-Wunused-function" -#pragma clang diagnostic ignored "-Wunused-variable" -#else -#pragma GCC diagnostic push -#pragma GCC diagnostic ignored "-Wsign-compare" -#pragma GCC diagnostic ignored "-Wunused-function" -#pragma GCC diagnostic ignored "-Wunused-variable" -#endif -} - -%{ - -#define YYLTYPE CYLocation -#include "Cycript.tab.hh" -typedef cy::parser::token tk; - -#include "Highlight.hpp" - -#define YY_EXTRA_TYPE CYDriver * - -#define F(value, highlight) do { \ - yyextra->newline_ = yyextra->last_; \ - yyextra->last_ = false; \ - yyextra->next_ = false; \ - BEGIN(yyextra->template_.top() ? DivOrTemplateTail : Div); \ - yylval->highlight_ = highlight; \ - return value; \ -} while (false) - -#define P yyextra->pool_ -#define A new(P) -#define Y P.strmemdup(yytext, yyleng) - -#define I(type, Type, value, highlight) do { \ - yylval->semantic_.type ## _ = A CY ## Type; \ - F(value, highlight); \ -} while (false) - -#define N \ - if (yyextra->last_ && yyextra->next_) { \ - yyextra->last_ = false; \ - F(tk::NewLine, hi::Nothing); \ - } - -#define V(more) { \ - if (const char *nl = reinterpret_cast(memchr(yytext, '\n', yyleng))) { \ - unsigned lines(0); \ - size_t left; \ - do { \ - ++lines; \ - left = yyleng - (nl - yytext) - 1; \ - nl = reinterpret_cast(memchr(nl + 1, '\n', left)); \ - } while (nl != NULL); \ - yylloc->step(); \ - yylloc->end.lines(lines); \ - yylloc->end.columns(left); \ - more \ - } else L \ -} - -#define R yylloc->end.columns(yyleng); -#define L yylloc->step(); R - -#define H(value, highlight) do { \ - if (yyextra->highlight_) \ - F(value, highlight); \ -} while (false) - -#define M \ - H(tk::Comment, hi::Comment); - -#define E(message) { \ - CYDriver::Error error; \ - error.location_ = *yylloc; \ - error.message_ = "syntax error, " message; \ - yyextra->errors_.push_back(error); \ - yyterminate(); \ -} - -int X(char c) { - if (c >= '0' && c <= '9') - return c - '0'; - if (c >= 'a' && c <= 'f') - return c - 'a' + 10; - if (c >= 'A' && c <= 'F') - return c - 'A' + 10; - return -1; -} - -template -static void U(Type_ &local, unsigned point) { - if (false) { - } else if (point < 0x000080) { - *local++ = point; - } else if (point < 0x000800) { - *local++ = 0xc0 | point >> 0x06 & 0x1f; - goto one; - } else if (point < 0x010000) { - *local++ = 0xe0 | point >> 0x0c & 0x0f; - goto two; - } else if (point < 0x110000) { - *local++ = 0xf0 | point >> 0x12 & 0x07; - *local++ = 0x80 | point >> 0x0c & 0x3f; - two: - *local++ = 0x80 | point >> 0x06 & 0x3f; - one: - *local++ = 0x80 | point >> 0x00 & 0x3f; - } else _assert(false); -} - -static void U(char *&local, const char *text, yy_size_t &i) { - unsigned point; - - char next(text[++i]); - if (next != '{') { - point = X(text[i + 0]) << 12 | X(text[i + 1]) << 8 | X(text[i + 2]) << 4 | X(text[i + 3]); - i += 3; - } else { - point = 0; - for (;;) { - next = text[++i]; - if (next == '}') - break; - point = (point << 4) | X(next); - } - } - - U(local, point); -} - -#define CYLexBufferPoint(point) do { \ - std::back_insert_iterator > inserter(yyextra->buffer_); \ - U(inserter, point); \ -} while (false) - -#define CYLexBufferUnit(value) do { \ - yyextra->buffer_.push_back(value); \ -} while (false) - -#define CYLexBufferUnits(data, size) do { \ - yyextra->buffer_.insert(yyextra->buffer_.end(), data, data + size); \ -} while (false) - -#define CYLexBufferStart(condition) do { \ - yyextra->buffer_.clear(); \ - yy_push_state(condition, yyscanner); \ -} while (false) - -#define CYLexBufferEnd(type, Type, value, highlight) do { \ - yy_pop_state(yyscanner); \ - I(type, Type(P.strmemdup(yyextra->buffer_.data(), yyextra->buffer_.size()), yyextra->buffer_.size()), value, highlight); \ -} while (false) - -#define YY_INPUT(data, value, size) { \ - if (yyextra->data_.eof()) \ - value = YY_NULL; \ - else { \ - yyextra->data_.read(data, size); \ - size_t copy(yyextra->data_.gcount()); \ - value = copy == 0 ? YY_NULL : copy; \ - } \ -} - -%} - -%option prefix="cy" -%option bison-bridge -%option bison-locations -%option nodefault -%option noyywrap -%option noyylineno -%option nounput -%option nounistd -%option 8bit -%option backup -%option batch -%option never-interactive -%option pointer -%option reentrant -%option stack - -%option full -%option ecs - -U1 [\x00-\x7f] -U0 [\x80-\xbf] -U2 [\xc2-\xdf] -U3 [\xe0-\xef] -U4 [\xf0-\xf4] -UN [\xc0-\xc1\xf5-\xff] - -HexDigit [0-9a-fA-F] -LineTerminatorSequence \r?\n|\r|\xe2\x80[\xa8\xa9] -WhiteSpace [\x09\x0b\x0c\x20]|\xc2\xa0|\xef\xbb\xbf -UnicodeEscape \\u({HexDigit}{4}|\{{HexDigit}+\}) - -@include NotLineTerminator.l -NoneTerminatorCharacter [^\r\n\x80-\xff]|{NotLineTerminator} -RegExCharacter [^/[\\]{-}[\r\n\x80-\xff]|{NotLineTerminator} -RegClsCharacter [^]\\]{-}[\r\n\x80-\xff]|{NotLineTerminator} -CommentCharacter [^*/]{-}[\r\n\x80-\xff]|{NotLineTerminator} -SingleCharacter [^'\\]{-}[\r\n\x80-\xff]|{NotLineTerminator} -DoubleCharacter [^"\\]{-}[\r\n\x80-\xff]|{NotLineTerminator} -PlateCharacter [^$`\\]{-}[\r\n\x80-\xff]|{NotLineTerminator} - -@include UnicodeIDStart.l -@include UnicodeIDContinue.l -IdentifierMore [$_] - -UnicodeStart {IdentifierMore}|{UnicodeIDStart} -UnicodePart {IdentifierMore}|\xe2\x80[\x8c\x8d]|{UnicodeIDContinue} -UnicodeFail {U2}|{U3}|{U3}{U0}|{U4}|{U4}{U0}|{U4}{U0}{U0}|{UN}|{U0} -UnicodeScrap {UnicodePart}*{UnicodeFail}? - -IdentifierStart {UnicodeStart}|{UnicodeEscape} -IdentifierPart {UnicodePart}|{UnicodeEscape} -IdentifierFail {UnicodeFail}|\\(u({HexDigit}{0,3}|\{{HexDigit}*))? -IdentifierScrap {IdentifierPart}*{IdentifierFail}? - -RegularExpressionBackslashSequence \\{NoneTerminatorCharacter} -RegularExpressionClassChars ({RegClsCharacter}|{RegularExpressionBackslashSequence})* - -@begin E4X -XMLNameStart [a-zA-Z_:] -XMLNamePart [a-zA-Z0-9.-_:] -XMLName {XMLNameStart}{XMLNamePart}* -@end - -%x RegularExpression -%x MultiLine - -%x LegacySingleString -%x LegacyDoubleString - -%x StrictSingleString -%x StrictDoubleString -%x StrictAccentString - -%s Div -%s DivOrTemplateTail -%s RegExp -%s RegExpOrTemplateTail - -@begin E4X -%x XMLContent -%x XMLTag -@end - -%% - - /* RegEx {{{ */ -\/ L CYLexBufferStart(RegularExpression); CYLexBufferUnit('/'); - -{ - \/{UnicodePart}* R CYLexBufferUnits(yytext, yyleng); CYLexBufferEnd(literal, RegEx, tk::RegularExpressionLiteral, hi::Constant); - \/{UnicodePart}*{UnicodeFail} R E("invalid flags") - - {RegExCharacter}+ R CYLexBufferUnits(yytext, yyleng); - {RegExCharacter}*{UnicodeFail} R E("invalid character"); - - {RegularExpressionBackslashSequence} R CYLexBufferUnits(yytext, yyleng); - \\{UnicodeFail}? R E("invalid escape") - - "["{RegularExpressionClassChars}"]" R CYLexBufferUnits(yytext, yyleng); - "["{RegularExpressionClassChars}\\? R E("invalid class"); - "["{RegularExpressionClassChars}\\?{UnicodeFail} R E("invalid character"); - "["{RegularExpressionClassChars}\\?{LineTerminatorSequence} R E("invalid newline"); - - (\\|{RegExCharacter}+)?{LineTerminatorSequence} R E("invalid newline"); - <> R E("unterminated regex") -} - /* }}} */ - /* Comment {{{ */ -#![^\n]* L M -\/\/[^\n]* L M - -\/\* L yy_push_state(MultiLine, yyscanner); - -{ - \**\*\/ R yy_pop_state(yyscanner); M N - \**{LineTerminatorSequence} yylloc->end.lines(); yyextra->last_ = true; - \**{CommentCharacter}|\/ R - \**({UnicodeFail}|\*) R E("invalid comment"); - <> R E("invalid comment") -} - /* }}} */ - /* Element {{{ */ -@begin E4X -"<>" L F(tk::LeftRight, hi::Structure); -"" L F(tk::LeftSlashRight, hi::Structure); - -\])*]]> V() F(tk::XMLCDATA, hi::Constant); -\ V() F(tk::XMLComment, hi::Comment); -\])*?> V() F(tk::XMLPI, hi::Meta); - -"=" L F(tk::Equal, hi::Structure); -">" L F(tk::Right, hi::Structure); -"/>" L F(tk::SlashRight, hi::Structure); -"{" L F(tk::OpenBrace, hi::Structure); - -\"(\n|[^"])*\"|'(\n|[^'])*' V() F(tk::XMLAttributeValue, hi::Constant); -{XMLName} L F(tk::XMLName, hi::Identifier); -[ \t\r\n] V() F(tk::XMLWhitespace, hi::Nothing); - -"{" L F(tk::OpenBrace, hi::Structure); -"<" L F(tk::Left, hi::Structure); -"" L F(yyextra->newline_ ? tk::EqualRight_ : tk::EqualRight, hi::Operator); -"!" L F(tk::Exclamation, hi::Operator); -"!=" L F(tk::ExclamationEqual, hi::Operator); -"!==" L F(tk::ExclamationEqualEqual, hi::Operator); -"-" L F(tk::Hyphen, hi::Operator); -"-=" L F(tk::HyphenEqual, hi::Operator); -"--" L F(yyextra->newline_ ? tk::HyphenHyphen_ : tk::HyphenHyphen, hi::Operator); -"->" L F(tk::HyphenRight, hi::Operator); -"<" L F(tk::Left, hi::Operator); -"<=" L F(tk::LeftEqual, hi::Operator); -"<<" L F(tk::LeftLeft, hi::Operator); -"<<=" L F(tk::LeftLeftEqual, hi::Operator); -"%" L F(tk::Percent, hi::Operator); -"%=" L F(tk::PercentEqual, hi::Operator); -"." L F(tk::Period, hi::Operator); -"|" L F(tk::Pipe, hi::Operator); -"|=" L F(tk::PipeEqual, hi::Operator); -"||" L F(tk::PipePipe, hi::Operator); -"+" L F(tk::Plus, hi::Operator); -"+=" L F(tk::PlusEqual, hi::Operator); -"++" L F(yyextra->newline_ ? tk::PlusPlus_ : tk::PlusPlus, hi::Operator); -">" L F(tk::Right, hi::Operator); -">=" L F(tk::RightEqual, hi::Operator); -">>" L F(tk::RightRight, hi::Operator); -">>=" L F(tk::RightRightEqual, hi::Operator); -">>>" L F(tk::RightRightRight, hi::Operator); -">>>=" L F(tk::RightRightRightEqual, hi::Operator); -"*" L F(tk::Star, hi::Operator); -"*=" L F(tk::StarEqual, hi::Operator); -"~" L F(tk::Tilde, hi::Operator); - -"/" L F(tk::Slash, hi::Operator); -"/=" L F(tk::SlashEqual, hi::Operator); - -":" L F(tk::Colon, hi::Structure); -"," L F(tk::Comma, hi::Structure); -"?" L F(tk::Question, hi::Structure); -";" L F(tk::SemiColon, hi::Structure); - -"(" L F(tk::OpenParen, hi::Structure); -")" L F(tk::CloseParen, hi::Structure); - -"{" L yyextra->template_.push(false); F(yyextra->newline_ ? tk::OpenBrace_ : tk::OpenBrace, hi::Structure); -"}" L yyextra->template_.pop(); F(tk::CloseBrace, hi::Structure); - -"[" L F(tk::OpenBracket, hi::Structure); -"]" L F(tk::CloseBracket, hi::Structure); - /* }}} */ - /* Keyword {{{ */ -"@error" L F(tk::At_error_, hi::Error); - -@begin Java -"@class" L F(tk::At_class_, hi::Meta); -@end - -@begin C -"@encode" L F(tk::At_encode_, hi::Meta); -@end - -@begin ObjectiveC -"@end" L F(tk::At_end_, hi::Meta); -"@false" L F(tk::At_false_, hi::Constant); -"@implementation" L F(tk::At_implementation_, hi::Meta); -"@import" L F(tk::At_import_, hi::Special); -"@NO" L F(tk::At_NO_, hi::Constant); -"@null" L F(tk::At_null_, hi::Constant); -"@selector" L F(tk::At_selector_, hi::Meta); -"@true" L F(tk::At_true_, hi::Constant); -"@YES" L F(tk::At_YES_, hi::Constant); -@end - -@({UnicodeStart}{UnicodeScrap}|{UnicodeFail}) L E("invalid keyword") - /* }}} */ - /* Highlight {{{ */ -"undefined" L F(tk::_undefined_, hi::Operator); - -@begin ObjectiveC -"bool" L F(tk::_bool_, hi::Type); -"BOOL" L F(tk::_BOOL_, hi::Type); -"id" L F(tk::_id_, hi::Type); -"nil" L F(tk::_nil_, hi::Constant); -"NULL" L F(tk::_NULL_, hi::Constant); -"SEL" L F(tk::_SEL_, hi::Type); -@end - /* }}} */ - /* Reserved {{{ */ -"abstract" L /*FII*/ F(tk::_abstract_, hi::Meta); -"await" L /*II?*/ F(tk::_await_, hi::Meta); -"boolean" L /*FII*/ F(tk::_boolean_, hi::Type); -"break" L /*KKK*/ F(tk::_break_, hi::Control); -"byte" L /*FII*/ F(tk::_byte_, hi::Type); -"case" L /*KKK*/ F(tk::_case_, hi::Control); -"catch" L /*KKK*/ F(tk::_catch_, hi::Control); -"char" L /*FII*/ F(tk::_char_, hi::Type); -"class" L /*FFK*/ F(tk::_class_, hi::Meta); -"const" L /*FFK*/ F(tk::_const_, hi::Meta); -"continue" L /*KKK*/ F(tk::_continue_, hi::Control); -"debugger" L /*FKK*/ F(tk::_debugger_, hi::Meta); -"default" L /*KKK*/ F(tk::_default_, hi::Control); -"delete" L /*KKK*/ F(tk::_delete_, hi::Operator); -"do" L /*KKK*/ F(tk::_do_, hi::Control); -"double" L /*FII*/ F(tk::_double_, hi::Type); -"else" L /*KKK*/ F(tk::_else_, hi::Control); -"enum" L /*FFF*/ F(tk::_enum_, hi::Meta); -"export" L /*FFK*/ F(tk::_export_, hi::Meta); -"extends" L /*FFK*/ F(tk::_extends_, hi::Meta); -"false" L /*LLL*/ F(tk::_false_, hi::Constant); -"final" L /*FII*/ F(tk::_final_, hi::Meta); -"finally" L /*KKK*/ F(tk::_finally_, hi::Control); -"float" L /*FII*/ F(tk::_float_, hi::Type); -"for" L /*KKK*/ F(tk::_for_, hi::Control); -"from" L /*III*/ F(tk::_from_, hi::Meta); -"function" L /*KKK*/ F(tk::_function_, hi::Meta); -"goto" L /*FII*/ F(tk::_goto_, hi::Control); -"get" L /*III*/ F(tk::_get_, hi::Meta); -"if" L /*KKK*/ F(tk::_if_, hi::Control); -"implements" L /*FSS*/ F(tk::_implements_, hi::Meta); -"import" L /*FFK*/ F(tk::_import_, hi::Meta); -"in" L /*KKK*/ F(yyextra->in_.top() ? tk::_in__ : tk::_in_, hi::Operator); -"instanceof" L /*KKK*/ F(tk::_instanceof_, hi::Operator); -"int" L /*FII*/ F(tk::_int_, hi::Type); -"interface" L /*FSS*/ F(tk::_interface_, hi::Meta); -"let" L /*IS?*/ F(tk::_let_, hi::Meta); -"long" L /*FII*/ F(tk::_long_, hi::Type); -"native" L /*FII*/ F(tk::_native_, hi::Meta); -"new" L /*KKK*/ F(tk::_new_, hi::Operator); -"null" L /*LLL*/ F(tk::_null_, hi::Constant); -"package" L /*FSS*/ F(tk::_package_, hi::Meta); -"private" L /*FSS*/ F(tk::_private_, hi::Meta); -"protected" L /*FSS*/ F(tk::_protected_, hi::Meta); -"public" L /*FSS*/ F(tk::_public_, hi::Meta); -"return" L /*KKK*/ F(yyextra->return_.top() ? tk::_return__ : tk::_return_, hi::Control); -"set" L /*III*/ F(tk::_set_, hi::Meta); -"short" L /*FII*/ F(tk::_short_, hi::Type); -"static" L /*FS?*/ F(tk::_static_, hi::Meta); -"super" L /*FFK*/ F(tk::_super_, hi::Constant); -"switch" L /*KKK*/ F(tk::_switch_, hi::Control); -"synchronized" L /*FII*/ F(tk::_synchronized_, hi::Meta); -"this" L /*KKK*/ F(tk::_this_, hi::Constant); -"throw" L /*KKK*/ F(tk::_throw_, hi::Control); -"throws" L /*FII*/ F(tk::_throws_, hi::Meta); -"transient" L /*FII*/ F(tk::_transient_, hi::Meta); -"true" L /*LLL*/ F(tk::_true_, hi::Constant); -"try" L /*KKK*/ F(tk::_try_, hi::Control); -"typeof" L /*KKK*/ F(tk::_typeof_, hi::Operator); -"var" L /*KKK*/ F(tk::_var_, hi::Meta); -"void" L /*KKK*/ F(tk::_void_, hi::Operator); -"volatile" L /*FII*/ F(tk::_volatile_, hi::Meta); -"while" L /*KKK*/ F(tk::_while_, hi::Control); -"with" L /*KKK*/ F(tk::_with_, hi::Control); -"yield" L /*IS?*/ F(yyextra->yield_.top() ? tk::_yield__ : tk::_yield_, hi::Control); - -"auto" L F(tk::_auto_, hi::Meta); -"each" L F(tk::_each_, hi::Control); -"of" L F(tk::_of_, hi::Operator); - -@begin C -"extern" L F(tk::_extern_, hi::Type); -"signed" L F(tk::_signed_, hi::Type); -"typedef" L F(tk::_typedef_, hi::Meta); -"unsigned" L F(tk::_unsigned_, hi::Type); -@end - -@begin ObjectiveC -"NO" L F(tk::_NO_, hi::Constant); -"YES" L F(tk::_YES_, hi::Constant); -@end - -@begin E4X -"namespace" L F(tk::_namespace_, hi::Meta); -"xml" L F(tk::_xml_, hi::Meta); -@end - /* }}} */ - /* Identifier {{{ */ -{UnicodeStart}{UnicodePart}* L I(identifier, Identifier(Y), tk::Identifier_, hi::Identifier); - -{IdentifierStart}{IdentifierPart}* L { - char *value(A char[yyleng + 1]); - char *local(value); - - for (yy_size_t i(0), e(yyleng); i != e; ++i) { - char next(yytext[i]); - if (next != '\\') - *local++ = next; - else - U(local, yytext, ++i); - } - - *local = '\0'; - I(identifier, Identifier(value), tk::Identifier_, hi::Identifier); -} - -({IdentifierStart}{IdentifierPart}*)?{IdentifierFail} L E("invalid identifier") - /* }}} */ - /* Number {{{ */ -0[0-7]+ L I(number, Number(strtoull(yytext + 1, NULL, 8)), tk::NumericLiteral, hi::Constant); -0[0-9]+ L I(number, Number(strtoull(yytext + 1, NULL, 10)), tk::NumericLiteral, hi::Constant); - -0[xX][0-9a-fA-F]+ L I(number, Number(strtoull(yytext + 2, NULL, 16)), tk::NumericLiteral, hi::Constant); -0[oO][0-7]+ L I(number, Number(strtoull(yytext + 2, NULL, 8)), tk::NumericLiteral, hi::Constant); -0[bB][0-1]+ L I(number, Number(strtoull(yytext + 2, NULL, 2)), tk::NumericLiteral, hi::Constant); - -(\.[0-9]+|(0|[1-9][0-9]*)(\.[0-9]*)?)([eE][+-]?[0-9]+)? L I(number, Number(strtod(yytext, NULL)), tk::NumericLiteral, hi::Constant); -(\.[0-9]+|(0|[1-9][0-9]*)(\.[0-9]*)?)[eE][+-]?{IdentifierScrap} L E("invalid exponent") -(\.?[0-9]|(0|[1-9][0-9]*)\.){IdentifierScrap} L E("invalid number") - /* }}} */ - /* String {{{ */ -\' L CYLexBufferStart(LegacySingleString); -{ - \' R CYLexBufferEnd(string, String, tk::StringLiteral, hi::Constant); - {SingleCharacter}+ R CYLexBufferUnits(yytext, yyleng); - {SingleCharacter}*{UnicodeFail} R E("invalid character"); - {LineTerminatorSequence} R E("invalid newline"); -} - -\" L CYLexBufferStart(LegacyDoubleString); -{ - \" R CYLexBufferEnd(string, String, tk::StringLiteral, hi::Constant); - {DoubleCharacter}+ R CYLexBufferUnits(yytext, yyleng); - {DoubleCharacter}*{UnicodeFail} R E("invalid character"); - {LineTerminatorSequence} R E("invalid newline"); -} - /* }}} */ - /* Template {{{ */ -"`" L yyextra->tail_ = false; CYLexBufferStart(StrictAccentString); -"}" L yyextra->tail_ = true; yyextra->template_.pop(); CYLexBufferStart(StrictAccentString); - -{ - "`" R CYLexBufferEnd(string, String, yyextra->tail_ ? tk::TemplateTail : tk::NoSubstitutionTemplate, hi::Constant); - "${" R yyextra->template_.push(true); CYLexBufferEnd(string, String, yyextra->tail_ ? tk::TemplateMiddle : tk::TemplateHead, hi::Constant); - - "$" R CYLexBufferUnit('$'); - - {PlateCharacter}+ R CYLexBufferUnits(yytext, yyleng); - {PlateCharacter}*{UnicodeFail} R E("invalid character"); - {LineTerminatorSequence} R E("invalid newline"); -} - /* }}} */ - /* Escapes {{{ */ -{ - \\[0-3][0-7][0-7] R CYLexBufferPoint(X(yytext[1]) << 6 | X(yytext[2]) << 3 | X(yytext[3])); - \\[0-7][0-7] R CYLexBufferUnit(X(yytext[1]) << 3 | X(yytext[2])); - \\[0-7] R CYLexBufferUnit(X(yytext[1])); -} - -{ - \\0[0-7] R E("legacy escape"); - \\0 R CYLexBufferUnit('\0'); -} - -{ - \\b R CYLexBufferUnit('\b'); - \\f R CYLexBufferUnit('\f'); - \\n R CYLexBufferUnit('\n'); - \\r R CYLexBufferUnit('\r'); - \\t R CYLexBufferUnit('\t'); - \\v R CYLexBufferUnit('\v'); - - \\x{HexDigit}{2} R CYLexBufferPoint(X(yytext[2]) << 4 | X(yytext[3])); - - \\u{HexDigit}{4} R CYLexBufferPoint(X(yytext[2]) << 12 | X(yytext[3]) << 8 | X(yytext[4]) << 4 | X(yytext[5])); - - \\u\{{HexDigit}+\} R { - unsigned point(0); - for (yy_size_t i(3); i != yyleng - 1; ++i) - point = point << 4 | X(yytext[i]); - CYLexBufferPoint(point); - } - - \\{LineTerminatorSequence} yylloc->end.lines(); - \\(.|{NotLineTerminator}) R CYLexBufferUnits(yytext + 1, yyleng - 1); - - \\(x{HexDigit}{0,1}|u({HexDigit}{0,3}|\{{HexDigit}*)|{UnicodeFail})? R E("invalid escape"); - <> R E("invalid string"); -} - /* }}} */ - -{LineTerminatorSequence} yylloc->step(); yylloc->end.lines(); yyextra->last_ = true; N -{WhiteSpace} L - -<> if (yyextra->auto_) { yyextra->auto_ = false; F(tk::AutoComplete, hi::Nothing); } L yyterminate(); - -. L E("invalid character") - -%% - -void CYDriver::ScannerInit() { - cylex_init(&scanner_); - cyset_extra(this, scanner_); -} - -void CYDriver::ScannerDestroy() { - cylex_destroy(scanner_); -} - -void CYDriver::SetCondition(Condition condition) { - struct yyguts_t *yyg(reinterpret_cast(scanner_)); - - switch (condition) { - case RegExpCondition: - BEGIN(template_.top() ? RegExpOrTemplateTail : 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_); -} - -bool CYLexerHighlight(hi::Value &highlight, CYLocation &location, void *scanner) { - YYSTYPE value; - if (cylex(&value, &location, scanner) == 0) - return false; - highlight = value.highlight_; - return true; -} - -#if defined(__clang__) -#pragma clang diagnostic pop -#else -// must not pop -Wunused-function -//#pragma GCC diagnostic pop -#endif diff --git a/Cycript.yy.in b/Cycript.yy.in deleted file mode 100644 index 295fa81..0000000 --- a/Cycript.yy.in +++ /dev/null @@ -1,2365 +0,0 @@ -/* Cycript - Optimizing JavaScript Compiler/Runtime - * Copyright (C) 2009-2015 Jay Freeman (saurik) -*/ - -/* GNU Affero General Public License, Version 3 {{{ */ -/* - * This program is free software: you can redistribute it and/or modify - * it under the terms of the GNU Affero General Public License as published by - * the Free Software Foundation, either version 3 of the License, or - * (at your option) any later version. - - * This program is distributed in the hope that it will be useful, - * but WITHOUT ANY WARRANTY; without even the implied warranty of - * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the - * GNU Affero General Public License for more details. - - * You should have received a copy of the GNU Affero General Public License - * along with this program. If not, see . -**/ -/* }}} */ - -%code top { -#define YYSTACKEXPANDABLE 1 -} - -%code requires { -#include "Driver.hpp" -#include "Parser.hpp" -#include "Stack.hpp" -#define CYNew new(driver.pool_) - -@begin ObjectiveC -#include "ObjectiveC/Syntax.hpp" -@end - -@begin E4X -#include "E4X/Syntax.hpp" -@end - -#include "Highlight.hpp" -} - -%union { bool bool_; } - -%union { CYArgument *argument_; } -%union { CYAssignment *assignment_; } -%union { CYBoolean *boolean_; } -%union { CYClause *clause_; } -%union { cy::Syntax::Catch *catch_; } -%union { CYComprehension *comprehension_; } -%union { CYDeclaration *declaration_; } -%union { CYDeclarations *declarations_; } -%union { CYElement *element_; } -%union { CYExpression *expression_; } -%union { CYFalse *false_; } -%union { CYVariable *variable_; } -%union { CYFinally *finally_; } -%union { CYForInitializer *for_; } -%union { CYForInInitializer *forin_; } -%union { CYFunctionParameter *functionParameter_; } -%union { CYIdentifier *identifier_; } -%union { CYInfix *infix_; } -%union { CYLiteral *literal_; } -%union { CYMember *member_; } -%union { CYModule *module_; } -%union { CYNull *null_; } -%union { CYNumber *number_; } -%union { CYParenthetical *parenthetical_; } -%union { CYProperty *property_; } -%union { CYPropertyName *propertyName_; } -%union { CYRubyProc *rubyProc_; } -%union { CYSpan *span_; } -%union { CYStatement *statement_; } -%union { CYString *string_; } -%union { CYThis *this_; } -%union { CYTrue *true_; } -%union { CYWord *word_; } - -@begin C -%union { CYTypeModifier *modifier_; } -%union { CYTypeSpecifier *specifier_; } -%union { CYTypedIdentifier *typedIdentifier_; } -%union { CYTypedParameter *typedParameter_; } -@end - -@begin ObjectiveC -%union { CYClassName *className_; } -%union { CYClassField *classField_; } -%union { CYMessage *message_; } -%union { CYMessageParameter *messageParameter_; } -%union { CYProtocol *protocol_; } -%union { CYSelectorPart *selector_; } -@end - -@begin E4X -%union { CYAttribute *attribute_; } -%union { CYPropertyIdentifier *propertyIdentifier_; } -%union { CYSelector *selector_; } -@end - -%code provides { - -struct YYSTYPE { - cy::parser::semantic_type semantic_; - hi::Value highlight_; -}; - -int cylex(YYSTYPE *, CYLocation *, void *); - -} - -%code { - -#undef yylex -_finline int yylex(cy::parser::semantic_type *semantic, CYLocation *location, CYDriver &driver) { - if (driver.mark_ == CYMarkIgnore); - else if (driver.mark_ == CYMarkScript) { - driver.mark_ = CYMarkIgnore; - return cy::parser::token::MarkScript; - } else if (driver.mark_ == CYMarkModule) { - driver.mark_ = CYMarkIgnore; - return cy::parser::token::MarkModule; - } - - YYSTYPE data; - int token(cylex(&data, location, driver.scanner_)); - *semantic = data.semantic_; - return token; -} - -#define CYMAP(to, from) do { \ - if (yyla.empty()) \ - yyla.type = yytranslate_(yylex(&yyla.value, &yyla.location, driver)); \ - if (yyla.type == yytranslate_(token::from)) \ - yyla.type = yytranslate_(token::to); \ -} while (false) - -#define CYERR(location, message) do { \ - error(location, message); \ - YYABORT; \ -} while (false) - -#define CYNOT(location) \ - CYERR(location, "unimplemented feature") - -} - -%name-prefix "cy" - -%language "C++" - -%initial-action { - @$.begin.filename = @$.end.filename = &driver.filename_; -}; - -%locations -%defines - -%define api.location.type { CYLocation } - -//%glr-parser -//%expect 1 - -%error-verbose - -%param { CYDriver &driver } - -/* Token Declarations {{{ */ -@begin E4X -%token XMLCDATA -%token XMLComment -%token XMLPI - -%token XMLAttributeValue -%token XMLName -%token XMLTagCharacters -%token XMLText -%token XMLWhitespace -@end - -@begin E4X -%token LeftRight "<>" -%token LeftSlashRight "" - -%token SlashRight "/>" -%token LeftSlash "" -%token EqualRight_ "\n=>" -%token Exclamation "!" -%token ExclamationEqual "!=" -%token ExclamationEqualEqual "!==" -%token Hyphen "-" -%token HyphenEqual "-=" -%token HyphenHyphen "--" -%token HyphenHyphen_ "\n--" -%token HyphenRight "->" -%token Left "<" -%token LeftEqual "<=" -%token LeftLeft "<<" -%token LeftLeftEqual "<<=" -%token Percent "%" -%token PercentEqual "%=" -%token Period "." -%token PeriodPeriodPeriod "..." -%token Pipe "|" -%token PipeEqual "|=" -%token PipePipe "||" -%token Plus "+" -%token PlusEqual "+=" -%token PlusPlus "++" -%token PlusPlus_ "\n++" -%token Right ">" -%token RightEqual ">=" -%token RightRight ">>" -%token RightRightEqual ">>=" -%token RightRightRight ">>>" -%token RightRightRightEqual ">>>=" -%token Slash "/" -%token SlashEqual "/=" -%token Star "*" -%token StarEqual "*=" -%token Tilde "~" - -%token Colon ":" -%token Comma "," -%token Question "?" -%token SemiColon ";" -%token NewLine "\n" - -%token Comment - -%token OpenParen "(" -%token CloseParen ")" - -%token OpenBrace "{" -%token OpenBrace_ "\n{" -%token OpenBrace__ ";{" -%token CloseBrace "}" - -%token OpenBracket "[" -%token CloseBracket "]" - -%token At_error_ "@error" - -@begin Java -%token At_class_ "@class" -@end - -@begin C -%token _typedef_ "typedef" -%token _unsigned_ "unsigned" -%token _signed_ "signed" -%token _extern_ "extern" -@end - -@begin C -%token At_encode_ "@encode" -@end - -@begin ObjectiveC -%token At_implementation_ "@implementation" -%token At_import_ "@import" -%token At_end_ "@end" -%token At_selector_ "@selector" -%token At_null_ "@null" -%token At_YES_ "@YES" -%token At_NO_ "@NO" -%token At_true_ "@true" -%token At_false_ "@false" -%token _YES_ "YES" -%token _NO_ "NO" -@end - -%token _false_ "false" -%token _null_ "null" -%token _true_ "true" - -%token _break_ "break" -%token _case_ "case" -%token _catch_ "catch" -%token _class_ "class" -%token _class__ ";class" -%token _const_ "const" -%token _continue_ "continue" -%token _debugger_ "debugger" -%token _default_ "default" -%token _delete_ "delete" -%token _do_ "do" -%token _else_ "else" -%token _enum_ "enum" -%token _export_ "export" -%token _extends_ "extends" -%token _finally_ "finally" -%token _for_ "for" -%token _function_ "function" -%token _function__ ";function" -%token _if_ "if" -%token _import_ "import" -%token _in_ "in" -%token _in__ "!in" -%token _instanceof_ "instanceof" -%token _new_ "new" -%token _return_ "return" -%token _return__ "!return" -%token _super_ "super" -%token _switch_ "switch" -%token _this_ "this" -%token _throw_ "throw" -%token _try_ "try" -%token _typeof_ "typeof" -%token _var_ "var" -%token _void_ "void" -%token _while_ "while" -%token _with_ "with" - -%token _abstract_ "abstract" -%token _await_ "await" -%token _boolean_ "boolean" -%token _byte_ "byte" -%token _char_ "char" -%token _double_ "double" -%token _final_ "final" -%token _float_ "float" -%token _from_ "from" -%token _get_ "get" -%token _goto_ "goto" -%token _implements_ "implements" -%token _int_ "int" -%token _interface_ "interface" -%token _let_ "let" -%token _long_ "long" -%token _native_ "native" -%token _package_ "package" -%token _private_ "private" -%token _protected_ "protected" -%token _public_ "public" -%token _set_ "set" -%token _short_ "short" -%token _static_ "static" -%token _synchronized_ "synchronized" -%token _throws_ "throws" -%token _transient_ "transient" -%token _volatile_ "volatile" -%token _yield_ "yield" -%token _yield__ "!yield" - -%token _undefined_ "undefined" - -@begin ObjectiveC -%token _bool_ "bool" -%token _BOOL_ "BOOL" -%token _id_ "id" -%token _nil_ "nil" -%token _NULL_ "NULL" -%token _SEL_ "SEL" -@end - -%token _auto_ "auto" -%token _each_ "each" -%token _of_ "of" - -@begin E4X -%token _namespace_ "namespace" -%token _xml_ "xml" -@end - -%token AutoComplete -%token YieldStar - -%token Identifier_ -%token NumericLiteral -%token StringLiteral -%token RegularExpressionLiteral - -%token NoSubstitutionTemplate -%token TemplateHead -%token TemplateMiddle -%token TemplateTail - -%type AdditiveExpression -%type ArgumentList_ -%type ArgumentList -%type ArgumentListOpt -%type Arguments -%type ArrayComprehension -%type ArrayLiteral -%type ArrowFunction -%type ArrowParameters -%type AssignmentExpression -%type AssignmentExpressionOpt -%type Binding -%type BindingIdentifier -%type BindingIdentifierOpt -%type BitwiseANDExpression -%type Block -%type BlockStatement -%type BooleanLiteral -%type BindingElement -%type BitwiseORExpression -%type BitwiseXORExpression -%type BreakStatement -%type BreakableStatement -%type CallExpression_ -%type CallExpression -%type CaseBlock -%type CaseClause -%type CaseClausesOpt -%type Catch -%type CatchParameter -%type ClassDeclaration -%type ClassExpression -%type Comprehension -%type ComprehensionFor -%type ComprehensionIf -%type ComprehensionTail -%type ComputedPropertyName -%type ConditionalExpression -%type ContinueStatement -%type ConciseBody -%type CoverParenthesizedExpressionAndArrowParameterList -%type DebuggerStatement -%type Declaration__ -%type Declaration_ -%type Declaration -%type DefaultClause -%type ElementList -%type ElementListOpt -%type ElseStatementOpt -%type EmptyStatement -%type EqualityExpression -%type Expression -%type ExpressionOpt -%type ExpressionStatement -%type Finally -%type ForStatementInitializer -%type ForInStatementInitializer -%type FormalParameter -%type FormalParameterList_ -%type FormalParameterList -%type FormalParameters -%type FunctionBody -%type FunctionDeclaration -%type FunctionExpression -%type FunctionStatementList -%type GeneratorBody -%type GeneratorDeclaration -%type GeneratorExpression -%type GeneratorMethod -%type HoistableDeclaration -%type Identifier -%type IdentifierType -%type IdentifierName -%type IdentifierReference -%type IfStatement -%type Initializer -%type InitializerOpt -%type IterationStatement -%type LabelIdentifier -%type LabelledItem -%type LabelledStatement -%type LeftHandSideExpression -%type LetStatement -%type LexicalDeclaration -%type Literal -%type LiteralPropertyName -%type LogicalANDExpression -%type LogicalORExpression -%type MemberAccess -%type MemberExpression -%type MethodDefinition -%type ModulePath -%type MultiplicativeExpression -%type NewExpression -%type NullLiteral -%type ObjectLiteral -%type PostfixExpression -%type PrimaryExpression -%type PropertyName -%type PropertyDefinition -%type PropertyDefinitionList_ -%type PropertyDefinitionList -%type PropertyDefinitionListOpt -%type PropertySetParameterList -%type RelationalExpression -%type ReturnStatement -%type RubyProcExpression -%type RubyProcParameterList_ -%type RubyProcParameterList -%type RubyProcParameters -%type RubyProcParametersOpt -%type Script -%type ScriptBody -%type ScriptBodyOpt -%type ShiftExpression -%type SingleNameBinding -%type Statement__ -%type Statement_ -%type Statement -%type StatementList -%type StatementListOpt -%type StatementListItem -%type StrictFormalParameters -%type SwitchStatement -%type TemplateLiteral -%type TemplateSpans -%type ThrowStatement -%type TryStatement -%type UnaryExpression_ -%type UnaryExpression -%type VariableDeclaration -%type VariableDeclarationList_ -%type VariableDeclarationList -%type VariableStatement -%type WithStatement -%type Word -@begin ObjectiveC -%type WordOpt -@end -%type YieldExpression - -@begin C -%type IntegerType -%type IntegerTypeOpt -%type PrefixedType -%type PrimitiveType -%type SuffixedType -%type TypeSignifier -%type TypeQualifierLeft -%type TypeQualifierRight -%type TypedIdentifier -%type TypedParameterList_ -%type TypedParameterList -%type TypedParameterListOpt -@end - -@begin ObjectiveC -%type BoxableExpression -%type CategoryStatement -%type ClassFieldListOpt -%type ClassFields -%type ClassStatement -%type ClassSuperOpt -%type ClassMessageDeclaration -%type ClassMessageDeclarationListOpt -%type ClassName -%type ClassProtocolListOpt -%type ClassProtocols -%type ClassProtocolsOpt -%type MessageExpression -%type MessageParameter -%type MessageParameters -%type MessageParameterList -%type MessageParameterListOpt -%type MessageScope -%type SelectorCall_ -%type SelectorCall -%type SelectorExpression_ -%type SelectorExpression -%type SelectorExpressionOpt -%type SelectorList -%type SelectorWordOpt -%type TypeOpt -%type VariadicCall -@end - -@begin E4X -%type PropertyIdentifier_ -%type PropertySelector_ -%type PropertySelector -%type QualifiedIdentifier_ -%type QualifiedIdentifier -%type WildcardIdentifier -%type XMLComment -%type XMLCDATA -%type XMLElement -%type XMLElementContent -%type XMLMarkup -%type XMLPI - -%type AttributeIdentifier -/* XXX: %type DefaultXMLNamespaceStatement */ -%type PropertyIdentifier -%type XMLListInitialiser -%type XMLInitialiser -@end -/* }}} */ -/* Token Priorities {{{ */ -%nonassoc "" -%left "++" "--" "{" - -%nonassoc "if" -%nonassoc "else" -/* }}} */ - -%start Program -%token MarkModule -%token MarkScript - -%% - -Program - : MarkScript Script - | MarkModule Module - ; - -/* Lexer State {{{ */ -LexPushInOn: { driver.in_.push(true); }; -LexPushInOff: { driver.in_.push(false); }; -LexPopIn: { driver.in_.pop(); }; - -LexPushReturnOn: { driver.return_.push(true); }; -LexPopReturn: { driver.return_.pop(); }; - -LexPushYieldOn: { driver.yield_.push(true); }; -LexPushYieldOff: { driver.yield_.push(false); }; -LexPopYield: { driver.yield_.pop(); }; - -LexSetRegExp - : { driver.SetCondition(CYDriver::RegExpCondition); } - ; - -LexNewLine - : { if (!yyla.empty() && yyla.type_get() != yyeof_) CYERR(@$, "unexpected lookahead"); driver.next_ = true; } - ; - -LexNoStar - : { CYMAP(YieldStar, Star); } - ; - -LexNoBrace - : { CYMAP(OpenBrace__, OpenBrace); CYMAP(OpenBrace__, OpenBrace_); } - ; - -LexNoClass - : { CYMAP(_class__, _class_); } - ; - -LexNoFunction - : { CYMAP(_function__, _function_); } - ; - -LexSetStatement - : LexNoBrace LexNoClass LexNoFunction - ; -/* }}} */ -/* Virtual Tokens {{{ */ -BRACE - : "{" - | "\n{" - ; - -Var_ - : "var" - ; -/* }}} */ - -/* 11.6 Names and Keywords {{{ */ -IdentifierName - : Word { $$ = $1; } - | "for" { $$ = CYNew CYWord("for"); } - | "in" { $$ = CYNew CYWord("in"); } - | "instanceof" { $$ = CYNew CYWord("instanceof"); } - ; - -NewLineOpt - : "\n" - | - ; - -Word - : Identifier { $$ = $1; } - | "auto" { $$ = CYNew CYWord("auto"); } - | "break" { $$ = CYNew CYWord("break"); } - | "case" { $$ = CYNew CYWord("case"); } - | "catch" { $$ = CYNew CYWord("catch"); } - | "class" { $$ = CYNew CYWord("class"); } - | ";class" { $$ = CYNew CYWord("class"); } - | "const" { $$ = CYNew CYWord("const"); } - | "continue" { $$ = CYNew CYWord("continue"); } - | "debugger" { $$ = CYNew CYWord("debugger"); } - | "default" { $$ = CYNew CYWord("default"); } - | "delete" LexSetRegExp { $$ = CYNew CYWord("delete"); } - | "do" { $$ = CYNew CYWord("do"); } - | "else" { $$ = CYNew CYWord("else"); } - | "enum" { $$ = CYNew CYWord("enum"); } - | "export" { $$ = CYNew CYWord("export"); } - | "extends" { $$ = CYNew CYWord("extends"); } - | "false" { $$ = CYNew CYWord("false"); } - | "finally" { $$ = CYNew CYWord("finally"); } - | "function" { $$ = CYNew CYWord("function"); } - | "if" { $$ = CYNew CYWord("if"); } - | "import" { $$ = CYNew CYWord("import"); } - | "!in" { $$ = CYNew CYWord("in"); } - | "new" LexSetRegExp { $$ = CYNew CYWord("new"); } - | "null" { $$ = CYNew CYWord("null"); } - | "return" { $$ = CYNew CYWord("return"); } - | "!return" { $$ = CYNew CYWord("return"); } - | "super" { $$ = CYNew CYWord("super"); } - | "switch" { $$ = CYNew CYWord("switch"); } - | "this" { $$ = CYNew CYWord("this"); } - | "throw" { $$ = CYNew CYWord("throw"); } - | "true" { $$ = CYNew CYWord("true"); } - | "try" { $$ = CYNew CYWord("try"); } - | "typeof" LexSetRegExp { $$ = CYNew CYWord("typeof"); } - | "var" { $$ = CYNew CYWord("var"); } - | "void" LexSetRegExp { $$ = CYNew CYWord("void"); } - | "while" { $$ = CYNew CYWord("while"); } - | "with" { $$ = CYNew CYWord("with"); } - | "yield" { $$ = CYNew CYIdentifier("yield"); } - - | Yield LexSetRegExp NewLineOpt { $$ = CYNew CYIdentifier("yield"); } - - // XXX: should be Identifier - | "let" { $$ = CYNew CYIdentifier("let"); } - ; - -@begin ObjectiveC -WordOpt - : Word { $$ = $1; } - | { $$ = NULL; } - ; -@end -/* }}} */ -/* 11.8.1 Null Literals {{{ */ -NullLiteral - : "null" { $$ = CYNew CYNull(); } - ; -/* }}} */ -/* 11.8.2 Boolean Literals {{{ */ -BooleanLiteral - : "true" { $$ = CYNew CYTrue(); } - | "false" { $$ = CYNew CYFalse(); } - ; -/* }}} */ - -/* 11.9 Automatic Semicolon Insertion {{{ */ -StrictSemi - : { driver.Warning(@$, "warning, automatic semi-colon insertion required"); } - ; - -TerminatorSoft - : ";" - | "\n" StrictSemi - ; - -Terminator - : ";" - | error { if (yyla.type_get() != yyeof_ && yyla.type != yytranslate_(token::CloseBrace) && !driver.newline_) { CYERR(@1, "required semi-colon"); } else { yyerrok; driver.errors_.pop_back(); } } StrictSemi - ; - -TerminatorOpt - : ";" - | error { yyerrok; driver.errors_.pop_back(); } StrictSemi - ; -/* }}} */ - -/* 12.1 Identifiers {{{ */ -IdentifierReference - : Identifier { $$ = CYNew CYVariable($1); } - | "yield" { $$ = CYNew CYVariable(CYNew CYIdentifier("yield")); } - ; - -BindingIdentifier - : Identifier { $$ = $1; } - | "yield" { $$ = CYNew CYIdentifier("yield"); } - ; - -BindingIdentifierOpt - : BindingIdentifier { $$ = $1; } - | { $$ = NULL; } - ; - -LabelIdentifier - : Identifier { $$ = $1; } - | "yield" { $$ = CYNew CYIdentifier("yield"); } - ; - -IdentifierType - : Identifier_ { $$ = $1; } - | "abstract" { $$ = CYNew CYIdentifier("abstract"); } - | "await" { $$ = CYNew CYIdentifier("await"); } - | "boolean" { $$ = CYNew CYIdentifier("boolean"); } - | "byte" { $$ = CYNew CYIdentifier("byte"); } - | "double" { $$ = CYNew CYIdentifier("double"); } - | "each" { $$ = CYNew CYIdentifier("each"); } - | "final" { $$ = CYNew CYIdentifier("final"); } - | "float" { $$ = CYNew CYIdentifier("float"); } - | "goto" { $$ = CYNew CYIdentifier("goto"); } - | "implements" { $$ = CYNew CYIdentifier("implements"); } - | "interface" { $$ = CYNew CYIdentifier("interface"); } - | "native" { $$ = CYNew CYIdentifier("native"); } - | "of" { $$ = CYNew CYIdentifier("of"); } - | "package" { $$ = CYNew CYIdentifier("package"); } - | "private" { $$ = CYNew CYIdentifier("private"); } - | "protected" { $$ = CYNew CYIdentifier("protected"); } - | "public" { $$ = CYNew CYIdentifier("public"); } - | "static" { $$ = CYNew CYIdentifier("static"); } - | "synchronized" { $$ = CYNew CYIdentifier("synchronized"); } - | "throws" { $$ = CYNew CYIdentifier("throws"); } - | "transient" { $$ = CYNew CYIdentifier("transient"); } -@begin ObjectiveC - | "bool" { $$ = CYNew CYIdentifier("bool"); } - | "BOOL" { $$ = CYNew CYIdentifier("BOOL"); } - | "id" { $$ = CYNew CYIdentifier("id"); } - | "SEL" { $$ = CYNew CYIdentifier("SEL"); } -@end - ; - -Identifier - : IdentifierType - | "char" { $$ = CYNew CYIdentifier("char"); } - | "from" { $$ = CYNew CYIdentifier("from"); } - | "get" { $$ = CYNew CYIdentifier("get"); } - | "int" { $$ = CYNew CYIdentifier("int"); } - | "long" { $$ = CYNew CYIdentifier("long"); } - | "set" { $$ = CYNew CYIdentifier("set"); } - | "short" { $$ = CYNew CYIdentifier("short"); } - | "undefined" { $$ = CYNew CYIdentifier("undefined"); } - | "volatile" { $$ = CYNew CYIdentifier("volatile"); } -@begin C - | "extern" { $$ = CYNew CYIdentifier("extern"); } - | "signed" { $$ = CYNew CYIdentifier("signed"); } - | "typedef" { $$ = CYNew CYIdentifier("typedef"); } - | "unsigned" { $$ = CYNew CYIdentifier("unsigned"); } -@end -@begin ObjectiveC - | "nil" { $$ = CYNew CYIdentifier("nil"); } - | "NO" { $$ = CYNew CYIdentifier("NO"); } - | "NULL" { $$ = CYNew CYIdentifier("NULL"); } - | "YES" { $$ = CYNew CYIdentifier("YES"); } -@end - ; -/* }}} */ -/* 12.2 Primary Expression {{{ */ -PrimaryExpression - : "this" { $$ = CYNew CYThis(); } - | IdentifierReference { $$ = $1; } - | Literal { $$ = $1; } - | ArrayLiteral { $$ = $1; } - | ObjectLiteral { $$ = $1; } - | FunctionExpression { $$ = $1; } - | ClassExpression { $$ = $1; } - | GeneratorExpression { $$ = $1; } - | RegularExpressionLiteral { $$ = $1; } - | TemplateLiteral { $$ = $1; } - | CoverParenthesizedExpressionAndArrowParameterList { if ($1 == NULL) CYERR(@1, "invalid parenthetical"); $$ = $1; } - | AutoComplete { driver.mode_ = CYDriver::AutoPrimary; YYACCEPT; } - ; - -CoverParenthesizedExpressionAndArrowParameterList - : "(" LexPushInOff Expression ")" LexPopIn { $$ = CYNew CYParenthetical($3); } - | "(" LexPushInOff LexSetRegExp ")" LexPopIn { $$ = NULL; } - | "(" LexPushInOff LexSetRegExp "..." BindingIdentifier ")" LexPopIn { CYNOT(@$); } - | "(" LexPushInOff Expression "," LexSetRegExp "..." BindingIdentifier ")" LexPopIn { CYNOT(@$); } - ; -/* }}} */ -/* 12.2.4 Literals {{{ */ -Literal - : NullLiteral { $$ = $1; } - | BooleanLiteral { $$ = $1; } - | NumericLiteral { $$ = $1; } - | StringLiteral { $$ = $1; } - ; -/* }}} */ -/* 12.2.5 Array Initializer {{{ */ -ArrayLiteral - : "[" LexPushInOff ElementListOpt "]" LexPopIn { $$ = CYNew CYArray($3); } - ; - -ElementList - : AssignmentExpressionOpt "," ElementListOpt { $$ = CYNew CYElementValue($1, $3); } - | LexSetRegExp "..." AssignmentExpression { $$ = CYNew CYElementSpread($3); } - | AssignmentExpression { $$ = CYNew CYElementValue($1, NULL); } - ; - -ElementListOpt - : ElementList { $$ = $1; } - | LexSetRegExp { $$ = NULL; } - ; -/* }}} */ -/* 12.2.6 Object Initializer {{{ */ -ObjectLiteral - : BRACE LexPushInOff PropertyDefinitionListOpt "}" LexPopIn { $$ = CYNew CYObject($3); } - ; - -PropertyDefinitionList_ - : "," PropertyDefinitionListOpt { $$ = $2; } - | { $$ = NULL; } - ; - -PropertyDefinitionList - : PropertyDefinition PropertyDefinitionList_ { $1->SetNext($2); $$ = $1; } - ; - -PropertyDefinitionListOpt - : LexSetRegExp PropertyDefinitionList { $$ = $2; } - | LexSetRegExp { $$ = NULL; } - ; - -PropertyDefinition - : IdentifierReference { $$ = CYNew CYProperty($1->name_, $1); } - | CoverInitializedName { CYNOT(@$); } - | PropertyName ":" AssignmentExpression { $$ = CYNew CYProperty($1, $3); } - | MethodDefinition { $$ = $1; } - ; - -PropertyName - : LiteralPropertyName { $$ = $1; } - | ComputedPropertyName { CYNOT(@$); /* $$ = $1; */ } - ; - -LiteralPropertyName - : IdentifierName { $$ = $1; } - | StringLiteral { $$ = $1; } - | NumericLiteral { $$ = $1; } - ; - -ComputedPropertyName - : "[" AssignmentExpression "]" { $$ = $2; } - ; - -CoverInitializedName - : IdentifierReference Initializer - ; - -Initializer - : "=" AssignmentExpression { $$ = $2; } - ; - -InitializerOpt - : Initializer { $$ = $1; } - | { $$ = NULL; } - ; -/* }}} */ -/* 12.2.9 Template Literals {{{ */ -TemplateLiteral - : NoSubstitutionTemplate { $$ = CYNew CYTemplate($1, NULL); } - | TemplateHead TemplateSpans { $$ = CYNew CYTemplate($1, $2); } - ; - -TemplateSpans - : Expression TemplateMiddle TemplateSpans { $$ = CYNew CYSpan($1, $2, $3); } - | Expression TemplateTail { $$ = CYNew CYSpan($1, $2, NULL); } - ; -/* }}} */ - -/* 12.3 Left-Hand-Side Expressions {{{ */ -MemberAccess - : "[" LexPushInOff Expression "]" LexPopIn { $$ = CYNew CYDirectMember(NULL, $3); } - | "." IdentifierName { $$ = CYNew CYDirectMember(NULL, CYNew CYString($2)); } - | "." AutoComplete { driver.mode_ = CYDriver::AutoDirect; YYACCEPT; } - | TemplateLiteral { CYNOT(@$); } - ; - -MemberExpression - : LexSetRegExp PrimaryExpression { $$ = $2; } - | MemberExpression { driver.context_ = $1; } MemberAccess { $3->SetLeft($1); $$ = $3; } - | SuperProperty { CYNOT(@$); } - | MetaProperty { CYNOT(@$); } - | LexSetRegExp "new" MemberExpression Arguments { $$ = CYNew cy::Syntax::New($3, $4); } - ; - -SuperProperty - : LexSetRegExp "super" "[" Expression "]" - | LexSetRegExp "super" "." IdentifierName - ; - -MetaProperty - : NewTarget - ; - -NewTarget - : LexSetRegExp "new" LexSetRegExp "." "target" - ; - -NewExpression - : MemberExpression { $$ = $1; } - | LexSetRegExp "new" NewExpression { $$ = CYNew cy::Syntax::New($3, NULL); } - ; - -CallExpression_ - : MemberExpression - | CallExpression - ; - -CallExpression - : CallExpression_ Arguments { $$ = CYNew CYCall($1, $2); } - | SuperCall { CYNOT(@$); } - | CallExpression { driver.context_ = $1; } MemberAccess { $3->SetLeft($1); $$ = $3; } - ; - -SuperCall - : LexSetRegExp "super" Arguments - ; - -Arguments - : "(" LexPushInOff ArgumentListOpt ")" LexPopIn { $$ = $3; } - ; - -ArgumentList_ - : "," ArgumentList { $$ = $2; } - | { $$ = NULL; } - ; - -ArgumentList - : AssignmentExpression ArgumentList_ { $$ = CYNew CYArgument(NULL, $1, $2); } - | LexSetRegExp "..." AssignmentExpression { CYNOT(@$); } - ; - -ArgumentListOpt - : ArgumentList { $$ = $1; } - | LexSetRegExp { $$ = NULL; } - ; - -LeftHandSideExpression - : NewExpression { $$ = $1; } - | CallExpression { $$ = $1; } - ; -/* }}} */ -/* 12.4 Postfix Expressions {{{ */ -PostfixExpression - : %prec "" LeftHandSideExpression { $$ = $1; } - | LeftHandSideExpression "++" { $$ = CYNew CYPostIncrement($1); } - | LeftHandSideExpression "--" { $$ = CYNew CYPostDecrement($1); } - ; -/* }}} */ -/* 12.5 Unary Operators {{{ */ -UnaryExpression_ - : "delete" UnaryExpression { $$ = CYNew CYDelete($2); } - | "void" UnaryExpression { $$ = CYNew CYVoid($2); } - | "typeof" UnaryExpression { $$ = CYNew CYTypeOf($2); } - | "++" UnaryExpression { $$ = CYNew CYPreIncrement($2); } - | "\n++" UnaryExpression { $$ = CYNew CYPreIncrement($2); } - | "--" UnaryExpression { $$ = CYNew CYPreDecrement($2); } - | "\n--" UnaryExpression { $$ = CYNew CYPreDecrement($2); } - | "+" UnaryExpression { $$ = CYNew CYAffirm($2); } - | "-" UnaryExpression { $$ = CYNew CYNegate($2); } - | "~" UnaryExpression { $$ = CYNew CYBitwiseNot($2); } - | "!" UnaryExpression { $$ = CYNew CYLogicalNot($2); } - ; - -UnaryExpression - : PostfixExpression { $$ = $1; } - | LexSetRegExp UnaryExpression_ { $$ = $2; } - ; -/* }}} */ -/* 12.6 Multiplicative Operators {{{ */ -MultiplicativeExpression - : UnaryExpression { $$ = $1; } - | MultiplicativeExpression "*" UnaryExpression { $$ = CYNew CYMultiply($1, $3); } - | MultiplicativeExpression "/" UnaryExpression { $$ = CYNew CYDivide($1, $3); } - | MultiplicativeExpression "%" UnaryExpression { $$ = CYNew CYModulus($1, $3); } - ; -/* }}} */ -/* 12.7 Additive Operators {{{ */ -AdditiveExpression - : MultiplicativeExpression { $$ = $1; } - | AdditiveExpression "+" MultiplicativeExpression { $$ = CYNew CYAdd($1, $3); } - | AdditiveExpression "-" MultiplicativeExpression { $$ = CYNew CYSubtract($1, $3); } - ; -/* }}} */ -/* 12.8 Bitwise Shift Operators {{{ */ -ShiftExpression - : AdditiveExpression { $$ = $1; } - | ShiftExpression "<<" AdditiveExpression { $$ = CYNew CYShiftLeft($1, $3); } - | ShiftExpression ">>" AdditiveExpression { $$ = CYNew CYShiftRightSigned($1, $3); } - | ShiftExpression ">>>" AdditiveExpression { $$ = CYNew CYShiftRightUnsigned($1, $3); } - ; -/* }}} */ -/* 12.9 Relational Operators {{{ */ -RelationalExpression - : ShiftExpression { $$ = $1; } - | RelationalExpression "<" ShiftExpression { $$ = CYNew CYLess($1, $3); } - | RelationalExpression ">" ShiftExpression { $$ = CYNew CYGreater($1, $3); } - | RelationalExpression "<=" ShiftExpression { $$ = CYNew CYLessOrEqual($1, $3); } - | RelationalExpression ">=" ShiftExpression { $$ = CYNew CYGreaterOrEqual($1, $3); } - | RelationalExpression "instanceof" ShiftExpression { $$ = CYNew CYInstanceOf($1, $3); } - | RelationalExpression "in" ShiftExpression { $$ = CYNew CYIn($1, $3); } - ; -/* }}} */ -/* 12.10 Equality Operators {{{ */ -EqualityExpression - : RelationalExpression { $$ = $1; } - | EqualityExpression "==" RelationalExpression { $$ = CYNew CYEqual($1, $3); } - | EqualityExpression "!=" RelationalExpression { $$ = CYNew CYNotEqual($1, $3); } - | EqualityExpression "===" RelationalExpression { $$ = CYNew CYIdentical($1, $3); } - | EqualityExpression "!==" RelationalExpression { $$ = CYNew CYNotIdentical($1, $3); } - ; -/* }}} */ -/* 12.11 Binary Bitwise Operators {{{ */ -BitwiseANDExpression - : EqualityExpression { $$ = $1; } - | BitwiseANDExpression "&" EqualityExpression { $$ = CYNew CYBitwiseAnd($1, $3); } - ; - -BitwiseXORExpression - : BitwiseANDExpression { $$ = $1; } - | BitwiseXORExpression "^" BitwiseANDExpression { $$ = CYNew CYBitwiseXOr($1, $3); } - ; - -BitwiseORExpression - : BitwiseXORExpression { $$ = $1; } - | BitwiseORExpression "|" BitwiseXORExpression { $$ = CYNew CYBitwiseOr($1, $3); } - ; -/* }}} */ -/* 12.12 Binary Logical Operators {{{ */ -LogicalANDExpression - : BitwiseORExpression { $$ = $1; } - | LogicalANDExpression "&&" BitwiseORExpression { $$ = CYNew CYLogicalAnd($1, $3); } - ; - -LogicalORExpression - : LogicalANDExpression { $$ = $1; } - | LogicalORExpression "||" LogicalANDExpression { $$ = CYNew CYLogicalOr($1, $3); } - ; -/* }}} */ -/* 12.13 Conditional Operator ( ? : ) {{{ */ -ConditionalExpression - : LogicalORExpression { $$ = $1; } - | LogicalORExpression "?" LexPushInOff AssignmentExpression ":" LexPopIn AssignmentExpression { $$ = CYNew CYCondition($1, $4, $7); } - ; -/* }}} */ -/* 12.14 Assignment Operators {{{ */ -AssignmentExpression - : ConditionalExpression { $$ = $1; } - | LexSetRegExp YieldExpression { $$ = $2; } - | ArrowFunction { $$ = $1; } - | LeftHandSideExpression "=" AssignmentExpression { $$ = CYNew CYAssign($1, $3); } - | LeftHandSideExpression "*=" AssignmentExpression { $$ = CYNew CYMultiplyAssign($1, $3); } - | LeftHandSideExpression "/=" AssignmentExpression { $$ = CYNew CYDivideAssign($1, $3); } - | LeftHandSideExpression "%=" AssignmentExpression { $$ = CYNew CYModulusAssign($1, $3); } - | LeftHandSideExpression "+=" AssignmentExpression { $$ = CYNew CYAddAssign($1, $3); } - | LeftHandSideExpression "-=" AssignmentExpression { $$ = CYNew CYSubtractAssign($1, $3); } - | LeftHandSideExpression "<<=" AssignmentExpression { $$ = CYNew CYShiftLeftAssign($1, $3); } - | LeftHandSideExpression ">>=" AssignmentExpression { $$ = CYNew CYShiftRightSignedAssign($1, $3); } - | LeftHandSideExpression ">>>=" AssignmentExpression { $$ = CYNew CYShiftRightUnsignedAssign($1, $3); } - | LeftHandSideExpression "&=" AssignmentExpression { $$ = CYNew CYBitwiseAndAssign($1, $3); } - | LeftHandSideExpression "^=" AssignmentExpression { $$ = CYNew CYBitwiseXOrAssign($1, $3); } - | LeftHandSideExpression "|=" AssignmentExpression { $$ = CYNew CYBitwiseOrAssign($1, $3); } - ; - -AssignmentExpressionOpt - : AssignmentExpression { $$ = $1; } - | LexSetRegExp { $$ = NULL; } - ; -/* }}} */ -/* 12.15 Comma Operator ( , ) {{{ */ -Expression - : AssignmentExpression { $$ = $1; } - | Expression "," AssignmentExpression { $$ = CYNew CYCompound($1, $3); } - ; - -ExpressionOpt - : Expression { $$ = $1; } - | LexSetRegExp { $$ = NULL; } - ; -/* }}} */ - -/* 13 Statements and Declarations {{{ */ -Statement__ - : BlockStatement { $$ = $1; } - | VariableStatement { $$ = $1; } - | EmptyStatement { $$ = $1; } - | IfStatement { $$ = $1; } - | BreakableStatement { $$ = $1; } - | ContinueStatement { $$ = $1; } - | BreakStatement { $$ = $1; } - | ReturnStatement { $$ = $1; } - | WithStatement { $$ = $1; } - | LabelledStatement { $$ = $1; } - | ThrowStatement { $$ = $1; } - | TryStatement { $$ = $1; } - | DebuggerStatement { $$ = $1; } - ; - -Statement_ - : LexSetRegExp Statement__ { $$ = $2; } - | ExpressionStatement { $$ = $1; } - ; - -Statement - : LexSetStatement Statement_ { $$ = $2; } - ; - -Declaration__ - : HoistableDeclaration { $$ = $1; } - | ClassDeclaration { $$ = $1; } - | LexicalDeclaration { $$ = $1; } - ; - -Declaration_ - : LexSetRegExp Declaration__ { $$ = $2; } - ; - -Declaration - : LexSetStatement Declaration_ { $$ = $2; } - ; - -HoistableDeclaration - : FunctionDeclaration { $$ = $1; } - | GeneratorDeclaration { $$ = $1; } - ; - -BreakableStatement - : IterationStatement { $$ = $1; } - | SwitchStatement { $$ = $1; } - ; -/* }}} */ -/* 13.2 Block {{{ */ -BlockStatement - : ";{" StatementListOpt "}" { $$ = CYNew CYBlock($2); } - ; - -Block - : BRACE StatementListOpt "}" { $$ = $2; } - ; - -StatementList - : StatementListItem StatementListOpt { $1->SetNext($2); $$ = $1; } - ; - -StatementListOpt - : StatementList { $$ = $1; } - | LexSetStatement LexSetRegExp { $$ = NULL; } - ; - -StatementListItem - : Statement { $$ = $1; } - | Declaration { $$ = $1; } - ; -/* }}} */ -/* 13.3+ Let and Const Declarations {{{ */ -LexicalDeclaration - : LetOrConst VariableDeclarationList Terminator { $$ = CYNew CYVar($2); } - ; - -LetOrConst - : "let" - | "const" - ; - -Binding - : BindingIdentifier - ; - -// XXX: lots of binding stuff -/* }}} */ -/* 13.3.2+ Variable Statement {{{ */ -VariableStatement - : Var_ VariableDeclarationList Terminator { $$ = CYNew CYVar($2); } - ; - -VariableDeclarationList_ - : "," VariableDeclarationList { $$ = $2; } - | { $$ = NULL; } - ; - -VariableDeclarationList - : VariableDeclaration VariableDeclarationList_ { $$ = CYNew CYDeclarations($1, $2); } - ; - -VariableDeclaration - : BindingIdentifier InitializerOpt { $$ = CYNew CYDeclaration($1, $2); } - // XXX: | BindingPattern Initializer { $$ = CYNew CYDeclaration($1, $2); } - ; -/* }}} */ -/* 13.3.3 Destructuring Binding Patterns {{{ */ -BindingPattern - : ObjectBindingPattern - | ArrayBindingPattern - ; - -ObjectBindingPattern - : BRACE BindingPropertyListOpt "}" - ; - -ArrayBindingPattern - : "[" { CYNOT(@$); } - ; - -BindingPropertyList_ - : "," BindingPropertyListOpt - | - ; - -BindingPropertyList - : BindingProperty BindingPropertyList_ - ; - -BindingPropertyListOpt - : BindingPropertyList - | - ; - -BindingProperty - : SingleNameBinding - | PropertyName ":" BindingElement - ; - -BindingElement - : SingleNameBinding { $$ = $1; } - | BindingPattern InitializerOpt { CYNOT(@$); } - ; - -SingleNameBinding - : BindingIdentifier InitializerOpt { $$ = CYNew CYDeclaration($1, $2); } - ; - -BindingRestElement - : "..." BindingIdentifier - ; -/* }}} */ -/* 13.4 Empty Statement {{{ */ -EmptyStatement - : ";" { $$ = CYNew CYEmpty(); } - ; -/* }}} */ -/* 13.5 Expression Statement {{{ */ -ExpressionStatement - : Expression Terminator { $$ = CYNew CYExpress($1); } - ; -/* }}} */ -/* 13.6 The if Statement {{{ */ -ElseStatementOpt - : "else" Statement { $$ = $2; } - | %prec "if" { $$ = NULL; } - ; - -IfStatement - : "if" "(" Expression ")" Statement ElseStatementOpt { $$ = CYNew CYIf($3, $5, $6); } - ; -/* }}} */ -/* 13.7+ Iteration Statements {{{ */ -IterationStatement - : "do" Statement "while" "(" Expression ")" TerminatorOpt { $$ = CYNew CYDoWhile($5, $2); } - | "while" "(" Expression ")" Statement { $$ = CYNew CYWhile($3, $5); } - | "for" "(" LexPushInOn ForStatementInitializer ";" LexPopIn ExpressionOpt ";" ExpressionOpt ")" Statement { $$ = CYNew CYFor($4, $7, $9, $11); } - | "for" "(" LexPushInOn ForInStatementInitializer "!in" LexPopIn Expression ")" Statement { $$ = CYNew CYForIn($4, $7, $9); } - | "for" "(" LexPushInOn ForInStatementInitializer "of" LexPopIn Expression ")" Statement { $$ = CYNew CYForOf($4, $7, $9); } - ; - -ForStatementInitializer - : ExpressionOpt { $$ = $1; } - | LexSetRegExp Var_ VariableDeclarationList { $$ = CYNew CYForDeclarations($3); } - ; - -ForInStatementInitializer - : LeftHandSideExpression { $$ = $1; } - | LexSetRegExp Var_ VariableDeclaration { $$ = $3; } - ; -/* }}} */ -/* 13.8 The continue Statement {{{ */ -Continue - : "continue" LexNewLine - ; - -ContinueStatement - : Continue TerminatorSoft { $$ = CYNew CYContinue(NULL); } - | Continue Identifier Terminator { $$ = CYNew CYContinue($2); } - ; -/* }}} */ -/* 13.9 The break Statement {{{ */ -Break - : "break" LexNewLine - ; - -BreakStatement - : Break TerminatorSoft { $$ = CYNew CYBreak(NULL); } - | Break Identifier Terminator { $$ = CYNew CYBreak($2); } - ; -/* }}} */ -/* 13.10 The return Statement {{{ */ -Return - : "!return" LexNewLine - ; - -ReturnStatement - : Return LexSetRegExp TerminatorSoft { $$ = CYNew CYReturn(NULL); } - | Return Expression Terminator { $$ = CYNew CYReturn($2); } - ; -/* }}} */ -/* 13.11 The with Statement {{{ */ -WithStatement - : "with" "(" Expression ")" Statement { $$ = CYNew CYWith($3, $5); } - ; -/* }}} */ -/* 13.12 The switch Statement {{{ */ -SwitchStatement - : "switch" "(" Expression ")" CaseBlock { $$ = CYNew CYSwitch($3, $5); } - ; - -CaseBlock - : BRACE CaseClausesOpt "}" { $$ = $2; } - ; - -CaseClause - : "case" Expression ":" StatementListOpt { $$ = CYNew CYClause($2, $4); } - ; - -CaseClausesOpt - : CaseClause CaseClausesOpt { $1->SetNext($2); $$ = $1; } - | DefaultClause CaseClausesOpt { $1->SetNext($2); $$ = $1; } - | { $$ = NULL; } - ; - -// XXX: the standard makes certain you can only have one of these -DefaultClause - : "default" ":" StatementListOpt { $$ = CYNew CYClause(NULL, $3); } - ; -/* }}} */ -/* 13.13 Labelled Statements {{{ */ -LabelledStatement - : LabelIdentifier ":" LabelledItem { $$ = CYNew CYLabel($1, $3); } - ; - -LabelledItem - : Statement { $$ = $1; } - | LexSetStatement LexSetRegExp FunctionDeclaration { $$ = $3; } - ; -/* }}} */ -/* 13.14 The throw Statement {{{ */ -Throw - : "throw" LexNewLine - ; - -ThrowStatement - : Throw LexSetRegExp TerminatorSoft { CYERR(@1, "throw without exception"); } - | Throw Expression Terminator { $$ = CYNew cy::Syntax::Throw($2); } - ; -/* }}} */ -/* 13.15 The try Statement {{{ */ -TryStatement - : "try" Block Catch { $$ = CYNew cy::Syntax::Try($2, $3, NULL); } - | "try" Block Finally { $$ = CYNew cy::Syntax::Try($2, NULL, $3); } - | "try" Block Catch Finally { $$ = CYNew cy::Syntax::Try($2, $3, $4); } - ; - -Catch - : "catch" "(" CatchParameter ")" Block { $$ = CYNew cy::Syntax::Catch($3, $5); } - ; - -Finally - : "finally" Block { $$ = CYNew CYFinally($2); } - ; - -CatchParameter - : BindingIdentifier { $$ = $1; } - | BindingPattern { CYNOT(@$); } - ; -/* }}} */ -/* 13.16 The debugger Statement {{{ */ -DebuggerStatement - : "debugger" Terminator { $$ = CYNew CYDebugger(); } - ; -/* }}} */ - -/* 14.1 Function Definitions {{{ */ -FunctionDeclaration - : ";function" BindingIdentifier "(" FormalParameters ")" BRACE FunctionBody "}" { $$ = CYNew CYFunctionStatement($2, $4, $7); } - ; - -FunctionExpression - : "function" BindingIdentifierOpt "(" LexPushInOff FormalParameters ")" LexPopIn BRACE LexPushInOff FunctionBody "}" LexPopIn { $$ = CYNew CYFunctionExpression($2, $5, $10); } - ; - -StrictFormalParameters - : FormalParameters { $$ = $1; } - ; - -FormalParameters - : { $$ = NULL; } - | FormalParameterList - ; - -FormalParameterList_ - : "," FormalParameterList { $$ = $2; } - | { $$ = NULL; } - ; - -FormalParameterList - : FunctionRestParameter { CYNOT(@$); } - | FormalParameter FormalParameterList_ { $$ = CYNew CYFunctionParameter($1, $2); } - ; - -FunctionRestParameter - : BindingRestElement - ; - -FormalParameter - : BindingElement { $$ = $1; } - ; - -FunctionBody - : LexPushYieldOff FunctionStatementList LexPopYield { $$ = $2; } - ; - -FunctionStatementList - : LexPushReturnOn StatementListOpt LexPopReturn { $$ = $2; } - ; -/* }}} */ -/* 14.2 Arrow Function Definitions {{{ */ -ArrowFunction - : LexSetRegExp ArrowParameters "=>" LexNoBrace ConciseBody { $$ = CYNew CYFatArrow($2, $5); } - ; - -ArrowParameters - : BindingIdentifier { $$ = CYNew CYFunctionParameter(CYNew CYDeclaration($1)); } - | CoverParenthesizedExpressionAndArrowParameterList { $$ = $1->expression_->Parameter(); if ($$ == NULL) CYERR(@1, "invalid parameter list"); } - ; - -ConciseBody - : AssignmentExpression { $$ = CYNew CYReturn($1); } - | LexSetRegExp ";{" LexPushInOff FunctionBody "}" LexPopIn { $$ = $4; } - ; -/* }}} */ -/* 14.3 Method Definitions {{{ */ -MethodDefinition - : PropertyName "(" StrictFormalParameters ")" BRACE FunctionBody "}" { CYNOT(@$); /* $$ = CYNew CYFunctionMethod($1, $3, $6); */ } - | GeneratorMethod { $$ = $1; } - | "get" PropertyName "(" ")" BRACE FunctionBody "}" { CYNOT(@$); /* $$ = CYNew CYMethodGet($2, $6); */ } - | "set" PropertyName "(" PropertySetParameterList ")" BRACE FunctionBody "}" { CYNOT(@$); /* $$ = CYNew CYMethodSet($2, $4); */ } - ; - -PropertySetParameterList - : FormalParameter { $$ = $1; } - ; -/* }}} */ -/* 14.4 Generator Function Definitions {{{ */ -GeneratorMethod - : "*" PropertyName "(" StrictFormalParameters ")" BRACE GeneratorBody "}" { CYNOT(@$); /* $$ = CYNew CYGeneratorMethod($2, $4, $7); */ } - ; - -GeneratorDeclaration - : ";function" "*" BindingIdentifier "(" FormalParameters ")" BRACE GeneratorBody "}" { CYNOT(@$); /* $$ = CYNew CYGeneratorStatement($3, $5, $8); */ } - ; - -GeneratorExpression - : "function" "*" BindingIdentifierOpt "(" FormalParameters ")" BRACE GeneratorBody "}" { CYNOT(@$); /* $$ = CYNew CYGeneratorExpression($3, $5, $8); */ } - ; - -GeneratorBody - : LexPushYieldOn FunctionStatementList LexPopYield { $$ = $2; } - ; - -Yield - : "!yield" LexNewLine LexNoStar - ; - -YieldExpression - : Yield LexSetRegExp "\n" { CYNOT(@$); /* $$ = CYNew CYYieldValue(NULL); */ } - | Yield AssignmentExpression { CYNOT(@$); /* $$ = CYNew CYYieldValue($2); */ } - | Yield LexSetRegExp YieldStar AssignmentExpression { CYNOT(@$); /* $$ = CYNew CYYieldGenerator($4); */ } - ; -/* }}} */ -/* 14.5 Class Definitions {{{ */ -ClassDeclaration - : ";class" BindingIdentifier ClassTail { CYNOT(@$); } - ; - -ClassExpression - : "class" BindingIdentifierOpt ClassTail { CYNOT(@$); } - ; - -ClassTail - : ClassHeritageOpt BRACE ClassBodyOpt "}" - ; - -ClassHeritage - : "extends" LeftHandSideExpression - ; - -ClassHeritageOpt - : ClassHeritage - | - ; - -ClassBody - : ClassElementList - ; - -ClassBodyOpt - : ClassBody - | - ; - -ClassElementList - : ClassElementListOpt ClassElement - ; - -ClassElementListOpt - : ClassElementList - | - ; - -ClassElement - : MethodDefinition - | "static" MethodDefinition - | ";" - ; -/* }}} */ - -/* 15.1 Scripts {{{ */ -Script - : ScriptBodyOpt { driver.script_ = CYNew CYScript($1); } - ; - -ScriptBody - : StatementList { $$ = $1; } - ; - -ScriptBodyOpt - : ScriptBody { $$ = $1; } - | LexSetStatement LexSetRegExp { $$ = NULL; } - ; -/* }}} */ -/* 15.2 Modules {{{ */ -Module - : ModuleBodyOpt - ; - -ModuleBody - : ModuleItemList - ; - -ModuleBodyOpt - : ModuleBody - | - ; - -ModuleItemList - : ModuleItemListOpt ModuleItem - ; - -ModuleItemListOpt - : ModuleItemList - | - ; - -ModuleItem - : LexSetStatement LexSetRegExp ImportDeclaration - | LexSetStatement LexSetRegExp ExportDeclaration - | StatementListItem - ; -/* }}} */ -/* 15.2.2 Imports {{{ */ -ImportDeclaration - : "import" ImportClause FromClause Terminator - | "import" ModuleSpecifier Terminator - ; - -ImportClause - : ImportedDefaultBinding - | NameSpaceImport - | NamedImports - | ImportedDefaultBinding "," NameSpaceImport - | ImportedDefaultBinding "," NamedImports - ; - -ImportedDefaultBinding - : ImportedBinding - ; - -NameSpaceImport - : "*" "as" ImportedBinding - ; - -NamedImports - : BRACE ImportsListOpt "}" - ; - -FromClause - : "from" ModuleSpecifier - ; - -ImportsList_ - : "," ImportsListOpt - | - ; - -ImportsList - : ImportSpecifier ImportsList_ - ; - -ImportsListOpt - : ImportsList - | - ; - -ImportSpecifier - : ImportedBinding - | IdentifierName "as" ImportedBinding - ; - -ModuleSpecifier - : StringLiteral - ; - -ImportedBinding - : BindingIdentifier - ; -/* }}} */ -/* 15.2.3 Exports {{{ */ -ExportDeclaration_ - : "*" FromClause Terminator - | ExportClause FromClause Terminator - | ExportClause Terminator - | VariableStatement - | "default" LexSetStatement LexSetRegExp HoistableDeclaration - | "default" LexSetStatement LexSetRegExp ClassDeclaration - | "default" LexSetStatement AssignmentExpression Terminator - ; - -ExportDeclaration - : "export" LexSetStatement LexSetRegExp ExportDeclaration_ - | "export" Declaration - ; - -ExportClause - : ";{" ExportsListOpt "}" - ; - -ExportsList_ - : "," ExportsListOpt - | - ; - -ExportsList - : ExportSpecifier ExportsList_ - ; - -ExportsListOpt - : ExportsList - | - ; - -ExportSpecifier - : IdentifierName - | IdentifierName "as" IdentifierName - ; -/* }}} */ - -@begin C -/* Cycript (C): Type Encoding {{{ */ -TypeSignifier - : IdentifierType { $$ = CYNew CYTypedIdentifier(@1, $1); } - | "(" LexPushInOff "*" TypeQualifierRight ")" LexPopIn { $$ = $4; } - ; - -SuffixedType - : SuffixedType "[" NumericLiteral "]" { $$ = $1; $$->modifier_ = CYNew CYTypeArrayOf($3, $$->modifier_); } - | "(" LexPushInOff "^" TypeQualifierRight ")" LexPopIn "(" LexPushInOff TypedParameterListOpt ")" LexPopIn { $$ = $4; $$->modifier_ = CYNew CYTypeBlockWith($9, $$->modifier_); } - | TypeSignifier "(" LexPushInOff TypedParameterListOpt ")" LexPopIn { $$ = $1; $$->modifier_ = CYNew CYTypeFunctionWith($4, $$->modifier_); } - | "(" LexPushInOff TypedParameterListOpt ")" LexPopIn { $$ = CYNew CYTypedIdentifier(@1); $$->modifier_ = CYNew CYTypeFunctionWith($3, $$->modifier_); } - | TypeSignifier { $$ = $1; } - | { $$ = CYNew CYTypedIdentifier(@$); } - ; - -PrefixedType - : "*" TypeQualifierRight { $$ = $2; $$->modifier_ = CYNew CYTypePointerTo($$->modifier_); } - ; - -TypeQualifierLeft - : { $$ = NULL; } - | "const" TypeQualifierLeft { $$ = $2; CYSetLast($$) = CYNew CYTypeConstant(); } - | "volatile" TypeQualifierLeft { $$ = $2; CYSetLast($$) = CYNew CYTypeVolatile(); } - ; - -TypeQualifierRight - : PrefixedType { $$ = $1; } - | SuffixedType { $$ = $1; } - | "const" TypeQualifierRight { $$ = $2; $$->modifier_ = CYNew CYTypeConstant($$->modifier_); } - | "volatile" TypeQualifierRight { $$ = $2; $$->modifier_ = CYNew CYTypeVolatile($$->modifier_); } - ; - -IntegerType - : "int" { $$ = CYNew CYTypeVariable("int"); } - | "unsigned" IntegerTypeOpt { $$ = CYNew CYTypeUnsigned($2); } - | "signed" IntegerTypeOpt { $$ = CYNew CYTypeSigned($2); } - | "long" IntegerTypeOpt { $$ = CYNew CYTypeLong($2); } - | "short" IntegerTypeOpt { $$ = CYNew CYTypeShort($2); } - ; - -IntegerTypeOpt - : IntegerType { $$ = $1; } - | { $$ = CYNew CYTypeVariable("int"); } - ; - -PrimitiveType - : IdentifierType { $$ = CYNew CYTypeVariable($1); } - | IntegerType { $$ = $1; } - | "void" { $$ = CYNew CYTypeVoid(); } - | "char" { $$ = CYNew CYTypeVariable("char"); } - | "signed" "char" { $$ = CYNew CYTypeSigned(CYNew CYTypeVariable("char")); } - | "unsigned" "char" { $$ = CYNew CYTypeUnsigned(CYNew CYTypeVariable("char")); } - ; - -TypedIdentifier - : TypeQualifierLeft PrimitiveType TypeQualifierRight { $$ = $3; $$->specifier_ = $2; CYSetLast($1) = $$->modifier_; $$->modifier_ = $1; } - ; - -PrimaryExpression - : "@encode" "(" TypedIdentifier ")" { $$ = CYNew CYEncodedType($3); } - ; -/* }}} */ -@end - -@begin ObjectiveC -/* Cycript (Objective-C): @class Declaration {{{ */ -ClassSuperOpt - /* XXX: why the hell did I choose MemberExpression? */ - : ":" LexSetRegExp MemberExpression { $$ = $3; } - | { $$ = NULL; } - ; - -ClassFieldListOpt - : TypedIdentifier ";" ClassFieldListOpt { $$ = CYNew CYClassField($1, $3); } - | LexSetRegExp { $$ = NULL; } - ; - -ClassFields - : BRACE ClassFieldListOpt "}" { $$ = $2; } - ; - -MessageScope - : "+" { $$ = false; } - | "-" { $$ = true; } - ; - -TypeOpt - : "(" LexSetRegExp TypedIdentifier ")" { if ($3->identifier_ != NULL) CYERR($3->location_, "unexpected identifier"); $$ = $3; } - | { $$ = CYNew CYTypedIdentifier(CYNew CYTypeVariable("id")); } - ; - -MessageParameter - : Word ":" TypeOpt Identifier { $3->identifier_ = $4; $$ = CYNew CYMessageParameter($1, $3); } - ; - -MessageParameterList - : MessageParameter MessageParameterListOpt { $1->SetNext($2); $$ = $1; } - ; - -MessageParameterListOpt - : MessageParameterList { $$ = $1; } - | { $$ = NULL; } - ; - -MessageParameters - : MessageParameterList { $$ = $1; } - | Word { $$ = CYNew CYMessageParameter($1, NULL); } - ; - -ClassMessageDeclaration - : MessageScope TypeOpt MessageParameters BRACE FunctionBody "}" { $$ = CYNew CYMessage($1, $2, $3, $5); } - ; - -ClassMessageDeclarationListOpt - : ClassMessageDeclarationListOpt ClassMessageDeclaration { $2->SetNext($1); $$ = $2; } - | { $$ = NULL; } - ; - -ClassName - : Identifier { $$ = $1; } - | "(" AssignmentExpression ")" { $$ = $2; } - ; - -// XXX: this should be AssignmentExpressionNoRight -ClassProtocols - : ShiftExpression ClassProtocolsOpt { $$ = CYNew CYProtocol($1, $2); } - ; - -ClassProtocolsOpt - : "," ClassProtocols { $$ = $2; } - | { $$ = NULL; } - ; - -ClassProtocolListOpt - : "<" ClassProtocols ">" { $$ = $2; } - | { $$ = NULL; } - ; - -ClassStatement - : "@implementation" ClassName ClassSuperOpt ClassProtocolListOpt ClassFields ClassMessageDeclarationListOpt "@end" { $$ = CYNew CYClassStatement($2, $3, $4, $5, $6); } - ; - -CategoryName - : "(" WordOpt ")" - ; - -CategoryStatement - : "@implementation" ClassName CategoryName ClassMessageDeclarationListOpt "@end" { $$ = CYNew CYCategory($2, $4); } - ; - -Statement__ - : ClassStatement { $$ = $1; } - | CategoryStatement { $$ = $1; } - ; -/* }}} */ -/* Cycript (Objective-C): Send Message {{{ */ -VariadicCall - : "," AssignmentExpression VariadicCall { $$ = CYNew CYArgument(NULL, $2, $3); } - | { $$ = NULL; } - ; - -SelectorWordOpt - : WordOpt { driver.contexts_.back().words_.push_back($1); } { $$ = $1; } - | AutoComplete { driver.mode_ = CYDriver::AutoMessage; YYACCEPT; } - ; - -SelectorCall_ - : SelectorCall { $$ = $1; } - | VariadicCall { $$ = $1; } - ; - -SelectorCall - : SelectorWordOpt ":" AssignmentExpression SelectorCall_ { $$ = CYNew CYArgument($1 ?: CYNew CYWord(""), $3, $4); } - ; - -SelectorList - : SelectorCall { $$ = $1; } - | Word { $$ = CYNew CYArgument($1, NULL); } - ; - -MessageExpression - : "[" LexPushInOff AssignmentExpression { driver.contexts_.push_back($3); } SelectorList "]" LexPopIn { driver.contexts_.pop_back(); } { $$ = CYNew CYSendDirect($3, $5); } - | "[" LexPushInOff LexSetRegExp "super" { driver.context_ = NULL; } SelectorList "]" LexPopIn { $$ = CYNew CYSendSuper($6); } - ; - -SelectorExpression_ - : WordOpt ":" SelectorExpressionOpt { $$ = CYNew CYSelectorPart($1, true, $3); } - ; - -SelectorExpression - : SelectorExpression_ { $$ = $1; } - | Word { $$ = CYNew CYSelectorPart($1, false, NULL); } - ; - -SelectorExpressionOpt - : SelectorExpression_ { $$ = $1; } - | { $$ = NULL; } - ; - -PrimaryExpression - : MessageExpression { $$ = $1; } - | "@selector" "(" LexPushInOff SelectorExpression ")" LexPopIn { $$ = CYNew CYSelector($4); } - ; -/* }}} */ -@end - -/* Cycript: @import Directive {{{ */ -ModulePath - : ModulePath "." Word { $$ = CYNew CYModule($3, $1); } - | Word { $$ = CYNew CYModule($1); } - ; - -Declaration__ - : "@import" ModulePath { $$ = CYNew CYImport($2); } - ; -/* }}} */ - -@begin ObjectiveC -/* Cycript (Objective-C): Boxed Expressions {{{ */ -BoxableExpression - : NullLiteral { $$ = $1; } - | BooleanLiteral { $$ = $1; } - | NumericLiteral { $$ = $1; } - | StringLiteral { $$ = $1; } - | ArrayLiteral { $$ = $1; } - | ObjectLiteral { $$ = $1; } - | CoverParenthesizedExpressionAndArrowParameterList { $$ = $1; } - | "YES" { $$ = CYNew CYTrue(); } - | "NO" { $$ = CYNew CYFalse(); } - ; - -PrimaryExpression - : "@" BoxableExpression { $$ = CYNew CYBox($2); } - | "@YES" { $$ = CYNew CYBox(CYNew CYTrue()); } - | "@NO" { $$ = CYNew CYBox(CYNew CYFalse()); } - | "@true" { $$ = CYNew CYBox(CYNew CYTrue()); } - | "@false" { $$ = CYNew CYBox(CYNew CYFalse()); } - | "@null" { $$ = CYNew CYBox(CYNew CYNull()); } - ; -/* }}} */ -/* Cycript (Objective-C): Block Expressions {{{ */ -PrimaryExpression - : "^" TypedIdentifier { if ($2->identifier_ != NULL) CYERR($2->location_, "unexpected identifier"); } BRACE LexPushInOff FunctionBody "}" LexPopIn { if (CYTypeFunctionWith *function = $2->Function()) $$ = CYNew CYObjCBlock($2, function->parameters_, $6); else CYERR($2->location_, "expected parameters"); } - ; -/* }}} */ -/* Cycript (Objective-C): Instance Literals {{{ */ -PrimaryExpression - : "#" NumericLiteral { $$ = CYNew CYInstanceLiteral($2); } - ; -/* }}} */ -@end - -@begin C -/* Cycript (C): Pointer Indirection/Addressing {{{ */ -LeftHandSideExpression - : LexSetRegExp "*" UnaryExpression { $$ = CYNew CYIndirect($3); } - ; - -UnaryExpression_ - : "&" UnaryExpression { $$ = CYNew CYAddressOf($2); } - ; - -MemberAccess - : "->" "[" Expression "]" { $$ = CYNew CYIndirectMember(NULL, $3); } - | "->" IdentifierName { $$ = CYNew CYIndirectMember(NULL, CYNew CYString($2)); } - | "->" AutoComplete { driver.mode_ = CYDriver::AutoIndirect; YYACCEPT; } - ; -/* }}} */ -/* Cycript (C): auto Compatibility {{{ */ -Var_ - : "auto" - ; -/* }}} */ -/* Cycript (C): Lambda Expressions {{{ */ -TypedParameterList_ - : "," TypedParameterList { $$ = $2; } - | { $$ = NULL; } - ; - -TypedParameterList - : TypedIdentifier TypedParameterList_ { $$ = CYNew CYTypedParameter($1, $2); } - ; - -TypedParameterListOpt - : TypedParameterList { $$ = $1; } - | { $$ = NULL; } - ; - -PrimaryExpression - : "[" LexPushInOff LexSetRegExp "&" LexSetRegExp "]" LexPopIn "(" LexPushInOff TypedParameterListOpt ")" LexPopIn "->" TypedIdentifier BRACE LexPushInOff FunctionBody "}" LexPopIn { $$ = CYNew CYLambda($14, $10, $17); } - ; -/* }}} */ -/* Cycript (C): Type Definitions {{{ */ -Statement__ - : "typedef" TypedIdentifier { if ($2->identifier_ == NULL) CYERR($2->location_, "expected identifier"); } Terminator { $$ = CYNew CYTypeDefinition($2); } - ; -/* }}} */ -/* Cycript (C): extern "C" {{{ */ -Statement__ - : "extern" StringLiteral { if (strcmp($2->Value(), "C") != 0) CYERR(@2, "unknown extern binding"); } TypedIdentifier { if ($4->identifier_ == NULL) CYERR($4->location_, "expected identifier"); } Terminator { $$ = CYNew CYExternal($2, $4); } - ; -/* }}} */ - -@end - -@begin E4X -/* Lexer State {{{ */ -LexPushRegExp - : { driver.PushCondition(CYDriver::RegExpCondition); } - ; - -LexPushXMLContent - : { driver.PushCondition(CYDriver::XMLContentCondition); } - ; - -LexPushXMLTag - : { driver.PushCondition(CYDriver::XMLTagCondition); } - ; - -LexPop - : { driver.PopCondition(); } - ; - -LexSetXMLContent - : { driver.SetCondition(CYDriver::XMLContentCondition); } - ; - -LexSetXMLTag - : { driver.SetCondition(CYDriver::XMLTagCondition); } - ; -/* }}} */ -/* Virtual Tokens {{{ */ -XMLWhitespaceOpt - : XMLWhitespace - | - ; -/* }}} */ - -/* 8.1 Context Keywords {{{ */ -Identifier - : "namespace" { $$ = CYNew CYIdentifier("namespace"); } - | "xml" { $$ = CYNew CYIdentifier("xml"); } - ; -/* }}} */ -/* 8.3 XML Initializer Input Elements {{{ */ -XMLMarkup - : XMLComment { $$ = $1; } - | XMLCDATA { $$ = $1; } - | XMLPI { $$ = $1; } - ; -/* }}} */ - -/* 11.1 Primary Expressions {{{ */ -PrimaryExpression - : PropertyIdentifier { $$ = CYNew CYPropertyVariable($1); } - | XMLInitialiser { $$ = $1; } - | XMLListInitialiser { $$ = $1; } - ; - -PropertyIdentifier - : AttributeIdentifier { $$ = $1; } - | QualifiedIdentifier { $$ = $1; } - | WildcardIdentifier { $$ = $1; } - ; -/* }}} */ -/* 11.1.1 Attribute Identifiers {{{ */ -AttributeIdentifier - : "@" QualifiedIdentifier_ { $$ = CYNew CYAttribute($2); } - ; - -PropertySelector_ - : PropertySelector { $$ = $1; } - | "[" LexPushInOff Expression "]" LexPopIn { $$ = CYNew CYSelector($3); } - ; - -PropertySelector - : Identifier { $$ = CYNew CYSelector($1); } - | WildcardIdentifier { $$ = $1; } - ; -/* }}} */ -/* 11.1.2 Qualified Identifiers {{{ */ -QualifiedIdentifier_ - : PropertySelector_ { $$ = CYNew CYQualified(NULL, $1); } - | QualifiedIdentifier { $$ = $1; } - ; - -QualifiedIdentifier - : PropertySelector "::" PropertySelector_ { $$ = CYNew CYQualified($1, $3); } - ; -/* }}} */ -/* 11.1.3 Wildcard Identifiers {{{ */ -WildcardIdentifier - : "*" { $$ = CYNew CYWildcard(); } - ; -/* }}} */ -/* 11.1.4 XML Initializer {{{ */ -XMLInitialiser - : XMLMarkup { $$ = $1; } - | XMLElement { $$ = $1; } - ; - -XMLElement - : "<" LexPushInOff XMLTagContent LexPop "/>" LexPopIn - | "<" LexPushInOff XMLTagContent ">" LexSetXMLContent XMLElementContentOpt "" LexPopIn - ; - -XMLTagContent - : LexPushXMLTag XMLTagName XMLAttributes - ; - -XMLExpression - : BRACE LexPushRegExp Expression LexPop "}" - ; - -XMLTagName - : XMLExpression - | XMLName - ; - -XMLAttributes_ - : XMLAttributes_ XMLAttribute - | - ; - -XMLAttributes - : XMLAttributes_ XMLWhitespace XMLExpression XMLWhitespaceOpt - | XMLAttributes_ XMLWhitespaceOpt - ; - -XMLAttributeValue_ - : XMLExpression - | XMLAttributeValue - ; - -XMLAttribute - : XMLWhitespace XMLName XMLWhitespaceOpt "=" XMLWhitespaceOpt XMLAttributeValue_ - ; - -XMLElementContent - : XMLExpression XMLElementContentOpt - | XMLMarkup XMLElementContentOpt - | XMLText XMLElementContentOpt - | XMLElement XMLElementContentOpt - ; - -XMLElementContentOpt - : XMLElementContent - | - ; -/* }}} */ -/* 11.1.5 XMLList Initializer {{{ */ -XMLListInitialiser - : "<>" LexPushInOff LexPushXMLContent XMLElementContent LexPop "" LexPopIn { $$ = CYNew CYXMLList($4); } - ; -/* }}} */ - -/* 11.2 Left-Hand-Side Expressions {{{ */ -PropertyIdentifier_ - : Identifier { $$ = $1; } - | PropertyIdentifier { $$ = $1; } - ; - -MemberAccess - : "." PropertyIdentifier { $$ = CYNew CYPropertyMember(NULL, $2); } - | ".." PropertyIdentifier_ { $$ = CYNew CYDescendantMember(NULL, $2); } - | "." "(" Expression ")" { $$ = CYNew CYFilteringPredicate(NULL, $3); } - ; -/* }}} */ -/* 12.1 The default xml namespace Statement {{{ */ -/* XXX: DefaultXMLNamespaceStatement - : "default" "xml" "namespace" "=" Expression Terminator { $$ = CYNew CYDefaultXMLNamespace($5); } - ; - -Statement__ - : DefaultXMLNamespaceStatement { $$ = $1; } - ; */ -/* }}} */ -@end - -/* JavaScript FTL: Array Comprehensions {{{ */ -Comprehension - : AssignmentExpression ComprehensionFor ComprehensionTail { $$ = CYNew CYArrayComprehension($1, $2->Modify($3)); } - ; - -ComprehensionFor - : "for" "(" Binding "in" Expression ")" { $$ = CYNew CYForInComprehension($3, $5); } - | "for" "each" "(" Binding "in" Expression ")" { $$ = CYNew CYForOfComprehension($4, $6); } - ; -/* }}} */ -/* JavaScript FTL: for each {{{ */ -IterationStatement - : "for" "each" "(" LexPushInOn ForInStatementInitializer "!in" LexPopIn Expression ")" Statement { $$ = CYNew CYForOf($5, $8, $10); } - ; -/* }}} */ -/* JavaScript FTL: let Statements {{{ */ -LetStatement - : "let" "(" VariableDeclarationList ")" Statement { $$ = CYNew CYLetStatement($3, $5); } - ; - -Statement__ - : LetStatement - ; -/* }}} */ - -/* JavaScript FTW: Array Comprehensions {{{ */ -PrimaryExpression - : ArrayComprehension - ; - -ArrayComprehension - : "[" LexPushInOff Comprehension "]" LexPopIn { $$ = $3; } - ; - -Comprehension - : LexSetRegExp ComprehensionFor ComprehensionTail AssignmentExpression { $$ = CYNew CYArrayComprehension($4, $2->Modify($3)); } - ; - -ComprehensionTail - : { $$ = NULL; } - | ComprehensionFor ComprehensionTail { $$ = $1->Modify($2); } - | ComprehensionIf ComprehensionTail { $$ = $1->Modify($2); } - ; - -ComprehensionFor - : "for" "(" Binding "of" Expression ")" { $$ = CYNew CYForOfComprehension($3, $5); } - ; - -ComprehensionIf - : "if" "(" AssignmentExpression ")" { $$ = CYNew CYIfComprehension($3); } - ; -/* }}} */ -/* JavaScript FTW: Coalesce Operator {{{ */ -ConditionalExpression - : LogicalORExpression "?" LexPushInOff LexSetRegExp ":" LexPopIn AssignmentExpression { $$ = CYNew CYCondition($1, $1, $7); } - ; -/* }}} */ -/* JavaScript FTW: Named Arguments {{{ */ -ArgumentList - : LexSetRegExp Word ":" AssignmentExpression ArgumentList_ { $$ = CYNew CYArgument($2, $4, $5); } - ; -/* }}} */ -/* JavaScript FTW: Ruby Blocks {{{ */ -RubyProcParameterList_ - : "," RubyProcParameterList { $$ = $2; } - | { $$ = NULL; } - ; - -RubyProcParameterList - : Identifier RubyProcParameterList_ { $$ = CYNew CYFunctionParameter(CYNew CYDeclaration($1), $2); } - | { $$ = NULL; } - ; - -RubyProcParameters - : LexSetRegExp "|" RubyProcParameterList "|" { $$ = $3; } - | LexSetRegExp "||" { $$ = NULL; } - ; - -RubyProcParametersOpt - : RubyProcParameters { $$ = $1; } - | { $$ = NULL; } - ; - -RubyProcExpression - : "{" RubyProcParametersOpt StatementListOpt "}" { $$ = CYNew CYRubyProc($2, $3); } - ; - -PrimaryExpression - : BRACE LexPushInOff RubyProcParameters StatementListOpt "}" LexPopIn { $$ = CYNew CYRubyProc($3, $4); } - ; - -PostfixExpression - : LeftHandSideExpression RubyProcExpression { $$ = CYNew CYRubyBlock($1, $2); } - ; -/* }}} */ - -%% - -bool CYDriver::Parse(CYMark mark) { - mark_ = mark; - CYLocal local(&pool_); - cy::parser parser(*this); -#ifdef YYDEBUG - parser.set_debug_level(debug_); -#endif - return parser.parse() != 0; -} - -void CYDriver::Warning(const cy::parser::location_type &location, const char *message) { - if (!strict_) - return; - - CYDriver::Error error; - error.warning_ = true; - error.location_ = location; - error.message_ = message; - errors_.push_back(error); -} - -void cy::parser::error(const cy::parser::location_type &location, const std::string &message) { - CYDriver::Error error; - error.warning_ = false; - error.location_ = location; - error.message_ = message; - driver.errors_.push_back(error); -} diff --git a/Decode.hpp b/Decode.hpp index f84cf00..be4e8b9 100644 --- a/Decode.hpp +++ b/Decode.hpp @@ -24,7 +24,7 @@ #include -#include "Parser.hpp" +#include "Syntax.hpp" CYTypedIdentifier *Decode(CYPool &pool, struct sig::Type *type); diff --git a/Display.cpp b/Display.cpp index ed643f2..5227fa1 100644 --- a/Display.cpp +++ b/Display.cpp @@ -32,10 +32,10 @@ #include -#include "Highlight.hpp" - #include +#include "Highlight.hpp" + typedef std::complex CYCursor; extern "C" int rl_display_fixed; diff --git a/Driver.cpp b/Driver.cpp index 4bac2c2..df31a03 100644 --- a/Driver.cpp +++ b/Driver.cpp @@ -20,7 +20,7 @@ /* }}} */ #include "Driver.hpp" -#include "Parser.hpp" +#include "Syntax.hpp" bool CYParser(CYPool &pool, bool debug); diff --git a/E4X/Syntax.hpp b/E4X/Syntax.hpp index 1789ead..4828cdc 100644 --- a/E4X/Syntax.hpp +++ b/E4X/Syntax.hpp @@ -22,7 +22,7 @@ #ifndef CYCRIPT_E4X_SYNTAX_HPP #define CYCRIPT_E4X_SYNTAX_HPP -#include "Parser.hpp" +#include "Syntax.hpp" struct CYDefaultXMLNamespace : CYStatement diff --git a/Error.hpp b/Error.hpp index 4d899e0..f63180e 100644 --- a/Error.hpp +++ b/Error.hpp @@ -22,8 +22,8 @@ #ifndef CYCRIPT_ERROR_HPP #define CYCRIPT_ERROR_HPP -#include "Pooling.hpp" #include "Exception.hpp" +#include "Pooling.hpp" #ifdef CY_EXECUTE struct CYJSError : diff --git a/Execute.cpp b/Execute.cpp index 89a796a..80b9e63 100644 --- a/Execute.cpp +++ b/Execute.cpp @@ -19,35 +19,33 @@ **/ /* }}} */ -#include "Internal.hpp" +#include "cycript.hpp" + +#include +#include +#include +#include +#include +#include #include #include #include #include -#include "cycript.hpp" - -#include "sig/parse.hpp" -#include "sig/ffi_type.hpp" - -#include "Pooling.hpp" -#include "Execute.hpp" - #include #include -#include -#include -#include -#include -#include -#include +#include "sig/parse.hpp" +#include "sig/ffi_type.hpp" #include "Code.hpp" #include "Decode.hpp" #include "Error.hpp" +#include "Execute.hpp" +#include "Internal.hpp" #include "JavaScript.hpp" +#include "Pooling.hpp" #include "String.hpp" static std::vector &GetHooks() { diff --git a/Handler.cpp b/Handler.cpp index 2a17d61..a49fcb6 100644 --- a/Handler.cpp +++ b/Handler.cpp @@ -19,6 +19,8 @@ **/ /* }}} */ +#include "cycript.hpp" + #include #include #include @@ -34,11 +36,9 @@ #include #endif -#include "cycript.hpp" - #include "Driver.hpp" #include "JavaScript.hpp" -#include "Parser.hpp" +#include "Syntax.hpp" #include "Pooling.hpp" struct CYExecute_ { diff --git a/Library.cpp b/Library.cpp index e8e70d6..f5eb1c3 100644 --- a/Library.cpp +++ b/Library.cpp @@ -19,14 +19,8 @@ **/ /* }}} */ -#include - #include "cycript.hpp" -#include "Pooling.hpp" - -#include - #include #include #include @@ -34,13 +28,17 @@ #include #include +#include + +#include + +#include "ConvertUTF.h" #include "Driver.hpp" #include "Error.hpp" #include "Execute.hpp" -#include "Parser.hpp" +#include "Pooling.hpp" #include "String.hpp" - -#include "ConvertUTF.h" +#include "Syntax.hpp" template <> ::pthread_key_t CYLocal::key_ = Key_(); diff --git a/Makefile.am b/Makefile.am index d89c83f..343b050 100644 --- a/Makefile.am +++ b/Makefile.am @@ -43,8 +43,8 @@ lib_LTLIBRARIES += libcycript.la libcycript_la_LDFLAGS = $(CY_LDFLAGS) libcycript_la_LIBADD = $(LTLIBFFI) $(LTLIBGCC) -ldl -libcycript_la_SOURCES = ConvertUTF.c Decode.cpp Driver.cpp Highlight.cpp Library.cpp Network.cpp Output.cpp Parser.cpp Replace.cpp -libcycript_la_SOURCES += Cycript.tab.cc lex.cy.cpp +libcycript_la_SOURCES = ConvertUTF.c Decode.cpp Driver.cpp Highlight.cpp Library.cpp Network.cpp Output.cpp Replace.cpp Syntax.cpp +libcycript_la_SOURCES += Parser.cpp Scanner.cpp filters = @@ -95,25 +95,25 @@ AM_CPPFLAGS += -DCY_ATTACH endif endif -CLEANFILES += Cycript.yy -Cycript.yy: Cycript.yy.in +CLEANFILES += Parser.ypp +Parser.ypp: Parser.ypp.in $(srcdir)/Filter.sh $< >$@ $(filters) -CLEANFILES += Cycript.l -Cycript.l: Cycript.l.in UnicodeIDStart.l UnicodeIDContinue.l +CLEANFILES += Scanner.lpp +Scanner.lpp: Scanner.lpp.in UnicodeIDStart.l UnicodeIDContinue.l $(srcdir)/Filter.sh $< >$@ $(filters) -CLEANFILES += lex.cy.cpp -lex.cy.cpp: Cycript.l - $(FLEX) -o $@ -T $< 2>lex.output || (grep -F '$<:' lex.output; false) - grep -F 'No backing up.' lex.backup >/dev/null - ! grep -F ': warning, ' lex.output || true +CLEANFILES += Scanner.cpp Scanner.output lex.backup +Scanner.cpp: Scanner.lpp + $(FLEX) -o $@ -T $< 2>Scanner.output || (grep -F '$<:' Scanner.output; false) + grep -E '^(No backing up\.|Compressed tables always back up\.)$$' lex.backup >/dev/null + ! grep -F ': warning, ' Scanner.output || true -lex.cy.lo: Cycript.tab.hh +Scanner.lo: Parser.hpp -CLEANFILES += Cycript.tab.cc Cycript.tab.hh stack.hh Cycript.output -Cycript.tab.cc Cycript.tab.hh stack.hh Cycript.output: Cycript.yy - $(BISON) -v --report=state -Werror $< - ! grep -n '^State [0-9]* conflicts:' Cycript.output - ! grep -n '^ *$$default *reduce using rule [0-9]* (Lex[A-Z][^)]*)$$' Cycript.output -B 2 | grep 'shift, and go to state [0-9]*$$' - ! grep -n '^ *$$default *reduce using rule [0-9]* (Lex[A-Z][^)]*)$$' Cycript.output -B 2 | grep -v '$$default' | grep 'reduce using rule [0-9]* ([^)]*)$$' +CLEANFILES += Parser.cpp Parser.hpp stack.hh Parser.output +Parser.cpp Parser.hpp stack.hh Parser.output: Parser.ypp + $(BISON) -v --report=state -Werror -o Parser.cpp $< + ! grep -n '^State [0-9]* conflicts:' Parser.output + ! grep -n '^ *$$default *reduce using rule [0-9]* (Lex[A-Z][^)]*)$$' Parser.output -B 2 | grep 'shift, and go to state [0-9]*$$' + ! grep -n '^ *$$default *reduce using rule [0-9]* (Lex[A-Z][^)]*)$$' Parser.output -B 2 | grep -v '$$default' | grep 'reduce using rule [0-9]* ([^)]*)$$' diff --git a/Makefile.in b/Makefile.in index ba8d8f5..9d6be43 100644 --- a/Makefile.in +++ b/Makefile.in @@ -180,8 +180,8 @@ libcycript_la_DEPENDENCIES = $(am__DEPENDENCIES_1) \ $(am__DEPENDENCIES_1) $(am__DEPENDENCIES_2) \ $(am__DEPENDENCIES_3) $(am__DEPENDENCIES_4) am__libcycript_la_SOURCES_DIST = ConvertUTF.c Decode.cpp Driver.cpp \ - Highlight.cpp Library.cpp Network.cpp Output.cpp Parser.cpp \ - Replace.cpp Cycript.tab.cc lex.cy.cpp Complete.cpp \ + Highlight.cpp Library.cpp Network.cpp Output.cpp Replace.cpp \ + Syntax.cpp Parser.cpp Scanner.cpp Complete.cpp \ sig/ffi_type.cpp sig/parse.cpp sig/copy.cpp Bridge.cpp \ Execute.cpp JavaScriptCore.cpp Java/Execute.cpp \ ObjectiveC/Output.cpp ObjectiveC/Replace.cpp \ @@ -197,8 +197,8 @@ am__dirstamp = $(am__leading_dot)dirstamp @CY_OBJECTIVEC_TRUE@ ObjectiveC/Library.lo @CY_ATTACH_TRUE@am__objects_5 = Handler.lo am_libcycript_la_OBJECTS = ConvertUTF.lo Decode.lo Driver.lo \ - Highlight.lo Library.lo Network.lo Output.lo Parser.lo \ - Replace.lo Cycript.tab.lo lex.cy.lo $(am__objects_1) \ + Highlight.lo Library.lo Network.lo Output.lo Replace.lo \ + Syntax.lo Parser.lo Scanner.lo $(am__objects_1) \ $(am__objects_2) $(am__objects_3) $(am__objects_4) \ $(am__objects_5) libcycript_la_OBJECTS = $(am_libcycript_la_OBJECTS) @@ -536,8 +536,9 @@ top_build_prefix = @top_build_prefix@ top_builddir = @top_builddir@ top_srcdir = @top_srcdir@ AUTOMAKE_OPTIONS = subdir-objects -CLEANFILES = $(am__append_6) Cycript.yy Cycript.l lex.cy.cpp \ - Cycript.tab.cc Cycript.tab.hh stack.hh Cycript.output +CLEANFILES = $(am__append_6) Parser.ypp Scanner.lpp Scanner.cpp \ + Scanner.output lex.backup Parser.cpp Parser.hpp stack.hh \ + Parser.output SUBDIRS = ACLOCAL_AMFLAGS = -I m4 AM_CPPFLAGS = -DYYDEBUG=1 -include config.h -include \ @@ -552,8 +553,8 @@ libcycript_la_LDFLAGS = $(CY_LDFLAGS) libcycript_la_LIBADD = $(LTLIBFFI) $(LTLIBGCC) -ldl $(am__append_3) \ $(am__append_9) $(am__append_12) libcycript_la_SOURCES = ConvertUTF.c Decode.cpp Driver.cpp \ - Highlight.cpp Library.cpp Network.cpp Output.cpp Parser.cpp \ - Replace.cpp Cycript.tab.cc lex.cy.cpp $(am__append_1) \ + Highlight.cpp Library.cpp Network.cpp Output.cpp Replace.cpp \ + Syntax.cpp Parser.cpp Scanner.cpp $(am__append_1) \ $(am__append_2) $(am__append_8) $(am__append_11) \ $(am__append_13) filters = $(am__append_5) $(am__append_7) $(am__append_10) @@ -564,7 +565,7 @@ all: config.h $(MAKE) $(AM_MAKEFLAGS) all-recursive .SUFFIXES: -.SUFFIXES: .c .cc .cpp .lo .mm .o .obj +.SUFFIXES: .c .cpp .lo .mm .o .obj am--refresh: Makefile @: $(srcdir)/Makefile.in: @MAINTAINER_MODE_TRUE@ $(srcdir)/Makefile.am $(am__configure_deps) @@ -749,7 +750,6 @@ distclean-compile: @AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/Complete.Plo@am__quote@ @AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/Console.Po@am__quote@ @AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/ConvertUTF.Plo@am__quote@ -@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/Cycript.tab.Plo@am__quote@ @AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/Decode.Plo@am__quote@ @AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/Display.Po@am__quote@ @AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/Driver.Plo@am__quote@ @@ -763,7 +763,8 @@ distclean-compile: @AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/Output.Plo@am__quote@ @AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/Parser.Plo@am__quote@ @AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/Replace.Plo@am__quote@ -@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/lex.cy.Plo@am__quote@ +@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/Scanner.Plo@am__quote@ +@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/Syntax.Plo@am__quote@ @AMDEP_TRUE@@am__include@ @am__quote@Java/$(DEPDIR)/Execute.Plo@am__quote@ @AMDEP_TRUE@@am__include@ @am__quote@ObjectiveC/$(DEPDIR)/Library.Plo@am__quote@ @AMDEP_TRUE@@am__include@ @am__quote@ObjectiveC/$(DEPDIR)/Output.Plo@am__quote@ @@ -796,30 +797,6 @@ distclean-compile: @AMDEP_TRUE@@am__fastdepCC_FALSE@ DEPDIR=$(DEPDIR) $(CCDEPMODE) $(depcomp) @AMDEPBACKSLASH@ @am__fastdepCC_FALSE@ $(AM_V_CC@am__nodep@)$(LTCOMPILE) -c -o $@ $< -.cc.o: -@am__fastdepCXX_TRUE@ $(AM_V_CXX)depbase=`echo $@ | sed 's|[^/]*$$|$(DEPDIR)/&|;s|\.o$$||'`;\ -@am__fastdepCXX_TRUE@ $(CXXCOMPILE) -MT $@ -MD -MP -MF $$depbase.Tpo -c -o $@ $< &&\ -@am__fastdepCXX_TRUE@ $(am__mv) $$depbase.Tpo $$depbase.Po -@AMDEP_TRUE@@am__fastdepCXX_FALSE@ $(AM_V_CXX)source='$<' object='$@' libtool=no @AMDEPBACKSLASH@ -@AMDEP_TRUE@@am__fastdepCXX_FALSE@ DEPDIR=$(DEPDIR) $(CXXDEPMODE) $(depcomp) @AMDEPBACKSLASH@ -@am__fastdepCXX_FALSE@ $(AM_V_CXX@am__nodep@)$(CXXCOMPILE) -c -o $@ $< - -.cc.obj: -@am__fastdepCXX_TRUE@ $(AM_V_CXX)depbase=`echo $@ | sed 's|[^/]*$$|$(DEPDIR)/&|;s|\.obj$$||'`;\ -@am__fastdepCXX_TRUE@ $(CXXCOMPILE) -MT $@ -MD -MP -MF $$depbase.Tpo -c -o $@ `$(CYGPATH_W) '$<'` &&\ -@am__fastdepCXX_TRUE@ $(am__mv) $$depbase.Tpo $$depbase.Po -@AMDEP_TRUE@@am__fastdepCXX_FALSE@ $(AM_V_CXX)source='$<' object='$@' libtool=no @AMDEPBACKSLASH@ -@AMDEP_TRUE@@am__fastdepCXX_FALSE@ DEPDIR=$(DEPDIR) $(CXXDEPMODE) $(depcomp) @AMDEPBACKSLASH@ -@am__fastdepCXX_FALSE@ $(AM_V_CXX@am__nodep@)$(CXXCOMPILE) -c -o $@ `$(CYGPATH_W) '$<'` - -.cc.lo: -@am__fastdepCXX_TRUE@ $(AM_V_CXX)depbase=`echo $@ | sed 's|[^/]*$$|$(DEPDIR)/&|;s|\.lo$$||'`;\ -@am__fastdepCXX_TRUE@ $(LTCXXCOMPILE) -MT $@ -MD -MP -MF $$depbase.Tpo -c -o $@ $< &&\ -@am__fastdepCXX_TRUE@ $(am__mv) $$depbase.Tpo $$depbase.Plo -@AMDEP_TRUE@@am__fastdepCXX_FALSE@ $(AM_V_CXX)source='$<' object='$@' libtool=yes @AMDEPBACKSLASH@ -@AMDEP_TRUE@@am__fastdepCXX_FALSE@ DEPDIR=$(DEPDIR) $(CXXDEPMODE) $(depcomp) @AMDEPBACKSLASH@ -@am__fastdepCXX_FALSE@ $(AM_V_CXX@am__nodep@)$(LTCXXCOMPILE) -c -o $@ $< - .cpp.o: @am__fastdepCXX_TRUE@ $(AM_V_CXX)depbase=`echo $@ | sed 's|[^/]*$$|$(DEPDIR)/&|;s|\.o$$||'`;\ @am__fastdepCXX_TRUE@ $(CXXCOMPILE) -MT $@ -MD -MP -MF $$depbase.Tpo -c -o $@ $< &&\ @@ -1326,21 +1303,21 @@ uninstall-am: uninstall-binPROGRAMS uninstall-libLTLIBRARIES @CY_EXECUTE_TRUE@ $(srcdir)/Bridge.sh $< >$@ @CY_EXECUTE_TRUE@Bridge.hpp: Bridge.gperf @CY_EXECUTE_TRUE@ $(GPERF) $< >$@ -Cycript.yy: Cycript.yy.in +Parser.ypp: Parser.ypp.in $(srcdir)/Filter.sh $< >$@ $(filters) -Cycript.l: Cycript.l.in UnicodeIDStart.l UnicodeIDContinue.l +Scanner.lpp: Scanner.lpp.in UnicodeIDStart.l UnicodeIDContinue.l $(srcdir)/Filter.sh $< >$@ $(filters) -lex.cy.cpp: Cycript.l - $(FLEX) -o $@ -T $< 2>lex.output || (grep -F '$<:' lex.output; false) - grep -F 'No backing up.' lex.backup >/dev/null - ! grep -F ': warning, ' lex.output || true - -lex.cy.lo: Cycript.tab.hh -Cycript.tab.cc Cycript.tab.hh stack.hh Cycript.output: Cycript.yy - $(BISON) -v --report=state -Werror $< - ! grep -n '^State [0-9]* conflicts:' Cycript.output - ! grep -n '^ *$$default *reduce using rule [0-9]* (Lex[A-Z][^)]*)$$' Cycript.output -B 2 | grep 'shift, and go to state [0-9]*$$' - ! grep -n '^ *$$default *reduce using rule [0-9]* (Lex[A-Z][^)]*)$$' Cycript.output -B 2 | grep -v '$$default' | grep 'reduce using rule [0-9]* ([^)]*)$$' +Scanner.cpp: Scanner.lpp + $(FLEX) -o $@ -T $< 2>Scanner.output || (grep -F '$<:' Scanner.output; false) + grep -E '^(No backing up\.|Compressed tables always back up\.)$$' lex.backup >/dev/null + ! grep -F ': warning, ' Scanner.output || true + +Scanner.lo: Parser.hpp +Parser.cpp Parser.hpp stack.hh Parser.output: Parser.ypp + $(BISON) -v --report=state -Werror -o Parser.cpp $< + ! grep -n '^State [0-9]* conflicts:' Parser.output + ! grep -n '^ *$$default *reduce using rule [0-9]* (Lex[A-Z][^)]*)$$' Parser.output -B 2 | grep 'shift, and go to state [0-9]*$$' + ! grep -n '^ *$$default *reduce using rule [0-9]* (Lex[A-Z][^)]*)$$' Parser.output -B 2 | grep -v '$$default' | grep 'reduce using rule [0-9]* ([^)]*)$$' # Tell versions [3.59,3.63) of GNU make to not export all variables. # Otherwise a system limit (for SysV at least) may be exceeded. diff --git a/ObjectiveC/Internal.hpp b/ObjectiveC/Internal.hpp index d4e5426..9cffb48 100644 --- a/ObjectiveC/Internal.hpp +++ b/ObjectiveC/Internal.hpp @@ -22,9 +22,10 @@ #ifndef CYCRIPT_OBJECTIVEC_INTERNAL_HPP #define CYCRIPT_OBJECTIVEC_INTERNAL_HPP -#include #include +#include "../Internal.hpp" + struct Selector_privateData : CYValue { diff --git a/ObjectiveC/Library.mm b/ObjectiveC/Library.mm index 87ad547..86c705f 100644 --- a/ObjectiveC/Library.mm +++ b/ObjectiveC/Library.mm @@ -21,22 +21,27 @@ #include "cycript.hpp" -#include "ObjectiveC/Internal.hpp" +#include + +#include +#include + +#include + +#ifdef __APPLE__ +#include +#include +#endif #include #include -#include - #ifdef __APPLE__ #include #include #endif -#ifdef __APPLE__ -#include -#include -#endif +#include #include "Code.hpp" #include "Error.hpp" @@ -44,11 +49,7 @@ #include "String.hpp" #include "Execute.hpp" -#include -#include -#include - -#include +#include "ObjectiveC/Internal.hpp" #define CYObjectiveTry_ { \ try diff --git a/ObjectiveC/Output.cpp b/ObjectiveC/Output.cpp index 9d0caa0..360a54e 100644 --- a/ObjectiveC/Output.cpp +++ b/ObjectiveC/Output.cpp @@ -19,10 +19,11 @@ **/ /* }}} */ +#include + #include "Replace.hpp" -#include "ObjectiveC/Syntax.hpp" -#include +#include "ObjectiveC/Syntax.hpp" void CYCategory::Output(CYOutput &out, CYFlags flags) const { out << "(function($cys,$cyp,$cyc,$cyn,$cyt){"; diff --git a/ObjectiveC/Replace.cpp b/ObjectiveC/Replace.cpp index 1b71e02..74e9227 100644 --- a/ObjectiveC/Replace.cpp +++ b/ObjectiveC/Replace.cpp @@ -19,10 +19,11 @@ **/ /* }}} */ +#include + #include "Replace.hpp" -#include "ObjectiveC/Syntax.hpp" -#include +#include "ObjectiveC/Syntax.hpp" static CYExpression *MessageType(CYContext &context, CYTypedIdentifier *type, CYMessageParameter *next, CYExpression *extra = NULL) { CYExpression *left($C0($M(type->Replace(context), $S("toString")))); diff --git a/ObjectiveC/Syntax.hpp b/ObjectiveC/Syntax.hpp index d7a74cd..025612a 100644 --- a/ObjectiveC/Syntax.hpp +++ b/ObjectiveC/Syntax.hpp @@ -22,7 +22,7 @@ #ifndef CYCRIPT_OBJECTIVEC_SYNTAX_HPP #define CYCRIPT_OBJECTIVEC_SYNTAX_HPP -#include "Parser.hpp" +#include "../Syntax.hpp" struct CYInstanceLiteral : CYExpression diff --git a/Output.cpp b/Output.cpp index 2ff5ad7..c8205e5 100644 --- a/Output.cpp +++ b/Output.cpp @@ -20,10 +20,11 @@ /* }}} */ #include "cycript.hpp" -#include "Parser.hpp" #include +#include "Syntax.hpp" + void CYOutput::Terminate() { operator ()(';'); mode_ = NoMode; diff --git a/Parser.cpp b/Parser.cpp deleted file mode 100644 index f9a146a..0000000 --- a/Parser.cpp +++ /dev/null @@ -1,26 +0,0 @@ -/* Cycript - Optimizing JavaScript Compiler/Runtime - * Copyright (C) 2009-2015 Jay Freeman (saurik) -*/ - -/* GNU Affero General Public License, Version 3 {{{ */ -/* - * This program is free software: you can redistribute it and/or modify - * it under the terms of the GNU Affero General Public License as published by - * the Free Software Foundation, either version 3 of the License, or - * (at your option) any later version. - - * This program is distributed in the hope that it will be useful, - * but WITHOUT ANY WARRANTY; without even the implied warranty of - * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the - * GNU Affero General Public License for more details. - - * You should have received a copy of the GNU Affero General Public License - * along with this program. If not, see . -**/ -/* }}} */ - -#include "Parser.hpp" - -CYRange DigitRange_ (0x3ff000000000000LLU, 0x000000000000000LLU); // 0-9 -CYRange WordStartRange_(0x000001000000000LLU, 0x7fffffe87fffffeLLU); // A-Za-z_$ -CYRange WordEndRange_ (0x3ff001000000000LLU, 0x7fffffe87fffffeLLU); // A-Za-z_$0-9 diff --git a/Parser.hpp b/Parser.hpp deleted file mode 100644 index 02b08eb..0000000 --- a/Parser.hpp +++ /dev/null @@ -1,2354 +0,0 @@ -/* Cycript - Optimizing JavaScript Compiler/Runtime - * Copyright (C) 2009-2015 Jay Freeman (saurik) -*/ - -/* GNU Affero General Public License, Version 3 {{{ */ -/* - * This program is free software: you can redistribute it and/or modify - * it under the terms of the GNU Affero General Public License as published by - * the Free Software Foundation, either version 3 of the License, or - * (at your option) any later version. - - * This program is distributed in the hope that it will be useful, - * but WITHOUT ANY WARRANTY; without even the implied warranty of - * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the - * GNU Affero General Public License for more details. - - * You should have received a copy of the GNU Affero General Public License - * along with this program. If not, see . -**/ -/* }}} */ - -#ifndef CYCRIPT_PARSER_HPP -#define CYCRIPT_PARSER_HPP - -#include -#include -#include -#include -#include - -#include -#include - -#include "List.hpp" -#include "Location.hpp" -#include "Pooling.hpp" -#include "Options.hpp" - -struct CYContext; - -struct CYThing { - virtual void Output(struct CYOutput &out) const = 0; -}; - -struct CYOutput { - std::streambuf &out_; - CYPosition position_; - - CYOptions &options_; - bool pretty_; - unsigned indent_; - unsigned recent_; - bool right_; - - enum { - NoMode, - NoLetter, - NoPlus, - NoHyphen, - Terminated - } mode_; - - CYOutput(std::streambuf &out, CYOptions &options) : - out_(out), - options_(options), - pretty_(false), - indent_(0), - recent_(0), - right_(false), - mode_(NoMode) - { - } - - void Check(char value); - void Terminate(); - - _finline void operator ()(char value) { - _assert(out_.sputc(value) != EOF); - recent_ = indent_; - if (value == '\n') - position_.lines(1); - else - position_.columns(1); - } - - _finline void operator ()(const char *data, std::streamsize size) { - _assert(out_.sputn(data, size) == size); - recent_ = indent_; - position_.columns(size); - } - - _finline void operator ()(const char *data) { - return operator ()(data, strlen(data)); - } - - CYOutput &operator <<(char rhs); - CYOutput &operator <<(const char *rhs); - - _finline CYOutput &operator <<(const CYThing *rhs) { - if (rhs != NULL) - rhs->Output(*this); - return *this; - } - - _finline CYOutput &operator <<(const CYThing &rhs) { - rhs.Output(*this); - return *this; - } -}; - -struct CYPropertyName { - virtual void PropertyName(CYOutput &out) const = 0; -}; - -struct CYExpression; -struct CYAssignment; - -enum CYNeeded { - CYNever = -1, - CYSometimes = 0, - CYAlways = 1, -}; - -enum CYFlags { - CYNoFlags = 0, - CYNoBrace = (1 << 0), - CYNoFunction = (1 << 1), - CYNoIn = (1 << 2), - CYNoCall = (1 << 3), - CYNoRightHand = (1 << 4), - CYNoDangle = (1 << 5), - CYNoInteger = (1 << 6), - CYNoBF = (CYNoBrace | CYNoFunction), -}; - -_finline CYFlags operator ~(CYFlags rhs) { - return static_cast(~static_cast(rhs)); -} - -_finline CYFlags operator &(CYFlags lhs, CYFlags rhs) { - return static_cast(static_cast(lhs) & static_cast(rhs)); -} - -_finline CYFlags operator |(CYFlags lhs, CYFlags rhs) { - return static_cast(static_cast(lhs) | static_cast(rhs)); -} - -_finline CYFlags &operator |=(CYFlags &lhs, CYFlags rhs) { - return lhs = lhs | rhs; -} - -_finline CYFlags CYLeft(CYFlags flags) { - return flags & ~(CYNoDangle | CYNoInteger); -} - -_finline CYFlags CYRight(CYFlags flags) { - return flags & ~CYNoBF; -} - -_finline CYFlags CYCenter(CYFlags flags) { - return CYLeft(CYRight(flags)); -} - -enum CYCompactType { - CYCompactNone, - CYCompactLong, - CYCompactShort, -}; - -#define CYCompact(type) \ - virtual CYCompactType Compact() const { \ - return CYCompact ## type; \ - } - -struct CYStatement : - CYNext, - CYThing -{ - void Single(CYOutput &out, CYFlags flags, CYCompactType request) const; - void Multiple(CYOutput &out, CYFlags flags = CYNoFlags) const; - virtual void Output(CYOutput &out) const; - - virtual CYStatement *Replace(CYContext &context) = 0; - - virtual CYCompactType Compact() const = 0; - virtual CYStatement *Return(); - - private: - virtual void Output(CYOutput &out, CYFlags flags) const = 0; -}; - -struct CYStatements { - CYStatement *first_; - CYStatement *last_; - - CYStatements() : - first_(NULL), - last_(NULL) - { - } - - operator CYStatement *() const { - return first_; - } - - CYStatements &operator ->*(CYStatement *next) { - if (next != NULL) - if (first_ == NULL) { - first_ = next; - last_ = next; - } else for (;; last_ = last_->next_) - if (last_->next_ == NULL) { - last_->next_ = next; - last_ = next; - break; - } - return *this; - } -}; - -struct CYClassName { - virtual CYExpression *ClassName(CYContext &context, bool object) = 0; - virtual void ClassName(CYOutput &out, bool object) const = 0; -}; - -struct CYWord : - CYThing, - CYPropertyName, - CYClassName -{ - const char *word_; - - CYWord(const char *word) : - word_(word) - { - } - - void Set(const char *value) { - word_ = value; - } - - virtual const char *Word() const; - virtual void Output(CYOutput &out) const; - - virtual CYExpression *ClassName(CYContext &context, bool object); - virtual void ClassName(CYOutput &out, bool object) const; - virtual void PropertyName(CYOutput &out) const; -}; - -_finline std::ostream &operator <<(std::ostream &lhs, const CYWord &rhs) { - lhs << &rhs << '='; - return lhs << rhs.Word(); -} - -struct CYIdentifier : - CYNext, - CYWord -{ - CYIdentifier *replace_; - size_t offset_; - size_t usage_; - - CYIdentifier(const char *word) : - CYWord(word), - replace_(NULL), - offset_(0), - usage_(0) - { - } - - virtual const char *Word() const; - CYIdentifier *Replace(CYContext &context); -}; - -struct CYLabel : - CYStatement -{ - CYIdentifier *name_; - CYStatement *statement_; - - CYLabel(CYIdentifier *name, CYStatement *statement) : - name_(name), - statement_(statement) - { - } - - CYCompact(Short) - - virtual CYStatement *Replace(CYContext &context); - virtual void Output(CYOutput &out, CYFlags flags) const; -}; - -struct CYCStringLess : - std::binary_function -{ - _finline bool operator ()(const char *lhs, const char *rhs) const { - return strcmp(lhs, rhs) < 0; - } -}; - -struct CYIdentifierValueLess : - std::binary_function -{ - _finline bool operator ()(CYIdentifier *lhs, CYIdentifier *rhs) const { - return CYCStringLess()(lhs->Word(), rhs->Word()); - } -}; - -enum CYIdentifierFlags { - CYIdentifierArgument, - CYIdentifierVariable, - CYIdentifierOther, - CYIdentifierMagic, - CYIdentifierCatch, -}; - -typedef std::set CYCStringSet; -typedef std::set CYIdentifierValueSet; -typedef std::map CYIdentifierAddressFlagsMap; - -struct CYIdentifierUsage { - CYIdentifier *identifier_; - size_t usage_; -}; - -typedef std::vector CYIdentifierUsageVector; - -struct CYScope { - bool transparent_; - CYScope *parent_; - - CYIdentifierAddressFlagsMap internal_; - CYIdentifierValueSet identifiers_; - - CYScope(bool transparent, CYContext &context); - - void Declare(CYContext &context, CYIdentifier *identifier, CYIdentifierFlags flags); - virtual CYIdentifier *Lookup(CYContext &context, CYIdentifier *identifier); - void Merge(CYContext &context, CYIdentifier *identifier); - void Close(CYContext &context, CYStatement *&statements); -}; - -struct CYScript : - CYThing -{ - CYStatement *code_; - - CYScript(CYStatement *code) : - code_(code) - { - } - - virtual void Replace(CYContext &context); - virtual void Output(CYOutput &out) const; -}; - -struct CYNonLocal; -struct CYThisScope; - -struct CYContext { - CYOptions &options_; - - CYScope *scope_; - CYThisScope *this_; - - CYIdentifierUsageVector rename_; - - CYNonLocal *nonlocal_; - CYNonLocal *nextlocal_; - unsigned unique_; - - CYContext(CYOptions &options) : - options_(options), - scope_(NULL), - this_(NULL), - nonlocal_(NULL), - nextlocal_(NULL), - unique_(0) - { - } - - void ReplaceAll(CYStatement *&statement) { - if (statement == NULL) - return; - CYStatement *next(statement->next_); - - Replace(statement); - ReplaceAll(next); - - if (statement == NULL) - statement = next; - else - statement->SetNext(next); - } - - template - void Replace(Type_ *&value) { - for (;;) if (value == NULL) - break; - else { - Type_ *replace(value->Replace(*this)); - if (replace != value) - value = replace; - else break; - } - } - - void NonLocal(CYStatement *&statements); - CYIdentifier *Unique(); -}; - -struct CYNonLocal { - CYIdentifier *identifier_; - - CYNonLocal() : - identifier_(NULL) - { - } - - CYIdentifier *Target(CYContext &context) { - if (identifier_ == NULL) - identifier_ = context.Unique(); - return identifier_; - } -}; - -struct CYThisScope : - CYNext -{ - CYIdentifier *identifier_; - - CYThisScope() : - identifier_(NULL) - { - } - - CYIdentifier *Identifier(CYContext &context) { - if (next_ != NULL) - return next_->Identifier(context); - if (identifier_ == NULL) - identifier_ = context.Unique(); - return identifier_; - } -}; - -struct CYBlock : - CYStatement -{ - CYStatement *code_; - - CYBlock(CYStatement *code) : - code_(code) - { - } - - CYCompact(Short) - - virtual CYStatement *Replace(CYContext &context); - - virtual void Output(CYOutput &out, CYFlags flags) const; - - virtual CYStatement *Return(); -}; - -struct CYForInitializer { - virtual CYExpression *Replace(CYContext &context) = 0; - virtual void Output(CYOutput &out, CYFlags flags) const = 0; -}; - -struct CYForInInitializer { - virtual void ForIn(CYOutput &out, CYFlags flags) const = 0; - virtual CYStatement *ForEachIn(CYContext &out, CYExpression *value) = 0; - - virtual CYExpression *Replace(CYContext &context) = 0; - virtual CYAssignment *Assignment(CYContext &context) = 0; - - virtual void Output(CYOutput &out, CYFlags flags) const = 0; -}; - -struct CYFunctionParameter; - -struct CYNumber; -struct CYString; - -struct CYExpression : - CYForInitializer, - CYForInInitializer, - CYClassName, - CYThing -{ - virtual int Precedence() const = 0; - - virtual bool RightHand() const { - return true; - } - - virtual void ForIn(CYOutput &out, CYFlags flags) const; - virtual CYStatement *ForEachIn(CYContext &out, CYExpression *value); - - virtual CYExpression *AddArgument(CYContext &context, CYExpression *value); - - virtual void Output(CYOutput &out) const; - virtual void Output(CYOutput &out, CYFlags flags) const = 0; - void Output(CYOutput &out, int precedence, CYFlags flags) const; - - virtual CYExpression *ClassName(CYContext &context, bool object); - virtual void ClassName(CYOutput &out, bool object) const; - - virtual CYExpression *Replace(CYContext &context) = 0; - virtual CYAssignment *Assignment(CYContext &context); - - virtual CYExpression *Primitive(CYContext &context) { - return NULL; - } - - virtual CYFunctionParameter *Parameter() const; - - virtual CYNumber *Number(CYContext &context) { - return NULL; - } - - virtual CYString *String(CYContext &context) { - return NULL; - } - - virtual const char *Word() const { - return NULL; - } -}; - -#define CYAlphabetic(value) \ - virtual bool Alphabetic() const { \ - return value; \ - } - -#define CYPrecedence(value) \ - static const int Precedence_ = value; \ - virtual int Precedence() const { \ - return Precedence_; \ - } - -#define CYRightHand(value) \ - virtual bool RightHand() const { \ - return value; \ - } - -struct CYCompound : - CYExpression -{ - CYExpression *expression_; - CYExpression *next_; - - CYCompound(CYExpression *expression, CYExpression *next) : - expression_(expression), - next_(next) - { - _assert(expression_ != NULL); - _assert(next != NULL); - } - - CYPrecedence(17) - - virtual CYExpression *Replace(CYContext &context); - void Output(CYOutput &out, CYFlags flags) const; - - virtual CYFunctionParameter *Parameter() const; -}; - -struct CYParenthetical : - CYExpression -{ - CYExpression *expression_; - - CYParenthetical(CYExpression *expression) : - expression_(expression) - { - } - - CYPrecedence(0) - - virtual CYExpression *Replace(CYContext &context); - void Output(CYOutput &out, CYFlags flags) const; -}; - -struct CYDeclaration; - -struct CYFunctionParameter : - CYNext, - CYThing -{ - CYForInInitializer *initialiser_; - - CYFunctionParameter(CYForInInitializer *initialiser, CYFunctionParameter *next = NULL) : - CYNext(next), - initialiser_(initialiser) - { - } - - void Replace(CYContext &context, CYStatement *&statements); - void Output(CYOutput &out) const; -}; - -struct CYComprehension : - CYNext, - CYThing -{ - CYComprehension(CYComprehension *next = NULL) : - CYNext(next) - { - } - - CYComprehension *Modify(CYComprehension *next) { - next_ = next; - return this; - } - - virtual const char *Name() const = 0; - - virtual CYFunctionParameter *Parameter(CYContext &context) const = 0; - CYFunctionParameter *Parameters(CYContext &context) const; - virtual CYStatement *Replace(CYContext &context, CYStatement *statement) const; - virtual void Output(CYOutput &out) const = 0; -}; - -struct CYForInComprehension : - CYComprehension -{ - CYIdentifier *name_; - CYExpression *set_; - - CYForInComprehension(CYIdentifier *name, CYExpression *set, CYComprehension *next = NULL) : - CYComprehension(next), - name_(name), - set_(set) - { - } - - virtual const char *Name() const { - return name_->Word(); - } - - virtual CYFunctionParameter *Parameter(CYContext &context) const; - virtual CYStatement *Replace(CYContext &context, CYStatement *statement) const; - virtual void Output(CYOutput &out) const; -}; - -struct CYForOfComprehension : - CYComprehension -{ - CYIdentifier *name_; - CYExpression *set_; - - CYForOfComprehension(CYIdentifier *name, CYExpression *set, CYComprehension *next = NULL) : - CYComprehension(next), - name_(name), - set_(set) - { - } - - virtual const char *Name() const { - return name_->Word(); - } - - virtual CYFunctionParameter *Parameter(CYContext &context) const; - virtual CYStatement *Replace(CYContext &context, CYStatement *statement) const; - virtual void Output(CYOutput &out) const; -}; - -struct CYIfComprehension : - CYComprehension -{ - CYExpression *test_; - - CYIfComprehension(CYExpression *test, CYComprehension *next = NULL) : - CYComprehension(next), - test_(test) - { - } - - virtual const char *Name() const { - return NULL; - } - - virtual CYFunctionParameter *Parameter(CYContext &context) const; - virtual CYStatement *Replace(CYContext &context, CYStatement *statement) const; - virtual void Output(CYOutput &out) const; -}; - -struct CYArrayComprehension : - CYExpression -{ - CYExpression *expression_; - CYComprehension *comprehensions_; - - CYArrayComprehension(CYExpression *expression, CYComprehension *comprehensions) : - expression_(expression), - comprehensions_(comprehensions) - { - } - - CYPrecedence(0) - - virtual CYExpression *Replace(CYContext &context); - virtual void Output(CYOutput &out, CYFlags flags) const; -}; - -struct CYLiteral : - CYExpression -{ - CYPrecedence(0) - CYRightHand(false) - - virtual CYExpression *Primitive(CYContext &context) { - return this; - } -}; - -struct CYTrivial : - CYLiteral -{ - virtual CYExpression *Replace(CYContext &context); -}; - -struct CYMagic : - CYExpression -{ - CYPrecedence(0) - CYRightHand(false) -}; - -struct CYRange { - uint64_t lo_; - uint64_t hi_; - - CYRange(uint64_t lo, uint64_t hi) : - lo_(lo), hi_(hi) - { - } - - bool operator [](uint8_t value) const { - return !(value >> 7) && (value >> 6 ? hi_ : lo_) >> (value & 0x3f) & 0x1; - } - - void operator()(uint8_t value) { - if (value >> 7) - return; - (value >> 6 ? hi_ : lo_) |= uint64_t(0x1) << (value & 0x3f); - } -}; - -extern CYRange DigitRange_; -extern CYRange WordStartRange_; -extern CYRange WordEndRange_; - -struct CYString : - CYTrivial, - CYPropertyName -{ - const char *value_; - size_t size_; - - CYString() : - value_(NULL), - size_(0) - { - } - - CYString(const char *value) : - value_(value), - size_(strlen(value)) - { - } - - CYString(const char *value, size_t size) : - value_(value), - size_(size) - { - } - - CYString(const CYWord *word) : - value_(word->Word()), - size_(strlen(value_)) - { - } - - const char *Value() const { - return value_; - } - - virtual const char *Word() const; - - virtual CYNumber *Number(CYContext &context); - virtual CYString *String(CYContext &context); - - CYString *Concat(CYContext &out, CYString *rhs) const; - virtual void Output(CYOutput &out, CYFlags flags) const; - virtual void PropertyName(CYOutput &out) const; -}; - -struct CYElementValue; - -struct CYSpan : - CYNext -{ - CYExpression *expression_; - CYString *string_; - - CYSpan(CYExpression *expression, CYString *string, CYSpan *next) : - CYNext(next), - expression_(expression), - string_(string) - { - } - - CYElementValue *Replace(CYContext &context); -}; - -struct CYTemplate : - CYExpression -{ - CYString *string_; - CYSpan *spans_; - - CYTemplate(CYString *string, CYSpan *spans) : - string_(string), - spans_(spans) - { - } - - CYPrecedence(0) - CYRightHand(false) - - virtual CYExpression *Replace(CYContext &context); - virtual void Output(CYOutput &out, CYFlags flags) const; -}; - -struct CYNumber : - CYTrivial, - CYPropertyName -{ - double value_; - - CYNumber(double value) : - value_(value) - { - } - - double Value() const { - return value_; - } - - virtual CYNumber *Number(CYContext &context); - virtual CYString *String(CYContext &context); - - virtual void Output(CYOutput &out, CYFlags flags) const; - virtual void PropertyName(CYOutput &out) const; -}; - -struct CYRegEx : - CYTrivial -{ - const char *value_; - size_t size_; - - CYRegEx(const char *value, size_t size) : - value_(value), - size_(size) - { - } - - const char *Value() const { - return value_; - } - - virtual void Output(CYOutput &out, CYFlags flags) const; -}; - -struct CYNull : - CYTrivial -{ - virtual CYNumber *Number(CYContext &context); - virtual CYString *String(CYContext &context); - - virtual void Output(CYOutput &out, CYFlags flags) const; -}; - -struct CYThis : - CYMagic -{ - virtual CYExpression *Replace(CYContext &context); - virtual void Output(CYOutput &out, CYFlags flags) const; -}; - -struct CYBoolean : - CYTrivial -{ - virtual bool Value() const = 0; - virtual void Output(CYOutput &out, CYFlags flags) const; -}; - -struct CYFalse : - CYBoolean -{ - virtual bool Value() const { - return false; - } - - virtual CYNumber *Number(CYContext &context); - virtual CYString *String(CYContext &context); -}; - -struct CYTrue : - CYBoolean -{ - virtual bool Value() const { - return true; - } - - virtual CYNumber *Number(CYContext &context); - virtual CYString *String(CYContext &context); -}; - -struct CYVariable : - CYExpression -{ - CYIdentifier *name_; - - CYVariable(CYIdentifier *name) : - name_(name) - { - } - - CYVariable(const char *name) : - name_(new($pool) CYIdentifier(name)) - { - } - - CYPrecedence(0) - CYRightHand(false) - - virtual CYExpression *Replace(CYContext &context); - virtual void Output(CYOutput &out, CYFlags flags) const; - - virtual CYFunctionParameter *Parameter() const; -}; - -struct CYPrefix : - CYExpression -{ - CYExpression *rhs_; - - CYPrefix(CYExpression *rhs) : - rhs_(rhs) - { - } - - virtual bool Alphabetic() const = 0; - virtual const char *Operator() const = 0; - - CYPrecedence(4) - - virtual CYExpression *Replace(CYContext &context); - virtual void Output(CYOutput &out, CYFlags flags) const; -}; - -struct CYInfix : - CYExpression -{ - CYExpression *lhs_; - CYExpression *rhs_; - - CYInfix(CYExpression *lhs, CYExpression *rhs) : - lhs_(lhs), - rhs_(rhs) - { - } - - void SetLeft(CYExpression *lhs) { - lhs_ = lhs; - } - - virtual bool Alphabetic() const = 0; - virtual const char *Operator() const = 0; - - virtual CYExpression *Replace(CYContext &context); - virtual void Output(CYOutput &out, CYFlags flags) const; -}; - -struct CYPostfix : - CYExpression -{ - CYExpression *lhs_; - - CYPostfix(CYExpression *lhs) : - lhs_(lhs) - { - } - - virtual const char *Operator() const = 0; - - CYPrecedence(3) - - virtual CYExpression *Replace(CYContext &context); - virtual void Output(CYOutput &out, CYFlags flags) const; -}; - -struct CYAssignment : - CYExpression -{ - CYExpression *lhs_; - CYExpression *rhs_; - - CYAssignment(CYExpression *lhs, CYExpression *rhs) : - lhs_(lhs), - rhs_(rhs) - { - } - - void SetLeft(CYExpression *lhs) { - lhs_ = lhs; - } - - virtual const char *Operator() const = 0; - - CYPrecedence(16) - - virtual CYExpression *Replace(CYContext &context); - virtual void Output(CYOutput &out, CYFlags flags) const; -}; - -struct CYArgument : - CYNext, - CYThing -{ - CYWord *name_; - CYExpression *value_; - - CYArgument(CYExpression *value, CYArgument *next = NULL) : - CYNext(next), - name_(NULL), - value_(value) - { - } - - CYArgument(CYWord *name, CYExpression *value, CYArgument *next = NULL) : - CYNext(next), - name_(name), - value_(value) - { - } - - CYArgument *Replace(CYContext &context); - void Output(CYOutput &out) const; -}; - -struct CYClause : - CYThing, - CYNext -{ - CYExpression *case_; - CYStatement *code_; - - CYClause(CYExpression *_case, CYStatement *code) : - case_(_case), - code_(code) - { - } - - void Replace(CYContext &context); - virtual void Output(CYOutput &out) const; -}; - -struct CYElement : - CYThing -{ - virtual bool Elision() const = 0; - - virtual void Replace(CYContext &context) = 0; -}; - -struct CYElementValue : - CYNext, - CYElement -{ - CYExpression *value_; - - CYElementValue(CYExpression *value, CYElement *next) : - CYNext(next), - value_(value) - { - } - - virtual bool Elision() const { - return value_ == NULL; - } - - virtual void Replace(CYContext &context); - virtual void Output(CYOutput &out) const; -}; - -struct CYElementSpread : - CYElement -{ - CYExpression *value_; - - CYElementSpread(CYExpression *value) : - value_(value) - { - } - - virtual bool Elision() const { - return false; - } - - virtual void Replace(CYContext &context); - virtual void Output(CYOutput &out) const; -}; - -struct CYArray : - CYLiteral -{ - CYElement *elements_; - - CYArray(CYElement *elements = NULL) : - elements_(elements) - { - } - - virtual CYExpression *Replace(CYContext &context); - virtual void Output(CYOutput &out, CYFlags flags) const; -}; - -struct CYProperty : - CYNext, - CYThing -{ - CYPropertyName *name_; - CYExpression *value_; - - CYProperty(CYPropertyName *name, CYExpression *value, CYProperty *next = NULL) : - CYNext(next), - name_(name), - value_(value) - { - } - - void Replace(CYContext &context); - virtual void Output(CYOutput &out) const; -}; - -struct CYDeclaration : - CYForInInitializer -{ - CYIdentifier *identifier_; - CYExpression *initialiser_; - - CYDeclaration(CYIdentifier *identifier, CYExpression *initialiser = NULL) : - identifier_(identifier), - initialiser_(initialiser) - { - } - - virtual void ForIn(CYOutput &out, CYFlags flags) const; - virtual CYStatement *ForEachIn(CYContext &out, CYExpression *value); - - virtual CYExpression *Replace(CYContext &context); - - virtual CYAssignment *Assignment(CYContext &context); - CYVariable *Variable(CYContext &context); - - virtual void Output(CYOutput &out, CYFlags flags) const; -}; - -struct CYDeclarations : - CYNext, - CYThing -{ - CYDeclaration *declaration_; - - CYDeclarations(CYDeclaration *declaration, CYDeclarations *next = NULL) : - CYNext(next), - declaration_(declaration) - { - } - - void Replace(CYContext &context); - - CYExpression *Expression(CYContext &context); - CYProperty *Property(CYContext &context); - CYArgument *Argument(CYContext &context); - CYFunctionParameter *Parameter(CYContext &context); - - virtual void Output(CYOutput &out) const; - virtual void Output(CYOutput &out, CYFlags flags) const; -}; - -struct CYForDeclarations : - CYForInitializer -{ - CYDeclarations *declarations_; - - CYForDeclarations(CYDeclarations *declarations) : - declarations_(declarations) - { - } - - virtual CYExpression *Replace(CYContext &context); - virtual void Output(CYOutput &out, CYFlags flags) const; -}; - -struct CYVar : - CYStatement -{ - CYDeclarations *declarations_; - - CYVar(CYDeclarations *declarations) : - declarations_(declarations) - { - } - - CYCompact(None) - - virtual CYStatement *Replace(CYContext &context); - virtual void Output(CYOutput &out, CYFlags flags) const; -}; - -struct CYLetStatement : - CYStatement -{ - CYDeclarations *declarations_; - CYStatement *code_; - - CYLetStatement(CYDeclarations *declarations, CYStatement *code) : - declarations_(declarations), - code_(code) - { - } - - CYCompact(Long) - - virtual CYStatement *Replace(CYContext &context); - virtual void Output(CYOutput &out, CYFlags flags) const; -}; - -struct CYFor : - CYStatement -{ - CYForInitializer *initialiser_; - CYExpression *test_; - CYExpression *increment_; - CYStatement *code_; - - CYFor(CYForInitializer *initialiser, CYExpression *test, CYExpression *increment, CYStatement *code) : - initialiser_(initialiser), - test_(test), - increment_(increment), - code_(code) - { - } - - CYCompact(Long) - - virtual CYStatement *Replace(CYContext &context); - virtual void Output(CYOutput &out, CYFlags flags) const; -}; - -struct CYForIn : - CYStatement -{ - CYForInInitializer *initialiser_; - CYExpression *set_; - CYStatement *code_; - - CYForIn(CYForInInitializer *initialiser, CYExpression *set, CYStatement *code) : - initialiser_(initialiser), - set_(set), - code_(code) - { - } - - CYCompact(Long) - - virtual CYStatement *Replace(CYContext &context); - virtual void Output(CYOutput &out, CYFlags flags) const; -}; - -struct CYForOf : - CYStatement -{ - CYForInInitializer *initialiser_; - CYExpression *set_; - CYStatement *code_; - - CYForOf(CYForInInitializer *initialiser, CYExpression *set, CYStatement *code) : - initialiser_(initialiser), - set_(set), - code_(code) - { - } - - CYCompact(Long) - - virtual CYStatement *Replace(CYContext &context); - virtual void Output(CYOutput &out, CYFlags flags) const; -}; - -struct CYObject : - CYLiteral -{ - CYProperty *properties_; - - CYObject(CYProperty *properties = NULL) : - properties_(properties) - { - } - - virtual CYExpression *Replace(CYContext &context); - void Output(CYOutput &out, CYFlags flags) const; -}; - -struct CYMember : - CYExpression -{ - CYExpression *object_; - CYExpression *property_; - - CYMember(CYExpression *object, CYExpression *property) : - object_(object), - property_(property) - { - } - - void SetLeft(CYExpression *object) { - object_ = object; - } -}; - -struct CYDirectMember : - CYMember -{ - CYDirectMember(CYExpression *object, CYExpression *property) : - CYMember(object, property) - { - } - - CYPrecedence(1) - CYRightHand(false) - - virtual CYExpression *Replace(CYContext &context); - virtual void Output(CYOutput &out, CYFlags flags) const; -}; - -struct CYIndirectMember : - CYMember -{ - CYIndirectMember(CYExpression *object, CYExpression *property) : - CYMember(object, property) - { - } - - CYPrecedence(1) - CYRightHand(false) - - virtual CYExpression *Replace(CYContext &context); - virtual void Output(CYOutput &out, CYFlags flags) const; -}; - -namespace cy { -namespace Syntax { - -struct New : - CYExpression -{ - CYExpression *constructor_; - CYArgument *arguments_; - - New(CYExpression *constructor, CYArgument *arguments) : - constructor_(constructor), - arguments_(arguments) - { - } - - virtual int Precedence() const { - return arguments_ == NULL ? 2 : 1; - } - - CYRightHand(false) - - virtual CYExpression *Replace(CYContext &context); - virtual void Output(CYOutput &out, CYFlags flags) const; - - virtual CYExpression *AddArgument(CYContext &context, CYExpression *value); -}; - -} } - -struct CYCall : - CYExpression -{ - CYExpression *function_; - CYArgument *arguments_; - - CYCall(CYExpression *function, CYArgument *arguments = NULL) : - function_(function), - arguments_(arguments) - { - } - - CYPrecedence(1) - CYRightHand(false) - - virtual CYExpression *Replace(CYContext &context); - virtual void Output(CYOutput &out, CYFlags flags) const; - - virtual CYExpression *AddArgument(CYContext &context, CYExpression *value); -}; - -struct CYRubyProc; - -struct CYRubyBlock : - CYExpression -{ - CYExpression *call_; - CYRubyProc *proc_; - - CYRubyBlock(CYExpression *call, CYRubyProc *proc) : - call_(call), - proc_(proc) - { - } - - CYPrecedence(1) - CYRightHand(false) - - virtual CYExpression *Replace(CYContext &context); - virtual void Output(CYOutput &out, CYFlags flags) const; -}; - -struct CYIf : - CYStatement -{ - CYExpression *test_; - CYStatement *true_; - CYStatement *false_; - - CYIf(CYExpression *test, CYStatement *_true, CYStatement *_false = NULL) : - test_(test), - true_(_true), - false_(_false) - { - } - - CYCompact(Long) - - virtual CYStatement *Replace(CYContext &context); - virtual void Output(CYOutput &out, CYFlags flags) const; - - virtual CYStatement *Return(); -}; - -struct CYDoWhile : - CYStatement -{ - CYExpression *test_; - CYStatement *code_; - - CYDoWhile(CYExpression *test, CYStatement *code) : - test_(test), - code_(code) - { - } - - CYCompact(None) - - virtual CYStatement *Replace(CYContext &context); - virtual void Output(CYOutput &out, CYFlags flags) const; -}; - -struct CYWhile : - CYStatement -{ - CYExpression *test_; - CYStatement *code_; - - CYWhile(CYExpression *test, CYStatement *code) : - test_(test), - code_(code) - { - } - - CYCompact(Long) - - virtual CYStatement *Replace(CYContext &context); - virtual void Output(CYOutput &out, CYFlags flags) const; -}; - -// XXX: this should be split up into CYAnonymousFunction and CYNamedFunction (subclass) -struct CYFunction { - CYIdentifier *name_; - CYFunctionParameter *parameters_; - CYStatement *code_; - - CYNonLocal *nonlocal_; - bool implicit_; - CYThisScope this_; - - CYFunction(CYIdentifier *name, CYFunctionParameter *parameters, CYStatement *code) : - name_(name), - parameters_(parameters), - code_(code), - nonlocal_(NULL), - implicit_(false) - { - } - - void Inject(CYContext &context); - virtual void Replace_(CYContext &context, bool outer); - virtual void Output(CYOutput &out, CYFlags flags) const; -}; - -// XXX: this should be split up into CYAnonymousFunctionExpression and CYNamedFunctionExpression -struct CYFunctionExpression : - CYFunction, - CYExpression -{ - CYFunctionExpression(CYIdentifier *name, CYFunctionParameter *parameters, CYStatement *code) : - CYFunction(name, parameters, code) - { - } - - CYPrecedence(0) - CYRightHand(false) - - virtual CYExpression *Replace(CYContext &context); - virtual void Output(CYOutput &out, CYFlags flags) const; -}; - -// XXX: this should derive from CYAnonymousFunction -struct CYFatArrow : - CYFunction, - CYExpression -{ - CYFatArrow(CYFunctionParameter *parameters, CYStatement *code) : - CYFunction(NULL, parameters, code) - { - } - - CYPrecedence(0) - CYRightHand(false) - - virtual CYExpression *Replace(CYContext &context); - virtual void Output(CYOutput &out, CYFlags flags) const; -}; - -// XXX: this should derive from CYAnonymousFunctionExpression -struct CYRubyProc : - CYFunctionExpression -{ - CYRubyProc(CYFunctionParameter *parameters, CYStatement *code) : - CYFunctionExpression(NULL, parameters, code) - { - } - - virtual CYExpression *Replace(CYContext &context); - virtual void Output(CYOutput &out, CYFlags flags) const; -}; - -// XXX: this should derive from CYNamedFunction -struct CYFunctionStatement : - CYFunction, - CYStatement -{ - CYFunctionStatement(CYIdentifier *name, CYFunctionParameter *parameters, CYStatement *code) : - CYFunction(name, parameters, code) - { - } - - CYCompact(None) - - virtual CYStatement *Replace(CYContext &context); - virtual void Output(CYOutput &out, CYFlags flags) const; -}; - -struct CYExpress : - CYStatement -{ - CYExpression *expression_; - - CYExpress(CYExpression *expression) : - expression_(expression) - { - if (expression_ == NULL) - throw; - } - - CYCompact(None) - - virtual CYStatement *Replace(CYContext &context); - virtual void Output(CYOutput &out, CYFlags flags) const; - - virtual CYStatement *Return(); -}; - -struct CYContinue : - CYStatement -{ - CYIdentifier *label_; - - CYContinue(CYIdentifier *label) : - label_(label) - { - } - - CYCompact(Short) - - virtual CYStatement *Replace(CYContext &context); - virtual void Output(CYOutput &out, CYFlags flags) const; -}; - -struct CYBreak : - CYStatement -{ - CYIdentifier *label_; - - CYBreak(CYIdentifier *label) : - label_(label) - { - } - - CYCompact(Short) - - virtual CYStatement *Replace(CYContext &context); - virtual void Output(CYOutput &out, CYFlags flags) const; -}; - -struct CYReturn : - CYStatement -{ - CYExpression *value_; - - CYReturn(CYExpression *value) : - value_(value) - { - } - - CYCompact(None) - - virtual CYStatement *Replace(CYContext &context); - virtual void Output(CYOutput &out, CYFlags flags) const; -}; - -struct CYYieldGenerator : - CYExpression -{ - CYExpression *value_; - - CYYieldGenerator(CYExpression *value) : - value_(value) - { - } - - CYPrecedence(0) - - virtual CYExpression *Replace(CYContext &context); - virtual void Output(CYOutput &out, CYFlags flags) const; -}; - -struct CYYieldValue : - CYExpression -{ - CYExpression *value_; - - CYYieldValue(CYExpression *value) : - value_(value) - { - } - - CYPrecedence(0) - - virtual CYExpression *Replace(CYContext &context); - virtual void Output(CYOutput &out, CYFlags flags) const; -}; - -struct CYEmpty : - CYStatement -{ - CYCompact(Short) - - virtual CYStatement *Replace(CYContext &context); - virtual void Output(CYOutput &out, CYFlags flags) const; -}; - -struct CYFinally : - CYThing -{ - CYStatement *code_; - - CYFinally(CYStatement *code) : - code_(code) - { - } - - void Replace(CYContext &context); - virtual void Output(CYOutput &out) const; -}; - -struct CYTypeSpecifier : - CYThing -{ - virtual CYExpression *Replace(CYContext &context) = 0; -}; - -struct CYTypeError : - CYTypeSpecifier -{ - CYTypeError() { - } - - virtual CYExpression *Replace(CYContext &context); - virtual void Output(CYOutput &out) const; -}; - -struct CYTypeVoid : - CYTypeSpecifier -{ - CYTypeVoid() { - } - - virtual CYExpression *Replace(CYContext &context); - virtual void Output(CYOutput &out) const; -}; - -struct CYTypeVariable : - CYTypeSpecifier -{ - CYIdentifier *name_; - - CYTypeVariable(CYIdentifier *name) : - name_(name) - { - } - - CYTypeVariable(const char *name) : - name_(new($pool) CYIdentifier(name)) - { - } - - virtual CYExpression *Replace(CYContext &context); - virtual void Output(CYOutput &out) const; -}; - -struct CYTypeUnsigned : - CYTypeSpecifier -{ - CYTypeSpecifier *specifier_; - - CYTypeUnsigned(CYTypeSpecifier *specifier) : - specifier_(specifier) - { - } - - virtual CYExpression *Replace(CYContext &context); - virtual void Output(CYOutput &out) const; -}; - -struct CYTypeSigned : - CYTypeSpecifier -{ - CYTypeSpecifier *specifier_; - - CYTypeSigned(CYTypeSpecifier *specifier) : - specifier_(specifier) - { - } - - virtual CYExpression *Replace(CYContext &context); - virtual void Output(CYOutput &out) const; -}; - -struct CYTypeLong : - CYTypeSpecifier -{ - CYTypeSpecifier *specifier_; - - CYTypeLong(CYTypeSpecifier *specifier) : - specifier_(specifier) - { - } - - virtual CYExpression *Replace(CYContext &context); - virtual void Output(CYOutput &out) const; -}; - -struct CYTypeShort : - CYTypeSpecifier -{ - CYTypeSpecifier *specifier_; - - CYTypeShort(CYTypeSpecifier *specifier) : - specifier_(specifier) - { - } - - virtual CYExpression *Replace(CYContext &context); - virtual void Output(CYOutput &out) const; -}; - -struct CYTypeFunctionWith; - -struct CYTypeModifier : - CYNext -{ - CYTypeModifier(CYTypeModifier *next) : - CYNext(next) - { - } - - virtual int Precedence() const = 0; - - virtual CYExpression *Replace_(CYContext &context, CYExpression *type) = 0; - CYExpression *Replace(CYContext &context, CYExpression *type); - - virtual void Output(CYOutput &out, CYIdentifier *identifier) const = 0; - void Output(CYOutput &out, int precedence, CYIdentifier *identifier) const; - - virtual CYTypeFunctionWith *Function() { return NULL; } -}; - -struct CYTypeArrayOf : - CYTypeModifier -{ - CYExpression *size_; - - CYTypeArrayOf(CYExpression *size, CYTypeModifier *next = NULL) : - CYTypeModifier(next), - size_(size) - { - } - - CYPrecedence(1) - - virtual CYExpression *Replace_(CYContext &context, CYExpression *type); - virtual void Output(CYOutput &out, CYIdentifier *identifier) const; -}; - -struct CYTypeConstant : - CYTypeModifier -{ - CYTypeConstant(CYTypeModifier *next = NULL) : - CYTypeModifier(next) - { - } - - CYPrecedence(0) - - virtual CYExpression *Replace_(CYContext &context, CYExpression *type); - virtual void Output(CYOutput &out, CYIdentifier *identifier) const; -}; - -struct CYTypePointerTo : - CYTypeModifier -{ - CYTypePointerTo(CYTypeModifier *next = NULL) : - CYTypeModifier(next) - { - } - - CYPrecedence(0) - - virtual CYExpression *Replace_(CYContext &context, CYExpression *type); - virtual void Output(CYOutput &out, CYIdentifier *identifier) const; -}; - -struct CYTypeVolatile : - CYTypeModifier -{ - CYTypeVolatile(CYTypeModifier *next = NULL) : - CYTypeModifier(next) - { - } - - CYPrecedence(0) - - virtual CYExpression *Replace_(CYContext &context, CYExpression *type); - virtual void Output(CYOutput &out, CYIdentifier *identifier) const; -}; - -struct CYTypedIdentifier : - CYNext, - CYThing -{ - CYLocation location_; - CYIdentifier *identifier_; - CYTypeSpecifier *specifier_; - CYTypeModifier *modifier_; - - CYTypedIdentifier(const CYLocation &location, CYIdentifier *identifier = NULL) : - location_(location), - identifier_(identifier), - specifier_(NULL), - modifier_(NULL) - { - } - - CYTypedIdentifier(CYTypeSpecifier *specifier, CYTypeModifier *modifier = NULL) : - identifier_(NULL), - specifier_(specifier), - modifier_(modifier) - { - } - - inline CYTypedIdentifier *Modify(CYTypeModifier *modifier) { - CYSetLast(modifier_) = modifier; - return this; - } - - virtual CYExpression *Replace(CYContext &context); - virtual void Output(CYOutput &out) const; - - CYTypeFunctionWith *Function(); -}; - -struct CYEncodedType : - CYExpression -{ - CYTypedIdentifier *typed_; - - CYEncodedType(CYTypedIdentifier *typed) : - typed_(typed) - { - } - - CYPrecedence(1) - - virtual CYExpression *Replace(CYContext &context); - virtual void Output(CYOutput &out, CYFlags flags) const; -}; - -struct CYTypedParameter : - CYNext, - CYThing -{ - CYTypedIdentifier *typed_; - - CYTypedParameter(CYTypedIdentifier *typed, CYTypedParameter *next) : - CYNext(next), - typed_(typed) - { - } - - CYArgument *Argument(CYContext &context); - CYFunctionParameter *Parameters(CYContext &context); - CYExpression *TypeSignature(CYContext &context, CYExpression *prefix); - - virtual void Output(CYOutput &out) const; -}; - -struct CYLambda : - CYExpression -{ - CYTypedIdentifier *typed_; - CYTypedParameter *parameters_; - CYStatement *code_; - - CYLambda(CYTypedIdentifier *typed, CYTypedParameter *parameters, CYStatement *code) : - typed_(typed), - parameters_(parameters), - code_(code) - { - } - - CYPrecedence(1) - - virtual CYExpression *Replace(CYContext &context); - virtual void Output(CYOutput &out, CYFlags flags) const; -}; - -struct CYModule : - CYNext, - CYThing -{ - CYWord *part_; - - CYModule(CYWord *part, CYModule *next = NULL) : - CYNext(next), - part_(part) - { - } - - CYString *Replace(CYContext &context, const char *separator) const; - void Output(CYOutput &out) const; -}; - -struct CYImport : - CYStatement -{ - CYModule *module_; - - CYImport(CYModule *module) : - module_(module) - { - } - - CYCompact(None) - - virtual CYStatement *Replace(CYContext &context); - virtual void Output(CYOutput &out, CYFlags flags) const; -}; - -struct CYExternal : - CYStatement -{ - CYString *abi_; - CYTypedIdentifier *typed_; - - CYExternal(CYString *abi, CYTypedIdentifier *typed) : - abi_(abi), - typed_(typed) - { - } - - CYCompact(None) - - virtual CYStatement *Replace(CYContext &context); - virtual void Output(CYOutput &out, CYFlags flags) const; -}; - -struct CYTypeDefinition : - CYStatement -{ - CYTypedIdentifier *typed_; - - CYTypeDefinition(CYTypedIdentifier *typed) : - typed_(typed) - { - } - - CYCompact(None) - - virtual CYStatement *Replace(CYContext &context); - virtual void Output(CYOutput &out, CYFlags flags) const; -}; - -struct CYTypeBlockWith : - CYTypeModifier -{ - CYTypedParameter *parameters_; - - CYTypeBlockWith(CYTypedParameter *parameters, CYTypeModifier *next = NULL) : - CYTypeModifier(next), - parameters_(parameters) - { - } - - CYPrecedence(0) - - virtual CYExpression *Replace_(CYContext &context, CYExpression *type); - virtual void Output(CYOutput &out, CYIdentifier *identifier) const; -}; - -struct CYTypeFunctionWith : - CYTypeModifier -{ - CYTypedParameter *parameters_; - - CYTypeFunctionWith(CYTypedParameter *parameters, CYTypeModifier *next = NULL) : - CYTypeModifier(next), - parameters_(parameters) - { - } - - CYPrecedence(1) - - virtual CYExpression *Replace_(CYContext &context, CYExpression *type); - virtual void Output(CYOutput &out, CYIdentifier *identifier) const; - - virtual CYTypeFunctionWith *Function() { return this; } -}; - -namespace cy { -namespace Syntax { - -struct Catch : - CYThing -{ - CYIdentifier *name_; - CYStatement *code_; - - Catch(CYIdentifier *name, CYStatement *code) : - name_(name), - code_(code) - { - } - - void Replace(CYContext &context); - virtual void Output(CYOutput &out) const; -}; - -struct Try : - CYStatement -{ - CYStatement *code_; - Catch *catch_; - CYFinally *finally_; - - Try(CYStatement *code, Catch *_catch, CYFinally *finally) : - code_(code), - catch_(_catch), - finally_(finally) - { - } - - CYCompact(Short) - - virtual CYStatement *Replace(CYContext &context); - virtual void Output(CYOutput &out, CYFlags flags) const; -}; - -struct Throw : - CYStatement -{ - CYExpression *value_; - - Throw(CYExpression *value = NULL) : - value_(value) - { - } - - CYCompact(None) - - virtual CYStatement *Replace(CYContext &context); - virtual void Output(CYOutput &out, CYFlags flags) const; -}; - -} } - -struct CYWith : - CYStatement -{ - CYExpression *scope_; - CYStatement *code_; - - CYWith(CYExpression *scope, CYStatement *code) : - scope_(scope), - code_(code) - { - } - - CYCompact(Long) - - virtual CYStatement *Replace(CYContext &context); - virtual void Output(CYOutput &out, CYFlags flags) const; -}; - -struct CYSwitch : - CYStatement -{ - CYExpression *value_; - CYClause *clauses_; - - CYSwitch(CYExpression *value, CYClause *clauses) : - value_(value), - clauses_(clauses) - { - } - - CYCompact(Long) - - virtual CYStatement *Replace(CYContext &context); - virtual void Output(CYOutput &out, CYFlags flags) const; -}; - -struct CYDebugger : - CYStatement -{ - CYDebugger() - { - } - - CYCompact(None) - - virtual CYStatement *Replace(CYContext &context); - virtual void Output(CYOutput &out, CYFlags flags) const; -}; - -struct CYCondition : - CYExpression -{ - CYExpression *test_; - CYExpression *true_; - CYExpression *false_; - - CYCondition(CYExpression *test, CYExpression *_true, CYExpression *_false) : - test_(test), - true_(_true), - false_(_false) - { - } - - CYPrecedence(15) - - virtual CYExpression *Replace(CYContext &context); - virtual void Output(CYOutput &out, CYFlags flags) const; -}; - -struct CYAddressOf : - CYPrefix -{ - CYAddressOf(CYExpression *rhs) : - CYPrefix(rhs) - { - } - - virtual const char *Operator() const { - return "&"; - } - - CYAlphabetic(false) - - virtual CYExpression *Replace(CYContext &context); -}; - -struct CYIndirect : - CYPrefix -{ - CYIndirect(CYExpression *rhs) : - CYPrefix(rhs) - { - } - - virtual const char *Operator() const { - return "*"; - } - - CYAlphabetic(false) - - virtual CYExpression *Replace(CYContext &context); -}; - -#define CYReplace \ - virtual CYExpression *Replace(CYContext &context); - -#define CYPostfix_(op, name, args...) \ - struct CY ## name : \ - CYPostfix \ - { args \ - CY ## name(CYExpression *lhs) : \ - CYPostfix(lhs) \ - { \ - } \ - \ - virtual const char *Operator() const { \ - return op; \ - } \ - }; - -#define CYPrefix_(alphabetic, op, name, args...) \ - struct CY ## name : \ - CYPrefix \ - { args \ - CY ## name(CYExpression *rhs) : \ - CYPrefix(rhs) \ - { \ - } \ - \ - CYAlphabetic(alphabetic) \ - \ - virtual const char *Operator() const { \ - return op; \ - } \ - }; - -#define CYInfix_(alphabetic, precedence, op, name, args...) \ - struct CY ## name : \ - CYInfix \ - { args \ - CY ## name(CYExpression *lhs, CYExpression *rhs) : \ - CYInfix(lhs, rhs) \ - { \ - } \ - \ - CYAlphabetic(alphabetic) \ - CYPrecedence(precedence) \ - \ - virtual const char *Operator() const { \ - return op; \ - } \ - }; - -#define CYAssignment_(op, name, args...) \ - struct CY ## name ## Assign : \ - CYAssignment \ - { args \ - CY ## name ## Assign(CYExpression *lhs, CYExpression *rhs) : \ - CYAssignment(lhs, rhs) \ - { \ - } \ - \ - virtual const char *Operator() const { \ - return op; \ - } \ - }; - -CYPostfix_("++", PostIncrement) -CYPostfix_("--", PostDecrement) - -CYPrefix_(true, "delete", Delete) -CYPrefix_(true, "void", Void) -CYPrefix_(true, "typeof", TypeOf) -CYPrefix_(false, "++", PreIncrement) -CYPrefix_(false, "--", PreDecrement) -CYPrefix_(false, "+", Affirm) -CYPrefix_(false, "-", Negate) -CYPrefix_(false, "~", BitwiseNot) -CYPrefix_(false, "!", LogicalNot) - -CYInfix_(false, 5, "*", Multiply, CYReplace) -CYInfix_(false, 5, "/", Divide) -CYInfix_(false, 5, "%", Modulus) -CYInfix_(false, 6, "+", Add, CYReplace) -CYInfix_(false, 6, "-", Subtract) -CYInfix_(false, 7, "<<", ShiftLeft) -CYInfix_(false, 7, ">>", ShiftRightSigned) -CYInfix_(false, 7, ">>>", ShiftRightUnsigned) -CYInfix_(false, 8, "<", Less) -CYInfix_(false, 8, ">", Greater) -CYInfix_(false, 8, "<=", LessOrEqual) -CYInfix_(false, 8, ">=", GreaterOrEqual) -CYInfix_(true, 8, "instanceof", InstanceOf) -CYInfix_(true, 8, "in", In) -CYInfix_(false, 9, "==", Equal) -CYInfix_(false, 9, "!=", NotEqual) -CYInfix_(false, 9, "===", Identical) -CYInfix_(false, 9, "!==", NotIdentical) -CYInfix_(false, 10, "&", BitwiseAnd) -CYInfix_(false, 11, "^", BitwiseXOr) -CYInfix_(false, 12, "|", BitwiseOr) -CYInfix_(false, 13, "&&", LogicalAnd) -CYInfix_(false, 14, "||", LogicalOr) - -CYAssignment_("=", ) -CYAssignment_("*=", Multiply) -CYAssignment_("/=", Divide) -CYAssignment_("%=", Modulus) -CYAssignment_("+=", Add) -CYAssignment_("-=", Subtract) -CYAssignment_("<<=", ShiftLeft) -CYAssignment_(">>=", ShiftRightSigned) -CYAssignment_(">>>=", ShiftRightUnsigned) -CYAssignment_("&=", BitwiseAnd) -CYAssignment_("^=", BitwiseXOr) -CYAssignment_("|=", BitwiseOr) - -#endif/*CYCRIPT_PARSER_HPP*/ diff --git a/Parser.ypp.in b/Parser.ypp.in new file mode 100644 index 0000000..295fa81 --- /dev/null +++ b/Parser.ypp.in @@ -0,0 +1,2365 @@ +/* Cycript - Optimizing JavaScript Compiler/Runtime + * Copyright (C) 2009-2015 Jay Freeman (saurik) +*/ + +/* GNU Affero General Public License, Version 3 {{{ */ +/* + * This program is free software: you can redistribute it and/or modify + * it under the terms of the GNU Affero General Public License as published by + * the Free Software Foundation, either version 3 of the License, or + * (at your option) any later version. + + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU Affero General Public License for more details. + + * You should have received a copy of the GNU Affero General Public License + * along with this program. If not, see . +**/ +/* }}} */ + +%code top { +#define YYSTACKEXPANDABLE 1 +} + +%code requires { +#include "Driver.hpp" +#include "Parser.hpp" +#include "Stack.hpp" +#define CYNew new(driver.pool_) + +@begin ObjectiveC +#include "ObjectiveC/Syntax.hpp" +@end + +@begin E4X +#include "E4X/Syntax.hpp" +@end + +#include "Highlight.hpp" +} + +%union { bool bool_; } + +%union { CYArgument *argument_; } +%union { CYAssignment *assignment_; } +%union { CYBoolean *boolean_; } +%union { CYClause *clause_; } +%union { cy::Syntax::Catch *catch_; } +%union { CYComprehension *comprehension_; } +%union { CYDeclaration *declaration_; } +%union { CYDeclarations *declarations_; } +%union { CYElement *element_; } +%union { CYExpression *expression_; } +%union { CYFalse *false_; } +%union { CYVariable *variable_; } +%union { CYFinally *finally_; } +%union { CYForInitializer *for_; } +%union { CYForInInitializer *forin_; } +%union { CYFunctionParameter *functionParameter_; } +%union { CYIdentifier *identifier_; } +%union { CYInfix *infix_; } +%union { CYLiteral *literal_; } +%union { CYMember *member_; } +%union { CYModule *module_; } +%union { CYNull *null_; } +%union { CYNumber *number_; } +%union { CYParenthetical *parenthetical_; } +%union { CYProperty *property_; } +%union { CYPropertyName *propertyName_; } +%union { CYRubyProc *rubyProc_; } +%union { CYSpan *span_; } +%union { CYStatement *statement_; } +%union { CYString *string_; } +%union { CYThis *this_; } +%union { CYTrue *true_; } +%union { CYWord *word_; } + +@begin C +%union { CYTypeModifier *modifier_; } +%union { CYTypeSpecifier *specifier_; } +%union { CYTypedIdentifier *typedIdentifier_; } +%union { CYTypedParameter *typedParameter_; } +@end + +@begin ObjectiveC +%union { CYClassName *className_; } +%union { CYClassField *classField_; } +%union { CYMessage *message_; } +%union { CYMessageParameter *messageParameter_; } +%union { CYProtocol *protocol_; } +%union { CYSelectorPart *selector_; } +@end + +@begin E4X +%union { CYAttribute *attribute_; } +%union { CYPropertyIdentifier *propertyIdentifier_; } +%union { CYSelector *selector_; } +@end + +%code provides { + +struct YYSTYPE { + cy::parser::semantic_type semantic_; + hi::Value highlight_; +}; + +int cylex(YYSTYPE *, CYLocation *, void *); + +} + +%code { + +#undef yylex +_finline int yylex(cy::parser::semantic_type *semantic, CYLocation *location, CYDriver &driver) { + if (driver.mark_ == CYMarkIgnore); + else if (driver.mark_ == CYMarkScript) { + driver.mark_ = CYMarkIgnore; + return cy::parser::token::MarkScript; + } else if (driver.mark_ == CYMarkModule) { + driver.mark_ = CYMarkIgnore; + return cy::parser::token::MarkModule; + } + + YYSTYPE data; + int token(cylex(&data, location, driver.scanner_)); + *semantic = data.semantic_; + return token; +} + +#define CYMAP(to, from) do { \ + if (yyla.empty()) \ + yyla.type = yytranslate_(yylex(&yyla.value, &yyla.location, driver)); \ + if (yyla.type == yytranslate_(token::from)) \ + yyla.type = yytranslate_(token::to); \ +} while (false) + +#define CYERR(location, message) do { \ + error(location, message); \ + YYABORT; \ +} while (false) + +#define CYNOT(location) \ + CYERR(location, "unimplemented feature") + +} + +%name-prefix "cy" + +%language "C++" + +%initial-action { + @$.begin.filename = @$.end.filename = &driver.filename_; +}; + +%locations +%defines + +%define api.location.type { CYLocation } + +//%glr-parser +//%expect 1 + +%error-verbose + +%param { CYDriver &driver } + +/* Token Declarations {{{ */ +@begin E4X +%token XMLCDATA +%token XMLComment +%token XMLPI + +%token XMLAttributeValue +%token XMLName +%token XMLTagCharacters +%token XMLText +%token XMLWhitespace +@end + +@begin E4X +%token LeftRight "<>" +%token LeftSlashRight "" + +%token SlashRight "/>" +%token LeftSlash "" +%token EqualRight_ "\n=>" +%token Exclamation "!" +%token ExclamationEqual "!=" +%token ExclamationEqualEqual "!==" +%token Hyphen "-" +%token HyphenEqual "-=" +%token HyphenHyphen "--" +%token HyphenHyphen_ "\n--" +%token HyphenRight "->" +%token Left "<" +%token LeftEqual "<=" +%token LeftLeft "<<" +%token LeftLeftEqual "<<=" +%token Percent "%" +%token PercentEqual "%=" +%token Period "." +%token PeriodPeriodPeriod "..." +%token Pipe "|" +%token PipeEqual "|=" +%token PipePipe "||" +%token Plus "+" +%token PlusEqual "+=" +%token PlusPlus "++" +%token PlusPlus_ "\n++" +%token Right ">" +%token RightEqual ">=" +%token RightRight ">>" +%token RightRightEqual ">>=" +%token RightRightRight ">>>" +%token RightRightRightEqual ">>>=" +%token Slash "/" +%token SlashEqual "/=" +%token Star "*" +%token StarEqual "*=" +%token Tilde "~" + +%token Colon ":" +%token Comma "," +%token Question "?" +%token SemiColon ";" +%token NewLine "\n" + +%token Comment + +%token OpenParen "(" +%token CloseParen ")" + +%token OpenBrace "{" +%token OpenBrace_ "\n{" +%token OpenBrace__ ";{" +%token CloseBrace "}" + +%token OpenBracket "[" +%token CloseBracket "]" + +%token At_error_ "@error" + +@begin Java +%token At_class_ "@class" +@end + +@begin C +%token _typedef_ "typedef" +%token _unsigned_ "unsigned" +%token _signed_ "signed" +%token _extern_ "extern" +@end + +@begin C +%token At_encode_ "@encode" +@end + +@begin ObjectiveC +%token At_implementation_ "@implementation" +%token At_import_ "@import" +%token At_end_ "@end" +%token At_selector_ "@selector" +%token At_null_ "@null" +%token At_YES_ "@YES" +%token At_NO_ "@NO" +%token At_true_ "@true" +%token At_false_ "@false" +%token _YES_ "YES" +%token _NO_ "NO" +@end + +%token _false_ "false" +%token _null_ "null" +%token _true_ "true" + +%token _break_ "break" +%token _case_ "case" +%token _catch_ "catch" +%token _class_ "class" +%token _class__ ";class" +%token _const_ "const" +%token _continue_ "continue" +%token _debugger_ "debugger" +%token _default_ "default" +%token _delete_ "delete" +%token _do_ "do" +%token _else_ "else" +%token _enum_ "enum" +%token _export_ "export" +%token _extends_ "extends" +%token _finally_ "finally" +%token _for_ "for" +%token _function_ "function" +%token _function__ ";function" +%token _if_ "if" +%token _import_ "import" +%token _in_ "in" +%token _in__ "!in" +%token _instanceof_ "instanceof" +%token _new_ "new" +%token _return_ "return" +%token _return__ "!return" +%token _super_ "super" +%token _switch_ "switch" +%token _this_ "this" +%token _throw_ "throw" +%token _try_ "try" +%token _typeof_ "typeof" +%token _var_ "var" +%token _void_ "void" +%token _while_ "while" +%token _with_ "with" + +%token _abstract_ "abstract" +%token _await_ "await" +%token _boolean_ "boolean" +%token _byte_ "byte" +%token _char_ "char" +%token _double_ "double" +%token _final_ "final" +%token _float_ "float" +%token _from_ "from" +%token _get_ "get" +%token _goto_ "goto" +%token _implements_ "implements" +%token _int_ "int" +%token _interface_ "interface" +%token _let_ "let" +%token _long_ "long" +%token _native_ "native" +%token _package_ "package" +%token _private_ "private" +%token _protected_ "protected" +%token _public_ "public" +%token _set_ "set" +%token _short_ "short" +%token _static_ "static" +%token _synchronized_ "synchronized" +%token _throws_ "throws" +%token _transient_ "transient" +%token _volatile_ "volatile" +%token _yield_ "yield" +%token _yield__ "!yield" + +%token _undefined_ "undefined" + +@begin ObjectiveC +%token _bool_ "bool" +%token _BOOL_ "BOOL" +%token _id_ "id" +%token _nil_ "nil" +%token _NULL_ "NULL" +%token _SEL_ "SEL" +@end + +%token _auto_ "auto" +%token _each_ "each" +%token _of_ "of" + +@begin E4X +%token _namespace_ "namespace" +%token _xml_ "xml" +@end + +%token AutoComplete +%token YieldStar + +%token Identifier_ +%token NumericLiteral +%token StringLiteral +%token RegularExpressionLiteral + +%token NoSubstitutionTemplate +%token TemplateHead +%token TemplateMiddle +%token TemplateTail + +%type AdditiveExpression +%type ArgumentList_ +%type ArgumentList +%type ArgumentListOpt +%type Arguments +%type ArrayComprehension +%type ArrayLiteral +%type ArrowFunction +%type ArrowParameters +%type AssignmentExpression +%type AssignmentExpressionOpt +%type Binding +%type BindingIdentifier +%type BindingIdentifierOpt +%type BitwiseANDExpression +%type Block +%type BlockStatement +%type BooleanLiteral +%type BindingElement +%type BitwiseORExpression +%type BitwiseXORExpression +%type BreakStatement +%type BreakableStatement +%type CallExpression_ +%type CallExpression +%type CaseBlock +%type CaseClause +%type CaseClausesOpt +%type Catch +%type CatchParameter +%type ClassDeclaration +%type ClassExpression +%type Comprehension +%type ComprehensionFor +%type ComprehensionIf +%type ComprehensionTail +%type ComputedPropertyName +%type ConditionalExpression +%type ContinueStatement +%type ConciseBody +%type CoverParenthesizedExpressionAndArrowParameterList +%type DebuggerStatement +%type Declaration__ +%type Declaration_ +%type Declaration +%type DefaultClause +%type ElementList +%type ElementListOpt +%type ElseStatementOpt +%type EmptyStatement +%type EqualityExpression +%type Expression +%type ExpressionOpt +%type ExpressionStatement +%type Finally +%type ForStatementInitializer +%type ForInStatementInitializer +%type FormalParameter +%type FormalParameterList_ +%type FormalParameterList +%type FormalParameters +%type FunctionBody +%type FunctionDeclaration +%type FunctionExpression +%type FunctionStatementList +%type GeneratorBody +%type GeneratorDeclaration +%type GeneratorExpression +%type GeneratorMethod +%type HoistableDeclaration +%type Identifier +%type IdentifierType +%type IdentifierName +%type IdentifierReference +%type IfStatement +%type Initializer +%type InitializerOpt +%type IterationStatement +%type LabelIdentifier +%type LabelledItem +%type LabelledStatement +%type LeftHandSideExpression +%type LetStatement +%type LexicalDeclaration +%type Literal +%type LiteralPropertyName +%type LogicalANDExpression +%type LogicalORExpression +%type MemberAccess +%type MemberExpression +%type MethodDefinition +%type ModulePath +%type MultiplicativeExpression +%type NewExpression +%type NullLiteral +%type ObjectLiteral +%type PostfixExpression +%type PrimaryExpression +%type PropertyName +%type PropertyDefinition +%type PropertyDefinitionList_ +%type PropertyDefinitionList +%type PropertyDefinitionListOpt +%type PropertySetParameterList +%type RelationalExpression +%type ReturnStatement +%type RubyProcExpression +%type RubyProcParameterList_ +%type RubyProcParameterList +%type RubyProcParameters +%type RubyProcParametersOpt +%type Script +%type ScriptBody +%type ScriptBodyOpt +%type ShiftExpression +%type SingleNameBinding +%type Statement__ +%type Statement_ +%type Statement +%type StatementList +%type StatementListOpt +%type StatementListItem +%type StrictFormalParameters +%type SwitchStatement +%type TemplateLiteral +%type TemplateSpans +%type ThrowStatement +%type TryStatement +%type UnaryExpression_ +%type UnaryExpression +%type VariableDeclaration +%type VariableDeclarationList_ +%type VariableDeclarationList +%type VariableStatement +%type WithStatement +%type Word +@begin ObjectiveC +%type WordOpt +@end +%type YieldExpression + +@begin C +%type IntegerType +%type IntegerTypeOpt +%type PrefixedType +%type PrimitiveType +%type SuffixedType +%type TypeSignifier +%type TypeQualifierLeft +%type TypeQualifierRight +%type TypedIdentifier +%type TypedParameterList_ +%type TypedParameterList +%type TypedParameterListOpt +@end + +@begin ObjectiveC +%type BoxableExpression +%type CategoryStatement +%type ClassFieldListOpt +%type ClassFields +%type ClassStatement +%type ClassSuperOpt +%type ClassMessageDeclaration +%type ClassMessageDeclarationListOpt +%type ClassName +%type ClassProtocolListOpt +%type ClassProtocols +%type ClassProtocolsOpt +%type MessageExpression +%type MessageParameter +%type MessageParameters +%type MessageParameterList +%type MessageParameterListOpt +%type MessageScope +%type SelectorCall_ +%type SelectorCall +%type SelectorExpression_ +%type SelectorExpression +%type SelectorExpressionOpt +%type SelectorList +%type SelectorWordOpt +%type TypeOpt +%type VariadicCall +@end + +@begin E4X +%type PropertyIdentifier_ +%type PropertySelector_ +%type PropertySelector +%type QualifiedIdentifier_ +%type QualifiedIdentifier +%type WildcardIdentifier +%type XMLComment +%type XMLCDATA +%type XMLElement +%type XMLElementContent +%type XMLMarkup +%type XMLPI + +%type AttributeIdentifier +/* XXX: %type DefaultXMLNamespaceStatement */ +%type PropertyIdentifier +%type XMLListInitialiser +%type XMLInitialiser +@end +/* }}} */ +/* Token Priorities {{{ */ +%nonassoc "" +%left "++" "--" "{" + +%nonassoc "if" +%nonassoc "else" +/* }}} */ + +%start Program +%token MarkModule +%token MarkScript + +%% + +Program + : MarkScript Script + | MarkModule Module + ; + +/* Lexer State {{{ */ +LexPushInOn: { driver.in_.push(true); }; +LexPushInOff: { driver.in_.push(false); }; +LexPopIn: { driver.in_.pop(); }; + +LexPushReturnOn: { driver.return_.push(true); }; +LexPopReturn: { driver.return_.pop(); }; + +LexPushYieldOn: { driver.yield_.push(true); }; +LexPushYieldOff: { driver.yield_.push(false); }; +LexPopYield: { driver.yield_.pop(); }; + +LexSetRegExp + : { driver.SetCondition(CYDriver::RegExpCondition); } + ; + +LexNewLine + : { if (!yyla.empty() && yyla.type_get() != yyeof_) CYERR(@$, "unexpected lookahead"); driver.next_ = true; } + ; + +LexNoStar + : { CYMAP(YieldStar, Star); } + ; + +LexNoBrace + : { CYMAP(OpenBrace__, OpenBrace); CYMAP(OpenBrace__, OpenBrace_); } + ; + +LexNoClass + : { CYMAP(_class__, _class_); } + ; + +LexNoFunction + : { CYMAP(_function__, _function_); } + ; + +LexSetStatement + : LexNoBrace LexNoClass LexNoFunction + ; +/* }}} */ +/* Virtual Tokens {{{ */ +BRACE + : "{" + | "\n{" + ; + +Var_ + : "var" + ; +/* }}} */ + +/* 11.6 Names and Keywords {{{ */ +IdentifierName + : Word { $$ = $1; } + | "for" { $$ = CYNew CYWord("for"); } + | "in" { $$ = CYNew CYWord("in"); } + | "instanceof" { $$ = CYNew CYWord("instanceof"); } + ; + +NewLineOpt + : "\n" + | + ; + +Word + : Identifier { $$ = $1; } + | "auto" { $$ = CYNew CYWord("auto"); } + | "break" { $$ = CYNew CYWord("break"); } + | "case" { $$ = CYNew CYWord("case"); } + | "catch" { $$ = CYNew CYWord("catch"); } + | "class" { $$ = CYNew CYWord("class"); } + | ";class" { $$ = CYNew CYWord("class"); } + | "const" { $$ = CYNew CYWord("const"); } + | "continue" { $$ = CYNew CYWord("continue"); } + | "debugger" { $$ = CYNew CYWord("debugger"); } + | "default" { $$ = CYNew CYWord("default"); } + | "delete" LexSetRegExp { $$ = CYNew CYWord("delete"); } + | "do" { $$ = CYNew CYWord("do"); } + | "else" { $$ = CYNew CYWord("else"); } + | "enum" { $$ = CYNew CYWord("enum"); } + | "export" { $$ = CYNew CYWord("export"); } + | "extends" { $$ = CYNew CYWord("extends"); } + | "false" { $$ = CYNew CYWord("false"); } + | "finally" { $$ = CYNew CYWord("finally"); } + | "function" { $$ = CYNew CYWord("function"); } + | "if" { $$ = CYNew CYWord("if"); } + | "import" { $$ = CYNew CYWord("import"); } + | "!in" { $$ = CYNew CYWord("in"); } + | "new" LexSetRegExp { $$ = CYNew CYWord("new"); } + | "null" { $$ = CYNew CYWord("null"); } + | "return" { $$ = CYNew CYWord("return"); } + | "!return" { $$ = CYNew CYWord("return"); } + | "super" { $$ = CYNew CYWord("super"); } + | "switch" { $$ = CYNew CYWord("switch"); } + | "this" { $$ = CYNew CYWord("this"); } + | "throw" { $$ = CYNew CYWord("throw"); } + | "true" { $$ = CYNew CYWord("true"); } + | "try" { $$ = CYNew CYWord("try"); } + | "typeof" LexSetRegExp { $$ = CYNew CYWord("typeof"); } + | "var" { $$ = CYNew CYWord("var"); } + | "void" LexSetRegExp { $$ = CYNew CYWord("void"); } + | "while" { $$ = CYNew CYWord("while"); } + | "with" { $$ = CYNew CYWord("with"); } + | "yield" { $$ = CYNew CYIdentifier("yield"); } + + | Yield LexSetRegExp NewLineOpt { $$ = CYNew CYIdentifier("yield"); } + + // XXX: should be Identifier + | "let" { $$ = CYNew CYIdentifier("let"); } + ; + +@begin ObjectiveC +WordOpt + : Word { $$ = $1; } + | { $$ = NULL; } + ; +@end +/* }}} */ +/* 11.8.1 Null Literals {{{ */ +NullLiteral + : "null" { $$ = CYNew CYNull(); } + ; +/* }}} */ +/* 11.8.2 Boolean Literals {{{ */ +BooleanLiteral + : "true" { $$ = CYNew CYTrue(); } + | "false" { $$ = CYNew CYFalse(); } + ; +/* }}} */ + +/* 11.9 Automatic Semicolon Insertion {{{ */ +StrictSemi + : { driver.Warning(@$, "warning, automatic semi-colon insertion required"); } + ; + +TerminatorSoft + : ";" + | "\n" StrictSemi + ; + +Terminator + : ";" + | error { if (yyla.type_get() != yyeof_ && yyla.type != yytranslate_(token::CloseBrace) && !driver.newline_) { CYERR(@1, "required semi-colon"); } else { yyerrok; driver.errors_.pop_back(); } } StrictSemi + ; + +TerminatorOpt + : ";" + | error { yyerrok; driver.errors_.pop_back(); } StrictSemi + ; +/* }}} */ + +/* 12.1 Identifiers {{{ */ +IdentifierReference + : Identifier { $$ = CYNew CYVariable($1); } + | "yield" { $$ = CYNew CYVariable(CYNew CYIdentifier("yield")); } + ; + +BindingIdentifier + : Identifier { $$ = $1; } + | "yield" { $$ = CYNew CYIdentifier("yield"); } + ; + +BindingIdentifierOpt + : BindingIdentifier { $$ = $1; } + | { $$ = NULL; } + ; + +LabelIdentifier + : Identifier { $$ = $1; } + | "yield" { $$ = CYNew CYIdentifier("yield"); } + ; + +IdentifierType + : Identifier_ { $$ = $1; } + | "abstract" { $$ = CYNew CYIdentifier("abstract"); } + | "await" { $$ = CYNew CYIdentifier("await"); } + | "boolean" { $$ = CYNew CYIdentifier("boolean"); } + | "byte" { $$ = CYNew CYIdentifier("byte"); } + | "double" { $$ = CYNew CYIdentifier("double"); } + | "each" { $$ = CYNew CYIdentifier("each"); } + | "final" { $$ = CYNew CYIdentifier("final"); } + | "float" { $$ = CYNew CYIdentifier("float"); } + | "goto" { $$ = CYNew CYIdentifier("goto"); } + | "implements" { $$ = CYNew CYIdentifier("implements"); } + | "interface" { $$ = CYNew CYIdentifier("interface"); } + | "native" { $$ = CYNew CYIdentifier("native"); } + | "of" { $$ = CYNew CYIdentifier("of"); } + | "package" { $$ = CYNew CYIdentifier("package"); } + | "private" { $$ = CYNew CYIdentifier("private"); } + | "protected" { $$ = CYNew CYIdentifier("protected"); } + | "public" { $$ = CYNew CYIdentifier("public"); } + | "static" { $$ = CYNew CYIdentifier("static"); } + | "synchronized" { $$ = CYNew CYIdentifier("synchronized"); } + | "throws" { $$ = CYNew CYIdentifier("throws"); } + | "transient" { $$ = CYNew CYIdentifier("transient"); } +@begin ObjectiveC + | "bool" { $$ = CYNew CYIdentifier("bool"); } + | "BOOL" { $$ = CYNew CYIdentifier("BOOL"); } + | "id" { $$ = CYNew CYIdentifier("id"); } + | "SEL" { $$ = CYNew CYIdentifier("SEL"); } +@end + ; + +Identifier + : IdentifierType + | "char" { $$ = CYNew CYIdentifier("char"); } + | "from" { $$ = CYNew CYIdentifier("from"); } + | "get" { $$ = CYNew CYIdentifier("get"); } + | "int" { $$ = CYNew CYIdentifier("int"); } + | "long" { $$ = CYNew CYIdentifier("long"); } + | "set" { $$ = CYNew CYIdentifier("set"); } + | "short" { $$ = CYNew CYIdentifier("short"); } + | "undefined" { $$ = CYNew CYIdentifier("undefined"); } + | "volatile" { $$ = CYNew CYIdentifier("volatile"); } +@begin C + | "extern" { $$ = CYNew CYIdentifier("extern"); } + | "signed" { $$ = CYNew CYIdentifier("signed"); } + | "typedef" { $$ = CYNew CYIdentifier("typedef"); } + | "unsigned" { $$ = CYNew CYIdentifier("unsigned"); } +@end +@begin ObjectiveC + | "nil" { $$ = CYNew CYIdentifier("nil"); } + | "NO" { $$ = CYNew CYIdentifier("NO"); } + | "NULL" { $$ = CYNew CYIdentifier("NULL"); } + | "YES" { $$ = CYNew CYIdentifier("YES"); } +@end + ; +/* }}} */ +/* 12.2 Primary Expression {{{ */ +PrimaryExpression + : "this" { $$ = CYNew CYThis(); } + | IdentifierReference { $$ = $1; } + | Literal { $$ = $1; } + | ArrayLiteral { $$ = $1; } + | ObjectLiteral { $$ = $1; } + | FunctionExpression { $$ = $1; } + | ClassExpression { $$ = $1; } + | GeneratorExpression { $$ = $1; } + | RegularExpressionLiteral { $$ = $1; } + | TemplateLiteral { $$ = $1; } + | CoverParenthesizedExpressionAndArrowParameterList { if ($1 == NULL) CYERR(@1, "invalid parenthetical"); $$ = $1; } + | AutoComplete { driver.mode_ = CYDriver::AutoPrimary; YYACCEPT; } + ; + +CoverParenthesizedExpressionAndArrowParameterList + : "(" LexPushInOff Expression ")" LexPopIn { $$ = CYNew CYParenthetical($3); } + | "(" LexPushInOff LexSetRegExp ")" LexPopIn { $$ = NULL; } + | "(" LexPushInOff LexSetRegExp "..." BindingIdentifier ")" LexPopIn { CYNOT(@$); } + | "(" LexPushInOff Expression "," LexSetRegExp "..." BindingIdentifier ")" LexPopIn { CYNOT(@$); } + ; +/* }}} */ +/* 12.2.4 Literals {{{ */ +Literal + : NullLiteral { $$ = $1; } + | BooleanLiteral { $$ = $1; } + | NumericLiteral { $$ = $1; } + | StringLiteral { $$ = $1; } + ; +/* }}} */ +/* 12.2.5 Array Initializer {{{ */ +ArrayLiteral + : "[" LexPushInOff ElementListOpt "]" LexPopIn { $$ = CYNew CYArray($3); } + ; + +ElementList + : AssignmentExpressionOpt "," ElementListOpt { $$ = CYNew CYElementValue($1, $3); } + | LexSetRegExp "..." AssignmentExpression { $$ = CYNew CYElementSpread($3); } + | AssignmentExpression { $$ = CYNew CYElementValue($1, NULL); } + ; + +ElementListOpt + : ElementList { $$ = $1; } + | LexSetRegExp { $$ = NULL; } + ; +/* }}} */ +/* 12.2.6 Object Initializer {{{ */ +ObjectLiteral + : BRACE LexPushInOff PropertyDefinitionListOpt "}" LexPopIn { $$ = CYNew CYObject($3); } + ; + +PropertyDefinitionList_ + : "," PropertyDefinitionListOpt { $$ = $2; } + | { $$ = NULL; } + ; + +PropertyDefinitionList + : PropertyDefinition PropertyDefinitionList_ { $1->SetNext($2); $$ = $1; } + ; + +PropertyDefinitionListOpt + : LexSetRegExp PropertyDefinitionList { $$ = $2; } + | LexSetRegExp { $$ = NULL; } + ; + +PropertyDefinition + : IdentifierReference { $$ = CYNew CYProperty($1->name_, $1); } + | CoverInitializedName { CYNOT(@$); } + | PropertyName ":" AssignmentExpression { $$ = CYNew CYProperty($1, $3); } + | MethodDefinition { $$ = $1; } + ; + +PropertyName + : LiteralPropertyName { $$ = $1; } + | ComputedPropertyName { CYNOT(@$); /* $$ = $1; */ } + ; + +LiteralPropertyName + : IdentifierName { $$ = $1; } + | StringLiteral { $$ = $1; } + | NumericLiteral { $$ = $1; } + ; + +ComputedPropertyName + : "[" AssignmentExpression "]" { $$ = $2; } + ; + +CoverInitializedName + : IdentifierReference Initializer + ; + +Initializer + : "=" AssignmentExpression { $$ = $2; } + ; + +InitializerOpt + : Initializer { $$ = $1; } + | { $$ = NULL; } + ; +/* }}} */ +/* 12.2.9 Template Literals {{{ */ +TemplateLiteral + : NoSubstitutionTemplate { $$ = CYNew CYTemplate($1, NULL); } + | TemplateHead TemplateSpans { $$ = CYNew CYTemplate($1, $2); } + ; + +TemplateSpans + : Expression TemplateMiddle TemplateSpans { $$ = CYNew CYSpan($1, $2, $3); } + | Expression TemplateTail { $$ = CYNew CYSpan($1, $2, NULL); } + ; +/* }}} */ + +/* 12.3 Left-Hand-Side Expressions {{{ */ +MemberAccess + : "[" LexPushInOff Expression "]" LexPopIn { $$ = CYNew CYDirectMember(NULL, $3); } + | "." IdentifierName { $$ = CYNew CYDirectMember(NULL, CYNew CYString($2)); } + | "." AutoComplete { driver.mode_ = CYDriver::AutoDirect; YYACCEPT; } + | TemplateLiteral { CYNOT(@$); } + ; + +MemberExpression + : LexSetRegExp PrimaryExpression { $$ = $2; } + | MemberExpression { driver.context_ = $1; } MemberAccess { $3->SetLeft($1); $$ = $3; } + | SuperProperty { CYNOT(@$); } + | MetaProperty { CYNOT(@$); } + | LexSetRegExp "new" MemberExpression Arguments { $$ = CYNew cy::Syntax::New($3, $4); } + ; + +SuperProperty + : LexSetRegExp "super" "[" Expression "]" + | LexSetRegExp "super" "." IdentifierName + ; + +MetaProperty + : NewTarget + ; + +NewTarget + : LexSetRegExp "new" LexSetRegExp "." "target" + ; + +NewExpression + : MemberExpression { $$ = $1; } + | LexSetRegExp "new" NewExpression { $$ = CYNew cy::Syntax::New($3, NULL); } + ; + +CallExpression_ + : MemberExpression + | CallExpression + ; + +CallExpression + : CallExpression_ Arguments { $$ = CYNew CYCall($1, $2); } + | SuperCall { CYNOT(@$); } + | CallExpression { driver.context_ = $1; } MemberAccess { $3->SetLeft($1); $$ = $3; } + ; + +SuperCall + : LexSetRegExp "super" Arguments + ; + +Arguments + : "(" LexPushInOff ArgumentListOpt ")" LexPopIn { $$ = $3; } + ; + +ArgumentList_ + : "," ArgumentList { $$ = $2; } + | { $$ = NULL; } + ; + +ArgumentList + : AssignmentExpression ArgumentList_ { $$ = CYNew CYArgument(NULL, $1, $2); } + | LexSetRegExp "..." AssignmentExpression { CYNOT(@$); } + ; + +ArgumentListOpt + : ArgumentList { $$ = $1; } + | LexSetRegExp { $$ = NULL; } + ; + +LeftHandSideExpression + : NewExpression { $$ = $1; } + | CallExpression { $$ = $1; } + ; +/* }}} */ +/* 12.4 Postfix Expressions {{{ */ +PostfixExpression + : %prec "" LeftHandSideExpression { $$ = $1; } + | LeftHandSideExpression "++" { $$ = CYNew CYPostIncrement($1); } + | LeftHandSideExpression "--" { $$ = CYNew CYPostDecrement($1); } + ; +/* }}} */ +/* 12.5 Unary Operators {{{ */ +UnaryExpression_ + : "delete" UnaryExpression { $$ = CYNew CYDelete($2); } + | "void" UnaryExpression { $$ = CYNew CYVoid($2); } + | "typeof" UnaryExpression { $$ = CYNew CYTypeOf($2); } + | "++" UnaryExpression { $$ = CYNew CYPreIncrement($2); } + | "\n++" UnaryExpression { $$ = CYNew CYPreIncrement($2); } + | "--" UnaryExpression { $$ = CYNew CYPreDecrement($2); } + | "\n--" UnaryExpression { $$ = CYNew CYPreDecrement($2); } + | "+" UnaryExpression { $$ = CYNew CYAffirm($2); } + | "-" UnaryExpression { $$ = CYNew CYNegate($2); } + | "~" UnaryExpression { $$ = CYNew CYBitwiseNot($2); } + | "!" UnaryExpression { $$ = CYNew CYLogicalNot($2); } + ; + +UnaryExpression + : PostfixExpression { $$ = $1; } + | LexSetRegExp UnaryExpression_ { $$ = $2; } + ; +/* }}} */ +/* 12.6 Multiplicative Operators {{{ */ +MultiplicativeExpression + : UnaryExpression { $$ = $1; } + | MultiplicativeExpression "*" UnaryExpression { $$ = CYNew CYMultiply($1, $3); } + | MultiplicativeExpression "/" UnaryExpression { $$ = CYNew CYDivide($1, $3); } + | MultiplicativeExpression "%" UnaryExpression { $$ = CYNew CYModulus($1, $3); } + ; +/* }}} */ +/* 12.7 Additive Operators {{{ */ +AdditiveExpression + : MultiplicativeExpression { $$ = $1; } + | AdditiveExpression "+" MultiplicativeExpression { $$ = CYNew CYAdd($1, $3); } + | AdditiveExpression "-" MultiplicativeExpression { $$ = CYNew CYSubtract($1, $3); } + ; +/* }}} */ +/* 12.8 Bitwise Shift Operators {{{ */ +ShiftExpression + : AdditiveExpression { $$ = $1; } + | ShiftExpression "<<" AdditiveExpression { $$ = CYNew CYShiftLeft($1, $3); } + | ShiftExpression ">>" AdditiveExpression { $$ = CYNew CYShiftRightSigned($1, $3); } + | ShiftExpression ">>>" AdditiveExpression { $$ = CYNew CYShiftRightUnsigned($1, $3); } + ; +/* }}} */ +/* 12.9 Relational Operators {{{ */ +RelationalExpression + : ShiftExpression { $$ = $1; } + | RelationalExpression "<" ShiftExpression { $$ = CYNew CYLess($1, $3); } + | RelationalExpression ">" ShiftExpression { $$ = CYNew CYGreater($1, $3); } + | RelationalExpression "<=" ShiftExpression { $$ = CYNew CYLessOrEqual($1, $3); } + | RelationalExpression ">=" ShiftExpression { $$ = CYNew CYGreaterOrEqual($1, $3); } + | RelationalExpression "instanceof" ShiftExpression { $$ = CYNew CYInstanceOf($1, $3); } + | RelationalExpression "in" ShiftExpression { $$ = CYNew CYIn($1, $3); } + ; +/* }}} */ +/* 12.10 Equality Operators {{{ */ +EqualityExpression + : RelationalExpression { $$ = $1; } + | EqualityExpression "==" RelationalExpression { $$ = CYNew CYEqual($1, $3); } + | EqualityExpression "!=" RelationalExpression { $$ = CYNew CYNotEqual($1, $3); } + | EqualityExpression "===" RelationalExpression { $$ = CYNew CYIdentical($1, $3); } + | EqualityExpression "!==" RelationalExpression { $$ = CYNew CYNotIdentical($1, $3); } + ; +/* }}} */ +/* 12.11 Binary Bitwise Operators {{{ */ +BitwiseANDExpression + : EqualityExpression { $$ = $1; } + | BitwiseANDExpression "&" EqualityExpression { $$ = CYNew CYBitwiseAnd($1, $3); } + ; + +BitwiseXORExpression + : BitwiseANDExpression { $$ = $1; } + | BitwiseXORExpression "^" BitwiseANDExpression { $$ = CYNew CYBitwiseXOr($1, $3); } + ; + +BitwiseORExpression + : BitwiseXORExpression { $$ = $1; } + | BitwiseORExpression "|" BitwiseXORExpression { $$ = CYNew CYBitwiseOr($1, $3); } + ; +/* }}} */ +/* 12.12 Binary Logical Operators {{{ */ +LogicalANDExpression + : BitwiseORExpression { $$ = $1; } + | LogicalANDExpression "&&" BitwiseORExpression { $$ = CYNew CYLogicalAnd($1, $3); } + ; + +LogicalORExpression + : LogicalANDExpression { $$ = $1; } + | LogicalORExpression "||" LogicalANDExpression { $$ = CYNew CYLogicalOr($1, $3); } + ; +/* }}} */ +/* 12.13 Conditional Operator ( ? : ) {{{ */ +ConditionalExpression + : LogicalORExpression { $$ = $1; } + | LogicalORExpression "?" LexPushInOff AssignmentExpression ":" LexPopIn AssignmentExpression { $$ = CYNew CYCondition($1, $4, $7); } + ; +/* }}} */ +/* 12.14 Assignment Operators {{{ */ +AssignmentExpression + : ConditionalExpression { $$ = $1; } + | LexSetRegExp YieldExpression { $$ = $2; } + | ArrowFunction { $$ = $1; } + | LeftHandSideExpression "=" AssignmentExpression { $$ = CYNew CYAssign($1, $3); } + | LeftHandSideExpression "*=" AssignmentExpression { $$ = CYNew CYMultiplyAssign($1, $3); } + | LeftHandSideExpression "/=" AssignmentExpression { $$ = CYNew CYDivideAssign($1, $3); } + | LeftHandSideExpression "%=" AssignmentExpression { $$ = CYNew CYModulusAssign($1, $3); } + | LeftHandSideExpression "+=" AssignmentExpression { $$ = CYNew CYAddAssign($1, $3); } + | LeftHandSideExpression "-=" AssignmentExpression { $$ = CYNew CYSubtractAssign($1, $3); } + | LeftHandSideExpression "<<=" AssignmentExpression { $$ = CYNew CYShiftLeftAssign($1, $3); } + | LeftHandSideExpression ">>=" AssignmentExpression { $$ = CYNew CYShiftRightSignedAssign($1, $3); } + | LeftHandSideExpression ">>>=" AssignmentExpression { $$ = CYNew CYShiftRightUnsignedAssign($1, $3); } + | LeftHandSideExpression "&=" AssignmentExpression { $$ = CYNew CYBitwiseAndAssign($1, $3); } + | LeftHandSideExpression "^=" AssignmentExpression { $$ = CYNew CYBitwiseXOrAssign($1, $3); } + | LeftHandSideExpression "|=" AssignmentExpression { $$ = CYNew CYBitwiseOrAssign($1, $3); } + ; + +AssignmentExpressionOpt + : AssignmentExpression { $$ = $1; } + | LexSetRegExp { $$ = NULL; } + ; +/* }}} */ +/* 12.15 Comma Operator ( , ) {{{ */ +Expression + : AssignmentExpression { $$ = $1; } + | Expression "," AssignmentExpression { $$ = CYNew CYCompound($1, $3); } + ; + +ExpressionOpt + : Expression { $$ = $1; } + | LexSetRegExp { $$ = NULL; } + ; +/* }}} */ + +/* 13 Statements and Declarations {{{ */ +Statement__ + : BlockStatement { $$ = $1; } + | VariableStatement { $$ = $1; } + | EmptyStatement { $$ = $1; } + | IfStatement { $$ = $1; } + | BreakableStatement { $$ = $1; } + | ContinueStatement { $$ = $1; } + | BreakStatement { $$ = $1; } + | ReturnStatement { $$ = $1; } + | WithStatement { $$ = $1; } + | LabelledStatement { $$ = $1; } + | ThrowStatement { $$ = $1; } + | TryStatement { $$ = $1; } + | DebuggerStatement { $$ = $1; } + ; + +Statement_ + : LexSetRegExp Statement__ { $$ = $2; } + | ExpressionStatement { $$ = $1; } + ; + +Statement + : LexSetStatement Statement_ { $$ = $2; } + ; + +Declaration__ + : HoistableDeclaration { $$ = $1; } + | ClassDeclaration { $$ = $1; } + | LexicalDeclaration { $$ = $1; } + ; + +Declaration_ + : LexSetRegExp Declaration__ { $$ = $2; } + ; + +Declaration + : LexSetStatement Declaration_ { $$ = $2; } + ; + +HoistableDeclaration + : FunctionDeclaration { $$ = $1; } + | GeneratorDeclaration { $$ = $1; } + ; + +BreakableStatement + : IterationStatement { $$ = $1; } + | SwitchStatement { $$ = $1; } + ; +/* }}} */ +/* 13.2 Block {{{ */ +BlockStatement + : ";{" StatementListOpt "}" { $$ = CYNew CYBlock($2); } + ; + +Block + : BRACE StatementListOpt "}" { $$ = $2; } + ; + +StatementList + : StatementListItem StatementListOpt { $1->SetNext($2); $$ = $1; } + ; + +StatementListOpt + : StatementList { $$ = $1; } + | LexSetStatement LexSetRegExp { $$ = NULL; } + ; + +StatementListItem + : Statement { $$ = $1; } + | Declaration { $$ = $1; } + ; +/* }}} */ +/* 13.3+ Let and Const Declarations {{{ */ +LexicalDeclaration + : LetOrConst VariableDeclarationList Terminator { $$ = CYNew CYVar($2); } + ; + +LetOrConst + : "let" + | "const" + ; + +Binding + : BindingIdentifier + ; + +// XXX: lots of binding stuff +/* }}} */ +/* 13.3.2+ Variable Statement {{{ */ +VariableStatement + : Var_ VariableDeclarationList Terminator { $$ = CYNew CYVar($2); } + ; + +VariableDeclarationList_ + : "," VariableDeclarationList { $$ = $2; } + | { $$ = NULL; } + ; + +VariableDeclarationList + : VariableDeclaration VariableDeclarationList_ { $$ = CYNew CYDeclarations($1, $2); } + ; + +VariableDeclaration + : BindingIdentifier InitializerOpt { $$ = CYNew CYDeclaration($1, $2); } + // XXX: | BindingPattern Initializer { $$ = CYNew CYDeclaration($1, $2); } + ; +/* }}} */ +/* 13.3.3 Destructuring Binding Patterns {{{ */ +BindingPattern + : ObjectBindingPattern + | ArrayBindingPattern + ; + +ObjectBindingPattern + : BRACE BindingPropertyListOpt "}" + ; + +ArrayBindingPattern + : "[" { CYNOT(@$); } + ; + +BindingPropertyList_ + : "," BindingPropertyListOpt + | + ; + +BindingPropertyList + : BindingProperty BindingPropertyList_ + ; + +BindingPropertyListOpt + : BindingPropertyList + | + ; + +BindingProperty + : SingleNameBinding + | PropertyName ":" BindingElement + ; + +BindingElement + : SingleNameBinding { $$ = $1; } + | BindingPattern InitializerOpt { CYNOT(@$); } + ; + +SingleNameBinding + : BindingIdentifier InitializerOpt { $$ = CYNew CYDeclaration($1, $2); } + ; + +BindingRestElement + : "..." BindingIdentifier + ; +/* }}} */ +/* 13.4 Empty Statement {{{ */ +EmptyStatement + : ";" { $$ = CYNew CYEmpty(); } + ; +/* }}} */ +/* 13.5 Expression Statement {{{ */ +ExpressionStatement + : Expression Terminator { $$ = CYNew CYExpress($1); } + ; +/* }}} */ +/* 13.6 The if Statement {{{ */ +ElseStatementOpt + : "else" Statement { $$ = $2; } + | %prec "if" { $$ = NULL; } + ; + +IfStatement + : "if" "(" Expression ")" Statement ElseStatementOpt { $$ = CYNew CYIf($3, $5, $6); } + ; +/* }}} */ +/* 13.7+ Iteration Statements {{{ */ +IterationStatement + : "do" Statement "while" "(" Expression ")" TerminatorOpt { $$ = CYNew CYDoWhile($5, $2); } + | "while" "(" Expression ")" Statement { $$ = CYNew CYWhile($3, $5); } + | "for" "(" LexPushInOn ForStatementInitializer ";" LexPopIn ExpressionOpt ";" ExpressionOpt ")" Statement { $$ = CYNew CYFor($4, $7, $9, $11); } + | "for" "(" LexPushInOn ForInStatementInitializer "!in" LexPopIn Expression ")" Statement { $$ = CYNew CYForIn($4, $7, $9); } + | "for" "(" LexPushInOn ForInStatementInitializer "of" LexPopIn Expression ")" Statement { $$ = CYNew CYForOf($4, $7, $9); } + ; + +ForStatementInitializer + : ExpressionOpt { $$ = $1; } + | LexSetRegExp Var_ VariableDeclarationList { $$ = CYNew CYForDeclarations($3); } + ; + +ForInStatementInitializer + : LeftHandSideExpression { $$ = $1; } + | LexSetRegExp Var_ VariableDeclaration { $$ = $3; } + ; +/* }}} */ +/* 13.8 The continue Statement {{{ */ +Continue + : "continue" LexNewLine + ; + +ContinueStatement + : Continue TerminatorSoft { $$ = CYNew CYContinue(NULL); } + | Continue Identifier Terminator { $$ = CYNew CYContinue($2); } + ; +/* }}} */ +/* 13.9 The break Statement {{{ */ +Break + : "break" LexNewLine + ; + +BreakStatement + : Break TerminatorSoft { $$ = CYNew CYBreak(NULL); } + | Break Identifier Terminator { $$ = CYNew CYBreak($2); } + ; +/* }}} */ +/* 13.10 The return Statement {{{ */ +Return + : "!return" LexNewLine + ; + +ReturnStatement + : Return LexSetRegExp TerminatorSoft { $$ = CYNew CYReturn(NULL); } + | Return Expression Terminator { $$ = CYNew CYReturn($2); } + ; +/* }}} */ +/* 13.11 The with Statement {{{ */ +WithStatement + : "with" "(" Expression ")" Statement { $$ = CYNew CYWith($3, $5); } + ; +/* }}} */ +/* 13.12 The switch Statement {{{ */ +SwitchStatement + : "switch" "(" Expression ")" CaseBlock { $$ = CYNew CYSwitch($3, $5); } + ; + +CaseBlock + : BRACE CaseClausesOpt "}" { $$ = $2; } + ; + +CaseClause + : "case" Expression ":" StatementListOpt { $$ = CYNew CYClause($2, $4); } + ; + +CaseClausesOpt + : CaseClause CaseClausesOpt { $1->SetNext($2); $$ = $1; } + | DefaultClause CaseClausesOpt { $1->SetNext($2); $$ = $1; } + | { $$ = NULL; } + ; + +// XXX: the standard makes certain you can only have one of these +DefaultClause + : "default" ":" StatementListOpt { $$ = CYNew CYClause(NULL, $3); } + ; +/* }}} */ +/* 13.13 Labelled Statements {{{ */ +LabelledStatement + : LabelIdentifier ":" LabelledItem { $$ = CYNew CYLabel($1, $3); } + ; + +LabelledItem + : Statement { $$ = $1; } + | LexSetStatement LexSetRegExp FunctionDeclaration { $$ = $3; } + ; +/* }}} */ +/* 13.14 The throw Statement {{{ */ +Throw + : "throw" LexNewLine + ; + +ThrowStatement + : Throw LexSetRegExp TerminatorSoft { CYERR(@1, "throw without exception"); } + | Throw Expression Terminator { $$ = CYNew cy::Syntax::Throw($2); } + ; +/* }}} */ +/* 13.15 The try Statement {{{ */ +TryStatement + : "try" Block Catch { $$ = CYNew cy::Syntax::Try($2, $3, NULL); } + | "try" Block Finally { $$ = CYNew cy::Syntax::Try($2, NULL, $3); } + | "try" Block Catch Finally { $$ = CYNew cy::Syntax::Try($2, $3, $4); } + ; + +Catch + : "catch" "(" CatchParameter ")" Block { $$ = CYNew cy::Syntax::Catch($3, $5); } + ; + +Finally + : "finally" Block { $$ = CYNew CYFinally($2); } + ; + +CatchParameter + : BindingIdentifier { $$ = $1; } + | BindingPattern { CYNOT(@$); } + ; +/* }}} */ +/* 13.16 The debugger Statement {{{ */ +DebuggerStatement + : "debugger" Terminator { $$ = CYNew CYDebugger(); } + ; +/* }}} */ + +/* 14.1 Function Definitions {{{ */ +FunctionDeclaration + : ";function" BindingIdentifier "(" FormalParameters ")" BRACE FunctionBody "}" { $$ = CYNew CYFunctionStatement($2, $4, $7); } + ; + +FunctionExpression + : "function" BindingIdentifierOpt "(" LexPushInOff FormalParameters ")" LexPopIn BRACE LexPushInOff FunctionBody "}" LexPopIn { $$ = CYNew CYFunctionExpression($2, $5, $10); } + ; + +StrictFormalParameters + : FormalParameters { $$ = $1; } + ; + +FormalParameters + : { $$ = NULL; } + | FormalParameterList + ; + +FormalParameterList_ + : "," FormalParameterList { $$ = $2; } + | { $$ = NULL; } + ; + +FormalParameterList + : FunctionRestParameter { CYNOT(@$); } + | FormalParameter FormalParameterList_ { $$ = CYNew CYFunctionParameter($1, $2); } + ; + +FunctionRestParameter + : BindingRestElement + ; + +FormalParameter + : BindingElement { $$ = $1; } + ; + +FunctionBody + : LexPushYieldOff FunctionStatementList LexPopYield { $$ = $2; } + ; + +FunctionStatementList + : LexPushReturnOn StatementListOpt LexPopReturn { $$ = $2; } + ; +/* }}} */ +/* 14.2 Arrow Function Definitions {{{ */ +ArrowFunction + : LexSetRegExp ArrowParameters "=>" LexNoBrace ConciseBody { $$ = CYNew CYFatArrow($2, $5); } + ; + +ArrowParameters + : BindingIdentifier { $$ = CYNew CYFunctionParameter(CYNew CYDeclaration($1)); } + | CoverParenthesizedExpressionAndArrowParameterList { $$ = $1->expression_->Parameter(); if ($$ == NULL) CYERR(@1, "invalid parameter list"); } + ; + +ConciseBody + : AssignmentExpression { $$ = CYNew CYReturn($1); } + | LexSetRegExp ";{" LexPushInOff FunctionBody "}" LexPopIn { $$ = $4; } + ; +/* }}} */ +/* 14.3 Method Definitions {{{ */ +MethodDefinition + : PropertyName "(" StrictFormalParameters ")" BRACE FunctionBody "}" { CYNOT(@$); /* $$ = CYNew CYFunctionMethod($1, $3, $6); */ } + | GeneratorMethod { $$ = $1; } + | "get" PropertyName "(" ")" BRACE FunctionBody "}" { CYNOT(@$); /* $$ = CYNew CYMethodGet($2, $6); */ } + | "set" PropertyName "(" PropertySetParameterList ")" BRACE FunctionBody "}" { CYNOT(@$); /* $$ = CYNew CYMethodSet($2, $4); */ } + ; + +PropertySetParameterList + : FormalParameter { $$ = $1; } + ; +/* }}} */ +/* 14.4 Generator Function Definitions {{{ */ +GeneratorMethod + : "*" PropertyName "(" StrictFormalParameters ")" BRACE GeneratorBody "}" { CYNOT(@$); /* $$ = CYNew CYGeneratorMethod($2, $4, $7); */ } + ; + +GeneratorDeclaration + : ";function" "*" BindingIdentifier "(" FormalParameters ")" BRACE GeneratorBody "}" { CYNOT(@$); /* $$ = CYNew CYGeneratorStatement($3, $5, $8); */ } + ; + +GeneratorExpression + : "function" "*" BindingIdentifierOpt "(" FormalParameters ")" BRACE GeneratorBody "}" { CYNOT(@$); /* $$ = CYNew CYGeneratorExpression($3, $5, $8); */ } + ; + +GeneratorBody + : LexPushYieldOn FunctionStatementList LexPopYield { $$ = $2; } + ; + +Yield + : "!yield" LexNewLine LexNoStar + ; + +YieldExpression + : Yield LexSetRegExp "\n" { CYNOT(@$); /* $$ = CYNew CYYieldValue(NULL); */ } + | Yield AssignmentExpression { CYNOT(@$); /* $$ = CYNew CYYieldValue($2); */ } + | Yield LexSetRegExp YieldStar AssignmentExpression { CYNOT(@$); /* $$ = CYNew CYYieldGenerator($4); */ } + ; +/* }}} */ +/* 14.5 Class Definitions {{{ */ +ClassDeclaration + : ";class" BindingIdentifier ClassTail { CYNOT(@$); } + ; + +ClassExpression + : "class" BindingIdentifierOpt ClassTail { CYNOT(@$); } + ; + +ClassTail + : ClassHeritageOpt BRACE ClassBodyOpt "}" + ; + +ClassHeritage + : "extends" LeftHandSideExpression + ; + +ClassHeritageOpt + : ClassHeritage + | + ; + +ClassBody + : ClassElementList + ; + +ClassBodyOpt + : ClassBody + | + ; + +ClassElementList + : ClassElementListOpt ClassElement + ; + +ClassElementListOpt + : ClassElementList + | + ; + +ClassElement + : MethodDefinition + | "static" MethodDefinition + | ";" + ; +/* }}} */ + +/* 15.1 Scripts {{{ */ +Script + : ScriptBodyOpt { driver.script_ = CYNew CYScript($1); } + ; + +ScriptBody + : StatementList { $$ = $1; } + ; + +ScriptBodyOpt + : ScriptBody { $$ = $1; } + | LexSetStatement LexSetRegExp { $$ = NULL; } + ; +/* }}} */ +/* 15.2 Modules {{{ */ +Module + : ModuleBodyOpt + ; + +ModuleBody + : ModuleItemList + ; + +ModuleBodyOpt + : ModuleBody + | + ; + +ModuleItemList + : ModuleItemListOpt ModuleItem + ; + +ModuleItemListOpt + : ModuleItemList + | + ; + +ModuleItem + : LexSetStatement LexSetRegExp ImportDeclaration + | LexSetStatement LexSetRegExp ExportDeclaration + | StatementListItem + ; +/* }}} */ +/* 15.2.2 Imports {{{ */ +ImportDeclaration + : "import" ImportClause FromClause Terminator + | "import" ModuleSpecifier Terminator + ; + +ImportClause + : ImportedDefaultBinding + | NameSpaceImport + | NamedImports + | ImportedDefaultBinding "," NameSpaceImport + | ImportedDefaultBinding "," NamedImports + ; + +ImportedDefaultBinding + : ImportedBinding + ; + +NameSpaceImport + : "*" "as" ImportedBinding + ; + +NamedImports + : BRACE ImportsListOpt "}" + ; + +FromClause + : "from" ModuleSpecifier + ; + +ImportsList_ + : "," ImportsListOpt + | + ; + +ImportsList + : ImportSpecifier ImportsList_ + ; + +ImportsListOpt + : ImportsList + | + ; + +ImportSpecifier + : ImportedBinding + | IdentifierName "as" ImportedBinding + ; + +ModuleSpecifier + : StringLiteral + ; + +ImportedBinding + : BindingIdentifier + ; +/* }}} */ +/* 15.2.3 Exports {{{ */ +ExportDeclaration_ + : "*" FromClause Terminator + | ExportClause FromClause Terminator + | ExportClause Terminator + | VariableStatement + | "default" LexSetStatement LexSetRegExp HoistableDeclaration + | "default" LexSetStatement LexSetRegExp ClassDeclaration + | "default" LexSetStatement AssignmentExpression Terminator + ; + +ExportDeclaration + : "export" LexSetStatement LexSetRegExp ExportDeclaration_ + | "export" Declaration + ; + +ExportClause + : ";{" ExportsListOpt "}" + ; + +ExportsList_ + : "," ExportsListOpt + | + ; + +ExportsList + : ExportSpecifier ExportsList_ + ; + +ExportsListOpt + : ExportsList + | + ; + +ExportSpecifier + : IdentifierName + | IdentifierName "as" IdentifierName + ; +/* }}} */ + +@begin C +/* Cycript (C): Type Encoding {{{ */ +TypeSignifier + : IdentifierType { $$ = CYNew CYTypedIdentifier(@1, $1); } + | "(" LexPushInOff "*" TypeQualifierRight ")" LexPopIn { $$ = $4; } + ; + +SuffixedType + : SuffixedType "[" NumericLiteral "]" { $$ = $1; $$->modifier_ = CYNew CYTypeArrayOf($3, $$->modifier_); } + | "(" LexPushInOff "^" TypeQualifierRight ")" LexPopIn "(" LexPushInOff TypedParameterListOpt ")" LexPopIn { $$ = $4; $$->modifier_ = CYNew CYTypeBlockWith($9, $$->modifier_); } + | TypeSignifier "(" LexPushInOff TypedParameterListOpt ")" LexPopIn { $$ = $1; $$->modifier_ = CYNew CYTypeFunctionWith($4, $$->modifier_); } + | "(" LexPushInOff TypedParameterListOpt ")" LexPopIn { $$ = CYNew CYTypedIdentifier(@1); $$->modifier_ = CYNew CYTypeFunctionWith($3, $$->modifier_); } + | TypeSignifier { $$ = $1; } + | { $$ = CYNew CYTypedIdentifier(@$); } + ; + +PrefixedType + : "*" TypeQualifierRight { $$ = $2; $$->modifier_ = CYNew CYTypePointerTo($$->modifier_); } + ; + +TypeQualifierLeft + : { $$ = NULL; } + | "const" TypeQualifierLeft { $$ = $2; CYSetLast($$) = CYNew CYTypeConstant(); } + | "volatile" TypeQualifierLeft { $$ = $2; CYSetLast($$) = CYNew CYTypeVolatile(); } + ; + +TypeQualifierRight + : PrefixedType { $$ = $1; } + | SuffixedType { $$ = $1; } + | "const" TypeQualifierRight { $$ = $2; $$->modifier_ = CYNew CYTypeConstant($$->modifier_); } + | "volatile" TypeQualifierRight { $$ = $2; $$->modifier_ = CYNew CYTypeVolatile($$->modifier_); } + ; + +IntegerType + : "int" { $$ = CYNew CYTypeVariable("int"); } + | "unsigned" IntegerTypeOpt { $$ = CYNew CYTypeUnsigned($2); } + | "signed" IntegerTypeOpt { $$ = CYNew CYTypeSigned($2); } + | "long" IntegerTypeOpt { $$ = CYNew CYTypeLong($2); } + | "short" IntegerTypeOpt { $$ = CYNew CYTypeShort($2); } + ; + +IntegerTypeOpt + : IntegerType { $$ = $1; } + | { $$ = CYNew CYTypeVariable("int"); } + ; + +PrimitiveType + : IdentifierType { $$ = CYNew CYTypeVariable($1); } + | IntegerType { $$ = $1; } + | "void" { $$ = CYNew CYTypeVoid(); } + | "char" { $$ = CYNew CYTypeVariable("char"); } + | "signed" "char" { $$ = CYNew CYTypeSigned(CYNew CYTypeVariable("char")); } + | "unsigned" "char" { $$ = CYNew CYTypeUnsigned(CYNew CYTypeVariable("char")); } + ; + +TypedIdentifier + : TypeQualifierLeft PrimitiveType TypeQualifierRight { $$ = $3; $$->specifier_ = $2; CYSetLast($1) = $$->modifier_; $$->modifier_ = $1; } + ; + +PrimaryExpression + : "@encode" "(" TypedIdentifier ")" { $$ = CYNew CYEncodedType($3); } + ; +/* }}} */ +@end + +@begin ObjectiveC +/* Cycript (Objective-C): @class Declaration {{{ */ +ClassSuperOpt + /* XXX: why the hell did I choose MemberExpression? */ + : ":" LexSetRegExp MemberExpression { $$ = $3; } + | { $$ = NULL; } + ; + +ClassFieldListOpt + : TypedIdentifier ";" ClassFieldListOpt { $$ = CYNew CYClassField($1, $3); } + | LexSetRegExp { $$ = NULL; } + ; + +ClassFields + : BRACE ClassFieldListOpt "}" { $$ = $2; } + ; + +MessageScope + : "+" { $$ = false; } + | "-" { $$ = true; } + ; + +TypeOpt + : "(" LexSetRegExp TypedIdentifier ")" { if ($3->identifier_ != NULL) CYERR($3->location_, "unexpected identifier"); $$ = $3; } + | { $$ = CYNew CYTypedIdentifier(CYNew CYTypeVariable("id")); } + ; + +MessageParameter + : Word ":" TypeOpt Identifier { $3->identifier_ = $4; $$ = CYNew CYMessageParameter($1, $3); } + ; + +MessageParameterList + : MessageParameter MessageParameterListOpt { $1->SetNext($2); $$ = $1; } + ; + +MessageParameterListOpt + : MessageParameterList { $$ = $1; } + | { $$ = NULL; } + ; + +MessageParameters + : MessageParameterList { $$ = $1; } + | Word { $$ = CYNew CYMessageParameter($1, NULL); } + ; + +ClassMessageDeclaration + : MessageScope TypeOpt MessageParameters BRACE FunctionBody "}" { $$ = CYNew CYMessage($1, $2, $3, $5); } + ; + +ClassMessageDeclarationListOpt + : ClassMessageDeclarationListOpt ClassMessageDeclaration { $2->SetNext($1); $$ = $2; } + | { $$ = NULL; } + ; + +ClassName + : Identifier { $$ = $1; } + | "(" AssignmentExpression ")" { $$ = $2; } + ; + +// XXX: this should be AssignmentExpressionNoRight +ClassProtocols + : ShiftExpression ClassProtocolsOpt { $$ = CYNew CYProtocol($1, $2); } + ; + +ClassProtocolsOpt + : "," ClassProtocols { $$ = $2; } + | { $$ = NULL; } + ; + +ClassProtocolListOpt + : "<" ClassProtocols ">" { $$ = $2; } + | { $$ = NULL; } + ; + +ClassStatement + : "@implementation" ClassName ClassSuperOpt ClassProtocolListOpt ClassFields ClassMessageDeclarationListOpt "@end" { $$ = CYNew CYClassStatement($2, $3, $4, $5, $6); } + ; + +CategoryName + : "(" WordOpt ")" + ; + +CategoryStatement + : "@implementation" ClassName CategoryName ClassMessageDeclarationListOpt "@end" { $$ = CYNew CYCategory($2, $4); } + ; + +Statement__ + : ClassStatement { $$ = $1; } + | CategoryStatement { $$ = $1; } + ; +/* }}} */ +/* Cycript (Objective-C): Send Message {{{ */ +VariadicCall + : "," AssignmentExpression VariadicCall { $$ = CYNew CYArgument(NULL, $2, $3); } + | { $$ = NULL; } + ; + +SelectorWordOpt + : WordOpt { driver.contexts_.back().words_.push_back($1); } { $$ = $1; } + | AutoComplete { driver.mode_ = CYDriver::AutoMessage; YYACCEPT; } + ; + +SelectorCall_ + : SelectorCall { $$ = $1; } + | VariadicCall { $$ = $1; } + ; + +SelectorCall + : SelectorWordOpt ":" AssignmentExpression SelectorCall_ { $$ = CYNew CYArgument($1 ?: CYNew CYWord(""), $3, $4); } + ; + +SelectorList + : SelectorCall { $$ = $1; } + | Word { $$ = CYNew CYArgument($1, NULL); } + ; + +MessageExpression + : "[" LexPushInOff AssignmentExpression { driver.contexts_.push_back($3); } SelectorList "]" LexPopIn { driver.contexts_.pop_back(); } { $$ = CYNew CYSendDirect($3, $5); } + | "[" LexPushInOff LexSetRegExp "super" { driver.context_ = NULL; } SelectorList "]" LexPopIn { $$ = CYNew CYSendSuper($6); } + ; + +SelectorExpression_ + : WordOpt ":" SelectorExpressionOpt { $$ = CYNew CYSelectorPart($1, true, $3); } + ; + +SelectorExpression + : SelectorExpression_ { $$ = $1; } + | Word { $$ = CYNew CYSelectorPart($1, false, NULL); } + ; + +SelectorExpressionOpt + : SelectorExpression_ { $$ = $1; } + | { $$ = NULL; } + ; + +PrimaryExpression + : MessageExpression { $$ = $1; } + | "@selector" "(" LexPushInOff SelectorExpression ")" LexPopIn { $$ = CYNew CYSelector($4); } + ; +/* }}} */ +@end + +/* Cycript: @import Directive {{{ */ +ModulePath + : ModulePath "." Word { $$ = CYNew CYModule($3, $1); } + | Word { $$ = CYNew CYModule($1); } + ; + +Declaration__ + : "@import" ModulePath { $$ = CYNew CYImport($2); } + ; +/* }}} */ + +@begin ObjectiveC +/* Cycript (Objective-C): Boxed Expressions {{{ */ +BoxableExpression + : NullLiteral { $$ = $1; } + | BooleanLiteral { $$ = $1; } + | NumericLiteral { $$ = $1; } + | StringLiteral { $$ = $1; } + | ArrayLiteral { $$ = $1; } + | ObjectLiteral { $$ = $1; } + | CoverParenthesizedExpressionAndArrowParameterList { $$ = $1; } + | "YES" { $$ = CYNew CYTrue(); } + | "NO" { $$ = CYNew CYFalse(); } + ; + +PrimaryExpression + : "@" BoxableExpression { $$ = CYNew CYBox($2); } + | "@YES" { $$ = CYNew CYBox(CYNew CYTrue()); } + | "@NO" { $$ = CYNew CYBox(CYNew CYFalse()); } + | "@true" { $$ = CYNew CYBox(CYNew CYTrue()); } + | "@false" { $$ = CYNew CYBox(CYNew CYFalse()); } + | "@null" { $$ = CYNew CYBox(CYNew CYNull()); } + ; +/* }}} */ +/* Cycript (Objective-C): Block Expressions {{{ */ +PrimaryExpression + : "^" TypedIdentifier { if ($2->identifier_ != NULL) CYERR($2->location_, "unexpected identifier"); } BRACE LexPushInOff FunctionBody "}" LexPopIn { if (CYTypeFunctionWith *function = $2->Function()) $$ = CYNew CYObjCBlock($2, function->parameters_, $6); else CYERR($2->location_, "expected parameters"); } + ; +/* }}} */ +/* Cycript (Objective-C): Instance Literals {{{ */ +PrimaryExpression + : "#" NumericLiteral { $$ = CYNew CYInstanceLiteral($2); } + ; +/* }}} */ +@end + +@begin C +/* Cycript (C): Pointer Indirection/Addressing {{{ */ +LeftHandSideExpression + : LexSetRegExp "*" UnaryExpression { $$ = CYNew CYIndirect($3); } + ; + +UnaryExpression_ + : "&" UnaryExpression { $$ = CYNew CYAddressOf($2); } + ; + +MemberAccess + : "->" "[" Expression "]" { $$ = CYNew CYIndirectMember(NULL, $3); } + | "->" IdentifierName { $$ = CYNew CYIndirectMember(NULL, CYNew CYString($2)); } + | "->" AutoComplete { driver.mode_ = CYDriver::AutoIndirect; YYACCEPT; } + ; +/* }}} */ +/* Cycript (C): auto Compatibility {{{ */ +Var_ + : "auto" + ; +/* }}} */ +/* Cycript (C): Lambda Expressions {{{ */ +TypedParameterList_ + : "," TypedParameterList { $$ = $2; } + | { $$ = NULL; } + ; + +TypedParameterList + : TypedIdentifier TypedParameterList_ { $$ = CYNew CYTypedParameter($1, $2); } + ; + +TypedParameterListOpt + : TypedParameterList { $$ = $1; } + | { $$ = NULL; } + ; + +PrimaryExpression + : "[" LexPushInOff LexSetRegExp "&" LexSetRegExp "]" LexPopIn "(" LexPushInOff TypedParameterListOpt ")" LexPopIn "->" TypedIdentifier BRACE LexPushInOff FunctionBody "}" LexPopIn { $$ = CYNew CYLambda($14, $10, $17); } + ; +/* }}} */ +/* Cycript (C): Type Definitions {{{ */ +Statement__ + : "typedef" TypedIdentifier { if ($2->identifier_ == NULL) CYERR($2->location_, "expected identifier"); } Terminator { $$ = CYNew CYTypeDefinition($2); } + ; +/* }}} */ +/* Cycript (C): extern "C" {{{ */ +Statement__ + : "extern" StringLiteral { if (strcmp($2->Value(), "C") != 0) CYERR(@2, "unknown extern binding"); } TypedIdentifier { if ($4->identifier_ == NULL) CYERR($4->location_, "expected identifier"); } Terminator { $$ = CYNew CYExternal($2, $4); } + ; +/* }}} */ + +@end + +@begin E4X +/* Lexer State {{{ */ +LexPushRegExp + : { driver.PushCondition(CYDriver::RegExpCondition); } + ; + +LexPushXMLContent + : { driver.PushCondition(CYDriver::XMLContentCondition); } + ; + +LexPushXMLTag + : { driver.PushCondition(CYDriver::XMLTagCondition); } + ; + +LexPop + : { driver.PopCondition(); } + ; + +LexSetXMLContent + : { driver.SetCondition(CYDriver::XMLContentCondition); } + ; + +LexSetXMLTag + : { driver.SetCondition(CYDriver::XMLTagCondition); } + ; +/* }}} */ +/* Virtual Tokens {{{ */ +XMLWhitespaceOpt + : XMLWhitespace + | + ; +/* }}} */ + +/* 8.1 Context Keywords {{{ */ +Identifier + : "namespace" { $$ = CYNew CYIdentifier("namespace"); } + | "xml" { $$ = CYNew CYIdentifier("xml"); } + ; +/* }}} */ +/* 8.3 XML Initializer Input Elements {{{ */ +XMLMarkup + : XMLComment { $$ = $1; } + | XMLCDATA { $$ = $1; } + | XMLPI { $$ = $1; } + ; +/* }}} */ + +/* 11.1 Primary Expressions {{{ */ +PrimaryExpression + : PropertyIdentifier { $$ = CYNew CYPropertyVariable($1); } + | XMLInitialiser { $$ = $1; } + | XMLListInitialiser { $$ = $1; } + ; + +PropertyIdentifier + : AttributeIdentifier { $$ = $1; } + | QualifiedIdentifier { $$ = $1; } + | WildcardIdentifier { $$ = $1; } + ; +/* }}} */ +/* 11.1.1 Attribute Identifiers {{{ */ +AttributeIdentifier + : "@" QualifiedIdentifier_ { $$ = CYNew CYAttribute($2); } + ; + +PropertySelector_ + : PropertySelector { $$ = $1; } + | "[" LexPushInOff Expression "]" LexPopIn { $$ = CYNew CYSelector($3); } + ; + +PropertySelector + : Identifier { $$ = CYNew CYSelector($1); } + | WildcardIdentifier { $$ = $1; } + ; +/* }}} */ +/* 11.1.2 Qualified Identifiers {{{ */ +QualifiedIdentifier_ + : PropertySelector_ { $$ = CYNew CYQualified(NULL, $1); } + | QualifiedIdentifier { $$ = $1; } + ; + +QualifiedIdentifier + : PropertySelector "::" PropertySelector_ { $$ = CYNew CYQualified($1, $3); } + ; +/* }}} */ +/* 11.1.3 Wildcard Identifiers {{{ */ +WildcardIdentifier + : "*" { $$ = CYNew CYWildcard(); } + ; +/* }}} */ +/* 11.1.4 XML Initializer {{{ */ +XMLInitialiser + : XMLMarkup { $$ = $1; } + | XMLElement { $$ = $1; } + ; + +XMLElement + : "<" LexPushInOff XMLTagContent LexPop "/>" LexPopIn + | "<" LexPushInOff XMLTagContent ">" LexSetXMLContent XMLElementContentOpt "" LexPopIn + ; + +XMLTagContent + : LexPushXMLTag XMLTagName XMLAttributes + ; + +XMLExpression + : BRACE LexPushRegExp Expression LexPop "}" + ; + +XMLTagName + : XMLExpression + | XMLName + ; + +XMLAttributes_ + : XMLAttributes_ XMLAttribute + | + ; + +XMLAttributes + : XMLAttributes_ XMLWhitespace XMLExpression XMLWhitespaceOpt + | XMLAttributes_ XMLWhitespaceOpt + ; + +XMLAttributeValue_ + : XMLExpression + | XMLAttributeValue + ; + +XMLAttribute + : XMLWhitespace XMLName XMLWhitespaceOpt "=" XMLWhitespaceOpt XMLAttributeValue_ + ; + +XMLElementContent + : XMLExpression XMLElementContentOpt + | XMLMarkup XMLElementContentOpt + | XMLText XMLElementContentOpt + | XMLElement XMLElementContentOpt + ; + +XMLElementContentOpt + : XMLElementContent + | + ; +/* }}} */ +/* 11.1.5 XMLList Initializer {{{ */ +XMLListInitialiser + : "<>" LexPushInOff LexPushXMLContent XMLElementContent LexPop "" LexPopIn { $$ = CYNew CYXMLList($4); } + ; +/* }}} */ + +/* 11.2 Left-Hand-Side Expressions {{{ */ +PropertyIdentifier_ + : Identifier { $$ = $1; } + | PropertyIdentifier { $$ = $1; } + ; + +MemberAccess + : "." PropertyIdentifier { $$ = CYNew CYPropertyMember(NULL, $2); } + | ".." PropertyIdentifier_ { $$ = CYNew CYDescendantMember(NULL, $2); } + | "." "(" Expression ")" { $$ = CYNew CYFilteringPredicate(NULL, $3); } + ; +/* }}} */ +/* 12.1 The default xml namespace Statement {{{ */ +/* XXX: DefaultXMLNamespaceStatement + : "default" "xml" "namespace" "=" Expression Terminator { $$ = CYNew CYDefaultXMLNamespace($5); } + ; + +Statement__ + : DefaultXMLNamespaceStatement { $$ = $1; } + ; */ +/* }}} */ +@end + +/* JavaScript FTL: Array Comprehensions {{{ */ +Comprehension + : AssignmentExpression ComprehensionFor ComprehensionTail { $$ = CYNew CYArrayComprehension($1, $2->Modify($3)); } + ; + +ComprehensionFor + : "for" "(" Binding "in" Expression ")" { $$ = CYNew CYForInComprehension($3, $5); } + | "for" "each" "(" Binding "in" Expression ")" { $$ = CYNew CYForOfComprehension($4, $6); } + ; +/* }}} */ +/* JavaScript FTL: for each {{{ */ +IterationStatement + : "for" "each" "(" LexPushInOn ForInStatementInitializer "!in" LexPopIn Expression ")" Statement { $$ = CYNew CYForOf($5, $8, $10); } + ; +/* }}} */ +/* JavaScript FTL: let Statements {{{ */ +LetStatement + : "let" "(" VariableDeclarationList ")" Statement { $$ = CYNew CYLetStatement($3, $5); } + ; + +Statement__ + : LetStatement + ; +/* }}} */ + +/* JavaScript FTW: Array Comprehensions {{{ */ +PrimaryExpression + : ArrayComprehension + ; + +ArrayComprehension + : "[" LexPushInOff Comprehension "]" LexPopIn { $$ = $3; } + ; + +Comprehension + : LexSetRegExp ComprehensionFor ComprehensionTail AssignmentExpression { $$ = CYNew CYArrayComprehension($4, $2->Modify($3)); } + ; + +ComprehensionTail + : { $$ = NULL; } + | ComprehensionFor ComprehensionTail { $$ = $1->Modify($2); } + | ComprehensionIf ComprehensionTail { $$ = $1->Modify($2); } + ; + +ComprehensionFor + : "for" "(" Binding "of" Expression ")" { $$ = CYNew CYForOfComprehension($3, $5); } + ; + +ComprehensionIf + : "if" "(" AssignmentExpression ")" { $$ = CYNew CYIfComprehension($3); } + ; +/* }}} */ +/* JavaScript FTW: Coalesce Operator {{{ */ +ConditionalExpression + : LogicalORExpression "?" LexPushInOff LexSetRegExp ":" LexPopIn AssignmentExpression { $$ = CYNew CYCondition($1, $1, $7); } + ; +/* }}} */ +/* JavaScript FTW: Named Arguments {{{ */ +ArgumentList + : LexSetRegExp Word ":" AssignmentExpression ArgumentList_ { $$ = CYNew CYArgument($2, $4, $5); } + ; +/* }}} */ +/* JavaScript FTW: Ruby Blocks {{{ */ +RubyProcParameterList_ + : "," RubyProcParameterList { $$ = $2; } + | { $$ = NULL; } + ; + +RubyProcParameterList + : Identifier RubyProcParameterList_ { $$ = CYNew CYFunctionParameter(CYNew CYDeclaration($1), $2); } + | { $$ = NULL; } + ; + +RubyProcParameters + : LexSetRegExp "|" RubyProcParameterList "|" { $$ = $3; } + | LexSetRegExp "||" { $$ = NULL; } + ; + +RubyProcParametersOpt + : RubyProcParameters { $$ = $1; } + | { $$ = NULL; } + ; + +RubyProcExpression + : "{" RubyProcParametersOpt StatementListOpt "}" { $$ = CYNew CYRubyProc($2, $3); } + ; + +PrimaryExpression + : BRACE LexPushInOff RubyProcParameters StatementListOpt "}" LexPopIn { $$ = CYNew CYRubyProc($3, $4); } + ; + +PostfixExpression + : LeftHandSideExpression RubyProcExpression { $$ = CYNew CYRubyBlock($1, $2); } + ; +/* }}} */ + +%% + +bool CYDriver::Parse(CYMark mark) { + mark_ = mark; + CYLocal local(&pool_); + cy::parser parser(*this); +#ifdef YYDEBUG + parser.set_debug_level(debug_); +#endif + return parser.parse() != 0; +} + +void CYDriver::Warning(const cy::parser::location_type &location, const char *message) { + if (!strict_) + return; + + CYDriver::Error error; + error.warning_ = true; + error.location_ = location; + error.message_ = message; + errors_.push_back(error); +} + +void cy::parser::error(const cy::parser::location_type &location, const std::string &message) { + CYDriver::Error error; + error.warning_ = false; + error.location_ = location; + error.message_ = message; + driver.errors_.push_back(error); +} diff --git a/Replace.cpp b/Replace.cpp index 06b6359..bc162d3 100644 --- a/Replace.cpp +++ b/Replace.cpp @@ -19,11 +19,11 @@ **/ /* }}} */ -#include "Parser.hpp" -#include "Replace.hpp" - #include +#include "Replace.hpp" +#include "Syntax.hpp" + CYFunctionExpression *CYNonLocalize(CYContext &context, CYFunctionExpression *function) { function->nonlocal_ = context.nextlocal_; return function; diff --git a/Replace.hpp b/Replace.hpp index 4aa6e00..3fac91e 100644 --- a/Replace.hpp +++ b/Replace.hpp @@ -22,7 +22,7 @@ #ifndef CYCRIPT_REPLACE_HPP #define CYCRIPT_REPLACE_HPP -#include "Parser.hpp" +#include "Syntax.hpp" #define $ new($pool) diff --git a/Scanner.lpp.in b/Scanner.lpp.in new file mode 100644 index 0000000..bcbd0d0 --- /dev/null +++ b/Scanner.lpp.in @@ -0,0 +1,707 @@ +/* Cycript - Optimizing JavaScript Compiler/Runtime + * Copyright (C) 2009-2015 Jay Freeman (saurik) +*/ + +/* GNU Affero General Public License, Version 3 {{{ */ +/* + * This program is free software: you can redistribute it and/or modify + * it under the terms of the GNU Affero General Public License as published by + * the Free Software Foundation, either version 3 of the License, or + * (at your option) any later version. + + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU Affero General Public License for more details. + + * You should have received a copy of the GNU Affero General Public License + * along with this program. If not, see . +**/ +/* }}} */ + +%top{ +#if defined(__clang__) +#pragma clang diagnostic push +#pragma clang diagnostic ignored "-Wdeprecated-register" +#pragma clang diagnostic ignored "-Wunused-function" +#pragma clang diagnostic ignored "-Wunused-variable" +#else +#pragma GCC diagnostic push +#pragma GCC diagnostic ignored "-Wsign-compare" +#pragma GCC diagnostic ignored "-Wunused-function" +#pragma GCC diagnostic ignored "-Wunused-variable" +#endif +} + +%{ + +#define YYLTYPE CYLocation +#include "Parser.hpp" +typedef cy::parser::token tk; + +#include "Highlight.hpp" + +#define YY_EXTRA_TYPE CYDriver * + +#define F(value, highlight) do { \ + yyextra->newline_ = yyextra->last_; \ + yyextra->last_ = false; \ + yyextra->next_ = false; \ + BEGIN(yyextra->template_.top() ? DivOrTemplateTail : Div); \ + yylval->highlight_ = highlight; \ + return value; \ +} while (false) + +#define P yyextra->pool_ +#define A new(P) +#define Y P.strmemdup(yytext, yyleng) + +#define I(type, Type, value, highlight) do { \ + yylval->semantic_.type ## _ = A CY ## Type; \ + F(value, highlight); \ +} while (false) + +#define N \ + if (yyextra->last_ && yyextra->next_) { \ + yyextra->last_ = false; \ + F(tk::NewLine, hi::Nothing); \ + } + +#define V(more) { \ + if (const char *nl = reinterpret_cast(memchr(yytext, '\n', yyleng))) { \ + unsigned lines(0); \ + size_t left; \ + do { \ + ++lines; \ + left = yyleng - (nl - yytext) - 1; \ + nl = reinterpret_cast(memchr(nl + 1, '\n', left)); \ + } while (nl != NULL); \ + yylloc->step(); \ + yylloc->end.lines(lines); \ + yylloc->end.columns(left); \ + more \ + } else L \ +} + +#define R yylloc->end.columns(yyleng); +#define L yylloc->step(); R + +#define H(value, highlight) do { \ + if (yyextra->highlight_) \ + F(value, highlight); \ +} while (false) + +#define M \ + H(tk::Comment, hi::Comment); + +#define E(message) { \ + CYDriver::Error error; \ + error.location_ = *yylloc; \ + error.message_ = "syntax error, " message; \ + yyextra->errors_.push_back(error); \ + yyterminate(); \ +} + +int X(char c) { + if (c >= '0' && c <= '9') + return c - '0'; + if (c >= 'a' && c <= 'f') + return c - 'a' + 10; + if (c >= 'A' && c <= 'F') + return c - 'A' + 10; + return -1; +} + +template +static void U(Type_ &local, unsigned point) { + if (false) { + } else if (point < 0x000080) { + *local++ = point; + } else if (point < 0x000800) { + *local++ = 0xc0 | point >> 0x06 & 0x1f; + goto one; + } else if (point < 0x010000) { + *local++ = 0xe0 | point >> 0x0c & 0x0f; + goto two; + } else if (point < 0x110000) { + *local++ = 0xf0 | point >> 0x12 & 0x07; + *local++ = 0x80 | point >> 0x0c & 0x3f; + two: + *local++ = 0x80 | point >> 0x06 & 0x3f; + one: + *local++ = 0x80 | point >> 0x00 & 0x3f; + } else _assert(false); +} + +static void U(char *&local, const char *text, yy_size_t &i) { + unsigned point; + + char next(text[++i]); + if (next != '{') { + point = X(text[i + 0]) << 12 | X(text[i + 1]) << 8 | X(text[i + 2]) << 4 | X(text[i + 3]); + i += 3; + } else { + point = 0; + for (;;) { + next = text[++i]; + if (next == '}') + break; + point = (point << 4) | X(next); + } + } + + U(local, point); +} + +#define CYLexBufferPoint(point) do { \ + std::back_insert_iterator > inserter(yyextra->buffer_); \ + U(inserter, point); \ +} while (false) + +#define CYLexBufferUnit(value) do { \ + yyextra->buffer_.push_back(value); \ +} while (false) + +#define CYLexBufferUnits(data, size) do { \ + yyextra->buffer_.insert(yyextra->buffer_.end(), data, data + size); \ +} while (false) + +#define CYLexBufferStart(condition) do { \ + yyextra->buffer_.clear(); \ + yy_push_state(condition, yyscanner); \ +} while (false) + +#define CYLexBufferEnd(type, Type, value, highlight) do { \ + yy_pop_state(yyscanner); \ + I(type, Type(P.strmemdup(yyextra->buffer_.data(), yyextra->buffer_.size()), yyextra->buffer_.size()), value, highlight); \ +} while (false) + +#define YY_INPUT(data, value, size) { \ + if (yyextra->data_.eof()) \ + value = YY_NULL; \ + else { \ + yyextra->data_.read(data, size); \ + size_t copy(yyextra->data_.gcount()); \ + value = copy == 0 ? YY_NULL : copy; \ + } \ +} + +%} + +%option prefix="cy" +%option bison-bridge +%option bison-locations +%option nodefault +%option noyywrap +%option noyylineno +%option nounput +%option nounistd +%option 8bit +%option backup +%option batch +%option never-interactive +%option pointer +%option reentrant +%option stack + +%option full +%option ecs + +U1 [\x00-\x7f] +U0 [\x80-\xbf] +U2 [\xc2-\xdf] +U3 [\xe0-\xef] +U4 [\xf0-\xf4] +UN [\xc0-\xc1\xf5-\xff] + +HexDigit [0-9a-fA-F] +LineTerminatorSequence \r?\n|\r|\xe2\x80[\xa8\xa9] +WhiteSpace [\x09\x0b\x0c\x20]|\xc2\xa0|\xef\xbb\xbf +UnicodeEscape \\u({HexDigit}{4}|\{{HexDigit}+\}) + +@include NotLineTerminator.l +NoneTerminatorCharacter [^\r\n\x80-\xff]|{NotLineTerminator} +RegExCharacter [^/[\\]{-}[\r\n\x80-\xff]|{NotLineTerminator} +RegClsCharacter [^]\\]{-}[\r\n\x80-\xff]|{NotLineTerminator} +CommentCharacter [^*/]{-}[\r\n\x80-\xff]|{NotLineTerminator} +SingleCharacter [^'\\]{-}[\r\n\x80-\xff]|{NotLineTerminator} +DoubleCharacter [^"\\]{-}[\r\n\x80-\xff]|{NotLineTerminator} +PlateCharacter [^$`\\]{-}[\r\n\x80-\xff]|{NotLineTerminator} + +@include UnicodeIDStart.l +@include UnicodeIDContinue.l +IdentifierMore [$_] + +UnicodeStart {IdentifierMore}|{UnicodeIDStart} +UnicodePart {IdentifierMore}|\xe2\x80[\x8c\x8d]|{UnicodeIDContinue} +UnicodeFail {U2}|{U3}|{U3}{U0}|{U4}|{U4}{U0}|{U4}{U0}{U0}|{UN}|{U0} +UnicodeScrap {UnicodePart}*{UnicodeFail}? + +IdentifierStart {UnicodeStart}|{UnicodeEscape} +IdentifierPart {UnicodePart}|{UnicodeEscape} +IdentifierFail {UnicodeFail}|\\(u({HexDigit}{0,3}|\{{HexDigit}*))? +IdentifierScrap {IdentifierPart}*{IdentifierFail}? + +RegularExpressionBackslashSequence \\{NoneTerminatorCharacter} +RegularExpressionClassChars ({RegClsCharacter}|{RegularExpressionBackslashSequence})* + +@begin E4X +XMLNameStart [a-zA-Z_:] +XMLNamePart [a-zA-Z0-9.-_:] +XMLName {XMLNameStart}{XMLNamePart}* +@end + +%x RegularExpression +%x MultiLine + +%x LegacySingleString +%x LegacyDoubleString + +%x StrictSingleString +%x StrictDoubleString +%x StrictAccentString + +%s Div +%s DivOrTemplateTail +%s RegExp +%s RegExpOrTemplateTail + +@begin E4X +%x XMLContent +%x XMLTag +@end + +%% + + /* RegEx {{{ */ +\/ L CYLexBufferStart(RegularExpression); CYLexBufferUnit('/'); + +{ + \/{UnicodePart}* R CYLexBufferUnits(yytext, yyleng); CYLexBufferEnd(literal, RegEx, tk::RegularExpressionLiteral, hi::Constant); + \/{UnicodePart}*{UnicodeFail} R E("invalid flags") + + {RegExCharacter}+ R CYLexBufferUnits(yytext, yyleng); + {RegExCharacter}*{UnicodeFail} R E("invalid character"); + + {RegularExpressionBackslashSequence} R CYLexBufferUnits(yytext, yyleng); + \\{UnicodeFail}? R E("invalid escape") + + "["{RegularExpressionClassChars}"]" R CYLexBufferUnits(yytext, yyleng); + "["{RegularExpressionClassChars}\\? R E("invalid class"); + "["{RegularExpressionClassChars}\\?{UnicodeFail} R E("invalid character"); + "["{RegularExpressionClassChars}\\?{LineTerminatorSequence} R E("invalid newline"); + + (\\|{RegExCharacter}+)?{LineTerminatorSequence} R E("invalid newline"); + <> R E("unterminated regex") +} + /* }}} */ + /* Comment {{{ */ +#![^\n]* L M +\/\/[^\n]* L M + +\/\* L yy_push_state(MultiLine, yyscanner); + +{ + \**\*\/ R yy_pop_state(yyscanner); M N + \**{LineTerminatorSequence} yylloc->end.lines(); yyextra->last_ = true; + \**{CommentCharacter}|\/ R + \**({UnicodeFail}|\*) R E("invalid comment"); + <> R E("invalid comment") +} + /* }}} */ + /* Element {{{ */ +@begin E4X +"<>" L F(tk::LeftRight, hi::Structure); +"" L F(tk::LeftSlashRight, hi::Structure); + +\])*]]> V() F(tk::XMLCDATA, hi::Constant); +\ V() F(tk::XMLComment, hi::Comment); +\])*?> V() F(tk::XMLPI, hi::Meta); + +"=" L F(tk::Equal, hi::Structure); +">" L F(tk::Right, hi::Structure); +"/>" L F(tk::SlashRight, hi::Structure); +"{" L F(tk::OpenBrace, hi::Structure); + +\"(\n|[^"])*\"|'(\n|[^'])*' V() F(tk::XMLAttributeValue, hi::Constant); +{XMLName} L F(tk::XMLName, hi::Identifier); +[ \t\r\n] V() F(tk::XMLWhitespace, hi::Nothing); + +"{" L F(tk::OpenBrace, hi::Structure); +"<" L F(tk::Left, hi::Structure); +"" L F(yyextra->newline_ ? tk::EqualRight_ : tk::EqualRight, hi::Operator); +"!" L F(tk::Exclamation, hi::Operator); +"!=" L F(tk::ExclamationEqual, hi::Operator); +"!==" L F(tk::ExclamationEqualEqual, hi::Operator); +"-" L F(tk::Hyphen, hi::Operator); +"-=" L F(tk::HyphenEqual, hi::Operator); +"--" L F(yyextra->newline_ ? tk::HyphenHyphen_ : tk::HyphenHyphen, hi::Operator); +"->" L F(tk::HyphenRight, hi::Operator); +"<" L F(tk::Left, hi::Operator); +"<=" L F(tk::LeftEqual, hi::Operator); +"<<" L F(tk::LeftLeft, hi::Operator); +"<<=" L F(tk::LeftLeftEqual, hi::Operator); +"%" L F(tk::Percent, hi::Operator); +"%=" L F(tk::PercentEqual, hi::Operator); +"." L F(tk::Period, hi::Operator); +"|" L F(tk::Pipe, hi::Operator); +"|=" L F(tk::PipeEqual, hi::Operator); +"||" L F(tk::PipePipe, hi::Operator); +"+" L F(tk::Plus, hi::Operator); +"+=" L F(tk::PlusEqual, hi::Operator); +"++" L F(yyextra->newline_ ? tk::PlusPlus_ : tk::PlusPlus, hi::Operator); +">" L F(tk::Right, hi::Operator); +">=" L F(tk::RightEqual, hi::Operator); +">>" L F(tk::RightRight, hi::Operator); +">>=" L F(tk::RightRightEqual, hi::Operator); +">>>" L F(tk::RightRightRight, hi::Operator); +">>>=" L F(tk::RightRightRightEqual, hi::Operator); +"*" L F(tk::Star, hi::Operator); +"*=" L F(tk::StarEqual, hi::Operator); +"~" L F(tk::Tilde, hi::Operator); + +"/" L F(tk::Slash, hi::Operator); +"/=" L F(tk::SlashEqual, hi::Operator); + +":" L F(tk::Colon, hi::Structure); +"," L F(tk::Comma, hi::Structure); +"?" L F(tk::Question, hi::Structure); +";" L F(tk::SemiColon, hi::Structure); + +"(" L F(tk::OpenParen, hi::Structure); +")" L F(tk::CloseParen, hi::Structure); + +"{" L yyextra->template_.push(false); F(yyextra->newline_ ? tk::OpenBrace_ : tk::OpenBrace, hi::Structure); +"}" L yyextra->template_.pop(); F(tk::CloseBrace, hi::Structure); + +"[" L F(tk::OpenBracket, hi::Structure); +"]" L F(tk::CloseBracket, hi::Structure); + /* }}} */ + /* Keyword {{{ */ +"@error" L F(tk::At_error_, hi::Error); + +@begin Java +"@class" L F(tk::At_class_, hi::Meta); +@end + +@begin C +"@encode" L F(tk::At_encode_, hi::Meta); +@end + +@begin ObjectiveC +"@end" L F(tk::At_end_, hi::Meta); +"@false" L F(tk::At_false_, hi::Constant); +"@implementation" L F(tk::At_implementation_, hi::Meta); +"@import" L F(tk::At_import_, hi::Special); +"@NO" L F(tk::At_NO_, hi::Constant); +"@null" L F(tk::At_null_, hi::Constant); +"@selector" L F(tk::At_selector_, hi::Meta); +"@true" L F(tk::At_true_, hi::Constant); +"@YES" L F(tk::At_YES_, hi::Constant); +@end + +@({UnicodeStart}{UnicodeScrap}|{UnicodeFail}) L E("invalid keyword") + /* }}} */ + /* Highlight {{{ */ +"undefined" L F(tk::_undefined_, hi::Operator); + +@begin ObjectiveC +"bool" L F(tk::_bool_, hi::Type); +"BOOL" L F(tk::_BOOL_, hi::Type); +"id" L F(tk::_id_, hi::Type); +"nil" L F(tk::_nil_, hi::Constant); +"NULL" L F(tk::_NULL_, hi::Constant); +"SEL" L F(tk::_SEL_, hi::Type); +@end + /* }}} */ + /* Reserved {{{ */ +"abstract" L /*FII*/ F(tk::_abstract_, hi::Meta); +"await" L /*II?*/ F(tk::_await_, hi::Meta); +"boolean" L /*FII*/ F(tk::_boolean_, hi::Type); +"break" L /*KKK*/ F(tk::_break_, hi::Control); +"byte" L /*FII*/ F(tk::_byte_, hi::Type); +"case" L /*KKK*/ F(tk::_case_, hi::Control); +"catch" L /*KKK*/ F(tk::_catch_, hi::Control); +"char" L /*FII*/ F(tk::_char_, hi::Type); +"class" L /*FFK*/ F(tk::_class_, hi::Meta); +"const" L /*FFK*/ F(tk::_const_, hi::Meta); +"continue" L /*KKK*/ F(tk::_continue_, hi::Control); +"debugger" L /*FKK*/ F(tk::_debugger_, hi::Meta); +"default" L /*KKK*/ F(tk::_default_, hi::Control); +"delete" L /*KKK*/ F(tk::_delete_, hi::Operator); +"do" L /*KKK*/ F(tk::_do_, hi::Control); +"double" L /*FII*/ F(tk::_double_, hi::Type); +"else" L /*KKK*/ F(tk::_else_, hi::Control); +"enum" L /*FFF*/ F(tk::_enum_, hi::Meta); +"export" L /*FFK*/ F(tk::_export_, hi::Meta); +"extends" L /*FFK*/ F(tk::_extends_, hi::Meta); +"false" L /*LLL*/ F(tk::_false_, hi::Constant); +"final" L /*FII*/ F(tk::_final_, hi::Meta); +"finally" L /*KKK*/ F(tk::_finally_, hi::Control); +"float" L /*FII*/ F(tk::_float_, hi::Type); +"for" L /*KKK*/ F(tk::_for_, hi::Control); +"from" L /*III*/ F(tk::_from_, hi::Meta); +"function" L /*KKK*/ F(tk::_function_, hi::Meta); +"goto" L /*FII*/ F(tk::_goto_, hi::Control); +"get" L /*III*/ F(tk::_get_, hi::Meta); +"if" L /*KKK*/ F(tk::_if_, hi::Control); +"implements" L /*FSS*/ F(tk::_implements_, hi::Meta); +"import" L /*FFK*/ F(tk::_import_, hi::Meta); +"in" L /*KKK*/ F(yyextra->in_.top() ? tk::_in__ : tk::_in_, hi::Operator); +"instanceof" L /*KKK*/ F(tk::_instanceof_, hi::Operator); +"int" L /*FII*/ F(tk::_int_, hi::Type); +"interface" L /*FSS*/ F(tk::_interface_, hi::Meta); +"let" L /*IS?*/ F(tk::_let_, hi::Meta); +"long" L /*FII*/ F(tk::_long_, hi::Type); +"native" L /*FII*/ F(tk::_native_, hi::Meta); +"new" L /*KKK*/ F(tk::_new_, hi::Operator); +"null" L /*LLL*/ F(tk::_null_, hi::Constant); +"package" L /*FSS*/ F(tk::_package_, hi::Meta); +"private" L /*FSS*/ F(tk::_private_, hi::Meta); +"protected" L /*FSS*/ F(tk::_protected_, hi::Meta); +"public" L /*FSS*/ F(tk::_public_, hi::Meta); +"return" L /*KKK*/ F(yyextra->return_.top() ? tk::_return__ : tk::_return_, hi::Control); +"set" L /*III*/ F(tk::_set_, hi::Meta); +"short" L /*FII*/ F(tk::_short_, hi::Type); +"static" L /*FS?*/ F(tk::_static_, hi::Meta); +"super" L /*FFK*/ F(tk::_super_, hi::Constant); +"switch" L /*KKK*/ F(tk::_switch_, hi::Control); +"synchronized" L /*FII*/ F(tk::_synchronized_, hi::Meta); +"this" L /*KKK*/ F(tk::_this_, hi::Constant); +"throw" L /*KKK*/ F(tk::_throw_, hi::Control); +"throws" L /*FII*/ F(tk::_throws_, hi::Meta); +"transient" L /*FII*/ F(tk::_transient_, hi::Meta); +"true" L /*LLL*/ F(tk::_true_, hi::Constant); +"try" L /*KKK*/ F(tk::_try_, hi::Control); +"typeof" L /*KKK*/ F(tk::_typeof_, hi::Operator); +"var" L /*KKK*/ F(tk::_var_, hi::Meta); +"void" L /*KKK*/ F(tk::_void_, hi::Operator); +"volatile" L /*FII*/ F(tk::_volatile_, hi::Meta); +"while" L /*KKK*/ F(tk::_while_, hi::Control); +"with" L /*KKK*/ F(tk::_with_, hi::Control); +"yield" L /*IS?*/ F(yyextra->yield_.top() ? tk::_yield__ : tk::_yield_, hi::Control); + +"auto" L F(tk::_auto_, hi::Meta); +"each" L F(tk::_each_, hi::Control); +"of" L F(tk::_of_, hi::Operator); + +@begin C +"extern" L F(tk::_extern_, hi::Type); +"signed" L F(tk::_signed_, hi::Type); +"typedef" L F(tk::_typedef_, hi::Meta); +"unsigned" L F(tk::_unsigned_, hi::Type); +@end + +@begin ObjectiveC +"NO" L F(tk::_NO_, hi::Constant); +"YES" L F(tk::_YES_, hi::Constant); +@end + +@begin E4X +"namespace" L F(tk::_namespace_, hi::Meta); +"xml" L F(tk::_xml_, hi::Meta); +@end + /* }}} */ + /* Identifier {{{ */ +{UnicodeStart}{UnicodePart}* L I(identifier, Identifier(Y), tk::Identifier_, hi::Identifier); + +{IdentifierStart}{IdentifierPart}* L { + char *value(A char[yyleng + 1]); + char *local(value); + + for (yy_size_t i(0), e(yyleng); i != e; ++i) { + char next(yytext[i]); + if (next != '\\') + *local++ = next; + else + U(local, yytext, ++i); + } + + *local = '\0'; + I(identifier, Identifier(value), tk::Identifier_, hi::Identifier); +} + +({IdentifierStart}{IdentifierPart}*)?{IdentifierFail} L E("invalid identifier") + /* }}} */ + /* Number {{{ */ +0[0-7]+ L I(number, Number(strtoull(yytext + 1, NULL, 8)), tk::NumericLiteral, hi::Constant); +0[0-9]+ L I(number, Number(strtoull(yytext + 1, NULL, 10)), tk::NumericLiteral, hi::Constant); + +0[xX][0-9a-fA-F]+ L I(number, Number(strtoull(yytext + 2, NULL, 16)), tk::NumericLiteral, hi::Constant); +0[oO][0-7]+ L I(number, Number(strtoull(yytext + 2, NULL, 8)), tk::NumericLiteral, hi::Constant); +0[bB][0-1]+ L I(number, Number(strtoull(yytext + 2, NULL, 2)), tk::NumericLiteral, hi::Constant); + +(\.[0-9]+|(0|[1-9][0-9]*)(\.[0-9]*)?)([eE][+-]?[0-9]+)? L I(number, Number(strtod(yytext, NULL)), tk::NumericLiteral, hi::Constant); +(\.[0-9]+|(0|[1-9][0-9]*)(\.[0-9]*)?)[eE][+-]?{IdentifierScrap} L E("invalid exponent") +(\.?[0-9]|(0|[1-9][0-9]*)\.){IdentifierScrap} L E("invalid number") + /* }}} */ + /* String {{{ */ +\' L CYLexBufferStart(LegacySingleString); +{ + \' R CYLexBufferEnd(string, String, tk::StringLiteral, hi::Constant); + {SingleCharacter}+ R CYLexBufferUnits(yytext, yyleng); + {SingleCharacter}*{UnicodeFail} R E("invalid character"); + {LineTerminatorSequence} R E("invalid newline"); +} + +\" L CYLexBufferStart(LegacyDoubleString); +{ + \" R CYLexBufferEnd(string, String, tk::StringLiteral, hi::Constant); + {DoubleCharacter}+ R CYLexBufferUnits(yytext, yyleng); + {DoubleCharacter}*{UnicodeFail} R E("invalid character"); + {LineTerminatorSequence} R E("invalid newline"); +} + /* }}} */ + /* Template {{{ */ +"`" L yyextra->tail_ = false; CYLexBufferStart(StrictAccentString); +"}" L yyextra->tail_ = true; yyextra->template_.pop(); CYLexBufferStart(StrictAccentString); + +{ + "`" R CYLexBufferEnd(string, String, yyextra->tail_ ? tk::TemplateTail : tk::NoSubstitutionTemplate, hi::Constant); + "${" R yyextra->template_.push(true); CYLexBufferEnd(string, String, yyextra->tail_ ? tk::TemplateMiddle : tk::TemplateHead, hi::Constant); + + "$" R CYLexBufferUnit('$'); + + {PlateCharacter}+ R CYLexBufferUnits(yytext, yyleng); + {PlateCharacter}*{UnicodeFail} R E("invalid character"); + {LineTerminatorSequence} R E("invalid newline"); +} + /* }}} */ + /* Escapes {{{ */ +{ + \\[0-3][0-7][0-7] R CYLexBufferPoint(X(yytext[1]) << 6 | X(yytext[2]) << 3 | X(yytext[3])); + \\[0-7][0-7] R CYLexBufferUnit(X(yytext[1]) << 3 | X(yytext[2])); + \\[0-7] R CYLexBufferUnit(X(yytext[1])); +} + +{ + \\0[0-7] R E("legacy escape"); + \\0 R CYLexBufferUnit('\0'); +} + +{ + \\b R CYLexBufferUnit('\b'); + \\f R CYLexBufferUnit('\f'); + \\n R CYLexBufferUnit('\n'); + \\r R CYLexBufferUnit('\r'); + \\t R CYLexBufferUnit('\t'); + \\v R CYLexBufferUnit('\v'); + + \\x{HexDigit}{2} R CYLexBufferPoint(X(yytext[2]) << 4 | X(yytext[3])); + + \\u{HexDigit}{4} R CYLexBufferPoint(X(yytext[2]) << 12 | X(yytext[3]) << 8 | X(yytext[4]) << 4 | X(yytext[5])); + + \\u\{{HexDigit}+\} R { + unsigned point(0); + for (yy_size_t i(3); i != yyleng - 1; ++i) + point = point << 4 | X(yytext[i]); + CYLexBufferPoint(point); + } + + \\{LineTerminatorSequence} yylloc->end.lines(); + \\(.|{NotLineTerminator}) R CYLexBufferUnits(yytext + 1, yyleng - 1); + + \\(x{HexDigit}{0,1}|u({HexDigit}{0,3}|\{{HexDigit}*)|{UnicodeFail})? R E("invalid escape"); + <> R E("invalid string"); +} + /* }}} */ + +{LineTerminatorSequence} yylloc->step(); yylloc->end.lines(); yyextra->last_ = true; N +{WhiteSpace} L + +<> if (yyextra->auto_) { yyextra->auto_ = false; F(tk::AutoComplete, hi::Nothing); } L yyterminate(); + +. L E("invalid character") + +%% + +void CYDriver::ScannerInit() { + cylex_init(&scanner_); + cyset_extra(this, scanner_); +} + +void CYDriver::ScannerDestroy() { + cylex_destroy(scanner_); +} + +void CYDriver::SetCondition(Condition condition) { + struct yyguts_t *yyg(reinterpret_cast(scanner_)); + + switch (condition) { + case RegExpCondition: + BEGIN(template_.top() ? RegExpOrTemplateTail : 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_); +} + +bool CYLexerHighlight(hi::Value &highlight, CYLocation &location, void *scanner) { + YYSTYPE value; + if (cylex(&value, &location, scanner) == 0) + return false; + highlight = value.highlight_; + return true; +} + +#if defined(__clang__) +#pragma clang diagnostic pop +#else +// must not pop -Wunused-function +//#pragma GCC diagnostic pop +#endif diff --git a/Server.cpp b/Server.cpp index e6415f0..e3f61fc 100644 --- a/Server.cpp +++ b/Server.cpp @@ -19,16 +19,16 @@ **/ /* }}} */ -#include - #include #include -#include -#include #include +#include +#include #include +#include "Pooling.hpp" + struct Client { CFHTTPMessageRef message_; CFSocketRef socket_; diff --git a/String.hpp b/String.hpp index ce48f2c..2f52007 100644 --- a/String.hpp +++ b/String.hpp @@ -22,10 +22,10 @@ #ifndef CYCRIPT_STRING_HPP #define CYCRIPT_STRING_HPP -#include "Pooling.hpp" - #include +#include "Pooling.hpp" + struct CYUTF8String { const char *data; size_t size; diff --git a/Syntax.cpp b/Syntax.cpp new file mode 100644 index 0000000..c2e84e8 --- /dev/null +++ b/Syntax.cpp @@ -0,0 +1,26 @@ +/* Cycript - Optimizing JavaScript Compiler/Runtime + * Copyright (C) 2009-2015 Jay Freeman (saurik) +*/ + +/* GNU Affero General Public License, Version 3 {{{ */ +/* + * This program is free software: you can redistribute it and/or modify + * it under the terms of the GNU Affero General Public License as published by + * the Free Software Foundation, either version 3 of the License, or + * (at your option) any later version. + + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU Affero General Public License for more details. + + * You should have received a copy of the GNU Affero General Public License + * along with this program. If not, see . +**/ +/* }}} */ + +#include "Syntax.hpp" + +CYRange DigitRange_ (0x3ff000000000000LLU, 0x000000000000000LLU); // 0-9 +CYRange WordStartRange_(0x000001000000000LLU, 0x7fffffe87fffffeLLU); // A-Za-z_$ +CYRange WordEndRange_ (0x3ff001000000000LLU, 0x7fffffe87fffffeLLU); // A-Za-z_$0-9 diff --git a/Syntax.hpp b/Syntax.hpp new file mode 100644 index 0000000..3d248d6 --- /dev/null +++ b/Syntax.hpp @@ -0,0 +1,2354 @@ +/* Cycript - Optimizing JavaScript Compiler/Runtime + * Copyright (C) 2009-2015 Jay Freeman (saurik) +*/ + +/* GNU Affero General Public License, Version 3 {{{ */ +/* + * This program is free software: you can redistribute it and/or modify + * it under the terms of the GNU Affero General Public License as published by + * the Free Software Foundation, either version 3 of the License, or + * (at your option) any later version. + + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU Affero General Public License for more details. + + * You should have received a copy of the GNU Affero General Public License + * along with this program. If not, see . +**/ +/* }}} */ + +#ifndef CYCRIPT_SYNTAX_HPP +#define CYCRIPT_SYNTAX_HPP + +#include +#include + +#include +#include +#include +#include +#include + +#include "List.hpp" +#include "Location.hpp" +#include "Options.hpp" +#include "Pooling.hpp" + +struct CYContext; + +struct CYThing { + virtual void Output(struct CYOutput &out) const = 0; +}; + +struct CYOutput { + std::streambuf &out_; + CYPosition position_; + + CYOptions &options_; + bool pretty_; + unsigned indent_; + unsigned recent_; + bool right_; + + enum { + NoMode, + NoLetter, + NoPlus, + NoHyphen, + Terminated + } mode_; + + CYOutput(std::streambuf &out, CYOptions &options) : + out_(out), + options_(options), + pretty_(false), + indent_(0), + recent_(0), + right_(false), + mode_(NoMode) + { + } + + void Check(char value); + void Terminate(); + + _finline void operator ()(char value) { + _assert(out_.sputc(value) != EOF); + recent_ = indent_; + if (value == '\n') + position_.lines(1); + else + position_.columns(1); + } + + _finline void operator ()(const char *data, std::streamsize size) { + _assert(out_.sputn(data, size) == size); + recent_ = indent_; + position_.columns(size); + } + + _finline void operator ()(const char *data) { + return operator ()(data, strlen(data)); + } + + CYOutput &operator <<(char rhs); + CYOutput &operator <<(const char *rhs); + + _finline CYOutput &operator <<(const CYThing *rhs) { + if (rhs != NULL) + rhs->Output(*this); + return *this; + } + + _finline CYOutput &operator <<(const CYThing &rhs) { + rhs.Output(*this); + return *this; + } +}; + +struct CYPropertyName { + virtual void PropertyName(CYOutput &out) const = 0; +}; + +struct CYExpression; +struct CYAssignment; + +enum CYNeeded { + CYNever = -1, + CYSometimes = 0, + CYAlways = 1, +}; + +enum CYFlags { + CYNoFlags = 0, + CYNoBrace = (1 << 0), + CYNoFunction = (1 << 1), + CYNoIn = (1 << 2), + CYNoCall = (1 << 3), + CYNoRightHand = (1 << 4), + CYNoDangle = (1 << 5), + CYNoInteger = (1 << 6), + CYNoBF = (CYNoBrace | CYNoFunction), +}; + +_finline CYFlags operator ~(CYFlags rhs) { + return static_cast(~static_cast(rhs)); +} + +_finline CYFlags operator &(CYFlags lhs, CYFlags rhs) { + return static_cast(static_cast(lhs) & static_cast(rhs)); +} + +_finline CYFlags operator |(CYFlags lhs, CYFlags rhs) { + return static_cast(static_cast(lhs) | static_cast(rhs)); +} + +_finline CYFlags &operator |=(CYFlags &lhs, CYFlags rhs) { + return lhs = lhs | rhs; +} + +_finline CYFlags CYLeft(CYFlags flags) { + return flags & ~(CYNoDangle | CYNoInteger); +} + +_finline CYFlags CYRight(CYFlags flags) { + return flags & ~CYNoBF; +} + +_finline CYFlags CYCenter(CYFlags flags) { + return CYLeft(CYRight(flags)); +} + +enum CYCompactType { + CYCompactNone, + CYCompactLong, + CYCompactShort, +}; + +#define CYCompact(type) \ + virtual CYCompactType Compact() const { \ + return CYCompact ## type; \ + } + +struct CYStatement : + CYNext, + CYThing +{ + void Single(CYOutput &out, CYFlags flags, CYCompactType request) const; + void Multiple(CYOutput &out, CYFlags flags = CYNoFlags) const; + virtual void Output(CYOutput &out) const; + + virtual CYStatement *Replace(CYContext &context) = 0; + + virtual CYCompactType Compact() const = 0; + virtual CYStatement *Return(); + + private: + virtual void Output(CYOutput &out, CYFlags flags) const = 0; +}; + +struct CYStatements { + CYStatement *first_; + CYStatement *last_; + + CYStatements() : + first_(NULL), + last_(NULL) + { + } + + operator CYStatement *() const { + return first_; + } + + CYStatements &operator ->*(CYStatement *next) { + if (next != NULL) + if (first_ == NULL) { + first_ = next; + last_ = next; + } else for (;; last_ = last_->next_) + if (last_->next_ == NULL) { + last_->next_ = next; + last_ = next; + break; + } + return *this; + } +}; + +struct CYClassName { + virtual CYExpression *ClassName(CYContext &context, bool object) = 0; + virtual void ClassName(CYOutput &out, bool object) const = 0; +}; + +struct CYWord : + CYThing, + CYPropertyName, + CYClassName +{ + const char *word_; + + CYWord(const char *word) : + word_(word) + { + } + + void Set(const char *value) { + word_ = value; + } + + virtual const char *Word() const; + virtual void Output(CYOutput &out) const; + + virtual CYExpression *ClassName(CYContext &context, bool object); + virtual void ClassName(CYOutput &out, bool object) const; + virtual void PropertyName(CYOutput &out) const; +}; + +_finline std::ostream &operator <<(std::ostream &lhs, const CYWord &rhs) { + lhs << &rhs << '='; + return lhs << rhs.Word(); +} + +struct CYIdentifier : + CYNext, + CYWord +{ + CYIdentifier *replace_; + size_t offset_; + size_t usage_; + + CYIdentifier(const char *word) : + CYWord(word), + replace_(NULL), + offset_(0), + usage_(0) + { + } + + virtual const char *Word() const; + CYIdentifier *Replace(CYContext &context); +}; + +struct CYLabel : + CYStatement +{ + CYIdentifier *name_; + CYStatement *statement_; + + CYLabel(CYIdentifier *name, CYStatement *statement) : + name_(name), + statement_(statement) + { + } + + CYCompact(Short) + + virtual CYStatement *Replace(CYContext &context); + virtual void Output(CYOutput &out, CYFlags flags) const; +}; + +struct CYCStringLess : + std::binary_function +{ + _finline bool operator ()(const char *lhs, const char *rhs) const { + return strcmp(lhs, rhs) < 0; + } +}; + +struct CYIdentifierValueLess : + std::binary_function +{ + _finline bool operator ()(CYIdentifier *lhs, CYIdentifier *rhs) const { + return CYCStringLess()(lhs->Word(), rhs->Word()); + } +}; + +enum CYIdentifierFlags { + CYIdentifierArgument, + CYIdentifierVariable, + CYIdentifierOther, + CYIdentifierMagic, + CYIdentifierCatch, +}; + +typedef std::set CYCStringSet; +typedef std::set CYIdentifierValueSet; +typedef std::map CYIdentifierAddressFlagsMap; + +struct CYIdentifierUsage { + CYIdentifier *identifier_; + size_t usage_; +}; + +typedef std::vector CYIdentifierUsageVector; + +struct CYScope { + bool transparent_; + CYScope *parent_; + + CYIdentifierAddressFlagsMap internal_; + CYIdentifierValueSet identifiers_; + + CYScope(bool transparent, CYContext &context); + + void Declare(CYContext &context, CYIdentifier *identifier, CYIdentifierFlags flags); + virtual CYIdentifier *Lookup(CYContext &context, CYIdentifier *identifier); + void Merge(CYContext &context, CYIdentifier *identifier); + void Close(CYContext &context, CYStatement *&statements); +}; + +struct CYScript : + CYThing +{ + CYStatement *code_; + + CYScript(CYStatement *code) : + code_(code) + { + } + + virtual void Replace(CYContext &context); + virtual void Output(CYOutput &out) const; +}; + +struct CYNonLocal; +struct CYThisScope; + +struct CYContext { + CYOptions &options_; + + CYScope *scope_; + CYThisScope *this_; + + CYIdentifierUsageVector rename_; + + CYNonLocal *nonlocal_; + CYNonLocal *nextlocal_; + unsigned unique_; + + CYContext(CYOptions &options) : + options_(options), + scope_(NULL), + this_(NULL), + nonlocal_(NULL), + nextlocal_(NULL), + unique_(0) + { + } + + void ReplaceAll(CYStatement *&statement) { + if (statement == NULL) + return; + CYStatement *next(statement->next_); + + Replace(statement); + ReplaceAll(next); + + if (statement == NULL) + statement = next; + else + statement->SetNext(next); + } + + template + void Replace(Type_ *&value) { + for (;;) if (value == NULL) + break; + else { + Type_ *replace(value->Replace(*this)); + if (replace != value) + value = replace; + else break; + } + } + + void NonLocal(CYStatement *&statements); + CYIdentifier *Unique(); +}; + +struct CYNonLocal { + CYIdentifier *identifier_; + + CYNonLocal() : + identifier_(NULL) + { + } + + CYIdentifier *Target(CYContext &context) { + if (identifier_ == NULL) + identifier_ = context.Unique(); + return identifier_; + } +}; + +struct CYThisScope : + CYNext +{ + CYIdentifier *identifier_; + + CYThisScope() : + identifier_(NULL) + { + } + + CYIdentifier *Identifier(CYContext &context) { + if (next_ != NULL) + return next_->Identifier(context); + if (identifier_ == NULL) + identifier_ = context.Unique(); + return identifier_; + } +}; + +struct CYBlock : + CYStatement +{ + CYStatement *code_; + + CYBlock(CYStatement *code) : + code_(code) + { + } + + CYCompact(Short) + + virtual CYStatement *Replace(CYContext &context); + + virtual void Output(CYOutput &out, CYFlags flags) const; + + virtual CYStatement *Return(); +}; + +struct CYForInitializer { + virtual CYExpression *Replace(CYContext &context) = 0; + virtual void Output(CYOutput &out, CYFlags flags) const = 0; +}; + +struct CYForInInitializer { + virtual void ForIn(CYOutput &out, CYFlags flags) const = 0; + virtual CYStatement *ForEachIn(CYContext &out, CYExpression *value) = 0; + + virtual CYExpression *Replace(CYContext &context) = 0; + virtual CYAssignment *Assignment(CYContext &context) = 0; + + virtual void Output(CYOutput &out, CYFlags flags) const = 0; +}; + +struct CYFunctionParameter; + +struct CYNumber; +struct CYString; + +struct CYExpression : + CYForInitializer, + CYForInInitializer, + CYClassName, + CYThing +{ + virtual int Precedence() const = 0; + + virtual bool RightHand() const { + return true; + } + + virtual void ForIn(CYOutput &out, CYFlags flags) const; + virtual CYStatement *ForEachIn(CYContext &out, CYExpression *value); + + virtual CYExpression *AddArgument(CYContext &context, CYExpression *value); + + virtual void Output(CYOutput &out) const; + virtual void Output(CYOutput &out, CYFlags flags) const = 0; + void Output(CYOutput &out, int precedence, CYFlags flags) const; + + virtual CYExpression *ClassName(CYContext &context, bool object); + virtual void ClassName(CYOutput &out, bool object) const; + + virtual CYExpression *Replace(CYContext &context) = 0; + virtual CYAssignment *Assignment(CYContext &context); + + virtual CYExpression *Primitive(CYContext &context) { + return NULL; + } + + virtual CYFunctionParameter *Parameter() const; + + virtual CYNumber *Number(CYContext &context) { + return NULL; + } + + virtual CYString *String(CYContext &context) { + return NULL; + } + + virtual const char *Word() const { + return NULL; + } +}; + +#define CYAlphabetic(value) \ + virtual bool Alphabetic() const { \ + return value; \ + } + +#define CYPrecedence(value) \ + static const int Precedence_ = value; \ + virtual int Precedence() const { \ + return Precedence_; \ + } + +#define CYRightHand(value) \ + virtual bool RightHand() const { \ + return value; \ + } + +struct CYCompound : + CYExpression +{ + CYExpression *expression_; + CYExpression *next_; + + CYCompound(CYExpression *expression, CYExpression *next) : + expression_(expression), + next_(next) + { + _assert(expression_ != NULL); + _assert(next != NULL); + } + + CYPrecedence(17) + + virtual CYExpression *Replace(CYContext &context); + void Output(CYOutput &out, CYFlags flags) const; + + virtual CYFunctionParameter *Parameter() const; +}; + +struct CYParenthetical : + CYExpression +{ + CYExpression *expression_; + + CYParenthetical(CYExpression *expression) : + expression_(expression) + { + } + + CYPrecedence(0) + + virtual CYExpression *Replace(CYContext &context); + void Output(CYOutput &out, CYFlags flags) const; +}; + +struct CYDeclaration; + +struct CYFunctionParameter : + CYNext, + CYThing +{ + CYForInInitializer *initialiser_; + + CYFunctionParameter(CYForInInitializer *initialiser, CYFunctionParameter *next = NULL) : + CYNext(next), + initialiser_(initialiser) + { + } + + void Replace(CYContext &context, CYStatement *&statements); + void Output(CYOutput &out) const; +}; + +struct CYComprehension : + CYNext, + CYThing +{ + CYComprehension(CYComprehension *next = NULL) : + CYNext(next) + { + } + + CYComprehension *Modify(CYComprehension *next) { + next_ = next; + return this; + } + + virtual const char *Name() const = 0; + + virtual CYFunctionParameter *Parameter(CYContext &context) const = 0; + CYFunctionParameter *Parameters(CYContext &context) const; + virtual CYStatement *Replace(CYContext &context, CYStatement *statement) const; + virtual void Output(CYOutput &out) const = 0; +}; + +struct CYForInComprehension : + CYComprehension +{ + CYIdentifier *name_; + CYExpression *set_; + + CYForInComprehension(CYIdentifier *name, CYExpression *set, CYComprehension *next = NULL) : + CYComprehension(next), + name_(name), + set_(set) + { + } + + virtual const char *Name() const { + return name_->Word(); + } + + virtual CYFunctionParameter *Parameter(CYContext &context) const; + virtual CYStatement *Replace(CYContext &context, CYStatement *statement) const; + virtual void Output(CYOutput &out) const; +}; + +struct CYForOfComprehension : + CYComprehension +{ + CYIdentifier *name_; + CYExpression *set_; + + CYForOfComprehension(CYIdentifier *name, CYExpression *set, CYComprehension *next = NULL) : + CYComprehension(next), + name_(name), + set_(set) + { + } + + virtual const char *Name() const { + return name_->Word(); + } + + virtual CYFunctionParameter *Parameter(CYContext &context) const; + virtual CYStatement *Replace(CYContext &context, CYStatement *statement) const; + virtual void Output(CYOutput &out) const; +}; + +struct CYIfComprehension : + CYComprehension +{ + CYExpression *test_; + + CYIfComprehension(CYExpression *test, CYComprehension *next = NULL) : + CYComprehension(next), + test_(test) + { + } + + virtual const char *Name() const { + return NULL; + } + + virtual CYFunctionParameter *Parameter(CYContext &context) const; + virtual CYStatement *Replace(CYContext &context, CYStatement *statement) const; + virtual void Output(CYOutput &out) const; +}; + +struct CYArrayComprehension : + CYExpression +{ + CYExpression *expression_; + CYComprehension *comprehensions_; + + CYArrayComprehension(CYExpression *expression, CYComprehension *comprehensions) : + expression_(expression), + comprehensions_(comprehensions) + { + } + + CYPrecedence(0) + + virtual CYExpression *Replace(CYContext &context); + virtual void Output(CYOutput &out, CYFlags flags) const; +}; + +struct CYLiteral : + CYExpression +{ + CYPrecedence(0) + CYRightHand(false) + + virtual CYExpression *Primitive(CYContext &context) { + return this; + } +}; + +struct CYTrivial : + CYLiteral +{ + virtual CYExpression *Replace(CYContext &context); +}; + +struct CYMagic : + CYExpression +{ + CYPrecedence(0) + CYRightHand(false) +}; + +struct CYRange { + uint64_t lo_; + uint64_t hi_; + + CYRange(uint64_t lo, uint64_t hi) : + lo_(lo), hi_(hi) + { + } + + bool operator [](uint8_t value) const { + return !(value >> 7) && (value >> 6 ? hi_ : lo_) >> (value & 0x3f) & 0x1; + } + + void operator()(uint8_t value) { + if (value >> 7) + return; + (value >> 6 ? hi_ : lo_) |= uint64_t(0x1) << (value & 0x3f); + } +}; + +extern CYRange DigitRange_; +extern CYRange WordStartRange_; +extern CYRange WordEndRange_; + +struct CYString : + CYTrivial, + CYPropertyName +{ + const char *value_; + size_t size_; + + CYString() : + value_(NULL), + size_(0) + { + } + + CYString(const char *value) : + value_(value), + size_(strlen(value)) + { + } + + CYString(const char *value, size_t size) : + value_(value), + size_(size) + { + } + + CYString(const CYWord *word) : + value_(word->Word()), + size_(strlen(value_)) + { + } + + const char *Value() const { + return value_; + } + + virtual const char *Word() const; + + virtual CYNumber *Number(CYContext &context); + virtual CYString *String(CYContext &context); + + CYString *Concat(CYContext &out, CYString *rhs) const; + virtual void Output(CYOutput &out, CYFlags flags) const; + virtual void PropertyName(CYOutput &out) const; +}; + +struct CYElementValue; + +struct CYSpan : + CYNext +{ + CYExpression *expression_; + CYString *string_; + + CYSpan(CYExpression *expression, CYString *string, CYSpan *next) : + CYNext(next), + expression_(expression), + string_(string) + { + } + + CYElementValue *Replace(CYContext &context); +}; + +struct CYTemplate : + CYExpression +{ + CYString *string_; + CYSpan *spans_; + + CYTemplate(CYString *string, CYSpan *spans) : + string_(string), + spans_(spans) + { + } + + CYPrecedence(0) + CYRightHand(false) + + virtual CYExpression *Replace(CYContext &context); + virtual void Output(CYOutput &out, CYFlags flags) const; +}; + +struct CYNumber : + CYTrivial, + CYPropertyName +{ + double value_; + + CYNumber(double value) : + value_(value) + { + } + + double Value() const { + return value_; + } + + virtual CYNumber *Number(CYContext &context); + virtual CYString *String(CYContext &context); + + virtual void Output(CYOutput &out, CYFlags flags) const; + virtual void PropertyName(CYOutput &out) const; +}; + +struct CYRegEx : + CYTrivial +{ + const char *value_; + size_t size_; + + CYRegEx(const char *value, size_t size) : + value_(value), + size_(size) + { + } + + const char *Value() const { + return value_; + } + + virtual void Output(CYOutput &out, CYFlags flags) const; +}; + +struct CYNull : + CYTrivial +{ + virtual CYNumber *Number(CYContext &context); + virtual CYString *String(CYContext &context); + + virtual void Output(CYOutput &out, CYFlags flags) const; +}; + +struct CYThis : + CYMagic +{ + virtual CYExpression *Replace(CYContext &context); + virtual void Output(CYOutput &out, CYFlags flags) const; +}; + +struct CYBoolean : + CYTrivial +{ + virtual bool Value() const = 0; + virtual void Output(CYOutput &out, CYFlags flags) const; +}; + +struct CYFalse : + CYBoolean +{ + virtual bool Value() const { + return false; + } + + virtual CYNumber *Number(CYContext &context); + virtual CYString *String(CYContext &context); +}; + +struct CYTrue : + CYBoolean +{ + virtual bool Value() const { + return true; + } + + virtual CYNumber *Number(CYContext &context); + virtual CYString *String(CYContext &context); +}; + +struct CYVariable : + CYExpression +{ + CYIdentifier *name_; + + CYVariable(CYIdentifier *name) : + name_(name) + { + } + + CYVariable(const char *name) : + name_(new($pool) CYIdentifier(name)) + { + } + + CYPrecedence(0) + CYRightHand(false) + + virtual CYExpression *Replace(CYContext &context); + virtual void Output(CYOutput &out, CYFlags flags) const; + + virtual CYFunctionParameter *Parameter() const; +}; + +struct CYPrefix : + CYExpression +{ + CYExpression *rhs_; + + CYPrefix(CYExpression *rhs) : + rhs_(rhs) + { + } + + virtual bool Alphabetic() const = 0; + virtual const char *Operator() const = 0; + + CYPrecedence(4) + + virtual CYExpression *Replace(CYContext &context); + virtual void Output(CYOutput &out, CYFlags flags) const; +}; + +struct CYInfix : + CYExpression +{ + CYExpression *lhs_; + CYExpression *rhs_; + + CYInfix(CYExpression *lhs, CYExpression *rhs) : + lhs_(lhs), + rhs_(rhs) + { + } + + void SetLeft(CYExpression *lhs) { + lhs_ = lhs; + } + + virtual bool Alphabetic() const = 0; + virtual const char *Operator() const = 0; + + virtual CYExpression *Replace(CYContext &context); + virtual void Output(CYOutput &out, CYFlags flags) const; +}; + +struct CYPostfix : + CYExpression +{ + CYExpression *lhs_; + + CYPostfix(CYExpression *lhs) : + lhs_(lhs) + { + } + + virtual const char *Operator() const = 0; + + CYPrecedence(3) + + virtual CYExpression *Replace(CYContext &context); + virtual void Output(CYOutput &out, CYFlags flags) const; +}; + +struct CYAssignment : + CYExpression +{ + CYExpression *lhs_; + CYExpression *rhs_; + + CYAssignment(CYExpression *lhs, CYExpression *rhs) : + lhs_(lhs), + rhs_(rhs) + { + } + + void SetLeft(CYExpression *lhs) { + lhs_ = lhs; + } + + virtual const char *Operator() const = 0; + + CYPrecedence(16) + + virtual CYExpression *Replace(CYContext &context); + virtual void Output(CYOutput &out, CYFlags flags) const; +}; + +struct CYArgument : + CYNext, + CYThing +{ + CYWord *name_; + CYExpression *value_; + + CYArgument(CYExpression *value, CYArgument *next = NULL) : + CYNext(next), + name_(NULL), + value_(value) + { + } + + CYArgument(CYWord *name, CYExpression *value, CYArgument *next = NULL) : + CYNext(next), + name_(name), + value_(value) + { + } + + CYArgument *Replace(CYContext &context); + void Output(CYOutput &out) const; +}; + +struct CYClause : + CYThing, + CYNext +{ + CYExpression *case_; + CYStatement *code_; + + CYClause(CYExpression *_case, CYStatement *code) : + case_(_case), + code_(code) + { + } + + void Replace(CYContext &context); + virtual void Output(CYOutput &out) const; +}; + +struct CYElement : + CYThing +{ + virtual bool Elision() const = 0; + + virtual void Replace(CYContext &context) = 0; +}; + +struct CYElementValue : + CYNext, + CYElement +{ + CYExpression *value_; + + CYElementValue(CYExpression *value, CYElement *next) : + CYNext(next), + value_(value) + { + } + + virtual bool Elision() const { + return value_ == NULL; + } + + virtual void Replace(CYContext &context); + virtual void Output(CYOutput &out) const; +}; + +struct CYElementSpread : + CYElement +{ + CYExpression *value_; + + CYElementSpread(CYExpression *value) : + value_(value) + { + } + + virtual bool Elision() const { + return false; + } + + virtual void Replace(CYContext &context); + virtual void Output(CYOutput &out) const; +}; + +struct CYArray : + CYLiteral +{ + CYElement *elements_; + + CYArray(CYElement *elements = NULL) : + elements_(elements) + { + } + + virtual CYExpression *Replace(CYContext &context); + virtual void Output(CYOutput &out, CYFlags flags) const; +}; + +struct CYProperty : + CYNext, + CYThing +{ + CYPropertyName *name_; + CYExpression *value_; + + CYProperty(CYPropertyName *name, CYExpression *value, CYProperty *next = NULL) : + CYNext(next), + name_(name), + value_(value) + { + } + + void Replace(CYContext &context); + virtual void Output(CYOutput &out) const; +}; + +struct CYDeclaration : + CYForInInitializer +{ + CYIdentifier *identifier_; + CYExpression *initialiser_; + + CYDeclaration(CYIdentifier *identifier, CYExpression *initialiser = NULL) : + identifier_(identifier), + initialiser_(initialiser) + { + } + + virtual void ForIn(CYOutput &out, CYFlags flags) const; + virtual CYStatement *ForEachIn(CYContext &out, CYExpression *value); + + virtual CYExpression *Replace(CYContext &context); + + virtual CYAssignment *Assignment(CYContext &context); + CYVariable *Variable(CYContext &context); + + virtual void Output(CYOutput &out, CYFlags flags) const; +}; + +struct CYDeclarations : + CYNext, + CYThing +{ + CYDeclaration *declaration_; + + CYDeclarations(CYDeclaration *declaration, CYDeclarations *next = NULL) : + CYNext(next), + declaration_(declaration) + { + } + + void Replace(CYContext &context); + + CYExpression *Expression(CYContext &context); + CYProperty *Property(CYContext &context); + CYArgument *Argument(CYContext &context); + CYFunctionParameter *Parameter(CYContext &context); + + virtual void Output(CYOutput &out) const; + virtual void Output(CYOutput &out, CYFlags flags) const; +}; + +struct CYForDeclarations : + CYForInitializer +{ + CYDeclarations *declarations_; + + CYForDeclarations(CYDeclarations *declarations) : + declarations_(declarations) + { + } + + virtual CYExpression *Replace(CYContext &context); + virtual void Output(CYOutput &out, CYFlags flags) const; +}; + +struct CYVar : + CYStatement +{ + CYDeclarations *declarations_; + + CYVar(CYDeclarations *declarations) : + declarations_(declarations) + { + } + + CYCompact(None) + + virtual CYStatement *Replace(CYContext &context); + virtual void Output(CYOutput &out, CYFlags flags) const; +}; + +struct CYLetStatement : + CYStatement +{ + CYDeclarations *declarations_; + CYStatement *code_; + + CYLetStatement(CYDeclarations *declarations, CYStatement *code) : + declarations_(declarations), + code_(code) + { + } + + CYCompact(Long) + + virtual CYStatement *Replace(CYContext &context); + virtual void Output(CYOutput &out, CYFlags flags) const; +}; + +struct CYFor : + CYStatement +{ + CYForInitializer *initialiser_; + CYExpression *test_; + CYExpression *increment_; + CYStatement *code_; + + CYFor(CYForInitializer *initialiser, CYExpression *test, CYExpression *increment, CYStatement *code) : + initialiser_(initialiser), + test_(test), + increment_(increment), + code_(code) + { + } + + CYCompact(Long) + + virtual CYStatement *Replace(CYContext &context); + virtual void Output(CYOutput &out, CYFlags flags) const; +}; + +struct CYForIn : + CYStatement +{ + CYForInInitializer *initialiser_; + CYExpression *set_; + CYStatement *code_; + + CYForIn(CYForInInitializer *initialiser, CYExpression *set, CYStatement *code) : + initialiser_(initialiser), + set_(set), + code_(code) + { + } + + CYCompact(Long) + + virtual CYStatement *Replace(CYContext &context); + virtual void Output(CYOutput &out, CYFlags flags) const; +}; + +struct CYForOf : + CYStatement +{ + CYForInInitializer *initialiser_; + CYExpression *set_; + CYStatement *code_; + + CYForOf(CYForInInitializer *initialiser, CYExpression *set, CYStatement *code) : + initialiser_(initialiser), + set_(set), + code_(code) + { + } + + CYCompact(Long) + + virtual CYStatement *Replace(CYContext &context); + virtual void Output(CYOutput &out, CYFlags flags) const; +}; + +struct CYObject : + CYLiteral +{ + CYProperty *properties_; + + CYObject(CYProperty *properties = NULL) : + properties_(properties) + { + } + + virtual CYExpression *Replace(CYContext &context); + void Output(CYOutput &out, CYFlags flags) const; +}; + +struct CYMember : + CYExpression +{ + CYExpression *object_; + CYExpression *property_; + + CYMember(CYExpression *object, CYExpression *property) : + object_(object), + property_(property) + { + } + + void SetLeft(CYExpression *object) { + object_ = object; + } +}; + +struct CYDirectMember : + CYMember +{ + CYDirectMember(CYExpression *object, CYExpression *property) : + CYMember(object, property) + { + } + + CYPrecedence(1) + CYRightHand(false) + + virtual CYExpression *Replace(CYContext &context); + virtual void Output(CYOutput &out, CYFlags flags) const; +}; + +struct CYIndirectMember : + CYMember +{ + CYIndirectMember(CYExpression *object, CYExpression *property) : + CYMember(object, property) + { + } + + CYPrecedence(1) + CYRightHand(false) + + virtual CYExpression *Replace(CYContext &context); + virtual void Output(CYOutput &out, CYFlags flags) const; +}; + +namespace cy { +namespace Syntax { + +struct New : + CYExpression +{ + CYExpression *constructor_; + CYArgument *arguments_; + + New(CYExpression *constructor, CYArgument *arguments) : + constructor_(constructor), + arguments_(arguments) + { + } + + virtual int Precedence() const { + return arguments_ == NULL ? 2 : 1; + } + + CYRightHand(false) + + virtual CYExpression *Replace(CYContext &context); + virtual void Output(CYOutput &out, CYFlags flags) const; + + virtual CYExpression *AddArgument(CYContext &context, CYExpression *value); +}; + +} } + +struct CYCall : + CYExpression +{ + CYExpression *function_; + CYArgument *arguments_; + + CYCall(CYExpression *function, CYArgument *arguments = NULL) : + function_(function), + arguments_(arguments) + { + } + + CYPrecedence(1) + CYRightHand(false) + + virtual CYExpression *Replace(CYContext &context); + virtual void Output(CYOutput &out, CYFlags flags) const; + + virtual CYExpression *AddArgument(CYContext &context, CYExpression *value); +}; + +struct CYRubyProc; + +struct CYRubyBlock : + CYExpression +{ + CYExpression *call_; + CYRubyProc *proc_; + + CYRubyBlock(CYExpression *call, CYRubyProc *proc) : + call_(call), + proc_(proc) + { + } + + CYPrecedence(1) + CYRightHand(false) + + virtual CYExpression *Replace(CYContext &context); + virtual void Output(CYOutput &out, CYFlags flags) const; +}; + +struct CYIf : + CYStatement +{ + CYExpression *test_; + CYStatement *true_; + CYStatement *false_; + + CYIf(CYExpression *test, CYStatement *_true, CYStatement *_false = NULL) : + test_(test), + true_(_true), + false_(_false) + { + } + + CYCompact(Long) + + virtual CYStatement *Replace(CYContext &context); + virtual void Output(CYOutput &out, CYFlags flags) const; + + virtual CYStatement *Return(); +}; + +struct CYDoWhile : + CYStatement +{ + CYExpression *test_; + CYStatement *code_; + + CYDoWhile(CYExpression *test, CYStatement *code) : + test_(test), + code_(code) + { + } + + CYCompact(None) + + virtual CYStatement *Replace(CYContext &context); + virtual void Output(CYOutput &out, CYFlags flags) const; +}; + +struct CYWhile : + CYStatement +{ + CYExpression *test_; + CYStatement *code_; + + CYWhile(CYExpression *test, CYStatement *code) : + test_(test), + code_(code) + { + } + + CYCompact(Long) + + virtual CYStatement *Replace(CYContext &context); + virtual void Output(CYOutput &out, CYFlags flags) const; +}; + +// XXX: this should be split up into CYAnonymousFunction and CYNamedFunction (subclass) +struct CYFunction { + CYIdentifier *name_; + CYFunctionParameter *parameters_; + CYStatement *code_; + + CYNonLocal *nonlocal_; + bool implicit_; + CYThisScope this_; + + CYFunction(CYIdentifier *name, CYFunctionParameter *parameters, CYStatement *code) : + name_(name), + parameters_(parameters), + code_(code), + nonlocal_(NULL), + implicit_(false) + { + } + + void Inject(CYContext &context); + virtual void Replace_(CYContext &context, bool outer); + virtual void Output(CYOutput &out, CYFlags flags) const; +}; + +// XXX: this should be split up into CYAnonymousFunctionExpression and CYNamedFunctionExpression +struct CYFunctionExpression : + CYFunction, + CYExpression +{ + CYFunctionExpression(CYIdentifier *name, CYFunctionParameter *parameters, CYStatement *code) : + CYFunction(name, parameters, code) + { + } + + CYPrecedence(0) + CYRightHand(false) + + virtual CYExpression *Replace(CYContext &context); + virtual void Output(CYOutput &out, CYFlags flags) const; +}; + +// XXX: this should derive from CYAnonymousFunction +struct CYFatArrow : + CYFunction, + CYExpression +{ + CYFatArrow(CYFunctionParameter *parameters, CYStatement *code) : + CYFunction(NULL, parameters, code) + { + } + + CYPrecedence(0) + CYRightHand(false) + + virtual CYExpression *Replace(CYContext &context); + virtual void Output(CYOutput &out, CYFlags flags) const; +}; + +// XXX: this should derive from CYAnonymousFunctionExpression +struct CYRubyProc : + CYFunctionExpression +{ + CYRubyProc(CYFunctionParameter *parameters, CYStatement *code) : + CYFunctionExpression(NULL, parameters, code) + { + } + + virtual CYExpression *Replace(CYContext &context); + virtual void Output(CYOutput &out, CYFlags flags) const; +}; + +// XXX: this should derive from CYNamedFunction +struct CYFunctionStatement : + CYFunction, + CYStatement +{ + CYFunctionStatement(CYIdentifier *name, CYFunctionParameter *parameters, CYStatement *code) : + CYFunction(name, parameters, code) + { + } + + CYCompact(None) + + virtual CYStatement *Replace(CYContext &context); + virtual void Output(CYOutput &out, CYFlags flags) const; +}; + +struct CYExpress : + CYStatement +{ + CYExpression *expression_; + + CYExpress(CYExpression *expression) : + expression_(expression) + { + if (expression_ == NULL) + throw; + } + + CYCompact(None) + + virtual CYStatement *Replace(CYContext &context); + virtual void Output(CYOutput &out, CYFlags flags) const; + + virtual CYStatement *Return(); +}; + +struct CYContinue : + CYStatement +{ + CYIdentifier *label_; + + CYContinue(CYIdentifier *label) : + label_(label) + { + } + + CYCompact(Short) + + virtual CYStatement *Replace(CYContext &context); + virtual void Output(CYOutput &out, CYFlags flags) const; +}; + +struct CYBreak : + CYStatement +{ + CYIdentifier *label_; + + CYBreak(CYIdentifier *label) : + label_(label) + { + } + + CYCompact(Short) + + virtual CYStatement *Replace(CYContext &context); + virtual void Output(CYOutput &out, CYFlags flags) const; +}; + +struct CYReturn : + CYStatement +{ + CYExpression *value_; + + CYReturn(CYExpression *value) : + value_(value) + { + } + + CYCompact(None) + + virtual CYStatement *Replace(CYContext &context); + virtual void Output(CYOutput &out, CYFlags flags) const; +}; + +struct CYYieldGenerator : + CYExpression +{ + CYExpression *value_; + + CYYieldGenerator(CYExpression *value) : + value_(value) + { + } + + CYPrecedence(0) + + virtual CYExpression *Replace(CYContext &context); + virtual void Output(CYOutput &out, CYFlags flags) const; +}; + +struct CYYieldValue : + CYExpression +{ + CYExpression *value_; + + CYYieldValue(CYExpression *value) : + value_(value) + { + } + + CYPrecedence(0) + + virtual CYExpression *Replace(CYContext &context); + virtual void Output(CYOutput &out, CYFlags flags) const; +}; + +struct CYEmpty : + CYStatement +{ + CYCompact(Short) + + virtual CYStatement *Replace(CYContext &context); + virtual void Output(CYOutput &out, CYFlags flags) const; +}; + +struct CYFinally : + CYThing +{ + CYStatement *code_; + + CYFinally(CYStatement *code) : + code_(code) + { + } + + void Replace(CYContext &context); + virtual void Output(CYOutput &out) const; +}; + +struct CYTypeSpecifier : + CYThing +{ + virtual CYExpression *Replace(CYContext &context) = 0; +}; + +struct CYTypeError : + CYTypeSpecifier +{ + CYTypeError() { + } + + virtual CYExpression *Replace(CYContext &context); + virtual void Output(CYOutput &out) const; +}; + +struct CYTypeVoid : + CYTypeSpecifier +{ + CYTypeVoid() { + } + + virtual CYExpression *Replace(CYContext &context); + virtual void Output(CYOutput &out) const; +}; + +struct CYTypeVariable : + CYTypeSpecifier +{ + CYIdentifier *name_; + + CYTypeVariable(CYIdentifier *name) : + name_(name) + { + } + + CYTypeVariable(const char *name) : + name_(new($pool) CYIdentifier(name)) + { + } + + virtual CYExpression *Replace(CYContext &context); + virtual void Output(CYOutput &out) const; +}; + +struct CYTypeUnsigned : + CYTypeSpecifier +{ + CYTypeSpecifier *specifier_; + + CYTypeUnsigned(CYTypeSpecifier *specifier) : + specifier_(specifier) + { + } + + virtual CYExpression *Replace(CYContext &context); + virtual void Output(CYOutput &out) const; +}; + +struct CYTypeSigned : + CYTypeSpecifier +{ + CYTypeSpecifier *specifier_; + + CYTypeSigned(CYTypeSpecifier *specifier) : + specifier_(specifier) + { + } + + virtual CYExpression *Replace(CYContext &context); + virtual void Output(CYOutput &out) const; +}; + +struct CYTypeLong : + CYTypeSpecifier +{ + CYTypeSpecifier *specifier_; + + CYTypeLong(CYTypeSpecifier *specifier) : + specifier_(specifier) + { + } + + virtual CYExpression *Replace(CYContext &context); + virtual void Output(CYOutput &out) const; +}; + +struct CYTypeShort : + CYTypeSpecifier +{ + CYTypeSpecifier *specifier_; + + CYTypeShort(CYTypeSpecifier *specifier) : + specifier_(specifier) + { + } + + virtual CYExpression *Replace(CYContext &context); + virtual void Output(CYOutput &out) const; +}; + +struct CYTypeFunctionWith; + +struct CYTypeModifier : + CYNext +{ + CYTypeModifier(CYTypeModifier *next) : + CYNext(next) + { + } + + virtual int Precedence() const = 0; + + virtual CYExpression *Replace_(CYContext &context, CYExpression *type) = 0; + CYExpression *Replace(CYContext &context, CYExpression *type); + + virtual void Output(CYOutput &out, CYIdentifier *identifier) const = 0; + void Output(CYOutput &out, int precedence, CYIdentifier *identifier) const; + + virtual CYTypeFunctionWith *Function() { return NULL; } +}; + +struct CYTypeArrayOf : + CYTypeModifier +{ + CYExpression *size_; + + CYTypeArrayOf(CYExpression *size, CYTypeModifier *next = NULL) : + CYTypeModifier(next), + size_(size) + { + } + + CYPrecedence(1) + + virtual CYExpression *Replace_(CYContext &context, CYExpression *type); + virtual void Output(CYOutput &out, CYIdentifier *identifier) const; +}; + +struct CYTypeConstant : + CYTypeModifier +{ + CYTypeConstant(CYTypeModifier *next = NULL) : + CYTypeModifier(next) + { + } + + CYPrecedence(0) + + virtual CYExpression *Replace_(CYContext &context, CYExpression *type); + virtual void Output(CYOutput &out, CYIdentifier *identifier) const; +}; + +struct CYTypePointerTo : + CYTypeModifier +{ + CYTypePointerTo(CYTypeModifier *next = NULL) : + CYTypeModifier(next) + { + } + + CYPrecedence(0) + + virtual CYExpression *Replace_(CYContext &context, CYExpression *type); + virtual void Output(CYOutput &out, CYIdentifier *identifier) const; +}; + +struct CYTypeVolatile : + CYTypeModifier +{ + CYTypeVolatile(CYTypeModifier *next = NULL) : + CYTypeModifier(next) + { + } + + CYPrecedence(0) + + virtual CYExpression *Replace_(CYContext &context, CYExpression *type); + virtual void Output(CYOutput &out, CYIdentifier *identifier) const; +}; + +struct CYTypedIdentifier : + CYNext, + CYThing +{ + CYLocation location_; + CYIdentifier *identifier_; + CYTypeSpecifier *specifier_; + CYTypeModifier *modifier_; + + CYTypedIdentifier(const CYLocation &location, CYIdentifier *identifier = NULL) : + location_(location), + identifier_(identifier), + specifier_(NULL), + modifier_(NULL) + { + } + + CYTypedIdentifier(CYTypeSpecifier *specifier, CYTypeModifier *modifier = NULL) : + identifier_(NULL), + specifier_(specifier), + modifier_(modifier) + { + } + + inline CYTypedIdentifier *Modify(CYTypeModifier *modifier) { + CYSetLast(modifier_) = modifier; + return this; + } + + virtual CYExpression *Replace(CYContext &context); + virtual void Output(CYOutput &out) const; + + CYTypeFunctionWith *Function(); +}; + +struct CYEncodedType : + CYExpression +{ + CYTypedIdentifier *typed_; + + CYEncodedType(CYTypedIdentifier *typed) : + typed_(typed) + { + } + + CYPrecedence(1) + + virtual CYExpression *Replace(CYContext &context); + virtual void Output(CYOutput &out, CYFlags flags) const; +}; + +struct CYTypedParameter : + CYNext, + CYThing +{ + CYTypedIdentifier *typed_; + + CYTypedParameter(CYTypedIdentifier *typed, CYTypedParameter *next) : + CYNext(next), + typed_(typed) + { + } + + CYArgument *Argument(CYContext &context); + CYFunctionParameter *Parameters(CYContext &context); + CYExpression *TypeSignature(CYContext &context, CYExpression *prefix); + + virtual void Output(CYOutput &out) const; +}; + +struct CYLambda : + CYExpression +{ + CYTypedIdentifier *typed_; + CYTypedParameter *parameters_; + CYStatement *code_; + + CYLambda(CYTypedIdentifier *typed, CYTypedParameter *parameters, CYStatement *code) : + typed_(typed), + parameters_(parameters), + code_(code) + { + } + + CYPrecedence(1) + + virtual CYExpression *Replace(CYContext &context); + virtual void Output(CYOutput &out, CYFlags flags) const; +}; + +struct CYModule : + CYNext, + CYThing +{ + CYWord *part_; + + CYModule(CYWord *part, CYModule *next = NULL) : + CYNext(next), + part_(part) + { + } + + CYString *Replace(CYContext &context, const char *separator) const; + void Output(CYOutput &out) const; +}; + +struct CYImport : + CYStatement +{ + CYModule *module_; + + CYImport(CYModule *module) : + module_(module) + { + } + + CYCompact(None) + + virtual CYStatement *Replace(CYContext &context); + virtual void Output(CYOutput &out, CYFlags flags) const; +}; + +struct CYExternal : + CYStatement +{ + CYString *abi_; + CYTypedIdentifier *typed_; + + CYExternal(CYString *abi, CYTypedIdentifier *typed) : + abi_(abi), + typed_(typed) + { + } + + CYCompact(None) + + virtual CYStatement *Replace(CYContext &context); + virtual void Output(CYOutput &out, CYFlags flags) const; +}; + +struct CYTypeDefinition : + CYStatement +{ + CYTypedIdentifier *typed_; + + CYTypeDefinition(CYTypedIdentifier *typed) : + typed_(typed) + { + } + + CYCompact(None) + + virtual CYStatement *Replace(CYContext &context); + virtual void Output(CYOutput &out, CYFlags flags) const; +}; + +struct CYTypeBlockWith : + CYTypeModifier +{ + CYTypedParameter *parameters_; + + CYTypeBlockWith(CYTypedParameter *parameters, CYTypeModifier *next = NULL) : + CYTypeModifier(next), + parameters_(parameters) + { + } + + CYPrecedence(0) + + virtual CYExpression *Replace_(CYContext &context, CYExpression *type); + virtual void Output(CYOutput &out, CYIdentifier *identifier) const; +}; + +struct CYTypeFunctionWith : + CYTypeModifier +{ + CYTypedParameter *parameters_; + + CYTypeFunctionWith(CYTypedParameter *parameters, CYTypeModifier *next = NULL) : + CYTypeModifier(next), + parameters_(parameters) + { + } + + CYPrecedence(1) + + virtual CYExpression *Replace_(CYContext &context, CYExpression *type); + virtual void Output(CYOutput &out, CYIdentifier *identifier) const; + + virtual CYTypeFunctionWith *Function() { return this; } +}; + +namespace cy { +namespace Syntax { + +struct Catch : + CYThing +{ + CYIdentifier *name_; + CYStatement *code_; + + Catch(CYIdentifier *name, CYStatement *code) : + name_(name), + code_(code) + { + } + + void Replace(CYContext &context); + virtual void Output(CYOutput &out) const; +}; + +struct Try : + CYStatement +{ + CYStatement *code_; + Catch *catch_; + CYFinally *finally_; + + Try(CYStatement *code, Catch *_catch, CYFinally *finally) : + code_(code), + catch_(_catch), + finally_(finally) + { + } + + CYCompact(Short) + + virtual CYStatement *Replace(CYContext &context); + virtual void Output(CYOutput &out, CYFlags flags) const; +}; + +struct Throw : + CYStatement +{ + CYExpression *value_; + + Throw(CYExpression *value = NULL) : + value_(value) + { + } + + CYCompact(None) + + virtual CYStatement *Replace(CYContext &context); + virtual void Output(CYOutput &out, CYFlags flags) const; +}; + +} } + +struct CYWith : + CYStatement +{ + CYExpression *scope_; + CYStatement *code_; + + CYWith(CYExpression *scope, CYStatement *code) : + scope_(scope), + code_(code) + { + } + + CYCompact(Long) + + virtual CYStatement *Replace(CYContext &context); + virtual void Output(CYOutput &out, CYFlags flags) const; +}; + +struct CYSwitch : + CYStatement +{ + CYExpression *value_; + CYClause *clauses_; + + CYSwitch(CYExpression *value, CYClause *clauses) : + value_(value), + clauses_(clauses) + { + } + + CYCompact(Long) + + virtual CYStatement *Replace(CYContext &context); + virtual void Output(CYOutput &out, CYFlags flags) const; +}; + +struct CYDebugger : + CYStatement +{ + CYDebugger() + { + } + + CYCompact(None) + + virtual CYStatement *Replace(CYContext &context); + virtual void Output(CYOutput &out, CYFlags flags) const; +}; + +struct CYCondition : + CYExpression +{ + CYExpression *test_; + CYExpression *true_; + CYExpression *false_; + + CYCondition(CYExpression *test, CYExpression *_true, CYExpression *_false) : + test_(test), + true_(_true), + false_(_false) + { + } + + CYPrecedence(15) + + virtual CYExpression *Replace(CYContext &context); + virtual void Output(CYOutput &out, CYFlags flags) const; +}; + +struct CYAddressOf : + CYPrefix +{ + CYAddressOf(CYExpression *rhs) : + CYPrefix(rhs) + { + } + + virtual const char *Operator() const { + return "&"; + } + + CYAlphabetic(false) + + virtual CYExpression *Replace(CYContext &context); +}; + +struct CYIndirect : + CYPrefix +{ + CYIndirect(CYExpression *rhs) : + CYPrefix(rhs) + { + } + + virtual const char *Operator() const { + return "*"; + } + + CYAlphabetic(false) + + virtual CYExpression *Replace(CYContext &context); +}; + +#define CYReplace \ + virtual CYExpression *Replace(CYContext &context); + +#define CYPostfix_(op, name, args...) \ + struct CY ## name : \ + CYPostfix \ + { args \ + CY ## name(CYExpression *lhs) : \ + CYPostfix(lhs) \ + { \ + } \ + \ + virtual const char *Operator() const { \ + return op; \ + } \ + }; + +#define CYPrefix_(alphabetic, op, name, args...) \ + struct CY ## name : \ + CYPrefix \ + { args \ + CY ## name(CYExpression *rhs) : \ + CYPrefix(rhs) \ + { \ + } \ + \ + CYAlphabetic(alphabetic) \ + \ + virtual const char *Operator() const { \ + return op; \ + } \ + }; + +#define CYInfix_(alphabetic, precedence, op, name, args...) \ + struct CY ## name : \ + CYInfix \ + { args \ + CY ## name(CYExpression *lhs, CYExpression *rhs) : \ + CYInfix(lhs, rhs) \ + { \ + } \ + \ + CYAlphabetic(alphabetic) \ + CYPrecedence(precedence) \ + \ + virtual const char *Operator() const { \ + return op; \ + } \ + }; + +#define CYAssignment_(op, name, args...) \ + struct CY ## name ## Assign : \ + CYAssignment \ + { args \ + CY ## name ## Assign(CYExpression *lhs, CYExpression *rhs) : \ + CYAssignment(lhs, rhs) \ + { \ + } \ + \ + virtual const char *Operator() const { \ + return op; \ + } \ + }; + +CYPostfix_("++", PostIncrement) +CYPostfix_("--", PostDecrement) + +CYPrefix_(true, "delete", Delete) +CYPrefix_(true, "void", Void) +CYPrefix_(true, "typeof", TypeOf) +CYPrefix_(false, "++", PreIncrement) +CYPrefix_(false, "--", PreDecrement) +CYPrefix_(false, "+", Affirm) +CYPrefix_(false, "-", Negate) +CYPrefix_(false, "~", BitwiseNot) +CYPrefix_(false, "!", LogicalNot) + +CYInfix_(false, 5, "*", Multiply, CYReplace) +CYInfix_(false, 5, "/", Divide) +CYInfix_(false, 5, "%", Modulus) +CYInfix_(false, 6, "+", Add, CYReplace) +CYInfix_(false, 6, "-", Subtract) +CYInfix_(false, 7, "<<", ShiftLeft) +CYInfix_(false, 7, ">>", ShiftRightSigned) +CYInfix_(false, 7, ">>>", ShiftRightUnsigned) +CYInfix_(false, 8, "<", Less) +CYInfix_(false, 8, ">", Greater) +CYInfix_(false, 8, "<=", LessOrEqual) +CYInfix_(false, 8, ">=", GreaterOrEqual) +CYInfix_(true, 8, "instanceof", InstanceOf) +CYInfix_(true, 8, "in", In) +CYInfix_(false, 9, "==", Equal) +CYInfix_(false, 9, "!=", NotEqual) +CYInfix_(false, 9, "===", Identical) +CYInfix_(false, 9, "!==", NotIdentical) +CYInfix_(false, 10, "&", BitwiseAnd) +CYInfix_(false, 11, "^", BitwiseXOr) +CYInfix_(false, 12, "|", BitwiseOr) +CYInfix_(false, 13, "&&", LogicalAnd) +CYInfix_(false, 14, "||", LogicalOr) + +CYAssignment_("=", ) +CYAssignment_("*=", Multiply) +CYAssignment_("/=", Divide) +CYAssignment_("%=", Modulus) +CYAssignment_("+=", Add) +CYAssignment_("-=", Subtract) +CYAssignment_("<<=", ShiftLeft) +CYAssignment_(">>=", ShiftRightSigned) +CYAssignment_(">>>=", ShiftRightUnsigned) +CYAssignment_("&=", BitwiseAnd) +CYAssignment_("^=", BitwiseXOr) +CYAssignment_("|=", BitwiseOr) + +#endif/*CYCRIPT_PARSER_HPP*/ diff --git a/backtrack.sh b/backtrack.sh index 20b250f..6ad3f07 100755 --- a/backtrack.sh +++ b/backtrack.sh @@ -1,5 +1,5 @@ #!/bin/bash ./apple-make.sh build-osx-i386 echo "backup $(grep -c '^State ' build.osx-i386/lex.backup)" -echo "states $(grep '^static .* yy_accept\[' build.osx-i386/lex.cy.cpp | sed -e 's/.*\[//;s/].*//') 3528" -echo "jammed $(grep -F 'accepts: ['"$(grep 'jammed' build.osx-i386/lex.cy.cpp -B 3 | head -n 1 | sed -e 's/:$//;s/.* //')"']' build.osx-i386/lex.output | sed -e 's/.* # //;s/ .*//')" +echo "states $(grep '^static .* yy_accept\[' build.osx-i386/Scanner.cpp | sed -e 's/.*\[//;s/].*//') 3528" +echo "jammed $(grep -F 'accepts: ['"$(grep 'jammed' build.osx-i386/Scanner.cpp -B 3 | head -n 1 | sed -e 's/:$//;s/.* //')"']' build.osx-i386/Scanner.output | sed -e 's/.* # //;s/ .*//')" diff --git a/cycript.hpp b/cycript.hpp index 0f6ed13..a70cd94 100644 --- a/cycript.hpp +++ b/cycript.hpp @@ -22,9 +22,10 @@ #ifndef CYCRIPT_HPP #define CYCRIPT_HPP -#include #include +#include + #include "Pooling.hpp" #include "String.hpp"