external/bsd/llvm/dist/clang/lib/AST/CommentParser.cpp

   1 //===--- CommentParser.cpp - Doxygen comment parser -----------------------===//
   2 //
   3 //                     The LLVM Compiler Infrastructure
   4 //
   5 // This file is distributed under the University of Illinois Open Source
   6 // License. See LICENSE.TXT for details.
   7 //
   8 //===----------------------------------------------------------------------===//
   9
  10 #include "clang/AST/CommentParser.h"
  11 #include "clang/AST/CommentCommandTraits.h"
  12 #include "clang/AST/CommentDiagnostic.h"
  13 #include "clang/AST/CommentSema.h"
  14 #include "clang/Basic/CharInfo.h"
  15 #include "clang/Basic/SourceManager.h"
  16 #include "llvm/Support/ErrorHandling.h"
  17
  18 namespace clang {
  19
  20 static inline bool isWhitespace(llvm::StringRef S) {
  21   for (StringRef::const_iterator I = S.begin(), E = S.end(); I != E; ++I) {
  22     if (!isWhitespace(*I))
  23       return false;
  24   }
  25   return true;
  26 }
  27
  28 namespace comments {
  29
  30 /// Re-lexes a sequence of tok::text tokens.
  31 class TextTokenRetokenizer {
  32   llvm::BumpPtrAllocator &Allocator;
  33   Parser &P;
  34
  35   /// This flag is set when there are no more tokens we can fetch from lexer.
  36   bool NoMoreInterestingTokens;
  37
  38   /// Token buffer: tokens we have processed and lookahead.
  39   SmallVector<Token, 16> Toks;
  40
  41   /// A position in \c Toks.
  42   struct Position {
  43     unsigned CurToken;
  44     const char *BufferStart;
  45     const char *BufferEnd;
  46     const char *BufferPtr;
  47     SourceLocation BufferStartLoc;
  48   };
  49
  50   /// Current position in Toks.
  51   Position Pos;
  52
  53   bool isEnd() const {
  54     return Pos.CurToken >= Toks.size();
  55   }
  56
  57   /// Sets up the buffer pointers to point to current token.
  58   void setupBuffer() {
  59     assert(!isEnd());
  60     const Token &Tok = Toks[Pos.CurToken];
  61
  62     Pos.BufferStart = Tok.getText().begin();
  63     Pos.BufferEnd = Tok.getText().end();
  64     Pos.BufferPtr = Pos.BufferStart;
  65     Pos.BufferStartLoc = Tok.getLocation();
  66   }
  67
  68   SourceLocation getSourceLocation() const {
  69     const unsigned CharNo = Pos.BufferPtr - Pos.BufferStart;
  70     return Pos.BufferStartLoc.getLocWithOffset(CharNo);
  71   }
  72
  73   char peek() const {
  74     assert(!isEnd());
  75     assert(Pos.BufferPtr != Pos.BufferEnd);
  76     return *Pos.BufferPtr;
  77   }
  78
  79   void consumeChar() {
  80     assert(!isEnd());
  81     assert(Pos.BufferPtr != Pos.BufferEnd);
  82     Pos.BufferPtr++;
  83     if (Pos.BufferPtr == Pos.BufferEnd) {
  84       Pos.CurToken++;
  85       if (isEnd() && !addToken())
  86         return;
  87
  88       assert(!isEnd());
  89       setupBuffer();
  90     }
  91   }
  92
  93   /// Add a token.
  94   /// Returns true on success, false if there are no interesting tokens to
  95   /// fetch from lexer.
  96   bool addToken() {
  97     if (NoMoreInterestingTokens)
  98       return false;
  99
 100     if (P.Tok.is(tok::newline)) {
 101       // If we see a single newline token between text tokens, skip it.
 102       Token Newline = P.Tok;
 103       P.consumeToken();
 104       if (P.Tok.isNot(tok::text)) {
 105         P.putBack(Newline);
 106         NoMoreInterestingTokens = true;
 107         return false;
 108       }
 109     }
 110     if (P.Tok.isNot(tok::text)) {
 111       NoMoreInterestingTokens = true;
 112       return false;
 113     }
 114
 115     Toks.push_back(P.Tok);
 116     P.consumeToken();
 117     if (Toks.size() == 1)
 118       setupBuffer();
 119     return true;
 120   }
 121
 122   void consumeWhitespace() {
 123     while (!isEnd()) {
 124       if (isWhitespace(peek()))
 125         consumeChar();
 126       else
 127         break;
 128     }
 129   }
 130
 131   void formTokenWithChars(Token &Result,
 132                           SourceLocation Loc,
 133                           const char *TokBegin,
 134                           unsigned TokLength,
 135                           StringRef Text) {
 136     Result.setLocation(Loc);
 137     Result.setKind(tok::text);
 138     Result.setLength(TokLength);
 139 #ifndef NDEBUG
 140     Result.TextPtr = "<UNSET>";
 141     Result.IntVal = 7;
 142 #endif
 143     Result.setText(Text);
 144   }
 145
 146 public:
 147   TextTokenRetokenizer(llvm::BumpPtrAllocator &Allocator, Parser &P):
 148       Allocator(Allocator), P(P), NoMoreInterestingTokens(false) {
 149     Pos.CurToken = 0;
 150     addToken();
 151   }
 152
 153   /// Extract a word -- sequence of non-whitespace characters.
 154   bool lexWord(Token &Tok) {
 155     if (isEnd())
 156       return false;
 157
 158     Position SavedPos = Pos;
 159
 160     consumeWhitespace();
 161     SmallString<32> WordText;
 162     const char *WordBegin = Pos.BufferPtr;
 163     SourceLocation Loc = getSourceLocation();
 164     while (!isEnd()) {
 165       const char C = peek();
 166       if (!isWhitespace(C)) {
 167         WordText.push_back(C);
 168         consumeChar();
 169       } else
 170         break;
 171     }
 172     const unsigned Length = WordText.size();
 173     if (Length == 0) {
 174       Pos = SavedPos;
 175       return false;
 176     }
 177
 178     char *TextPtr = Allocator.Allocate<char>(Length + 1);
 179
 180     memcpy(TextPtr, WordText.c_str(), Length + 1);
 181     StringRef Text = StringRef(TextPtr, Length);
 182
 183     formTokenWithChars(Tok, Loc, WordBegin, Length, Text);
 184     return true;
 185   }
 186
 187   bool lexDelimitedSeq(Token &Tok, char OpenDelim, char CloseDelim) {
 188     if (isEnd())
 189       return false;
 190
 191     Position SavedPos = Pos;
 192
 193     consumeWhitespace();
 194     SmallString<32> WordText;
 195     const char *WordBegin = Pos.BufferPtr;
 196     SourceLocation Loc = getSourceLocation();
 197     bool Error = false;
 198     if (!isEnd()) {
 199       const char C = peek();
 200       if (C == OpenDelim) {
 201         WordText.push_back(C);
 202         consumeChar();
 203       } else
 204         Error = true;
 205     }
 206     char C = '\0';
 207     while (!Error && !isEnd()) {
 208       C = peek();
 209       WordText.push_back(C);
 210       consumeChar();
 211       if (C == CloseDelim)
 212         break;
 213     }
 214     if (!Error && C != CloseDelim)
 215       Error = true;
 216
 217     if (Error) {
 218       Pos = SavedPos;
 219       return false;
 220     }
 221
 222     const unsigned Length = WordText.size();
 223     char *TextPtr = Allocator.Allocate<char>(Length + 1);
 224
 225     memcpy(TextPtr, WordText.c_str(), Length + 1);
 226     StringRef Text = StringRef(TextPtr, Length);
 227
 228     formTokenWithChars(Tok, Loc, WordBegin,
 229                        Pos.BufferPtr - WordBegin, Text);
 230     return true;
 231   }
 232
 233   /// Put back tokens that we didn't consume.
 234   void putBackLeftoverTokens() {
 235     if (isEnd())
 236       return;
 237
 238     bool HavePartialTok = false;
 239     Token PartialTok;
 240     if (Pos.BufferPtr != Pos.BufferStart) {
 241       formTokenWithChars(PartialTok, getSourceLocation(),
 242                          Pos.BufferPtr, Pos.BufferEnd - Pos.BufferPtr,
 243                          StringRef(Pos.BufferPtr,
 244                                    Pos.BufferEnd - Pos.BufferPtr));
 245       HavePartialTok = true;
 246       Pos.CurToken++;
 247     }
 248
 249     P.putBack(llvm::makeArrayRef(Toks.begin() + Pos.CurToken, Toks.end()));
 250     Pos.CurToken = Toks.size();
 251
 252     if (HavePartialTok)
 253       P.putBack(PartialTok);
 254   }
 255 };
 256
 257 Parser::Parser(Lexer &L, Sema &S, llvm::BumpPtrAllocator &Allocator,
 258                const SourceManager &SourceMgr, DiagnosticsEngine &Diags,
 259                const CommandTraits &Traits):
 260     L(L), S(S), Allocator(Allocator), SourceMgr(SourceMgr), Diags(Diags),
 261     Traits(Traits) {
 262   consumeToken();
 263 }
 264
 265 void Parser::parseParamCommandArgs(ParamCommandComment *PC,
 266                                    TextTokenRetokenizer &Retokenizer) {
 267   Token Arg;
 268   // Check if argument looks like direction specification: [dir]
 269   // e.g., [in], [out], [in,out]
 270   if (Retokenizer.lexDelimitedSeq(Arg, '[', ']'))
 271     S.actOnParamCommandDirectionArg(PC,
 272                                     Arg.getLocation(),
 273                                     Arg.getEndLocation(),
 274                                     Arg.getText());
 275
 276   if (Retokenizer.lexWord(Arg))
 277     S.actOnParamCommandParamNameArg(PC,
 278                                     Arg.getLocation(),
 279                                     Arg.getEndLocation(),
 280                                     Arg.getText());
 281 }
 282
 283 void Parser::parseTParamCommandArgs(TParamCommandComment *TPC,
 284                                     TextTokenRetokenizer &Retokenizer) {
 285   Token Arg;
 286   if (Retokenizer.lexWord(Arg))
 287     S.actOnTParamCommandParamNameArg(TPC,
 288                                      Arg.getLocation(),
 289                                      Arg.getEndLocation(),
 290                                      Arg.getText());
 291 }
 292
 293 void Parser::parseBlockCommandArgs(BlockCommandComment *BC,
 294                                    TextTokenRetokenizer &Retokenizer,
 295                                    unsigned NumArgs) {
 296   typedef BlockCommandComment::Argument Argument;
 297   Argument *Args =
 298       new (Allocator.Allocate<Argument>(NumArgs)) Argument[NumArgs];
 299   unsigned ParsedArgs = 0;
 300   Token Arg;
 301   while (ParsedArgs < NumArgs && Retokenizer.lexWord(Arg)) {
 302     Args[ParsedArgs] = Argument(SourceRange(Arg.getLocation(),
 303                                             Arg.getEndLocation()),
 304                                 Arg.getText());
 305     ParsedArgs++;
 306   }
 307
 308   S.actOnBlockCommandArgs(BC, llvm::makeArrayRef(Args, ParsedArgs));
 309 }
 310
 311 BlockCommandComment *Parser::parseBlockCommand() {
 312   assert(Tok.is(tok::backslash_command) || Tok.is(tok::at_command));
 313
 314   ParamCommandComment *PC = nullptr;
 315   TParamCommandComment *TPC = nullptr;
 316   BlockCommandComment *BC = nullptr;
 317   const CommandInfo *Info = Traits.getCommandInfo(Tok.getCommandID());
 318   CommandMarkerKind CommandMarker =
 319       Tok.is(tok::backslash_command) ? CMK_Backslash : CMK_At;
 320   if (Info->IsParamCommand) {
 321     PC = S.actOnParamCommandStart(Tok.getLocation(),
 322                                   Tok.getEndLocation(),
 323                                   Tok.getCommandID(),
 324                                   CommandMarker);
 325   } else if (Info->IsTParamCommand) {
 326     TPC = S.actOnTParamCommandStart(Tok.getLocation(),
 327                                     Tok.getEndLocation(),
 328                                     Tok.getCommandID(),
 329                                     CommandMarker);
 330   } else {
 331     BC = S.actOnBlockCommandStart(Tok.getLocation(),
 332                                   Tok.getEndLocation(),
 333                                   Tok.getCommandID(),
 334                                   CommandMarker);
 335   }
 336   consumeToken();
 337
 338   if (isTokBlockCommand()) {
 339     // Block command ahead.  We can't nest block commands, so pretend that this
 340     // command has an empty argument.
 341     ParagraphComment *Paragraph = S.actOnParagraphComment(None);
 342     if (PC) {
 343       S.actOnParamCommandFinish(PC, Paragraph);
 344       return PC;
 345     } else if (TPC) {
 346       S.actOnTParamCommandFinish(TPC, Paragraph);
 347       return TPC;
 348     } else {
 349       S.actOnBlockCommandFinish(BC, Paragraph);
 350       return BC;
 351     }
 352   }
 353
 354   if (PC || TPC || Info->NumArgs > 0) {
 355     // In order to parse command arguments we need to retokenize a few
 356     // following text tokens.
 357     TextTokenRetokenizer Retokenizer(Allocator, *this);
 358
 359     if (PC)
 360       parseParamCommandArgs(PC, Retokenizer);
 361     else if (TPC)
 362       parseTParamCommandArgs(TPC, Retokenizer);
 363     else
 364       parseBlockCommandArgs(BC, Retokenizer, Info->NumArgs);
 365
 366     Retokenizer.putBackLeftoverTokens();
 367   }
 368
 369   // If there's a block command ahead, we will attach an empty paragraph to
 370   // this command.
 371   bool EmptyParagraph = false;
 372   if (isTokBlockCommand())
 373     EmptyParagraph = true;
 374   else if (Tok.is(tok::newline)) {
 375     Token PrevTok = Tok;
 376     consumeToken();
 377     EmptyParagraph = isTokBlockCommand();
 378     putBack(PrevTok);
 379   }
 380
 381   ParagraphComment *Paragraph;
 382   if (EmptyParagraph)
 383     Paragraph = S.actOnParagraphComment(None);
 384   else {
 385     BlockContentComment *Block = parseParagraphOrBlockCommand();
 386     // Since we have checked for a block command, we should have parsed a
 387     // paragraph.
 388     Paragraph = cast<ParagraphComment>(Block);
 389   }
 390
 391   if (PC) {
 392     S.actOnParamCommandFinish(PC, Paragraph);
 393     return PC;
 394   } else if (TPC) {
 395     S.actOnTParamCommandFinish(TPC, Paragraph);
 396     return TPC;
 397   } else {
 398     S.actOnBlockCommandFinish(BC, Paragraph);
 399     return BC;
 400   }
 401 }
 402
 403 InlineCommandComment *Parser::parseInlineCommand() {
 404   assert(Tok.is(tok::backslash_command) || Tok.is(tok::at_command));
 405
 406   const Token CommandTok = Tok;
 407   consumeToken();
 408
 409   TextTokenRetokenizer Retokenizer(Allocator, *this);
 410
 411   Token ArgTok;
 412   bool ArgTokValid = Retokenizer.lexWord(ArgTok);
 413
 414   InlineCommandComment *IC;
 415   if (ArgTokValid) {
 416     IC = S.actOnInlineCommand(CommandTok.getLocation(),
 417                               CommandTok.getEndLocation(),
 418                               CommandTok.getCommandID(),
 419                               ArgTok.getLocation(),
 420                               ArgTok.getEndLocation(),
 421                               ArgTok.getText());
 422   } else {
 423     IC = S.actOnInlineCommand(CommandTok.getLocation(),
 424                               CommandTok.getEndLocation(),
 425                               CommandTok.getCommandID());
 426   }
 427
 428   Retokenizer.putBackLeftoverTokens();
 429
 430   return IC;
 431 }
 432
 433 HTMLStartTagComment *Parser::parseHTMLStartTag() {
 434   assert(Tok.is(tok::html_start_tag));
 435   HTMLStartTagComment *HST =
 436       S.actOnHTMLStartTagStart(Tok.getLocation(),
 437                                Tok.getHTMLTagStartName());
 438   consumeToken();
 439
 440   SmallVector<HTMLStartTagComment::Attribute, 2> Attrs;
 441   while (true) {
 442     switch (Tok.getKind()) {
 443     case tok::html_ident: {
 444       Token Ident = Tok;
 445       consumeToken();
 446       if (Tok.isNot(tok::html_equals)) {
 447         Attrs.push_back(HTMLStartTagComment::Attribute(Ident.getLocation(),
 448                                                        Ident.getHTMLIdent()));
 449         continue;
 450       }
 451       Token Equals = Tok;
 452       consumeToken();
 453       if (Tok.isNot(tok::html_quoted_string)) {
 454         Diag(Tok.getLocation(),
 455              diag::warn_doc_html_start_tag_expected_quoted_string)
 456           << SourceRange(Equals.getLocation());
 457         Attrs.push_back(HTMLStartTagComment::Attribute(Ident.getLocation(),
 458                                                        Ident.getHTMLIdent()));
 459         while (Tok.is(tok::html_equals) ||
 460                Tok.is(tok::html_quoted_string))
 461           consumeToken();
 462         continue;
 463       }
 464       Attrs.push_back(HTMLStartTagComment::Attribute(
 465                               Ident.getLocation(),
 466                               Ident.getHTMLIdent(),
 467                               Equals.getLocation(),
 468                               SourceRange(Tok.getLocation(),
 469                                           Tok.getEndLocation()),
 470                               Tok.getHTMLQuotedString()));
 471       consumeToken();
 472       continue;
 473     }
 474
 475     case tok::html_greater:
 476       S.actOnHTMLStartTagFinish(HST,
 477                                 S.copyArray(llvm::makeArrayRef(Attrs)),
 478                                 Tok.getLocation(),
 479                                 /* IsSelfClosing = */ false);
 480       consumeToken();
 481       return HST;
 482
 483     case tok::html_slash_greater:
 484       S.actOnHTMLStartTagFinish(HST,
 485                                 S.copyArray(llvm::makeArrayRef(Attrs)),
 486                                 Tok.getLocation(),
 487                                 /* IsSelfClosing = */ true);
 488       consumeToken();
 489       return HST;
 490
 491     case tok::html_equals:
 492     case tok::html_quoted_string:
 493       Diag(Tok.getLocation(),
 494            diag::warn_doc_html_start_tag_expected_ident_or_greater);
 495       while (Tok.is(tok::html_equals) ||
 496              Tok.is(tok::html_quoted_string))
 497         consumeToken();
 498       if (Tok.is(tok::html_ident) ||
 499           Tok.is(tok::html_greater) ||
 500           Tok.is(tok::html_slash_greater))
 501         continue;
 502
 503       S.actOnHTMLStartTagFinish(HST,
 504                                 S.copyArray(llvm::makeArrayRef(Attrs)),
 505                                 SourceLocation(),
 506                                 /* IsSelfClosing = */ false);
 507       return HST;
 508
 509     default:
 510       // Not a token from an HTML start tag.  Thus HTML tag prematurely ended.
 511       S.actOnHTMLStartTagFinish(HST,
 512                                 S.copyArray(llvm::makeArrayRef(Attrs)),
 513                                 SourceLocation(),
 514                                 /* IsSelfClosing = */ false);
 515       bool StartLineInvalid;
 516       const unsigned StartLine = SourceMgr.getPresumedLineNumber(
 517                                                   HST->getLocation(),
 518                                                   &StartLineInvalid);
 519       bool EndLineInvalid;
 520       const unsigned EndLine = SourceMgr.getPresumedLineNumber(
 521                                                   Tok.getLocation(),
 522                                                   &EndLineInvalid);
 523       if (StartLineInvalid || EndLineInvalid || StartLine == EndLine)
 524         Diag(Tok.getLocation(),
 525              diag::warn_doc_html_start_tag_expected_ident_or_greater)
 526           << HST->getSourceRange();
 527       else {
 528         Diag(Tok.getLocation(),
 529              diag::warn_doc_html_start_tag_expected_ident_or_greater);
 530         Diag(HST->getLocation(), diag::note_doc_html_tag_started_here)
 531           << HST->getSourceRange();
 532       }
 533       return HST;
 534     }
 535   }
 536 }
 537
 538 HTMLEndTagComment *Parser::parseHTMLEndTag() {
 539   assert(Tok.is(tok::html_end_tag));
 540   Token TokEndTag = Tok;
 541   consumeToken();
 542   SourceLocation Loc;
 543   if (Tok.is(tok::html_greater)) {
 544     Loc = Tok.getLocation();
 545     consumeToken();
 546   }
 547
 548   return S.actOnHTMLEndTag(TokEndTag.getLocation(),
 549                            Loc,
 550                            TokEndTag.getHTMLTagEndName());
 551 }
 552
 553 BlockContentComment *Parser::parseParagraphOrBlockCommand() {
 554   SmallVector<InlineContentComment *, 8> Content;
 555
 556   while (true) {
 557     switch (Tok.getKind()) {
 558     case tok::verbatim_block_begin:
 559     case tok::verbatim_line_name:
 560     case tok::eof:
 561       assert(Content.size() != 0);
 562       break; // Block content or EOF ahead, finish this parapgaph.
 563
 564     case tok::unknown_command:
 565       Content.push_back(S.actOnUnknownCommand(Tok.getLocation(),
 566                                               Tok.getEndLocation(),
 567                                               Tok.getUnknownCommandName()));
 568       consumeToken();
 569       continue;
 570
 571     case tok::backslash_command:
 572     case tok::at_command: {
 573       const CommandInfo *Info = Traits.getCommandInfo(Tok.getCommandID());
 574       if (Info->IsBlockCommand) {
 575         if (Content.size() == 0)
 576           return parseBlockCommand();
 577         break; // Block command ahead, finish this parapgaph.
 578       }
 579       if (Info->IsVerbatimBlockEndCommand) {
 580         Diag(Tok.getLocation(),
 581              diag::warn_verbatim_block_end_without_start)
 582           << Tok.is(tok::at_command)
 583           << Info->Name
 584           << SourceRange(Tok.getLocation(), Tok.getEndLocation());
 585         consumeToken();
 586         continue;
 587       }
 588       if (Info->IsUnknownCommand) {
 589         Content.push_back(S.actOnUnknownCommand(Tok.getLocation(),
 590                                                 Tok.getEndLocation(),
 591                                                 Info->getID()));
 592         consumeToken();
 593         continue;
 594       }
 595       assert(Info->IsInlineCommand);
 596       Content.push_back(parseInlineCommand());
 597       continue;
 598     }
 599
 600     case tok::newline: {
 601       consumeToken();
 602       if (Tok.is(tok::newline) || Tok.is(tok::eof)) {
 603         consumeToken();
 604         break; // Two newlines -- end of paragraph.
 605       }
 606       // Also allow [tok::newline, tok::text, tok::newline] if the middle
 607       // tok::text is just whitespace.
 608       if (Tok.is(tok::text) && isWhitespace(Tok.getText())) {
 609         Token WhitespaceTok = Tok;
 610         consumeToken();
 611         if (Tok.is(tok::newline) || Tok.is(tok::eof)) {
 612           consumeToken();
 613           break;
 614         }
 615         // We have [tok::newline, tok::text, non-newline].  Put back tok::text.
 616         putBack(WhitespaceTok);
 617       }
 618       if (Content.size() > 0)
 619         Content.back()->addTrailingNewline();
 620       continue;
 621     }
 622
 623     // Don't deal with HTML tag soup now.
 624     case tok::html_start_tag:
 625       Content.push_back(parseHTMLStartTag());
 626       continue;
 627
 628     case tok::html_end_tag:
 629       Content.push_back(parseHTMLEndTag());
 630       continue;
 631
 632     case tok::text:
 633       Content.push_back(S.actOnText(Tok.getLocation(),
 634                                     Tok.getEndLocation(),
 635                                     Tok.getText()));
 636       consumeToken();
 637       continue;
 638
 639     case tok::verbatim_block_line:
 640     case tok::verbatim_block_end:
 641     case tok::verbatim_line_text:
 642     case tok::html_ident:
 643     case tok::html_equals:
 644     case tok::html_quoted_string:
 645     case tok::html_greater:
 646     case tok::html_slash_greater:
 647       llvm_unreachable("should not see this token");
 648     }
 649     break;
 650   }
 651
 652   return S.actOnParagraphComment(S.copyArray(llvm::makeArrayRef(Content)));
 653 }
 654
 655 VerbatimBlockComment *Parser::parseVerbatimBlock() {
 656   assert(Tok.is(tok::verbatim_block_begin));
 657
 658   VerbatimBlockComment *VB =
 659       S.actOnVerbatimBlockStart(Tok.getLocation(),
 660                                 Tok.getVerbatimBlockID());
 661   consumeToken();
 662
 663   // Don't create an empty line if verbatim opening command is followed
 664   // by a newline.
 665   if (Tok.is(tok::newline))
 666     consumeToken();
 667
 668   SmallVector<VerbatimBlockLineComment *, 8> Lines;
 669   while (Tok.is(tok::verbatim_block_line) ||
 670          Tok.is(tok::newline)) {
 671     VerbatimBlockLineComment *Line;
 672     if (Tok.is(tok::verbatim_block_line)) {
 673       Line = S.actOnVerbatimBlockLine(Tok.getLocation(),
 674                                       Tok.getVerbatimBlockText());
 675       consumeToken();
 676       if (Tok.is(tok::newline)) {
 677         consumeToken();
 678       }
 679     } else {
 680       // Empty line, just a tok::newline.
 681       Line = S.actOnVerbatimBlockLine(Tok.getLocation(), "");
 682       consumeToken();
 683     }
 684     Lines.push_back(Line);
 685   }
 686
 687   if (Tok.is(tok::verbatim_block_end)) {
 688     const CommandInfo *Info = Traits.getCommandInfo(Tok.getVerbatimBlockID());
 689     S.actOnVerbatimBlockFinish(VB, Tok.getLocation(),
 690                                Info->Name,
 691                                S.copyArray(llvm::makeArrayRef(Lines)));
 692     consumeToken();
 693   } else {
 694     // Unterminated \\verbatim block
 695     S.actOnVerbatimBlockFinish(VB, SourceLocation(), "",
 696                                S.copyArray(llvm::makeArrayRef(Lines)));
 697   }
 698
 699   return VB;
 700 }
 701
 702 VerbatimLineComment *Parser::parseVerbatimLine() {
 703   assert(Tok.is(tok::verbatim_line_name));
 704
 705   Token NameTok = Tok;
 706   consumeToken();
 707
 708   SourceLocation TextBegin;
 709   StringRef Text;
 710   // Next token might not be a tok::verbatim_line_text if verbatim line
 711   // starting command comes just before a newline or comment end.
 712   if (Tok.is(tok::verbatim_line_text)) {
 713     TextBegin = Tok.getLocation();
 714     Text = Tok.getVerbatimLineText();
 715   } else {
 716     TextBegin = NameTok.getEndLocation();
 717     Text = "";
 718   }
 719
 720   VerbatimLineComment *VL = S.actOnVerbatimLine(NameTok.getLocation(),
 721                                                 NameTok.getVerbatimLineID(),
 722                                                 TextBegin,
 723                                                 Text);
 724   consumeToken();
 725   return VL;
 726 }
 727
 728 BlockContentComment *Parser::parseBlockContent() {
 729   switch (Tok.getKind()) {
 730   case tok::text:
 731   case tok::unknown_command:
 732   case tok::backslash_command:
 733   case tok::at_command:
 734   case tok::html_start_tag:
 735   case tok::html_end_tag:
 736     return parseParagraphOrBlockCommand();
 737
 738   case tok::verbatim_block_begin:
 739     return parseVerbatimBlock();
 740
 741   case tok::verbatim_line_name:
 742     return parseVerbatimLine();
 743
 744   case tok::eof:
 745   case tok::newline:
 746   case tok::verbatim_block_line:
 747   case tok::verbatim_block_end:
 748   case tok::verbatim_line_text:
 749   case tok::html_ident:
 750   case tok::html_equals:
 751   case tok::html_quoted_string:
 752   case tok::html_greater:
 753   case tok::html_slash_greater:
 754     llvm_unreachable("should not see this token");
 755   }
 756   llvm_unreachable("bogus token kind");
 757 }
 758
 759 FullComment *Parser::parseFullComment() {
 760   // Skip newlines at the beginning of the comment.
 761   while (Tok.is(tok::newline))
 762     consumeToken();
 763
 764   SmallVector<BlockContentComment *, 8> Blocks;
 765   while (Tok.isNot(tok::eof)) {
 766     Blocks.push_back(parseBlockContent());
 767
 768     // Skip extra newlines after paragraph end.
 769     while (Tok.is(tok::newline))
 770       consumeToken();
 771   }
 772   return S.actOnFullComment(S.copyArray(llvm::makeArrayRef(Blocks)));
 773 }
 774
 775 } // end namespace comments
 776 } // end namespace clang