|
|
|
@ -1,6 +1,6 @@
|
|
|
|
/*
|
|
|
|
/*
|
|
|
|
Source:
|
|
|
|
Source:
|
|
|
|
github:tree-sitter/tree-sitter-typescript#0ab9d99867435a7667c5548a6617a6bf73dbd830
|
|
|
|
0.20.5
|
|
|
|
|
|
|
|
|
|
|
|
The MIT License (MIT)
|
|
|
|
The MIT License (MIT)
|
|
|
|
|
|
|
|
|
|
|
|
@ -25,220 +25,300 @@ OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
|
|
|
|
SOFTWARE.
|
|
|
|
SOFTWARE.
|
|
|
|
*/
|
|
|
|
*/
|
|
|
|
|
|
|
|
|
|
|
|
#include <tree_sitter/parser.h>
|
|
|
|
#include "tree_sitter/parser.h"
|
|
|
|
|
|
|
|
|
|
|
|
#include <wctype.h>
|
|
|
|
#include <wctype.h>
|
|
|
|
|
|
|
|
|
|
|
|
enum TokenType {
|
|
|
|
enum TokenType {
|
|
|
|
AUTOMATIC_SEMICOLON,
|
|
|
|
AUTOMATIC_SEMICOLON,
|
|
|
|
TEMPLATE_CHARS,
|
|
|
|
TEMPLATE_CHARS,
|
|
|
|
TERNARY_QMARK,
|
|
|
|
TERNARY_QMARK,
|
|
|
|
BINARY_OPERATORS,
|
|
|
|
HTML_COMMENT,
|
|
|
|
FUNCTION_SIGNATURE_AUTOMATIC_SEMICOLON,
|
|
|
|
LOGICAL_OR,
|
|
|
|
|
|
|
|
ESCAPE_SEQUENCE,
|
|
|
|
|
|
|
|
FUNCTION_SIGNATURE_AUTOMATIC_SEMICOLON,
|
|
|
|
|
|
|
|
ERROR_RECOVERY,
|
|
|
|
};
|
|
|
|
};
|
|
|
|
|
|
|
|
|
|
|
|
static void advance(TSLexer *lexer) { lexer->advance(lexer, false); }
|
|
|
|
static void advance(TSLexer *lexer) { lexer->advance(lexer, false); }
|
|
|
|
|
|
|
|
|
|
|
|
static void skip(TSLexer *lexer) { lexer->advance(lexer, true); }
|
|
|
|
static void skip(TSLexer *lexer) { lexer->advance(lexer, true); }
|
|
|
|
|
|
|
|
|
|
|
|
static bool scan_template_chars(TSLexer *lexer) {
|
|
|
|
static bool scan_template_chars(TSLexer *lexer) {
|
|
|
|
lexer->result_symbol = TEMPLATE_CHARS;
|
|
|
|
lexer->result_symbol = TEMPLATE_CHARS;
|
|
|
|
for (bool has_content = false;; has_content = true) {
|
|
|
|
for (bool has_content = false;; has_content = true) {
|
|
|
|
lexer->mark_end(lexer);
|
|
|
|
lexer->mark_end(lexer);
|
|
|
|
switch (lexer->lookahead) {
|
|
|
|
switch (lexer->lookahead) {
|
|
|
|
case '`':
|
|
|
|
case '`':
|
|
|
|
return has_content;
|
|
|
|
return has_content;
|
|
|
|
case '\0':
|
|
|
|
case '\0':
|
|
|
|
return false;
|
|
|
|
return false;
|
|
|
|
case '$':
|
|
|
|
case '$':
|
|
|
|
advance(lexer);
|
|
|
|
advance(lexer);
|
|
|
|
if (lexer->lookahead == '{') return has_content;
|
|
|
|
if (lexer->lookahead == '{') {
|
|
|
|
break;
|
|
|
|
return has_content;
|
|
|
|
case '\\':
|
|
|
|
}
|
|
|
|
return has_content;
|
|
|
|
break;
|
|
|
|
default:
|
|
|
|
case '\\':
|
|
|
|
advance(lexer);
|
|
|
|
return has_content;
|
|
|
|
|
|
|
|
default:
|
|
|
|
|
|
|
|
advance(lexer);
|
|
|
|
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
static bool scan_whitespace_and_comments(TSLexer *lexer) {
|
|
|
|
static bool scan_whitespace_and_comments(TSLexer *lexer, bool *scanned_comment) {
|
|
|
|
for (;;) {
|
|
|
|
for (;;) {
|
|
|
|
while (iswspace(lexer->lookahead)) {
|
|
|
|
while (iswspace(lexer->lookahead)) {
|
|
|
|
skip(lexer);
|
|
|
|
skip(lexer);
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
if (lexer->lookahead == '/') {
|
|
|
|
|
|
|
|
skip(lexer);
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
if (lexer->lookahead == '/') {
|
|
|
|
|
|
|
|
skip(lexer);
|
|
|
|
|
|
|
|
while (lexer->lookahead != 0 && lexer->lookahead != '\n') {
|
|
|
|
|
|
|
|
skip(lexer);
|
|
|
|
|
|
|
|
}
|
|
|
|
}
|
|
|
|
} else if (lexer->lookahead == '*') {
|
|
|
|
|
|
|
|
skip(lexer);
|
|
|
|
if (lexer->lookahead == '/') {
|
|
|
|
while (lexer->lookahead != 0) {
|
|
|
|
|
|
|
|
if (lexer->lookahead == '*') {
|
|
|
|
|
|
|
|
skip(lexer);
|
|
|
|
skip(lexer);
|
|
|
|
|
|
|
|
|
|
|
|
if (lexer->lookahead == '/') {
|
|
|
|
if (lexer->lookahead == '/') {
|
|
|
|
skip(lexer);
|
|
|
|
skip(lexer);
|
|
|
|
break;
|
|
|
|
while (lexer->lookahead != 0 && lexer->lookahead != '\n') {
|
|
|
|
|
|
|
|
skip(lexer);
|
|
|
|
|
|
|
|
}
|
|
|
|
|
|
|
|
*scanned_comment = true;
|
|
|
|
|
|
|
|
} else if (lexer->lookahead == '*') {
|
|
|
|
|
|
|
|
skip(lexer);
|
|
|
|
|
|
|
|
while (lexer->lookahead != 0) {
|
|
|
|
|
|
|
|
if (lexer->lookahead == '*') {
|
|
|
|
|
|
|
|
skip(lexer);
|
|
|
|
|
|
|
|
if (lexer->lookahead == '/') {
|
|
|
|
|
|
|
|
skip(lexer);
|
|
|
|
|
|
|
|
break;
|
|
|
|
|
|
|
|
}
|
|
|
|
|
|
|
|
} else {
|
|
|
|
|
|
|
|
skip(lexer);
|
|
|
|
|
|
|
|
}
|
|
|
|
|
|
|
|
}
|
|
|
|
|
|
|
|
} else {
|
|
|
|
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
} else {
|
|
|
|
} else {
|
|
|
|
skip(lexer);
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
|
|
|
|
}
|
|
|
|
}
|
|
|
|
} else {
|
|
|
|
|
|
|
|
return false;
|
|
|
|
|
|
|
|
}
|
|
|
|
|
|
|
|
} else {
|
|
|
|
|
|
|
|
return true;
|
|
|
|
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
static bool scan_automatic_semicolon(TSLexer *lexer, const bool *valid_symbols){
|
|
|
|
static bool scan_automatic_semicolon(TSLexer *lexer, const bool *valid_symbols, bool *scanned_comment) {
|
|
|
|
lexer->result_symbol = AUTOMATIC_SEMICOLON;
|
|
|
|
lexer->result_symbol = AUTOMATIC_SEMICOLON;
|
|
|
|
lexer->mark_end(lexer);
|
|
|
|
lexer->mark_end(lexer);
|
|
|
|
|
|
|
|
|
|
|
|
for (;;) {
|
|
|
|
for (;;) {
|
|
|
|
if (lexer->lookahead == 0) return true;
|
|
|
|
if (lexer->lookahead == 0) {
|
|
|
|
if (lexer->lookahead == '}') {
|
|
|
|
return true;
|
|
|
|
// Automatic semicolon insertion breaks detection of object patterns
|
|
|
|
}
|
|
|
|
// in a typed context:
|
|
|
|
if (lexer->lookahead == '}') {
|
|
|
|
// type F = ({a}: {a: number}) => number;
|
|
|
|
// Automatic semicolon insertion breaks detection of object patterns
|
|
|
|
// Therefore, disable automatic semicolons when followed by typing
|
|
|
|
// in a typed context:
|
|
|
|
do {
|
|
|
|
// type F = ({a}: {a: number}) => number;
|
|
|
|
|
|
|
|
// Therefore, disable automatic semicolons when followed by typing
|
|
|
|
|
|
|
|
do {
|
|
|
|
|
|
|
|
skip(lexer);
|
|
|
|
|
|
|
|
} while (iswspace(lexer->lookahead));
|
|
|
|
|
|
|
|
if (lexer->lookahead == ':') {
|
|
|
|
|
|
|
|
return false;
|
|
|
|
|
|
|
|
}
|
|
|
|
|
|
|
|
return true;
|
|
|
|
|
|
|
|
}
|
|
|
|
|
|
|
|
if (!iswspace(lexer->lookahead)) {
|
|
|
|
|
|
|
|
return false;
|
|
|
|
|
|
|
|
}
|
|
|
|
|
|
|
|
if (lexer->lookahead == '\n') {
|
|
|
|
|
|
|
|
break;
|
|
|
|
|
|
|
|
}
|
|
|
|
skip(lexer);
|
|
|
|
skip(lexer);
|
|
|
|
} while (iswspace(lexer->lookahead));
|
|
|
|
|
|
|
|
if (lexer->lookahead == ':') return false;
|
|
|
|
|
|
|
|
return true;
|
|
|
|
|
|
|
|
}
|
|
|
|
}
|
|
|
|
if (!iswspace(lexer->lookahead)) return false;
|
|
|
|
|
|
|
|
if (lexer->lookahead == '\n') break;
|
|
|
|
|
|
|
|
skip(lexer);
|
|
|
|
skip(lexer);
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
skip(lexer);
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
if (!scan_whitespace_and_comments(lexer)) return false;
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
switch (lexer->lookahead) {
|
|
|
|
|
|
|
|
case ',':
|
|
|
|
|
|
|
|
case '.':
|
|
|
|
|
|
|
|
case ';':
|
|
|
|
|
|
|
|
case '*':
|
|
|
|
|
|
|
|
case '%':
|
|
|
|
|
|
|
|
case '>':
|
|
|
|
|
|
|
|
case '<':
|
|
|
|
|
|
|
|
case '=':
|
|
|
|
|
|
|
|
case '?':
|
|
|
|
|
|
|
|
case '^':
|
|
|
|
|
|
|
|
case '|':
|
|
|
|
|
|
|
|
case '&':
|
|
|
|
|
|
|
|
case '/':
|
|
|
|
|
|
|
|
case ':':
|
|
|
|
|
|
|
|
return false;
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
case '{':
|
|
|
|
if (!scan_whitespace_and_comments(lexer, scanned_comment)) {
|
|
|
|
if (valid_symbols[FUNCTION_SIGNATURE_AUTOMATIC_SEMICOLON]) return false;
|
|
|
|
return false;
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
// Don't insert a semicolon before a '[' or '(', unless we're parsing
|
|
|
|
switch (lexer->lookahead) {
|
|
|
|
// a type. Detect whether we're parsing a type or an expression using
|
|
|
|
case ',':
|
|
|
|
// the validity of a binary operator token.
|
|
|
|
case '.':
|
|
|
|
case '(':
|
|
|
|
case ';':
|
|
|
|
case '[':
|
|
|
|
case '*':
|
|
|
|
if (valid_symbols[BINARY_OPERATORS]) return false;
|
|
|
|
case '%':
|
|
|
|
break;
|
|
|
|
case '>':
|
|
|
|
|
|
|
|
case '<':
|
|
|
|
|
|
|
|
case '=':
|
|
|
|
|
|
|
|
case '?':
|
|
|
|
|
|
|
|
case '^':
|
|
|
|
|
|
|
|
case '|':
|
|
|
|
|
|
|
|
case '&':
|
|
|
|
|
|
|
|
case '/':
|
|
|
|
|
|
|
|
case ':':
|
|
|
|
|
|
|
|
return false;
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
case '{':
|
|
|
|
|
|
|
|
if (valid_symbols[FUNCTION_SIGNATURE_AUTOMATIC_SEMICOLON]) {
|
|
|
|
|
|
|
|
return false;
|
|
|
|
|
|
|
|
}
|
|
|
|
|
|
|
|
break;
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
// Don't insert a semicolon before a '[' or '(', unless we're parsing
|
|
|
|
|
|
|
|
// a type. Detect whether we're parsing a type or an expression using
|
|
|
|
|
|
|
|
// the validity of a binary operator token.
|
|
|
|
|
|
|
|
case '(':
|
|
|
|
|
|
|
|
case '[':
|
|
|
|
|
|
|
|
if (valid_symbols[LOGICAL_OR]) {
|
|
|
|
|
|
|
|
return false;
|
|
|
|
|
|
|
|
}
|
|
|
|
|
|
|
|
break;
|
|
|
|
|
|
|
|
|
|
|
|
// Insert a semicolon before `--` and `++`, but not before binary `+` or `-`.
|
|
|
|
// Insert a semicolon before `--` and `++`, but not before binary `+` or `-`.
|
|
|
|
case '+':
|
|
|
|
case '+':
|
|
|
|
skip(lexer);
|
|
|
|
skip(lexer);
|
|
|
|
return lexer->lookahead == '+';
|
|
|
|
return lexer->lookahead == '+';
|
|
|
|
case '-':
|
|
|
|
case '-':
|
|
|
|
skip(lexer);
|
|
|
|
skip(lexer);
|
|
|
|
return lexer->lookahead == '-';
|
|
|
|
return lexer->lookahead == '-';
|
|
|
|
|
|
|
|
|
|
|
|
// Don't insert a semicolon before `!=`, but do insert one before a unary `!`.
|
|
|
|
// Don't insert a semicolon before `!=`, but do insert one before a unary `!`.
|
|
|
|
case '!':
|
|
|
|
case '!':
|
|
|
|
skip(lexer);
|
|
|
|
skip(lexer);
|
|
|
|
return lexer->lookahead != '=';
|
|
|
|
return lexer->lookahead != '=';
|
|
|
|
|
|
|
|
|
|
|
|
// Don't insert a semicolon before `in` or `instanceof`, but do insert one
|
|
|
|
// Don't insert a semicolon before `in` or `instanceof`, but do insert one
|
|
|
|
// before an identifier.
|
|
|
|
// before an identifier.
|
|
|
|
case 'i':
|
|
|
|
case 'i':
|
|
|
|
skip(lexer);
|
|
|
|
skip(lexer);
|
|
|
|
|
|
|
|
|
|
|
|
if (lexer->lookahead != 'n') return true;
|
|
|
|
if (lexer->lookahead != 'n') {
|
|
|
|
skip(lexer);
|
|
|
|
return true;
|
|
|
|
|
|
|
|
}
|
|
|
|
|
|
|
|
skip(lexer);
|
|
|
|
|
|
|
|
|
|
|
|
if (!iswalpha(lexer->lookahead)) return false;
|
|
|
|
if (!iswalpha(lexer->lookahead)) {
|
|
|
|
|
|
|
|
return false;
|
|
|
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
for (unsigned i = 0; i < 8; i++) {
|
|
|
|
for (unsigned i = 0; i < 8; i++) {
|
|
|
|
if (lexer->lookahead != "stanceof"[i]) return true;
|
|
|
|
if (lexer->lookahead != "stanceof"[i]) {
|
|
|
|
skip(lexer);
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
skip(lexer);
|
|
|
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
if (!iswalpha(lexer->lookahead)) return false;
|
|
|
|
if (!iswalpha(lexer->lookahead)) {
|
|
|
|
break;
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
break;
|
|
|
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
return true;
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
static bool scan_ternary_qmark(TSLexer *lexer) {
|
|
|
|
static bool scan_ternary_qmark(TSLexer *lexer) {
|
|
|
|
for(;;) {
|
|
|
|
for (;;) {
|
|
|
|
if (!iswspace(lexer->lookahead)) break;
|
|
|
|
if (!iswspace(lexer->lookahead)) {
|
|
|
|
skip(lexer);
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
skip(lexer);
|
|
|
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
if (lexer->lookahead == '?') {
|
|
|
|
if (lexer->lookahead == '?') {
|
|
|
|
advance(lexer);
|
|
|
|
advance(lexer);
|
|
|
|
|
|
|
|
|
|
|
|
if (lexer->lookahead == '?') return false;
|
|
|
|
/* Optional chaining. */
|
|
|
|
/* Optional chaining. */
|
|
|
|
if (lexer->lookahead == '?' || lexer->lookahead == '.') {
|
|
|
|
if (lexer->lookahead == '.') return false;
|
|
|
|
return false;
|
|
|
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
lexer->mark_end(lexer);
|
|
|
|
lexer->mark_end(lexer);
|
|
|
|
lexer->result_symbol = TERNARY_QMARK;
|
|
|
|
lexer->result_symbol = TERNARY_QMARK;
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
/* TypeScript optional arguments contain the ?: sequence, possibly
|
|
|
|
|
|
|
|
with whitespace. */
|
|
|
|
|
|
|
|
for (;;) {
|
|
|
|
|
|
|
|
if (!iswspace(lexer->lookahead)) {
|
|
|
|
|
|
|
|
break;
|
|
|
|
|
|
|
|
}
|
|
|
|
|
|
|
|
advance(lexer);
|
|
|
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
if (lexer->lookahead == ':' || lexer->lookahead == ')' || lexer->lookahead == ',') {
|
|
|
|
|
|
|
|
return false;
|
|
|
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
/* TypeScript optional arguments contain the ?: sequence, possibly
|
|
|
|
if (lexer->lookahead == '.') {
|
|
|
|
with whitespace. */
|
|
|
|
advance(lexer);
|
|
|
|
for(;;) {
|
|
|
|
if (iswdigit(lexer->lookahead)) {
|
|
|
|
if (!iswspace(lexer->lookahead)) break;
|
|
|
|
return true;
|
|
|
|
advance(lexer);
|
|
|
|
}
|
|
|
|
|
|
|
|
return false;
|
|
|
|
|
|
|
|
}
|
|
|
|
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
if (lexer->lookahead == ':') return false;
|
|
|
|
return false;
|
|
|
|
if (lexer->lookahead == ')') return false;
|
|
|
|
}
|
|
|
|
if (lexer->lookahead == ',') return false;
|
|
|
|
|
|
|
|
|
|
|
|
static bool scan_closing_comment(TSLexer *lexer) {
|
|
|
|
if (lexer->lookahead == '.') {
|
|
|
|
while (iswspace(lexer->lookahead) || lexer->lookahead == 0x2028 || lexer->lookahead == 0x2029) {
|
|
|
|
advance(lexer);
|
|
|
|
skip(lexer);
|
|
|
|
if (iswdigit(lexer->lookahead)) return true;
|
|
|
|
|
|
|
|
return false;
|
|
|
|
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
const char *comment_start = "<!--";
|
|
|
|
|
|
|
|
const char *comment_end = "-->";
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
if (lexer->lookahead == '<') {
|
|
|
|
|
|
|
|
for (unsigned i = 0; i < 4; i++) {
|
|
|
|
|
|
|
|
if (lexer->lookahead != comment_start[i]) {
|
|
|
|
|
|
|
|
return false;
|
|
|
|
|
|
|
|
}
|
|
|
|
|
|
|
|
advance(lexer);
|
|
|
|
|
|
|
|
}
|
|
|
|
|
|
|
|
} else if (lexer->lookahead == '-') {
|
|
|
|
|
|
|
|
for (unsigned i = 0; i < 3; i++) {
|
|
|
|
|
|
|
|
if (lexer->lookahead != comment_end[i]) {
|
|
|
|
|
|
|
|
return false;
|
|
|
|
|
|
|
|
}
|
|
|
|
|
|
|
|
advance(lexer);
|
|
|
|
|
|
|
|
}
|
|
|
|
|
|
|
|
} else {
|
|
|
|
|
|
|
|
return false;
|
|
|
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
while (lexer->lookahead != 0 && lexer->lookahead != '\n' && lexer->lookahead != 0x2028 &&
|
|
|
|
|
|
|
|
lexer->lookahead != 0x2029) {
|
|
|
|
|
|
|
|
advance(lexer);
|
|
|
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
lexer->result_symbol = HTML_COMMENT;
|
|
|
|
|
|
|
|
lexer->mark_end(lexer);
|
|
|
|
|
|
|
|
|
|
|
|
return true;
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
|
|
|
|
return false;
|
|
|
|
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
static inline bool external_scanner_scan(void *payload, TSLexer *lexer, const bool *valid_symbols) {
|
|
|
|
static inline bool external_scanner_scan(void *payload, TSLexer *lexer, const bool *valid_symbols) {
|
|
|
|
if (valid_symbols[TEMPLATE_CHARS]) {
|
|
|
|
if (valid_symbols[TEMPLATE_CHARS]) {
|
|
|
|
if (valid_symbols[AUTOMATIC_SEMICOLON]) return false;
|
|
|
|
if (valid_symbols[AUTOMATIC_SEMICOLON]) {
|
|
|
|
return scan_template_chars(lexer);
|
|
|
|
return false;
|
|
|
|
} else if (
|
|
|
|
}
|
|
|
|
valid_symbols[AUTOMATIC_SEMICOLON] ||
|
|
|
|
return scan_template_chars(lexer);
|
|
|
|
valid_symbols[FUNCTION_SIGNATURE_AUTOMATIC_SEMICOLON]
|
|
|
|
}
|
|
|
|
) {
|
|
|
|
if (valid_symbols[AUTOMATIC_SEMICOLON] || valid_symbols[FUNCTION_SIGNATURE_AUTOMATIC_SEMICOLON]) {
|
|
|
|
bool ret = scan_automatic_semicolon(lexer, valid_symbols);
|
|
|
|
bool scanned_comment = false;
|
|
|
|
if (!ret && valid_symbols[TERNARY_QMARK] && lexer->lookahead == '?')
|
|
|
|
bool ret = scan_automatic_semicolon(lexer, valid_symbols, &scanned_comment);
|
|
|
|
return scan_ternary_qmark(lexer);
|
|
|
|
if (!ret && !scanned_comment && valid_symbols[TERNARY_QMARK] && lexer->lookahead == '?') {
|
|
|
|
return ret;
|
|
|
|
return scan_ternary_qmark(lexer);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
if (valid_symbols[TERNARY_QMARK]) {
|
|
|
|
return ret;
|
|
|
|
return scan_ternary_qmark(lexer);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
if (valid_symbols[TERNARY_QMARK]) {
|
|
|
|
|
|
|
|
return scan_ternary_qmark(lexer);
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
if (valid_symbols[HTML_COMMENT] && !valid_symbols[LOGICAL_OR] && !valid_symbols[ESCAPE_SEQUENCE]) {
|
|
|
|
|
|
|
|
return scan_closing_comment(lexer);
|
|
|
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
Wilfred Hughes