clang-tools 17.0.0git
HTMLGenerator.cpp
Go to the documentation of this file.
1//===-- HTMLGenerator.cpp - HTML Generator ----------------------*- C++ -*-===//
2//
3// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
4// See https://llvm.org/LICENSE.txt for license information.
5// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
6//
7//===----------------------------------------------------------------------===//
8
9#include "Generators.h"
10#include "Representation.h"
11#include "clang/Basic/Version.h"
12#include "llvm/ADT/StringExtras.h"
13#include "llvm/ADT/StringRef.h"
14#include "llvm/ADT/StringSet.h"
15#include "llvm/Support/FileSystem.h"
16#include "llvm/Support/JSON.h"
17#include "llvm/Support/Path.h"
18#include "llvm/Support/raw_ostream.h"
19#include <optional>
20#include <string>
21
22using namespace llvm;
23
24namespace clang {
25namespace doc {
26
27namespace {
28
29class HTMLTag {
30public:
31 // Any other tag can be added if required
32 enum TagType {
33 TAG_A,
34 TAG_DIV,
35 TAG_FOOTER,
36 TAG_H1,
37 TAG_H2,
38 TAG_H3,
39 TAG_HEADER,
40 TAG_LI,
41 TAG_LINK,
42 TAG_MAIN,
43 TAG_META,
44 TAG_OL,
45 TAG_P,
46 TAG_SCRIPT,
47 TAG_SPAN,
48 TAG_TITLE,
49 TAG_UL,
50 };
51
52 HTMLTag() = default;
53 constexpr HTMLTag(TagType Value) : Value(Value) {}
54
55 operator TagType() const { return Value; }
56 operator bool() = delete;
57
58 bool IsSelfClosing() const;
59 llvm::SmallString<16> ToString() const;
60
61private:
62 TagType Value;
63};
64
65enum NodeType {
66 NODE_TEXT,
67 NODE_TAG,
68};
69
70struct HTMLNode {
71 HTMLNode(NodeType Type) : Type(Type) {}
72 virtual ~HTMLNode() = default;
73
74 virtual void Render(llvm::raw_ostream &OS, int IndentationLevel) = 0;
75 NodeType Type; // Type of node
76};
77
78struct TextNode : public HTMLNode {
79 TextNode(const Twine &Text)
80 : HTMLNode(NodeType::NODE_TEXT), Text(Text.str()) {}
81
82 std::string Text; // Content of node
83 void Render(llvm::raw_ostream &OS, int IndentationLevel) override;
84};
85
86struct TagNode : public HTMLNode {
87 TagNode(HTMLTag Tag) : HTMLNode(NodeType::NODE_TAG), Tag(Tag) {}
88 TagNode(HTMLTag Tag, const Twine &Text) : TagNode(Tag) {
89 Children.emplace_back(std::make_unique<TextNode>(Text.str()));
90 }
91
92 HTMLTag Tag; // Name of HTML Tag (p, div, h1)
93 std::vector<std::unique_ptr<HTMLNode>> Children; // List of child nodes
94 std::vector<std::pair<std::string, std::string>>
95 Attributes; // List of key-value attributes for tag
96
97 void Render(llvm::raw_ostream &OS, int IndentationLevel) override;
98};
99
100constexpr const char *kDoctypeDecl = "<!DOCTYPE html>";
101
102struct HTMLFile {
103 std::vector<std::unique_ptr<HTMLNode>> Children; // List of child nodes
104 void Render(llvm::raw_ostream &OS) {
105 OS << kDoctypeDecl << "\n";
106 for (const auto &C : Children) {
107 C->Render(OS, 0);
108 OS << "\n";
109 }
110 }
111};
112
113} // namespace
114
115bool HTMLTag::IsSelfClosing() const {
116 switch (Value) {
117 case HTMLTag::TAG_META:
118 case HTMLTag::TAG_LINK:
119 return true;
120 case HTMLTag::TAG_A:
121 case HTMLTag::TAG_DIV:
122 case HTMLTag::TAG_FOOTER:
123 case HTMLTag::TAG_H1:
124 case HTMLTag::TAG_H2:
125 case HTMLTag::TAG_H3:
126 case HTMLTag::TAG_HEADER:
127 case HTMLTag::TAG_LI:
128 case HTMLTag::TAG_MAIN:
129 case HTMLTag::TAG_OL:
130 case HTMLTag::TAG_P:
131 case HTMLTag::TAG_SCRIPT:
132 case HTMLTag::TAG_SPAN:
133 case HTMLTag::TAG_TITLE:
134 case HTMLTag::TAG_UL:
135 return false;
136 }
137 llvm_unreachable("Unhandled HTMLTag::TagType");
138}
139
140llvm::SmallString<16> HTMLTag::ToString() const {
141 switch (Value) {
142 case HTMLTag::TAG_A:
143 return llvm::SmallString<16>("a");
144 case HTMLTag::TAG_DIV:
145 return llvm::SmallString<16>("div");
146 case HTMLTag::TAG_FOOTER:
147 return llvm::SmallString<16>("footer");
148 case HTMLTag::TAG_H1:
149 return llvm::SmallString<16>("h1");
150 case HTMLTag::TAG_H2:
151 return llvm::SmallString<16>("h2");
152 case HTMLTag::TAG_H3:
153 return llvm::SmallString<16>("h3");
154 case HTMLTag::TAG_HEADER:
155 return llvm::SmallString<16>("header");
156 case HTMLTag::TAG_LI:
157 return llvm::SmallString<16>("li");
158 case HTMLTag::TAG_LINK:
159 return llvm::SmallString<16>("link");
160 case HTMLTag::TAG_MAIN:
161 return llvm::SmallString<16>("main");
162 case HTMLTag::TAG_META:
163 return llvm::SmallString<16>("meta");
164 case HTMLTag::TAG_OL:
165 return llvm::SmallString<16>("ol");
166 case HTMLTag::TAG_P:
167 return llvm::SmallString<16>("p");
168 case HTMLTag::TAG_SCRIPT:
169 return llvm::SmallString<16>("script");
170 case HTMLTag::TAG_SPAN:
171 return llvm::SmallString<16>("span");
172 case HTMLTag::TAG_TITLE:
173 return llvm::SmallString<16>("title");
174 case HTMLTag::TAG_UL:
175 return llvm::SmallString<16>("ul");
176 }
177 llvm_unreachable("Unhandled HTMLTag::TagType");
178}
179
180void TextNode::Render(llvm::raw_ostream &OS, int IndentationLevel) {
181 OS.indent(IndentationLevel * 2);
182 printHTMLEscaped(Text, OS);
183}
184
185void TagNode::Render(llvm::raw_ostream &OS, int IndentationLevel) {
186 // Children nodes are rendered in the same line if all of them are text nodes
187 bool InlineChildren = true;
188 for (const auto &C : Children)
189 if (C->Type == NodeType::NODE_TAG) {
190 InlineChildren = false;
191 break;
192 }
193 OS.indent(IndentationLevel * 2);
194 OS << "<" << Tag.ToString();
195 for (const auto &A : Attributes)
196 OS << " " << A.first << "=\"" << A.second << "\"";
197 if (Tag.IsSelfClosing()) {
198 OS << "/>";
199 return;
200 }
201 OS << ">";
202 if (!InlineChildren)
203 OS << "\n";
204 bool NewLineRendered = true;
205 for (const auto &C : Children) {
206 int ChildrenIndentation =
207 InlineChildren || !NewLineRendered ? 0 : IndentationLevel + 1;
208 C->Render(OS, ChildrenIndentation);
209 if (!InlineChildren && (C == Children.back() ||
210 (C->Type != NodeType::NODE_TEXT ||
211 (&C + 1)->get()->Type != NodeType::NODE_TEXT))) {
212 OS << "\n";
213 NewLineRendered = true;
214 } else
215 NewLineRendered = false;
216 }
217 if (!InlineChildren)
218 OS.indent(IndentationLevel * 2);
219 OS << "</" << Tag.ToString() << ">";
220}
221
222template <typename Derived, typename Base,
223 typename = std::enable_if<std::is_base_of<Derived, Base>::value>>
224static void AppendVector(std::vector<Derived> &&New,
225 std::vector<Base> &Original) {
226 std::move(New.begin(), New.end(), std::back_inserter(Original));
227}
228
229// Compute the relative path from an Origin directory to a Destination directory
230static SmallString<128> computeRelativePath(StringRef Destination,
231 StringRef Origin) {
232 // If Origin is empty, the relative path to the Destination is its complete
233 // path.
234 if (Origin.empty())
235 return Destination;
236
237 // The relative path is an empty path if both directories are the same.
238 if (Destination == Origin)
239 return {};
240
241 // These iterators iterate through each of their parent directories
242 llvm::sys::path::const_iterator FileI = llvm::sys::path::begin(Destination);
243 llvm::sys::path::const_iterator FileE = llvm::sys::path::end(Destination);
244 llvm::sys::path::const_iterator DirI = llvm::sys::path::begin(Origin);
245 llvm::sys::path::const_iterator DirE = llvm::sys::path::end(Origin);
246 // Advance both iterators until the paths differ. Example:
247 // Destination = A/B/C/D
248 // Origin = A/B/E/F
249 // FileI will point to C and DirI to E. The directories behind them is the
250 // directory they share (A/B).
251 while (FileI != FileE && DirI != DirE && *FileI == *DirI) {
252 ++FileI;
253 ++DirI;
254 }
255 SmallString<128> Result; // This will hold the resulting path.
256 // Result has to go up one directory for each of the remaining directories in
257 // Origin
258 while (DirI != DirE) {
259 llvm::sys::path::append(Result, "..");
260 ++DirI;
261 }
262 // Result has to append each of the remaining directories in Destination
263 while (FileI != FileE) {
264 llvm::sys::path::append(Result, *FileI);
265 ++FileI;
266 }
267 return Result;
268}
269
270// HTML generation
271
272static std::vector<std::unique_ptr<TagNode>>
273genStylesheetsHTML(StringRef InfoPath, const ClangDocContext &CDCtx) {
274 std::vector<std::unique_ptr<TagNode>> Out;
275 for (const auto &FilePath : CDCtx.UserStylesheets) {
276 auto LinkNode = std::make_unique<TagNode>(HTMLTag::TAG_LINK);
277 LinkNode->Attributes.emplace_back("rel", "stylesheet");
278 SmallString<128> StylesheetPath = computeRelativePath("", InfoPath);
279 llvm::sys::path::append(StylesheetPath,
280 llvm::sys::path::filename(FilePath));
281 // Paths in HTML must be in posix-style
282 llvm::sys::path::native(StylesheetPath, llvm::sys::path::Style::posix);
283 LinkNode->Attributes.emplace_back("href", std::string(StylesheetPath.str()));
284 Out.emplace_back(std::move(LinkNode));
285 }
286 return Out;
287}
288
289static std::vector<std::unique_ptr<TagNode>>
290genJsScriptsHTML(StringRef InfoPath, const ClangDocContext &CDCtx) {
291 std::vector<std::unique_ptr<TagNode>> Out;
292 for (const auto &FilePath : CDCtx.JsScripts) {
293 auto ScriptNode = std::make_unique<TagNode>(HTMLTag::TAG_SCRIPT);
294 SmallString<128> ScriptPath = computeRelativePath("", InfoPath);
295 llvm::sys::path::append(ScriptPath, llvm::sys::path::filename(FilePath));
296 // Paths in HTML must be in posix-style
297 llvm::sys::path::native(ScriptPath, llvm::sys::path::Style::posix);
298 ScriptNode->Attributes.emplace_back("src", std::string(ScriptPath.str()));
299 Out.emplace_back(std::move(ScriptNode));
300 }
301 return Out;
302}
303
304static std::unique_ptr<TagNode> genLink(const Twine &Text, const Twine &Link) {
305 auto LinkNode = std::make_unique<TagNode>(HTMLTag::TAG_A, Text);
306 LinkNode->Attributes.emplace_back("href", Link.str());
307 return LinkNode;
308}
309
310static std::unique_ptr<HTMLNode>
311genReference(const Reference &Type, StringRef CurrentDirectory,
312 std::optional<StringRef> JumpToSection = std::nullopt) {
313 if (Type.Path.empty()) {
314 if (!JumpToSection)
315 return std::make_unique<TextNode>(Type.Name);
316 else
317 return genLink(Type.Name, "#" + *JumpToSection);
318 }
319 llvm::SmallString<64> Path = Type.getRelativeFilePath(CurrentDirectory);
320 llvm::sys::path::append(Path, Type.getFileBaseName() + ".html");
321
322 // Paths in HTML must be in posix-style
323 llvm::sys::path::native(Path, llvm::sys::path::Style::posix);
324 if (JumpToSection)
325 Path += ("#" + *JumpToSection).str();
326 return genLink(Type.Name, Path);
327}
328
329static std::vector<std::unique_ptr<HTMLNode>>
331 const StringRef &CurrentDirectory) {
332 std::vector<std::unique_ptr<HTMLNode>> Out;
333 for (const auto &R : Refs) {
334 if (&R != Refs.begin())
335 Out.emplace_back(std::make_unique<TextNode>(", "));
336 Out.emplace_back(genReference(R, CurrentDirectory));
337 }
338 return Out;
339}
340
341static std::vector<std::unique_ptr<TagNode>>
342genHTML(const EnumInfo &I, const ClangDocContext &CDCtx);
343static std::vector<std::unique_ptr<TagNode>>
344genHTML(const FunctionInfo &I, const ClangDocContext &CDCtx,
345 StringRef ParentInfoDir);
346
347static std::vector<std::unique_ptr<TagNode>>
348genEnumsBlock(const std::vector<EnumInfo> &Enums,
349 const ClangDocContext &CDCtx) {
350 if (Enums.empty())
351 return {};
352
353 std::vector<std::unique_ptr<TagNode>> Out;
354 Out.emplace_back(std::make_unique<TagNode>(HTMLTag::TAG_H2, "Enums"));
355 Out.back()->Attributes.emplace_back("id", "Enums");
356 Out.emplace_back(std::make_unique<TagNode>(HTMLTag::TAG_DIV));
357 auto &DivBody = Out.back();
358 for (const auto &E : Enums) {
359 std::vector<std::unique_ptr<TagNode>> Nodes = genHTML(E, CDCtx);
360 AppendVector(std::move(Nodes), DivBody->Children);
361 }
362 return Out;
363}
364
365static std::unique_ptr<TagNode>
366genEnumMembersBlock(const llvm::SmallVector<EnumValueInfo, 4> &Members) {
367 if (Members.empty())
368 return nullptr;
369
370 auto List = std::make_unique<TagNode>(HTMLTag::TAG_UL);
371 for (const auto &M : Members)
372 List->Children.emplace_back(
373 std::make_unique<TagNode>(HTMLTag::TAG_LI, M.Name));
374 return List;
375}
376
377static std::vector<std::unique_ptr<TagNode>>
378genFunctionsBlock(const std::vector<FunctionInfo> &Functions,
379 const ClangDocContext &CDCtx, StringRef ParentInfoDir) {
380 if (Functions.empty())
381 return {};
382
383 std::vector<std::unique_ptr<TagNode>> Out;
384 Out.emplace_back(std::make_unique<TagNode>(HTMLTag::TAG_H2, "Functions"));
385 Out.back()->Attributes.emplace_back("id", "Functions");
386 Out.emplace_back(std::make_unique<TagNode>(HTMLTag::TAG_DIV));
387 auto &DivBody = Out.back();
388 for (const auto &F : Functions) {
389 std::vector<std::unique_ptr<TagNode>> Nodes =
390 genHTML(F, CDCtx, ParentInfoDir);
391 AppendVector(std::move(Nodes), DivBody->Children);
392 }
393 return Out;
394}
395
396static std::vector<std::unique_ptr<TagNode>>
397genRecordMembersBlock(const llvm::SmallVector<MemberTypeInfo, 4> &Members,
398 StringRef ParentInfoDir) {
399 if (Members.empty())
400 return {};
401
402 std::vector<std::unique_ptr<TagNode>> Out;
403 Out.emplace_back(std::make_unique<TagNode>(HTMLTag::TAG_H2, "Members"));
404 Out.back()->Attributes.emplace_back("id", "Members");
405 Out.emplace_back(std::make_unique<TagNode>(HTMLTag::TAG_UL));
406 auto &ULBody = Out.back();
407 for (const auto &M : Members) {
408 std::string Access = getAccessSpelling(M.Access).str();
409 if (Access != "")
410 Access = Access + " ";
411 auto LIBody = std::make_unique<TagNode>(HTMLTag::TAG_LI);
412 LIBody->Children.emplace_back(std::make_unique<TextNode>(Access));
413 LIBody->Children.emplace_back(genReference(M.Type, ParentInfoDir));
414 LIBody->Children.emplace_back(std::make_unique<TextNode>(" " + M.Name));
415 ULBody->Children.emplace_back(std::move(LIBody));
416 }
417 return Out;
418}
419
420static std::vector<std::unique_ptr<TagNode>>
421genReferencesBlock(const std::vector<Reference> &References,
422 llvm::StringRef Title, StringRef ParentPath) {
423 if (References.empty())
424 return {};
425
426 std::vector<std::unique_ptr<TagNode>> Out;
427 Out.emplace_back(std::make_unique<TagNode>(HTMLTag::TAG_H2, Title));
428 Out.back()->Attributes.emplace_back("id", std::string(Title));
429 Out.emplace_back(std::make_unique<TagNode>(HTMLTag::TAG_UL));
430 auto &ULBody = Out.back();
431 for (const auto &R : References) {
432 auto LiNode = std::make_unique<TagNode>(HTMLTag::TAG_LI);
433 LiNode->Children.emplace_back(genReference(R, ParentPath));
434 ULBody->Children.emplace_back(std::move(LiNode));
435 }
436 return Out;
437}
438
439static std::unique_ptr<TagNode>
441 std::optional<StringRef> RepositoryUrl = std::nullopt) {
442 if (!L.IsFileInRootDir || !RepositoryUrl)
443 return std::make_unique<TagNode>(
444 HTMLTag::TAG_P, "Defined at line " + std::to_string(L.LineNumber) +
445 " of file " + L.Filename);
446 SmallString<128> FileURL(*RepositoryUrl);
447 llvm::sys::path::append(FileURL, llvm::sys::path::Style::posix, L.Filename);
448 auto Node = std::make_unique<TagNode>(HTMLTag::TAG_P);
449 Node->Children.emplace_back(std::make_unique<TextNode>("Defined at line "));
450 auto LocNumberNode =
451 std::make_unique<TagNode>(HTMLTag::TAG_A, std::to_string(L.LineNumber));
452 // The links to a specific line in the source code use the github /
453 // googlesource notation so it won't work for all hosting pages.
454 LocNumberNode->Attributes.emplace_back(
455 "href", (FileURL + "#" + std::to_string(L.LineNumber)).str());
456 Node->Children.emplace_back(std::move(LocNumberNode));
457 Node->Children.emplace_back(std::make_unique<TextNode>(" of file "));
458 auto LocFileNode = std::make_unique<TagNode>(
459 HTMLTag::TAG_A, llvm::sys::path::filename(FileURL));
460 LocFileNode->Attributes.emplace_back("href", std::string(FileURL.str()));
461 Node->Children.emplace_back(std::move(LocFileNode));
462 return Node;
463}
464
465static std::vector<std::unique_ptr<TagNode>>
466genHTML(const Index &Index, StringRef InfoPath, bool IsOutermostList);
467
468// Generates a list of child nodes for the HTML head tag
469// It contains a meta node, link nodes to import CSS files, and script nodes to
470// import JS files
471static std::vector<std::unique_ptr<TagNode>>
472genFileHeadNodes(StringRef Title, StringRef InfoPath,
473 const ClangDocContext &CDCtx) {
474 std::vector<std::unique_ptr<TagNode>> Out;
475 auto MetaNode = std::make_unique<TagNode>(HTMLTag::TAG_META);
476 MetaNode->Attributes.emplace_back("charset", "utf-8");
477 Out.emplace_back(std::move(MetaNode));
478 Out.emplace_back(std::make_unique<TagNode>(HTMLTag::TAG_TITLE, Title));
479 std::vector<std::unique_ptr<TagNode>> StylesheetsNodes =
480 genStylesheetsHTML(InfoPath, CDCtx);
481 AppendVector(std::move(StylesheetsNodes), Out);
482 std::vector<std::unique_ptr<TagNode>> JsNodes =
483 genJsScriptsHTML(InfoPath, CDCtx);
484 AppendVector(std::move(JsNodes), Out);
485 return Out;
486}
487
488// Generates a header HTML node that can be used for any file
489// It contains the project name
490static std::unique_ptr<TagNode> genFileHeaderNode(StringRef ProjectName) {
491 auto HeaderNode = std::make_unique<TagNode>(HTMLTag::TAG_HEADER, ProjectName);
492 HeaderNode->Attributes.emplace_back("id", "project-title");
493 return HeaderNode;
494}
495
496// Generates a main HTML node that has all the main content of an info file
497// It contains both indexes and the info's documented information
498// This function should only be used for the info files (not for the file that
499// only has the general index)
500static std::unique_ptr<TagNode> genInfoFileMainNode(
501 StringRef InfoPath,
502 std::vector<std::unique_ptr<TagNode>> &MainContentInnerNodes,
503 const Index &InfoIndex) {
504 auto MainNode = std::make_unique<TagNode>(HTMLTag::TAG_MAIN);
505
506 auto LeftSidebarNode = std::make_unique<TagNode>(HTMLTag::TAG_DIV);
507 LeftSidebarNode->Attributes.emplace_back("id", "sidebar-left");
508 LeftSidebarNode->Attributes.emplace_back("path", std::string(InfoPath));
509 LeftSidebarNode->Attributes.emplace_back(
510 "class", "col-xs-6 col-sm-3 col-md-2 sidebar sidebar-offcanvas-left");
511
512 auto MainContentNode = std::make_unique<TagNode>(HTMLTag::TAG_DIV);
513 MainContentNode->Attributes.emplace_back("id", "main-content");
514 MainContentNode->Attributes.emplace_back(
515 "class", "col-xs-12 col-sm-9 col-md-8 main-content");
516 AppendVector(std::move(MainContentInnerNodes), MainContentNode->Children);
517
518 auto RightSidebarNode = std::make_unique<TagNode>(HTMLTag::TAG_DIV);
519 RightSidebarNode->Attributes.emplace_back("id", "sidebar-right");
520 RightSidebarNode->Attributes.emplace_back(
521 "class", "col-xs-6 col-sm-6 col-md-2 sidebar sidebar-offcanvas-right");
522 std::vector<std::unique_ptr<TagNode>> InfoIndexHTML =
523 genHTML(InfoIndex, InfoPath, true);
524 AppendVector(std::move(InfoIndexHTML), RightSidebarNode->Children);
525
526 MainNode->Children.emplace_back(std::move(LeftSidebarNode));
527 MainNode->Children.emplace_back(std::move(MainContentNode));
528 MainNode->Children.emplace_back(std::move(RightSidebarNode));
529
530 return MainNode;
531}
532
533// Generates a footer HTML node that can be used for any file
534// It contains clang-doc's version
535static std::unique_ptr<TagNode> genFileFooterNode() {
536 auto FooterNode = std::make_unique<TagNode>(HTMLTag::TAG_FOOTER);
537 auto SpanNode = std::make_unique<TagNode>(
538 HTMLTag::TAG_SPAN, clang::getClangToolFullVersion("clang-doc"));
539 SpanNode->Attributes.emplace_back("class", "no-break");
540 FooterNode->Children.emplace_back(std::move(SpanNode));
541 return FooterNode;
542}
543
544// Generates a complete HTMLFile for an Info
545static HTMLFile
546genInfoFile(StringRef Title, StringRef InfoPath,
547 std::vector<std::unique_ptr<TagNode>> &MainContentNodes,
548 const Index &InfoIndex, const ClangDocContext &CDCtx) {
549 HTMLFile F;
550
551 std::vector<std::unique_ptr<TagNode>> HeadNodes =
552 genFileHeadNodes(Title, InfoPath, CDCtx);
553 std::unique_ptr<TagNode> HeaderNode = genFileHeaderNode(CDCtx.ProjectName);
554 std::unique_ptr<TagNode> MainNode =
555 genInfoFileMainNode(InfoPath, MainContentNodes, InfoIndex);
556 std::unique_ptr<TagNode> FooterNode = genFileFooterNode();
557
558 AppendVector(std::move(HeadNodes), F.Children);
559 F.Children.emplace_back(std::move(HeaderNode));
560 F.Children.emplace_back(std::move(MainNode));
561 F.Children.emplace_back(std::move(FooterNode));
562
563 return F;
564}
565
566template <typename T,
567 typename = std::enable_if<std::is_base_of<T, Info>::value>>
568static Index genInfoIndexItem(const std::vector<T> &Infos, StringRef Title) {
569 Index Idx(Title, Title);
570 for (const auto &C : Infos)
571 Idx.Children.emplace_back(C.extractName(),
572 llvm::toHex(llvm::toStringRef(C.USR)));
573 return Idx;
574}
575
576static std::vector<std::unique_ptr<TagNode>>
577genHTML(const Index &Index, StringRef InfoPath, bool IsOutermostList) {
578 std::vector<std::unique_ptr<TagNode>> Out;
579 if (!Index.Name.empty()) {
580 Out.emplace_back(std::make_unique<TagNode>(HTMLTag::TAG_SPAN));
581 auto &SpanBody = Out.back();
582 if (!Index.JumpToSection)
583 SpanBody->Children.emplace_back(genReference(Index, InfoPath));
584 else
585 SpanBody->Children.emplace_back(
586 genReference(Index, InfoPath, Index.JumpToSection->str()));
587 }
588 if (Index.Children.empty())
589 return Out;
590 // Only the outermost list should use ol, the others should use ul
591 HTMLTag ListHTMLTag = IsOutermostList ? HTMLTag::TAG_OL : HTMLTag::TAG_UL;
592 Out.emplace_back(std::make_unique<TagNode>(ListHTMLTag));
593 const auto &UlBody = Out.back();
594 for (const auto &C : Index.Children) {
595 auto LiBody = std::make_unique<TagNode>(HTMLTag::TAG_LI);
596 std::vector<std::unique_ptr<TagNode>> Nodes = genHTML(C, InfoPath, false);
597 AppendVector(std::move(Nodes), LiBody->Children);
598 UlBody->Children.emplace_back(std::move(LiBody));
599 }
600 return Out;
601}
602
603static std::unique_ptr<HTMLNode> genHTML(const CommentInfo &I) {
604 if (I.Kind == "FullComment") {
605 auto FullComment = std::make_unique<TagNode>(HTMLTag::TAG_DIV);
606 for (const auto &Child : I.Children) {
607 std::unique_ptr<HTMLNode> Node = genHTML(*Child);
608 if (Node)
609 FullComment->Children.emplace_back(std::move(Node));
610 }
611 return std::move(FullComment);
612 } else if (I.Kind == "ParagraphComment") {
613 auto ParagraphComment = std::make_unique<TagNode>(HTMLTag::TAG_P);
614 for (const auto &Child : I.Children) {
615 std::unique_ptr<HTMLNode> Node = genHTML(*Child);
616 if (Node)
617 ParagraphComment->Children.emplace_back(std::move(Node));
618 }
619 if (ParagraphComment->Children.empty())
620 return nullptr;
621 return std::move(ParagraphComment);
622 } else if (I.Kind == "TextComment") {
623 if (I.Text == "")
624 return nullptr;
625 return std::make_unique<TextNode>(I.Text);
626 }
627 return nullptr;
628}
629
630static std::unique_ptr<TagNode> genHTML(const std::vector<CommentInfo> &C) {
631 auto CommentBlock = std::make_unique<TagNode>(HTMLTag::TAG_DIV);
632 for (const auto &Child : C) {
633 if (std::unique_ptr<HTMLNode> Node = genHTML(Child))
634 CommentBlock->Children.emplace_back(std::move(Node));
635 }
636 return CommentBlock;
637}
638
639static std::vector<std::unique_ptr<TagNode>>
640genHTML(const EnumInfo &I, const ClangDocContext &CDCtx) {
641 std::vector<std::unique_ptr<TagNode>> Out;
642 std::string EnumType;
643 if (I.Scoped)
644 EnumType = "enum class ";
645 else
646 EnumType = "enum ";
647
648 Out.emplace_back(
649 std::make_unique<TagNode>(HTMLTag::TAG_H3, EnumType + I.Name));
650 Out.back()->Attributes.emplace_back("id",
651 llvm::toHex(llvm::toStringRef(I.USR)));
652
653 std::unique_ptr<TagNode> Node = genEnumMembersBlock(I.Members);
654 if (Node)
655 Out.emplace_back(std::move(Node));
656
657 if (I.DefLoc) {
658 if (!CDCtx.RepositoryUrl)
659 Out.emplace_back(writeFileDefinition(*I.DefLoc));
660 else
661 Out.emplace_back(writeFileDefinition(
662 *I.DefLoc, StringRef{*CDCtx.RepositoryUrl}));
663 }
664
665 std::string Description;
666 if (!I.Description.empty())
667 Out.emplace_back(genHTML(I.Description));
668
669 return Out;
670}
671
672static std::vector<std::unique_ptr<TagNode>>
673genHTML(const FunctionInfo &I, const ClangDocContext &CDCtx,
674 StringRef ParentInfoDir) {
675 std::vector<std::unique_ptr<TagNode>> Out;
676 Out.emplace_back(std::make_unique<TagNode>(HTMLTag::TAG_H3, I.Name));
677 // USR is used as id for functions instead of name to disambiguate function
678 // overloads.
679 Out.back()->Attributes.emplace_back("id",
680 llvm::toHex(llvm::toStringRef(I.USR)));
681
682 Out.emplace_back(std::make_unique<TagNode>(HTMLTag::TAG_P));
683 auto &FunctionHeader = Out.back();
684
685 std::string Access = getAccessSpelling(I.Access).str();
686 if (Access != "")
687 FunctionHeader->Children.emplace_back(
688 std::make_unique<TextNode>(Access + " "));
689 if (I.ReturnType.Type.Name != "") {
690 FunctionHeader->Children.emplace_back(
691 genReference(I.ReturnType.Type, ParentInfoDir));
692 FunctionHeader->Children.emplace_back(std::make_unique<TextNode>(" "));
693 }
694 FunctionHeader->Children.emplace_back(
695 std::make_unique<TextNode>(I.Name + "("));
696
697 for (const auto &P : I.Params) {
698 if (&P != I.Params.begin())
699 FunctionHeader->Children.emplace_back(std::make_unique<TextNode>(", "));
700 FunctionHeader->Children.emplace_back(genReference(P.Type, ParentInfoDir));
701 FunctionHeader->Children.emplace_back(
702 std::make_unique<TextNode>(" " + P.Name));
703 }
704 FunctionHeader->Children.emplace_back(std::make_unique<TextNode>(")"));
705
706 if (I.DefLoc) {
707 if (!CDCtx.RepositoryUrl)
708 Out.emplace_back(writeFileDefinition(*I.DefLoc));
709 else
710 Out.emplace_back(writeFileDefinition(
711 *I.DefLoc, StringRef{*CDCtx.RepositoryUrl}));
712 }
713
714 std::string Description;
715 if (!I.Description.empty())
716 Out.emplace_back(genHTML(I.Description));
717
718 return Out;
719}
720
721static std::vector<std::unique_ptr<TagNode>>
722genHTML(const NamespaceInfo &I, Index &InfoIndex, const ClangDocContext &CDCtx,
723 std::string &InfoTitle) {
724 std::vector<std::unique_ptr<TagNode>> Out;
725 if (I.Name.str() == "")
726 InfoTitle = "Global Namespace";
727 else
728 InfoTitle = ("namespace " + I.Name).str();
729
730 Out.emplace_back(std::make_unique<TagNode>(HTMLTag::TAG_H1, InfoTitle));
731
732 std::string Description;
733 if (!I.Description.empty())
734 Out.emplace_back(genHTML(I.Description));
735
736 llvm::SmallString<64> BasePath = I.getRelativeFilePath("");
737
738 std::vector<std::unique_ptr<TagNode>> ChildNamespaces =
739 genReferencesBlock(I.Children.Namespaces, "Namespaces", BasePath);
740 AppendVector(std::move(ChildNamespaces), Out);
741 std::vector<std::unique_ptr<TagNode>> ChildRecords =
742 genReferencesBlock(I.Children.Records, "Records", BasePath);
743 AppendVector(std::move(ChildRecords), Out);
744
745 std::vector<std::unique_ptr<TagNode>> ChildFunctions =
746 genFunctionsBlock(I.Children.Functions, CDCtx, BasePath);
747 AppendVector(std::move(ChildFunctions), Out);
748 std::vector<std::unique_ptr<TagNode>> ChildEnums =
749 genEnumsBlock(I.Children.Enums, CDCtx);
750 AppendVector(std::move(ChildEnums), Out);
751
752 if (!I.Children.Namespaces.empty())
753 InfoIndex.Children.emplace_back("Namespaces", "Namespaces");
754 if (!I.Children.Records.empty())
755 InfoIndex.Children.emplace_back("Records", "Records");
756 if (!I.Children.Functions.empty())
757 InfoIndex.Children.emplace_back(
758 genInfoIndexItem(I.Children.Functions, "Functions"));
759 if (!I.Children.Enums.empty())
760 InfoIndex.Children.emplace_back(
761 genInfoIndexItem(I.Children.Enums, "Enums"));
762
763 return Out;
764}
765
766static std::vector<std::unique_ptr<TagNode>>
767genHTML(const RecordInfo &I, Index &InfoIndex, const ClangDocContext &CDCtx,
768 std::string &InfoTitle) {
769 std::vector<std::unique_ptr<TagNode>> Out;
770 InfoTitle = (getTagType(I.TagType) + " " + I.Name).str();
771 Out.emplace_back(std::make_unique<TagNode>(HTMLTag::TAG_H1, InfoTitle));
772
773 if (I.DefLoc) {
774 if (!CDCtx.RepositoryUrl)
775 Out.emplace_back(writeFileDefinition(*I.DefLoc));
776 else
777 Out.emplace_back(writeFileDefinition(
778 *I.DefLoc, StringRef{*CDCtx.RepositoryUrl}));
779 }
780
781 std::string Description;
782 if (!I.Description.empty())
783 Out.emplace_back(genHTML(I.Description));
784
785 std::vector<std::unique_ptr<HTMLNode>> Parents =
787 std::vector<std::unique_ptr<HTMLNode>> VParents =
789 if (!Parents.empty() || !VParents.empty()) {
790 Out.emplace_back(std::make_unique<TagNode>(HTMLTag::TAG_P));
791 auto &PBody = Out.back();
792 PBody->Children.emplace_back(std::make_unique<TextNode>("Inherits from "));
793 if (Parents.empty())
794 AppendVector(std::move(VParents), PBody->Children);
795 else if (VParents.empty())
796 AppendVector(std::move(Parents), PBody->Children);
797 else {
798 AppendVector(std::move(Parents), PBody->Children);
799 PBody->Children.emplace_back(std::make_unique<TextNode>(", "));
800 AppendVector(std::move(VParents), PBody->Children);
801 }
802 }
803
804 std::vector<std::unique_ptr<TagNode>> Members =
806 AppendVector(std::move(Members), Out);
807 std::vector<std::unique_ptr<TagNode>> ChildRecords =
808 genReferencesBlock(I.Children.Records, "Records", I.Path);
809 AppendVector(std::move(ChildRecords), Out);
810
811 std::vector<std::unique_ptr<TagNode>> ChildFunctions =
813 AppendVector(std::move(ChildFunctions), Out);
814 std::vector<std::unique_ptr<TagNode>> ChildEnums =
815 genEnumsBlock(I.Children.Enums, CDCtx);
816 AppendVector(std::move(ChildEnums), Out);
817
818 if (!I.Members.empty())
819 InfoIndex.Children.emplace_back("Members", "Members");
820 if (!I.Children.Records.empty())
821 InfoIndex.Children.emplace_back("Records", "Records");
822 if (!I.Children.Functions.empty())
823 InfoIndex.Children.emplace_back(
824 genInfoIndexItem(I.Children.Functions, "Functions"));
825 if (!I.Children.Enums.empty())
826 InfoIndex.Children.emplace_back(
827 genInfoIndexItem(I.Children.Enums, "Enums"));
828
829 return Out;
830}
831
832static std::vector<std::unique_ptr<TagNode>>
833genHTML(const TypedefInfo &I, const ClangDocContext &CDCtx,
834 std::string &InfoTitle) {
835 // TODO support typedefs in HTML.
836 return {};
837}
838
839/// Generator for HTML documentation.
840class HTMLGenerator : public Generator {
841public:
842 static const char *Format;
843
844 llvm::Error generateDocs(StringRef RootDir,
845 llvm::StringMap<std::unique_ptr<doc::Info>> Infos,
846 const ClangDocContext &CDCtx) override;
847 llvm::Error createResources(ClangDocContext &CDCtx) override;
848 llvm::Error generateDocForInfo(Info *I, llvm::raw_ostream &OS,
849 const ClangDocContext &CDCtx) override;
850};
851
852const char *HTMLGenerator::Format = "html";
853
854llvm::Error
856 llvm::StringMap<std::unique_ptr<doc::Info>> Infos,
857 const ClangDocContext &CDCtx) {
858 // Track which directories we already tried to create.
859 llvm::StringSet<> CreatedDirs;
860
861 // Collect all output by file name and create the nexessary directories.
862 llvm::StringMap<std::vector<doc::Info *>> FileToInfos;
863 for (const auto &Group : Infos) {
864 doc::Info *Info = Group.getValue().get();
865
866 llvm::SmallString<128> Path;
867 llvm::sys::path::native(RootDir, Path);
868 llvm::sys::path::append(Path, Info->getRelativeFilePath(""));
869 if (!CreatedDirs.contains(Path)) {
870 if (std::error_code Err = llvm::sys::fs::create_directories(Path);
871 Err != std::error_code()) {
872 return llvm::createStringError(Err, "Failed to create directory '%s'.",
873 Path.c_str());
874 }
875 CreatedDirs.insert(Path);
876 }
877
878 llvm::sys::path::append(Path, Info->getFileBaseName() + ".html");
879 FileToInfos[Path].push_back(Info);
880 }
881
882 for (const auto &Group : FileToInfos) {
883 std::error_code FileErr;
884 llvm::raw_fd_ostream InfoOS(Group.getKey(), FileErr,
885 llvm::sys::fs::OF_None);
886 if (FileErr) {
887 return llvm::createStringError(FileErr, "Error opening file '%s'",
888 Group.getKey().str().c_str());
889 }
890
891 // TODO: https://github.com/llvm/llvm-project/issues/59073
892 // If there are multiple Infos for this file name (for example, template
893 // specializations), this will generate multiple complete web pages (with
894 // <DOCTYPE> and <title>, etc.) concatenated together. This generator needs
895 // some refactoring to be able to output the headers separately from the
896 // contents.
897 for (const auto &Info : Group.getValue()) {
898 if (llvm::Error Err = generateDocForInfo(Info, InfoOS, CDCtx)) {
899 return Err;
900 }
901 }
902 }
903
904 return llvm::Error::success();
905}
906
907llvm::Error HTMLGenerator::generateDocForInfo(Info *I, llvm::raw_ostream &OS,
908 const ClangDocContext &CDCtx) {
909 std::string InfoTitle;
910 std::vector<std::unique_ptr<TagNode>> MainContentNodes;
911 Index InfoIndex;
912 switch (I->IT) {
914 MainContentNodes = genHTML(*static_cast<clang::doc::NamespaceInfo *>(I),
915 InfoIndex, CDCtx, InfoTitle);
916 break;
918 MainContentNodes = genHTML(*static_cast<clang::doc::RecordInfo *>(I),
919 InfoIndex, CDCtx, InfoTitle);
920 break;
922 MainContentNodes = genHTML(*static_cast<clang::doc::EnumInfo *>(I), CDCtx);
923 break;
925 MainContentNodes =
926 genHTML(*static_cast<clang::doc::FunctionInfo *>(I), CDCtx, "");
927 break;
929 MainContentNodes =
930 genHTML(*static_cast<clang::doc::TypedefInfo *>(I), CDCtx, InfoTitle);
931 break;
933 return llvm::createStringError(llvm::inconvertibleErrorCode(),
934 "unexpected info type");
935 }
936
937 HTMLFile F = genInfoFile(InfoTitle, I->getRelativeFilePath(""),
938 MainContentNodes, InfoIndex, CDCtx);
939 F.Render(OS);
940
941 return llvm::Error::success();
942}
943
944static std::string getRefType(InfoType IT) {
945 switch (IT) {
947 return "default";
949 return "namespace";
951 return "record";
953 return "function";
955 return "enum";
957 return "typedef";
958 }
959 llvm_unreachable("Unknown InfoType");
960}
961
962static llvm::Error SerializeIndex(ClangDocContext &CDCtx) {
963 std::error_code OK;
964 std::error_code FileErr;
965 llvm::SmallString<128> FilePath;
966 llvm::sys::path::native(CDCtx.OutDirectory, FilePath);
967 llvm::sys::path::append(FilePath, "index_json.js");
968 llvm::raw_fd_ostream OS(FilePath, FileErr, llvm::sys::fs::OF_None);
969 if (FileErr != OK) {
970 return llvm::createStringError(llvm::inconvertibleErrorCode(),
971 "error creating index file: " +
972 FileErr.message());
973 }
974 CDCtx.Idx.sort();
975 llvm::json::OStream J(OS, 2);
976 std::function<void(Index)> IndexToJSON = [&](const Index &I) {
977 J.object([&] {
978 J.attribute("USR", toHex(llvm::toStringRef(I.USR)));
979 J.attribute("Name", I.Name);
980 J.attribute("RefType", getRefType(I.RefType));
981 J.attribute("Path", I.getRelativeFilePath(""));
982 J.attributeArray("Children", [&] {
983 for (const Index &C : I.Children)
984 IndexToJSON(C);
985 });
986 });
987 };
988 OS << "var JsonIndex = `\n";
989 IndexToJSON(CDCtx.Idx);
990 OS << "`;\n";
991 return llvm::Error::success();
992}
993
994// Generates a main HTML node that has the main content of the file that shows
995// only the general index
996// It contains the general index with links to all the generated files
997static std::unique_ptr<TagNode> genIndexFileMainNode() {
998 auto MainNode = std::make_unique<TagNode>(HTMLTag::TAG_MAIN);
999
1000 auto LeftSidebarNode = std::make_unique<TagNode>(HTMLTag::TAG_DIV);
1001 LeftSidebarNode->Attributes.emplace_back("id", "sidebar-left");
1002 LeftSidebarNode->Attributes.emplace_back("path", "");
1003 LeftSidebarNode->Attributes.emplace_back(
1004 "class", "col-xs-6 col-sm-3 col-md-2 sidebar sidebar-offcanvas-left");
1005 LeftSidebarNode->Attributes.emplace_back("style", "flex: 0 100%;");
1006
1007 MainNode->Children.emplace_back(std::move(LeftSidebarNode));
1008
1009 return MainNode;
1010}
1011
1012static llvm::Error GenIndex(const ClangDocContext &CDCtx) {
1013 std::error_code FileErr, OK;
1014 llvm::SmallString<128> IndexPath;
1015 llvm::sys::path::native(CDCtx.OutDirectory, IndexPath);
1016 llvm::sys::path::append(IndexPath, "index.html");
1017 llvm::raw_fd_ostream IndexOS(IndexPath, FileErr, llvm::sys::fs::OF_None);
1018 if (FileErr != OK) {
1019 return llvm::createStringError(llvm::inconvertibleErrorCode(),
1020 "error creating main index: " +
1021 FileErr.message());
1022 }
1023
1024 HTMLFile F;
1025
1026 std::vector<std::unique_ptr<TagNode>> HeadNodes =
1027 genFileHeadNodes("Index", "", CDCtx);
1028 std::unique_ptr<TagNode> HeaderNode = genFileHeaderNode(CDCtx.ProjectName);
1029 std::unique_ptr<TagNode> MainNode = genIndexFileMainNode();
1030 std::unique_ptr<TagNode> FooterNode = genFileFooterNode();
1031
1032 AppendVector(std::move(HeadNodes), F.Children);
1033 F.Children.emplace_back(std::move(HeaderNode));
1034 F.Children.emplace_back(std::move(MainNode));
1035 F.Children.emplace_back(std::move(FooterNode));
1036
1037 F.Render(IndexOS);
1038
1039 return llvm::Error::success();
1040}
1041
1042static llvm::Error CopyFile(StringRef FilePath, StringRef OutDirectory) {
1043 llvm::SmallString<128> PathWrite;
1044 llvm::sys::path::native(OutDirectory, PathWrite);
1045 llvm::sys::path::append(PathWrite, llvm::sys::path::filename(FilePath));
1046 llvm::SmallString<128> PathRead;
1047 llvm::sys::path::native(FilePath, PathRead);
1048 std::error_code OK;
1049 std::error_code FileErr = llvm::sys::fs::copy_file(PathRead, PathWrite);
1050 if (FileErr != OK) {
1051 return llvm::createStringError(llvm::inconvertibleErrorCode(),
1052 "error creating file " +
1053 llvm::sys::path::filename(FilePath) +
1054 ": " + FileErr.message() + "\n");
1055 }
1056 return llvm::Error::success();
1057}
1058
1060 auto Err = SerializeIndex(CDCtx);
1061 if (Err)
1062 return Err;
1063 Err = GenIndex(CDCtx);
1064 if (Err)
1065 return Err;
1066
1067 for (const auto &FilePath : CDCtx.UserStylesheets) {
1068 Err = CopyFile(FilePath, CDCtx.OutDirectory);
1069 if (Err)
1070 return Err;
1071 }
1072 for (const auto &FilePath : CDCtx.FilesToCopy) {
1073 Err = CopyFile(FilePath, CDCtx.OutDirectory);
1074 if (Err)
1075 return Err;
1076 }
1077 return llvm::Error::success();
1078}
1079
1080static GeneratorRegistry::Add<HTMLGenerator> HTML(HTMLGenerator::Format,
1081 "Generator for HTML output.");
1082
1083// This anchor is used to force the linker to link in the generated object
1084// file and thus register the generator.
1086
1087} // namespace doc
1088} // namespace clang
const Expr * E
static llvm::cl::opt< std::string > ProjectName("project-name", llvm::cl::desc("Name of project."), llvm::cl::cat(ClangDocCategory))
static llvm::cl::opt< std::string > OutDirectory("output", llvm::cl::desc("Directory for outputting generated files."), llvm::cl::init("docs"), llvm::cl::cat(ClangDocCategory))
static llvm::cl::opt< std::string > RepositoryUrl("repository", llvm::cl::desc(R"( URL of repository that hosts code. Used for links to definition locations.)"), llvm::cl::cat(ClangDocCategory))
unsigned References
CompiledFragmentImpl & Out
const Criteria C
HTMLTag Tag
std::vector< std::pair< std::string, std::string > > Attributes
std::vector< std::unique_ptr< HTMLNode > > Children
NodeType Type
std::string Text
std::vector< HeaderHandle > Path
const google::protobuf::Message & M
Definition: Server.cpp:309
llvm::raw_string_ostream OS
Definition: TraceTests.cpp:160
Generator for HTML documentation.
static const char * Format
llvm::Error createResources(ClangDocContext &CDCtx) override
llvm::Error generateDocs(StringRef RootDir, llvm::StringMap< std::unique_ptr< doc::Info > > Infos, const ClangDocContext &CDCtx) override
llvm::Error generateDocForInfo(Info *I, llvm::raw_ostream &OS, const ClangDocContext &CDCtx) override
static std::unique_ptr< TagNode > genInfoFileMainNode(StringRef InfoPath, std::vector< std::unique_ptr< TagNode > > &MainContentInnerNodes, const Index &InfoIndex)
static std::vector< std::unique_ptr< TagNode > > genHTML(const EnumInfo &I, const ClangDocContext &CDCtx)
static llvm::Error SerializeIndex(ClangDocContext &CDCtx)
static std::unique_ptr< HTMLNode > genReference(const Reference &Type, StringRef CurrentDirectory, std::optional< StringRef > JumpToSection=std::nullopt)
std::string getTagType(TagTypeKind AS)
Definition: Generators.cpp:29
static std::vector< std::unique_ptr< TagNode > > genStylesheetsHTML(StringRef InfoPath, const ClangDocContext &CDCtx)
static llvm::Error GenIndex(const ClangDocContext &CDCtx)
static std::vector< std::unique_ptr< HTMLNode > > genReferenceList(const llvm::SmallVectorImpl< Reference > &Refs, const StringRef &CurrentDirectory)
static llvm::Error CopyFile(StringRef FilePath, StringRef OutDirectory)
static std::vector< std::unique_ptr< TagNode > > genRecordMembersBlock(const llvm::SmallVector< MemberTypeInfo, 4 > &Members, StringRef ParentInfoDir)
static std::vector< std::unique_ptr< TagNode > > genReferencesBlock(const std::vector< Reference > &References, llvm::StringRef Title, StringRef ParentPath)
static std::unique_ptr< TagNode > genFileHeaderNode(StringRef ProjectName)
static void AppendVector(std::vector< Derived > &&New, std::vector< Base > &Original)
static std::unique_ptr< TagNode > genLink(const Twine &Text, const Twine &Link)
static GeneratorRegistry::Add< HTMLGenerator > HTML(HTMLGenerator::Format, "Generator for HTML output.")
static std::unique_ptr< TagNode > genFileFooterNode()
volatile int HTMLGeneratorAnchorSource
static std::vector< std::unique_ptr< TagNode > > genFileHeadNodes(StringRef Title, StringRef InfoPath, const ClangDocContext &CDCtx)
static Index genInfoIndexItem(const std::vector< T > &Infos, StringRef Title)
static std::unique_ptr< TagNode > writeFileDefinition(const Location &L, std::optional< StringRef > RepositoryUrl=std::nullopt)
static std::string getRefType(InfoType IT)
static std::vector< std::unique_ptr< TagNode > > genJsScriptsHTML(StringRef InfoPath, const ClangDocContext &CDCtx)
static HTMLFile genInfoFile(StringRef Title, StringRef InfoPath, std::vector< std::unique_ptr< TagNode > > &MainContentNodes, const Index &InfoIndex, const ClangDocContext &CDCtx)
static std::unique_ptr< TagNode > genIndexFileMainNode()
static std::vector< std::unique_ptr< TagNode > > genFunctionsBlock(const std::vector< FunctionInfo > &Functions, const ClangDocContext &CDCtx, StringRef ParentInfoDir)
static std::unique_ptr< TagNode > genEnumMembersBlock(const llvm::SmallVector< EnumValueInfo, 4 > &Members)
static std::vector< std::unique_ptr< TagNode > > genEnumsBlock(const std::vector< EnumInfo > &Enums, const ClangDocContext &CDCtx)
static SmallString< 128 > computeRelativePath(StringRef Destination, StringRef Origin)
===– Representation.cpp - ClangDoc Representation --------—*- C++ -*-===//
Some operations such as code completion produce a set of candidates.
std::optional< std::string > RepositoryUrl
std::vector< std::string > UserStylesheets
std::vector< std::string > JsScripts
std::vector< std::string > FilesToCopy
SmallString< 16 > Kind
std::vector< std::unique_ptr< CommentInfo > > Children
SmallString< 64 > Text
llvm::SmallVector< EnumValueInfo, 4 > Members
llvm::SmallVector< FieldTypeInfo, 4 > Params
std::optional< SmallString< 16 > > JumpToSection
std::vector< Index > Children
A base struct for Infos.
SmallString< 16 > Name
llvm::SmallString< 16 > getFileBaseName() const
Returns the basename that should be used for this Info.
std::vector< CommentInfo > Description
llvm::SmallString< 128 > Path
llvm::SmallString< 64 > getRelativeFilePath(const StringRef &CurrentPath) const
Returns the file path for this Info relative to CurrentPath.
const InfoType IT
llvm::SmallVector< MemberTypeInfo, 4 > Members
llvm::SmallVector< Reference, 4 > VirtualParents
llvm::SmallVector< Reference, 4 > Parents
SmallString< 16 > Name
std::vector< Reference > Records
std::vector< FunctionInfo > Functions
std::vector< Reference > Namespaces
std::vector< EnumInfo > Enums
std::optional< Location > DefLoc