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()
1468 while (Lexer.isNot(AsmToken::EndOfStatement)) { in eatToEndOfStatement()
1469 if (Lexer.is(AsmToken::Eof)) { in eatToEndOfStatement()
1483 if (Lexer.is(AsmToken::EndOfStatement)) in eatToEndOfStatement()
1488 MasmParser::parseStringRefsTo(AsmToken::TokenKind EndTok) { in parseStringRefsTo()
1492 if (Lexer.is(AsmToken::Eof)) { in parseStringRefsTo()
1511 std::string MasmParser::parseStringTo(AsmToken::TokenKind EndTok) { in parseStringTo()
1523 while (Lexer.isNot(AsmToken::EndOfStatement) && Lexer.isNot(AsmToken::Eof)) in parseStringToEndOfStatement()
1551 if (parseToken(AsmToken::RBrac, "expected ']' in brackets expression")) in parseBracketExpr()
1567 AsmToken::TokenKind FirstTokenKind = Lexer.getKind(); in parsePrimaryExpr()
1572 case AsmToken::Error: in parsePrimaryExpr()
1574 case AsmToken::Exclaim: in parsePrimaryExpr()
1580 case AsmToken::Dollar: in parsePrimaryExpr()
1581 case AsmToken::At: in parsePrimaryExpr()
1582 case AsmToken::Identifier: { in parsePrimaryExpr()
1586 if (getTok().is(AsmToken::Dollar)) { in parsePrimaryExpr()
1622 } else if (Lexer.is(AsmToken::LParen)) { in parsePrimaryExpr()
1627 if (parseToken(AsmToken::RParen, in parsePrimaryExpr()
1732 case AsmToken::BigNum: in parsePrimaryExpr()
1734 case AsmToken::Integer: { in parsePrimaryExpr()
1741 case AsmToken::String: { in parsePrimaryExpr()
1755 case AsmToken::Real: { in parsePrimaryExpr()
1763 case AsmToken::Dot: { in parsePrimaryExpr()
1773 case AsmToken::LParen: in parsePrimaryExpr()
1776 case AsmToken::LBrac: in parsePrimaryExpr()
1781 case AsmToken::Minus: in parsePrimaryExpr()
1787 case AsmToken::Plus: in parsePrimaryExpr()
1793 case AsmToken::Tilde: in parsePrimaryExpr()
1801 case AsmToken::PercentCall16: in parsePrimaryExpr()
1802 case AsmToken::PercentCall_Hi: in parsePrimaryExpr()
1803 case AsmToken::PercentCall_Lo: in parsePrimaryExpr()
1804 case AsmToken::PercentDtprel_Hi: in parsePrimaryExpr()
1805 case AsmToken::PercentDtprel_Lo: in parsePrimaryExpr()
1806 case AsmToken::PercentGot: in parsePrimaryExpr()
1807 case AsmToken::PercentGot_Disp: in parsePrimaryExpr()
1808 case AsmToken::PercentGot_Hi: in parsePrimaryExpr()
1809 case AsmToken::PercentGot_Lo: in parsePrimaryExpr()
1810 case AsmToken::PercentGot_Ofst: in parsePrimaryExpr()
1811 case AsmToken::PercentGot_Page: in parsePrimaryExpr()
1812 case AsmToken::PercentGottprel: in parsePrimaryExpr()
1813 case AsmToken::PercentGp_Rel: in parsePrimaryExpr()
1814 case AsmToken::PercentHi: in parsePrimaryExpr()
1815 case AsmToken::PercentHigher: in parsePrimaryExpr()
1816 case AsmToken::PercentHighest: in parsePrimaryExpr()
1817 case AsmToken::PercentLo: in parsePrimaryExpr()
1818 case AsmToken::PercentNeg: in parsePrimaryExpr()
1819 case AsmToken::PercentPcrel_Hi: in parsePrimaryExpr()
1820 case AsmToken::PercentPcrel_Lo: in parsePrimaryExpr()
1821 case AsmToken::PercentTlsgd: in parsePrimaryExpr()
1822 case AsmToken::PercentTlsldm: in parsePrimaryExpr()
1823 case AsmToken::PercentTprel_Hi: in parsePrimaryExpr()
1824 case AsmToken::PercentTprel_Lo: in parsePrimaryExpr()
1826 if (Lexer.isNot(AsmToken::LParen)) in parsePrimaryExpr()
1941 static unsigned getGNUBinOpPrecedence(AsmToken::TokenKind K, in getGNUBinOpPrecedence()
1950 case AsmToken::AmpAmp: in getGNUBinOpPrecedence()
1953 case AsmToken::PipePipe: in getGNUBinOpPrecedence()
1958 case AsmToken::EqualEqual: in getGNUBinOpPrecedence()
1961 case AsmToken::ExclaimEqual: in getGNUBinOpPrecedence()
1962 case AsmToken::LessGreater: in getGNUBinOpPrecedence()
1965 case AsmToken::Less: in getGNUBinOpPrecedence()
1968 case AsmToken::LessEqual: in getGNUBinOpPrecedence()
1971 case AsmToken::Greater: in getGNUBinOpPrecedence()
1976 case AsmToken::GreaterEqual: in getGNUBinOpPrecedence()
1981 case AsmToken::Plus: in getGNUBinOpPrecedence()
1984 case AsmToken::Minus: in getGNUBinOpPrecedence()
1989 case AsmToken::Pipe: in getGNUBinOpPrecedence()
1992 case AsmToken::Caret: in getGNUBinOpPrecedence()
1995 case AsmToken::Amp: in getGNUBinOpPrecedence()
2000 case AsmToken::Star: in getGNUBinOpPrecedence()
2003 case AsmToken::Slash: in getGNUBinOpPrecedence()
2006 case AsmToken::Percent: in getGNUBinOpPrecedence()
2009 case AsmToken::LessLess: in getGNUBinOpPrecedence()
2012 case AsmToken::GreaterGreater: in getGNUBinOpPrecedence()
2020 unsigned MasmParser::getBinOpPrecedence(AsmToken::TokenKind K, in getBinOpPrecedence()
2033 AsmToken::TokenKind TokKind = Lexer.getKind(); in parseBinOpRHS()
2034 if (Lexer.getKind() == AsmToken::Identifier) { in parseBinOpRHS()
2035 TokKind = StringSwitch<AsmToken::TokenKind>(Lexer.getTok().getString()) in parseBinOpRHS()
2036 .CaseLower("and", AsmToken::Amp) in parseBinOpRHS()
2037 .CaseLower("not", AsmToken::Exclaim) in parseBinOpRHS()
2038 .CaseLower("or", AsmToken::Pipe) in parseBinOpRHS()
2039 .CaseLower("xor", AsmToken::Caret) in parseBinOpRHS()
2040 .CaseLower("shl", AsmToken::LessLess) in parseBinOpRHS()
2041 .CaseLower("shr", AsmToken::GreaterGreater) in parseBinOpRHS()
2042 .CaseLower("eq", AsmToken::EqualEqual) in parseBinOpRHS()
2043 .CaseLower("ne", AsmToken::ExclaimEqual) in parseBinOpRHS()
2044 .CaseLower("lt", AsmToken::Less) in parseBinOpRHS()
2045 .CaseLower("le", AsmToken::LessEqual) in parseBinOpRHS()
2046 .CaseLower("gt", AsmToken::Greater) in parseBinOpRHS()
2047 .CaseLower("ge", AsmToken::GreaterEqual) in parseBinOpRHS()
2086 while (Lexer.is(AsmToken::Space)) in parseStatement()
2088 if (Lexer.is(AsmToken::EndOfStatement)) { in parseStatement()
2099 if (getTok().is(AsmToken::Percent)) { in parseStatement()
2101 if (parseToken(AsmToken::Percent) || expandStatement(ExpansionLoc)) in parseStatement()
2107 AsmToken ID = getTok(); in parseStatement()
2110 if (Lexer.is(AsmToken::HashDirective)) in parseStatement()
2112 if (Lexer.is(AsmToken::Dot)) { in parseStatement()
2116 } else if (Lexer.is(AsmToken::Real)) { in parseStatement()
2205 if (Lexer.is(AsmToken::Colon) && getTargetParser().isLabel(ID)) { in parseStatement()
2242 if (getTok().is(AsmToken::Hash)) { in parseStatement()
2243 std::string CommentStr = parseStringTo(AsmToken::EndOfStatement); in parseStatement()
2245 Lexer.UnLex(AsmToken(AsmToken::EndOfStatement, CommentStr)); in parseStatement()
2250 if (getTok().is(AsmToken::EndOfStatement)) { in parseStatement()
2295 getTok().is(AsmToken::EndOfStatement)) { in parseStatement()
2307 if (ID.isNot(AsmToken::Identifier)) in parseStatement()
2508 const AsmToken nextTok = getTok(); in parseStatement()
2512 const AsmToken afterNextTok = peekTok(); in parseStatement()
2557 if (afterNextTok.is(AsmToken::Identifier) && in parseStatement()
2568 if (afterNextTok.is(AsmToken::Identifier) && in parseStatement()
2579 if (afterNextTok.is(AsmToken::Identifier) && in parseStatement()
2590 if (afterNextTok.is(AsmToken::Identifier) && in parseStatement()
2600 if (afterNextTok.is(AsmToken::Identifier) && in parseStatement()
2728 if (Lexer.isNot(AsmToken::LCurly) && Lexer.isNot(AsmToken::RCurly)) in parseCurlyBlockScope()
2733 if (Lexer.is(AsmToken::EndOfStatement)) in parseCurlyBlockScope()
2748 assert(getTok().is(AsmToken::Integer) && in parseCppHashLineFilenameComment()
2752 assert(getTok().is(AsmToken::String) && in parseCppHashLineFilenameComment()
2924 for (const AsmToken &Token : A[Index]) { in expandMacro()
2932 if (Token.getString().front() == '%' && Token.is(AsmToken::Integer)) in expandMacro()
2951 static bool isOperator(AsmToken::TokenKind kind) { in isOperator()
2955 case AsmToken::Plus: in isOperator()
2956 case AsmToken::Minus: in isOperator()
2957 case AsmToken::Tilde: in isOperator()
2958 case AsmToken::Slash: in isOperator()
2959 case AsmToken::Star: in isOperator()
2960 case AsmToken::Dot: in isOperator()
2961 case AsmToken::Equal: in isOperator()
2962 case AsmToken::EqualEqual: in isOperator()
2963 case AsmToken::Pipe: in isOperator()
2964 case AsmToken::PipePipe: in isOperator()
2965 case AsmToken::Caret: in isOperator()
2966 case AsmToken::Amp: in isOperator()
2967 case AsmToken::AmpAmp: in isOperator()
2968 case AsmToken::Exclaim: in isOperator()
2969 case AsmToken::ExclaimEqual: in isOperator()
2970 case AsmToken::Less: in isOperator()
2971 case AsmToken::LessEqual: in isOperator()
2972 case AsmToken::LessLess: in isOperator()
2973 case AsmToken::LessGreater: in isOperator()
2974 case AsmToken::Greater: in isOperator()
2975 case AsmToken::GreaterEqual: in isOperator()
2976 case AsmToken::GreaterGreater: in isOperator()
3001 AsmToken::TokenKind EndTok) { in parseMacroArgument()
3006 MA.emplace_back(AsmToken::String, S); in parseMacroArgument()
3013 if (Lexer.is(AsmToken::Less) && isAngleBracketString(StrLoc, EndLoc)) { in parseMacroArgument()
3019 MA.emplace_back(AsmToken::String, StringRef(StrChar, EndChar - StrChar)); in parseMacroArgument()
3032 if (Lexer.is(AsmToken::Eof) || Lexer.is(AsmToken::Equal)) in parseMacroArgument()
3036 if (Lexer.is(AsmToken::Comma)) in parseMacroArgument()
3039 if (Lexer.is(AsmToken::Space)) { in parseMacroArgument()
3053 if (Lexer.is(AsmToken::Space)) in parseMacroArgument()
3065 if (Lexer.is(EndTok) && (EndTok != AsmToken::RParen || ParenLevel == 0)) in parseMacroArgument()
3069 if (Lexer.is(AsmToken::LParen)) in parseMacroArgument()
3071 else if (Lexer.is(AsmToken::RParen) && ParenLevel) in parseMacroArgument()
3096 AsmToken::TokenKind EndTok) { in parseMacroArguments()
3112 if (Lexer.is(AsmToken::Identifier) && peekTok().is(AsmToken::Equal)) { in parseMacroArguments()
3116 if (Lexer.isNot(AsmToken::Equal)) in parseMacroArguments()
3147 if (Lexer.is(AsmToken::Percent)) { in parseMacroArguments()
3159 AsmToken newToken(AsmToken::Integer, in parseMacroArguments()
3202 if (Lexer.is(AsmToken::Comma)) in parseMacroArguments()
3210 AsmToken::TokenKind ArgumentEndTok) { in handleMacroEntry()
3276 if (parseToken(AsmToken::LParen, "invoking macro function '" + M->Name + in handleMacroInvocation()
3278 handleMacroEntry(M, NameLoc, AsmToken::RParen)) in handleMacroInvocation()
3284 while (Lexer.isNot(AsmToken::Eof)) { in handleMacroInvocation()
3296 if (Parsed && !hasPendingError() && Lexer.getTok().is(AsmToken::Error)) { in handleMacroInvocation()
3338 if (Lexer.is(AsmToken::Dollar) || Lexer.is(AsmToken::At)) { in parseIdentifier()
3343 AsmToken nextTok = peekTok(false); in parseIdentifier()
3345 if (nextTok.isNot(AsmToken::Identifier)) in parseIdentifier()
3361 if (Lexer.isNot(AsmToken::Identifier) && Lexer.isNot(AsmToken::String)) in parseIdentifier()
3412 if (parseOptionalToken(AsmToken::Comma) && parseMany(parseItem)) in parseDirectiveEquate()
3512 if (check(getTok().isNot(AsmToken::String), "expected string")) in parseEscapedString()
3556 case AsmToken::Percent: { in parseTextItem()
3558 if (parseToken(AsmToken::Percent) || parseAbsoluteExpression(Res)) in parseTextItem()
3563 case AsmToken::Less: in parseTextItem()
3564 case AsmToken::LessEqual: in parseTextItem()
3565 case AsmToken::LessLess: in parseTextItem()
3566 case AsmToken::LessGreater: in parseTextItem()
3568 case AsmToken::Identifier: { in parseTextItem()
3613 getLexer().UnLex(AsmToken(AsmToken::Identifier, ID)); in parseTextItem()
3663 if (Size == 1 && getTok().is(AsmToken::String)) { in parseScalarInitializer()
3678 if (getTok().is(AsmToken::Identifier) && in parseScalarInitializer()
3691 if (parseToken(AsmToken::LParen, in parseScalarInitializer()
3707 const AsmToken::TokenKind EndToken) { in parseScalarInstList()
3709 (EndToken != AsmToken::Greater || in parseScalarInstList()
3710 getTok().isNot(AsmToken::GreaterGreater))) { in parseScalarInstList()
3714 if (!parseOptionalToken(AsmToken::Comma)) in parseScalarInstList()
3716 parseOptionalToken(AsmToken::EndOfStatement); in parseScalarInstList()
3795 if (Asm.getTok().isNot(AsmToken::Integer) && in parseHexOcta()
3796 Asm.getTok().isNot(AsmToken::BigNum)) in parseHexOcta()
3818 if (getLexer().is(AsmToken::Minus)) { in parseRealValue()
3822 } else if (getLexer().is(AsmToken::Plus)) { in parseRealValue()
3827 if (Lexer.is(AsmToken::Error)) in parseRealValue()
3829 if (Lexer.isNot(AsmToken::Integer) && Lexer.isNot(AsmToken::Real) && in parseRealValue()
3830 Lexer.isNot(AsmToken::Identifier)) in parseRealValue()
3836 if (getLexer().is(AsmToken::Identifier)) { in parseRealValue()
3877 const AsmToken::TokenKind EndToken) { in parseRealInstList()
3879 (EndToken == AsmToken::Greater && in parseRealInstList()
3880 getTok().isNot(AsmToken::GreaterGreater))) { in parseRealInstList()
3881 const AsmToken NextTok = peekTok(); in parseRealInstList()
3882 if (NextTok.is(AsmToken::Identifier) && in parseRealInstList()
3885 if (parseExpression(Value) || parseToken(AsmToken::Identifier)) in parseRealInstList()
3897 if (parseToken(AsmToken::LParen, in parseRealInstList()
3912 if (!parseOptionalToken(AsmToken::Comma)) in parseRealInstList()
3914 parseOptionalToken(AsmToken::EndOfStatement); in parseRealInstList()
4004 const AsmToken Tok = getTok(); in parseOptionalAngleBracketOpen()
4005 if (parseOptionalToken(AsmToken::LessLess)) { in parseOptionalAngleBracketOpen()
4007 Lexer.UnLex(AsmToken(AsmToken::Less, Tok.getString().substr(1))); in parseOptionalAngleBracketOpen()
4009 } else if (parseOptionalToken(AsmToken::LessGreater)) { in parseOptionalAngleBracketOpen()
4011 Lexer.UnLex(AsmToken(AsmToken::Greater, Tok.getString().substr(1))); in parseOptionalAngleBracketOpen()
4013 } else if (parseOptionalToken(AsmToken::Less)) { in parseOptionalAngleBracketOpen()
4022 const AsmToken Tok = getTok(); in parseAngleBracketClose()
4023 if (parseOptionalToken(AsmToken::GreaterGreater)) { in parseAngleBracketClose()
4024 Lexer.UnLex(AsmToken(AsmToken::Greater, Tok.getString().substr(1))); in parseAngleBracketClose()
4025 } else if (parseToken(AsmToken::Greater, Msg)) { in parseAngleBracketClose()
4038 if (parseOptionalToken(AsmToken::LCurly)) { in parseFieldInitializer()
4041 if (parseScalarInstList(Field.Type, Values, AsmToken::RCurly) || in parseFieldInitializer()
4042 parseToken(AsmToken::RCurly)) in parseFieldInitializer()
4047 if (parseScalarInstList(Field.Type, Values, AsmToken::Greater) || in parseFieldInitializer()
4090 if (parseOptionalToken(AsmToken::LCurly)) { in parseFieldInitializer()
4093 if (parseRealInstList(*Semantics, AsIntValues, AsmToken::RCurly) || in parseFieldInitializer()
4094 parseToken(AsmToken::RCurly)) in parseFieldInitializer()
4099 if (parseRealInstList(*Semantics, AsIntValues, AsmToken::Greater) || in parseFieldInitializer()
4130 if (parseOptionalToken(AsmToken::LCurly)) { in parseFieldInitializer()
4132 AsmToken::RCurly) || in parseFieldInitializer()
4133 parseToken(AsmToken::RCurly)) in parseFieldInitializer()
4137 AsmToken::Greater) || in parseFieldInitializer()
4178 const AsmToken FirstToken = getTok(); in parseStructInitializer()
4180 std::optional<AsmToken::TokenKind> EndToken; in parseStructInitializer()
4181 if (parseOptionalToken(AsmToken::LCurly)) { in parseStructInitializer()
4182 EndToken = AsmToken::RCurly; in parseStructInitializer()
4184 EndToken = AsmToken::Greater; in parseStructInitializer()
4186 } else if (FirstToken.is(AsmToken::Identifier) && in parseStructInitializer()
4189 if (parseToken(AsmToken::Identifier)) in parseStructInitializer()
4201 if (parseOptionalToken(AsmToken::Comma)) { in parseStructInitializer()
4205 parseOptionalToken(AsmToken::EndOfStatement); in parseStructInitializer()
4214 if (!parseOptionalToken(AsmToken::Comma)) in parseStructInitializer()
4219 parseOptionalToken(AsmToken::EndOfStatement); in parseStructInitializer()
4227 if (*EndToken == AsmToken::Greater) in parseStructInitializer()
4238 const AsmToken::TokenKind EndToken) { in parseStructInstList()
4240 (EndToken == AsmToken::Greater && in parseStructInstList()
4241 getTok().isNot(AsmToken::GreaterGreater))) { in parseStructInstList()
4242 const AsmToken NextTok = peekTok(); in parseStructInstList()
4243 if (NextTok.is(AsmToken::Identifier) && in parseStructInstList()
4246 if (parseExpression(Value) || parseToken(AsmToken::Identifier)) in parseStructInstList()
4258 if (parseToken(AsmToken::LParen, in parseStructInstList()
4272 if (!parseOptionalToken(AsmToken::Comma)) in parseStructInstList()
4274 parseOptionalToken(AsmToken::EndOfStatement); in parseStructInstList()
4509 AsmToken NextTok = getTok(); in parseDirectiveStruct()
4511 if (NextTok.isNot(AsmToken::Comma) && in parseDirectiveStruct()
4512 NextTok.isNot(AsmToken::EndOfStatement) && in parseDirectiveStruct()
4524 if (parseOptionalToken(AsmToken::Comma)) { in parseDirectiveStruct()
4552 if (getTok().is(AsmToken::Identifier)) { in parseDirectiveNestedStruct()
4554 parseToken(AsmToken::Identifier); in parseDirectiveNestedStruct()
4732 if (getTok().is(AsmToken::EndOfStatement)) { in parseDirectiveAlign()
4772 if (getLexer().is(AsmToken::Integer)) { in parseDirectiveFile()
4784 if (check(getTok().isNot(AsmToken::String), in parseDirectiveFile()
4792 if (getLexer().is(AsmToken::String)) { in parseDirectiveFile()
4810 while (!parseOptionalToken(AsmToken::EndOfStatement)) { in parseDirectiveFile()
4812 if (check(getTok().isNot(AsmToken::Identifier), in parseDirectiveFile()
4826 check(getTok().isNot(AsmToken::String), in parseDirectiveFile()
4889 if (getLexer().is(AsmToken::Integer)) { in parseDirectiveLine()
4919 if (getLexer().is(AsmToken::Integer)) { in parseDirectiveLoc()
4927 if (getLexer().is(AsmToken::Integer)) { in parseDirectiveLoc()
5018 check(getTok().isNot(AsmToken::String), in parseDirectiveCVFile()
5022 if (!parseOptionalToken(AsmToken::EndOfStatement)) { in parseDirectiveCVFile()
5023 if (check(getTok().isNot(AsmToken::String), in parseDirectiveCVFile()
5104 if (check((getLexer().isNot(AsmToken::Identifier) || in parseDirectiveCVInlineSiteId()
5115 if (check((getLexer().isNot(AsmToken::Identifier) || in parseDirectiveCVInlineSiteId()
5128 if (getLexer().is(AsmToken::Integer)) { in parseDirectiveCVInlineSiteId()
5158 if (getLexer().is(AsmToken::Integer)) { in parseDirectiveCVLoc()
5166 if (getLexer().is(AsmToken::Integer)) { in parseDirectiveCVLoc()
5217 parseToken(AsmToken::Comma, in parseDirectiveCVLinetable()
5221 parseToken(AsmToken::Comma, in parseDirectiveCVLinetable()
5282 while (getLexer().is(AsmToken::Identifier)) { in parseDirectiveCVDefRange()
5300 AsmToken::Comma, in parseDirectiveCVDefRange()
5313 if (parseToken(AsmToken::Comma, "expected comma before register number in " in parseDirectiveCVDefRange()
5326 if (parseToken(AsmToken::Comma, in parseDirectiveCVDefRange()
5339 if (parseToken(AsmToken::Comma, "expected comma before register number in " in parseDirectiveCVDefRange()
5343 if (parseToken(AsmToken::Comma, in parseDirectiveCVDefRange()
5359 if (parseToken(AsmToken::Comma, "expected comma before register number in " in parseDirectiveCVDefRange()
5364 AsmToken::Comma, in parseDirectiveCVDefRange()
5368 if (parseToken(AsmToken::Comma, "expected comma before base pointer offset " in parseDirectiveCVDefRange()
5455 if (getLexer().is(AsmToken::Comma)) { in parseDirectiveCFISections()
5475 if (!parseOptionalToken(AsmToken::EndOfStatement)) { in parseDirectiveCFIStartProc()
5503 if (getLexer().isNot(AsmToken::Integer)) { in parseRegisterOrRegisterNumber()
5518 parseToken(AsmToken::Comma, "unexpected token in directive") || in parseDirectiveCFIDefCfa()
5542 parseToken(AsmToken::Comma, "unexpected token in directive") || in parseDirectiveCFIRegister()
5586 parseToken(AsmToken::Comma, "unexpected token in directive") || in parseDirectiveCFIOffset()
5600 parseToken(AsmToken::Comma, "unexpected token in directive") || in parseDirectiveCFIRelOffset()
5643 parseToken(AsmToken::Comma, "unexpected token in directive") || in parseDirectiveCFIPersonalityOrLsda()
5703 while (getLexer().is(AsmToken::Comma)) { in parseDirectiveCFIEscape()
5756 while (getLexer().isNot(AsmToken::EndOfStatement)) { in parseDirectiveMacro()
5772 if (Lexer.is(AsmToken::Colon)) { in parseDirectiveMacro()
5775 if (parseOptionalToken(AsmToken::Equal)) { in parseDirectiveMacro()
5806 if (getLexer().is(AsmToken::Comma)) in parseDirectiveMacro()
5814 if (getTok().is(AsmToken::Identifier) && in parseDirectiveMacro()
5825 if (!parseOptionalToken(AsmToken::Comma)) in parseDirectiveMacro()
5827 parseOptionalToken(AsmToken::EndOfStatement); in parseDirectiveMacro()
5832 AsmToken EndToken, StartToken = getTok(); in parseDirectiveMacro()
5838 while (Lexer.is(AsmToken::Error)) { in parseDirectiveMacro()
5843 if (getLexer().is(AsmToken::Eof)) in parseDirectiveMacro()
5848 if (getLexer().is(AsmToken::Identifier)) { in parseDirectiveMacro()
5853 if (getLexer().isNot(AsmToken::EndOfStatement)) in parseDirectiveMacro()
5862 if (MacroDepth == 0 && peekTok().isNot(AsmToken::EndOfStatement)) { in parseDirectiveMacro()
5897 if (getTok().isNot(AsmToken::EndOfStatement) && parseTextItem(Value)) in parseDirectiveExitMacro()
5919 if (getLexer().isNot(AsmToken::EndOfStatement)) in parseDirectiveEndMacro()
5952 if (!parseOptionalToken(AsmToken::Comma)) in parseDirectivePurgeMacro()
5954 parseOptionalToken(AsmToken::EndOfStatement); in parseDirectivePurgeMacro()
5967 if (parseToken(AsmToken::Colon)) in parseDirectiveExtern()
6031 if (getLexer().isNot(AsmToken::Comma)) in parseDirectiveComm()
6042 if (getLexer().is(AsmToken::Comma)) { in parseDirectiveComm()
6097 std::string FirstLine = parseStringTo(AsmToken::EndOfStatement); in parseDirectiveComment()
6104 if (getTok().is(AsmToken::Eof)) in parseDirectiveComment()
6108 !StringRef(parseStringTo(AsmToken::EndOfStatement)).contains(Delimiter)); in parseDirectiveComment()
6121 Filename = parseStringTo(AsmToken::EndOfStatement); in parseDirectiveInclude()
6123 check(getTok().isNot(AsmToken::EndOfStatement), in parseDirectiveInclude()
6198 if (Lexer.isNot(AsmToken::Comma)) { in parseDirectiveIfidn()
6409 if (Lexer.isNot(AsmToken::Comma)) { in parseDirectiveElseIfidn()
6464 while (Lexer.isNot(AsmToken::Eof)) in parseDirectiveEnd()
6481 if (Lexer.isNot(AsmToken::EndOfStatement)) in parseDirectiveError()
6482 Message = parseStringTo(AsmToken::EndOfStatement); in parseDirectiveError()
6503 if (Lexer.isNot(AsmToken::EndOfStatement)) { in parseDirectiveErrorIfb()
6504 if (parseToken(AsmToken::Comma)) in parseDirectiveErrorIfb()
6506 Message = parseStringTo(AsmToken::EndOfStatement); in parseDirectiveErrorIfb()
6547 if (Lexer.isNot(AsmToken::EndOfStatement)) { in parseDirectiveErrorIfdef()
6548 if (parseToken(AsmToken::Comma)) in parseDirectiveErrorIfdef()
6550 Message = parseStringTo(AsmToken::EndOfStatement); in parseDirectiveErrorIfdef()
6578 if (Lexer.isNot(AsmToken::Comma)) { in parseDirectiveErrorIfidn()
6598 if (Lexer.isNot(AsmToken::EndOfStatement)) { in parseDirectiveErrorIfidn()
6599 if (parseToken(AsmToken::Comma)) in parseDirectiveErrorIfidn()
6601 Message = parseStringTo(AsmToken::EndOfStatement); in parseDirectiveErrorIfidn()
6634 if (Lexer.isNot(AsmToken::EndOfStatement)) { in parseDirectiveErrorIfe()
6635 if (parseToken(AsmToken::Comma)) in parseDirectiveErrorIfe()
6637 Message = parseStringTo(AsmToken::EndOfStatement); in parseDirectiveErrorIfe()
6788 if (getLexer().is(AsmToken::Identifier)) { in isMacroLikeDirective()
6798 if (peekTok().is(AsmToken::Identifier) && in isMacroLikeDirective()
6806 AsmToken EndToken, StartToken = getTok(); in parseMacroLikeBody()
6811 if (getLexer().is(AsmToken::Eof)) { in parseMacroLikeBody()
6820 if (Lexer.is(AsmToken::Identifier) && in parseMacroLikeBody()
6825 if (Lexer.isNot(AsmToken::EndOfStatement)) { in parseMacroLikeBody()
6848 std::string Body = parseStringTo(AsmToken::EndOfStatement); in expandStatement()
6866 A.push_back(AsmToken(AsmToken::String, B.getValue())); in expandStatement()
6879 A.push_back(AsmToken(AsmToken::String, Var.TextValue)); in expandStatement()
7012 if (parseOptionalToken(AsmToken::Colon)) { in parseDirectiveFor()
7013 if (parseOptionalToken(AsmToken::Equal)) { in parseDirectiveFor()
7040 if (parseToken(AsmToken::Comma, in parseDirectiveFor()
7042 parseToken(AsmToken::Less, in parseDirectiveFor()
7049 if (parseMacroArgument(&Parameter, A.back(), /*EndTok=*/AsmToken::Greater)) in parseDirectiveFor()
7053 if (!parseOptionalToken(AsmToken::Comma)) in parseDirectiveFor()
7055 parseOptionalToken(AsmToken::EndOfStatement); in parseDirectiveFor()
7058 if (parseToken(AsmToken::Greater, in parseDirectiveFor()
7094 parseToken(AsmToken::Comma, in parseDirectiveForc()
7101 Argument = parseStringTo(AsmToken::EndOfStatement); in parseDirectiveForc()
7102 if (getTok().is(AsmToken::EndOfStatement)) in parseDirectiveForc()
7127 Arg.emplace_back(AsmToken::Identifier, Values.slice(I, I + 1)); in parseDirectiveForc()
7173 std::string RadixStringRaw = parseStringTo(AsmToken::EndOfStatement); in parseDirectiveRadix()
7191 std::string Message = parseStringTo(AsmToken::EndOfStatement); in parseDirectiveEcho()
7363 while (getLexer().isNot(AsmToken::Eof)) { in parseMSInlineAsm()