Lines Matching refs:AsmToken
80 typedef std::vector<AsmToken> MCAsmMacroArgument;
518 const AsmToken &Lex(ExpandKind ExpandNextToken);
519 const AsmToken &Lex() override { return Lex(ExpandMacros); } in Lex()
575 const AsmToken peekTok(bool ShouldSkipSpace = true);
596 AsmToken::TokenKind ArgumentEndTok = AsmToken::EndOfStatement);
610 AsmToken::TokenKind EndTok = AsmToken::EndOfStatement);
615 AsmToken::TokenKind EndTok = AsmToken::EndOfStatement);
652 SmallVector<StringRef, 1> parseStringRefsTo(AsmToken::TokenKind EndTok);
653 std::string parseStringTo(AsmToken::TokenKind EndTok);
662 unsigned getBinOpPrecedence(AsmToken::TokenKind K,
862 const AsmToken::TokenKind EndToken = AsmToken::EndOfStatement);
876 const AsmToken::TokenKind EndToken = AsmToken::EndOfStatement);
901 const AsmToken::TokenKind EndToken = AsmToken::EndOfStatement);
1186 const AsmToken &Tok = getTok(); in expandMacros()
1190 if (M && M->IsFunction && peekTok().is(AsmToken::LParen)) { in expandMacros()
1196 Lexer.UnLex(AsmToken(AsmToken::Error, MacroId)); in expandMacros()
1229 const AsmToken &MasmParser::Lex(ExpandKind ExpandNextToken) { in Lex()
1230 if (Lexer.getTok().is(AsmToken::Error)) in Lex()
1234 if (getTok().is(AsmToken::EndOfStatement)) { in Lex()
1241 const AsmToken *tok = &Lexer.Lex(); in Lex()
1244 while (ExpandNextToken == ExpandMacros && tok->is(AsmToken::Identifier)) { in Lex()
1246 AsmToken NextTok; in Lex()
1247 MutableArrayRef<AsmToken> Buf(NextTok); in Lex()
1249 if (ReadCount && NextTok.is(AsmToken::Identifier) && in Lex()
1262 while (tok->is(AsmToken::Comment)) { in Lex()
1269 while (tok->is(AsmToken::BackSlash) && in Lex()
1270 peekTok().is(AsmToken::EndOfStatement)) { in Lex()
1276 if (tok->is(AsmToken::Eof)) { in Lex()
1292 const AsmToken MasmParser::peekTok(bool ShouldSkipSpace) { in peekTok()
1293 AsmToken Tok; in peekTok()
1295 MutableArrayRef<AsmToken> Buf(Tok); in peekTok()
1369 while (Lexer.isNot(AsmToken::Eof) || in Run()
1372 if (Lexer.is(AsmToken::Eof)) in Run()
1381 if (Parsed && !hasPendingError() && Lexer.getTok().is(AsmToken::Error)) { in Run()
1469 while (Lexer.isNot(AsmToken::EndOfStatement)) { in eatToEndOfStatement()
1470 if (Lexer.is(AsmToken::Eof)) { in eatToEndOfStatement()
1484 if (Lexer.is(AsmToken::EndOfStatement)) in eatToEndOfStatement()
1489 MasmParser::parseStringRefsTo(AsmToken::TokenKind EndTok) { in parseStringRefsTo()
1493 if (Lexer.is(AsmToken::Eof)) { in parseStringRefsTo()
1512 std::string MasmParser::parseStringTo(AsmToken::TokenKind EndTok) { in parseStringTo()
1524 while (Lexer.isNot(AsmToken::EndOfStatement) && Lexer.isNot(AsmToken::Eof)) in parseStringToEndOfStatement()
1552 if (parseToken(AsmToken::RBrac, "expected ']' in brackets expression")) in parseBracketExpr()
1568 AsmToken::TokenKind FirstTokenKind = Lexer.getKind(); in parsePrimaryExpr()
1573 case AsmToken::Error: in parsePrimaryExpr()
1575 case AsmToken::Exclaim: in parsePrimaryExpr()
1581 case AsmToken::Dollar: in parsePrimaryExpr()
1582 case AsmToken::At: in parsePrimaryExpr()
1583 case AsmToken::Identifier: { in parsePrimaryExpr()
1587 if (getTok().is(AsmToken::Dollar)) { in parsePrimaryExpr()
1623 } else if (Lexer.is(AsmToken::LParen)) { in parsePrimaryExpr()
1628 if (parseToken(AsmToken::RParen, in parsePrimaryExpr()
1733 case AsmToken::BigNum: in parsePrimaryExpr()
1735 case AsmToken::Integer: { in parsePrimaryExpr()
1742 case AsmToken::String: { in parsePrimaryExpr()
1756 case AsmToken::Real: { in parsePrimaryExpr()
1764 case AsmToken::Dot: { in parsePrimaryExpr()
1774 case AsmToken::LParen: in parsePrimaryExpr()
1777 case AsmToken::LBrac: in parsePrimaryExpr()
1782 case AsmToken::Minus: in parsePrimaryExpr()
1788 case AsmToken::Plus: in parsePrimaryExpr()
1794 case AsmToken::Tilde: in parsePrimaryExpr()
1802 case AsmToken::PercentCall16: in parsePrimaryExpr()
1803 case AsmToken::PercentCall_Hi: in parsePrimaryExpr()
1804 case AsmToken::PercentCall_Lo: in parsePrimaryExpr()
1805 case AsmToken::PercentDtprel_Hi: in parsePrimaryExpr()
1806 case AsmToken::PercentDtprel_Lo: in parsePrimaryExpr()
1807 case AsmToken::PercentGot: in parsePrimaryExpr()
1808 case AsmToken::PercentGot_Disp: in parsePrimaryExpr()
1809 case AsmToken::PercentGot_Hi: in parsePrimaryExpr()
1810 case AsmToken::PercentGot_Lo: in parsePrimaryExpr()
1811 case AsmToken::PercentGot_Ofst: in parsePrimaryExpr()
1812 case AsmToken::PercentGot_Page: in parsePrimaryExpr()
1813 case AsmToken::PercentGottprel: in parsePrimaryExpr()
1814 case AsmToken::PercentGp_Rel: in parsePrimaryExpr()
1815 case AsmToken::PercentHi: in parsePrimaryExpr()
1816 case AsmToken::PercentHigher: in parsePrimaryExpr()
1817 case AsmToken::PercentHighest: in parsePrimaryExpr()
1818 case AsmToken::PercentLo: in parsePrimaryExpr()
1819 case AsmToken::PercentNeg: in parsePrimaryExpr()
1820 case AsmToken::PercentPcrel_Hi: in parsePrimaryExpr()
1821 case AsmToken::PercentPcrel_Lo: in parsePrimaryExpr()
1822 case AsmToken::PercentTlsgd: in parsePrimaryExpr()
1823 case AsmToken::PercentTlsldm: in parsePrimaryExpr()
1824 case AsmToken::PercentTprel_Hi: in parsePrimaryExpr()
1825 case AsmToken::PercentTprel_Lo: in parsePrimaryExpr()
1827 if (Lexer.isNot(AsmToken::LParen)) in parsePrimaryExpr()
1942 static unsigned getGNUBinOpPrecedence(AsmToken::TokenKind K, in getGNUBinOpPrecedence()
1951 case AsmToken::AmpAmp: in getGNUBinOpPrecedence()
1954 case AsmToken::PipePipe: in getGNUBinOpPrecedence()
1959 case AsmToken::EqualEqual: in getGNUBinOpPrecedence()
1962 case AsmToken::ExclaimEqual: in getGNUBinOpPrecedence()
1963 case AsmToken::LessGreater: in getGNUBinOpPrecedence()
1966 case AsmToken::Less: in getGNUBinOpPrecedence()
1969 case AsmToken::LessEqual: in getGNUBinOpPrecedence()
1972 case AsmToken::Greater: in getGNUBinOpPrecedence()
1977 case AsmToken::GreaterEqual: in getGNUBinOpPrecedence()
1982 case AsmToken::Plus: in getGNUBinOpPrecedence()
1985 case AsmToken::Minus: in getGNUBinOpPrecedence()
1990 case AsmToken::Pipe: in getGNUBinOpPrecedence()
1993 case AsmToken::Caret: in getGNUBinOpPrecedence()
1996 case AsmToken::Amp: in getGNUBinOpPrecedence()
2001 case AsmToken::Star: in getGNUBinOpPrecedence()
2004 case AsmToken::Slash: in getGNUBinOpPrecedence()
2007 case AsmToken::Percent: in getGNUBinOpPrecedence()
2010 case AsmToken::LessLess: in getGNUBinOpPrecedence()
2013 case AsmToken::GreaterGreater: in getGNUBinOpPrecedence()
2021 unsigned MasmParser::getBinOpPrecedence(AsmToken::TokenKind K, in getBinOpPrecedence()
2034 AsmToken::TokenKind TokKind = Lexer.getKind(); in parseBinOpRHS()
2035 if (Lexer.getKind() == AsmToken::Identifier) { in parseBinOpRHS()
2036 TokKind = StringSwitch<AsmToken::TokenKind>(Lexer.getTok().getString()) in parseBinOpRHS()
2037 .CaseLower("and", AsmToken::Amp) in parseBinOpRHS()
2038 .CaseLower("not", AsmToken::Exclaim) in parseBinOpRHS()
2039 .CaseLower("or", AsmToken::Pipe) in parseBinOpRHS()
2040 .CaseLower("xor", AsmToken::Caret) in parseBinOpRHS()
2041 .CaseLower("shl", AsmToken::LessLess) in parseBinOpRHS()
2042 .CaseLower("shr", AsmToken::GreaterGreater) in parseBinOpRHS()
2043 .CaseLower("eq", AsmToken::EqualEqual) in parseBinOpRHS()
2044 .CaseLower("ne", AsmToken::ExclaimEqual) in parseBinOpRHS()
2045 .CaseLower("lt", AsmToken::Less) in parseBinOpRHS()
2046 .CaseLower("le", AsmToken::LessEqual) in parseBinOpRHS()
2047 .CaseLower("gt", AsmToken::Greater) in parseBinOpRHS()
2048 .CaseLower("ge", AsmToken::GreaterEqual) in parseBinOpRHS()
2087 while (Lexer.is(AsmToken::Space)) in parseStatement()
2089 if (Lexer.is(AsmToken::EndOfStatement)) { in parseStatement()
2100 if (getTok().is(AsmToken::Percent)) { in parseStatement()
2102 if (parseToken(AsmToken::Percent) || expandStatement(ExpansionLoc)) in parseStatement()
2108 AsmToken ID = getTok(); in parseStatement()
2111 if (Lexer.is(AsmToken::HashDirective)) in parseStatement()
2113 if (Lexer.is(AsmToken::Dot)) { in parseStatement()
2117 } else if (Lexer.is(AsmToken::Real)) { in parseStatement()
2206 if (Lexer.is(AsmToken::Colon) && getTargetParser().isLabel(ID)) { in parseStatement()
2243 if (getTok().is(AsmToken::Hash)) { in parseStatement()
2244 std::string CommentStr = parseStringTo(AsmToken::EndOfStatement); in parseStatement()
2246 Lexer.UnLex(AsmToken(AsmToken::EndOfStatement, CommentStr)); in parseStatement()
2251 if (getTok().is(AsmToken::EndOfStatement)) { in parseStatement()
2296 getTok().is(AsmToken::EndOfStatement)) { in parseStatement()
2308 if (ID.isNot(AsmToken::Identifier)) in parseStatement()
2509 const AsmToken nextTok = getTok(); in parseStatement()
2513 const AsmToken afterNextTok = peekTok(); in parseStatement()
2558 if (afterNextTok.is(AsmToken::Identifier) && in parseStatement()
2569 if (afterNextTok.is(AsmToken::Identifier) && in parseStatement()
2580 if (afterNextTok.is(AsmToken::Identifier) && in parseStatement()
2591 if (afterNextTok.is(AsmToken::Identifier) && in parseStatement()
2601 if (afterNextTok.is(AsmToken::Identifier) && in parseStatement()
2729 if (Lexer.isNot(AsmToken::LCurly) && Lexer.isNot(AsmToken::RCurly)) in parseCurlyBlockScope()
2734 if (Lexer.is(AsmToken::EndOfStatement)) in parseCurlyBlockScope()
2749 assert(getTok().is(AsmToken::Integer) && in parseCppHashLineFilenameComment()
2753 assert(getTok().is(AsmToken::String) && in parseCppHashLineFilenameComment()
2925 for (const AsmToken &Token : A[Index]) { in expandMacro()
2933 if (Token.getString().front() == '%' && Token.is(AsmToken::Integer)) in expandMacro()
2952 static bool isOperator(AsmToken::TokenKind kind) { in isOperator()
2956 case AsmToken::Plus: in isOperator()
2957 case AsmToken::Minus: in isOperator()
2958 case AsmToken::Tilde: in isOperator()
2959 case AsmToken::Slash: in isOperator()
2960 case AsmToken::Star: in isOperator()
2961 case AsmToken::Dot: in isOperator()
2962 case AsmToken::Equal: in isOperator()
2963 case AsmToken::EqualEqual: in isOperator()
2964 case AsmToken::Pipe: in isOperator()
2965 case AsmToken::PipePipe: in isOperator()
2966 case AsmToken::Caret: in isOperator()
2967 case AsmToken::Amp: in isOperator()
2968 case AsmToken::AmpAmp: in isOperator()
2969 case AsmToken::Exclaim: in isOperator()
2970 case AsmToken::ExclaimEqual: in isOperator()
2971 case AsmToken::Less: in isOperator()
2972 case AsmToken::LessEqual: in isOperator()
2973 case AsmToken::LessLess: in isOperator()
2974 case AsmToken::LessGreater: in isOperator()
2975 case AsmToken::Greater: in isOperator()
2976 case AsmToken::GreaterEqual: in isOperator()
2977 case AsmToken::GreaterGreater: in isOperator()
3002 AsmToken::TokenKind EndTok) { in parseMacroArgument()
3007 MA.emplace_back(AsmToken::String, S); in parseMacroArgument()
3014 if (Lexer.is(AsmToken::Less) && isAngleBracketString(StrLoc, EndLoc)) { in parseMacroArgument()
3020 MA.emplace_back(AsmToken::String, StringRef(StrChar, EndChar - StrChar)); in parseMacroArgument()
3033 if (Lexer.is(AsmToken::Eof) || Lexer.is(AsmToken::Equal)) in parseMacroArgument()
3037 if (Lexer.is(AsmToken::Comma)) in parseMacroArgument()
3040 if (Lexer.is(AsmToken::Space)) { in parseMacroArgument()
3054 if (Lexer.is(AsmToken::Space)) in parseMacroArgument()
3066 if (Lexer.is(EndTok) && (EndTok != AsmToken::RParen || ParenLevel == 0)) in parseMacroArgument()
3070 if (Lexer.is(AsmToken::LParen)) in parseMacroArgument()
3072 else if (Lexer.is(AsmToken::RParen) && ParenLevel) in parseMacroArgument()
3097 AsmToken::TokenKind EndTok) { in parseMacroArguments()
3113 if (Lexer.is(AsmToken::Identifier) && peekTok().is(AsmToken::Equal)) { in parseMacroArguments()
3117 if (Lexer.isNot(AsmToken::Equal)) in parseMacroArguments()
3148 if (Lexer.is(AsmToken::Percent)) { in parseMacroArguments()
3160 AsmToken newToken(AsmToken::Integer, in parseMacroArguments()
3203 if (Lexer.is(AsmToken::Comma)) in parseMacroArguments()
3211 AsmToken::TokenKind ArgumentEndTok) { in handleMacroEntry()
3277 if (parseToken(AsmToken::LParen, "invoking macro function '" + M->Name + in handleMacroInvocation()
3279 handleMacroEntry(M, NameLoc, AsmToken::RParen)) in handleMacroInvocation()
3285 while (Lexer.isNot(AsmToken::Eof)) { in handleMacroInvocation()
3297 if (Parsed && !hasPendingError() && Lexer.getTok().is(AsmToken::Error)) { in handleMacroInvocation()
3339 if (Lexer.is(AsmToken::Dollar) || Lexer.is(AsmToken::At)) { in parseIdentifier()
3344 AsmToken nextTok = peekTok(false); in parseIdentifier()
3346 if (nextTok.isNot(AsmToken::Identifier)) in parseIdentifier()
3362 if (Lexer.isNot(AsmToken::Identifier) && Lexer.isNot(AsmToken::String)) in parseIdentifier()
3413 if (parseOptionalToken(AsmToken::Comma) && parseMany(parseItem)) in parseDirectiveEquate()
3513 if (check(getTok().isNot(AsmToken::String), "expected string")) in parseEscapedString()
3557 case AsmToken::Percent: { in parseTextItem()
3559 if (parseToken(AsmToken::Percent) || parseAbsoluteExpression(Res)) in parseTextItem()
3564 case AsmToken::Less: in parseTextItem()
3565 case AsmToken::LessEqual: in parseTextItem()
3566 case AsmToken::LessLess: in parseTextItem()
3567 case AsmToken::LessGreater: in parseTextItem()
3569 case AsmToken::Identifier: { in parseTextItem()
3614 getLexer().UnLex(AsmToken(AsmToken::Identifier, ID)); in parseTextItem()
3664 if (Size == 1 && getTok().is(AsmToken::String)) { in parseScalarInitializer()
3679 if (getTok().is(AsmToken::Identifier) && in parseScalarInitializer()
3692 if (parseToken(AsmToken::LParen, in parseScalarInitializer()
3708 const AsmToken::TokenKind EndToken) { in parseScalarInstList()
3710 (EndToken != AsmToken::Greater || in parseScalarInstList()
3711 getTok().isNot(AsmToken::GreaterGreater))) { in parseScalarInstList()
3715 if (!parseOptionalToken(AsmToken::Comma)) in parseScalarInstList()
3717 parseOptionalToken(AsmToken::EndOfStatement); in parseScalarInstList()
3796 if (Asm.getTok().isNot(AsmToken::Integer) && in parseHexOcta()
3797 Asm.getTok().isNot(AsmToken::BigNum)) in parseHexOcta()
3819 if (getLexer().is(AsmToken::Minus)) { in parseRealValue()
3823 } else if (getLexer().is(AsmToken::Plus)) { in parseRealValue()
3828 if (Lexer.is(AsmToken::Error)) in parseRealValue()
3830 if (Lexer.isNot(AsmToken::Integer) && Lexer.isNot(AsmToken::Real) && in parseRealValue()
3831 Lexer.isNot(AsmToken::Identifier)) in parseRealValue()
3837 if (getLexer().is(AsmToken::Identifier)) { in parseRealValue()
3878 const AsmToken::TokenKind EndToken) { in parseRealInstList()
3880 (EndToken == AsmToken::Greater && in parseRealInstList()
3881 getTok().isNot(AsmToken::GreaterGreater))) { in parseRealInstList()
3882 const AsmToken NextTok = peekTok(); in parseRealInstList()
3883 if (NextTok.is(AsmToken::Identifier) && in parseRealInstList()
3886 if (parseExpression(Value) || parseToken(AsmToken::Identifier)) in parseRealInstList()
3898 if (parseToken(AsmToken::LParen, in parseRealInstList()
3913 if (!parseOptionalToken(AsmToken::Comma)) in parseRealInstList()
3915 parseOptionalToken(AsmToken::EndOfStatement); in parseRealInstList()
4005 const AsmToken Tok = getTok(); in parseOptionalAngleBracketOpen()
4006 if (parseOptionalToken(AsmToken::LessLess)) { in parseOptionalAngleBracketOpen()
4008 Lexer.UnLex(AsmToken(AsmToken::Less, Tok.getString().substr(1))); in parseOptionalAngleBracketOpen()
4010 } else if (parseOptionalToken(AsmToken::LessGreater)) { in parseOptionalAngleBracketOpen()
4012 Lexer.UnLex(AsmToken(AsmToken::Greater, Tok.getString().substr(1))); in parseOptionalAngleBracketOpen()
4014 } else if (parseOptionalToken(AsmToken::Less)) { in parseOptionalAngleBracketOpen()
4023 const AsmToken Tok = getTok(); in parseAngleBracketClose()
4024 if (parseOptionalToken(AsmToken::GreaterGreater)) { in parseAngleBracketClose()
4025 Lexer.UnLex(AsmToken(AsmToken::Greater, Tok.getString().substr(1))); in parseAngleBracketClose()
4026 } else if (parseToken(AsmToken::Greater, Msg)) { in parseAngleBracketClose()
4039 if (parseOptionalToken(AsmToken::LCurly)) { in parseFieldInitializer()
4042 if (parseScalarInstList(Field.Type, Values, AsmToken::RCurly) || in parseFieldInitializer()
4043 parseToken(AsmToken::RCurly)) in parseFieldInitializer()
4048 if (parseScalarInstList(Field.Type, Values, AsmToken::Greater) || in parseFieldInitializer()
4091 if (parseOptionalToken(AsmToken::LCurly)) { in parseFieldInitializer()
4094 if (parseRealInstList(*Semantics, AsIntValues, AsmToken::RCurly) || in parseFieldInitializer()
4095 parseToken(AsmToken::RCurly)) in parseFieldInitializer()
4100 if (parseRealInstList(*Semantics, AsIntValues, AsmToken::Greater) || in parseFieldInitializer()
4131 if (parseOptionalToken(AsmToken::LCurly)) { in parseFieldInitializer()
4133 AsmToken::RCurly) || in parseFieldInitializer()
4134 parseToken(AsmToken::RCurly)) in parseFieldInitializer()
4138 AsmToken::Greater) || in parseFieldInitializer()
4179 const AsmToken FirstToken = getTok(); in parseStructInitializer()
4181 std::optional<AsmToken::TokenKind> EndToken; in parseStructInitializer()
4182 if (parseOptionalToken(AsmToken::LCurly)) { in parseStructInitializer()
4183 EndToken = AsmToken::RCurly; in parseStructInitializer()
4185 EndToken = AsmToken::Greater; in parseStructInitializer()
4187 } else if (FirstToken.is(AsmToken::Identifier) && in parseStructInitializer()
4190 if (parseToken(AsmToken::Identifier)) in parseStructInitializer()
4202 if (parseOptionalToken(AsmToken::Comma)) { in parseStructInitializer()
4206 parseOptionalToken(AsmToken::EndOfStatement); in parseStructInitializer()
4215 if (!parseOptionalToken(AsmToken::Comma)) in parseStructInitializer()
4220 parseOptionalToken(AsmToken::EndOfStatement); in parseStructInitializer()
4228 if (*EndToken == AsmToken::Greater) in parseStructInitializer()
4239 const AsmToken::TokenKind EndToken) { in parseStructInstList()
4241 (EndToken == AsmToken::Greater && in parseStructInstList()
4242 getTok().isNot(AsmToken::GreaterGreater))) { in parseStructInstList()
4243 const AsmToken NextTok = peekTok(); in parseStructInstList()
4244 if (NextTok.is(AsmToken::Identifier) && in parseStructInstList()
4247 if (parseExpression(Value) || parseToken(AsmToken::Identifier)) in parseStructInstList()
4259 if (parseToken(AsmToken::LParen, in parseStructInstList()
4273 if (!parseOptionalToken(AsmToken::Comma)) in parseStructInstList()
4275 parseOptionalToken(AsmToken::EndOfStatement); in parseStructInstList()
4510 AsmToken NextTok = getTok(); in parseDirectiveStruct()
4512 if (NextTok.isNot(AsmToken::Comma) && in parseDirectiveStruct()
4513 NextTok.isNot(AsmToken::EndOfStatement) && in parseDirectiveStruct()
4525 if (parseOptionalToken(AsmToken::Comma)) { in parseDirectiveStruct()
4553 if (getTok().is(AsmToken::Identifier)) { in parseDirectiveNestedStruct()
4555 parseToken(AsmToken::Identifier); in parseDirectiveNestedStruct()
4733 if (getTok().is(AsmToken::EndOfStatement)) { in parseDirectiveAlign()
4773 if (getLexer().is(AsmToken::Integer)) { in parseDirectiveFile()
4785 if (check(getTok().isNot(AsmToken::String), in parseDirectiveFile()
4793 if (getLexer().is(AsmToken::String)) { in parseDirectiveFile()
4811 while (!parseOptionalToken(AsmToken::EndOfStatement)) { in parseDirectiveFile()
4813 if (check(getTok().isNot(AsmToken::Identifier), in parseDirectiveFile()
4827 check(getTok().isNot(AsmToken::String), in parseDirectiveFile()
4890 if (getLexer().is(AsmToken::Integer)) { in parseDirectiveLine()
4920 if (getLexer().is(AsmToken::Integer)) { in parseDirectiveLoc()
4928 if (getLexer().is(AsmToken::Integer)) { in parseDirectiveLoc()
5019 check(getTok().isNot(AsmToken::String), in parseDirectiveCVFile()
5023 if (!parseOptionalToken(AsmToken::EndOfStatement)) { in parseDirectiveCVFile()
5024 if (check(getTok().isNot(AsmToken::String), in parseDirectiveCVFile()
5105 if (check((getLexer().isNot(AsmToken::Identifier) || in parseDirectiveCVInlineSiteId()
5116 if (check((getLexer().isNot(AsmToken::Identifier) || in parseDirectiveCVInlineSiteId()
5129 if (getLexer().is(AsmToken::Integer)) { in parseDirectiveCVInlineSiteId()
5159 if (getLexer().is(AsmToken::Integer)) { in parseDirectiveCVLoc()
5167 if (getLexer().is(AsmToken::Integer)) { in parseDirectiveCVLoc()
5218 parseToken(AsmToken::Comma, in parseDirectiveCVLinetable()
5222 parseToken(AsmToken::Comma, in parseDirectiveCVLinetable()
5283 while (getLexer().is(AsmToken::Identifier)) { in parseDirectiveCVDefRange()
5301 AsmToken::Comma, in parseDirectiveCVDefRange()
5314 if (parseToken(AsmToken::Comma, "expected comma before register number in " in parseDirectiveCVDefRange()
5327 if (parseToken(AsmToken::Comma, in parseDirectiveCVDefRange()
5340 if (parseToken(AsmToken::Comma, "expected comma before register number in " in parseDirectiveCVDefRange()
5344 if (parseToken(AsmToken::Comma, in parseDirectiveCVDefRange()
5360 if (parseToken(AsmToken::Comma, "expected comma before register number in " in parseDirectiveCVDefRange()
5365 AsmToken::Comma, in parseDirectiveCVDefRange()
5369 if (parseToken(AsmToken::Comma, "expected comma before base pointer offset " in parseDirectiveCVDefRange()
5456 if (getLexer().is(AsmToken::Comma)) { in parseDirectiveCFISections()
5476 if (!parseOptionalToken(AsmToken::EndOfStatement)) { in parseDirectiveCFIStartProc()
5504 if (getLexer().isNot(AsmToken::Integer)) { in parseRegisterOrRegisterNumber()
5519 parseToken(AsmToken::Comma, "unexpected token in directive") || in parseDirectiveCFIDefCfa()
5543 parseToken(AsmToken::Comma, "unexpected token in directive") || in parseDirectiveCFIRegister()
5587 parseToken(AsmToken::Comma, "unexpected token in directive") || in parseDirectiveCFIOffset()
5601 parseToken(AsmToken::Comma, "unexpected token in directive") || in parseDirectiveCFIRelOffset()
5644 parseToken(AsmToken::Comma, "unexpected token in directive") || in parseDirectiveCFIPersonalityOrLsda()
5704 while (getLexer().is(AsmToken::Comma)) { in parseDirectiveCFIEscape()
5757 while (getLexer().isNot(AsmToken::EndOfStatement)) { in parseDirectiveMacro()
5773 if (Lexer.is(AsmToken::Colon)) { in parseDirectiveMacro()
5776 if (parseOptionalToken(AsmToken::Equal)) { in parseDirectiveMacro()
5807 if (getLexer().is(AsmToken::Comma)) in parseDirectiveMacro()
5815 if (getTok().is(AsmToken::Identifier) && in parseDirectiveMacro()
5826 if (!parseOptionalToken(AsmToken::Comma)) in parseDirectiveMacro()
5828 parseOptionalToken(AsmToken::EndOfStatement); in parseDirectiveMacro()
5833 AsmToken EndToken, StartToken = getTok(); in parseDirectiveMacro()
5839 while (Lexer.is(AsmToken::Error)) { in parseDirectiveMacro()
5844 if (getLexer().is(AsmToken::Eof)) in parseDirectiveMacro()
5849 if (getLexer().is(AsmToken::Identifier)) { in parseDirectiveMacro()
5854 if (getLexer().isNot(AsmToken::EndOfStatement)) in parseDirectiveMacro()
5863 if (MacroDepth == 0 && peekTok().isNot(AsmToken::EndOfStatement)) { in parseDirectiveMacro()
5898 if (getTok().isNot(AsmToken::EndOfStatement) && parseTextItem(Value)) in parseDirectiveExitMacro()
5920 if (getLexer().isNot(AsmToken::EndOfStatement)) in parseDirectiveEndMacro()
5953 if (!parseOptionalToken(AsmToken::Comma)) in parseDirectivePurgeMacro()
5955 parseOptionalToken(AsmToken::EndOfStatement); in parseDirectivePurgeMacro()
5968 if (parseToken(AsmToken::Colon)) in parseDirectiveExtern()
6032 if (getLexer().isNot(AsmToken::Comma)) in parseDirectiveComm()
6043 if (getLexer().is(AsmToken::Comma)) { in parseDirectiveComm()
6098 std::string FirstLine = parseStringTo(AsmToken::EndOfStatement); in parseDirectiveComment()
6105 if (getTok().is(AsmToken::Eof)) in parseDirectiveComment()
6109 !StringRef(parseStringTo(AsmToken::EndOfStatement)).contains(Delimiter)); in parseDirectiveComment()
6122 Filename = parseStringTo(AsmToken::EndOfStatement); in parseDirectiveInclude()
6124 check(getTok().isNot(AsmToken::EndOfStatement), in parseDirectiveInclude()
6199 if (Lexer.isNot(AsmToken::Comma)) { in parseDirectiveIfidn()
6410 if (Lexer.isNot(AsmToken::Comma)) { in parseDirectiveElseIfidn()
6465 while (Lexer.isNot(AsmToken::Eof)) in parseDirectiveEnd()
6482 if (Lexer.isNot(AsmToken::EndOfStatement)) in parseDirectiveError()
6483 Message = parseStringTo(AsmToken::EndOfStatement); in parseDirectiveError()
6504 if (Lexer.isNot(AsmToken::EndOfStatement)) { in parseDirectiveErrorIfb()
6505 if (parseToken(AsmToken::Comma)) in parseDirectiveErrorIfb()
6507 Message = parseStringTo(AsmToken::EndOfStatement); in parseDirectiveErrorIfb()
6548 if (Lexer.isNot(AsmToken::EndOfStatement)) { in parseDirectiveErrorIfdef()
6549 if (parseToken(AsmToken::Comma)) in parseDirectiveErrorIfdef()
6551 Message = parseStringTo(AsmToken::EndOfStatement); in parseDirectiveErrorIfdef()
6579 if (Lexer.isNot(AsmToken::Comma)) { in parseDirectiveErrorIfidn()
6599 if (Lexer.isNot(AsmToken::EndOfStatement)) { in parseDirectiveErrorIfidn()
6600 if (parseToken(AsmToken::Comma)) in parseDirectiveErrorIfidn()
6602 Message = parseStringTo(AsmToken::EndOfStatement); in parseDirectiveErrorIfidn()
6635 if (Lexer.isNot(AsmToken::EndOfStatement)) { in parseDirectiveErrorIfe()
6636 if (parseToken(AsmToken::Comma)) in parseDirectiveErrorIfe()
6638 Message = parseStringTo(AsmToken::EndOfStatement); in parseDirectiveErrorIfe()
6789 if (getLexer().is(AsmToken::Identifier)) { in isMacroLikeDirective()
6799 if (peekTok().is(AsmToken::Identifier) && in isMacroLikeDirective()
6807 AsmToken EndToken, StartToken = getTok(); in parseMacroLikeBody()
6812 if (getLexer().is(AsmToken::Eof)) { in parseMacroLikeBody()
6821 if (Lexer.is(AsmToken::Identifier) && in parseMacroLikeBody()
6826 if (Lexer.isNot(AsmToken::EndOfStatement)) { in parseMacroLikeBody()
6849 std::string Body = parseStringTo(AsmToken::EndOfStatement); in expandStatement()
6867 A.push_back(AsmToken(AsmToken::String, B.getValue())); in expandStatement()
6880 A.push_back(AsmToken(AsmToken::String, Var.TextValue)); in expandStatement()
7013 if (parseOptionalToken(AsmToken::Colon)) { in parseDirectiveFor()
7014 if (parseOptionalToken(AsmToken::Equal)) { in parseDirectiveFor()
7041 if (parseToken(AsmToken::Comma, in parseDirectiveFor()
7043 parseToken(AsmToken::Less, in parseDirectiveFor()
7050 if (parseMacroArgument(&Parameter, A.back(), /*EndTok=*/AsmToken::Greater)) in parseDirectiveFor()
7054 if (!parseOptionalToken(AsmToken::Comma)) in parseDirectiveFor()
7056 parseOptionalToken(AsmToken::EndOfStatement); in parseDirectiveFor()
7059 if (parseToken(AsmToken::Greater, in parseDirectiveFor()
7095 parseToken(AsmToken::Comma, in parseDirectiveForc()
7102 Argument = parseStringTo(AsmToken::EndOfStatement); in parseDirectiveForc()
7103 if (getTok().is(AsmToken::EndOfStatement)) in parseDirectiveForc()
7128 Arg.emplace_back(AsmToken::Identifier, Values.slice(I, I + 1)); in parseDirectiveForc()
7174 std::string RadixStringRaw = parseStringTo(AsmToken::EndOfStatement); in parseDirectiveRadix()
7192 std::string Message = parseStringTo(AsmToken::EndOfStatement); in parseDirectiveEcho()
7364 while (getLexer().isNot(AsmToken::Eof)) { in parseMSInlineAsm()