wehub-resource-sync
1759 lines
62 KiB
C
1759 lines
62 KiB
C
#include "tag.h"
|
|
#include "tree_sitter/parser.h"
|
|
|
|
#include <stdint.h>
|
|
#include <string.h>
|
|
#include <wctype.h>
|
|
|
|
enum TokenType {
|
|
AUTOMATIC_SEMICOLON,
|
|
TERNARY_QMARK,
|
|
ELVIS_OPERATOR,
|
|
LOGICAL_OR,
|
|
CF_START_TAG_NAME,
|
|
CF_END_TAG_NAME,
|
|
ERRONEOUS_CF_END_TAG_NAME,
|
|
CF_SELF_CLOSING_TAG_DELIMITER,
|
|
CF_SELF_CLOSING_VOID_TAG_DELIMITER,
|
|
IMPLICIT_CF_END_TAG,
|
|
RAW_TEXT,
|
|
CFML_COMMENT,
|
|
CLOSE_TAG_DELIM,
|
|
CLOSE_CF_TAG_DELIM,
|
|
HTML_TEXT,
|
|
CF_VOID_START_TAG_NAME,
|
|
CF_SET_START_TAG_NAME,
|
|
CF_IF_START_TAG_NAME,
|
|
CF_IF_END_TAG_NAME,
|
|
CF_ELSEIF_TAG_NAME,
|
|
CF_ELSE_TAG_NAME,
|
|
CF_RETURN_START_TAG_NAME,
|
|
CF_OUTPUT_START_TAG_NAME,
|
|
|
|
// Rules below this point are not included by the cfquery dialect
|
|
SCRIPT_START_TAG_NAME,
|
|
STYLE_START_TAG_NAME,
|
|
START_TAG_NAME,
|
|
END_TAG_NAME,
|
|
ERRONEOUS_END_TAG_NAME,
|
|
SELF_CLOSING_TAG_DELIMITER,
|
|
IMPLICIT_END_TAG,
|
|
|
|
START_HASH_EXPRESSION,
|
|
SINGLE_HASH,
|
|
HASH_EMPTY,
|
|
|
|
CF_XML_START_TAG_NAME,
|
|
CF_XML_END_TAG_NAME,
|
|
CF_XML_CONTENT,
|
|
|
|
CF_QUERY_START_TAG_NAME,
|
|
CF_QUERY_END_TAG_NAME,
|
|
CF_QUERY_CONTENT,
|
|
|
|
CF_SCRIPT_START_TAG_NAME,
|
|
CF_SCRIPT_END_TAG_NAME,
|
|
CF_SCRIPT_CONTENT,
|
|
|
|
CF_SAVECONTENT_START_TAG_NAME,
|
|
CF_SAVECONTENT_END_TAG_NAME,
|
|
CF_SAVECONTENT_BODY_CFML,
|
|
CF_SAVECONTENT_BODY_HTML,
|
|
CF_SAVECONTENT_BODY_SCRIPT,
|
|
CF_SAVECONTENT_BODY_CSS,
|
|
CF_SAVECONTENT_BODY_XML,
|
|
CF_SAVECONTENT_BODY_SQL,
|
|
CF_SAVECONTENT_BODY_RAW,
|
|
CF_SAVECONTENT_CONTENT,
|
|
|
|
CF_FUNCTION_START_TAG_NAME,
|
|
CF_FUNCTION_END_TAG_NAME,
|
|
|
|
CF_COMPONENT_START_TAG_NAME,
|
|
CF_COMPONENT_END_TAG_NAME,
|
|
|
|
CF_COMPONENT_CONTENT,
|
|
SCANNER_SYMBOL_COUNT
|
|
};
|
|
|
|
typedef struct {
|
|
Array(Tag) tags;
|
|
Array(Tag) cf_tags;
|
|
uint16_t cfoutput_depth;
|
|
uint16_t cfcomponent_depth;
|
|
uint16_t cffunction_depth;
|
|
} Scanner;
|
|
|
|
typedef enum {
|
|
REJECT, // Semicolon is illegal, ie a syntax error occurred
|
|
NO_NEWLINE, // Unclear if semicolon will be legal, continue
|
|
ACCEPT, // Semicolon is legal, assuming a comment was encountered
|
|
} WhitespaceResult;
|
|
|
|
#define MAX(a, b) ((a) > (b) ? (a) : (b))
|
|
|
|
#define MAX_CF_END_DELIMITER_SIZE 256
|
|
|
|
#define VS(vs, sym, count) ((unsigned)(sym) < (count) && (vs)[(sym)])
|
|
|
|
static inline void advance(TSLexer *lexer) { lexer->advance(lexer, false); }
|
|
|
|
static inline void skip(TSLexer *lexer) { lexer->advance(lexer, true); }
|
|
|
|
static inline bool tag_has_name(TagType type, bool is_cfquery_context) {
|
|
return type == CUSTOM || type == CFML || type == CF_VOID || type == CF_SET ||
|
|
type == CF_XML || type == CF_SCRIPT || type == CF_SAVECONTENT ||
|
|
type == CF_QUERY || type == CF_OUTPUT || type == CF_FUNCTION || type == CF_RETURN ||
|
|
type == CF_IF || type == CF_ELSEIF || type == CF_ELSE;
|
|
}
|
|
|
|
static inline bool valid_start_tag_name(const bool *vs, unsigned count) {
|
|
return VS(vs, START_TAG_NAME, count) || VS(vs, SCRIPT_START_TAG_NAME, count) ||
|
|
VS(vs, CF_START_TAG_NAME, count) ||
|
|
VS(vs, CF_SET_START_TAG_NAME, count) || VS(vs, CF_VOID_START_TAG_NAME, count) ||
|
|
VS(vs, CF_RETURN_START_TAG_NAME, count) || VS(vs, CF_XML_START_TAG_NAME, count) ||
|
|
VS(vs, CF_QUERY_START_TAG_NAME, count) || VS(vs, CF_SCRIPT_START_TAG_NAME, count) ||
|
|
VS(vs, CF_SAVECONTENT_START_TAG_NAME, count) || VS(vs, CF_OUTPUT_START_TAG_NAME, count) ||
|
|
VS(vs, CF_FUNCTION_START_TAG_NAME, count) ||
|
|
VS(vs, CF_COMPONENT_START_TAG_NAME, count) ||
|
|
VS(vs, CF_IF_START_TAG_NAME, count) || VS(vs, CF_ELSEIF_TAG_NAME, count) ||
|
|
VS(vs, CF_ELSE_TAG_NAME, count);
|
|
}
|
|
|
|
static inline bool valid_end_tag_name(const bool *vs, unsigned count) {
|
|
return VS(vs, END_TAG_NAME, count) || VS(vs, CF_END_TAG_NAME, count) ||
|
|
VS(vs, CF_XML_END_TAG_NAME, count) || VS(vs, CF_QUERY_END_TAG_NAME, count) ||
|
|
VS(vs, CF_SCRIPT_END_TAG_NAME, count) || VS(vs, CF_SAVECONTENT_END_TAG_NAME, count) ||
|
|
VS(vs, CF_FUNCTION_END_TAG_NAME, count) ||
|
|
VS(vs, CF_IF_END_TAG_NAME, count);
|
|
}
|
|
|
|
static inline bool valid_cf_start_tag_name(const bool *vs, unsigned count) {
|
|
return VS(vs, CF_START_TAG_NAME, count) || VS(vs, CF_SET_START_TAG_NAME, count) ||
|
|
VS(vs, CF_VOID_START_TAG_NAME, count) || VS(vs, CF_RETURN_START_TAG_NAME, count) ||
|
|
VS(vs, CF_XML_START_TAG_NAME, count) || VS(vs, CF_QUERY_START_TAG_NAME, count) ||
|
|
VS(vs, CF_SCRIPT_START_TAG_NAME, count) || VS(vs, CF_SAVECONTENT_START_TAG_NAME, count) ||
|
|
VS(vs, CF_OUTPUT_START_TAG_NAME, count) || VS(vs, CF_FUNCTION_START_TAG_NAME, count) ||
|
|
VS(vs, CF_COMPONENT_START_TAG_NAME, count) ||
|
|
VS(vs, CF_IF_START_TAG_NAME, count) || VS(vs, CF_ELSEIF_TAG_NAME, count) ||
|
|
VS(vs, CF_ELSE_TAG_NAME, count);
|
|
}
|
|
|
|
static inline bool valid_cf_end_tag_name(const bool *vs, unsigned count) {
|
|
return VS(vs, CF_END_TAG_NAME, count) || VS(vs, CF_XML_END_TAG_NAME, count) ||
|
|
VS(vs, CF_QUERY_END_TAG_NAME, count) || VS(vs, CF_SCRIPT_END_TAG_NAME, count) ||
|
|
VS(vs, CF_SAVECONTENT_END_TAG_NAME, count) || VS(vs, CF_FUNCTION_END_TAG_NAME, count) ||
|
|
VS(vs, CF_IF_END_TAG_NAME, count);
|
|
}
|
|
|
|
static inline bool no_content_symbols(const bool *vs, unsigned count) {
|
|
return !VS(vs, RAW_TEXT, count) && !VS(vs, CF_XML_CONTENT, count) &&
|
|
!VS(vs, CF_QUERY_CONTENT, count) && !VS(vs, CF_SCRIPT_CONTENT, count);
|
|
}
|
|
|
|
static inline bool implicit_cf_end_tag_valid(const bool *vs, unsigned count) {
|
|
return VS(vs, IMPLICIT_CF_END_TAG, count) && !VS(vs, CF_XML_END_TAG_NAME, count) &&
|
|
!VS(vs, CF_QUERY_END_TAG_NAME, count) && !VS(vs, CF_SCRIPT_END_TAG_NAME, count) &&
|
|
!VS(vs, CF_SAVECONTENT_END_TAG_NAME, count) && !VS(vs, CF_FUNCTION_END_TAG_NAME, count) &&
|
|
!VS(vs, CF_IF_END_TAG_NAME, count) &&
|
|
!VS(vs, CF_ELSEIF_TAG_NAME, count) && !VS(vs, CF_ELSE_TAG_NAME, count);
|
|
}
|
|
|
|
#define SERIALIZE_TAGS(tags_field, buffer, size, is_cfquery_context) do { \
|
|
uint16_t _count = (tags_field).size > UINT16_MAX ? UINT16_MAX : (tags_field).size; \
|
|
uint16_t _serialized = 0; \
|
|
unsigned _count_offset = (size); \
|
|
if ((size) + sizeof(_count) + sizeof(_count) > TREE_SITTER_SERIALIZATION_BUFFER_SIZE) break; \
|
|
(size) += sizeof(_count); \
|
|
(size) += sizeof(_count); \
|
|
for (; _serialized < _count; _serialized++) { \
|
|
Tag _tag = (tags_field).contents[_serialized]; \
|
|
if (tag_has_name(_tag.type, is_cfquery_context)) { \
|
|
unsigned _len = _tag.tag_name.size; \
|
|
if (_len > UINT8_MAX) _len = UINT8_MAX; \
|
|
if ((size) + 2 + _len + sizeof(_tag.html_depth) >= TREE_SITTER_SERIALIZATION_BUFFER_SIZE) break; \
|
|
(buffer)[(size)++] = (char)_tag.type; \
|
|
(buffer)[(size)++] = (char)_len; \
|
|
strncpy(&(buffer)[(size)], _tag.tag_name.contents, _len); \
|
|
(size) += _len; \
|
|
memcpy(&(buffer)[(size)], &_tag.html_depth, sizeof(_tag.html_depth)); \
|
|
(size) += sizeof(_tag.html_depth); \
|
|
} else { \
|
|
if ((size) + 1 >= TREE_SITTER_SERIALIZATION_BUFFER_SIZE) break; \
|
|
(buffer)[(size)++] = (char)_tag.type; \
|
|
} \
|
|
} \
|
|
memcpy(&(buffer)[_count_offset], &_serialized, sizeof(_serialized)); \
|
|
memcpy(&(buffer)[_count_offset + sizeof(_serialized)], &_count, sizeof(_count)); \
|
|
} while(0)
|
|
|
|
static unsigned serialize(Scanner *scanner, char *buffer, bool is_cfquery_context) {
|
|
unsigned size = 0;
|
|
SERIALIZE_TAGS(scanner->tags, buffer, size, is_cfquery_context);
|
|
SERIALIZE_TAGS(scanner->cf_tags, buffer, size, is_cfquery_context);
|
|
if (size + sizeof(scanner->cfoutput_depth) + sizeof(scanner->cfcomponent_depth) + sizeof(scanner->cffunction_depth) < TREE_SITTER_SERIALIZATION_BUFFER_SIZE) {
|
|
memcpy(&buffer[size], &scanner->cfoutput_depth, sizeof(scanner->cfoutput_depth));
|
|
size += sizeof(scanner->cfoutput_depth);
|
|
memcpy(&buffer[size], &scanner->cfcomponent_depth, sizeof(scanner->cfcomponent_depth));
|
|
size += sizeof(scanner->cfcomponent_depth);
|
|
memcpy(&buffer[size], &scanner->cffunction_depth, sizeof(scanner->cffunction_depth));
|
|
size += sizeof(scanner->cffunction_depth);
|
|
}
|
|
return size;
|
|
}
|
|
|
|
#define DESERIALIZE_TAGS(tags_field, buffer, size, is_cfquery_context) do { \
|
|
for (unsigned _i = 0; _i < (tags_field).size; _i++) tag_free(&(tags_field).contents[_i]); \
|
|
array_clear(&(tags_field)); \
|
|
uint16_t _serialized = 0, _count = 0; \
|
|
memcpy(&_serialized, &(buffer)[(size)], sizeof(_serialized)); (size) += sizeof(_serialized); \
|
|
memcpy(&_count, &(buffer)[(size)], sizeof(_count)); (size) += sizeof(_count); \
|
|
array_reserve(&(tags_field), _count); \
|
|
unsigned _iter = 0; \
|
|
for (_iter = 0; _iter < _serialized; _iter++) { \
|
|
Tag _tag = tag_new(); \
|
|
_tag.type = (TagType)(unsigned char)(buffer)[(size)++]; \
|
|
if (tag_has_name(_tag.type, is_cfquery_context)) { \
|
|
uint16_t _len = (uint8_t)(buffer)[(size)++]; \
|
|
array_reserve(&_tag.tag_name, _len); \
|
|
_tag.tag_name.size = _len; \
|
|
memcpy(_tag.tag_name.contents, &(buffer)[(size)], _len); \
|
|
(size) += _len; \
|
|
memcpy(&_tag.html_depth, &(buffer)[(size)], sizeof(_tag.html_depth)); \
|
|
(size) += sizeof(_tag.html_depth); \
|
|
} \
|
|
array_push(&(tags_field), _tag); \
|
|
} \
|
|
for (; _iter < _count; _iter++) array_push(&(tags_field), tag_new()); \
|
|
} while(0)
|
|
|
|
static void deserialize(Scanner *scanner, const char *buffer, unsigned length, bool is_cfquery_context) {
|
|
scanner->cfoutput_depth = 0;
|
|
scanner->cfcomponent_depth = 0;
|
|
scanner->cffunction_depth = 0;
|
|
if (length > 0) {
|
|
unsigned size = 0;
|
|
DESERIALIZE_TAGS(scanner->tags, buffer, size, is_cfquery_context);
|
|
DESERIALIZE_TAGS(scanner->cf_tags, buffer, size, is_cfquery_context);
|
|
if (size + sizeof(scanner->cfoutput_depth) <= length) {
|
|
memcpy(&scanner->cfoutput_depth, &buffer[size], sizeof(scanner->cfoutput_depth));
|
|
size += sizeof(scanner->cfoutput_depth);
|
|
}
|
|
if (size + sizeof(scanner->cfcomponent_depth) <= length) {
|
|
memcpy(&scanner->cfcomponent_depth, &buffer[size], sizeof(scanner->cfcomponent_depth));
|
|
size += sizeof(scanner->cfcomponent_depth);
|
|
}
|
|
if (size + sizeof(scanner->cffunction_depth) <= length) {
|
|
memcpy(&scanner->cffunction_depth, &buffer[size], sizeof(scanner->cffunction_depth));
|
|
size += sizeof(scanner->cffunction_depth);
|
|
}
|
|
} else {
|
|
for (unsigned i = 0; i < scanner->tags.size; i++) tag_free(&scanner->tags.contents[i]);
|
|
array_clear(&scanner->tags);
|
|
for (unsigned i = 0; i < scanner->cf_tags.size; i++) tag_free(&scanner->cf_tags.contents[i]);
|
|
array_clear(&scanner->cf_tags);
|
|
}
|
|
}
|
|
|
|
typedef struct {
|
|
String tag_name;
|
|
bool is_cf_tag;
|
|
} TagNameResult;
|
|
|
|
static TagNameResult scan_tag_name(TSLexer *lexer, bool is_cfquery_context) {
|
|
TagNameResult result;
|
|
String tag_name = array_new();
|
|
bool is_cf_tag = false;
|
|
|
|
// ColdFusion tags might start with 'C', ie. <cfcomponent or <cfcontinue
|
|
if ( lexer->lookahead == 'c' || lexer->lookahead == 'C' ) {
|
|
array_push(&tag_name, towupper(lexer->lookahead));
|
|
advance(lexer);
|
|
if (lexer->lookahead == 'f' || lexer->lookahead == 'F') {
|
|
is_cf_tag = true;
|
|
array_delete(&tag_name);
|
|
advance(lexer);
|
|
}
|
|
}
|
|
|
|
while (( iswalnum(lexer->lookahead) || lexer->lookahead == '-' || lexer->lookahead == '_' || lexer->lookahead == ':' )) {
|
|
array_push(&tag_name, towupper(lexer->lookahead));
|
|
advance(lexer);
|
|
}
|
|
|
|
result.tag_name = tag_name;
|
|
result.is_cf_tag = is_cf_tag;
|
|
|
|
return result;
|
|
}
|
|
|
|
static bool scan_comment(TSLexer *lexer, bool is_cfquery_context) {
|
|
if (lexer->lookahead != '-') {
|
|
return false;
|
|
}
|
|
advance(lexer);
|
|
if (lexer->lookahead != '-') {
|
|
return false;
|
|
}
|
|
|
|
advance(lexer);
|
|
|
|
// IE conditional comments: <!--[if ...]>...<![endif]--> or <!--<![endif]-->
|
|
// These don't nest — just scan until -->
|
|
if (lexer->lookahead == '[' || lexer->lookahead == '<') {
|
|
unsigned close_dashes = 0;
|
|
while (lexer->lookahead) {
|
|
if (lexer->lookahead == '-') {
|
|
close_dashes++;
|
|
} else if (lexer->lookahead == '>' && close_dashes >= 2) {
|
|
lexer->result_symbol = CFML_COMMENT;
|
|
advance(lexer);
|
|
lexer->mark_end(lexer);
|
|
return true;
|
|
} else {
|
|
close_dashes = 0;
|
|
}
|
|
advance(lexer);
|
|
}
|
|
return false;
|
|
}
|
|
|
|
unsigned dashes = 0;
|
|
unsigned direction = -1;
|
|
unsigned nesting = 1;
|
|
|
|
while (lexer->lookahead) {
|
|
switch (lexer->lookahead) {
|
|
case '-':
|
|
++dashes;
|
|
if ( direction == 1 && dashes >= 2 ) {
|
|
++nesting;
|
|
direction = -1;
|
|
dashes = 0;
|
|
}
|
|
break;
|
|
case '>':
|
|
if (dashes >= 2) {
|
|
--nesting;
|
|
lexer->result_symbol = CFML_COMMENT;
|
|
advance(lexer);
|
|
lexer->mark_end(lexer);
|
|
if ( nesting == 0 ) {
|
|
return true;
|
|
}
|
|
dashes = 0;
|
|
direction = -1;
|
|
continue;
|
|
}
|
|
direction = -1;
|
|
dashes = 0;
|
|
break;
|
|
case '<':
|
|
direction = 0;
|
|
dashes = 0;
|
|
break;
|
|
case '!':
|
|
if ( direction == 0 ) {
|
|
direction = 1;
|
|
break;
|
|
}
|
|
direction = -1;
|
|
dashes = 0;
|
|
break;
|
|
default:
|
|
direction = -1;
|
|
dashes = 0;
|
|
break;
|
|
}
|
|
advance(lexer);
|
|
}
|
|
return false;
|
|
}
|
|
|
|
static WhitespaceResult scan_whitespace_and_comments(TSLexer *lexer, bool *scanned_comment, bool consume, bool is_cfquery_context) {
|
|
bool saw_block_newline = false;
|
|
for (;;) {
|
|
while (iswspace(lexer->lookahead)) {
|
|
skip(lexer);
|
|
}
|
|
|
|
if (lexer->lookahead == '/') {
|
|
skip(lexer);
|
|
|
|
if (lexer->lookahead == '/') {
|
|
skip(lexer);
|
|
while (lexer->lookahead != 0 && lexer->lookahead != '\n' && lexer->lookahead != 0x2028 && lexer->lookahead != 0x2029) {
|
|
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);
|
|
*scanned_comment = true;
|
|
|
|
if (lexer->lookahead != '/' && !consume) {
|
|
return saw_block_newline ? ACCEPT : NO_NEWLINE;
|
|
}
|
|
|
|
break;
|
|
}
|
|
} else if (lexer->lookahead == '\n' || lexer->lookahead == 0x2028 || lexer->lookahead == 0x2029) {
|
|
saw_block_newline = true;
|
|
skip(lexer);
|
|
} else {
|
|
skip(lexer);
|
|
}
|
|
}
|
|
} else {
|
|
return REJECT;
|
|
}
|
|
} else {
|
|
return ACCEPT;
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
static bool scan_html_text(Scanner *scanner, TSLexer *lexer, bool is_cfquery_context) {
|
|
// Check if we're inside a script/style tag
|
|
bool in_script_style = false;
|
|
if (scanner->tags.size > 0) {
|
|
TagType type = array_back(&scanner->tags)->type;
|
|
if (type == SCRIPT || type == STYLE) {
|
|
in_script_style = true;
|
|
}
|
|
}
|
|
|
|
// saw_text will be true if we see any non-whitespace content, or any whitespace content that is not a newline and
|
|
// does not immediately follow a newline.
|
|
bool saw_text = false;
|
|
// at_newline will be true if we are currently at a newline, or if we are at whitespace that is not a newline but
|
|
// immediately follows a newline.
|
|
bool at_newline = false;
|
|
|
|
bool saw_any = false;
|
|
|
|
if (in_script_style) {
|
|
// Inside script/style: consume until #, <cf, </cf, or </script|</style
|
|
lexer->mark_end(lexer);
|
|
while (lexer->lookahead != 0 && lexer->lookahead != '#') {
|
|
if (lexer->lookahead == '<') {
|
|
// Peek for <cf or </cf or </script|</style
|
|
advance(lexer);
|
|
if (towupper(lexer->lookahead) == 'C') {
|
|
advance(lexer);
|
|
if (towupper(lexer->lookahead) == 'F') {
|
|
break;
|
|
}
|
|
lexer->mark_end(lexer);
|
|
saw_text = true;
|
|
saw_any = true;
|
|
continue;
|
|
} else if (lexer->lookahead == '/') {
|
|
advance(lexer);
|
|
if (towupper(lexer->lookahead) == 'C') {
|
|
advance(lexer);
|
|
if (towupper(lexer->lookahead) == 'F') {
|
|
break;
|
|
}
|
|
lexer->mark_end(lexer);
|
|
saw_text = true;
|
|
saw_any = true;
|
|
continue;
|
|
} else if (towupper(lexer->lookahead) == 'S') {
|
|
// Potential </script or </style - stop
|
|
break;
|
|
}
|
|
lexer->mark_end(lexer);
|
|
saw_text = true;
|
|
saw_any = true;
|
|
continue;
|
|
}
|
|
lexer->mark_end(lexer);
|
|
saw_text = true;
|
|
saw_any = true;
|
|
continue;
|
|
}
|
|
saw_text = true;
|
|
saw_any = true;
|
|
advance(lexer);
|
|
lexer->mark_end(lexer);
|
|
}
|
|
lexer->result_symbol = HTML_TEXT;
|
|
return saw_text || (saw_any && lexer->lookahead == '#');
|
|
}
|
|
|
|
while (lexer->lookahead != 0 && lexer->lookahead != '<' && lexer->lookahead != '>' && lexer->lookahead != '{' &&
|
|
lexer->lookahead != '}' && lexer->lookahead != '#') {
|
|
if (lexer->lookahead == '&') {
|
|
// Peek ahead to determine if this is an entity
|
|
lexer->mark_end(lexer);
|
|
advance(lexer);
|
|
if (lexer->lookahead == '#') {
|
|
// Could be numeric entity (&#digits; or &#xhex;) or &# followed by CFML hash
|
|
// Mark end after & so it's consumed as text
|
|
lexer->mark_end(lexer);
|
|
saw_text = true;
|
|
saw_any = true;
|
|
advance(lexer);
|
|
if (lexer->lookahead == 'x' || lexer->lookahead == 'X' || iswdigit(lexer->lookahead)) {
|
|
// Numeric entity - consume fully as text
|
|
if (lexer->lookahead == 'x' || lexer->lookahead == 'X') {
|
|
advance(lexer);
|
|
while (iswxdigit(lexer->lookahead)) advance(lexer);
|
|
} else {
|
|
while (iswdigit(lexer->lookahead)) advance(lexer);
|
|
}
|
|
if (lexer->lookahead == ';') advance(lexer);
|
|
lexer->mark_end(lexer);
|
|
continue;
|
|
}
|
|
// &# not followed by digit/x - & consumed as text, break at #
|
|
break;
|
|
}
|
|
if (iswalpha(lexer->lookahead)) {
|
|
// Could be &word; - scan ahead for ;
|
|
unsigned count = 0;
|
|
while (iswalpha(lexer->lookahead) && count < 31) {
|
|
advance(lexer);
|
|
count++;
|
|
}
|
|
if (lexer->lookahead == ';' && count > 0) {
|
|
// Valid entity pattern - stop before &
|
|
break;
|
|
}
|
|
// Not a valid entity - consume as text
|
|
lexer->mark_end(lexer);
|
|
saw_text = true;
|
|
saw_any = true;
|
|
continue;
|
|
}
|
|
// & followed by non-alpha, non-# - consume as text
|
|
lexer->mark_end(lexer);
|
|
saw_text = true;
|
|
saw_any = true;
|
|
continue;
|
|
}
|
|
bool is_wspace = iswspace(lexer->lookahead);
|
|
if (lexer->lookahead == '\n') {
|
|
at_newline = true;
|
|
} else {
|
|
at_newline &= is_wspace;
|
|
if (!at_newline) {
|
|
saw_text = true;
|
|
}
|
|
}
|
|
saw_any = true;
|
|
advance(lexer);
|
|
}
|
|
|
|
lexer->result_symbol = HTML_TEXT;
|
|
// Emit whitespace-only content when the next char is '#' so the parser
|
|
// advances to a state where hash tokens become valid.
|
|
return saw_text || (saw_any && lexer->lookahead == '#');
|
|
}
|
|
|
|
|
|
static bool scan_script_comment(TSLexer *lexer, bool is_cfquery_context) {
|
|
|
|
for (;;) {
|
|
|
|
if (lexer->lookahead == '/') {
|
|
skip(lexer);
|
|
while (lexer->lookahead != 0 && lexer->lookahead != '\n' && lexer->lookahead != 0x2028 &&
|
|
lexer->lookahead != 0x2029) {
|
|
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);
|
|
//*scanned_comment = true;
|
|
break;
|
|
}
|
|
} else {
|
|
skip(lexer);
|
|
}
|
|
}
|
|
} else {
|
|
return false;
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
static bool scan_cfquery_content(Scanner *scanner, TSLexer *lexer, bool is_cfquery_context) {
|
|
|
|
if (scanner->cf_tags.size == 0) {
|
|
return false;
|
|
}
|
|
|
|
Tag *cf_tag = array_back(&scanner->cf_tags);
|
|
if (cf_tag->type != CF_QUERY) {
|
|
return false;
|
|
}
|
|
|
|
lexer->mark_end(lexer);
|
|
|
|
size_t tag_len = cf_tag->tag_name.size;
|
|
if (tag_len > MAX_CF_END_DELIMITER_SIZE - 5) return false;
|
|
|
|
char end_delimiter[MAX_CF_END_DELIMITER_SIZE];
|
|
memcpy(end_delimiter, "</CF", 4);
|
|
memcpy(&end_delimiter[4], cf_tag->tag_name.contents, tag_len);
|
|
end_delimiter[4 + tag_len] = '\0';
|
|
|
|
size_t delimiter_index = 0;
|
|
size_t end_delim_len = 4 + tag_len;
|
|
|
|
while (lexer->lookahead) {
|
|
if (towupper(lexer->lookahead) == end_delimiter[delimiter_index]) {
|
|
delimiter_index++;
|
|
if (delimiter_index == end_delim_len) {
|
|
break;
|
|
}
|
|
advance(lexer);
|
|
} else {
|
|
delimiter_index = 0;
|
|
advance(lexer);
|
|
lexer->mark_end(lexer);
|
|
}
|
|
}
|
|
|
|
lexer->result_symbol = CF_QUERY_CONTENT;
|
|
return true;
|
|
}
|
|
|
|
static bool scan_cfxml_content(Scanner *scanner, TSLexer *lexer, bool is_cfquery_context) {
|
|
|
|
if (scanner->cf_tags.size == 0) {
|
|
return false;
|
|
}
|
|
|
|
Tag *cf_tag = array_back(&scanner->cf_tags);
|
|
if (cf_tag->type != CF_XML) {
|
|
return false;
|
|
}
|
|
|
|
lexer->mark_end(lexer);
|
|
|
|
size_t tag_len = cf_tag->tag_name.size;
|
|
if (tag_len > MAX_CF_END_DELIMITER_SIZE - 5) return false;
|
|
|
|
char end_delimiter[MAX_CF_END_DELIMITER_SIZE];
|
|
memcpy(end_delimiter, "</CF", 4);
|
|
memcpy(&end_delimiter[4], cf_tag->tag_name.contents, tag_len);
|
|
end_delimiter[4 + tag_len] = '\0';
|
|
|
|
size_t delimiter_index = 0;
|
|
size_t end_delim_len = 4 + tag_len;
|
|
|
|
while (lexer->lookahead) {
|
|
if (towupper(lexer->lookahead) == end_delimiter[delimiter_index]) {
|
|
delimiter_index++;
|
|
if (delimiter_index == end_delim_len) {
|
|
break;
|
|
}
|
|
advance(lexer);
|
|
} else {
|
|
delimiter_index = 0;
|
|
advance(lexer);
|
|
lexer->mark_end(lexer);
|
|
}
|
|
}
|
|
|
|
lexer->result_symbol = CF_XML_CONTENT;
|
|
return true;
|
|
}
|
|
|
|
|
|
static bool scan_cfscript_content(Scanner *scanner, TSLexer *lexer, bool is_cfquery_context) {
|
|
|
|
if (scanner->cf_tags.size == 0) {
|
|
return false;
|
|
}
|
|
|
|
Tag *cf_tag = array_back(&scanner->cf_tags);
|
|
if (cf_tag->type != CF_SCRIPT) {
|
|
return false;
|
|
}
|
|
|
|
lexer->mark_end(lexer);
|
|
|
|
size_t tag_len = cf_tag->tag_name.size;
|
|
if (tag_len > MAX_CF_END_DELIMITER_SIZE - 5) return false;
|
|
|
|
char end_delimiter[MAX_CF_END_DELIMITER_SIZE];
|
|
memcpy(end_delimiter, "</CF", 4);
|
|
memcpy(&end_delimiter[4], cf_tag->tag_name.contents, tag_len);
|
|
end_delimiter[4 + tag_len] = '\0';
|
|
|
|
size_t delimiter_index = 0;
|
|
size_t end_delim_len = 4 + tag_len;
|
|
|
|
while (lexer->lookahead) {
|
|
if (towupper(lexer->lookahead) == end_delimiter[delimiter_index]) {
|
|
delimiter_index++;
|
|
if (delimiter_index == end_delim_len) {
|
|
break;
|
|
}
|
|
advance(lexer);
|
|
} else {
|
|
delimiter_index = 0;
|
|
advance(lexer);
|
|
lexer->mark_end(lexer);
|
|
}
|
|
}
|
|
|
|
lexer->result_symbol = CF_SCRIPT_CONTENT;
|
|
return true;
|
|
}
|
|
|
|
static bool scan_cfsavecontent_body_type(Scanner *scanner, TSLexer *lexer, const bool *valid_symbols, unsigned count, bool is_cfquery_context) {
|
|
if (scanner->cf_tags.size == 0) return false;
|
|
Tag *cf_tag = array_back(&scanner->cf_tags);
|
|
if (cf_tag->type != CF_SAVECONTENT) return false;
|
|
|
|
// Default to cfml
|
|
unsigned result = CF_SAVECONTENT_BODY_CFML;
|
|
|
|
// Mark end at current position - this is a zero-width token
|
|
lexer->mark_end(lexer);
|
|
|
|
// Peek ahead for <!--- @content TYPE --->
|
|
// Skip whitespace first
|
|
while (iswspace(lexer->lookahead)) advance(lexer);
|
|
|
|
if (lexer->lookahead == '<') {
|
|
advance(lexer);
|
|
if (lexer->lookahead == '!') {
|
|
advance(lexer);
|
|
if (lexer->lookahead == '-') {
|
|
advance(lexer);
|
|
if (lexer->lookahead == '-') {
|
|
advance(lexer);
|
|
if (lexer->lookahead == '-') {
|
|
advance(lexer);
|
|
// Skip whitespace after <!---
|
|
while (iswspace(lexer->lookahead)) advance(lexer);
|
|
// Check for @content
|
|
const char *directive = "@content";
|
|
size_t di = 0;
|
|
bool matched = true;
|
|
while (di < 8) {
|
|
if (lexer->lookahead != directive[di]) { matched = false; break; }
|
|
advance(lexer);
|
|
di++;
|
|
}
|
|
if (matched) {
|
|
// Skip whitespace
|
|
while (iswspace(lexer->lookahead)) advance(lexer);
|
|
// Read type word
|
|
char type_buf[16];
|
|
int len = 0;
|
|
while (iswalpha(lexer->lookahead) && len < 15) {
|
|
type_buf[len++] = towlower(lexer->lookahead);
|
|
advance(lexer);
|
|
}
|
|
type_buf[len] = '\0';
|
|
if (strcmp(type_buf, "script") == 0) result = CF_SAVECONTENT_BODY_SCRIPT;
|
|
else if (strcmp(type_buf, "css") == 0) result = CF_SAVECONTENT_BODY_CSS;
|
|
else if (strcmp(type_buf, "xml") == 0) result = CF_SAVECONTENT_BODY_XML;
|
|
else if (strcmp(type_buf, "sql") == 0) result = CF_SAVECONTENT_BODY_SQL;
|
|
else if (strcmp(type_buf, "raw") == 0) result = CF_SAVECONTENT_BODY_RAW;
|
|
else if (strcmp(type_buf, "html") == 0) result = CF_SAVECONTENT_BODY_HTML;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
if (!VS(valid_symbols, result, count)) return false;
|
|
lexer->result_symbol = result;
|
|
return true;
|
|
}
|
|
|
|
static bool scan_cfsavecontent_content(Scanner *scanner, TSLexer *lexer, bool is_cfquery_context) {
|
|
if (scanner->cf_tags.size == 0) return false;
|
|
Tag *cf_tag = array_back(&scanner->cf_tags);
|
|
if (cf_tag->type != CF_SAVECONTENT) return false;
|
|
|
|
lexer->mark_end(lexer);
|
|
|
|
size_t tag_len = cf_tag->tag_name.size;
|
|
if (tag_len > MAX_CF_END_DELIMITER_SIZE - 5) return false;
|
|
|
|
char end_delimiter[MAX_CF_END_DELIMITER_SIZE];
|
|
memcpy(end_delimiter, "</CF", 4);
|
|
memcpy(&end_delimiter[4], cf_tag->tag_name.contents, tag_len);
|
|
end_delimiter[4 + tag_len] = '\0';
|
|
size_t end_delim_len = 4 + tag_len;
|
|
|
|
bool has_content = false;
|
|
|
|
while (lexer->lookahead) {
|
|
if (lexer->lookahead == '<') {
|
|
lexer->mark_end(lexer);
|
|
advance(lexer);
|
|
if (lexer->lookahead == '/') {
|
|
advance(lexer);
|
|
size_t i = 2;
|
|
bool matched = true;
|
|
while (i < end_delim_len) {
|
|
if (towupper(lexer->lookahead) != end_delimiter[i]) { matched = false; break; }
|
|
i++;
|
|
if (i < end_delim_len) advance(lexer);
|
|
}
|
|
if (matched) {
|
|
lexer->result_symbol = CF_SAVECONTENT_CONTENT;
|
|
return has_content;
|
|
}
|
|
}
|
|
has_content = true;
|
|
lexer->mark_end(lexer);
|
|
} else {
|
|
has_content = true;
|
|
advance(lexer);
|
|
lexer->mark_end(lexer);
|
|
}
|
|
}
|
|
|
|
lexer->result_symbol = CF_SAVECONTENT_CONTENT;
|
|
return has_content;
|
|
}
|
|
|
|
static bool scan_raw_text(Scanner *scanner, TSLexer *lexer, bool is_cfquery_context) {
|
|
if (scanner->tags.size == 0) {
|
|
return false;
|
|
}
|
|
|
|
lexer->mark_end(lexer);
|
|
|
|
const char *end_delimiter = array_back(&scanner->tags)->type == SCRIPT ? "</SCRIPT" : "</STYLE";
|
|
|
|
bool stop_at_cfml = !is_cfquery_context &&
|
|
(array_back(&scanner->tags)->type == SCRIPT || array_back(&scanner->tags)->type == STYLE);
|
|
|
|
bool has_content = false;
|
|
unsigned delimiter_index = 0;
|
|
while (lexer->lookahead) {
|
|
// CFML boundary checks (only when not mid-delimiter match)
|
|
if (stop_at_cfml && delimiter_index == 0) {
|
|
if (lexer->lookahead == '#' && scanner->cfoutput_depth > 0) {
|
|
break;
|
|
}
|
|
if (lexer->lookahead == '<') {
|
|
advance(lexer);
|
|
if (towupper(lexer->lookahead) == 'C') {
|
|
advance(lexer);
|
|
if (towupper(lexer->lookahead) == 'F') {
|
|
// Stop before <cf
|
|
break;
|
|
}
|
|
lexer->mark_end(lexer);
|
|
has_content = true;
|
|
continue;
|
|
} else if (lexer->lookahead == '/') {
|
|
advance(lexer);
|
|
if (towupper(lexer->lookahead) == 'C') {
|
|
advance(lexer);
|
|
if (towupper(lexer->lookahead) == 'F') {
|
|
// Stop before </cf
|
|
break;
|
|
}
|
|
lexer->mark_end(lexer);
|
|
has_content = true;
|
|
continue;
|
|
} else if (towupper(lexer->lookahead) == end_delimiter[2]) {
|
|
// Potential </script or </style
|
|
delimiter_index = 3;
|
|
advance(lexer);
|
|
continue;
|
|
}
|
|
lexer->mark_end(lexer);
|
|
has_content = true;
|
|
continue;
|
|
} else {
|
|
lexer->mark_end(lexer);
|
|
has_content = true;
|
|
continue;
|
|
}
|
|
}
|
|
}
|
|
|
|
if (towupper(lexer->lookahead) == end_delimiter[delimiter_index]) {
|
|
delimiter_index++;
|
|
if (delimiter_index == strlen(end_delimiter)) {
|
|
break;
|
|
}
|
|
advance(lexer);
|
|
} else {
|
|
delimiter_index = 0;
|
|
advance(lexer);
|
|
lexer->mark_end(lexer);
|
|
has_content = true;
|
|
}
|
|
}
|
|
|
|
if (!has_content) {
|
|
return false;
|
|
}
|
|
|
|
lexer->result_symbol = RAW_TEXT;
|
|
return true;
|
|
}
|
|
|
|
static void pop_tag(Scanner *scanner, bool is_cf_context) {
|
|
if ( is_cf_context ) {
|
|
Tag popped_tag = array_pop(&scanner->cf_tags);
|
|
tag_free(&popped_tag);
|
|
} else {
|
|
Tag popped_tag = array_pop(&scanner->tags);
|
|
tag_free(&popped_tag);
|
|
}
|
|
}
|
|
|
|
static bool scan_implicit_end_tag(Scanner *scanner, TSLexer *lexer, bool is_cf_context, bool is_cfquery_context, bool from_tag_open) {
|
|
|
|
Tag *parent = is_cf_context
|
|
? (scanner->cf_tags.size == 0 ? NULL : array_back(&scanner->cf_tags))
|
|
: (scanner->tags.size == 0 ? NULL : array_back(&scanner->tags));
|
|
|
|
bool is_closing_tag = false;
|
|
if (lexer->lookahead == '/') {
|
|
is_closing_tag = true;
|
|
advance(lexer);
|
|
} else {
|
|
// Void tag processing
|
|
if (!is_cf_context && parent && tag_is_void(parent)) {
|
|
pop_tag(scanner, false);
|
|
lexer->result_symbol = IMPLICIT_END_TAG;
|
|
return true;
|
|
}
|
|
// Void tag processing
|
|
if (is_cf_context && parent && cf_tag_is_void(parent)) {
|
|
pop_tag(scanner, true);
|
|
lexer->result_symbol = IMPLICIT_CF_END_TAG;
|
|
return true;
|
|
}
|
|
}
|
|
|
|
TagNameResult result = scan_tag_name(lexer, is_cfquery_context);
|
|
if (result.tag_name.size == 0 && !lexer->eof(lexer)) {
|
|
array_delete(&result.tag_name);
|
|
return false;
|
|
}
|
|
|
|
if (result.is_cf_tag && !is_closing_tag &&
|
|
((result.tag_name.size == 4 && memcmp(result.tag_name.contents, "ELSE", 4) == 0) ||
|
|
(result.tag_name.size == 6 && memcmp(result.tag_name.contents, "ELSEIF", 6) == 0))) {
|
|
array_delete(&result.tag_name);
|
|
if (is_cf_context && parent &&
|
|
parent->type != CF_IF && parent->type != CF_ELSEIF && parent->type != CF_ELSE) {
|
|
pop_tag(scanner, true);
|
|
lexer->result_symbol = IMPLICIT_CF_END_TAG;
|
|
return true;
|
|
}
|
|
if (!is_cf_context && scanner->tags.size > 0) {
|
|
// Check if there's a CF_IF on the cf_tags stack whose html_depth
|
|
// is less than current tags.size (meaning HTML tags opened inside cfif)
|
|
for (unsigned i = scanner->cf_tags.size; i > 0; i--) {
|
|
Tag *ct = &scanner->cf_tags.contents[i - 1];
|
|
if (ct->type == CF_IF || ct->type == CF_ELSEIF || ct->type == CF_ELSE) {
|
|
if (scanner->tags.size > ct->html_depth) {
|
|
pop_tag(scanner, false);
|
|
lexer->result_symbol = IMPLICIT_END_TAG;
|
|
return true;
|
|
}
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
return false;
|
|
}
|
|
|
|
if (result.is_cf_tag && !is_cf_context && is_closing_tag) {
|
|
// A CF closing tag in HTML context: only implicitly close HTML tags
|
|
// that were opened inside this CF tag (i.e. tags.size > cf html_depth)
|
|
Tag cf_next = cf_tag_for_name(result.tag_name);
|
|
unsigned cf_html_depth = 0;
|
|
bool found = false;
|
|
for (unsigned i = scanner->cf_tags.size; i > 0; i--) {
|
|
if (tag_eq(&scanner->cf_tags.contents[i - 1], &cf_next)) {
|
|
cf_html_depth = scanner->cf_tags.contents[i - 1].html_depth;
|
|
found = true;
|
|
break;
|
|
}
|
|
}
|
|
tag_free(&cf_next);
|
|
if (found && scanner->tags.size > cf_html_depth) {
|
|
pop_tag(scanner, false);
|
|
lexer->result_symbol = IMPLICIT_END_TAG;
|
|
return true;
|
|
}
|
|
return false;
|
|
}
|
|
|
|
if (result.is_cf_tag && !is_cf_context) {
|
|
array_delete(&result.tag_name);
|
|
return false;
|
|
}
|
|
|
|
|
|
Tag next_tag = is_cf_context ? cf_tag_for_name(result.tag_name) : tag_for_name(result.tag_name);
|
|
|
|
if (is_closing_tag) {
|
|
// The tag correctly closes the topmost element on the stack
|
|
if (is_cf_context ? (scanner->cf_tags.size > 0 && tag_eq(array_back(&scanner->cf_tags), &next_tag))
|
|
: (scanner->tags.size > 0 && tag_eq(array_back(&scanner->tags), &next_tag))) {
|
|
// Before accepting the CF close, check if HTML tags opened inside
|
|
// this CF tag need implicit closing (e.g. <cfloop><span></cfloop>)
|
|
if (is_cf_context && scanner->tags.size > array_back(&scanner->cf_tags)->html_depth) {
|
|
pop_tag(scanner, false);
|
|
lexer->result_symbol = IMPLICIT_END_TAG;
|
|
tag_free(&next_tag);
|
|
return true;
|
|
}
|
|
tag_free(&next_tag);
|
|
return false;
|
|
}
|
|
|
|
// if (is_cf ? (scanner->cf_tags.size > 0 && !tag_eq(array_back(&scanner->cf_tags), &next_tag))
|
|
// : (scanner->tags.size > 0 && !tag_eq(array_back(&scanner->tags), &next_tag))) {
|
|
// pop_tag(scanner, is_cf);
|
|
// lexer->result_symbol = is_cf ? IMPLICIT_CF_END_TAG : IMPLICIT_END_TAG;
|
|
// tag_free(&next_tag);
|
|
// return true;
|
|
// }
|
|
|
|
// Otherwise, dig deeper and queue implicit end tags (to be nice in
|
|
// the case of malformed HTML)
|
|
if (is_cf_context) {
|
|
for (unsigned i = scanner->cf_tags.size; i > 0; i--) {
|
|
if (tag_eq(&scanner->cf_tags.contents[i - 1], &next_tag)) {
|
|
pop_tag(scanner, true);
|
|
lexer->result_symbol = IMPLICIT_CF_END_TAG;
|
|
tag_free(&next_tag);
|
|
return true;
|
|
}
|
|
}
|
|
} else {
|
|
for (unsigned i = scanner->tags.size; i > 0; i--) {
|
|
if (tag_eq(&scanner->tags.contents[i - 1], &next_tag)) {
|
|
pop_tag(scanner, false);
|
|
lexer->result_symbol = IMPLICIT_END_TAG;
|
|
tag_free(&next_tag);
|
|
return true;
|
|
}
|
|
}
|
|
}
|
|
} else {
|
|
|
|
if (from_tag_open && is_cf_context && !result.is_cf_tag && parent && tag_eq(parent, &next_tag)) {
|
|
pop_tag(scanner, true);
|
|
lexer->result_symbol = IMPLICIT_CF_END_TAG;
|
|
tag_free(&next_tag);
|
|
return true;
|
|
}
|
|
|
|
if (!is_cf_context && parent && tag_eq(parent, &next_tag) && tag_implicitly_closes_self(parent)) {
|
|
pop_tag(scanner, false);
|
|
lexer->result_symbol = IMPLICIT_END_TAG;
|
|
tag_free(&next_tag);
|
|
return true;
|
|
}
|
|
|
|
if (
|
|
parent &&
|
|
(
|
|
(lexer->eof(lexer))
|
|
|| (is_cf_context && lexer->eof(lexer))
|
|
)
|
|
) {
|
|
pop_tag(scanner, is_cf_context);
|
|
lexer->result_symbol = is_cf_context ? IMPLICIT_CF_END_TAG : IMPLICIT_END_TAG;
|
|
tag_free(&next_tag);
|
|
return true;
|
|
}
|
|
}
|
|
|
|
tag_free(&next_tag);
|
|
return false;
|
|
}
|
|
|
|
static bool scan_start_tag_name(Scanner *scanner, TSLexer *lexer, bool is_cf_context, bool is_cfquery_context) {
|
|
|
|
// Dynamic tag name: <#expression#>
|
|
if (lexer->lookahead == '#') {
|
|
Tag tag = tag_new();
|
|
tag.type = DYNAMIC;
|
|
array_push(&scanner->tags, tag);
|
|
lexer->result_symbol = START_TAG_NAME;
|
|
return true;
|
|
}
|
|
|
|
TagNameResult result = scan_tag_name(lexer, is_cfquery_context);
|
|
|
|
if (result.tag_name.size == 0) {
|
|
array_delete(&result.tag_name);
|
|
return false;
|
|
}
|
|
|
|
if ( result.is_cf_tag && !is_cf_context ) {
|
|
array_delete(&result.tag_name);
|
|
return false;
|
|
}
|
|
|
|
// bool is_cf = result.is_cf_tag || is_cf_context;
|
|
Tag tag = is_cf_context ? cf_tag_for_name(result.tag_name) : tag_for_name(result.tag_name);
|
|
|
|
// printf("scan_start_tag_name: tag=%.*s, is_cf_tag=%d, is_cf_context=%d, type=%d\n",
|
|
// (int)result.tag_name.size, result.tag_name.contents, result.is_cf_tag, is_cf_context, tag.type);
|
|
|
|
switch (tag.type) {
|
|
case SCRIPT:
|
|
lexer->result_symbol = SCRIPT_START_TAG_NAME;
|
|
break;
|
|
case STYLE:
|
|
lexer->result_symbol = STYLE_START_TAG_NAME;
|
|
break;
|
|
case CF_VOID:
|
|
if (is_cf_context && tag.tag_name.size == 9 &&
|
|
memcmp(tag.tag_name.contents, "COMPONENT", 9) == 0) {
|
|
scanner->cfcomponent_depth++;
|
|
lexer->result_symbol = CF_COMPONENT_START_TAG_NAME;
|
|
} else {
|
|
lexer->result_symbol = CF_VOID_START_TAG_NAME;
|
|
}
|
|
tag_free(&tag);
|
|
return true;
|
|
case CF_SET:
|
|
lexer->result_symbol = CF_SET_START_TAG_NAME;
|
|
tag_free(&tag); /* not pushed to the stack — free its owned tag_name */
|
|
return true;
|
|
case CF_RETURN:
|
|
lexer->result_symbol = CF_RETURN_START_TAG_NAME;
|
|
tag_free(&tag); /* not pushed to the stack — free its owned tag_name */
|
|
return true;
|
|
case CF_IF:
|
|
lexer->result_symbol = CF_IF_START_TAG_NAME;
|
|
break;
|
|
case CF_ELSEIF:
|
|
lexer->result_symbol = CF_ELSEIF_TAG_NAME;
|
|
tag_free(&tag); /* not pushed to the stack — free its owned tag_name */
|
|
return true;
|
|
case CF_ELSE:
|
|
lexer->result_symbol = CF_ELSE_TAG_NAME;
|
|
tag_free(&tag); /* not pushed to the stack — free its owned tag_name */
|
|
return true;
|
|
case CF_XML:
|
|
lexer->result_symbol = CF_XML_START_TAG_NAME;
|
|
break;
|
|
case CF_QUERY:
|
|
lexer->result_symbol = CF_QUERY_START_TAG_NAME;
|
|
break;
|
|
case CF_SCRIPT:
|
|
lexer->result_symbol = CF_SCRIPT_START_TAG_NAME;
|
|
break;
|
|
case CF_SAVECONTENT:
|
|
lexer->result_symbol = CF_SAVECONTENT_START_TAG_NAME;
|
|
break;
|
|
case CF_OUTPUT:
|
|
lexer->result_symbol = CF_OUTPUT_START_TAG_NAME;
|
|
if (is_cf_context) {
|
|
scanner->cfoutput_depth++;
|
|
}
|
|
break;
|
|
case CF_FUNCTION:
|
|
lexer->result_symbol = CF_FUNCTION_START_TAG_NAME;
|
|
if (is_cf_context) {
|
|
scanner->cffunction_depth++;
|
|
}
|
|
break;
|
|
default:
|
|
lexer->result_symbol = is_cf_context ? CF_START_TAG_NAME : START_TAG_NAME;
|
|
break;
|
|
}
|
|
|
|
if ( is_cf_context ) {
|
|
tag.html_depth = scanner->tags.size;
|
|
array_push(&scanner->cf_tags, tag);
|
|
} else {
|
|
array_push(&scanner->tags, tag);
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
static void set_end_tag_symbol(Scanner *scanner, TSLexer *lexer, Tag *tag, bool is_cf_context, bool is_cfquery_context) {
|
|
if (is_cf_context && tag->type == CF_OUTPUT) {
|
|
if (scanner->cfoutput_depth > 0) scanner->cfoutput_depth--;
|
|
lexer->result_symbol = CF_END_TAG_NAME;
|
|
} else if (is_cf_context && tag->type == CF_FUNCTION) {
|
|
if (scanner->cffunction_depth > 0) scanner->cffunction_depth--;
|
|
lexer->result_symbol = CF_FUNCTION_END_TAG_NAME;
|
|
} else if (is_cf_context && tag->type == CF_XML) {
|
|
lexer->result_symbol = CF_XML_END_TAG_NAME;
|
|
} else if (is_cf_context && tag->type == CF_QUERY) {
|
|
lexer->result_symbol = CF_QUERY_END_TAG_NAME;
|
|
} else if (is_cf_context && tag->type == CF_SCRIPT) {
|
|
lexer->result_symbol = CF_SCRIPT_END_TAG_NAME;
|
|
} else if (is_cf_context && tag->type == CF_SAVECONTENT) {
|
|
lexer->result_symbol = CF_SAVECONTENT_END_TAG_NAME;
|
|
} else if (is_cf_context && tag->type == CF_IF) {
|
|
lexer->result_symbol = CF_IF_END_TAG_NAME;
|
|
} else {
|
|
lexer->result_symbol = is_cf_context ? CF_END_TAG_NAME : END_TAG_NAME;
|
|
}
|
|
}
|
|
|
|
static bool scan_end_tag_name(Scanner *scanner, TSLexer *lexer, bool is_cf_context, bool is_cfquery_context) {
|
|
|
|
// Dynamic closing tag: </#expression#>
|
|
if (lexer->lookahead == '#') {
|
|
if (scanner->tags.size > 0 && array_back(&scanner->tags)->type == DYNAMIC) {
|
|
pop_tag(scanner, false);
|
|
}
|
|
lexer->result_symbol = END_TAG_NAME;
|
|
return true;
|
|
}
|
|
|
|
TagNameResult result = scan_tag_name(lexer, is_cfquery_context);
|
|
|
|
if (result.tag_name.size == 0) {
|
|
array_delete(&result.tag_name);
|
|
return false;
|
|
}
|
|
|
|
if ( result.is_cf_tag && !is_cf_context ) {
|
|
array_delete(&result.tag_name);
|
|
return false;
|
|
}
|
|
|
|
// printf("scan_end_tag_name: tag=%.*s, is_cf_context=%d, tags.size=%d, cf_tags.size=%d\n",
|
|
// (int)result.tag_name.size, result.tag_name.contents, is_cf_context,
|
|
// scanner->tags.size, scanner->cf_tags.size);
|
|
|
|
// bool is_cf = result.is_cf_tag || is_cf_context;
|
|
|
|
Tag tag = is_cf_context ? cf_tag_for_name(result.tag_name) : tag_for_name(result.tag_name);
|
|
|
|
// cfcomponent is a void tag (never pushed); just decrement depth
|
|
if (is_cf_context && tag.type == CF_VOID &&
|
|
tag.tag_name.size == 9 && memcmp(tag.tag_name.contents, "COMPONENT", 9) == 0) {
|
|
if (scanner->cfcomponent_depth > 0) scanner->cfcomponent_depth--;
|
|
lexer->result_symbol = CF_COMPONENT_END_TAG_NAME;
|
|
tag_free(&tag);
|
|
return true;
|
|
}
|
|
|
|
// Determine the minimum HTML stack index we can search to.
|
|
// CF control-flow tags record html_depth when pushed; don't search below that.
|
|
unsigned html_floor = 0;
|
|
if (!is_cf_context && scanner->cf_tags.size > 0) {
|
|
html_floor = array_back(&scanner->cf_tags)->html_depth;
|
|
}
|
|
|
|
Tag *tag_back = (is_cf_context) ? ( scanner->cf_tags.size > 0 ? array_back(&scanner->cf_tags) : NULL )
|
|
: ( scanner->tags.size > html_floor) ? array_back(&scanner->tags) : NULL;
|
|
|
|
if ( tag_back && tag_eq(tag_back, &tag) ) {
|
|
pop_tag(scanner, is_cf_context);
|
|
set_end_tag_symbol(scanner, lexer, &tag, is_cf_context, is_cfquery_context);
|
|
} else {
|
|
// Search deeper in the stack for a matching tag
|
|
bool found = false;
|
|
if (is_cf_context) {
|
|
for (unsigned i = scanner->cf_tags.size; i > 0; i--) {
|
|
if (tag_eq(&scanner->cf_tags.contents[i - 1], &tag)) {
|
|
found = true;
|
|
break;
|
|
}
|
|
}
|
|
} else {
|
|
for (unsigned i = scanner->tags.size; i > html_floor; i--) {
|
|
if (tag_eq(&scanner->tags.contents[i - 1], &tag)) {
|
|
found = true;
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
|
|
if (found) {
|
|
pop_tag(scanner, is_cf_context);
|
|
set_end_tag_symbol(scanner, lexer, &tag, is_cf_context, is_cfquery_context);
|
|
} else {
|
|
lexer->result_symbol = is_cf_context ? ERRONEOUS_CF_END_TAG_NAME : ERRONEOUS_END_TAG_NAME;
|
|
}
|
|
}
|
|
|
|
tag_free(&tag);
|
|
return true;
|
|
}
|
|
|
|
static bool scan_cf_self_closing_tag_delimiter(Scanner *scanner, TSLexer *lexer, bool is_void, bool is_cfquery_context) {
|
|
if (lexer->lookahead == '>') {
|
|
advance(lexer);
|
|
if (is_void) {
|
|
lexer->result_symbol = CF_SELF_CLOSING_VOID_TAG_DELIMITER;
|
|
} else {
|
|
lexer->result_symbol = CF_SELF_CLOSING_TAG_DELIMITER;
|
|
if (scanner->cf_tags.size > 0) {
|
|
pop_tag(scanner, true);
|
|
}
|
|
|
|
}
|
|
return true;
|
|
}
|
|
return false;
|
|
}
|
|
|
|
static bool scan_self_closing_tag_delimiter(Scanner *scanner, TSLexer *lexer, bool is_cfquery_context) {
|
|
if (lexer->lookahead == '>') {
|
|
advance(lexer);
|
|
if (scanner->tags.size > 0) {
|
|
pop_tag(scanner, false);
|
|
lexer->result_symbol = SELF_CLOSING_TAG_DELIMITER;
|
|
}
|
|
return true;
|
|
}
|
|
return false;
|
|
}
|
|
|
|
// Check if the current position matches a CFML word operator (case-insensitive).
|
|
static bool scan_cfml_word_operator(TSLexer *lexer) {
|
|
char buf[11] = {0};
|
|
int len = 0;
|
|
for (; len < 10 && iswalpha(lexer->lookahead); len++) {
|
|
buf[len] = towlower(lexer->lookahead);
|
|
skip(lexer);
|
|
}
|
|
bool at_end = !iswalnum(lexer->lookahead);
|
|
if (!at_end) return false;
|
|
|
|
return (len == 2 && (
|
|
(buf[0] == 'o' && buf[1] == 'r') ||
|
|
(buf[0] == 'e' && buf[1] == 'q') ||
|
|
(buf[0] == 'g' && buf[1] == 't') ||
|
|
(buf[0] == 'g' && buf[1] == 'e') ||
|
|
(buf[0] == 'l' && buf[1] == 't') ||
|
|
(buf[0] == 'l' && buf[1] == 'e') ||
|
|
(buf[0] == 'i' && buf[1] == 'n')
|
|
)) || (len == 3 && (
|
|
(buf[0] == 'a' && buf[1] == 'n' && buf[2] == 'd') ||
|
|
(buf[0] == 'n' && buf[1] == 'e' && buf[2] == 'q') ||
|
|
(buf[0] == 'n' && buf[1] == 'o' && buf[2] == 't') ||
|
|
(buf[0] == 'g' && buf[1] == 't' && buf[2] == 'e') ||
|
|
(buf[0] == 'l' && buf[1] == 't' && buf[2] == 'e') ||
|
|
(buf[0] == 'm' && buf[1] == 'o' && buf[2] == 'd')
|
|
)) || (len == 10 &&
|
|
buf[0] == 'i' && buf[1] == 'n' && buf[2] == 's' && buf[3] == 't' &&
|
|
buf[4] == 'a' && buf[5] == 'n' && buf[6] == 'c' && buf[7] == 'e' &&
|
|
buf[8] == 'o' && buf[9] == 'f'
|
|
);
|
|
}
|
|
|
|
static bool scan_automatic_semicolon(TSLexer *lexer, bool comment_condition, bool *scanned_comment, bool is_cfquery_context) {
|
|
lexer->result_symbol = AUTOMATIC_SEMICOLON;
|
|
lexer->mark_end(lexer);
|
|
|
|
for (;;) {
|
|
if (lexer->lookahead == 0) {
|
|
return true;
|
|
}
|
|
|
|
if (lexer->lookahead == '/') {
|
|
WhitespaceResult result = scan_whitespace_and_comments(lexer, scanned_comment, false, is_cfquery_context);
|
|
if (result == false) {
|
|
return false;
|
|
}
|
|
if (result == true && comment_condition && lexer->lookahead != ',' && lexer->lookahead != '=') {
|
|
return true;
|
|
}
|
|
}
|
|
|
|
if (lexer->lookahead == '}') {
|
|
return true;
|
|
}
|
|
|
|
if (lexer->is_at_included_range_start(lexer)) {
|
|
return true;
|
|
}
|
|
|
|
if (lexer->lookahead == '\n' || lexer->lookahead == 0x2028 || lexer->lookahead == 0x2029) {
|
|
break;
|
|
}
|
|
|
|
if (!iswspace(lexer->lookahead)) {
|
|
return false;
|
|
}
|
|
|
|
skip(lexer);
|
|
}
|
|
|
|
skip(lexer);
|
|
|
|
if (scan_whitespace_and_comments(lexer, scanned_comment, true, is_cfquery_context) == REJECT) {
|
|
return false;
|
|
}
|
|
|
|
switch (lexer->lookahead) {
|
|
case '`':
|
|
case ',':
|
|
case ':':
|
|
case ';':
|
|
case '*':
|
|
case '%':
|
|
case '>':
|
|
case '<':
|
|
case '=':
|
|
case '[':
|
|
case '(':
|
|
case '?':
|
|
case '^':
|
|
case '|':
|
|
case '&':
|
|
case '/':
|
|
return false;
|
|
|
|
// Insert a semicolon before decimals literals but not otherwise.
|
|
case '.':
|
|
skip(lexer);
|
|
return iswdigit(lexer->lookahead);
|
|
|
|
// Insert a semicolon before `--` and `++`, but not before binary `+` or `-`.
|
|
case '+':
|
|
skip(lexer);
|
|
return lexer->lookahead == '+';
|
|
case '-':
|
|
skip(lexer);
|
|
return lexer->lookahead == '-';
|
|
|
|
// Don't insert a semicolon before `!=`, but do insert one before a unary `!`.
|
|
case '!':
|
|
skip(lexer);
|
|
return lexer->lookahead != '=';
|
|
|
|
// Don't insert a semicolon before CFML word operators
|
|
// (and, or, eq, neq, not, gt, gte, ge, lt, lte, le, mod, in, instanceof)
|
|
case 'i':
|
|
case 'a': case 'A':
|
|
case 'o': case 'O':
|
|
case 'e': case 'E':
|
|
case 'n': case 'N':
|
|
case 'g': case 'G':
|
|
case 'l': case 'L':
|
|
case 'm': case 'M':
|
|
return !scan_cfml_word_operator(lexer);
|
|
|
|
default:
|
|
break;
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
static bool scan_ternary_qmark(TSLexer *lexer, bool is_cfquery_context) {
|
|
for (;;) {
|
|
if (!iswspace(lexer->lookahead)) {
|
|
break;
|
|
}
|
|
skip(lexer);
|
|
}
|
|
|
|
if (lexer->lookahead == '?') {
|
|
advance(lexer);
|
|
|
|
if (lexer->lookahead == ':') {
|
|
|
|
advance(lexer);
|
|
lexer->mark_end(lexer);
|
|
lexer->result_symbol = ELVIS_OPERATOR;
|
|
|
|
return true;
|
|
|
|
} else if (lexer->lookahead == '?') {
|
|
return false;
|
|
}
|
|
|
|
lexer->mark_end(lexer);
|
|
lexer->result_symbol = TERNARY_QMARK;
|
|
|
|
if (lexer->lookahead == '.') {
|
|
advance(lexer);
|
|
if (iswdigit(lexer->lookahead)) {
|
|
return true;
|
|
}
|
|
return false;
|
|
}
|
|
return true;
|
|
}
|
|
return false;
|
|
}
|
|
|
|
static bool scan_closetag_delim(Scanner *scanner, TSLexer *lexer, bool is_cf_context, bool is_cfquery_context) {
|
|
if ( lexer->lookahead == '>' ) {
|
|
advance(lexer);
|
|
lexer->mark_end(lexer);
|
|
lexer->result_symbol = is_cf_context ? CLOSE_CF_TAG_DELIM : CLOSE_TAG_DELIM;
|
|
return true;
|
|
} else {
|
|
return false;
|
|
}
|
|
}
|
|
|
|
static bool scanner_in_hash_eval_context(Scanner *scanner, bool is_cfquery_context) {
|
|
if (scanner->cfoutput_depth > 0 || scanner->cfcomponent_depth > 0 || scanner->cffunction_depth > 0) {
|
|
return true;
|
|
}
|
|
return false;
|
|
}
|
|
|
|
static bool scan_cf_component_content(TSLexer *lexer, bool is_cfquery_context) {
|
|
// Skip whitespace and script-style comments (// and /* */)
|
|
for (;;) {
|
|
while (iswspace(lexer->lookahead)) advance(lexer);
|
|
if (lexer->lookahead == '/') {
|
|
advance(lexer);
|
|
if (lexer->lookahead == '/') {
|
|
advance(lexer);
|
|
while (lexer->lookahead != 0 && lexer->lookahead != '\n') advance(lexer);
|
|
} else if (lexer->lookahead == '*') {
|
|
advance(lexer);
|
|
while (lexer->lookahead != 0) {
|
|
if (lexer->lookahead == '*') { advance(lexer); if (lexer->lookahead == '/') { advance(lexer); break; } }
|
|
else advance(lexer);
|
|
}
|
|
} else {
|
|
return false;
|
|
}
|
|
} else {
|
|
break;
|
|
}
|
|
}
|
|
|
|
// Read the first word
|
|
char word[16];
|
|
int len = 0;
|
|
while (iswalpha(lexer->lookahead) && len < 15) {
|
|
word[len++] = towlower(lexer->lookahead);
|
|
advance(lexer);
|
|
}
|
|
word[len] = '\0';
|
|
|
|
// Must not be followed by another identifier char (e.g. 'componentFoo')
|
|
if (iswalnum(lexer->lookahead) || lexer->lookahead == '_') return false;
|
|
|
|
// If the first word is a modifier, skip whitespace and read the next word
|
|
if (strcmp(word, "abstract") == 0 || strcmp(word, "static") == 0) {
|
|
while (iswspace(lexer->lookahead)) advance(lexer);
|
|
len = 0;
|
|
while (iswalpha(lexer->lookahead) && len < 15) {
|
|
word[len++] = towlower(lexer->lookahead);
|
|
advance(lexer);
|
|
}
|
|
word[len] = '\0';
|
|
if (iswalnum(lexer->lookahead) || lexer->lookahead == '_') return false;
|
|
}
|
|
|
|
if (strcmp(word, "component") != 0 && strcmp(word, "property") != 0 &&
|
|
strcmp(word, "interface") != 0 && strcmp(word, "import") != 0) {
|
|
return false;
|
|
}
|
|
|
|
// Consume the rest of the file
|
|
while (lexer->lookahead != 0) advance(lexer);
|
|
lexer->mark_end(lexer);
|
|
lexer->result_symbol = CF_COMPONENT_CONTENT;
|
|
return true;
|
|
}
|
|
|
|
static bool external_scanner_scan(Scanner *scanner, TSLexer *lexer, const bool *valid_symbols, unsigned count, bool is_cfquery_context) {
|
|
|
|
if (!VS(valid_symbols, HTML_TEXT, count) && !VS(valid_symbols, RAW_TEXT, count)) {
|
|
while (iswspace(lexer->lookahead)) {
|
|
skip(lexer);
|
|
}
|
|
}
|
|
|
|
if ((VS(valid_symbols, START_HASH_EXPRESSION, count) || VS(valid_symbols, SINGLE_HASH, count) || VS(valid_symbols, HASH_EMPTY, count))
|
|
&& !VS(valid_symbols, AUTOMATIC_SEMICOLON, count) && lexer->lookahead == '#') {
|
|
advance(lexer);
|
|
if (lexer->lookahead == '#') {
|
|
advance(lexer);
|
|
lexer->mark_end(lexer);
|
|
lexer->result_symbol = HASH_EMPTY;
|
|
} else if (scanner_in_hash_eval_context(scanner, is_cfquery_context)) {
|
|
lexer->result_symbol = START_HASH_EXPRESSION;
|
|
} else {
|
|
lexer->mark_end(lexer);
|
|
lexer->result_symbol = SINGLE_HASH;
|
|
}
|
|
return true;
|
|
}
|
|
|
|
if (VS(valid_symbols, CF_COMPONENT_CONTENT, count)
|
|
&& scanner->tags.size == 0 && scanner->cf_tags.size == 0
|
|
&& scan_cf_component_content(lexer, is_cfquery_context)) {
|
|
return true;
|
|
}
|
|
|
|
if (VS(valid_symbols, RAW_TEXT, count) && !VS(valid_symbols, START_TAG_NAME, count) && !VS(valid_symbols, END_TAG_NAME, count)) {
|
|
if (scan_raw_text(scanner, lexer, is_cfquery_context)) {
|
|
return true;
|
|
}
|
|
}
|
|
|
|
if (VS(valid_symbols, CF_XML_CONTENT, count)) {
|
|
return scan_cfxml_content(scanner, lexer, is_cfquery_context);
|
|
}
|
|
|
|
if (VS(valid_symbols, CF_QUERY_CONTENT, count)) {
|
|
return scan_cfquery_content(scanner, lexer, is_cfquery_context);
|
|
}
|
|
|
|
if (VS(valid_symbols, CF_SCRIPT_CONTENT, count)) {
|
|
return scan_cfscript_content(scanner, lexer, is_cfquery_context);
|
|
}
|
|
|
|
if (VS(valid_symbols, CF_SAVECONTENT_BODY_CFML, count) || VS(valid_symbols, CF_SAVECONTENT_BODY_HTML, count) ||
|
|
VS(valid_symbols, CF_SAVECONTENT_BODY_SCRIPT, count) ||
|
|
VS(valid_symbols, CF_SAVECONTENT_BODY_CSS, count) || VS(valid_symbols, CF_SAVECONTENT_BODY_XML, count) ||
|
|
VS(valid_symbols, CF_SAVECONTENT_BODY_SQL, count) || VS(valid_symbols, CF_SAVECONTENT_BODY_RAW, count)) {
|
|
if (scan_cfsavecontent_body_type(scanner, lexer, valid_symbols, count, is_cfquery_context)) {
|
|
return true;
|
|
}
|
|
}
|
|
|
|
if (VS(valid_symbols, CF_SAVECONTENT_CONTENT, count)) {
|
|
return scan_cfsavecontent_content(scanner, lexer, is_cfquery_context);
|
|
}
|
|
|
|
|
|
if (VS(valid_symbols, HTML_TEXT, count) && scan_html_text(scanner, lexer, is_cfquery_context)) {
|
|
return true;
|
|
}
|
|
|
|
switch (lexer->lookahead) {
|
|
case ';':
|
|
return false;
|
|
break;
|
|
case '<':
|
|
lexer->mark_end(lexer);
|
|
advance(lexer);
|
|
|
|
if (VS(valid_symbols, CFML_COMMENT, count) && lexer->lookahead == '!') {
|
|
advance(lexer);
|
|
return scan_comment(lexer, is_cfquery_context);
|
|
}
|
|
|
|
if (implicit_cf_end_tag_valid(valid_symbols, count)) {
|
|
return scan_implicit_end_tag(scanner, lexer, true, is_cfquery_context, true);
|
|
}
|
|
|
|
if (VS(valid_symbols, IMPLICIT_END_TAG, count)) {
|
|
return scan_implicit_end_tag(scanner, lexer, false, is_cfquery_context, true);
|
|
}
|
|
|
|
break;
|
|
|
|
case '\0':
|
|
|
|
if (implicit_cf_end_tag_valid(valid_symbols, count)) {
|
|
return scan_implicit_end_tag(scanner, lexer, true, is_cfquery_context, true);
|
|
}
|
|
|
|
if (VS(valid_symbols, IMPLICIT_END_TAG, count)) {
|
|
return scan_implicit_end_tag(scanner, lexer, false, is_cfquery_context, true);
|
|
}
|
|
break;
|
|
|
|
case '/':
|
|
|
|
advance(lexer);
|
|
if (lexer->lookahead == '>') {
|
|
if (VS(valid_symbols, CF_SELF_CLOSING_TAG_DELIMITER, count)) {
|
|
return scan_cf_self_closing_tag_delimiter(scanner, lexer, false, is_cfquery_context);
|
|
}
|
|
if (VS(valid_symbols, CF_SELF_CLOSING_VOID_TAG_DELIMITER, count)) {
|
|
return scan_cf_self_closing_tag_delimiter(scanner, lexer, true, is_cfquery_context);
|
|
}
|
|
if (VS(valid_symbols, SELF_CLOSING_TAG_DELIMITER, count)) {
|
|
return scan_self_closing_tag_delimiter(scanner, lexer, is_cfquery_context);
|
|
}
|
|
if (VS(valid_symbols, CLOSE_CF_TAG_DELIM, count)) {
|
|
return scan_closetag_delim(scanner, lexer, true, is_cfquery_context);
|
|
}
|
|
if (VS(valid_symbols, CLOSE_TAG_DELIM, count)) {
|
|
return scan_closetag_delim(scanner, lexer, false, is_cfquery_context);
|
|
}
|
|
} else if (lexer->lookahead == '/' || lexer->lookahead == '*') {
|
|
if (!scan_script_comment(lexer, is_cfquery_context)) {
|
|
return false;
|
|
}
|
|
}
|
|
|
|
break;
|
|
|
|
default:
|
|
if (valid_start_tag_name(valid_symbols, count) && no_content_symbols(valid_symbols, count)) {
|
|
return scan_start_tag_name(scanner, lexer, valid_cf_start_tag_name(valid_symbols, count), is_cfquery_context);
|
|
}
|
|
if (valid_end_tag_name(valid_symbols, count) && no_content_symbols(valid_symbols, count)) {
|
|
return scan_end_tag_name(scanner, lexer, valid_cf_end_tag_name(valid_symbols, count), is_cfquery_context);
|
|
}
|
|
|
|
if (VS(valid_symbols, IMPLICIT_END_TAG, count)) {
|
|
return scan_implicit_end_tag(scanner, lexer, false, is_cfquery_context, false);
|
|
} else if (VS(valid_symbols, IMPLICIT_CF_END_TAG, count)) {
|
|
return scan_implicit_end_tag(scanner, lexer, true, is_cfquery_context, false);
|
|
}
|
|
|
|
if (VS(valid_symbols, ERRONEOUS_END_TAG_NAME, count)) {
|
|
return scan_end_tag_name(scanner, lexer, false, is_cfquery_context);
|
|
} else if (VS(valid_symbols, ERRONEOUS_CF_END_TAG_NAME, count)) {
|
|
return scan_end_tag_name(scanner, lexer, true, is_cfquery_context);
|
|
}
|
|
|
|
if (VS(valid_symbols, CF_COMPONENT_END_TAG_NAME, count)) {
|
|
return scan_end_tag_name(scanner, lexer, true, is_cfquery_context);
|
|
}
|
|
|
|
if (VS(valid_symbols, CLOSE_CF_TAG_DELIM, count)) {
|
|
if (scan_closetag_delim(scanner, lexer, true, is_cfquery_context)) {
|
|
return true;
|
|
}
|
|
}
|
|
|
|
if (VS(valid_symbols, CLOSE_TAG_DELIM, count)) {
|
|
if (scan_closetag_delim(scanner, lexer, false, is_cfquery_context)) {
|
|
return true;
|
|
}
|
|
}
|
|
}
|
|
|
|
if (VS(valid_symbols, AUTOMATIC_SEMICOLON, count)) {
|
|
bool scanned_comment = false;
|
|
bool ret = scan_automatic_semicolon(lexer, !VS(valid_symbols, LOGICAL_OR, count), &scanned_comment, is_cfquery_context);
|
|
if (!ret && !scanned_comment && VS(valid_symbols, TERNARY_QMARK, count) && lexer->lookahead == '?') {
|
|
return scan_ternary_qmark(lexer, is_cfquery_context);
|
|
}
|
|
return ret;
|
|
}
|
|
|
|
if (VS(valid_symbols, TERNARY_QMARK, count) || VS(valid_symbols, ELVIS_OPERATOR, count)) {
|
|
return scan_ternary_qmark(lexer, is_cfquery_context);
|
|
}
|
|
|
|
return false;
|
|
}
|