reference, declarationdefinition
definition → references, declarations, derived classes, virtual overrides
reference to multiple definitions → definitions
unreferenced

References

tools/clang/include/clang/Parse/Parser.h
 2199       return isCXXDeclarationSpecifier() == TPResult::True;
 2327   TPResult isExpressionOrTypeSpecifierSimple(tok::TokenKind Kind);
 2336   TPResult
 2337   isCXXDeclarationSpecifier(TPResult BracedCastResult = TPResult::False,
 2337   isCXXDeclarationSpecifier(TPResult BracedCastResult = TPResult::False,
 2348   TPResult isTemplateArgumentList(unsigned TokensToSkip);
 2362   TPResult TryParseSimpleDeclaration(bool AllowForRangeDecl);
 2363   TPResult TryParseTypeofSpecifier();
 2364   TPResult TryParseProtocolQualifiers();
 2365   TPResult TryParsePtrOperatorSeq();
 2366   TPResult TryParseOperatorId();
 2367   TPResult TryParseInitDeclaratorList();
 2368   TPResult TryParseDeclarator(bool mayBeAbstract, bool mayHaveIdentifier = true,
 2370   TPResult
 2373   TPResult TryParseFunctionDeclarator();
 2374   TPResult TryParseBracketDeclarator();
 2375   TPResult TryConsumeDeclarationSpecifier();
tools/clang/lib/Parse/ParseCXXInlineMethods.cpp
 1047         TPResult Result = TPResult::Error;
 1047         TPResult Result = TPResult::Error;
 1054           if (Result == TPResult::Ambiguous && Tok.isNot(tok::semi))
 1055             Result = TPResult::False;
 1064           if (Result == TPResult::Ambiguous && InvalidAsDeclaration)
 1065             Result = TPResult::False;
 1070         if (Result != TPResult::False && Result != TPResult::Error) {
 1070         if (Result != TPResult::False && Result != TPResult::Error) {
tools/clang/lib/Parse/ParseDecl.cpp
 2693       TPResult TPR = TryParseDeclarator(/*mayBeAbstract*/false);
 2696       if (TPR != TPResult::False) {
 4398       TPResult TPR = isExpressionOrTypeSpecifierSimple(NextToken().getKind());
 4401       if (TPR == TPResult::True)
 4407       else if (TPR == TPResult::False &&
 4427              isCXXDeclarationSpecifier(TPResult::True) != TPResult::True) ||
 4427              isCXXDeclarationSpecifier(TPResult::True) != TPResult::True) ||
 5912               TPResult::False) {
tools/clang/lib/Parse/ParseExprCXX.cpp
  495             isTemplateArgumentList(1) == TPResult::False)
  512           (IsTypename || isTemplateArgumentList(1) == TPResult::True)) {
 2278           isTemplateArgumentList(0) == TPResult::False)
 2282           ObjectType && isTemplateArgumentList(0) == TPResult::True) {
tools/clang/lib/Parse/ParseTentative.cpp
  114   TPResult TPR = isCXXDeclarationSpecifier(TPResult::False,
  114   TPResult TPR = isCXXDeclarationSpecifier(TPResult::False,
  116   if (TPR != TPResult::Ambiguous)
  117     return TPR != TPResult::False; // Returns true for TPResult::True or
  141   if (TPR == TPResult::Error)
  145   if (TPR == TPResult::Ambiguous)
  146     TPR = TPResult::True;
  149   return TPR == TPResult::True;
  154 Parser::TPResult Parser::TryConsumeDeclarationSpecifier() {
  167       return TPResult::Error;
  170       return TPResult::Error;
  194           return TPResult::Error;
  198           return TPResult::Error;
  201           return TPResult::Error;
  208       return TPResult::Error;
  216       return TPResult::Error;
  230   return TPResult::Ambiguous;
  241 Parser::TPResult Parser::TryParseSimpleDeclaration(bool AllowForRangeDecl) {
  242   if (TryConsumeDeclarationSpecifier() == TPResult::Error)
  243     return TPResult::Error;
  249     TPResult TPR = isCXXDeclarationSpecifier();
  250     if (TPR == TPResult::Ambiguous)
  251       return TPResult::True;
  252     if (TPR == TPResult::True || TPR == TPResult::Error)
  252     if (TPR == TPResult::True || TPR == TPResult::Error)
  257   TPResult TPR = TryParseInitDeclaratorList();
  258   if (TPR != TPResult::Ambiguous)
  262     return TPResult::False;
  264   return TPResult::Ambiguous;
  294 Parser::TPResult Parser::TryParseInitDeclaratorList() {
  297     TPResult TPR = TryParseDeclarator(false/*mayBeAbstract*/);
  298     if (TPR != TPResult::Ambiguous)
  303       return TPResult::True;
  310         return TPResult::Error;
  314       return TPResult::True;
  332       return TPResult::True;
  339   return TPResult::Ambiguous;
  411   bool update(TPResult IsDecl) {
  413     case TPResult::True:
  417     case TPResult::False:
  420     case TPResult::Ambiguous:
  422     case TPResult::Error:
  555   TPResult TPR = isCXXDeclarationSpecifier();
  556   if (TPR != TPResult::Ambiguous)
  557     return TPR != TPResult::False; // Returns true for TPResult::True or
  576   if (TPR == TPResult::Error)
  577     TPR = TPResult::True;
  579   if (TPR == TPResult::Ambiguous) {
  583       TPR = TPResult::True;
  599       TPR = TPResult::True;
  603       TPR = TPResult::False;
  607   return TPR == TPResult::True;
  786 Parser::TPResult Parser::TryParsePtrOperatorSeq() {
  790         return TPResult::Error;
  801       return TPResult::True;
  824 Parser::TPResult Parser::TryParseOperatorId() {
  836     return TPResult::True;
  843     return TPResult::True;
  849       return TPResult::True;
  857       return TPResult::True;
  877         return TPResult::Error;
  879     return TPResult::True;
  885     TPResult TPR = isCXXDeclarationSpecifier();
  886     if (TPR == TPResult::Error)
  888     if (TPR == TPResult::False) {
  890         return TPResult::Error;
  893     if (TryConsumeDeclarationSpecifier() == TPResult::Error)
  894       return TPResult::Error;
  953 Parser::TPResult Parser::TryParseDeclarator(bool mayBeAbstract,
  959   if (TryParsePtrOperatorSeq() == TPResult::Error)
  960     return TPResult::Error;
  977       if (TryParseOperatorId() == TPResult::Error)
  978         return TPResult::Error;
  990       TPResult TPR = TryParseFunctionDeclarator();
  991       if (TPR != TPResult::Ambiguous)
 1000         return TPResult::True; // attributes indicate declaration
 1001       TPResult TPR = TryParseDeclarator(mayBeAbstract, mayHaveIdentifier);
 1002       if (TPR != TPResult::Ambiguous)
 1005         return TPResult::False;
 1009     return TPResult::False;
 1013     return TPResult::Ambiguous;
 1016     TPResult TPR(TPResult::Ambiguous);
 1016     TPResult TPR(TPResult::Ambiguous);
 1038     if (TPR != TPResult::Ambiguous)
 1042   return TPResult::Ambiguous;
 1045 Parser::TPResult
 1106     return TPResult::True;
 1160     return TPResult::False;
 1166   return TPResult::Ambiguous;
 1312 Parser::TPResult
 1313 Parser::isCXXDeclarationSpecifier(Parser::TPResult BracedCastResult,
 1320       return TPResult::True;
 1325       return TPResult::True;
 1335         return TPResult::Error;
 1337         return TPResult::False;
 1345             return TPResult::Error;
 1352         return GreaterThanIsOperator ? TPResult::True : TPResult::False;
 1352         return GreaterThanIsOperator ? TPResult::True : TPResult::False;
 1354         return InvalidAsDeclSpec ? TPResult::Ambiguous : TPResult::False;
 1354         return InvalidAsDeclSpec ? TPResult::Ambiguous : TPResult::False;
 1366         return TPResult::Error;
 1371         return TPResult::False;
 1382       return TPResult::Error;
 1389       return TPResult::False;
 1397       return TPResult::Error;
 1451     return TPResult::True;
 1456       return TPResult::False;
 1475     return TPResult::True;
 1496     return TPResult::True;
 1500     return TPResult::True;
 1504     return TPResult::True;
 1516       return TPResult::Ambiguous;
 1519       return TPResult::False;
 1529       return TPResult::Error;
 1543           TPResult TPR = TPResult::False;
 1543           TPResult TPR = TPResult::False;
 1549               TPR == TPResult::True || TPR == TPResult::Error)
 1549               TPR == TPResult::True || TPR == TPResult::Error)
 1550             return TPResult::Error;
 1556             return TPResult::Ambiguous;
 1566                 return TPResult::True;
 1574             return TPResult::Error;
 1576             return TPResult::False;
 1582                 return TPResult::Error;
 1591                        ? TPResult::True
 1592                        : TPResult::False;
 1594             return InvalidAsDeclSpec ? TPResult::Ambiguous : TPResult::False;
 1594             return InvalidAsDeclSpec ? TPResult::Ambiguous : TPResult::False;
 1605       return TPResult::False;
 1636       TPResult TPR = TryParseProtocolQualifiers();
 1640       if (TPR == TPResult::Error)
 1641         return TPResult::Error;
 1644         return TPResult::Ambiguous;
 1649       return TPResult::True;
 1676       return TPResult::Ambiguous;
 1688       return TPResult::False;
 1690     return TPResult::True;
 1695       return TPResult::True;
 1699     TPResult TPR = TryParseTypeofSpecifier();
 1703     if (TPR == TPResult::Error)
 1704       return TPResult::Error;
 1707       return TPResult::Ambiguous;
 1712     return TPResult::True;
 1717     return TPResult::True;
 1721     return TPResult::True;
 1724     return TPResult::False;
 1788 Parser::TPResult Parser::TryParseTypeofSpecifier() {
 1796     return TPResult::Error;
 1798   return TPResult::Ambiguous;
 1803 Parser::TPResult Parser::TryParseProtocolQualifiers() {
 1808       return TPResult::Error;
 1818       return TPResult::Ambiguous;
 1822   return TPResult::Error;
 1850   TPResult TPR = TryParseParameterDeclarationClause(&InvalidAsDeclaration);
 1851   if (TPR == TPResult::Ambiguous) {
 1853       TPR = TPResult::False;
 1863         TPR = TPResult::True;
 1866         TPR = TPResult::False;
 1870   if (IsAmbiguous && TPR == TPResult::Ambiguous)
 1874   return TPR != TPResult::False;
 1894 Parser::TPResult
 1899     return TPResult::Ambiguous;
 1913         return TPResult::True; // '...)' is a sign of a function declarator.
 1915         return TPResult::False;
 1921       return TPResult::True;
 1929     TPResult TPR = isCXXDeclarationSpecifier(TPResult::False,
 1929     TPResult TPR = isCXXDeclarationSpecifier(TPResult::False,
 1933     if (TPR != TPResult::Ambiguous &&
 1934         !(VersusTemplateArgument && TPR == TPResult::True))
 1940       if (TryConsumeDeclarationSpecifier() == TPResult::Error)
 1941         return TPResult::Error;
 1945         return TPResult::True;
 1947       TPR = isCXXDeclarationSpecifier(TPResult::False,
 1949       if (TPR == TPResult::Error)
 1953       if (TPR == TPResult::True && !VersusTemplateArgument)
 1955     } while (TPR != TPResult::False);
 1960     if (TPR != TPResult::Ambiguous)
 1965       return TPResult::True;
 1978       return Tok.isOneOf(tok::equal, tok::r_paren) ? TPResult::True
 1979                                                    : TPResult::False;
 1986         return TPResult::Error;
 1992         return TPResult::True; // '...)' is a sign of a function declarator.
 1994         return TPResult::False;
 2001   return TPResult::Ambiguous;
 2016 Parser::TPResult Parser::TryParseFunctionDeclarator() {
 2020   TPResult TPR = TryParseParameterDeclarationClause();
 2021   if (TPR == TPResult::Ambiguous && Tok.isNot(tok::r_paren))
 2022     TPR = TPResult::False;
 2024   if (TPR == TPResult::False || TPR == TPResult::Error)
 2024   if (TPR == TPResult::False || TPR == TPResult::Error)
 2029     return TPResult::Error;
 2044       return TPResult::Error;
 2049       return TPResult::Error;
 2058         return TPResult::Error;
 2062   return TPResult::Ambiguous;
 2067 Parser::TPResult Parser::TryParseBracketDeclarator() {
 2070     return TPResult::Error;
 2072   return TPResult::Ambiguous;
 2079 Parser::TPResult Parser::isTemplateArgumentList(unsigned TokensToSkip) {
 2082       return TPResult::False;
 2084       return TPResult::True;
 2095     return TPResult::False;
 2101   if (isCXXDeclarationSpecifier(TPResult::False,
 2103              TPResult::True)
 2104     return TPResult::True;
 2106     return TPResult::False;
 2122     return TPResult::Ambiguous;
 2123   return TPResult::False;
tools/clang/lib/Parse/Parser.cpp
 1611       isTemplateArgumentList(1) == TPResult::False) {
 1947             isTemplateArgumentList(1) != TPResult::False) {