Lines Matching refs:AsmToken
86 typedef std::vector<AsmToken> MCAsmMacroArgument;
502 const AsmToken &Lex(ExpandKind ExpandNextToken);
503 const AsmToken &Lex() override { return Lex(ExpandMacros); } in Lex()
559 const AsmToken peekTok(bool ShouldSkipSpace = true);
580 AsmToken::TokenKind ArgumentEndTok = AsmToken::EndOfStatement);
594 AsmToken::TokenKind EndTok = AsmToken::EndOfStatement);
599 AsmToken::TokenKind EndTok = AsmToken::EndOfStatement);
636 SmallVector<StringRef, 1> parseStringRefsTo(AsmToken::TokenKind EndTok);
637 std::string parseStringTo(AsmToken::TokenKind EndTok);
646 unsigned getBinOpPrecedence(AsmToken::TokenKind K,
846 const AsmToken::TokenKind EndToken = AsmToken::EndOfStatement);
860 const AsmToken::TokenKind EndToken = AsmToken::EndOfStatement);
885 const AsmToken::TokenKind EndToken = AsmToken::EndOfStatement);
1166 const AsmToken &Tok = getTok(); in expandMacros()
1170 if (M && M->IsFunction && peekTok().is(AsmToken::LParen)) { in expandMacros()
1176 Lexer.UnLex(AsmToken(AsmToken::Error, MacroId)); in expandMacros()
1209 const AsmToken &MasmParser::Lex(ExpandKind ExpandNextToken) { in Lex()
1210 if (Lexer.getTok().is(AsmToken::Error)) in Lex()
1214 if (getTok().is(AsmToken::EndOfStatement)) { in Lex()
1221 const AsmToken *tok = &Lexer.Lex(); in Lex()
1224 while (ExpandNextToken == ExpandMacros && tok->is(AsmToken::Identifier)) { in Lex()
1226 AsmToken NextTok; in Lex()
1227 MutableArrayRef<AsmToken> Buf(NextTok); in Lex()
1229 if (ReadCount && NextTok.is(AsmToken::Identifier) && in Lex()
1242 while (tok->is(AsmToken::Comment)) { in Lex()
1249 while (tok->is(AsmToken::BackSlash) && in Lex()
1250 peekTok().is(AsmToken::EndOfStatement)) { in Lex()
1256 if (tok->is(AsmToken::Eof)) { in Lex()
1272 const AsmToken MasmParser::peekTok(bool ShouldSkipSpace) { in peekTok()
1273 AsmToken Tok; in peekTok()
1275 MutableArrayRef<AsmToken> Buf(Tok); in peekTok()
1350 while (Lexer.isNot(AsmToken::Eof) || in Run()
1353 if (Lexer.is(AsmToken::Eof)) in Run()
1362 if (Parsed && !hasPendingError() && Lexer.getTok().is(AsmToken::Error)) { in Run()
1449 while (Lexer.isNot(AsmToken::EndOfStatement)) { in eatToEndOfStatement()
1450 if (Lexer.is(AsmToken::Eof)) { in eatToEndOfStatement()
1464 if (Lexer.is(AsmToken::EndOfStatement)) in eatToEndOfStatement()
1469 MasmParser::parseStringRefsTo(AsmToken::TokenKind EndTok) { in parseStringRefsTo()
1473 if (Lexer.is(AsmToken::Eof)) { in parseStringRefsTo()
1492 std::string MasmParser::parseStringTo(AsmToken::TokenKind EndTok) { in parseStringTo()
1504 while (Lexer.isNot(AsmToken::EndOfStatement) && Lexer.isNot(AsmToken::Eof)) in parseStringToEndOfStatement()
1519 if (Lexer.isNot(AsmToken::RParen)) in parseParenExpr()
1535 if (parseToken(AsmToken::RBrac, "expected ']' in brackets expression")) in parseBracketExpr()
1551 AsmToken::TokenKind FirstTokenKind = Lexer.getKind(); in parsePrimaryExpr()
1556 case AsmToken::Error: in parsePrimaryExpr()
1558 case AsmToken::Exclaim: in parsePrimaryExpr()
1564 case AsmToken::Dollar: in parsePrimaryExpr()
1565 case AsmToken::At: in parsePrimaryExpr()
1566 case AsmToken::Identifier: { in parsePrimaryExpr()
1570 if (getTok().is(AsmToken::Dollar)) { in parsePrimaryExpr()
1595 if (FirstTokenKind == AsmToken::String) { in parsePrimaryExpr()
1596 if (Lexer.is(AsmToken::At)) { in parsePrimaryExpr()
1608 } else if (Lexer.is(AsmToken::LParen)) { in parsePrimaryExpr()
1613 if (parseToken(AsmToken::RParen, in parsePrimaryExpr()
1718 case AsmToken::BigNum: in parsePrimaryExpr()
1720 case AsmToken::Integer: { in parsePrimaryExpr()
1727 if (Lexer.getKind() == AsmToken::Identifier) { in parsePrimaryExpr()
1751 case AsmToken::String: { in parsePrimaryExpr()
1765 case AsmToken::Real: { in parsePrimaryExpr()
1773 case AsmToken::Dot: { in parsePrimaryExpr()
1783 case AsmToken::LParen: in parsePrimaryExpr()
1786 case AsmToken::LBrac: in parsePrimaryExpr()
1791 case AsmToken::Minus: in parsePrimaryExpr()
1797 case AsmToken::Plus: in parsePrimaryExpr()
1803 case AsmToken::Tilde: in parsePrimaryExpr()
1811 case AsmToken::PercentCall16: in parsePrimaryExpr()
1812 case AsmToken::PercentCall_Hi: in parsePrimaryExpr()
1813 case AsmToken::PercentCall_Lo: in parsePrimaryExpr()
1814 case AsmToken::PercentDtprel_Hi: in parsePrimaryExpr()
1815 case AsmToken::PercentDtprel_Lo: in parsePrimaryExpr()
1816 case AsmToken::PercentGot: in parsePrimaryExpr()
1817 case AsmToken::PercentGot_Disp: in parsePrimaryExpr()
1818 case AsmToken::PercentGot_Hi: in parsePrimaryExpr()
1819 case AsmToken::PercentGot_Lo: in parsePrimaryExpr()
1820 case AsmToken::PercentGot_Ofst: in parsePrimaryExpr()
1821 case AsmToken::PercentGot_Page: in parsePrimaryExpr()
1822 case AsmToken::PercentGottprel: in parsePrimaryExpr()
1823 case AsmToken::PercentGp_Rel: in parsePrimaryExpr()
1824 case AsmToken::PercentHi: in parsePrimaryExpr()
1825 case AsmToken::PercentHigher: in parsePrimaryExpr()
1826 case AsmToken::PercentHighest: in parsePrimaryExpr()
1827 case AsmToken::PercentLo: in parsePrimaryExpr()
1828 case AsmToken::PercentNeg: in parsePrimaryExpr()
1829 case AsmToken::PercentPcrel_Hi: in parsePrimaryExpr()
1830 case AsmToken::PercentPcrel_Lo: in parsePrimaryExpr()
1831 case AsmToken::PercentTlsgd: in parsePrimaryExpr()
1832 case AsmToken::PercentTlsldm: in parsePrimaryExpr()
1833 case AsmToken::PercentTprel_Hi: in parsePrimaryExpr()
1834 case AsmToken::PercentTprel_Lo: in parsePrimaryExpr()
1836 if (Lexer.isNot(AsmToken::LParen)) in parsePrimaryExpr()
1841 if (Lexer.isNot(AsmToken::RParen)) in parsePrimaryExpr()
1932 if (parseToken(AsmToken::RParen, in parseParenExprOfDepth()
1953 static unsigned getGNUBinOpPrecedence(AsmToken::TokenKind K, in getGNUBinOpPrecedence()
1962 case AsmToken::AmpAmp: in getGNUBinOpPrecedence()
1965 case AsmToken::PipePipe: in getGNUBinOpPrecedence()
1970 case AsmToken::EqualEqual: in getGNUBinOpPrecedence()
1973 case AsmToken::ExclaimEqual: in getGNUBinOpPrecedence()
1974 case AsmToken::LessGreater: in getGNUBinOpPrecedence()
1977 case AsmToken::Less: in getGNUBinOpPrecedence()
1980 case AsmToken::LessEqual: in getGNUBinOpPrecedence()
1983 case AsmToken::Greater: in getGNUBinOpPrecedence()
1988 case AsmToken::GreaterEqual: in getGNUBinOpPrecedence()
1993 case AsmToken::Plus: in getGNUBinOpPrecedence()
1996 case AsmToken::Minus: in getGNUBinOpPrecedence()
2001 case AsmToken::Pipe: in getGNUBinOpPrecedence()
2004 case AsmToken::Caret: in getGNUBinOpPrecedence()
2007 case AsmToken::Amp: in getGNUBinOpPrecedence()
2012 case AsmToken::Star: in getGNUBinOpPrecedence()
2015 case AsmToken::Slash: in getGNUBinOpPrecedence()
2018 case AsmToken::Percent: in getGNUBinOpPrecedence()
2021 case AsmToken::LessLess: in getGNUBinOpPrecedence()
2024 case AsmToken::GreaterGreater: in getGNUBinOpPrecedence()
2032 unsigned MasmParser::getBinOpPrecedence(AsmToken::TokenKind K, in getBinOpPrecedence()
2045 AsmToken::TokenKind TokKind = Lexer.getKind(); in parseBinOpRHS()
2046 if (Lexer.getKind() == AsmToken::Identifier) { in parseBinOpRHS()
2047 TokKind = StringSwitch<AsmToken::TokenKind>(Lexer.getTok().getString()) in parseBinOpRHS()
2048 .CaseLower("and", AsmToken::Amp) in parseBinOpRHS()
2049 .CaseLower("not", AsmToken::Exclaim) in parseBinOpRHS()
2050 .CaseLower("or", AsmToken::Pipe) in parseBinOpRHS()
2051 .CaseLower("eq", AsmToken::EqualEqual) in parseBinOpRHS()
2052 .CaseLower("ne", AsmToken::ExclaimEqual) in parseBinOpRHS()
2053 .CaseLower("lt", AsmToken::Less) in parseBinOpRHS()
2054 .CaseLower("le", AsmToken::LessEqual) in parseBinOpRHS()
2055 .CaseLower("gt", AsmToken::Greater) in parseBinOpRHS()
2056 .CaseLower("ge", AsmToken::GreaterEqual) in parseBinOpRHS()
2095 while (Lexer.is(AsmToken::Space)) in parseStatement()
2097 if (Lexer.is(AsmToken::EndOfStatement)) { in parseStatement()
2108 if (getTok().is(AsmToken::Percent)) { in parseStatement()
2110 if (parseToken(AsmToken::Percent) || expandStatement(ExpansionLoc)) in parseStatement()
2116 AsmToken ID = getTok(); in parseStatement()
2120 if (Lexer.is(AsmToken::HashDirective)) in parseStatement()
2123 if (Lexer.is(AsmToken::Integer)) { in parseStatement()
2134 if (Lexer.getKind() != AsmToken::Colon) { in parseStatement()
2141 } else if (Lexer.is(AsmToken::Dot)) { in parseStatement()
2145 } else if (Lexer.is(AsmToken::LCurly)) { in parseStatement()
2150 } else if (Lexer.is(AsmToken::RCurly)) { in parseStatement()
2154 } else if (Lexer.is(AsmToken::Star) && in parseStatement()
2159 } else if (Lexer.is(AsmToken::Real)) { in parseStatement()
2247 case AsmToken::Colon: { in parseStatement()
2283 if (getTok().is(AsmToken::Hash)) { in parseStatement()
2284 std::string CommentStr = parseStringTo(AsmToken::EndOfStatement); in parseStatement()
2286 Lexer.UnLex(AsmToken(AsmToken::EndOfStatement, CommentStr)); in parseStatement()
2291 if (getTok().is(AsmToken::EndOfStatement)) { in parseStatement()
2340 getTok().is(AsmToken::EndOfStatement)) { in parseStatement()
2354 ID.is(AsmToken::Identifier) && getTargetParser().ParseDirective(ID); in parseStatement()
2560 const AsmToken nextTok = getTok(); in parseStatement()
2564 const AsmToken afterNextTok = peekTok(); in parseStatement()
2609 if (afterNextTok.is(AsmToken::Identifier) && in parseStatement()
2620 if (afterNextTok.is(AsmToken::Identifier) && in parseStatement()
2631 if (afterNextTok.is(AsmToken::Identifier) && in parseStatement()
2642 if (afterNextTok.is(AsmToken::Identifier) && in parseStatement()
2652 if (afterNextTok.is(AsmToken::Identifier) && in parseStatement()
2780 if (Lexer.isNot(AsmToken::LCurly) && Lexer.isNot(AsmToken::RCurly)) in parseCurlyBlockScope()
2785 if (Lexer.is(AsmToken::EndOfStatement)) in parseCurlyBlockScope()
2800 assert(getTok().is(AsmToken::Integer) && in parseCppHashLineFilenameComment()
2804 assert(getTok().is(AsmToken::String) && in parseCppHashLineFilenameComment()
2976 for (const AsmToken &Token : A[Index]) { in expandMacro()
2984 if (Token.getString().front() == '%' && Token.is(AsmToken::Integer)) in expandMacro()
3003 static bool isOperator(AsmToken::TokenKind kind) { in isOperator()
3007 case AsmToken::Plus: in isOperator()
3008 case AsmToken::Minus: in isOperator()
3009 case AsmToken::Tilde: in isOperator()
3010 case AsmToken::Slash: in isOperator()
3011 case AsmToken::Star: in isOperator()
3012 case AsmToken::Dot: in isOperator()
3013 case AsmToken::Equal: in isOperator()
3014 case AsmToken::EqualEqual: in isOperator()
3015 case AsmToken::Pipe: in isOperator()
3016 case AsmToken::PipePipe: in isOperator()
3017 case AsmToken::Caret: in isOperator()
3018 case AsmToken::Amp: in isOperator()
3019 case AsmToken::AmpAmp: in isOperator()
3020 case AsmToken::Exclaim: in isOperator()
3021 case AsmToken::ExclaimEqual: in isOperator()
3022 case AsmToken::Less: in isOperator()
3023 case AsmToken::LessEqual: in isOperator()
3024 case AsmToken::LessLess: in isOperator()
3025 case AsmToken::LessGreater: in isOperator()
3026 case AsmToken::Greater: in isOperator()
3027 case AsmToken::GreaterEqual: in isOperator()
3028 case AsmToken::GreaterGreater: in isOperator()
3053 AsmToken::TokenKind EndTok) { in parseMacroArgument()
3058 MA.emplace_back(AsmToken::String, S); in parseMacroArgument()
3065 if (Lexer.is(AsmToken::Less) && isAngleBracketString(StrLoc, EndLoc)) { in parseMacroArgument()
3071 MA.emplace_back(AsmToken::String, StringRef(StrChar, EndChar - StrChar)); in parseMacroArgument()
3084 if (Lexer.is(AsmToken::Eof) || Lexer.is(AsmToken::Equal)) in parseMacroArgument()
3088 if (Lexer.is(AsmToken::Comma)) in parseMacroArgument()
3091 if (Lexer.is(AsmToken::Space)) { in parseMacroArgument()
3105 if (Lexer.is(AsmToken::Space)) in parseMacroArgument()
3117 if (Lexer.is(EndTok) && (EndTok != AsmToken::RParen || ParenLevel == 0)) in parseMacroArgument()
3121 if (Lexer.is(AsmToken::LParen)) in parseMacroArgument()
3123 else if (Lexer.is(AsmToken::RParen) && ParenLevel) in parseMacroArgument()
3148 AsmToken::TokenKind EndTok) { in parseMacroArguments()
3164 if (Lexer.is(AsmToken::Identifier) && peekTok().is(AsmToken::Equal)) { in parseMacroArguments()
3168 if (Lexer.isNot(AsmToken::Equal)) in parseMacroArguments()
3199 if (Lexer.is(AsmToken::Percent)) { in parseMacroArguments()
3211 AsmToken newToken(AsmToken::Integer, in parseMacroArguments()
3254 if (Lexer.is(AsmToken::Comma)) in parseMacroArguments()
3262 AsmToken::TokenKind ArgumentEndTok) { in handleMacroEntry()
3328 if (parseToken(AsmToken::LParen, "invoking macro function '" + M->Name + in handleMacroInvocation()
3330 handleMacroEntry(M, NameLoc, AsmToken::RParen)) in handleMacroInvocation()
3336 while (Lexer.isNot(AsmToken::Eof)) { in handleMacroInvocation()
3348 if (Parsed && !hasPendingError() && Lexer.getTok().is(AsmToken::Error)) { in handleMacroInvocation()
3361 if (parseToken(AsmToken::RParen, "invoking macro function '" + M->Name + in handleMacroInvocation()
3391 if (Lexer.is(AsmToken::Dollar) || Lexer.is(AsmToken::At)) { in parseIdentifier()
3396 AsmToken nextTok = peekTok(false); in parseIdentifier()
3398 if (nextTok.isNot(AsmToken::Identifier)) in parseIdentifier()
3414 if (Lexer.isNot(AsmToken::Identifier) && Lexer.isNot(AsmToken::String)) in parseIdentifier()
3465 if (parseOptionalToken(AsmToken::Comma) && parseMany(parseItem)) in parseDirectiveEquate()
3565 if (check(getTok().isNot(AsmToken::String), "expected string")) in parseEscapedString()
3609 case AsmToken::Percent: { in parseTextItem()
3611 if (parseToken(AsmToken::Percent) || parseAbsoluteExpression(Res)) in parseTextItem()
3616 case AsmToken::Less: in parseTextItem()
3617 case AsmToken::LessEqual: in parseTextItem()
3618 case AsmToken::LessLess: in parseTextItem()
3619 case AsmToken::LessGreater: in parseTextItem()
3621 case AsmToken::Identifier: { in parseTextItem()
3666 getLexer().UnLex(AsmToken(AsmToken::Identifier, ID)); in parseTextItem()
3716 if (Size == 1 && getTok().is(AsmToken::String)) { in parseScalarInitializer()
3731 if (getTok().is(AsmToken::Identifier) && in parseScalarInitializer()
3744 if (parseToken(AsmToken::LParen, in parseScalarInitializer()
3747 parseToken(AsmToken::RParen, "unmatched parentheses")) in parseScalarInitializer()
3761 const AsmToken::TokenKind EndToken) { in parseScalarInstList()
3763 (EndToken != AsmToken::Greater || in parseScalarInstList()
3764 getTok().isNot(AsmToken::GreaterGreater))) { in parseScalarInstList()
3768 if (!parseOptionalToken(AsmToken::Comma)) in parseScalarInstList()
3770 parseOptionalToken(AsmToken::EndOfStatement); in parseScalarInstList()
3849 if (Asm.getTok().isNot(AsmToken::Integer) && in parseHexOcta()
3850 Asm.getTok().isNot(AsmToken::BigNum)) in parseHexOcta()
3872 if (getLexer().is(AsmToken::Minus)) { in parseRealValue()
3876 } else if (getLexer().is(AsmToken::Plus)) { in parseRealValue()
3881 if (Lexer.is(AsmToken::Error)) in parseRealValue()
3883 if (Lexer.isNot(AsmToken::Integer) && Lexer.isNot(AsmToken::Real) && in parseRealValue()
3884 Lexer.isNot(AsmToken::Identifier)) in parseRealValue()
3890 if (getLexer().is(AsmToken::Identifier)) { in parseRealValue()
3931 const AsmToken::TokenKind EndToken) { in parseRealInstList()
3933 (EndToken == AsmToken::Greater && in parseRealInstList()
3934 getTok().isNot(AsmToken::GreaterGreater))) { in parseRealInstList()
3935 const AsmToken NextTok = peekTok(); in parseRealInstList()
3936 if (NextTok.is(AsmToken::Identifier) && in parseRealInstList()
3939 if (parseExpression(Value) || parseToken(AsmToken::Identifier)) in parseRealInstList()
3951 if (parseToken(AsmToken::LParen, in parseRealInstList()
3954 parseToken(AsmToken::RParen, "unmatched parentheses")) in parseRealInstList()
3967 if (!parseOptionalToken(AsmToken::Comma)) in parseRealInstList()
3969 parseOptionalToken(AsmToken::EndOfStatement); in parseRealInstList()
4059 const AsmToken Tok = getTok(); in parseOptionalAngleBracketOpen()
4060 if (parseOptionalToken(AsmToken::LessLess)) { in parseOptionalAngleBracketOpen()
4062 Lexer.UnLex(AsmToken(AsmToken::Less, Tok.getString().substr(1))); in parseOptionalAngleBracketOpen()
4064 } else if (parseOptionalToken(AsmToken::LessGreater)) { in parseOptionalAngleBracketOpen()
4066 Lexer.UnLex(AsmToken(AsmToken::Greater, Tok.getString().substr(1))); in parseOptionalAngleBracketOpen()
4068 } else if (parseOptionalToken(AsmToken::Less)) { in parseOptionalAngleBracketOpen()
4077 const AsmToken Tok = getTok(); in parseAngleBracketClose()
4078 if (parseOptionalToken(AsmToken::GreaterGreater)) { in parseAngleBracketClose()
4079 Lexer.UnLex(AsmToken(AsmToken::Greater, Tok.getString().substr(1))); in parseAngleBracketClose()
4080 } else if (parseToken(AsmToken::Greater, Msg)) { in parseAngleBracketClose()
4093 if (parseOptionalToken(AsmToken::LCurly)) { in parseFieldInitializer()
4096 if (parseScalarInstList(Field.Type, Values, AsmToken::RCurly) || in parseFieldInitializer()
4097 parseToken(AsmToken::RCurly)) in parseFieldInitializer()
4102 if (parseScalarInstList(Field.Type, Values, AsmToken::Greater) || in parseFieldInitializer()
4145 if (parseOptionalToken(AsmToken::LCurly)) { in parseFieldInitializer()
4148 if (parseRealInstList(*Semantics, AsIntValues, AsmToken::RCurly) || in parseFieldInitializer()
4149 parseToken(AsmToken::RCurly)) in parseFieldInitializer()
4154 if (parseRealInstList(*Semantics, AsIntValues, AsmToken::Greater) || in parseFieldInitializer()
4185 if (parseOptionalToken(AsmToken::LCurly)) { in parseFieldInitializer()
4187 AsmToken::RCurly) || in parseFieldInitializer()
4188 parseToken(AsmToken::RCurly)) in parseFieldInitializer()
4192 AsmToken::Greater) || in parseFieldInitializer()
4233 const AsmToken FirstToken = getTok(); in parseStructInitializer()
4235 Optional<AsmToken::TokenKind> EndToken; in parseStructInitializer()
4236 if (parseOptionalToken(AsmToken::LCurly)) { in parseStructInitializer()
4237 EndToken = AsmToken::RCurly; in parseStructInitializer()
4239 EndToken = AsmToken::Greater; in parseStructInitializer()
4241 } else if (FirstToken.is(AsmToken::Identifier) && in parseStructInitializer()
4244 if (parseToken(AsmToken::Identifier)) in parseStructInitializer()
4257 if (parseOptionalToken(AsmToken::Comma)) { in parseStructInitializer()
4261 parseOptionalToken(AsmToken::EndOfStatement); in parseStructInitializer()
4270 if (!parseOptionalToken(AsmToken::Comma)) in parseStructInitializer()
4275 parseOptionalToken(AsmToken::EndOfStatement); in parseStructInitializer()
4286 if (EndToken.getValue() == AsmToken::Greater) in parseStructInitializer()
4297 const AsmToken::TokenKind EndToken) { in parseStructInstList()
4299 (EndToken == AsmToken::Greater && in parseStructInstList()
4300 getTok().isNot(AsmToken::GreaterGreater))) { in parseStructInstList()
4301 const AsmToken NextTok = peekTok(); in parseStructInstList()
4302 if (NextTok.is(AsmToken::Identifier) && in parseStructInstList()
4305 if (parseExpression(Value) || parseToken(AsmToken::Identifier)) in parseStructInstList()
4317 if (parseToken(AsmToken::LParen, in parseStructInstList()
4320 parseToken(AsmToken::RParen, "unmatched parentheses")) in parseStructInstList()
4332 if (!parseOptionalToken(AsmToken::Comma)) in parseStructInstList()
4334 parseOptionalToken(AsmToken::EndOfStatement); in parseStructInstList()
4575 AsmToken NextTok = getTok(); in parseDirectiveStruct()
4577 if (NextTok.isNot(AsmToken::Comma) && in parseDirectiveStruct()
4578 NextTok.isNot(AsmToken::EndOfStatement) && in parseDirectiveStruct()
4590 if (parseOptionalToken(AsmToken::Comma)) { in parseDirectiveStruct()
4600 if (parseToken(AsmToken::EndOfStatement)) in parseDirectiveStruct()
4618 if (getTok().is(AsmToken::Identifier)) { in parseDirectiveNestedStruct()
4620 parseToken(AsmToken::Identifier); in parseDirectiveNestedStruct()
4622 if (parseToken(AsmToken::EndOfStatement)) in parseDirectiveNestedStruct()
4648 if (parseToken(AsmToken::EndOfStatement)) in parseDirectiveEnds()
4660 if (parseToken(AsmToken::EndOfStatement)) in parseDirectiveNestedEnds()
4734 if (parseToken(AsmToken::EndOfStatement)) in parseDirectiveOrg()
4798 if (getTok().is(AsmToken::EndOfStatement)) { in parseDirectiveAlign()
4801 parseToken(AsmToken::EndOfStatement); in parseDirectiveAlign()
4804 parseToken(AsmToken::EndOfStatement)) in parseDirectiveAlign()
4827 if (parseToken(AsmToken::EndOfStatement) || emitAlignTo(2)) in parseDirectiveEven()
4839 if (getLexer().is(AsmToken::Integer)) { in parseDirectiveFile()
4851 if (check(getTok().isNot(AsmToken::String), in parseDirectiveFile()
4859 if (getLexer().is(AsmToken::String)) { in parseDirectiveFile()
4877 while (!parseOptionalToken(AsmToken::EndOfStatement)) { in parseDirectiveFile()
4879 if (check(getTok().isNot(AsmToken::Identifier), in parseDirectiveFile()
4893 check(getTok().isNot(AsmToken::String), in parseDirectiveFile()
4956 if (getLexer().is(AsmToken::Integer)) { in parseDirectiveLine()
4962 if (parseToken(AsmToken::EndOfStatement, in parseDirectiveLine()
4987 if (getLexer().is(AsmToken::Integer)) { in parseDirectiveLoc()
4995 if (getLexer().is(AsmToken::Integer)) { in parseDirectiveLoc()
5086 check(getTok().isNot(AsmToken::String), in parseDirectiveCVFile()
5090 if (!parseOptionalToken(AsmToken::EndOfStatement)) { in parseDirectiveCVFile()
5091 if (check(getTok().isNot(AsmToken::String), in parseDirectiveCVFile()
5096 parseToken(AsmToken::EndOfStatement, in parseDirectiveCVFile()
5144 parseToken(AsmToken::EndOfStatement, in parseDirectiveCVFuncId()
5175 if (check((getLexer().isNot(AsmToken::Identifier) || in parseDirectiveCVInlineSiteId()
5186 if (check((getLexer().isNot(AsmToken::Identifier) || in parseDirectiveCVInlineSiteId()
5199 if (getLexer().is(AsmToken::Integer)) { in parseDirectiveCVInlineSiteId()
5204 if (parseToken(AsmToken::EndOfStatement, in parseDirectiveCVInlineSiteId()
5230 if (getLexer().is(AsmToken::Integer)) { in parseDirectiveCVLoc()
5238 if (getLexer().is(AsmToken::Integer)) { in parseDirectiveCVLoc()
5289 parseToken(AsmToken::Comma, in parseDirectiveCVLinetable()
5293 parseToken(AsmToken::Comma, in parseDirectiveCVLinetable()
5331 if (parseToken(AsmToken::EndOfStatement, "Expected End of Statement")) in parseDirectiveCVInlineLinetable()
5354 while (getLexer().is(AsmToken::Identifier)) { in parseDirectiveCVDefRange()
5372 AsmToken::Comma, in parseDirectiveCVDefRange()
5385 if (parseToken(AsmToken::Comma, "expected comma before register number in " in parseDirectiveCVDefRange()
5398 if (parseToken(AsmToken::Comma, in parseDirectiveCVDefRange()
5411 if (parseToken(AsmToken::Comma, "expected comma before register number in " in parseDirectiveCVDefRange()
5415 if (parseToken(AsmToken::Comma, in parseDirectiveCVDefRange()
5431 if (parseToken(AsmToken::Comma, "expected comma before register number in " in parseDirectiveCVDefRange()
5436 AsmToken::Comma, in parseDirectiveCVDefRange()
5440 if (parseToken(AsmToken::Comma, "expected comma before base pointer offset " in parseDirectiveCVDefRange()
5492 if (parseToken(AsmToken::EndOfStatement, "Expected End of Statement")) in parseDirectiveCVFileChecksumOffset()
5527 if (getLexer().is(AsmToken::Comma)) { in parseDirectiveCFISections()
5547 if (!parseOptionalToken(AsmToken::EndOfStatement)) { in parseDirectiveCFIStartProc()
5550 parseToken(AsmToken::EndOfStatement)) in parseDirectiveCFIStartProc()
5575 if (getLexer().isNot(AsmToken::Integer)) { in parseRegisterOrRegisterNumber()
5590 parseToken(AsmToken::Comma, "unexpected token in directive") || in parseDirectiveCFIDefCfa()
5614 parseToken(AsmToken::Comma, "unexpected token in directive") || in parseDirectiveCFIRegister()
5658 parseToken(AsmToken::Comma, "unexpected token in directive") || in parseDirectiveCFIOffset()
5672 parseToken(AsmToken::Comma, "unexpected token in directive") || in parseDirectiveCFIRelOffset()
5715 parseToken(AsmToken::Comma, "unexpected token in directive") || in parseDirectiveCFIPersonalityOrLsda()
5775 while (getLexer().is(AsmToken::Comma)) { in parseDirectiveCFIEscape()
5801 if (parseToken(AsmToken::EndOfStatement, in parseDirectiveCFISignalFrame()
5829 while (getLexer().isNot(AsmToken::EndOfStatement)) { in parseDirectiveMacro()
5845 if (Lexer.is(AsmToken::Colon)) { in parseDirectiveMacro()
5848 if (parseOptionalToken(AsmToken::Equal)) { in parseDirectiveMacro()
5879 if (getLexer().is(AsmToken::Comma)) in parseDirectiveMacro()
5887 if (getTok().is(AsmToken::Identifier) && in parseDirectiveMacro()
5898 if (!parseOptionalToken(AsmToken::Comma)) in parseDirectiveMacro()
5900 parseOptionalToken(AsmToken::EndOfStatement); in parseDirectiveMacro()
5905 AsmToken EndToken, StartToken = getTok(); in parseDirectiveMacro()
5911 while (Lexer.is(AsmToken::Error)) { in parseDirectiveMacro()
5916 if (getLexer().is(AsmToken::Eof)) in parseDirectiveMacro()
5921 if (getLexer().is(AsmToken::Identifier)) { in parseDirectiveMacro()
5926 if (getLexer().isNot(AsmToken::EndOfStatement)) in parseDirectiveMacro()
5935 if (MacroDepth == 0 && peekTok().isNot(AsmToken::EndOfStatement)) { in parseDirectiveMacro()
5970 if (getTok().isNot(AsmToken::EndOfStatement) && parseTextItem(Value)) in parseDirectiveExitMacro()
5992 if (getLexer().isNot(AsmToken::EndOfStatement)) in parseDirectiveEndMacro()
6025 if (!parseOptionalToken(AsmToken::Comma)) in parseDirectivePurgeMacro()
6027 parseOptionalToken(AsmToken::EndOfStatement); in parseDirectivePurgeMacro()
6071 if (getLexer().isNot(AsmToken::Comma)) in parseDirectiveComm()
6082 if (getLexer().is(AsmToken::Comma)) { in parseDirectiveComm()
6101 if (parseToken(AsmToken::EndOfStatement, in parseDirectiveComm()
6137 std::string FirstLine = parseStringTo(AsmToken::EndOfStatement); in parseDirectiveComment()
6143 if (getTok().is(AsmToken::Eof)) in parseDirectiveComment()
6147 !StringRef(parseStringTo(AsmToken::EndOfStatement)).contains(Delimiter)); in parseDirectiveComment()
6148 return parseToken(AsmToken::EndOfStatement, in parseDirectiveComment()
6161 Filename = parseStringTo(AsmToken::EndOfStatement); in parseDirectiveInclude()
6163 check(getTok().isNot(AsmToken::EndOfStatement), in parseDirectiveInclude()
6184 parseToken(AsmToken::EndOfStatement, in parseDirectiveIf()
6218 if (parseToken(AsmToken::EndOfStatement, in parseDirectiveIfb()
6241 if (Lexer.isNot(AsmToken::Comma)) { in parseDirectiveIfidn()
6285 parseToken(AsmToken::EndOfStatement, "unexpected token in 'ifdef'")) in parseDirectiveIfdef()
6326 if (parseToken(AsmToken::EndOfStatement, in parseDirectiveElseIf()
6370 if (parseToken(AsmToken::EndOfStatement, in parseDirectiveElseIfb()
6408 parseToken(AsmToken::EndOfStatement, in parseDirectiveElseIfdef()
6455 if (Lexer.isNot(AsmToken::Comma)) { in parseDirectiveElseIfidn()
6485 if (parseToken(AsmToken::EndOfStatement, in parseDirectiveElse()
6508 if (parseToken(AsmToken::EndOfStatement, in parseDirectiveEnd()
6512 while (Lexer.isNot(AsmToken::Eof)) in parseDirectiveEnd()
6529 if (Lexer.isNot(AsmToken::EndOfStatement)) in parseDirectiveError()
6530 Message = parseStringTo(AsmToken::EndOfStatement); in parseDirectiveError()
6551 if (Lexer.isNot(AsmToken::EndOfStatement)) { in parseDirectiveErrorIfb()
6552 if (parseToken(AsmToken::Comma)) in parseDirectiveErrorIfb()
6554 Message = parseStringTo(AsmToken::EndOfStatement); in parseDirectiveErrorIfb()
6595 if (Lexer.isNot(AsmToken::EndOfStatement)) { in parseDirectiveErrorIfdef()
6596 if (parseToken(AsmToken::Comma)) in parseDirectiveErrorIfdef()
6598 Message = parseStringTo(AsmToken::EndOfStatement); in parseDirectiveErrorIfdef()
6626 if (Lexer.isNot(AsmToken::Comma)) { in parseDirectiveErrorIfidn()
6646 if (Lexer.isNot(AsmToken::EndOfStatement)) { in parseDirectiveErrorIfidn()
6647 if (parseToken(AsmToken::Comma)) in parseDirectiveErrorIfidn()
6649 Message = parseStringTo(AsmToken::EndOfStatement); in parseDirectiveErrorIfidn()
6682 if (Lexer.isNot(AsmToken::EndOfStatement)) { in parseDirectiveErrorIfe()
6683 if (parseToken(AsmToken::Comma)) in parseDirectiveErrorIfe()
6685 Message = parseStringTo(AsmToken::EndOfStatement); in parseDirectiveErrorIfe()
6697 if (parseToken(AsmToken::EndOfStatement, in parseDirectiveEndIf()
6836 if (getLexer().is(AsmToken::Identifier)) { in isMacroLikeDirective()
6846 if (peekTok().is(AsmToken::Identifier) && in isMacroLikeDirective()
6854 AsmToken EndToken, StartToken = getTok(); in parseMacroLikeBody()
6859 if (getLexer().is(AsmToken::Eof)) { in parseMacroLikeBody()
6868 if (Lexer.is(AsmToken::Identifier) && in parseMacroLikeBody()
6873 if (Lexer.isNot(AsmToken::EndOfStatement)) { in parseMacroLikeBody()
6896 std::string Body = parseStringTo(AsmToken::EndOfStatement); in expandStatement()
6914 A.push_back(AsmToken(AsmToken::String, B.getValue())); in expandStatement()
6927 A.push_back(AsmToken(AsmToken::String, Var.TextValue)); in expandStatement()
6993 parseToken(AsmToken::EndOfStatement, in parseDirectiveRepeat()
7060 if (parseOptionalToken(AsmToken::Colon)) { in parseDirectiveFor()
7061 if (parseOptionalToken(AsmToken::Equal)) { in parseDirectiveFor()
7088 if (parseToken(AsmToken::Comma, in parseDirectiveFor()
7090 parseToken(AsmToken::Less, in parseDirectiveFor()
7097 if (parseMacroArgument(&Parameter, A.back(), /*EndTok=*/AsmToken::Greater)) in parseDirectiveFor()
7101 if (!parseOptionalToken(AsmToken::Comma)) in parseDirectiveFor()
7103 parseOptionalToken(AsmToken::EndOfStatement); in parseDirectiveFor()
7106 if (parseToken(AsmToken::Greater, in parseDirectiveFor()
7109 parseToken(AsmToken::EndOfStatement, "expected End of Statement")) in parseDirectiveFor()
7142 parseToken(AsmToken::Comma, in parseDirectiveForc()
7149 Argument = parseStringTo(AsmToken::EndOfStatement); in parseDirectiveForc()
7150 if (getTok().is(AsmToken::EndOfStatement)) in parseDirectiveForc()
7159 if (parseToken(AsmToken::EndOfStatement, "expected end of statement")) in parseDirectiveForc()
7175 Arg.emplace_back(AsmToken::Identifier, Values.slice(I, I + 1)); in parseDirectiveForc()
7221 std::string RadixStringRaw = parseStringTo(AsmToken::EndOfStatement); in parseDirectiveRadix()
7239 std::string Message = parseStringTo(AsmToken::EndOfStatement); in parseDirectiveEcho()
7411 while (getLexer().isNot(AsmToken::Eof)) { in parseMSInlineAsm()