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
/* }}} */
#include <cstdlib>
+
#include "Bridge.hpp"
extern "C" struct CYBridgeEntry *CYBridgeHash(const char *data, size_t size) {
#include "Display.hpp"
#include "Driver.hpp"
#include "Highlight.hpp"
-#include "Parser.hpp"
+#include "Syntax.hpp"
static volatile enum {
Working,
+++ /dev/null
-/* 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 <http://www.gnu.org/licenses/>.
-**/
-/* }}} */
-
-%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<const char *>(memchr(yytext, '\n', yyleng))) { \
- unsigned lines(0); \
- size_t left; \
- do { \
- ++lines; \
- left = yyleng - (nl - yytext) - 1; \
- nl = reinterpret_cast<const char *>(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 <typename Type_>
-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<std::vector<char> > 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 {{{ */
-<RegExp,RegExpOrTemplateTail>\/ L CYLexBufferStart(RegularExpression); CYLexBufferUnit('/');
-
-<RegularExpression>{
- \/{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");
- <<EOF>> R E("unterminated regex")
-}
- /* }}} */
- /* Comment {{{ */
-#![^\n]* L M
-\/\/[^\n]* L M
-
-\/\* L yy_push_state(MultiLine, yyscanner);
-
-<MultiLine>{
- \**\*\/ R yy_pop_state(yyscanner); M N
- \**{LineTerminatorSequence} yylloc->end.lines(); yyextra->last_ = true;
- \**{CommentCharacter}|\/ R
- \**({UnicodeFail}|\*) R E("invalid comment");
- <<EOF>> R E("invalid comment")
-}
- /* }}} */
- /* Element {{{ */
-@begin E4X
-<RegExp>"<>" L F(tk::LeftRight, hi::Structure);
-<XMLContent>"</>" L F(tk::LeftSlashRight, hi::Structure);
-
-<RegExp,XMLContent>\<!\[CDATA\[(\n|[^[]|\[[^[]|\[\[[^>])*]]> V() F(tk::XMLCDATA, hi::Constant);
-<RegExp,XMLContent>\<!--(\n|[^-]|-[^-])*--> V() F(tk::XMLComment, hi::Comment);
-<RegExp,XMLContent>\<?(\n|[^?]|\?[^>])*?> V() F(tk::XMLPI, hi::Meta);
-
-<XMLTag>"=" L F(tk::Equal, hi::Structure);
-<XMLTag>">" L F(tk::Right, hi::Structure);
-<XMLTag>"/>" L F(tk::SlashRight, hi::Structure);
-<XMLTag>"{" L F(tk::OpenBrace, hi::Structure);
-
-<XMLTag>\"(\n|[^"])*\"|'(\n|[^'])*' V() F(tk::XMLAttributeValue, hi::Constant);
-<XMLTag>{XMLName} L F(tk::XMLName, hi::Identifier);
-<XMLTag>[ \t\r\n] V() F(tk::XMLWhitespace, hi::Nothing);
-
-<XMLContent>"{" L F(tk::OpenBrace, hi::Structure);
-<XMLContent>"<" L F(tk::Left, hi::Structure);
-<XMLContent>"</" L F(tk::LeftSlash, hi::Structure);
-@end
- /* }}} */
- /* Operator {{{ */
-"..." L F(tk::PeriodPeriodPeriod, hi::Meta);
-".." L E("invalid operator")
-
-@begin E4X
-"::" L F(tk::ColonColon, hi::Operator);
-".." L F(tk::PeriodPeriod, hi::Operator);
-@end
-
-@begin E4X ObjectiveC
-"@" L F(tk::At, hi::Operator);
-"#" L F(tk::Pound, hi::Operator);
-@end
-
-"&" L F(tk::Ampersand, hi::Operator);
-"&&" L F(tk::AmpersandAmpersand, hi::Operator);
-"&=" L F(tk::AmpersandEqual, hi::Operator);
-"^" L F(tk::Carrot, hi::Operator);
-"^=" L F(tk::CarrotEqual, hi::Operator);
-"=" L F(tk::Equal, hi::Operator);
-"==" L F(tk::EqualEqual, hi::Operator);
-"===" L F(tk::EqualEqualEqual, hi::Operator);
-"=>" 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);
-
-<Div,DivOrTemplateTail>"/" L F(tk::Slash, hi::Operator);
-<Div,DivOrTemplateTail>"/=" 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);
-<Div,RegExp>"}" 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);
-<LegacySingleString,StrictSingleString>{
- \' 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);
-<LegacyDoubleString,StrictDoubleString>{
- \" 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);
-<DivOrTemplateTail,RegExpOrTemplateTail>"}" L yyextra->tail_ = true; yyextra->template_.pop(); CYLexBufferStart(StrictAccentString);
-
-<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 {{{ */
-<LegacySingleString,LegacyDoubleString>{
- \\[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]));
-}
-
-<StrictSingleString,StrictDoubleString,StrictAccentString>{
- \\0[0-7] R E("legacy escape");
- \\0 R CYLexBufferUnit('\0');
-}
-
-<LegacySingleString,LegacyDoubleString,StrictSingleString,StrictDoubleString,StrictAccentString>{
- \\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");
- <<EOF>> R E("invalid string");
-}
- /* }}} */
-
-{LineTerminatorSequence} yylloc->step(); yylloc->end.lines(); yyextra->last_ = true; N
-{WhiteSpace} L
-
-<<EOF>> 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<struct yyguts_t *>(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
+++ /dev/null
-/* 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 <http://www.gnu.org/licenses/>.
-**/
-/* }}} */
-
-%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 ColonColon "::"
-%token PeriodPeriod ".."
-@end
-
-@begin E4X ObjectiveC
-%token At "@"
-%token Pound "#"
-@end
-
-%token Ampersand "&"
-%token AmpersandAmpersand "&&"
-%token AmpersandEqual "&="
-%token Carrot "^"
-%token CarrotEqual "^="
-%token Equal "="
-%token EqualEqual "=="
-%token EqualEqualEqual "==="
-%token EqualRight "=>"
-%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_> Identifier_
-%token <number_> NumericLiteral
-%token <string_> StringLiteral
-%token <literal_> RegularExpressionLiteral
-
-%token <string_> NoSubstitutionTemplate
-%token <string_> TemplateHead
-%token <string_> TemplateMiddle
-%token <string_> TemplateTail
-
-%type <expression_> AdditiveExpression
-%type <argument_> ArgumentList_
-%type <argument_> ArgumentList
-%type <argument_> ArgumentListOpt
-%type <argument_> Arguments
-%type <expression_> ArrayComprehension
-%type <literal_> ArrayLiteral
-%type <expression_> ArrowFunction
-%type <functionParameter_> ArrowParameters
-%type <expression_> AssignmentExpression
-%type <expression_> AssignmentExpressionOpt
-%type <identifier_> Binding
-%type <identifier_> BindingIdentifier
-%type <identifier_> BindingIdentifierOpt
-%type <expression_> BitwiseANDExpression
-%type <statement_> Block
-%type <statement_> BlockStatement
-%type <boolean_> BooleanLiteral
-%type <declaration_> BindingElement
-%type <expression_> BitwiseORExpression
-%type <expression_> BitwiseXORExpression
-%type <statement_> BreakStatement
-%type <statement_> BreakableStatement
-%type <expression_> CallExpression_
-%type <expression_> CallExpression
-%type <clause_> CaseBlock
-%type <clause_> CaseClause
-%type <clause_> CaseClausesOpt
-%type <catch_> Catch
-%type <identifier_> CatchParameter
-%type <statement_> ClassDeclaration
-%type <expression_> ClassExpression
-%type <expression_> Comprehension
-%type <comprehension_> ComprehensionFor
-%type <comprehension_> ComprehensionIf
-%type <comprehension_> ComprehensionTail
-%type <expression_> ComputedPropertyName
-%type <expression_> ConditionalExpression
-%type <statement_> ContinueStatement
-%type <statement_> ConciseBody
-%type <parenthetical_> CoverParenthesizedExpressionAndArrowParameterList
-%type <statement_> DebuggerStatement
-%type <statement_> Declaration__
-%type <statement_> Declaration_
-%type <statement_> Declaration
-%type <clause_> DefaultClause
-%type <element_> ElementList
-%type <element_> ElementListOpt
-%type <statement_> ElseStatementOpt
-%type <statement_> EmptyStatement
-%type <expression_> EqualityExpression
-%type <expression_> Expression
-%type <expression_> ExpressionOpt
-%type <statement_> ExpressionStatement
-%type <finally_> Finally
-%type <for_> ForStatementInitializer
-%type <forin_> ForInStatementInitializer
-%type <declaration_> FormalParameter
-%type <functionParameter_> FormalParameterList_
-%type <functionParameter_> FormalParameterList
-%type <functionParameter_> FormalParameters
-%type <statement_> FunctionBody
-%type <statement_> FunctionDeclaration
-%type <expression_> FunctionExpression
-%type <statement_> FunctionStatementList
-%type <statement_> GeneratorBody
-%type <statement_> GeneratorDeclaration
-%type <expression_> GeneratorExpression
-%type <property_> GeneratorMethod
-%type <statement_> HoistableDeclaration
-%type <identifier_> Identifier
-%type <identifier_> IdentifierType
-%type <word_> IdentifierName
-%type <variable_> IdentifierReference
-%type <statement_> IfStatement
-%type <expression_> Initializer
-%type <expression_> InitializerOpt
-%type <statement_> IterationStatement
-%type <identifier_> LabelIdentifier
-%type <statement_> LabelledItem
-%type <statement_> LabelledStatement
-%type <expression_> LeftHandSideExpression
-%type <statement_> LetStatement
-%type <statement_> LexicalDeclaration
-%type <literal_> Literal
-%type <propertyName_> LiteralPropertyName
-%type <expression_> LogicalANDExpression
-%type <expression_> LogicalORExpression
-%type <member_> MemberAccess
-%type <expression_> MemberExpression
-%type <property_> MethodDefinition
-%type <module_> ModulePath
-%type <expression_> MultiplicativeExpression
-%type <expression_> NewExpression
-%type <null_> NullLiteral
-%type <literal_> ObjectLiteral
-%type <expression_> PostfixExpression
-%type <expression_> PrimaryExpression
-%type <propertyName_> PropertyName
-%type <property_> PropertyDefinition
-%type <property_> PropertyDefinitionList_
-%type <property_> PropertyDefinitionList
-%type <property_> PropertyDefinitionListOpt
-%type <declaration_> PropertySetParameterList
-%type <expression_> RelationalExpression
-%type <statement_> ReturnStatement
-%type <rubyProc_> RubyProcExpression
-%type <functionParameter_> RubyProcParameterList_
-%type <functionParameter_> RubyProcParameterList
-%type <functionParameter_> RubyProcParameters
-%type <functionParameter_> RubyProcParametersOpt
-%type <statement_> Script
-%type <statement_> ScriptBody
-%type <statement_> ScriptBodyOpt
-%type <expression_> ShiftExpression
-%type <declaration_> SingleNameBinding
-%type <statement_> Statement__
-%type <statement_> Statement_
-%type <statement_> Statement
-%type <statement_> StatementList
-%type <statement_> StatementListOpt
-%type <statement_> StatementListItem
-%type <functionParameter_> StrictFormalParameters
-%type <statement_> SwitchStatement
-%type <expression_> TemplateLiteral
-%type <span_> TemplateSpans
-%type <statement_> ThrowStatement
-%type <statement_> TryStatement
-%type <expression_> UnaryExpression_
-%type <expression_> UnaryExpression
-%type <declaration_> VariableDeclaration
-%type <declarations_> VariableDeclarationList_
-%type <declarations_> VariableDeclarationList
-%type <statement_> VariableStatement
-%type <statement_> WithStatement
-%type <word_> Word
-@begin ObjectiveC
-%type <word_> WordOpt
-@end
-%type <expression_> YieldExpression
-
-@begin C
-%type <specifier_> IntegerType
-%type <specifier_> IntegerTypeOpt
-%type <typedIdentifier_> PrefixedType
-%type <specifier_> PrimitiveType
-%type <typedIdentifier_> SuffixedType
-%type <typedIdentifier_> TypeSignifier
-%type <modifier_> TypeQualifierLeft
-%type <typedIdentifier_> TypeQualifierRight
-%type <typedIdentifier_> TypedIdentifier
-%type <typedParameter_> TypedParameterList_
-%type <typedParameter_> TypedParameterList
-%type <typedParameter_> TypedParameterListOpt
-@end
-
-@begin ObjectiveC
-%type <expression_> BoxableExpression
-%type <statement_> CategoryStatement
-%type <classField_> ClassFieldListOpt
-%type <classField_> ClassFields
-%type <statement_> ClassStatement
-%type <expression_> ClassSuperOpt
-%type <message_> ClassMessageDeclaration
-%type <message_> ClassMessageDeclarationListOpt
-%type <className_> ClassName
-%type <protocol_> ClassProtocolListOpt
-%type <protocol_> ClassProtocols
-%type <protocol_> ClassProtocolsOpt
-%type <expression_> MessageExpression
-%type <messageParameter_> MessageParameter
-%type <messageParameter_> MessageParameters
-%type <messageParameter_> MessageParameterList
-%type <messageParameter_> MessageParameterListOpt
-%type <bool_> MessageScope
-%type <argument_> SelectorCall_
-%type <argument_> SelectorCall
-%type <selector_> SelectorExpression_
-%type <selector_> SelectorExpression
-%type <selector_> SelectorExpressionOpt
-%type <argument_> SelectorList
-%type <word_> SelectorWordOpt
-%type <typedIdentifier_> TypeOpt
-%type <argument_> VariadicCall
-@end
-
-@begin E4X
-%type <propertyIdentifier_> PropertyIdentifier_
-%type <selector_> PropertySelector_
-%type <selector_> PropertySelector
-%type <identifier_> QualifiedIdentifier_
-%type <identifier_> QualifiedIdentifier
-%type <identifier_> WildcardIdentifier
-%type <identifier_> XMLComment
-%type <identifier_> XMLCDATA
-%type <identifier_> XMLElement
-%type <identifier_> XMLElementContent
-%type <identifier_> XMLMarkup
-%type <identifier_> XMLPI
-
-%type <attribute_> AttributeIdentifier
-/* XXX: %type <statement_> DefaultXMLNamespaceStatement */
-%type <expression_> PropertyIdentifier
-%type <expression_> XMLListInitialiser
-%type <expression_> 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 "</" LexSetXMLTag XMLTagName XMLWhitespaceOpt LexPop ">" 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<CYPool> 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);
-}
#include <sig/types.hpp>
-#include "Parser.hpp"
+#include "Syntax.hpp"
CYTypedIdentifier *Decode(CYPool &pool, struct sig::Type *type);
#include <sys/ioctl.h>
-#include "Highlight.hpp"
-
#include <term.h>
+#include "Highlight.hpp"
+
typedef std::complex<int> CYCursor;
extern "C" int rl_display_fixed;
/* }}} */
#include "Driver.hpp"
-#include "Parser.hpp"
+#include "Syntax.hpp"
bool CYParser(CYPool &pool, bool debug);
#ifndef CYCRIPT_E4X_SYNTAX_HPP
#define CYCRIPT_E4X_SYNTAX_HPP
-#include "Parser.hpp"
+#include "Syntax.hpp"
struct CYDefaultXMLNamespace :
CYStatement
#ifndef CYCRIPT_ERROR_HPP
#define CYCRIPT_ERROR_HPP
-#include "Pooling.hpp"
#include "Exception.hpp"
+#include "Pooling.hpp"
#ifdef CY_EXECUTE
struct CYJSError :
**/
/* }}} */
-#include "Internal.hpp"
+#include "cycript.hpp"
+
+#include <iostream>
+#include <set>
+#include <map>
+#include <iomanip>
+#include <sstream>
+#include <cmath>
#include <dlfcn.h>
#include <dirent.h>
#include <fcntl.h>
#include <unistd.h>
-#include "cycript.hpp"
-
-#include "sig/parse.hpp"
-#include "sig/ffi_type.hpp"
-
-#include "Pooling.hpp"
-#include "Execute.hpp"
-
#include <sys/mman.h>
#include <sys/stat.h>
-#include <iostream>
-#include <set>
-#include <map>
-#include <iomanip>
-#include <sstream>
-#include <cmath>
+#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<CYHook *> &GetHooks() {
**/
/* }}} */
+#include "cycript.hpp"
+
#include <dlfcn.h>
#include <pthread.h>
#include <unistd.h>
#include <CoreFoundation/CoreFoundation.h>
#endif
-#include "cycript.hpp"
-
#include "Driver.hpp"
#include "JavaScript.hpp"
-#include "Parser.hpp"
+#include "Syntax.hpp"
#include "Pooling.hpp"
struct CYExecute_ {
**/
/* }}} */
-#include <dlfcn.h>
-
#include "cycript.hpp"
-#include "Pooling.hpp"
-
-#include <sys/mman.h>
-
#include <iostream>
#include <set>
#include <map>
#include <sstream>
#include <cmath>
+#include <dlfcn.h>
+
+#include <sys/mman.h>
+
+#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<CYPool>::key_ = Key_();
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 =
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]* ([^)]*)$$'
$(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 \
@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)
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 \
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)
$(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)
@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@
@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@
@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 $@ $< &&\
@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.
#ifndef CYCRIPT_OBJECTIVEC_INTERNAL_HPP
#define CYCRIPT_OBJECTIVEC_INTERNAL_HPP
-#include <Internal.hpp>
#include <objc/objc.h>
+#include "../Internal.hpp"
+
struct Selector_privateData :
CYValue
{
#include "cycript.hpp"
-#include "ObjectiveC/Internal.hpp"
+#include <cmath>
+
+#include <map>
+#include <set>
+
+#include <dlfcn.h>
+
+#ifdef __APPLE__
+#include <malloc/malloc.h>
+#include <mach/mach.h>
+#endif
#include <objc/message.h>
#include <objc/runtime.h>
-#include <Foundation/Foundation.h>
-
#ifdef __APPLE__
#include <CoreFoundation/CoreFoundation.h>
#include <JavaScriptCore/JSStringRefCF.h>
#endif
-#ifdef __APPLE__
-#include <malloc/malloc.h>
-#include <mach/mach.h>
-#endif
+#include <Foundation/Foundation.h>
#include "Code.hpp"
#include "Error.hpp"
#include "String.hpp"
#include "Execute.hpp"
-#include <cmath>
-#include <map>
-#include <set>
-
-#include <dlfcn.h>
+#include "ObjectiveC/Internal.hpp"
#define CYObjectiveTry_ { \
try
**/
/* }}} */
+#include <sstream>
+
#include "Replace.hpp"
-#include "ObjectiveC/Syntax.hpp"
-#include <sstream>
+#include "ObjectiveC/Syntax.hpp"
void CYCategory::Output(CYOutput &out, CYFlags flags) const {
out << "(function($cys,$cyp,$cyc,$cyn,$cyt){";
**/
/* }}} */
+#include <sstream>
+
#include "Replace.hpp"
-#include "ObjectiveC/Syntax.hpp"
-#include <sstream>
+#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"))));
#ifndef CYCRIPT_OBJECTIVEC_SYNTAX_HPP
#define CYCRIPT_OBJECTIVEC_SYNTAX_HPP
-#include "Parser.hpp"
+#include "../Syntax.hpp"
struct CYInstanceLiteral :
CYExpression
/* }}} */
#include "cycript.hpp"
-#include "Parser.hpp"
#include <sstream>
+#include "Syntax.hpp"
+
void CYOutput::Terminate() {
operator ()(';');
mode_ = NoMode;
+++ /dev/null
-/* 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 <http://www.gnu.org/licenses/>.
-**/
-/* }}} */
-
-#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
+++ /dev/null
-/* 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 <http://www.gnu.org/licenses/>.
-**/
-/* }}} */
-
-#ifndef CYCRIPT_PARSER_HPP
-#define CYCRIPT_PARSER_HPP
-
-#include <streambuf>
-#include <string>
-#include <vector>
-#include <map>
-#include <set>
-
-#include <cstdio>
-#include <cstdlib>
-
-#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<CYFlags>(~static_cast<unsigned>(rhs));
-}
-
-_finline CYFlags operator &(CYFlags lhs, CYFlags rhs) {
- return static_cast<CYFlags>(static_cast<unsigned>(lhs) & static_cast<unsigned>(rhs));
-}
-
-_finline CYFlags operator |(CYFlags lhs, CYFlags rhs) {
- return static_cast<CYFlags>(static_cast<unsigned>(lhs) | static_cast<unsigned>(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<CYStatement>,
- 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<CYIdentifier>,
- 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<const char *, const char *, bool>
-{
- _finline bool operator ()(const char *lhs, const char *rhs) const {
- return strcmp(lhs, rhs) < 0;
- }
-};
-
-struct CYIdentifierValueLess :
- std::binary_function<CYIdentifier *, CYIdentifier *, bool>
-{
- _finline bool operator ()(CYIdentifier *lhs, CYIdentifier *rhs) const {
- return CYCStringLess()(lhs->Word(), rhs->Word());
- }
-};
-
-enum CYIdentifierFlags {
- CYIdentifierArgument,
- CYIdentifierVariable,
- CYIdentifierOther,
- CYIdentifierMagic,
- CYIdentifierCatch,
-};
-
-typedef std::set<const char *, CYCStringLess> CYCStringSet;
-typedef std::set<CYIdentifier *, CYIdentifierValueLess> CYIdentifierValueSet;
-typedef std::map<CYIdentifier *, CYIdentifierFlags> CYIdentifierAddressFlagsMap;
-
-struct CYIdentifierUsage {
- CYIdentifier *identifier_;
- size_t usage_;
-};
-
-typedef std::vector<CYIdentifierUsage> 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 <typename Type_>
- 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<CYThisScope>
-{
- 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<CYFunctionParameter>,
- CYThing
-{
- CYForInInitializer *initialiser_;
-
- CYFunctionParameter(CYForInInitializer *initialiser, CYFunctionParameter *next = NULL) :
- CYNext<CYFunctionParameter>(next),
- initialiser_(initialiser)
- {
- }
-
- void Replace(CYContext &context, CYStatement *&statements);
- void Output(CYOutput &out) const;
-};
-
-struct CYComprehension :
- CYNext<CYComprehension>,
- CYThing
-{
- CYComprehension(CYComprehension *next = NULL) :
- CYNext<CYComprehension>(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<CYSpan>
-{
- CYExpression *expression_;
- CYString *string_;
-
- CYSpan(CYExpression *expression, CYString *string, CYSpan *next) :
- CYNext<CYSpan>(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<CYArgument>,
- CYThing
-{
- CYWord *name_;
- CYExpression *value_;
-
- CYArgument(CYExpression *value, CYArgument *next = NULL) :
- CYNext<CYArgument>(next),
- name_(NULL),
- value_(value)
- {
- }
-
- CYArgument(CYWord *name, CYExpression *value, CYArgument *next = NULL) :
- CYNext<CYArgument>(next),
- name_(name),
- value_(value)
- {
- }
-
- CYArgument *Replace(CYContext &context);
- void Output(CYOutput &out) const;
-};
-
-struct CYClause :
- CYThing,
- CYNext<CYClause>
-{
- 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>,
- CYElement
-{
- CYExpression *value_;
-
- CYElementValue(CYExpression *value, CYElement *next) :
- CYNext<CYElement>(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<CYProperty>,
- CYThing
-{
- CYPropertyName *name_;
- CYExpression *value_;
-
- CYProperty(CYPropertyName *name, CYExpression *value, CYProperty *next = NULL) :
- CYNext<CYProperty>(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<CYDeclarations>,
- CYThing
-{
- CYDeclaration *declaration_;
-
- CYDeclarations(CYDeclaration *declaration, CYDeclarations *next = NULL) :
- CYNext<CYDeclarations>(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(CYTypeModifier *next) :
- CYNext<CYTypeModifier>(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<CYTypedIdentifier>,
- 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<CYTypedParameter>,
- CYThing
-{
- CYTypedIdentifier *typed_;
-
- CYTypedParameter(CYTypedIdentifier *typed, CYTypedParameter *next) :
- CYNext<CYTypedParameter>(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<CYModule>,
- CYThing
-{
- CYWord *part_;
-
- CYModule(CYWord *part, CYModule *next = NULL) :
- CYNext<CYModule>(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*/
--- /dev/null
+/* 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 <http://www.gnu.org/licenses/>.
+**/
+/* }}} */
+
+%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 ColonColon "::"
+%token PeriodPeriod ".."
+@end
+
+@begin E4X ObjectiveC
+%token At "@"
+%token Pound "#"
+@end
+
+%token Ampersand "&"
+%token AmpersandAmpersand "&&"
+%token AmpersandEqual "&="
+%token Carrot "^"
+%token CarrotEqual "^="
+%token Equal "="
+%token EqualEqual "=="
+%token EqualEqualEqual "==="
+%token EqualRight "=>"
+%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_> Identifier_
+%token <number_> NumericLiteral
+%token <string_> StringLiteral
+%token <literal_> RegularExpressionLiteral
+
+%token <string_> NoSubstitutionTemplate
+%token <string_> TemplateHead
+%token <string_> TemplateMiddle
+%token <string_> TemplateTail
+
+%type <expression_> AdditiveExpression
+%type <argument_> ArgumentList_
+%type <argument_> ArgumentList
+%type <argument_> ArgumentListOpt
+%type <argument_> Arguments
+%type <expression_> ArrayComprehension
+%type <literal_> ArrayLiteral
+%type <expression_> ArrowFunction
+%type <functionParameter_> ArrowParameters
+%type <expression_> AssignmentExpression
+%type <expression_> AssignmentExpressionOpt
+%type <identifier_> Binding
+%type <identifier_> BindingIdentifier
+%type <identifier_> BindingIdentifierOpt
+%type <expression_> BitwiseANDExpression
+%type <statement_> Block
+%type <statement_> BlockStatement
+%type <boolean_> BooleanLiteral
+%type <declaration_> BindingElement
+%type <expression_> BitwiseORExpression
+%type <expression_> BitwiseXORExpression
+%type <statement_> BreakStatement
+%type <statement_> BreakableStatement
+%type <expression_> CallExpression_
+%type <expression_> CallExpression
+%type <clause_> CaseBlock
+%type <clause_> CaseClause
+%type <clause_> CaseClausesOpt
+%type <catch_> Catch
+%type <identifier_> CatchParameter
+%type <statement_> ClassDeclaration
+%type <expression_> ClassExpression
+%type <expression_> Comprehension
+%type <comprehension_> ComprehensionFor
+%type <comprehension_> ComprehensionIf
+%type <comprehension_> ComprehensionTail
+%type <expression_> ComputedPropertyName
+%type <expression_> ConditionalExpression
+%type <statement_> ContinueStatement
+%type <statement_> ConciseBody
+%type <parenthetical_> CoverParenthesizedExpressionAndArrowParameterList
+%type <statement_> DebuggerStatement
+%type <statement_> Declaration__
+%type <statement_> Declaration_
+%type <statement_> Declaration
+%type <clause_> DefaultClause
+%type <element_> ElementList
+%type <element_> ElementListOpt
+%type <statement_> ElseStatementOpt
+%type <statement_> EmptyStatement
+%type <expression_> EqualityExpression
+%type <expression_> Expression
+%type <expression_> ExpressionOpt
+%type <statement_> ExpressionStatement
+%type <finally_> Finally
+%type <for_> ForStatementInitializer
+%type <forin_> ForInStatementInitializer
+%type <declaration_> FormalParameter
+%type <functionParameter_> FormalParameterList_
+%type <functionParameter_> FormalParameterList
+%type <functionParameter_> FormalParameters
+%type <statement_> FunctionBody
+%type <statement_> FunctionDeclaration
+%type <expression_> FunctionExpression
+%type <statement_> FunctionStatementList
+%type <statement_> GeneratorBody
+%type <statement_> GeneratorDeclaration
+%type <expression_> GeneratorExpression
+%type <property_> GeneratorMethod
+%type <statement_> HoistableDeclaration
+%type <identifier_> Identifier
+%type <identifier_> IdentifierType
+%type <word_> IdentifierName
+%type <variable_> IdentifierReference
+%type <statement_> IfStatement
+%type <expression_> Initializer
+%type <expression_> InitializerOpt
+%type <statement_> IterationStatement
+%type <identifier_> LabelIdentifier
+%type <statement_> LabelledItem
+%type <statement_> LabelledStatement
+%type <expression_> LeftHandSideExpression
+%type <statement_> LetStatement
+%type <statement_> LexicalDeclaration
+%type <literal_> Literal
+%type <propertyName_> LiteralPropertyName
+%type <expression_> LogicalANDExpression
+%type <expression_> LogicalORExpression
+%type <member_> MemberAccess
+%type <expression_> MemberExpression
+%type <property_> MethodDefinition
+%type <module_> ModulePath
+%type <expression_> MultiplicativeExpression
+%type <expression_> NewExpression
+%type <null_> NullLiteral
+%type <literal_> ObjectLiteral
+%type <expression_> PostfixExpression
+%type <expression_> PrimaryExpression
+%type <propertyName_> PropertyName
+%type <property_> PropertyDefinition
+%type <property_> PropertyDefinitionList_
+%type <property_> PropertyDefinitionList
+%type <property_> PropertyDefinitionListOpt
+%type <declaration_> PropertySetParameterList
+%type <expression_> RelationalExpression
+%type <statement_> ReturnStatement
+%type <rubyProc_> RubyProcExpression
+%type <functionParameter_> RubyProcParameterList_
+%type <functionParameter_> RubyProcParameterList
+%type <functionParameter_> RubyProcParameters
+%type <functionParameter_> RubyProcParametersOpt
+%type <statement_> Script
+%type <statement_> ScriptBody
+%type <statement_> ScriptBodyOpt
+%type <expression_> ShiftExpression
+%type <declaration_> SingleNameBinding
+%type <statement_> Statement__
+%type <statement_> Statement_
+%type <statement_> Statement
+%type <statement_> StatementList
+%type <statement_> StatementListOpt
+%type <statement_> StatementListItem
+%type <functionParameter_> StrictFormalParameters
+%type <statement_> SwitchStatement
+%type <expression_> TemplateLiteral
+%type <span_> TemplateSpans
+%type <statement_> ThrowStatement
+%type <statement_> TryStatement
+%type <expression_> UnaryExpression_
+%type <expression_> UnaryExpression
+%type <declaration_> VariableDeclaration
+%type <declarations_> VariableDeclarationList_
+%type <declarations_> VariableDeclarationList
+%type <statement_> VariableStatement
+%type <statement_> WithStatement
+%type <word_> Word
+@begin ObjectiveC
+%type <word_> WordOpt
+@end
+%type <expression_> YieldExpression
+
+@begin C
+%type <specifier_> IntegerType
+%type <specifier_> IntegerTypeOpt
+%type <typedIdentifier_> PrefixedType
+%type <specifier_> PrimitiveType
+%type <typedIdentifier_> SuffixedType
+%type <typedIdentifier_> TypeSignifier
+%type <modifier_> TypeQualifierLeft
+%type <typedIdentifier_> TypeQualifierRight
+%type <typedIdentifier_> TypedIdentifier
+%type <typedParameter_> TypedParameterList_
+%type <typedParameter_> TypedParameterList
+%type <typedParameter_> TypedParameterListOpt
+@end
+
+@begin ObjectiveC
+%type <expression_> BoxableExpression
+%type <statement_> CategoryStatement
+%type <classField_> ClassFieldListOpt
+%type <classField_> ClassFields
+%type <statement_> ClassStatement
+%type <expression_> ClassSuperOpt
+%type <message_> ClassMessageDeclaration
+%type <message_> ClassMessageDeclarationListOpt
+%type <className_> ClassName
+%type <protocol_> ClassProtocolListOpt
+%type <protocol_> ClassProtocols
+%type <protocol_> ClassProtocolsOpt
+%type <expression_> MessageExpression
+%type <messageParameter_> MessageParameter
+%type <messageParameter_> MessageParameters
+%type <messageParameter_> MessageParameterList
+%type <messageParameter_> MessageParameterListOpt
+%type <bool_> MessageScope
+%type <argument_> SelectorCall_
+%type <argument_> SelectorCall
+%type <selector_> SelectorExpression_
+%type <selector_> SelectorExpression
+%type <selector_> SelectorExpressionOpt
+%type <argument_> SelectorList
+%type <word_> SelectorWordOpt
+%type <typedIdentifier_> TypeOpt
+%type <argument_> VariadicCall
+@end
+
+@begin E4X
+%type <propertyIdentifier_> PropertyIdentifier_
+%type <selector_> PropertySelector_
+%type <selector_> PropertySelector
+%type <identifier_> QualifiedIdentifier_
+%type <identifier_> QualifiedIdentifier
+%type <identifier_> WildcardIdentifier
+%type <identifier_> XMLComment
+%type <identifier_> XMLCDATA
+%type <identifier_> XMLElement
+%type <identifier_> XMLElementContent
+%type <identifier_> XMLMarkup
+%type <identifier_> XMLPI
+
+%type <attribute_> AttributeIdentifier
+/* XXX: %type <statement_> DefaultXMLNamespaceStatement */
+%type <expression_> PropertyIdentifier
+%type <expression_> XMLListInitialiser
+%type <expression_> 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 "</" LexSetXMLTag XMLTagName XMLWhitespaceOpt LexPop ">" 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<CYPool> 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);
+}
**/
/* }}} */
-#include "Parser.hpp"
-#include "Replace.hpp"
-
#include <iomanip>
+#include "Replace.hpp"
+#include "Syntax.hpp"
+
CYFunctionExpression *CYNonLocalize(CYContext &context, CYFunctionExpression *function) {
function->nonlocal_ = context.nextlocal_;
return function;
#ifndef CYCRIPT_REPLACE_HPP
#define CYCRIPT_REPLACE_HPP
-#include "Parser.hpp"
+#include "Syntax.hpp"
#define $ new($pool)
--- /dev/null
+/* 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 <http://www.gnu.org/licenses/>.
+**/
+/* }}} */
+
+%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<const char *>(memchr(yytext, '\n', yyleng))) { \
+ unsigned lines(0); \
+ size_t left; \
+ do { \
+ ++lines; \
+ left = yyleng - (nl - yytext) - 1; \
+ nl = reinterpret_cast<const char *>(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 <typename Type_>
+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<std::vector<char> > 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 {{{ */
+<RegExp,RegExpOrTemplateTail>\/ L CYLexBufferStart(RegularExpression); CYLexBufferUnit('/');
+
+<RegularExpression>{
+ \/{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");
+ <<EOF>> R E("unterminated regex")
+}
+ /* }}} */
+ /* Comment {{{ */
+#![^\n]* L M
+\/\/[^\n]* L M
+
+\/\* L yy_push_state(MultiLine, yyscanner);
+
+<MultiLine>{
+ \**\*\/ R yy_pop_state(yyscanner); M N
+ \**{LineTerminatorSequence} yylloc->end.lines(); yyextra->last_ = true;
+ \**{CommentCharacter}|\/ R
+ \**({UnicodeFail}|\*) R E("invalid comment");
+ <<EOF>> R E("invalid comment")
+}
+ /* }}} */
+ /* Element {{{ */
+@begin E4X
+<RegExp>"<>" L F(tk::LeftRight, hi::Structure);
+<XMLContent>"</>" L F(tk::LeftSlashRight, hi::Structure);
+
+<RegExp,XMLContent>\<!\[CDATA\[(\n|[^[]|\[[^[]|\[\[[^>])*]]> V() F(tk::XMLCDATA, hi::Constant);
+<RegExp,XMLContent>\<!--(\n|[^-]|-[^-])*--> V() F(tk::XMLComment, hi::Comment);
+<RegExp,XMLContent>\<?(\n|[^?]|\?[^>])*?> V() F(tk::XMLPI, hi::Meta);
+
+<XMLTag>"=" L F(tk::Equal, hi::Structure);
+<XMLTag>">" L F(tk::Right, hi::Structure);
+<XMLTag>"/>" L F(tk::SlashRight, hi::Structure);
+<XMLTag>"{" L F(tk::OpenBrace, hi::Structure);
+
+<XMLTag>\"(\n|[^"])*\"|'(\n|[^'])*' V() F(tk::XMLAttributeValue, hi::Constant);
+<XMLTag>{XMLName} L F(tk::XMLName, hi::Identifier);
+<XMLTag>[ \t\r\n] V() F(tk::XMLWhitespace, hi::Nothing);
+
+<XMLContent>"{" L F(tk::OpenBrace, hi::Structure);
+<XMLContent>"<" L F(tk::Left, hi::Structure);
+<XMLContent>"</" L F(tk::LeftSlash, hi::Structure);
+@end
+ /* }}} */
+ /* Operator {{{ */
+"..." L F(tk::PeriodPeriodPeriod, hi::Meta);
+".." L E("invalid operator")
+
+@begin E4X
+"::" L F(tk::ColonColon, hi::Operator);
+".." L F(tk::PeriodPeriod, hi::Operator);
+@end
+
+@begin E4X ObjectiveC
+"@" L F(tk::At, hi::Operator);
+"#" L F(tk::Pound, hi::Operator);
+@end
+
+"&" L F(tk::Ampersand, hi::Operator);
+"&&" L F(tk::AmpersandAmpersand, hi::Operator);
+"&=" L F(tk::AmpersandEqual, hi::Operator);
+"^" L F(tk::Carrot, hi::Operator);
+"^=" L F(tk::CarrotEqual, hi::Operator);
+"=" L F(tk::Equal, hi::Operator);
+"==" L F(tk::EqualEqual, hi::Operator);
+"===" L F(tk::EqualEqualEqual, hi::Operator);
+"=>" 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);
+
+<Div,DivOrTemplateTail>"/" L F(tk::Slash, hi::Operator);
+<Div,DivOrTemplateTail>"/=" 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);
+<Div,RegExp>"}" 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);
+<LegacySingleString,StrictSingleString>{
+ \' 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);
+<LegacyDoubleString,StrictDoubleString>{
+ \" 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);
+<DivOrTemplateTail,RegExpOrTemplateTail>"}" L yyextra->tail_ = true; yyextra->template_.pop(); CYLexBufferStart(StrictAccentString);
+
+<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 {{{ */
+<LegacySingleString,LegacyDoubleString>{
+ \\[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]));
+}
+
+<StrictSingleString,StrictDoubleString,StrictAccentString>{
+ \\0[0-7] R E("legacy escape");
+ \\0 R CYLexBufferUnit('\0');
+}
+
+<LegacySingleString,LegacyDoubleString,StrictSingleString,StrictDoubleString,StrictAccentString>{
+ \\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");
+ <<EOF>> R E("invalid string");
+}
+ /* }}} */
+
+{LineTerminatorSequence} yylloc->step(); yylloc->end.lines(); yyextra->last_ = true; N
+{WhiteSpace} L
+
+<<EOF>> 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<struct yyguts_t *>(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
**/
/* }}} */
-#include <Pooling.hpp>
-
#include <CoreFoundation/CFLogUtilities.h>
#include <CFNetwork/CFNetwork.h>
-#include <sys/types.h>
-#include <sys/socket.h>
#include <netinet/in.h>
+#include <sys/socket.h>
+#include <sys/types.h>
#include <sys/un.h>
+#include "Pooling.hpp"
+
struct Client {
CFHTTPMessageRef message_;
CFSocketRef socket_;
#ifndef CYCRIPT_STRING_HPP
#define CYCRIPT_STRING_HPP
-#include "Pooling.hpp"
-
#include <iostream>
+#include "Pooling.hpp"
+
struct CYUTF8String {
const char *data;
size_t size;
--- /dev/null
+/* 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 <http://www.gnu.org/licenses/>.
+**/
+/* }}} */
+
+#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
--- /dev/null
+/* 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 <http://www.gnu.org/licenses/>.
+**/
+/* }}} */
+
+#ifndef CYCRIPT_SYNTAX_HPP
+#define CYCRIPT_SYNTAX_HPP
+
+#include <cstdio>
+#include <cstdlib>
+
+#include <streambuf>
+#include <string>
+#include <vector>
+#include <map>
+#include <set>
+
+#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<CYFlags>(~static_cast<unsigned>(rhs));
+}
+
+_finline CYFlags operator &(CYFlags lhs, CYFlags rhs) {
+ return static_cast<CYFlags>(static_cast<unsigned>(lhs) & static_cast<unsigned>(rhs));
+}
+
+_finline CYFlags operator |(CYFlags lhs, CYFlags rhs) {
+ return static_cast<CYFlags>(static_cast<unsigned>(lhs) | static_cast<unsigned>(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<CYStatement>,
+ 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<CYIdentifier>,
+ 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<const char *, const char *, bool>
+{
+ _finline bool operator ()(const char *lhs, const char *rhs) const {
+ return strcmp(lhs, rhs) < 0;
+ }
+};
+
+struct CYIdentifierValueLess :
+ std::binary_function<CYIdentifier *, CYIdentifier *, bool>
+{
+ _finline bool operator ()(CYIdentifier *lhs, CYIdentifier *rhs) const {
+ return CYCStringLess()(lhs->Word(), rhs->Word());
+ }
+};
+
+enum CYIdentifierFlags {
+ CYIdentifierArgument,
+ CYIdentifierVariable,
+ CYIdentifierOther,
+ CYIdentifierMagic,
+ CYIdentifierCatch,
+};
+
+typedef std::set<const char *, CYCStringLess> CYCStringSet;
+typedef std::set<CYIdentifier *, CYIdentifierValueLess> CYIdentifierValueSet;
+typedef std::map<CYIdentifier *, CYIdentifierFlags> CYIdentifierAddressFlagsMap;
+
+struct CYIdentifierUsage {
+ CYIdentifier *identifier_;
+ size_t usage_;
+};
+
+typedef std::vector<CYIdentifierUsage> 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 <typename Type_>
+ 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<CYThisScope>
+{
+ 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<CYFunctionParameter>,
+ CYThing
+{
+ CYForInInitializer *initialiser_;
+
+ CYFunctionParameter(CYForInInitializer *initialiser, CYFunctionParameter *next = NULL) :
+ CYNext<CYFunctionParameter>(next),
+ initialiser_(initialiser)
+ {
+ }
+
+ void Replace(CYContext &context, CYStatement *&statements);
+ void Output(CYOutput &out) const;
+};
+
+struct CYComprehension :
+ CYNext<CYComprehension>,
+ CYThing
+{
+ CYComprehension(CYComprehension *next = NULL) :
+ CYNext<CYComprehension>(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<CYSpan>
+{
+ CYExpression *expression_;
+ CYString *string_;
+
+ CYSpan(CYExpression *expression, CYString *string, CYSpan *next) :
+ CYNext<CYSpan>(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<CYArgument>,
+ CYThing
+{
+ CYWord *name_;
+ CYExpression *value_;
+
+ CYArgument(CYExpression *value, CYArgument *next = NULL) :
+ CYNext<CYArgument>(next),
+ name_(NULL),
+ value_(value)
+ {
+ }
+
+ CYArgument(CYWord *name, CYExpression *value, CYArgument *next = NULL) :
+ CYNext<CYArgument>(next),
+ name_(name),
+ value_(value)
+ {
+ }
+
+ CYArgument *Replace(CYContext &context);
+ void Output(CYOutput &out) const;
+};
+
+struct CYClause :
+ CYThing,
+ CYNext<CYClause>
+{
+ 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>,
+ CYElement
+{
+ CYExpression *value_;
+
+ CYElementValue(CYExpression *value, CYElement *next) :
+ CYNext<CYElement>(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<CYProperty>,
+ CYThing
+{
+ CYPropertyName *name_;
+ CYExpression *value_;
+
+ CYProperty(CYPropertyName *name, CYExpression *value, CYProperty *next = NULL) :
+ CYNext<CYProperty>(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<CYDeclarations>,
+ CYThing
+{
+ CYDeclaration *declaration_;
+
+ CYDeclarations(CYDeclaration *declaration, CYDeclarations *next = NULL) :
+ CYNext<CYDeclarations>(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(CYTypeModifier *next) :
+ CYNext<CYTypeModifier>(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<CYTypedIdentifier>,
+ 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<CYTypedParameter>,
+ CYThing
+{
+ CYTypedIdentifier *typed_;
+
+ CYTypedParameter(CYTypedIdentifier *typed, CYTypedParameter *next) :
+ CYNext<CYTypedParameter>(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<CYModule>,
+ CYThing
+{
+ CYWord *part_;
+
+ CYModule(CYWord *part, CYModule *next = NULL) :
+ CYNext<CYModule>(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*/
#!/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/ .*//')"
#ifndef CYCRIPT_HPP
#define CYCRIPT_HPP
-#include <sig/types.hpp>
#include <sstream>
+#include <sig/types.hpp>
+
#include "Pooling.hpp"
#include "String.hpp"
projects / cycript.git / commitdiff
