8#include <private/qqmljsdiagnosticmessage_p.h>
9#include <private/qqmljsmemorypool_p.h>
10#include <private/qlocale_tools_p.h>
13#include <QtCore/qcoreapplication.h>
14#include <QtCore/qvarlengtharray.h>
15#include <QtCore/qdebug.h>
16#include <QtCore/QScopedValueRollback>
25 switch (
ch.unicode()) {
37 if (
c >=
'0' &&
c <=
'9')
39 else if (
c >=
'a' &&
c <=
'f')
40 return (
c -
'a' + 10);
42 return (
c -
'A' + 10);
51 : _engine(
engine), _lexMode(lexMode), _endPtr(
nullptr), _qmlMode(true)
71 _currentOffset += _code.
size();
79 _skipLinefeed =
false;
83 _errorMessage.
clear();
89 _tokenStartPtr = _codePtr;
92 _currentLineNumber = lineno;
93 _currentColumnNumber = 0;
94 _tokenLine = _currentLineNumber;
102void Lexer::scanChar()
107 _skipLinefeed =
false;
110 ++_currentColumnNumber;
112 if (isLineTerminator()) {
114 if (_codePtr < _endPtr && *_codePtr == u
'\n')
115 _skipLinefeed =
true;
118 ++_currentLineNumber;
119 _currentColumnNumber = 0;
123QChar Lexer::peekChar()
125 auto peekPtr = _codePtr;
126 if (peekPtr < _endPtr)
132inline bool isBinop(
int tok)
136 case Lexer::T_AND_AND:
137 case Lexer::T_AND_EQ:
138 case Lexer::T_DIVIDE_:
139 case Lexer::T_DIVIDE_EQ:
142 case Lexer::T_EQ_EQ_EQ:
146 case Lexer::T_GT_GT_EQ:
147 case Lexer::T_GT_GT_GT:
148 case Lexer::T_GT_GT_GT_EQ:
152 case Lexer::T_LT_LT_EQ:
154 case Lexer::T_MINUS_EQ:
155 case Lexer::T_NOT_EQ:
156 case Lexer::T_NOT_EQ_EQ:
161 case Lexer::T_PLUS_EQ:
162 case Lexer::T_REMAINDER:
163 case Lexer::T_REMAINDER_EQ:
164 case Lexer::T_RETURN:
166 case Lexer::T_STAR_EQ:
168 case Lexer::T_XOR_EQ:
178 if (
c >= u
'0' &&
c <= u
'9')
179 return c.unicode() - u
'0';
180 if (
c >= u
'a' &&
c <= u
'f')
181 return c.unicode() - u
'a' + 10;
182 if (
c >= u
'A' &&
c <= u
'F')
183 return c.unicode() - u
'A' + 10;
189 if (
c >= u
'0' &&
c <= u
'7')
190 return c.unicode() - u
'0';
198 const int previousTokenKind = _state.
tokenKind;
200 bool firstPass =
true;
213 _tokenStartPtr = _codePtr - 1;
214 _tokenLine = _currentLineNumber;
215 _tokenColumn = _currentColumnNumber;
216 while (_codePtr <= _endPtr) {
223 _codePtr - _tokenStartPtr - 1 - 4,
237 std::optional<ScanStringMode> scanMode;
238 switch (previousTokenKind) {
239 case T_PARTIAL_SINGLE_QUOTE_STRING_LITERAL:
240 scanMode = ScanStringMode::SingleQuote;
242 case T_PARTIAL_DOUBLE_QUOTE_STRING_LITERAL:
243 scanMode = ScanStringMode::DoubleQuote;
245 case T_PARTIAL_TEMPLATE_HEAD:
246 scanMode = ScanStringMode::TemplateHead;
248 case T_PARTIAL_TEMPLATE_MIDDLE:
249 scanMode = ScanStringMode::TemplateContinuation;
256 _tokenStartPtr = _codePtr - 1;
257 _tokenLine = _currentLineNumber;
258 _tokenColumn = _currentColumnNumber;
265 _tokenLength = _codePtr - _tokenStartPtr - 1;
273 case T_PARTIAL_COMMENT:
300 case T_AUTOMATIC_SEMICOLON:
353 }
else if (_state.
tokenKind == T_LPAREN) {
367uint Lexer::decodeUnicodeEscapeCharacter(
bool *
ok)
371 constexpr int distanceFromFirstHexToLastHex = 3;
372 if (_codePtr + distanceFromFirstHexToLastHex <= _endPtr && isHexDigit(_state.
currentChar)) {
374 for (
int i = 0;
i < 4; ++
i) {
385 }
else if (_codePtr < _endPtr && _state.
currentChar == u
'{') {
392 while (_codePtr <= _endPtr) {
398 if (codePoint > 0x10ffff)
421QChar Lexer::decodeHexEscapeCharacter(
bool *
ok)
423 if (isHexDigit(_codePtr[0]) && isHexDigit(_codePtr[1])) {
446 <<
" engine:" <<
qsizetype(l._engine) <<
",\n"
447 <<
" lexMode:" << int(l._lexMode) <<
",\n"
449 <<
" endPtr: codePtr + " << (l._endPtr - l._codePtr) <<
",\n"
450 <<
" qmlMode:" << l._qmlMode <<
",\n"
451 <<
" staticIsKeyword:" << l._staticIsKeyword <<
",\n"
452 <<
" currentLineNumber:" << l._currentLineNumber <<
",\n"
453 <<
" currentColumnNumber:" << l._currentColumnNumber <<
",\n"
454 <<
" currentOffset:" << l._currentOffset <<
",\n"
455 <<
" tokenLength:" << l._tokenLength <<
",\n"
456 <<
" tokenLine:" << l._tokenLine <<
",\n"
457 <<
" tokenColumn:" << l._tokenColumn <<
",\n"
458 <<
" tokenText:" << l._tokenText <<
",\n"
459 <<
" skipLinefeed:" << l._skipLinefeed <<
",\n"
460 <<
" errorMessage:" << l._errorMessage <<
",\n"
461 <<
" tokenSpell:" << l._tokenSpell <<
",\n"
462 <<
" rawString:" << l._rawString <<
",\n";
464 dbg <<
" codePtr: code.unicode()+" << (l._codePtr - l._code.
unicode()) <<
",\n";
466 dbg <<
" codePtr: *null*,\n";
467 if (l._tokenStartPtr)
468 dbg <<
" tokenStartPtr: codePtr " << (l._tokenStartPtr - l._codePtr) <<
",\n";
470 dbg <<
" tokenStartPtr: *null*,\n";
471 dbg <<
" state:" << l._state <<
"\n}";
479 if ((
ch >= u
'a' &&
ch <= u
'z') ||
480 (
ch >= u
'A' &&
ch <= u
'Z') ||
481 ch == u
'$' ||
ch == u
'_')
484 switch (QChar::category(
ch)) {
485 case QChar::Number_Letter:
486 case QChar::Letter_Uppercase:
487 case QChar::Letter_Lowercase:
488 case QChar::Letter_Titlecase:
489 case QChar::Letter_Modifier:
490 case QChar::Letter_Other:
501 if ((
ch >= u
'a' &&
ch <= u
'z') ||
502 (
ch >= u
'A' &&
ch <= u
'Z') ||
503 (
ch >= u
'0' &&
ch <= u
'9') ||
504 ch == u
'$' ||
ch == u
'_' ||
505 ch == 0x200c ||
ch == 0x200d )
508 switch (QChar::category(
ch)) {
509 case QChar::Mark_NonSpacing:
510 case QChar::Mark_SpacingCombining:
512 case QChar::Number_DecimalDigit:
513 case QChar::Number_Letter:
515 case QChar::Letter_Uppercase:
516 case QChar::Letter_Lowercase:
517 case QChar::Letter_Titlecase:
518 case QChar::Letter_Modifier:
519 case QChar::Letter_Other:
521 case QChar::Punctuation_Connector:
529int Lexer::scanToken()
539 return scanString(TemplateContinuation);
549 if (isLineTerminator()) {
550 bool isAtEnd = (_codePtr + (_skipLinefeed ? 1 : 0)) == _endPtr;
553 _tokenLine = _currentLineNumber;
554 _tokenColumn = _currentColumnNumber;
555 _tokenStartPtr = _codePtr - 1;
559 syncProhibitAutomaticSemicolon();
566 _tokenStartPtr = _codePtr - 1;
567 _tokenLine = _currentLineNumber;
568 _tokenColumn = _currentColumnNumber;
570 if (_codePtr >= _endPtr) {
578 }
else if (_codePtr > _endPtr) {
586 switch (
ch.unicode()) {
587 case u
'~':
return T_TILDE;
588 case u
'}':
return T_RBRACE;
600 case u
'{':
return T_LBRACE;
609 case u
']':
return T_RBRACKET;
610 case u
'[':
return T_LBRACKET;
614 return T_QUESTION_QUESTION;
618 return T_QUESTION_DOT;
631 return T_GT_GT_GT_EQ;
673 case u
';':
return T_SEMICOLON;
674 case u
':':
return T_COLON;
680 while (_codePtr <= _endPtr) {
700 return T_PARTIAL_COMMENT;
704 while (_codePtr <= _endPtr && !isLineTerminator()) {
725 return scanNumber(
ch);
752 return T_MINUS_MINUS;
756 case u
',':
return T_COMMA;
783 return T_STAR_STAR_EQ;
789 case u
')':
return T_RPAREN;
790 case u
'(':
return T_LPAREN;
792 case u
'@':
return T_AT;
807 return T_REMAINDER_EQ;
827 return scanString(ScanStringMode(
ch.unicode()));
839 return scanVersionNumber(
ch);
841 return scanNumber(
ch);
844 if (_currentLineNumber == 1 && _currentColumnNumber == 2) {
846 while (_codePtr <= _endPtr && !isLineTerminator()) {
862 bool identifierWithEscapeChars =
false;
863 if (QChar::isHighSurrogate(
c) && QChar::isLowSurrogate(_state.
currentChar.unicode())) {
867 identifierWithEscapeChars =
true;
869 c = decodeUnicodeEscapeCharacter(&
ok);
874 if (identifierWithEscapeChars) {
876 if (QChar::requiresSurrogates(
c)) {
877 _tokenText +=
QChar(QChar::highSurrogate(
c));
878 _tokenText +=
QChar(QChar::lowSurrogate(
c));
884 while (_codePtr <= _endPtr) {
886 if (QChar::isHighSurrogate(
c) && QChar::isLowSurrogate(_codePtr->unicode())) {
889 }
else if (_state.
currentChar == u
'\\' && _codePtr[0] == u
'u') {
890 if (!identifierWithEscapeChars) {
891 identifierWithEscapeChars =
true;
893 _tokenText.
insert(0, _tokenStartPtr, _codePtr - _tokenStartPtr - 1);
899 c = decodeUnicodeEscapeCharacter(&
ok);
906 if (QChar::requiresSurrogates(
c)) {
907 _tokenText +=
QChar(QChar::highSurrogate(
c));
908 _tokenText +=
QChar(QChar::lowSurrogate(
c));
918 if (identifierWithEscapeChars) {
919 if (QChar::requiresSurrogates(
c)) {
920 _tokenText +=
QChar(QChar::highSurrogate(
c));
921 _tokenText +=
QChar(QChar::lowSurrogate(
c));
929 _tokenLength = _codePtr - _tokenStartPtr - 1;
931 int kind = T_IDENTIFIER;
933 if (!identifierWithEscapeChars)
934 kind =
classify(_tokenStartPtr, _tokenLength, parseModeFlags());
936 if (kind == T_FUNCTION) {
938 while (_codePtr < _endPtr && _state.
currentChar.isSpace())
941 _tokenLength = _codePtr - _tokenStartPtr - 1;
942 kind = T_FUNCTION_STAR;
949 while (_codePtr <= _endPtr) {
956 _codePtr - _tokenStartPtr - 1 - 4,
962 goto continue_skipping;
969 return T_PARTIAL_COMMENT;
971 goto continue_skipping;
973 while (_codePtr <= _endPtr && !isLineTerminator()) {
978 _codePtr - _tokenStartPtr - 1 - 2,
984 goto continue_skipping;
992 if (kind == T_IDENTIFIER && identifierWithEscapeChars)
995 _tokenSpell = _engine->
midRef(_tokenStartPtr - _code.
unicode(), _tokenLength);
1008int Lexer::scanString(ScanStringMode
mode)
1016 bool multilineStringLiteral =
false;
1018 const QChar *startCode = _codePtr - 1;
1021 _skipLinefeed =
false;
1025 while (_codePtr <= _endPtr) {
1026 if (isLineTerminator()) {
1029 --_currentLineNumber;
1034 "Stray newline in string literal");
1042 _engine->
midRef(startCode - _code.
unicode(), _codePtr - startCode - 1);
1043 _rawString = _tokenSpell;
1048 if (
mode == TemplateHead)
1049 return T_NO_SUBSTITUTION_TEMPLATE;
1050 else if (
mode == TemplateContinuation)
1051 return T_TEMPLATE_TAIL;
1052 else if (multilineStringLiteral)
1053 return T_MULTILINE_STRING_LITERAL;
1055 return T_STRING_LITERAL;
1059 ++_currentColumnNumber;
1066 --_currentColumnNumber;
1069 _tokenText =
QString(startCode, _codePtr - startCode);
1071 auto setRawString = [&](
const QChar *
end) {
1074 raw.replace(u
'\r', u
'\n');
1080 while (_codePtr <= _endPtr) {
1087 setRawString(_codePtr - 1);
1093 if (
mode == TemplateContinuation)
1094 return T_TEMPLATE_TAIL;
1095 else if (
mode == TemplateHead)
1096 return T_NO_SUBSTITUTION_TEMPLATE;
1098 return multilineStringLiteral ? T_MULTILINE_STRING_LITERAL : T_STRING_LITERAL;
1099 }
else if (
quote == u
'`' && _state.
currentChar == u
'$' && *_codePtr == u
'{') {
1105 setRawString(_codePtr - 2);
1108 return (
mode == TemplateHead ? T_TEMPLATE_HEAD : T_TEMPLATE_MIDDLE);
1111 if (_codePtr > _endPtr) {
1114 "QQmlParser",
"End of file reached at escape sequence");
1124 uint codePoint = decodeUnicodeEscapeCharacter(&
ok);
1127 if (QChar::requiresSurrogates(codePoint)) {
1129 _tokenText +=
QChar(QChar::highSurrogate(codePoint));
1130 u = QChar::lowSurrogate(codePoint);
1132 u =
QChar(codePoint);
1139 u = decodeHexEscapeCharacter(&
ok);
1143 "QQmlParser",
"Illegal hexadecimal escape sequence");
1149 case u
'\\': u = u
'\\'; scanChar();
break;
1150 case u
'\'': u = u
'\''; scanChar();
break;
1151 case u
'\"': u = u
'\"'; scanChar();
break;
1152 case u
'b': u = u
'\b'; scanChar();
break;
1153 case u
'f': u = u
'\f'; scanChar();
break;
1154 case u
'n': u = u
'\n'; scanChar();
break;
1155 case u
'r': u = u
'\r'; scanChar();
break;
1156 case u
't': u = u
'\t'; scanChar();
break;
1157 case u
'v': u = u
'\v'; scanChar();
break;
1160 if (!_codePtr->isDigit()) {
1177 "QQmlParser",
"Octal escape sequences are not allowed");
1202 if (
mode == TemplateContinuation)
1203 return T_PARTIAL_TEMPLATE_MIDDLE;
1204 else if (
mode == TemplateHead)
1205 return T_PARTIAL_TEMPLATE_HEAD;
1206 else if (
mode == SingleQuote)
1207 return T_PARTIAL_SINGLE_QUOTE_STRING_LITERAL;
1208 return T_PARTIAL_DOUBLE_QUOTE_STRING_LITERAL;
1215int Lexer::scanNumber(
QChar ch)
1217 auto scanOptionalNumericSeparator = [
this](
auto isNextCharacterValid){
1219 if (peekChar() == u
'_') {
1223 "There can be at most one numeric separator beetwen digits"
1228 if (!isNextCharacterValid()) {
1232 "A trailing numeric separator is not allowed in numeric literals"
1254 "At least one hexadecimal digit is required after '0%1'")
1268 if (!scanOptionalNumericSeparator([
this](){
return isHexDigit(peekChar()); }))
1273 return T_NUMERIC_LITERAL;
1280 if (!isOctalDigit(_state.
currentChar.unicode())) {
1284 "QQmlParser",
"At least one octal digit is required after '0%1'")
1298 if (!scanOptionalNumericSeparator([
this](){
1299 return isOctalDigit(peekChar().unicode());
1306 return T_NUMERIC_LITERAL;
1317 "QQmlParser",
"At least one binary digit is required after '0%1'")
1333 if (!scanOptionalNumericSeparator([
this](){
1334 return peekChar().unicode() == u
'0' || peekChar().unicode() == u
'1';
1341 return T_NUMERIC_LITERAL;
1345 "Decimal numbers can't start with '0'");
1351 QVarLengthArray<char,32> chars;
1352 chars.append(
ch.unicode());
1355 if (!scanOptionalNumericSeparator([
this](){
return peekChar().isDigit(); }))
1362 if (!scanOptionalNumericSeparator([
this](){
return peekChar().isDigit(); }))
1376 if (!scanOptionalNumericSeparator([
this](){
return peekChar().isDigit(); }))
1382 || ((_codePtr[0] == u
'+' || _codePtr[0] == u
'-') && _codePtr[1].
isDigit())) {
1396 if (!scanOptionalNumericSeparator([
this](){
return peekChar().isDigit(); }))
1402 const char *
begin = chars.constData();
1403 const char *
end =
nullptr;
1415 return T_NUMERIC_LITERAL;
1418int Lexer::scanVersionNumber(
QChar ch)
1422 return T_VERSION_NUMBER;
1426 acc +=
ch.digitValue();
1435 return T_VERSION_NUMBER;
1458 "QQmlParser",
"Invalid regular expression flag '%0'")
1466 _tokenLength = _codePtr - _tokenStartPtr - 1;
1474 if (_codePtr > _endPtr || isLineTerminator()) {
1476 "QQmlParser",
"Unterminated regular expression backslash sequence");
1489 while (_codePtr <= _endPtr && !isLineTerminator()) {
1497 if (_codePtr > _endPtr || isLineTerminator()) {
1499 "QQmlParser",
"Unterminated regular expression backslash sequence");
1513 "QQmlParser",
"Unterminated regular expression class");
1522 if (_codePtr > _endPtr || isLineTerminator()) {
1524 "QQmlParser",
"Unterminated regular expression literal");
1536bool Lexer::isLineTerminator()
const
1539 return unicode == 0x000Au
1540 || unicode == 0x000Du
1541 || unicode == 0x2028u
1542 || unicode == 0x2029u;
1545unsigned Lexer::isLineTerminatorSequence()
const
1553 if (_codePtr->unicode() == 0x000Au)
1562bool Lexer::isIdentLetter(
QChar ch)
1566 if ((
ch >= u
'a' &&
ch <= u
'z')
1567 || (
ch >= u
'A' &&
ch <= u
'Z')
1568 ||
ch == u
'$' ||
ch == u
'_')
1570 if (
ch.unicode() < 128)
1572 return ch.isLetterOrNumber();
1575bool Lexer::isDecimalDigit(
ushort c)
1577 return (
c >= u
'0' &&
c <= u
'9');
1580bool Lexer::isHexDigit(
QChar c)
1582 return ((
c >= u
'0' &&
c <= u
'9')
1583 || (
c >= u
'a' &&
c <= u
'f')
1584 || (
c >= u
'A' &&
c <= u
'F'));
1587bool Lexer::isOctalDigit(
ushort c)
1589 return (
c >= u
'0' &&
c <= u
'7');
1597 if (_state.
tokenKind == T_STRING_LITERAL)
1598 return QString(_tokenStartPtr + 1, _tokenLength - 2);
1600 return QString(_tokenStartPtr, _tokenLength);
1610 return _errorMessage;
1613void Lexer::syncProhibitAutomaticSemicolon()
1626bool Lexer::prevTerminator()
const
1631bool Lexer::followsClosingBrace()
const
1643 QQmlJSGrammar::T_IDENTIFIER,
1644 QQmlJSGrammar::T_PROPERTY,
1645 QQmlJSGrammar::T_SIGNAL,
1646 QQmlJSGrammar::T_READONLY,
1647 QQmlJSGrammar::T_ON,
1648 QQmlJSGrammar::T_BREAK,
1649 QQmlJSGrammar::T_CASE,
1650 QQmlJSGrammar::T_CATCH,
1651 QQmlJSGrammar::T_CONTINUE,
1652 QQmlJSGrammar::T_DEFAULT,
1653 QQmlJSGrammar::T_DELETE,
1654 QQmlJSGrammar::T_DO,
1655 QQmlJSGrammar::T_ELSE,
1656 QQmlJSGrammar::T_FALSE,
1657 QQmlJSGrammar::T_FINALLY,
1658 QQmlJSGrammar::T_FOR,
1659 QQmlJSGrammar::T_FUNCTION,
1660 QQmlJSGrammar::T_FUNCTION_STAR,
1661 QQmlJSGrammar::T_IF,
1662 QQmlJSGrammar::T_IN,
1663 QQmlJSGrammar::T_OF,
1664 QQmlJSGrammar::T_INSTANCEOF,
1665 QQmlJSGrammar::T_NEW,
1666 QQmlJSGrammar::T_NULL,
1667 QQmlJSGrammar::T_RETURN,
1668 QQmlJSGrammar::T_SWITCH,
1669 QQmlJSGrammar::T_THIS,
1670 QQmlJSGrammar::T_THROW,
1671 QQmlJSGrammar::T_TRUE,
1672 QQmlJSGrammar::T_TRY,
1673 QQmlJSGrammar::T_TYPEOF,
1674 QQmlJSGrammar::T_VAR,
1675 QQmlJSGrammar::T_VOID,
1676 QQmlJSGrammar::T_WHILE,
1677 QQmlJSGrammar::T_CONST,
1678 QQmlJSGrammar::T_DEBUGGER,
1679 QQmlJSGrammar::T_RESERVED_WORD,
1680 QQmlJSGrammar::T_WITH,
1682 QQmlJSGrammar::EOF_SYMBOL
1687 while (*current != QQmlJSGrammar::EOF_SYMBOL) {
1688 if (*current ==
token)
1745 bool fileImport =
false;
1747 if (_state.
tokenKind == T_STRING_LITERAL) {
1759 }
else if (_state.
tokenKind == T_IDENTIFIER) {
1774 if (_state.
tokenKind != QQmlJSGrammar::T_DOT)
1777 pathOrUri.append(u
'.');
1786 if (_state.
tokenKind == T_VERSION_NUMBER) {
1792 if (_state.
tokenKind != T_VERSION_NUMBER) {
1794 "QQmlParser",
"Incomplete version number (dot but no minor)"));
1812 error->loc.startLine = lineNumber;
1826 const QString module = tokenText();
1827 if (!module.at(0).isUpper()) {
1859int Lexer::parseModeFlags()
const {
1865 if (_staticIsKeyword)
1874 <<
" errorCode:" << int(
s.errorCode) <<
",\n"
1875 <<
" currentChar:" <<
s.currentChar <<
",\n"
1876 <<
" tokenValue:" <<
s.tokenValue <<
",\n"
1877 <<
" parenthesesState:" <<
s.parenthesesState <<
",\n"
1878 <<
" parenthesesCount:" <<
s.parenthesesCount <<
",\n"
1879 <<
" outerTemplateBraceCount:" <<
s.outerTemplateBraceCount <<
",\n"
1880 <<
" bracesCount:" <<
s.bracesCount <<
",\n"
1881 <<
" stackToken:" <<
s.stackToken <<
",\n"
1882 <<
" patternFlags:" <<
s.patternFlags <<
",\n"
1883 <<
" tokenKind:" <<
s.tokenKind <<
",\n"
1884 <<
" importState:" << int(
s.importState) <<
",\n"
1885 <<
" validTokenText:" <<
s.validTokenText <<
",\n"
1886 <<
" prohibitAutomaticSemicolon:" <<
s.prohibitAutomaticSemicolon <<
",\n"
1887 <<
" restrictedKeyword:" <<
s.restrictedKeyword <<
",\n"
1888 <<
" terminator:" <<
s.terminator <<
",\n"
1889 <<
" followsClosingBrace:" <<
s.followsClosingBrace <<
",\n"
1890 <<
" delimited:" <<
s.delimited <<
",\n"
1891 <<
" handlingDirectives:" <<
s.handlingDirectives <<
",\n"
1892 <<
" generatorLevel:" <<
s.generatorLevel <<
"\n}";
static QString translate(const char *context, const char *key, const char *disambiguation=nullptr, int n=-1)
\threadsafe
virtual void pragmaLibrary()
virtual void importFile(const QString &jsfile, const QString &module, int line, int column)
virtual void importModule(const QString &uri, const QString &version, const QString &module, int line, int column)
void addComment(int pos, int len, int line, int col)
QStringView midRef(int position, int size)
QStringView newStringRef(const QString &text)
void setCode(const QString &code)
void setCode(const QString &code, int lineno, bool qmlMode=true, CodeContinuation codeContinuation=CodeContinuation::Reset)
static int classify(const QChar *s, int n, int parseModeFlags)
int tokenStartColumn() const
QString tokenText() const
@ IllegalUnicodeEscapeSequence
@ IllegalExponentIndicator
@ IllegalHexadecimalEscapeSequence
bool scanDirectives(Directives *directives, DiagnosticMessage *error)
bool scanRegExp(RegExpBodyPrefix prefix=NoPrefix)
const State & state() const
bool yieldIsKeyWord() const
int tokenStartLine() const
void setState(const State &state)
Lexer(Engine *engine, LexMode lexMode=LexMode::WholeCode)
QString errorMessage() const
bool canInsertAutomaticSemicolon(int token) const
T pop()
Removes the top item from the stack and returns it.
void push(const T &t)
Adds element t to the top of the stack.
\macro QT_RESTRICTED_CAST_FROM_ASCII
void reserve(qsizetype size)
Ensures the string has space for at least size characters.
bool isEmpty() const noexcept
Returns true if the string has no characters; otherwise returns false.
void clear()
Clears the contents of the string and makes it null.
qsizetype size() const noexcept
Returns the number of characters in this string.
QString & insert(qsizetype i, QChar c)
const QChar * unicode() const
Returns a Unicode representation of the string.
void resize(qsizetype size)
Sets the size of the string to size characters.
QDebug operator<<(QDebug dbg, const Lexer &l)
Combined button and popup list for selecting options.
DBusConnection const char DBusError * error
GLuint GLsizei const GLchar * message
GLenum GLenum GLsizei void GLsizei void * column
static int regExpFlagFromChar(const QChar &ch)
static const int uriTokens[]
static bool isIdentifierPart(uint ch)
static bool isUriToken(int token)
static unsigned char convertHex(ushort c)
static bool isIdentifierStart(uint ch)
static void setError(QJsonObject *response, const QString &msg)
static QT_BEGIN_NAMESPACE bool isDigit(ushort ch)
QtPrivate::QRegularExpressionMatchIteratorRangeBasedForIterator begin(const QRegularExpressionMatchIterator &iterator)
QLatin1StringView QLatin1String
static QString quote(const QString &str)
ParenthesesState parenthesesState
bool prohibitAutomaticSemicolon
QStack< int > outerTemplateBraceCount