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