llvm/clang/lib/AST/CommentLexer.cpp

//===--- CommentLexer.cpp -------------------------------------------------===//
//
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
//
//===----------------------------------------------------------------------===//

#include "clang/AST/CommentLexer.h"
#include "clang/AST/CommentCommandTraits.h"
#include "clang/AST/CommentDiagnostic.h"
#include "clang/Basic/CharInfo.h"
#include "llvm/ADT/StringExtras.h"
#include "llvm/ADT/StringSwitch.h"
#include "llvm/Support/ConvertUTF.h"
#include "llvm/Support/ErrorHandling.h"

namespace clang {
namespace comments {

void Token::dump(const Lexer &L, const SourceManager &SM) const { … }

static inline bool isHTMLNamedCharacterReferenceCharacter(char C) { … }

static inline bool isHTMLDecimalCharacterReferenceCharacter(char C) { … }

static inline bool isHTMLHexCharacterReferenceCharacter(char C) { … }

static inline StringRef convertCodePointToUTF8(
                                      llvm::BumpPtrAllocator &Allocator,
                                      unsigned CodePoint) { … }

namespace {

#include "clang/AST/CommentHTMLTags.inc"
#include "clang/AST/CommentHTMLNamedCharacterReferences.inc"

} // end anonymous namespace

StringRef Lexer::resolveHTMLNamedCharacterReference(StringRef Name) const { … }

StringRef Lexer::resolveHTMLDecimalCharacterReference(StringRef Name) const { … }

StringRef Lexer::resolveHTMLHexCharacterReference(StringRef Name) const { … }

void Lexer::skipLineStartingDecorations() { … }

namespace {
/// Returns pointer to the first newline character in the string.
const char *findNewline(const char *BufferPtr, const char *BufferEnd) { … }

const char *skipNewline(const char *BufferPtr, const char *BufferEnd) { … }

const char *skipNamedCharacterReference(const char *BufferPtr,
                                        const char *BufferEnd) { … }

const char *skipDecimalCharacterReference(const char *BufferPtr,
                                          const char *BufferEnd) { … }

const char *skipHexCharacterReference(const char *BufferPtr,
                                      const char *BufferEnd) { … }

bool isHTMLIdentifierStartingCharacter(char C) { … }

bool isHTMLIdentifierCharacter(char C) { … }

const char *skipHTMLIdentifier(const char *BufferPtr, const char *BufferEnd) { … }

/// Skip HTML string quoted in single or double quotes.  Escaping quotes inside
/// string allowed.
///
/// Returns pointer to closing quote.
const char *skipHTMLQuotedString(const char *BufferPtr, const char *BufferEnd)
{ … }

const char *skipWhitespace(const char *BufferPtr, const char *BufferEnd) { … }

bool isWhitespace(const char *BufferPtr, const char *BufferEnd) { … }

bool isCommandNameStartCharacter(char C) { … }

bool isCommandNameCharacter(char C) { … }

const char *skipCommandName(const char *BufferPtr, const char *BufferEnd) { … }

/// Return the one past end pointer for BCPL comments.
/// Handles newlines escaped with backslash or trigraph for backslahs.
const char *findBCPLCommentEnd(const char *BufferPtr, const char *BufferEnd) { … }

/// Return the one past end pointer for C comments.
/// Very dumb, does not handle escaped newlines or trigraphs.
const char *findCCommentEnd(const char *BufferPtr, const char *BufferEnd) { … }

} // end anonymous namespace

void Lexer::formTokenWithChars(Token &Result, const char *TokEnd,
                               tok::TokenKind Kind) { … }

const char *Lexer::skipTextToken() { … }

void Lexer::lexCommentText(Token &T) { … }

void Lexer::setupAndLexVerbatimBlock(Token &T,
                                     const char *TextBegin,
                                     char Marker, const CommandInfo *Info) { … }

void Lexer::lexVerbatimBlockFirstLine(Token &T) { … }

void Lexer::lexVerbatimBlockBody(Token &T) { … }

void Lexer::setupAndLexVerbatimLine(Token &T, const char *TextBegin,
                                    const CommandInfo *Info) { … }

void Lexer::lexVerbatimLineText(Token &T) { … }

void Lexer::lexHTMLCharacterReference(Token &T) { … }

void Lexer::setupAndLexHTMLStartTag(Token &T) { … }

void Lexer::lexHTMLStartTag(Token &T) { … }

void Lexer::setupAndLexHTMLEndTag(Token &T) { … }

void Lexer::lexHTMLEndTag(Token &T) { … }

Lexer::Lexer(llvm::BumpPtrAllocator &Allocator, DiagnosticsEngine &Diags,
             const CommandTraits &Traits, SourceLocation FileLoc,
             const char *BufferStart, const char *BufferEnd, bool ParseCommands)
    : … { … }

void Lexer::lex(Token &T) { … }

StringRef Lexer::getSpelling(const Token &Tok,
                             const SourceManager &SourceMgr) const { … }

} // end namespace comments
} // end namespace clang