82 typedef std::vector<AsmToken> MCAsmMacroArgument;
196                                              StringRef IDVal, AsmToken ID,
246   const AsmToken &Lex() override;
367   unsigned getBinOpPrecedence(AsmToken::TokenKind K,
728     while (Lexer.is(AsmToken::Space))  in lexLeadingSpaces()
906 const AsmToken &AsmParser::Lex() {  in Lex()
907   if (Lexer.getTok().is(AsmToken::Error))  in Lex()
911   if (getTok().is(AsmToken::EndOfStatement)) {  in Lex()
918   const AsmToken *tok = &Lexer.Lex();  in Lex()
921   while (tok->is(AsmToken::Comment)) {  in Lex()
927   if (tok->is(AsmToken::Eof)) {  in Lex()
997   while (Lexer.isNot(AsmToken::Eof)) {  in Run()
1004     if (Parsed && !hasPendingError() && Lexer.getTok().is(AsmToken::Error)) {  in Run()
1094   while (Lexer.isNot(AsmToken::EndOfStatement) && Lexer.isNot(AsmToken::Eof))  in eatToEndOfStatement()
1098   if (Lexer.is(AsmToken::EndOfStatement))  in eatToEndOfStatement()
1105   while (Lexer.isNot(AsmToken::EndOfStatement) && Lexer.isNot(AsmToken::Eof))  in parseStringToEndOfStatement()
1115   while (Lexer.isNot(AsmToken::EndOfStatement) &&  in parseStringToComma()
1116          Lexer.isNot(AsmToken::Comma) && Lexer.isNot(AsmToken::Eof))  in parseStringToComma()
1144   if (parseToken(AsmToken::RBrac, "expected ']' in brackets expression"))  in parseBracketExpr()
1158   AsmToken::TokenKind FirstTokenKind = Lexer.getKind();  in parsePrimaryExpr()
1163   case AsmToken::Error:  in parsePrimaryExpr()
1165   case AsmToken::Exclaim:  in parsePrimaryExpr()
1171   case AsmToken::Dollar:  in parsePrimaryExpr()
1172   case AsmToken::Star:  in parsePrimaryExpr()
1173   case AsmToken::At:  in parsePrimaryExpr()
1174   case AsmToken::String:  in parsePrimaryExpr()
1175   case AsmToken::Identifier: {  in parsePrimaryExpr()
1180       if (getTok().is(AsmToken::Dollar) || getTok().is(AsmToken::Star)) {  in parsePrimaryExpr()
1182         if ((getTok().is(AsmToken::Dollar) && MAI.getDollarIsPC()) ||  in parsePrimaryExpr()
1183             (getTok().is(AsmToken::Star) && MAI.getStarIsPC()))  in parsePrimaryExpr()
1204       if (FirstTokenKind == AsmToken::String) {  in parsePrimaryExpr()
1205         if (Lexer.is(AsmToken::At)) {  in parsePrimaryExpr()
1217     } else if (Lexer.is(AsmToken::LParen)) {  in parsePrimaryExpr()
1272   case AsmToken::BigNum:  in parsePrimaryExpr()
1274   case AsmToken::Integer: {  in parsePrimaryExpr()
1281     if (Lexer.getKind() == AsmToken::Identifier) {  in parsePrimaryExpr()
1305   case AsmToken::Real: {  in parsePrimaryExpr()
1313   case AsmToken::Dot: {  in parsePrimaryExpr()
1326   case AsmToken::LParen:  in parsePrimaryExpr()
1329   case AsmToken::LBrac:  in parsePrimaryExpr()
1334   case AsmToken::Minus:  in parsePrimaryExpr()
1340   case AsmToken::Plus:  in parsePrimaryExpr()
1346   case AsmToken::Tilde:  in parsePrimaryExpr()
1354   case AsmToken::PercentCall16:  in parsePrimaryExpr()
1355   case AsmToken::PercentCall_Hi:  in parsePrimaryExpr()
1356   case AsmToken::PercentCall_Lo:  in parsePrimaryExpr()
1357   case AsmToken::PercentDtprel_Hi:  in parsePrimaryExpr()
1358   case AsmToken::PercentDtprel_Lo:  in parsePrimaryExpr()
1359   case AsmToken::PercentGot:  in parsePrimaryExpr()
1360   case AsmToken::PercentGot_Disp:  in parsePrimaryExpr()
1361   case AsmToken::PercentGot_Hi:  in parsePrimaryExpr()
1362   case AsmToken::PercentGot_Lo:  in parsePrimaryExpr()
1363   case AsmToken::PercentGot_Ofst:  in parsePrimaryExpr()
1364   case AsmToken::PercentGot_Page:  in parsePrimaryExpr()
1365   case AsmToken::PercentGottprel:  in parsePrimaryExpr()
1366   case AsmToken::PercentGp_Rel:  in parsePrimaryExpr()
1367   case AsmToken::PercentHi:  in parsePrimaryExpr()
1368   case AsmToken::PercentHigher:  in parsePrimaryExpr()
1369   case AsmToken::PercentHighest:  in parsePrimaryExpr()
1370   case AsmToken::PercentLo:  in parsePrimaryExpr()
1371   case AsmToken::PercentNeg:  in parsePrimaryExpr()
1372   case AsmToken::PercentPcrel_Hi:  in parsePrimaryExpr()
1373   case AsmToken::PercentPcrel_Lo:  in parsePrimaryExpr()
1374   case AsmToken::PercentTlsgd:  in parsePrimaryExpr()
1375   case AsmToken::PercentTlsldm:  in parsePrimaryExpr()
1376   case AsmToken::PercentTprel_Hi:  in parsePrimaryExpr()
1377   case AsmToken::PercentTprel_Lo:  in parsePrimaryExpr()
1379     if (Lexer.isNot(AsmToken::LParen))  in parsePrimaryExpr()
1509   if (Lexer.getKind() == AsmToken::At) {  in parseExpression()
1512     if (Lexer.isNot(AsmToken::Identifier))  in parseExpression()
1577 static unsigned getDarwinBinOpPrecedence(AsmToken::TokenKind K,  in getDarwinBinOpPrecedence()
1585   case AsmToken::AmpAmp:  in getDarwinBinOpPrecedence()
1588   case AsmToken::PipePipe:  in getDarwinBinOpPrecedence()
1593   case AsmToken::Pipe:  in getDarwinBinOpPrecedence()
1596   case AsmToken::Caret:  in getDarwinBinOpPrecedence()
1599   case AsmToken::Amp:  in getDarwinBinOpPrecedence()
1604   case AsmToken::EqualEqual:  in getDarwinBinOpPrecedence()
1607   case AsmToken::ExclaimEqual:  in getDarwinBinOpPrecedence()
1608   case AsmToken::LessGreater:  in getDarwinBinOpPrecedence()
1611   case AsmToken::Less:  in getDarwinBinOpPrecedence()
1614   case AsmToken::LessEqual:  in getDarwinBinOpPrecedence()
1617   case AsmToken::Greater:  in getDarwinBinOpPrecedence()
1620   case AsmToken::GreaterEqual:  in getDarwinBinOpPrecedence()
1625   case AsmToken::LessLess:  in getDarwinBinOpPrecedence()
1628   case AsmToken::GreaterGreater:  in getDarwinBinOpPrecedence()
1633   case AsmToken::Plus:  in getDarwinBinOpPrecedence()
1636   case AsmToken::Minus:  in getDarwinBinOpPrecedence()
1641   case AsmToken::Star:  in getDarwinBinOpPrecedence()
1644   case AsmToken::Slash:  in getDarwinBinOpPrecedence()
1647   case AsmToken::Percent:  in getDarwinBinOpPrecedence()
1654                                       AsmToken::TokenKind K,  in getGNUBinOpPrecedence()
1662   case AsmToken::AmpAmp:  in getGNUBinOpPrecedence()
1665   case AsmToken::PipePipe:  in getGNUBinOpPrecedence()
1670   case AsmToken::EqualEqual:  in getGNUBinOpPrecedence()
1673   case AsmToken::ExclaimEqual:  in getGNUBinOpPrecedence()
1674   case AsmToken::LessGreater:  in getGNUBinOpPrecedence()
1677   case AsmToken::Less:  in getGNUBinOpPrecedence()
1680   case AsmToken::LessEqual:  in getGNUBinOpPrecedence()
1683   case AsmToken::Greater:  in getGNUBinOpPrecedence()
1686   case AsmToken::GreaterEqual:  in getGNUBinOpPrecedence()
1691   case AsmToken::Plus:  in getGNUBinOpPrecedence()
1694   case AsmToken::Minus:  in getGNUBinOpPrecedence()
1700   case AsmToken::Pipe:  in getGNUBinOpPrecedence()
1703   case AsmToken::Exclaim:  in getGNUBinOpPrecedence()
1710   case AsmToken::Caret:  in getGNUBinOpPrecedence()
1713   case AsmToken::Amp:  in getGNUBinOpPrecedence()
1718   case AsmToken::Star:  in getGNUBinOpPrecedence()
1721   case AsmToken::Slash:  in getGNUBinOpPrecedence()
1724   case AsmToken::Percent:  in getGNUBinOpPrecedence()
1727   case AsmToken::LessLess:  in getGNUBinOpPrecedence()
1730   case AsmToken::GreaterGreater:  in getGNUBinOpPrecedence()
1736 unsigned AsmParser::getBinOpPrecedence(AsmToken::TokenKind K,  in getBinOpPrecedence()
1784   while (Lexer.is(AsmToken::Space))  in parseStatement()
1786   if (Lexer.is(AsmToken::EndOfStatement)) {  in parseStatement()
1795   AsmToken ID = getTok();  in parseStatement()
1800   if (Lexer.is(AsmToken::HashDirective))  in parseStatement()
1805   if (Lexer.is(AsmToken::Integer)) {  in parseStatement()
1816       if (Lexer.getKind() != AsmToken::Colon) {  in parseStatement()
1823   } else if (Lexer.is(AsmToken::Dot)) {  in parseStatement()
1827   } else if (Lexer.is(AsmToken::LCurly)) {  in parseStatement()
1832   } else if (Lexer.is(AsmToken::RCurly)) {  in parseStatement()
1836   } else if (Lexer.is(AsmToken::Star) &&  in parseStatement()
1904   case AsmToken::Colon: {  in parseStatement()
1940     if (getTok().is(AsmToken::Hash)) {  in parseStatement()
1943       Lexer.UnLex(AsmToken(AsmToken::EndOfStatement, CommentStr));  in parseStatement()
1948     if (getTok().is(AsmToken::EndOfStatement)) {  in parseStatement()
1972   case AsmToken::Equal:  in parseStatement()
2325                                                       AsmToken ID,  in parseAndMatchAndEmitTargetInstruction()
2399   if (Lexer.isNot(AsmToken::LCurly) && Lexer.isNot(AsmToken::RCurly))  in parseCurlyBlockScope()
2404   if (Lexer.is(AsmToken::EndOfStatement))  in parseCurlyBlockScope()
2419   assert(getTok().is(AsmToken::Integer) &&  in parseCppHashLineFilenameComment()
2423   assert(getTok().is(AsmToken::String) &&  in parseCppHashLineFilenameComment()
2566         for (const AsmToken &Token : A[Index])  in expandMacro()
2603           for (const AsmToken &Token : A[Index])  in expandMacro()
2612                 Token.is(AsmToken::Integer))  in expandMacro()
2618                      Token.is(AsmToken::String)) {  in expandMacro()
2623             else if (Token.isNot(AsmToken::String) || VarargParameter)  in expandMacro()
2639 static bool isOperator(AsmToken::TokenKind kind) {  in isOperator()
2643   case AsmToken::Plus:  in isOperator()
2644   case AsmToken::Minus:  in isOperator()
2645   case AsmToken::Tilde:  in isOperator()
2646   case AsmToken::Slash:  in isOperator()
2647   case AsmToken::Star:  in isOperator()
2648   case AsmToken::Dot:  in isOperator()
2649   case AsmToken::Equal:  in isOperator()
2650   case AsmToken::EqualEqual:  in isOperator()
2651   case AsmToken::Pipe:  in isOperator()
2652   case AsmToken::PipePipe:  in isOperator()
2653   case AsmToken::Caret:  in isOperator()
2654   case AsmToken::Amp:  in isOperator()
2655   case AsmToken::AmpAmp:  in isOperator()
2656   case AsmToken::Exclaim:  in isOperator()
2657   case AsmToken::ExclaimEqual:  in isOperator()
2658   case AsmToken::Less:  in isOperator()
2659   case AsmToken::LessEqual:  in isOperator()
2660   case AsmToken::LessLess:  in isOperator()
2661   case AsmToken::LessGreater:  in isOperator()
2662   case AsmToken::Greater:  in isOperator()
2663   case AsmToken::GreaterEqual:  in isOperator()
2664   case AsmToken::GreaterGreater:  in isOperator()
2690     if (Lexer.isNot(AsmToken::EndOfStatement)) {  in parseMacroArgument()
2692       MA.emplace_back(AsmToken::String, Str);  in parseMacroArgument()
2706     if (Lexer.is(AsmToken::Eof) || Lexer.is(AsmToken::Equal))  in parseMacroArgument()
2711       if (Lexer.is(AsmToken::Comma))  in parseMacroArgument()
2714       if (Lexer.is(AsmToken::Space)) {  in parseMacroArgument()
2728           if (Lexer.is(AsmToken::Space))  in parseMacroArgument()
2740     if (Lexer.is(AsmToken::EndOfStatement))  in parseMacroArgument()
2744     if (Lexer.is(AsmToken::LParen))  in parseMacroArgument()
2746     else if (Lexer.is(AsmToken::RParen) && ParenLevel)  in parseMacroArgument()
2778     if (Lexer.is(AsmToken::Identifier) && Lexer.peekTok().is(AsmToken::Equal)) {  in parseMacroArguments()
2782       if (Lexer.isNot(AsmToken::Equal))  in parseMacroArguments()
2796     if (AltMacroMode && Lexer.is(AsmToken::Percent)) {  in parseMacroArguments()
2808       AsmToken newToken(AsmToken::Integer,  in parseMacroArguments()
2811     } else if (AltMacroMode && Lexer.is(AsmToken::Less) &&  in parseMacroArguments()
2818       AsmToken newToken(AsmToken::String,  in parseMacroArguments()
2853     if (Lexer.is(AsmToken::EndOfStatement)) {  in parseMacroArguments()
2871     if (Lexer.is(AsmToken::Comma))  in parseMacroArguments()
2987   if (Lexer.is(AsmToken::Dollar) || Lexer.is(AsmToken::At)) {  in parseIdentifier()
2992     AsmToken Buf[1];  in parseIdentifier()
2995     if (Buf[0].isNot(AsmToken::Identifier) && Buf[0].isNot(AsmToken::Integer))  in parseIdentifier()
3011   if (Lexer.isNot(AsmToken::Identifier) && Lexer.isNot(AsmToken::String))  in parseIdentifier()
3035   if (check(getTok().isNot(AsmToken::String), "expected string"))  in parseEscapedString()
3139     } while (!ZeroTerminated && getTok().is(AsmToken::String));  in parseDirectiveAscii()
3158       check(getTok().isNot(AsmToken::Identifier), "expected relocation name"))  in parseDirectiveReloc()
3165   if (Lexer.is(AsmToken::Comma)) {  in parseDirectiveReloc()
3213   if (Asm.getTok().isNot(AsmToken::Integer) &&  in parseHexOcta()
3214       Asm.getTok().isNot(AsmToken::BigNum))  in parseHexOcta()
3258   if (getLexer().is(AsmToken::Minus)) {  in parseRealValue()
3261   } else if (getLexer().is(AsmToken::Plus))  in parseRealValue()
3264   if (Lexer.is(AsmToken::Error))  in parseRealValue()
3266   if (Lexer.isNot(AsmToken::Integer) && Lexer.isNot(AsmToken::Real) &&  in parseRealValue()
3267       Lexer.isNot(AsmToken::Identifier))  in parseRealValue()
3273   if (getLexer().is(AsmToken::Identifier)) {  in parseRealValue()
3321   if (getLexer().is(AsmToken::Comma)) {  in parseDirectiveZero()
3347   if (parseOptionalToken(AsmToken::Comma)) {  in parseDirectiveFill()
3351     if (parseOptionalToken(AsmToken::Comma)) {  in parseDirectiveFill()
3387   if (parseOptionalToken(AsmToken::Comma))  in parseDirectiveOrg()
3410     if (parseOptionalToken(AsmToken::Comma)) {  in parseDirectiveAlign()
3414       if (getTok().isNot(AsmToken::Comma)) {  in parseDirectiveAlign()
3419       if (parseOptionalToken(AsmToken::Comma))  in parseDirectiveAlign()
3430   if (IsPow2 && (ValueSize == 1) && getTok().is(AsmToken::EndOfStatement)) {  in parseDirectiveAlign()
3505   if (getLexer().is(AsmToken::Integer)) {  in parseDirectiveFile()
3523   if (getLexer().is(AsmToken::String)) {  in parseDirectiveFile()
3541   while (!parseOptionalToken(AsmToken::EndOfStatement)) {  in parseDirectiveFile()
3543     if (check(getTok().isNot(AsmToken::Identifier),  in parseDirectiveFile()
3557           check(getTok().isNot(AsmToken::String),  in parseDirectiveFile()
3621   if (getLexer().is(AsmToken::Integer)) {  in parseDirectiveLine()
3648   if (getLexer().is(AsmToken::Integer)) {  in parseDirectiveLoc()
3656   if (getLexer().is(AsmToken::Integer)) {  in parseDirectiveLoc()
3747       check(getTok().isNot(AsmToken::String),  in parseDirectiveCVFile()
3751   if (!parseOptionalToken(AsmToken::EndOfStatement)) {  in parseDirectiveCVFile()
3752     if (check(getTok().isNot(AsmToken::String),  in parseDirectiveCVFile()
3833   if (check((getLexer().isNot(AsmToken::Identifier) ||  in parseDirectiveCVInlineSiteId()
3844   if (check((getLexer().isNot(AsmToken::Identifier) ||  in parseDirectiveCVInlineSiteId()
3857   if (getLexer().is(AsmToken::Integer)) {  in parseDirectiveCVInlineSiteId()
3887   if (getLexer().is(AsmToken::Integer)) {  in parseDirectiveCVLoc()
3895   if (getLexer().is(AsmToken::Integer)) {  in parseDirectiveCVLoc()
4009   while (getLexer().is(AsmToken::Identifier)) {  in parseDirectiveCVDefRange()
4027           AsmToken::Comma,  in parseDirectiveCVDefRange()
4040     if (parseToken(AsmToken::Comma, "expected comma before register number in "  in parseDirectiveCVDefRange()
4053     if (parseToken(AsmToken::Comma,  in parseDirectiveCVDefRange()
4066     if (parseToken(AsmToken::Comma, "expected comma before register number in "  in parseDirectiveCVDefRange()
4070     if (parseToken(AsmToken::Comma,  in parseDirectiveCVDefRange()
4086     if (parseToken(AsmToken::Comma, "expected comma before register number in "  in parseDirectiveCVDefRange()
4091             AsmToken::Comma,  in parseDirectiveCVDefRange()
4095     if (parseToken(AsmToken::Comma, "expected comma before base pointer offset "  in parseDirectiveCVDefRange()
4174   if (!parseOptionalToken(AsmToken::EndOfStatement)) {  in parseDirectiveCFISections()
4182       if (parseOptionalToken(AsmToken::EndOfStatement))  in parseDirectiveCFISections()
4196   if (!parseOptionalToken(AsmToken::EndOfStatement)) {  in parseDirectiveCFIStartProc()
4226   if (getLexer().isNot(AsmToken::Integer)) {  in parseRegisterOrRegisterNumber()
4442   while (getLexer().is(AsmToken::Comma)) {  in parseDirectiveCFIEscape()
4514   if (getLexer().is(AsmToken::Comma))  in parseDirectiveMacro()
4518   while (getLexer().isNot(AsmToken::EndOfStatement)) {  in parseDirectiveMacro()
4535     if (Lexer.is(AsmToken::Colon)) {  in parseDirectiveMacro()
4555     if (getLexer().is(AsmToken::Equal)) {  in parseDirectiveMacro()
4571     if (getLexer().is(AsmToken::Comma))  in parseDirectiveMacro()
4579   AsmToken EndToken, StartToken = getTok();  in parseDirectiveMacro()
4584     while (Lexer.is(AsmToken::Error)) {  in parseDirectiveMacro()
4589     if (getLexer().is(AsmToken::Eof))  in parseDirectiveMacro()
4594     if (getLexer().is(AsmToken::Identifier)) {  in parseDirectiveMacro()
4600           if (getLexer().isNot(AsmToken::EndOfStatement))  in parseDirectiveMacro()
4613     } else if (Lexer.is(AsmToken::HashDirective)) {  in parseDirectiveMacro()
4762   if (getLexer().isNot(AsmToken::EndOfStatement))  in parseDirectiveEndMacro()
4829   if (!parseOptionalToken(AsmToken::EndOfStatement)) {  in parseDirectiveBundleLock()
4859   if (parseOptionalToken(AsmToken::Comma))  in parseDirectiveSpace()
5025   if (getLexer().is(AsmToken::Comma)) {  in parseDirectiveComm()
5092   if (check(getTok().isNot(AsmToken::String),  in parseDirectiveInclude()
5095       check(getTok().isNot(AsmToken::EndOfStatement),  in parseDirectiveInclude()
5112   if (check(getTok().isNot(AsmToken::String),  in parseDirectiveIncbin()
5120   if (parseOptionalToken(AsmToken::Comma)) {  in parseDirectiveIncbin()
5123     if (getTok().isNot(AsmToken::Comma)) {  in parseDirectiveIncbin()
5127     if (parseOptionalToken(AsmToken::Comma)) {  in parseDirectiveIncbin()
5239   if (Lexer.isNot(AsmToken::String)) {  in parseDirectiveIfeqs()
5248   if (Lexer.isNot(AsmToken::Comma)) {  in parseDirectiveIfeqs()
5257   if (Lexer.isNot(AsmToken::String)) {  in parseDirectiveIfeqs()
5358   while (Lexer.isNot(AsmToken::Eof))  in parseDirectiveEnd()
5379   if (Lexer.isNot(AsmToken::EndOfStatement)) {  in parseDirectiveError()
5380     if (Lexer.isNot(AsmToken::String))  in parseDirectiveError()
5402   if (!parseOptionalToken(AsmToken::EndOfStatement)) {  in parseDirectiveWarning()
5403     if (Lexer.isNot(AsmToken::String))  in parseDirectiveWarning()
5606   AsmToken EndToken, StartToken = getTok();  in parseMacroLikeBody()
5611     if (getLexer().is(AsmToken::Eof)) {  in parseMacroLikeBody()
5616     if (Lexer.is(AsmToken::Identifier) &&  in parseMacroLikeBody()
5625     if (Lexer.is(AsmToken::Identifier) && getTok().getIdentifier() == ".endr") {  in parseMacroLikeBody()
5629         if (Lexer.isNot(AsmToken::EndOfStatement)) {  in parseMacroLikeBody()
5767     Arg.emplace_back(AsmToken::Identifier, Values.slice(I, I + 1));  in parseDirectiveIrpc()
5786   assert(getLexer().is(AsmToken::EndOfStatement));  in parseDirectiveEndr()
5826   const AsmToken StrTok = getTok();  in parseDirectivePrint()
5828   if (StrTok.isNot(AsmToken::String) || StrTok.getString().front() != '"')  in parseDirectivePrint()
5858   if (getLexer().is(AsmToken::Integer)) {  in parseDirectivePseudoProbe()
5863   if (getLexer().is(AsmToken::Integer)) {  in parseDirectivePseudoProbe()
5868   if (getLexer().is(AsmToken::Integer)) {  in parseDirectivePseudoProbe()
5873   if (getLexer().is(AsmToken::Integer)) {  in parseDirectivePseudoProbe()
5881   while (getLexer().is(AsmToken::At)) {  in parseDirectivePseudoProbe()
5886     if (getLexer().is(AsmToken::Integer)) {  in parseDirectivePseudoProbe()
5893     if (getLexer().is(AsmToken::Colon))  in parseDirectivePseudoProbe()
5897     if (getLexer().is(AsmToken::Integer)) {  in parseDirectivePseudoProbe()
5978   while (getLexer().isNot(AsmToken::Eof)) {  in parseMSInlineAsm()
6232   AsmToken LabelTok = getTok();  in parseAsHLASMLabel()
6250   if (getTok().is(AsmToken::EndOfStatement))  in parseAsHLASMLabel()
6277   AsmToken OperationEntryTok = Lexer.getTok();  in parseAsMachineInstruction()
6306   if (getTok().isNot(AsmToken::Space))  in parseStatement()
6311   if (Lexer.is(AsmToken::EndOfStatement)) {  in parseStatement()
6328   if (Lexer.is(AsmToken::EndOfStatement)) {  in parseStatement()