Diff 215649

clang-tools-extra/trunk/clang-doc/HTMLGenerator.cpp

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

#include "Generators.h"		#include "Generators.h"
#include "Representation.h"		#include "Representation.h"
		#include "clang/Basic/Version.h"
#include "llvm/ADT/StringExtras.h"		#include "llvm/ADT/StringExtras.h"
#include "llvm/ADT/StringRef.h"		#include "llvm/ADT/StringRef.h"
#include "llvm/Support/FileSystem.h"		#include "llvm/Support/FileSystem.h"
#include "llvm/Support/JSON.h"		#include "llvm/Support/JSON.h"
#include "llvm/Support/Path.h"		#include "llvm/Support/Path.h"
#include "llvm/Support/raw_ostream.h"		#include "llvm/Support/raw_ostream.h"
#include <string>		#include <string>

using namespace llvm;		using namespace llvm;

namespace clang {		namespace clang {
namespace doc {		namespace doc {

namespace {		namespace {

class HTMLTag {		class HTMLTag {
public:		public:
// Any other tag can be added if required		// Any other tag can be added if required
enum TagType {		enum TagType {
TAG_A,		TAG_A,
TAG_DIV,		TAG_DIV,
		TAG_FOOTER,
TAG_H1,		TAG_H1,
TAG_H2,		TAG_H2,
TAG_H3,		TAG_H3,
		TAG_HEADER,
TAG_LI,		TAG_LI,
TAG_LINK,		TAG_LINK,
		TAG_MAIN,
TAG_META,		TAG_META,
		TAG_OL,
TAG_P,		TAG_P,
TAG_SCRIPT,		TAG_SCRIPT,
TAG_SPAN,		TAG_SPAN,
TAG_TITLE,		TAG_TITLE,
TAG_UL,		TAG_UL,
};		};

HTMLTag() = default;		HTMLTag() = default;
Show All 33 Lines
struct TagNode : public HTMLNode {		struct TagNode : public HTMLNode {
TagNode(HTMLTag Tag) : HTMLNode(NodeType::NODE_TAG), Tag(Tag) {}		TagNode(HTMLTag Tag) : HTMLNode(NodeType::NODE_TAG), Tag(Tag) {}
TagNode(HTMLTag Tag, const Twine &Text) : TagNode(Tag) {		TagNode(HTMLTag Tag, const Twine &Text) : TagNode(Tag) {
Children.emplace_back(std::make_unique<TextNode>(Text.str()));		Children.emplace_back(std::make_unique<TextNode>(Text.str()));
}		}

HTMLTag Tag; // Name of HTML Tag (p, div, h1)		HTMLTag Tag; // Name of HTML Tag (p, div, h1)
std::vector<std::unique_ptr<HTMLNode>> Children; // List of child nodes		std::vector<std::unique_ptr<HTMLNode>> Children; // List of child nodes
llvm::StringMap<llvm::SmallString<16>>		std::vector<std::pair<llvm::SmallString<16>, llvm::SmallString<16>>>
Attributes; // List of key-value attributes for tag		Attributes; // List of key-value attributes for tag

void Render(llvm::raw_ostream &OS, int IndentationLevel) override;		void Render(llvm::raw_ostream &OS, int IndentationLevel) override;
};		};

constexpr const char *kDoctypeDecl = "<!DOCTYPE html>";		constexpr const char *kDoctypeDecl = "<!DOCTYPE html>";

struct HTMLFile {		struct HTMLFile {
Show All 11 Lines

bool HTMLTag::IsSelfClosing() const {		bool HTMLTag::IsSelfClosing() const {
switch (Value) {		switch (Value) {
case HTMLTag::TAG_META:		case HTMLTag::TAG_META:
case HTMLTag::TAG_LINK:		case HTMLTag::TAG_LINK:
return true;		return true;
case HTMLTag::TAG_A:		case HTMLTag::TAG_A:
case HTMLTag::TAG_DIV:		case HTMLTag::TAG_DIV:
		case HTMLTag::TAG_FOOTER:
case HTMLTag::TAG_H1:		case HTMLTag::TAG_H1:
case HTMLTag::TAG_H2:		case HTMLTag::TAG_H2:
case HTMLTag::TAG_H3:		case HTMLTag::TAG_H3:
		case HTMLTag::TAG_HEADER:
case HTMLTag::TAG_LI:		case HTMLTag::TAG_LI:
		case HTMLTag::TAG_MAIN:
		case HTMLTag::TAG_OL:
case HTMLTag::TAG_P:		case HTMLTag::TAG_P:
case HTMLTag::TAG_SCRIPT:		case HTMLTag::TAG_SCRIPT:
case HTMLTag::TAG_SPAN:		case HTMLTag::TAG_SPAN:
case HTMLTag::TAG_TITLE:		case HTMLTag::TAG_TITLE:
case HTMLTag::TAG_UL:		case HTMLTag::TAG_UL:
return false;		return false;
}		}
llvm_unreachable("Unhandled HTMLTag::TagType");		llvm_unreachable("Unhandled HTMLTag::TagType");
}		}

llvm::SmallString<16> HTMLTag::ToString() const {		llvm::SmallString<16> HTMLTag::ToString() const {
switch (Value) {		switch (Value) {
case HTMLTag::TAG_A:		case HTMLTag::TAG_A:
return llvm::SmallString<16>("a");		return llvm::SmallString<16>("a");
case HTMLTag::TAG_DIV:		case HTMLTag::TAG_DIV:
return llvm::SmallString<16>("div");		return llvm::SmallString<16>("div");
		case HTMLTag::TAG_FOOTER:
		return llvm::SmallString<16>("footer");
case HTMLTag::TAG_H1:		case HTMLTag::TAG_H1:
return llvm::SmallString<16>("h1");		return llvm::SmallString<16>("h1");
case HTMLTag::TAG_H2:		case HTMLTag::TAG_H2:
return llvm::SmallString<16>("h2");		return llvm::SmallString<16>("h2");
case HTMLTag::TAG_H3:		case HTMLTag::TAG_H3:
return llvm::SmallString<16>("h3");		return llvm::SmallString<16>("h3");
		case HTMLTag::TAG_HEADER:
		return llvm::SmallString<16>("header");
case HTMLTag::TAG_LI:		case HTMLTag::TAG_LI:
return llvm::SmallString<16>("li");		return llvm::SmallString<16>("li");
case HTMLTag::TAG_LINK:		case HTMLTag::TAG_LINK:
return llvm::SmallString<16>("link");		return llvm::SmallString<16>("link");
		case HTMLTag::TAG_MAIN:
		return llvm::SmallString<16>("main");
case HTMLTag::TAG_META:		case HTMLTag::TAG_META:
return llvm::SmallString<16>("meta");		return llvm::SmallString<16>("meta");
		case HTMLTag::TAG_OL:
		return llvm::SmallString<16>("ol");
case HTMLTag::TAG_P:		case HTMLTag::TAG_P:
return llvm::SmallString<16>("p");		return llvm::SmallString<16>("p");
case HTMLTag::TAG_SCRIPT:		case HTMLTag::TAG_SCRIPT:
return llvm::SmallString<16>("script");		return llvm::SmallString<16>("script");
case HTMLTag::TAG_SPAN:		case HTMLTag::TAG_SPAN:
return llvm::SmallString<16>("span");		return llvm::SmallString<16>("span");
case HTMLTag::TAG_TITLE:		case HTMLTag::TAG_TITLE:
return llvm::SmallString<16>("title");		return llvm::SmallString<16>("title");
Show All 14 Lines	void TagNode::Render(llvm::raw_ostream &OS, int IndentationLevel) {
for (const auto &C : Children)		for (const auto &C : Children)
if (C->Type == NodeType::NODE_TAG) {		if (C->Type == NodeType::NODE_TAG) {
InlineChildren = false;		InlineChildren = false;
break;		break;
}		}
OS.indent(IndentationLevel * 2);		OS.indent(IndentationLevel * 2);
OS << "<" << Tag.ToString();		OS << "<" << Tag.ToString();
for (const auto &A : Attributes)		for (const auto &A : Attributes)
OS << " " << A.getKey() << "=\"" << A.getValue() << "\"";		OS << " " << A.first << "=\"" << A.second << "\"";
if (Tag.IsSelfClosing()) {		if (Tag.IsSelfClosing()) {
OS << "/>";		OS << "/>";
return;		return;
}		}
OS << ">";		OS << ">";
if (!InlineChildren)		if (!InlineChildren)
OS << "\n";		OS << "\n";
bool NewLineRendered = true;		bool NewLineRendered = true;
▲ Show 20 Lines • Show All 64 Lines • ▼ Show 20 Lines

// HTML generation		// HTML generation

static std::vector<std::unique_ptr<TagNode>>		static std::vector<std::unique_ptr<TagNode>>
genStylesheetsHTML(StringRef InfoPath, const ClangDocContext &CDCtx) {		genStylesheetsHTML(StringRef InfoPath, const ClangDocContext &CDCtx) {
std::vector<std::unique_ptr<TagNode>> Out;		std::vector<std::unique_ptr<TagNode>> Out;
for (const auto &FilePath : CDCtx.UserStylesheets) {		for (const auto &FilePath : CDCtx.UserStylesheets) {
auto LinkNode = std::make_unique<TagNode>(HTMLTag::TAG_LINK);		auto LinkNode = std::make_unique<TagNode>(HTMLTag::TAG_LINK);
LinkNode->Attributes.try_emplace("rel", "stylesheet");		LinkNode->Attributes.emplace_back("rel", "stylesheet");
SmallString<128> StylesheetPath = computeRelativePath("", InfoPath);		SmallString<128> StylesheetPath = computeRelativePath("", InfoPath);
llvm::sys::path::append(StylesheetPath,		llvm::sys::path::append(StylesheetPath,
llvm::sys::path::filename(FilePath));		llvm::sys::path::filename(FilePath));
// Paths in HTML must be in posix-style		// Paths in HTML must be in posix-style
llvm::sys::path::native(StylesheetPath, llvm::sys::path::Style::posix);		llvm::sys::path::native(StylesheetPath, llvm::sys::path::Style::posix);
LinkNode->Attributes.try_emplace("href", StylesheetPath);		LinkNode->Attributes.emplace_back("href", StylesheetPath);
Out.emplace_back(std::move(LinkNode));		Out.emplace_back(std::move(LinkNode));
}		}
return Out;		return Out;
}		}

static std::vector<std::unique_ptr<TagNode>>		static std::vector<std::unique_ptr<TagNode>>
genJsScriptsHTML(StringRef InfoPath, const ClangDocContext &CDCtx) {		genJsScriptsHTML(StringRef InfoPath, const ClangDocContext &CDCtx) {
std::vector<std::unique_ptr<TagNode>> Out;		std::vector<std::unique_ptr<TagNode>> Out;
for (const auto &FilePath : CDCtx.JsScripts) {		for (const auto &FilePath : CDCtx.JsScripts) {
auto ScriptNode = std::make_unique<TagNode>(HTMLTag::TAG_SCRIPT);		auto ScriptNode = std::make_unique<TagNode>(HTMLTag::TAG_SCRIPT);
SmallString<128> ScriptPath = computeRelativePath("", InfoPath);		SmallString<128> ScriptPath = computeRelativePath("", InfoPath);
llvm::sys::path::append(ScriptPath, llvm::sys::path::filename(FilePath));		llvm::sys::path::append(ScriptPath, llvm::sys::path::filename(FilePath));
// Paths in HTML must be in posix-style		// Paths in HTML must be in posix-style
llvm::sys::path::native(ScriptPath, llvm::sys::path::Style::posix);		llvm::sys::path::native(ScriptPath, llvm::sys::path::Style::posix);
ScriptNode->Attributes.try_emplace("src", ScriptPath);		ScriptNode->Attributes.emplace_back("src", ScriptPath);
Out.emplace_back(std::move(ScriptNode));		Out.emplace_back(std::move(ScriptNode));
}		}
return Out;		return Out;
}		}

static std::unique_ptr<TagNode> genLink(const Twine &Text, const Twine &Link) {		static std::unique_ptr<TagNode> genLink(const Twine &Text, const Twine &Link) {
auto LinkNode = std::make_unique<TagNode>(HTMLTag::TAG_A, Text);		auto LinkNode = std::make_unique<TagNode>(HTMLTag::TAG_A, Text);
LinkNode->Attributes.try_emplace("href", Link.str());		LinkNode->Attributes.emplace_back("href", Link.str());
return LinkNode;		return LinkNode;
}		}

static std::unique_ptr<HTMLNode>		static std::unique_ptr<HTMLNode>
genReference(const Reference &Type, StringRef CurrentDirectory,		genReference(const Reference &Type, StringRef CurrentDirectory,
llvm::Optional<StringRef> JumpToSection = None) {		llvm::Optional<StringRef> JumpToSection = None) {
if (Type.Path.empty() && !Type.IsInGlobalNamespace) {		if (Type.Path.empty() && !Type.IsInGlobalNamespace) {
if (!JumpToSection)		if (!JumpToSection)
Show All 32 Lines
static std::vector<std::unique_ptr<TagNode>>		static std::vector<std::unique_ptr<TagNode>>
genEnumsBlock(const std::vector<EnumInfo> &Enums,		genEnumsBlock(const std::vector<EnumInfo> &Enums,
const ClangDocContext &CDCtx) {		const ClangDocContext &CDCtx) {
if (Enums.empty())		if (Enums.empty())
return {};		return {};

std::vector<std::unique_ptr<TagNode>> Out;		std::vector<std::unique_ptr<TagNode>> Out;
Out.emplace_back(std::make_unique<TagNode>(HTMLTag::TAG_H2, "Enums"));		Out.emplace_back(std::make_unique<TagNode>(HTMLTag::TAG_H2, "Enums"));
Out.back()->Attributes.try_emplace("id", "Enums");		Out.back()->Attributes.emplace_back("id", "Enums");
Out.emplace_back(std::make_unique<TagNode>(HTMLTag::TAG_DIV));		Out.emplace_back(std::make_unique<TagNode>(HTMLTag::TAG_DIV));
auto &DivBody = Out.back();		auto &DivBody = Out.back();
for (const auto &E : Enums) {		for (const auto &E : Enums) {
std::vector<std::unique_ptr<TagNode>> Nodes = genHTML(E, CDCtx);		std::vector<std::unique_ptr<TagNode>> Nodes = genHTML(E, CDCtx);
AppendVector(std::move(Nodes), DivBody->Children);		AppendVector(std::move(Nodes), DivBody->Children);
}		}
return Out;		return Out;
}		}
Show All 12 Lines
static std::vector<std::unique_ptr<TagNode>>		static std::vector<std::unique_ptr<TagNode>>
genFunctionsBlock(const std::vector<FunctionInfo> &Functions,		genFunctionsBlock(const std::vector<FunctionInfo> &Functions,
const ClangDocContext &CDCtx, StringRef ParentInfoDir) {		const ClangDocContext &CDCtx, StringRef ParentInfoDir) {
if (Functions.empty())		if (Functions.empty())
return {};		return {};

std::vector<std::unique_ptr<TagNode>> Out;		std::vector<std::unique_ptr<TagNode>> Out;
Out.emplace_back(std::make_unique<TagNode>(HTMLTag::TAG_H2, "Functions"));		Out.emplace_back(std::make_unique<TagNode>(HTMLTag::TAG_H2, "Functions"));
Out.back()->Attributes.try_emplace("id", "Functions");		Out.back()->Attributes.emplace_back("id", "Functions");
Out.emplace_back(std::make_unique<TagNode>(HTMLTag::TAG_DIV));		Out.emplace_back(std::make_unique<TagNode>(HTMLTag::TAG_DIV));
auto &DivBody = Out.back();		auto &DivBody = Out.back();
for (const auto &F : Functions) {		for (const auto &F : Functions) {
std::vector<std::unique_ptr<TagNode>> Nodes =		std::vector<std::unique_ptr<TagNode>> Nodes =
genHTML(F, CDCtx, ParentInfoDir);		genHTML(F, CDCtx, ParentInfoDir);
AppendVector(std::move(Nodes), DivBody->Children);		AppendVector(std::move(Nodes), DivBody->Children);
}		}
return Out;		return Out;
}		}

static std::vector<std::unique_ptr<TagNode>>		static std::vector<std::unique_ptr<TagNode>>
genRecordMembersBlock(const llvm::SmallVector<MemberTypeInfo, 4> &Members,		genRecordMembersBlock(const llvm::SmallVector<MemberTypeInfo, 4> &Members,
StringRef ParentInfoDir) {		StringRef ParentInfoDir) {
if (Members.empty())		if (Members.empty())
return {};		return {};

std::vector<std::unique_ptr<TagNode>> Out;		std::vector<std::unique_ptr<TagNode>> Out;
Out.emplace_back(std::make_unique<TagNode>(HTMLTag::TAG_H2, "Members"));		Out.emplace_back(std::make_unique<TagNode>(HTMLTag::TAG_H2, "Members"));
Out.back()->Attributes.try_emplace("id", "Members");		Out.back()->Attributes.emplace_back("id", "Members");
Out.emplace_back(std::make_unique<TagNode>(HTMLTag::TAG_UL));		Out.emplace_back(std::make_unique<TagNode>(HTMLTag::TAG_UL));
auto &ULBody = Out.back();		auto &ULBody = Out.back();
for (const auto &M : Members) {		for (const auto &M : Members) {
std::string Access = getAccess(M.Access);		std::string Access = getAccess(M.Access);
if (Access != "")		if (Access != "")
Access = Access + " ";		Access = Access + " ";
auto LIBody = std::make_unique<TagNode>(HTMLTag::TAG_LI);		auto LIBody = std::make_unique<TagNode>(HTMLTag::TAG_LI);
LIBody->Children.emplace_back(std::make_unique<TextNode>(Access));		LIBody->Children.emplace_back(std::make_unique<TextNode>(Access));
LIBody->Children.emplace_back(genReference(M.Type, ParentInfoDir));		LIBody->Children.emplace_back(genReference(M.Type, ParentInfoDir));
LIBody->Children.emplace_back(std::make_unique<TextNode>(" " + M.Name));		LIBody->Children.emplace_back(std::make_unique<TextNode>(" " + M.Name));
ULBody->Children.emplace_back(std::move(LIBody));		ULBody->Children.emplace_back(std::move(LIBody));
}		}
return Out;		return Out;
}		}

static std::vector<std::unique_ptr<TagNode>>		static std::vector<std::unique_ptr<TagNode>>
genReferencesBlock(const std::vector<Reference> &References,		genReferencesBlock(const std::vector<Reference> &References,
llvm::StringRef Title, StringRef ParentPath) {		llvm::StringRef Title, StringRef ParentPath) {
if (References.empty())		if (References.empty())
return {};		return {};

std::vector<std::unique_ptr<TagNode>> Out;		std::vector<std::unique_ptr<TagNode>> Out;
Out.emplace_back(std::make_unique<TagNode>(HTMLTag::TAG_H2, Title));		Out.emplace_back(std::make_unique<TagNode>(HTMLTag::TAG_H2, Title));
Out.back()->Attributes.try_emplace("id", Title);		Out.back()->Attributes.emplace_back("id", Title);
Out.emplace_back(std::make_unique<TagNode>(HTMLTag::TAG_UL));		Out.emplace_back(std::make_unique<TagNode>(HTMLTag::TAG_UL));
auto &ULBody = Out.back();		auto &ULBody = Out.back();
for (const auto &R : References) {		for (const auto &R : References) {
auto LiNode = std::make_unique<TagNode>(HTMLTag::TAG_LI);		auto LiNode = std::make_unique<TagNode>(HTMLTag::TAG_LI);
LiNode->Children.emplace_back(genReference(R, ParentPath));		LiNode->Children.emplace_back(genReference(R, ParentPath));
ULBody->Children.emplace_back(std::move(LiNode));		ULBody->Children.emplace_back(std::move(LiNode));
}		}
return Out;		return Out;
Show All 9 Lines	writeFileDefinition(const Location &L,
SmallString<128> FileURL(RepositoryUrl.getValue());		SmallString<128> FileURL(RepositoryUrl.getValue());
llvm::sys::path::append(FileURL, llvm::sys::path::Style::posix, L.Filename);		llvm::sys::path::append(FileURL, llvm::sys::path::Style::posix, L.Filename);
auto Node = std::make_unique<TagNode>(HTMLTag::TAG_P);		auto Node = std::make_unique<TagNode>(HTMLTag::TAG_P);
Node->Children.emplace_back(std::make_unique<TextNode>("Defined at line "));		Node->Children.emplace_back(std::make_unique<TextNode>("Defined at line "));
auto LocNumberNode =		auto LocNumberNode =
std::make_unique<TagNode>(HTMLTag::TAG_A, std::to_string(L.LineNumber));		std::make_unique<TagNode>(HTMLTag::TAG_A, std::to_string(L.LineNumber));
// The links to a specific line in the source code use the github /		// The links to a specific line in the source code use the github /
// googlesource notation so it won't work for all hosting pages.		// googlesource notation so it won't work for all hosting pages.
LocNumberNode->Attributes.try_emplace(		LocNumberNode->Attributes.emplace_back(
"href", (FileURL + "#" + std::to_string(L.LineNumber)).str());		"href", (FileURL + "#" + std::to_string(L.LineNumber)).str());
Node->Children.emplace_back(std::move(LocNumberNode));		Node->Children.emplace_back(std::move(LocNumberNode));
Node->Children.emplace_back(std::make_unique<TextNode>(" of file "));		Node->Children.emplace_back(std::make_unique<TextNode>(" of file "));
auto LocFileNode = std::make_unique<TagNode>(		auto LocFileNode = std::make_unique<TagNode>(
HTMLTag::TAG_A, llvm::sys::path::filename(FileURL));		HTMLTag::TAG_A, llvm::sys::path::filename(FileURL));
LocFileNode->Attributes.try_emplace("href", FileURL);		LocFileNode->Attributes.emplace_back("href", FileURL);
Node->Children.emplace_back(std::move(LocFileNode));		Node->Children.emplace_back(std::move(LocFileNode));
return Node;		return Node;
}		}

static std::vector<std::unique_ptr<TagNode>>		static std::vector<std::unique_ptr<TagNode>>
genCommonFileNodes(StringRef Title, StringRef InfoPath,		genHTML(const Index &Index, StringRef InfoPath, bool IsOutermostList);

		// Generates a list of child nodes for the HTML head tag
		// It contains a meta node, link nodes to import CSS files, and script nodes to
		// import JS files
		static std::vector<std::unique_ptr<TagNode>>
		genFileHeadNodes(StringRef Title, StringRef InfoPath,
const ClangDocContext &CDCtx) {		const ClangDocContext &CDCtx) {
std::vector<std::unique_ptr<TagNode>> Out;		std::vector<std::unique_ptr<TagNode>> Out;
auto MetaNode = std::make_unique<TagNode>(HTMLTag::TAG_META);		auto MetaNode = std::make_unique<TagNode>(HTMLTag::TAG_META);
MetaNode->Attributes.try_emplace("charset", "utf-8");		MetaNode->Attributes.emplace_back("charset", "utf-8");
Out.emplace_back(std::move(MetaNode));		Out.emplace_back(std::move(MetaNode));
Out.emplace_back(std::make_unique<TagNode>(HTMLTag::TAG_TITLE, Title));		Out.emplace_back(std::make_unique<TagNode>(HTMLTag::TAG_TITLE, Title));
std::vector<std::unique_ptr<TagNode>> StylesheetsNodes =		std::vector<std::unique_ptr<TagNode>> StylesheetsNodes =
genStylesheetsHTML(InfoPath, CDCtx);		genStylesheetsHTML(InfoPath, CDCtx);
AppendVector(std::move(StylesheetsNodes), Out);		AppendVector(std::move(StylesheetsNodes), Out);
std::vector<std::unique_ptr<TagNode>> JsNodes =		std::vector<std::unique_ptr<TagNode>> JsNodes =
genJsScriptsHTML(InfoPath, CDCtx);		genJsScriptsHTML(InfoPath, CDCtx);
AppendVector(std::move(JsNodes), Out);		AppendVector(std::move(JsNodes), Out);
// An empty <div> is generated but the index will be then rendered here
auto IndexNode = std::make_unique<TagNode>(HTMLTag::TAG_DIV);
IndexNode->Attributes.try_emplace("id", "index");
IndexNode->Attributes.try_emplace("path", InfoPath);
Out.emplace_back(std::move(IndexNode));
return Out;		return Out;
}		}

		// Generates a header HTML node that can be used for any file
		// It contains the project name
		static std::unique_ptr<TagNode> genFileHeaderNode(StringRef ProjectName) {
		auto HeaderNode = std::make_unique<TagNode>(HTMLTag::TAG_HEADER, ProjectName);
		HeaderNode->Attributes.emplace_back("id", "project-title");
		return HeaderNode;
		}

		// Generates a main HTML node that has all the main content of an info file
		// It contains both indexes and the info's documented information
		// This function should only be used for the info files (not for the file that
		// only has the general index)
		static std::unique_ptr<TagNode> genInfoFileMainNode(
		StringRef InfoPath,
		std::vector<std::unique_ptr<TagNode>> &MainContentInnerNodes,
		const Index &InfoIndex) {
		auto MainNode = std::make_unique<TagNode>(HTMLTag::TAG_MAIN);

		auto LeftSidebarNode = std::make_unique<TagNode>(HTMLTag::TAG_DIV);
		LeftSidebarNode->Attributes.emplace_back("id", "sidebar-left");
		LeftSidebarNode->Attributes.emplace_back("path", InfoPath);
		LeftSidebarNode->Attributes.emplace_back(
		"class", "col-xs-6 col-sm-3 col-md-2 sidebar sidebar-offcanvas-left");

		auto MainContentNode = std::make_unique<TagNode>(HTMLTag::TAG_DIV);
		MainContentNode->Attributes.emplace_back("id", "main-content");
		MainContentNode->Attributes.emplace_back(
		"class", "col-xs-12 col-sm-9 col-md-8 main-content");
		AppendVector(std::move(MainContentInnerNodes), MainContentNode->Children);

		auto RightSidebarNode = std::make_unique<TagNode>(HTMLTag::TAG_DIV);
		RightSidebarNode->Attributes.emplace_back("id", "sidebar-right");
		RightSidebarNode->Attributes.emplace_back(
		"class", "col-xs-6 col-sm-6 col-md-2 sidebar sidebar-offcanvas-right");
		std::vector<std::unique_ptr<TagNode>> InfoIndexHTML =
		genHTML(InfoIndex, InfoPath, true);
		AppendVector(std::move(InfoIndexHTML), RightSidebarNode->Children);

		MainNode->Children.emplace_back(std::move(LeftSidebarNode));
		MainNode->Children.emplace_back(std::move(MainContentNode));
		MainNode->Children.emplace_back(std::move(RightSidebarNode));

		return MainNode;
		}

		// Generates a footer HTML node that can be used for any file
		// It contains clang-doc's version
		static std::unique_ptr<TagNode> genFileFooterNode() {
		auto FooterNode = std::make_unique<TagNode>(HTMLTag::TAG_FOOTER);
		auto SpanNode = std::make_unique<TagNode>(
		HTMLTag::TAG_SPAN, clang::getClangToolFullVersion("clang-doc"));
		SpanNode->Attributes.emplace_back("class", "no-break");
		FooterNode->Children.emplace_back(std::move(SpanNode));
		return FooterNode;
		}

		// Generates a complete HTMLFile for an Info
		static HTMLFile
		genInfoFile(StringRef Title, StringRef InfoPath,
		std::vector<std::unique_ptr<TagNode>> &MainContentNodes,
		const Index &InfoIndex, const ClangDocContext &CDCtx) {
		HTMLFile F;

		std::vector<std::unique_ptr<TagNode>> HeadNodes =
		genFileHeadNodes(Title, InfoPath, CDCtx);
		std::unique_ptr<TagNode> HeaderNode = genFileHeaderNode(CDCtx.ProjectName);
		std::unique_ptr<TagNode> MainNode =
		genInfoFileMainNode(InfoPath, MainContentNodes, InfoIndex);
		std::unique_ptr<TagNode> FooterNode = genFileFooterNode();

		AppendVector(std::move(HeadNodes), F.Children);
		F.Children.emplace_back(std::move(HeaderNode));
		F.Children.emplace_back(std::move(MainNode));
		F.Children.emplace_back(std::move(FooterNode));

		return F;
		}

template <typename T,		template <typename T,
typename = std::enable_if<std::is_base_of<T, Info>::value>>		typename = std::enable_if<std::is_base_of<T, Info>::value>>
static Index genInfoIndexItem(const std::vector<T> &Infos, StringRef Title) {		static Index genInfoIndexItem(const std::vector<T> &Infos, StringRef Title) {
Index Idx(Title, Title);		Index Idx(Title, Title);
for (const auto &C : Infos)		for (const auto &C : Infos)
Idx.Children.emplace_back(C.extractName(),		Idx.Children.emplace_back(C.extractName(),
llvm::toHex(llvm::toStringRef(C.USR)));		llvm::toHex(llvm::toStringRef(C.USR)));
return Idx;		return Idx;
}		}

static std::vector<std::unique_ptr<TagNode>> genHTML(const Index &Index,		static std::vector<std::unique_ptr<TagNode>>
StringRef InfoPath) {		genHTML(const Index &Index, StringRef InfoPath, bool IsOutermostList) {
std::vector<std::unique_ptr<TagNode>> Out;		std::vector<std::unique_ptr<TagNode>> Out;
if (!Index.Name.empty()) {		if (!Index.Name.empty()) {
Out.emplace_back(std::make_unique<TagNode>(HTMLTag::TAG_SPAN));		Out.emplace_back(std::make_unique<TagNode>(HTMLTag::TAG_SPAN));
auto &SpanBody = Out.back();		auto &SpanBody = Out.back();
if (!Index.JumpToSection)		if (!Index.JumpToSection)
SpanBody->Children.emplace_back(genReference(Index, InfoPath));		SpanBody->Children.emplace_back(genReference(Index, InfoPath));
else		else
SpanBody->Children.emplace_back(genReference(		SpanBody->Children.emplace_back(genReference(
Index, InfoPath, StringRef{Index.JumpToSection.getValue()}));		Index, InfoPath, StringRef{Index.JumpToSection.getValue()}));
}		}
if (Index.Children.empty())		if (Index.Children.empty())
return Out;		return Out;
Out.emplace_back(std::make_unique<TagNode>(HTMLTag::TAG_UL));		// Only the outermost list should use ol, the others should use ul
		HTMLTag ListHTMLTag = IsOutermostList ? HTMLTag::TAG_OL : HTMLTag::TAG_UL;
		Out.emplace_back(std::make_unique<TagNode>(ListHTMLTag));
const auto &UlBody = Out.back();		const auto &UlBody = Out.back();
for (const auto &C : Index.Children) {		for (const auto &C : Index.Children) {
auto LiBody = std::make_unique<TagNode>(HTMLTag::TAG_LI);		auto LiBody = std::make_unique<TagNode>(HTMLTag::TAG_LI);
std::vector<std::unique_ptr<TagNode>> Nodes = genHTML(C, InfoPath);		std::vector<std::unique_ptr<TagNode>> Nodes = genHTML(C, InfoPath, false);
AppendVector(std::move(Nodes), LiBody->Children);		AppendVector(std::move(Nodes), LiBody->Children);
UlBody->Children.emplace_back(std::move(LiBody));		UlBody->Children.emplace_back(std::move(LiBody));
}		}
return Out;		return Out;
}		}

static std::unique_ptr<HTMLNode> genHTML(const CommentInfo &I) {		static std::unique_ptr<HTMLNode> genHTML(const CommentInfo &I) {
if (I.Kind == "FullComment") {		if (I.Kind == "FullComment") {
Show All 37 Lines	genHTML(const EnumInfo &I, const ClangDocContext &CDCtx) {
std::string EnumType;		std::string EnumType;
if (I.Scoped)		if (I.Scoped)
EnumType = "enum class ";		EnumType = "enum class ";
else		else
EnumType = "enum ";		EnumType = "enum ";

Out.emplace_back(		Out.emplace_back(
std::make_unique<TagNode>(HTMLTag::TAG_H3, EnumType + I.Name));		std::make_unique<TagNode>(HTMLTag::TAG_H3, EnumType + I.Name));
Out.back()->Attributes.try_emplace("id",		Out.back()->Attributes.emplace_back("id",
llvm::toHex(llvm::toStringRef(I.USR)));		llvm::toHex(llvm::toStringRef(I.USR)));

std::unique_ptr<TagNode> Node = genEnumMembersBlock(I.Members);		std::unique_ptr<TagNode> Node = genEnumMembersBlock(I.Members);
if (Node)		if (Node)
Out.emplace_back(std::move(Node));		Out.emplace_back(std::move(Node));

if (I.DefLoc) {		if (I.DefLoc) {
if (!CDCtx.RepositoryUrl)		if (!CDCtx.RepositoryUrl)
Out.emplace_back(writeFileDefinition(I.DefLoc.getValue()));		Out.emplace_back(writeFileDefinition(I.DefLoc.getValue()));
Show All 11 Lines

static std::vector<std::unique_ptr<TagNode>>		static std::vector<std::unique_ptr<TagNode>>
genHTML(const FunctionInfo &I, const ClangDocContext &CDCtx,		genHTML(const FunctionInfo &I, const ClangDocContext &CDCtx,
StringRef ParentInfoDir) {		StringRef ParentInfoDir) {
std::vector<std::unique_ptr<TagNode>> Out;		std::vector<std::unique_ptr<TagNode>> Out;
Out.emplace_back(std::make_unique<TagNode>(HTMLTag::TAG_H3, I.Name));		Out.emplace_back(std::make_unique<TagNode>(HTMLTag::TAG_H3, I.Name));
// USR is used as id for functions instead of name to disambiguate function		// USR is used as id for functions instead of name to disambiguate function
// overloads.		// overloads.
Out.back()->Attributes.try_emplace("id",		Out.back()->Attributes.emplace_back("id",
llvm::toHex(llvm::toStringRef(I.USR)));		llvm::toHex(llvm::toStringRef(I.USR)));

Out.emplace_back(std::make_unique<TagNode>(HTMLTag::TAG_P));		Out.emplace_back(std::make_unique<TagNode>(HTMLTag::TAG_P));
auto &FunctionHeader = Out.back();		auto &FunctionHeader = Out.back();

std::string Access = getAccess(I.Access);		std::string Access = getAccess(I.Access);
if (Access != "")		if (Access != "")
FunctionHeader->Children.emplace_back(		FunctionHeader->Children.emplace_back(
std::make_unique<TextNode>(Access + " "));		std::make_unique<TextNode>(Access + " "));
▲ Show 20 Lines • Show All 145 Lines • ▼ Show 20 Lines	llvm::Error generateDocForInfo(Info *I, llvm::raw_ostream &OS,
const ClangDocContext &CDCtx) override;		const ClangDocContext &CDCtx) override;
bool createResources(ClangDocContext &CDCtx) override;		bool createResources(ClangDocContext &CDCtx) override;
};		};

const char *HTMLGenerator::Format = "html";		const char *HTMLGenerator::Format = "html";

llvm::Error HTMLGenerator::generateDocForInfo(Info *I, llvm::raw_ostream &OS,		llvm::Error HTMLGenerator::generateDocForInfo(Info *I, llvm::raw_ostream &OS,
const ClangDocContext &CDCtx) {		const ClangDocContext &CDCtx) {
HTMLFile F;
std::string InfoTitle;		std::string InfoTitle;
auto MainContentNode = std::make_unique<TagNode>(HTMLTag::TAG_DIV);		std::vector<std::unique_ptr<TagNode>> MainContentNodes;
Index InfoIndex;		Index InfoIndex;
switch (I->IT) {		switch (I->IT) {
case InfoType::IT_namespace: {		case InfoType::IT_namespace:
std::vector<std::unique_ptr<TagNode>> Nodes =		MainContentNodes = genHTML(static_cast<clang::doc::NamespaceInfo >(I),
genHTML(static_cast<clang::doc::NamespaceInfo >(I), InfoIndex, CDCtx,		InfoIndex, CDCtx, InfoTitle);
InfoTitle);
AppendVector(std::move(Nodes), MainContentNode->Children);
break;		break;
}		case InfoType::IT_record:
case InfoType::IT_record: {		MainContentNodes = genHTML(static_cast<clang::doc::RecordInfo >(I),
std::vector<std::unique_ptr<TagNode>> Nodes = genHTML(		InfoIndex, CDCtx, InfoTitle);
static_cast<clang::doc::RecordInfo >(I), InfoIndex, CDCtx, InfoTitle);
AppendVector(std::move(Nodes), MainContentNode->Children);
break;		break;
}		case InfoType::IT_enum:
case InfoType::IT_enum: {		MainContentNodes = genHTML(static_cast<clang::doc::EnumInfo >(I), CDCtx);
std::vector<std::unique_ptr<TagNode>> Nodes =
genHTML(static_cast<clang::doc::EnumInfo >(I), CDCtx);
AppendVector(std::move(Nodes), MainContentNode->Children);
break;		break;
}		case InfoType::IT_function:
case InfoType::IT_function: {		MainContentNodes =
std::vector<std::unique_ptr<TagNode>> Nodes =
genHTML(static_cast<clang::doc::FunctionInfo >(I), CDCtx, "");		genHTML(static_cast<clang::doc::FunctionInfo >(I), CDCtx, "");
AppendVector(std::move(Nodes), MainContentNode->Children);
break;		break;
}
case InfoType::IT_default:		case InfoType::IT_default:
return llvm::make_error<llvm::StringError>("Unexpected info type.\n",		return llvm::make_error<llvm::StringError>("Unexpected info type.\n",
llvm::inconvertibleErrorCode());		llvm::inconvertibleErrorCode());
}		}

std::vector<std::unique_ptr<TagNode>> BasicNodes =		HTMLFile F =
genCommonFileNodes(InfoTitle, I->Path, CDCtx);		genInfoFile(InfoTitle, I->Path, MainContentNodes, InfoIndex, CDCtx);
AppendVector(std::move(BasicNodes), F.Children);
std::vector<std::unique_ptr<TagNode>> InfoIndexHTML =
genHTML(InfoIndex, I->Path);
AppendVector(std::move(InfoIndexHTML), F.Children);
F.Children.emplace_back(std::move(MainContentNode));
F.Render(OS);		F.Render(OS);

return llvm::Error::success();		return llvm::Error::success();
}		}

static std::string getRefType(InfoType IT) {		static std::string getRefType(InfoType IT) {
switch (IT) {		switch (IT) {
case InfoType::IT_default:		case InfoType::IT_default:
Show All 36 Lines	std::function<void(Index)> IndexToJSON = [&](Index I) {
});		});
};		};
OS << "var JsonIndex = `\n";		OS << "var JsonIndex = `\n";
IndexToJSON(CDCtx.Idx);		IndexToJSON(CDCtx.Idx);
OS << "`;\n";		OS << "`;\n";
return true;		return true;
}		}

		// Generates a main HTML node that has the main content of the file that shows
		// only the general index
		// It contains the general index with links to all the generated files
		static std::unique_ptr<TagNode> genIndexFileMainNode() {
		auto MainNode = std::make_unique<TagNode>(HTMLTag::TAG_MAIN);

		auto LeftSidebarNode = std::make_unique<TagNode>(HTMLTag::TAG_DIV);
		LeftSidebarNode->Attributes.emplace_back("id", "sidebar-left");
		LeftSidebarNode->Attributes.emplace_back("path", "");
		LeftSidebarNode->Attributes.emplace_back(
		"class", "col-xs-6 col-sm-3 col-md-2 sidebar sidebar-offcanvas-left");
		LeftSidebarNode->Attributes.emplace_back("style", "flex: 0 100%;");

		MainNode->Children.emplace_back(std::move(LeftSidebarNode));

		return MainNode;
		}

static bool GenIndex(const ClangDocContext &CDCtx) {		static bool GenIndex(const ClangDocContext &CDCtx) {
std::error_code FileErr, OK;		std::error_code FileErr, OK;
llvm::SmallString<128> IndexPath;		llvm::SmallString<128> IndexPath;
llvm::sys::path::native(CDCtx.OutDirectory, IndexPath);		llvm::sys::path::native(CDCtx.OutDirectory, IndexPath);
llvm::sys::path::append(IndexPath, "index.html");		llvm::sys::path::append(IndexPath, "index.html");
llvm::raw_fd_ostream IndexOS(IndexPath, FileErr, llvm::sys::fs::F_None);		llvm::raw_fd_ostream IndexOS(IndexPath, FileErr, llvm::sys::fs::F_None);
if (FileErr != OK) {		if (FileErr != OK) {
llvm::errs() << "Error creating main index: " << FileErr.message() << "\n";		llvm::errs() << "Error creating main index: " << FileErr.message() << "\n";
return false;		return false;
}		}

HTMLFile F;		HTMLFile F;
std::vector<std::unique_ptr<TagNode>> BasicNodes =
genCommonFileNodes("Index", "", CDCtx);		std::vector<std::unique_ptr<TagNode>> HeadNodes =
AppendVector(std::move(BasicNodes), F.Children);		genFileHeadNodes("Index", "", CDCtx);
		std::unique_ptr<TagNode> HeaderNode = genFileHeaderNode(CDCtx.ProjectName);
		std::unique_ptr<TagNode> MainNode = genIndexFileMainNode();
		std::unique_ptr<TagNode> FooterNode = genFileFooterNode();

		AppendVector(std::move(HeadNodes), F.Children);
		F.Children.emplace_back(std::move(HeaderNode));
		F.Children.emplace_back(std::move(MainNode));
		F.Children.emplace_back(std::move(FooterNode));

F.Render(IndexOS);		F.Render(IndexOS);

return true;		return true;
}		}

static bool CopyFile(StringRef FilePath, StringRef OutDirectory) {		static bool CopyFile(StringRef FilePath, StringRef OutDirectory) {
llvm::SmallString<128> PathWrite;		llvm::SmallString<128> PathWrite;
llvm::sys::path::native(OutDirectory, PathWrite);		llvm::sys::path::native(OutDirectory, PathWrite);
llvm::sys::path::append(PathWrite, llvm::sys::path::filename(FilePath));		llvm::sys::path::append(PathWrite, llvm::sys::path::filename(FilePath));
llvm::SmallString<128> PathRead;		llvm::SmallString<128> PathRead;
Show All 33 Lines

clang-tools-extra/trunk/clang-doc/Representation.h

	Show First 20 Lines • Show All 407 Lines • ▼ Show 20 Lines
	// A standalone function to call to merge a vector of infos into one.			// A standalone function to call to merge a vector of infos into one.
	// This assumes that all infos in the vector are of the same type, and will fail			// This assumes that all infos in the vector are of the same type, and will fail
	// if they are different.			// if they are different.
	llvm::Expected<std::unique_ptr<Info>>			llvm::Expected<std::unique_ptr<Info>>
	mergeInfos(std::vector<std::unique_ptr<Info>> &Values);			mergeInfos(std::vector<std::unique_ptr<Info>> &Values);

	struct ClangDocContext {			struct ClangDocContext {
	ClangDocContext() = default;			ClangDocContext() = default;
	ClangDocContext(tooling::ExecutionContext *ECtx, bool PublicOnly,			ClangDocContext(tooling::ExecutionContext *ECtx, StringRef ProjectName,
	StringRef OutDirectory, StringRef SourceRoot,			bool PublicOnly, StringRef OutDirectory, StringRef SourceRoot,
	StringRef RepositoryUrl,			StringRef RepositoryUrl,
	std::vector<std::string> UserStylesheets,			std::vector<std::string> UserStylesheets,
	std::vector<std::string> JsScripts);			std::vector<std::string> JsScripts);
	tooling::ExecutionContext *ECtx;			tooling::ExecutionContext *ECtx;
				std::string ProjectName; // Name of project clang-doc is documenting.
	bool PublicOnly; // Indicates if only public declarations are documented.			bool PublicOnly; // Indicates if only public declarations are documented.
	std::string OutDirectory; // Directory for outputting generated files.			std::string OutDirectory; // Directory for outputting generated files.
	std::string SourceRoot; // Directory where processed files are stored. Links			std::string SourceRoot; // Directory where processed files are stored. Links
	// to definition locations will only be generated if			// to definition locations will only be generated if
	// the file is in this dir.			// the file is in this dir.
	// URL of repository that hosts code used for links to definition locations.			// URL of repository that hosts code used for links to definition locations.
	llvm::Optional<std::string> RepositoryUrl;			llvm::Optional<std::string> RepositoryUrl;
	// Path of CSS stylesheets that will be copied to OutDirectory and used to			// Path of CSS stylesheets that will be copied to OutDirectory and used to
	Show All 13 Lines

clang-tools-extra/trunk/clang-doc/Representation.cpp

	Show First 20 Lines • Show All 268 Lines • ▼ Show 20 Lines

	void Index::sort() {			void Index::sort() {
	std::sort(Children.begin(), Children.end());			std::sort(Children.begin(), Children.end());
	for (auto &C : Children)			for (auto &C : Children)
	C.sort();			C.sort();
	}			}

	ClangDocContext::ClangDocContext(tooling::ExecutionContext *ECtx,			ClangDocContext::ClangDocContext(tooling::ExecutionContext *ECtx,
	bool PublicOnly, StringRef OutDirectory,			StringRef ProjectName, bool PublicOnly,
	StringRef SourceRoot, StringRef RepositoryUrl,			StringRef OutDirectory, StringRef SourceRoot,
				StringRef RepositoryUrl,
	std::vector<std::string> UserStylesheets,			std::vector<std::string> UserStylesheets,
	std::vector<std::string> JsScripts)			std::vector<std::string> JsScripts)
	: ECtx(ECtx), PublicOnly(PublicOnly), OutDirectory(OutDirectory),			: ECtx(ECtx), ProjectName(ProjectName), PublicOnly(PublicOnly),
	UserStylesheets(UserStylesheets), JsScripts(JsScripts) {			OutDirectory(OutDirectory), UserStylesheets(UserStylesheets),
				JsScripts(JsScripts) {
	llvm::SmallString<128> SourceRootDir(SourceRoot);			llvm::SmallString<128> SourceRootDir(SourceRoot);
	if (SourceRoot.empty())			if (SourceRoot.empty())
	// If no SourceRoot was provided the current path is used as the default			// If no SourceRoot was provided the current path is used as the default
	llvm::sys::fs::current_path(SourceRootDir);			llvm::sys::fs::current_path(SourceRootDir);
	this->SourceRoot = SourceRootDir.str();			this->SourceRoot = SourceRootDir.str();
	if (!RepositoryUrl.empty()) {			if (!RepositoryUrl.empty()) {
	this->RepositoryUrl = RepositoryUrl;			this->RepositoryUrl = RepositoryUrl;
	if (!RepositoryUrl.empty() && RepositoryUrl.find("http://") != 0 &&			if (!RepositoryUrl.empty() && RepositoryUrl.find("http://") != 0 &&
	RepositoryUrl.find("https://") != 0)			RepositoryUrl.find("https://") != 0)
	this->RepositoryUrl->insert(0, "https://");			this->RepositoryUrl->insert(0, "https://");
	}			}
	}			}

	} // namespace doc			} // namespace doc
	} // namespace clang			} // namespace clang

clang-tools-extra/trunk/clang-doc/assets/clang-doc-default-stylesheet.css

	body,div {			.dark-primary-color { background: #1976D2; }
				.default-primary-color { background: #2196F3; }
				.light-primary-color { background: #BBDEFB; }
				.text-primary-color { color: #FFFFFF; }
				.accent-color { background: #00BCD4; }
				.primary-text-color { color: #212121; }
				.secondary-text-color { color: #727272; }
				.divider-color { border-color: #B6B6B6; }

				/* for layout */
				html,
				body {
	margin: 0;			margin: 0;
	padding: 0;			padding: 0;
				height: 100%;
				width: 100%;
				overflow: hidden;
				box-sizing: border-box;
	}			}

	body[no-overflow] {			, :before, *:after {
	overflow: hidden;			box-sizing: inherit;
	}			}

	li>p:first-child {			body {
	margin-top: 0;			display: flex;
				flex-direction: column;
				min-height: 100vh;
	}			}

	li>p:last-child {			header {
	margin-bottom: 0;			flex: 0 0 50px;
				display: flex;
				flex-direction: row;
				align-items: center;
				padding-left: 30px;
	}			}

	html {			header ol {
	-webkit-box-sizing: border-box;			list-style: none;
	box-sizing: border-box;			margin: 0;
				padding: 0;
	}			}

	,::before,*::after {			header ol li {
	-webkit-box-sizing: inherit;			display: inline;
	box-sizing: inherit;
	}			}

	body,html {			header form {
	color: #202124;			display: flex;
	font: 400 16px/24px Roboto,sans-serif;			flex: 1;
	-moz-osx-font-smoothing: grayscale;			justify-content: flex-end;
	-webkit-font-smoothing: antialiased;			padding-right: 30px;
	height: 100%;
	margin: 36px;
	-webkit-text-size-adjust: 100%;
	-moz-text-size-adjust: 100%;
	-ms-text-size-adjust: 100%;
	text-size-adjust: 100%;
	}			}

	body[devsite-framebox] {			header#header-search-sidebar {
	overflow: hidden;			height: 50px;
				margin-bottom: 25px;
				}

				footer {
				flex: 0 0 16px;
				text-align: center;
				padding: 16px 20px;
				}

				main {
				flex: 1;
				display: flex;
				flex-direction: row;
	padding: 20px;			padding: 20px;
				min-height: 0;
				}

				.sidebar-offcanvas-left {
				flex: 0 1 230px;
				overflow-y: scroll;
				padding: 20px 0 15px 30px;
				margin: 5px 20px 0 0;
				visibility: visible; /* shown by Javascript after scroll position restore */
				}

				::-webkit-scrollbar-button{ display: none; height: 13px; border-radius: 0px; background-color: #AAA; }
				::-webkit-scrollbar-button:hover{ background-color: #AAA; }
				::-webkit-scrollbar-thumb{ background-color: #CCC; }
				::-webkit-scrollbar-thumb:hover{ background-color: #CCC; }
				::-webkit-scrollbar{ width: 4px; }
				/* ::-webkit-overflow-scrolling: touch; */

				.main-content::-webkit-scrollbar{ width: 8px; }

				.main-content {
				flex: 1;
				overflow-y: scroll;
				padding: 10px 20px 0 20px;
				visibility: visible; /* shown by Javascript after scroll position restore */
				}

				.sidebar-offcanvas-right {
				flex: 0 1 12em;
				overflow-y: scroll;
				padding: 20px 15px 15px 15px;
				margin-top: 5px;
				margin-right: 20px;
				visibility: visible; /* shown by Javascript after scroll position restore */
				}
				/* end for layout */

				body {
				-webkit-text-size-adjust: 100%;
				overflow-x: hidden;
				font-family: Roboto, sans-serif;
				font-size: 16px;
				line-height: 1.42857143;
				color: #111111;
				background-color: #fff;
				}

				/* some of this is to reset bootstrap */
				nav.navbar {
				background-color: inherit;
				min-height: 50px;
				border: 0;
				}

				@media (max-width: 768px) {
				.hidden-xs {
				display: none !important;
				}
				}

				@media (min-width: 769px) {
				.hidden-l {
				display: none !important;
				}
				}

				nav.navbar .row {
				padding-top: 8px;
				}

				nav .container {
				white-space: nowrap;
				}

				header {
				background-color: #eeeeee;
				box-shadow: 0 3px 5px rgba(0,0,0,0.1);
				}

				header#project-title {
				background-color: #fff;
				font-size: 200%;
				padding-top: 0.25em;
				padding-bottom: 0.25em;
				/* padding: 0em; */
				}

				header.header-fixed nav.navbar-fixed-top {
				box-shadow: 0 3px 5px rgba(0,0,0,0.1);
				}

				header.container-fluid {
				padding: 0;
				}

				header .masthead {
				padding-top: 64px;
				}

				header .contents {
				padding: 0;
	}			}

	body[sitemask--active] {			@media screen and (max-width:768px) {
				header .contents {
				padding-left: 15px;
				padding-right: 15px;
				}
				}

				a {
				text-decoration: none;
				}

				.body {
				margin-top: 90px;
				}

				section {
				margin-bottom: 36px;
				}

				dl {
				margin: 0;
				}

				h1,
				h2,
				h3,
				h4,
				h5,
				h6 {
				font-family: Roboto, sans-serif;
				font-weight: 400;
				margin-top: 1.5em;
				color: #111111;
				}

				h1.title {
	overflow: hidden;			overflow: hidden;
				text-overflow: ellipsis;
				}

				h1 {
				font-size: 37px;
				margin-top: 0;
				margin-bottom: 0.67em;
				}

				h2 {
				font-size: 28px;
				}

				h5 {
				font-size: 16px;
				}

				.subtitle {
				font-size: 17px;
				min-height: 1.4em;
				}

				.title-description .subtitle {
				white-space: nowrap;
				overflow-x: hidden;
				text-overflow: ellipsis;
	}			}

	p {			p {
				margin-bottom: 1em;
				margin-top: 0;
				}

				a {
				color: #0175C2;
				}

				a:hover {
				color: #13B9FD;
				}

				pre.prettyprint {
				font-family: 'Source Code Pro', Menlo, monospace;
				color: black;
				border-radius: 0;
				font-size: 15px;
				word-wrap: normal;
				line-height: 1.4;
				border: 0;
				margin: 16px 0 16px 0;
				padding: 8px;
				}

				pre code {
				white-space: pre;
				word-wrap: initial;
				font-size: 100%
				}

				.fixed {
				white-space: pre;
				}

				pre {
				border: 1px solid #ddd;
				background-color: #eee;
				font-size: 14px;
				}

				code {
				font-family: 'Source Code Pro', Menlo, monospace;
				/* overriding bootstrap */
				color: inherit;
				padding: 0.2em 0.4em;
				font-size: 85%;
				background-color: rgba(27,31,35,0.05);
				border-radius: 3px;
				}

				@media(max-width: 768px) {
				nav .container {
				width: 100%
				}

				h1 {
				font-size: 24px;
				}

				pre {
	margin: 16px 0;			margin: 16px 0;
				}
				}

				@media (min-width: 768px) {
				ul.subnav li {
				font-size: 17px;
				}
				}

				header h1 {
				font-weight: 400;
				margin-bottom: 16px;
				}

				header a,
				header p,
				header li {
				color: #111111;
				}

				header a:hover {
				color: #0175C2;
				}

				header h1 .kind {
				color: #555;
				}

				dt {
				font-weight: normal;
				}

				dd {
				color: #212121;
				margin-bottom: 1em;
				margin-left: 0;
				}

				dd.callable, dd.constant, dd.property {
				margin-bottom: 24px;
				}

				dd p {
				overflow-x: hidden;
				text-overflow: ellipsis;
				margin-bottom: 0;
				}

				/* indents wrapped lines */
				section.summary dt {
				margin-left: 24px;
				text-indent: -24px;
				}

				.dl-horizontal dd {
				margin-left: initial;
				}

				dl.dl-horizontal dt {
				font-style: normal;
				text-align: left;
				color: #727272;
				margin-right: 20px;
				width: initial;
				}

				dt .name {
				font-weight: 500;
				}

				dl dt.callable .name {
				float: none;
				width: auto;
				}

				.parameter {
				white-space: nowrap;
				}

				.type-parameter {
				white-space: nowrap;
				}

				.multi-line-signature .type-parameter .parameter {
				margin-left: 0px;
				display: unset;
				}

				.signature {
				color: #727272;
				}

				.signature a {
				/* 50% mix of default-primary-color and primary-text-color. */
				color: #4674a2;
				}

				.optional {
				font-style: italic;
				}

				.undocumented {
				font-style: italic;
				}

				.is-const {
				font-style: italic;
				}

				.deprecated {
				text-decoration: line-through;
				}

				.category.linked {
				font-weight: bold;
				opacity: 1;
				}

				/* Colors for category based on categoryOrder in dartdoc_options.config. */
				.category.cp-0 {
				background-color: #54b7c4
				}

				.category.cp-1 {
				background-color: #54c47f
				}

				.category.cp-2 {
				background-color: #c4c254
				}

				.category.cp-3 {
				background-color: #c49f54
				}

				.category.cp-4 {
				background-color: #c45465
				}

				.category.cp-5 {
				background-color: #c454c4
				}

				.category a {
				color: white;
				}

				.category {
				padding: 2px 4px;
				font-size: 12px;
				border-radius: 4px;
				background-color: #999;
				text-transform: uppercase;
				color: white;
				opacity: .5;
				}

				h1 .category {
				vertical-align: middle;
				}

				.source-link {
				padding: 18px 4px;
				vertical-align: middle;
				}

				.source-link .material-icons {
				font-size: 18px;
				}

				@media (max-width: 768px) {
				.source-link {
				padding: 7px 2px;
				font-size: 10px;
				}
				}

				#external-links {
				float: right;
				}

				.btn-group {
				position: relative;
				display: inline-flex;
				vertical-align: middle;
				}

				p.firstline {
				font-weight: bold;
				}

				footer {
				color: #fff;
				background-color: #111111;
				width: 100%;
				}

				footer p {
				margin: 0;
				}

				footer .no-break {
				white-space: nowrap;
				}

				footer .container,
				footer .container-fluid {
				padding-left: 0;
				padding-right: 0;
				}

				footer a, footer a:hover {
				color: #fff;
				}

				.markdown.desc {
				max-width: 700px;
				}

				.markdown h1 {
				font-size: 24px;
				margin-bottom: 8px;
				}

				.markdown h2 {
				font-size: 20px;
				margin-top: 24px;
				margin-bottom: 8px;
				}

				.markdown h3 {
				font-size: 18px;
				margin-bottom: 8px;
				}

				.markdown h4 {
				font-size: 16px;
				margin-bottom: 0;
				}

				.markdown li p {
				margin: 0;
				}

				.gt-separated {
				list-style: none;
	padding: 0;			padding: 0;
				margin: 0;
	}			}

	:link,:visited {			.gt-separated li {
	color: #039be5;			display: inline-block;
	outline: 0;
	text-decoration: none;
	}			}

	ul {			.gt-separated li:before {
				background-image: url("data:image/svg+xml;utf8,<svg xmlns='http://www.w3.org/2000/svg' width='16' height='16' viewBox='0 0 16 16'><path fill='%23DDDDDD' d='M6.7,4L5.7,4.9L8.8,8l-3.1,3.1L6.7,12l4-4L6.7,4z'/></svg>");
				background-position: center;
				content: "\00a0";
				margin: 0 6px 0 4px;
				padding: 0 3px 0 0;
				}

				.gt-separated.dark li:before {
				background-image: url("data:image/svg+xml;utf8,<svg xmlns='http://www.w3.org/2000/svg' width='16' height='16' viewBox='0 0 16 16'><path fill='%23727272' d='M6.7,4L5.7,4.9L8.8,8l-3.1,3.1L6.7,12l4-4L6.7,4z'/></svg>");
				}

				.gt-separated li:first-child:before {
				background-image: none;
				content: "";
	margin: 0;			margin: 0;
	padding-left: 40px;
	}			}

	ul {			/* The slug line under a declaration for things like "const", "read-only", etc. */
	list-style: disc outside;			.features {
				font-style: italic;
				color: #727272;
				}

				.multi-line-signature {
				font-size: 17px;
				color: #727272;
				}

				.multi-line-signature .parameter {
				margin-left: 24px;
				display: block;
	}			}

	li,li p {			.breadcrumbs {
	margin: 12px 0;
	padding: 0;			padding: 0;
				margin: 8px 0 8px 0;
				white-space: nowrap;
				line-height: 1;
	}			}

	*[visually-hidden] {			@media screen and (min-width: 768px) {
	opacity: 0 !important;			nav ol.breadcrumbs {
	pointer-events: none !important;			float: left;
	visibility: hidden !important;			}
	}			}

	*[hidden] {			@media screen and (max-width: 768px) {
	display: none !important;			.breadcrumbs {
				margin: 0 0 24px 0;
				overflow-x: hidden;
				}
	}			}

	[render-hidden] {			.self-crumb {
	display: inline !important;			color: #555;
	position: absolute !important;
	visibility: hidden !important;
	}			}

	*[no-scroll] {			.self-name {
	overflow: hidden;			color: #555;
				display: none;
	}			}

	@supports (display: flex) {			.annotation-list {
	body[ready] .devsite-wrapper {			list-style: none;
	display: -webkit-box;			padding: 0;
	display: -ms-flexbox;			display: inline;
	display: flex;
	-webkit-box-orient: vertical;
	-webkit-box-direction: normal;
	-ms-flex-direction: column;
	flex-direction: column;
	}			}

				.comma-separated {
				list-style: none;
				padding: 0;
				display: inline;
	}			}

	@media screen and (max-width: 840px) {			.comma-separated li {
	body[devsite-book-nav--open] {			display: inline;
	overflow: hidden;
	}			}

				.comma-separated li:after {
				content: ", ";
				}

				.comma-separated li:last-child:after {
				content: "";
				}

				.end-with-period li:last-child:after {
				content: ".";
				}

				.container > section:first-child {
				border: 0;
				}

				.constructor-modifier {
				font-style: italic;
				}

				section.multi-line-signature div.parameters {
				margin-left: 24px;
	}			}

	h1,h2,h3,h4,h5,h6 {			/* subnav styles */

				ul.subnav {
				overflow: auto;
				white-space: nowrap;
				padding-left: 0;
				min-height: 25px;
				}

				ul.subnav::-webkit-scrollbar {
				display: none;
				}

				ul.subnav li {
				display: inline-block;
				text-transform: uppercase;
				}

				ul.subnav li a {
				color: #111;
				}

				ul.subnav li {
				margin-right: 24px;
				}

				ul.subnav li:last-of-type {
				margin-right: 0;
				}

				@media(max-width: 768px) {
				ul.subnav li {
				margin-right: 16px;
				}
				}

				/* sidebar styles */

				.sidebar ol {
				list-style: none;
				line-height: 22px;
				margin-top: 0;
				margin-bottom: 0;
				padding: 0 0 15px 0;
				}

				.sidebar h5 a,
				.sidebar h5 a:hover {
				color: #727272;
				}

				.sidebar h5,
				.sidebar ol li {
				text-overflow: ellipsis;
	overflow: hidden;			overflow: hidden;
				padding: 3px 0;
				}

				.sidebar h5 {
				color: #727272;
				font-size: 18px;
				margin: 0 0 25px 0;
				padding-top: 0;
				}

				.sidebar ol li.section-title {
				font-size: 18px;
				font-weight: normal;
				text-transform: uppercase;
				padding-top: 25px;
				}

				.sidebar ol li.section-subtitle a {
				color: inherit;
				}

				.sidebar ol li.section-subtitle {
				font-weight: 400;
				text-transform: uppercase;
				}

				.sidebar ol li.section-subitem {
				margin-left: 12px;
				}

				.sidebar ol li:first-child {
				padding-top: 0;
				margin-top: 0;
				}

				button {
	padding: 0;			padding: 0;
	text-overflow: ellipsis;
	}			}

	h1 {			#sidenav-left-toggle {
	color: #80868b;			display: none;
	font: 300 34px/40px Roboto,sans-serif;			vertical-align: text-bottom;
	letter-spacing: -0.01em;			padding: 0;
	margin: 40px 0 20px;
	}			}

	[layout=docs] h2 {			/* left-nav disappears, and can transition in from the left */
	border-bottom: 1px solid #e8eaed;			@media screen and (max-width:768px) {
	padding-bottom: 3px;			#sidenav-left-toggle {
				display: inline;
				background: no-repeat url("data:image/svg+xml;utf8,<svg xmlns='http://www.w3.org/2000/svg' width='24' height='24' viewBox='0 0 24 24'><path fill='%23111' d='M3 18h18v-2H3v2zm0-5h18v-2H3v2zm0-7v2h18V6H3z'/></svg>");
				background-position: center;
				width: 24px;
				height: 24px;
				border: none;
				margin-right: 24px;
	}			}

	h2 {			#overlay-under-drawer.active {
	font: 300 24px/32px Roboto,sans-serif;			opacity: 0.4;
	letter-spacing: -0.01em;			height: 100%;
	margin: 40px 0 20px;			z-index: 1999;
				position: fixed;
				top: 0;
				left: 0;
				right: 0;
				bottom: 0;
				background-color: black;
				display: block;
	}			}

	h3 {			.sidebar-offcanvas-left {
	font: 400 20px/32px Roboto,sans-serif;			left: -100%;
	margin: 32px 0 16px;			position: fixed;
				-webkit-transition:all .25s ease-out;
				-o-transition:all .25s ease-out;
				transition:all .25s ease-out;
				z-index: 2000;
				top: 0;
				width: 280px; /* works all the way down to an iphone 4 */
				height: 90%;
				background-color: white;
				overflow-y: scroll; /* TODO: how to hide scroll bars? */
				padding: 10px;
				margin: 10px 10px;
				box-shadow: 5px 5px 5px 5px #444444;
				visibility: hidden; /* shown by Javascript after scroll position restore */
	}			}

	h4,h5,h6 {			ol#sidebar-nav {
	margin: 32px 0 16px;			font-size: 18px;
				white-space: pre-line;
	}			}

	h4 {			.sidebar-offcanvas-left.active {
	font: 500 16px/24px Roboto,sans-serif;			left: 0; /* this animates our drawer into the page */
	}			}

	h5 {			.self-name {
	font: 700 14px/24px Roboto,sans-serif;			display: inline-block;
				}
	}			}

	h6 {			.sidebar-offcanvas-left h5 {
	font: 500 14px/24px Roboto,sans-serif;			margin-bottom: 10px;
	}			}

	h1+h1,h1+h2,h1+h3,h1+h4,h1+h5,h1+h6,h2+h1,h2+h2,h2+h3,h2+h4,h2+h5,h2+h6,h3+h1,h3+h2,h3+h3,h3+h4,h3+h5,h3+h6,h4+h1,h4+h2,h4+h3,h4+h4,h4+h5,h4+h6,h5+h1,h5+h2,h5+h3,h5+h4,h5+h5,h5+h6,h6+h1,h6+h2,h6+h3,h6+h4,h6+h5,h6+h6 {			.sidebar-offcanvas-left h5:last-of-type {
	margin-top: 0;			border: 0;
				margin-bottom: 25px;
	}			}

	@media screen and (max-width: 600px) {			/* the right nav disappears out of view when the window shrinks */
	h1 {			@media screen and (max-width: 992px) {
	font: 300 24px/32px Roboto,sans-serif;			.sidebar-offcanvas-right {
				display: none;
	}			}
	}			}

	[scrollbars]::-webkit-scrollbar {			#overlay-under-drawer {
	height: 8px;			display: none;
	width: 8px;
	}			}

	[scrollbars]::-webkit-scrollbar-thumb {			/* find-as-you-type search box */
	background: rgba(128,134,139,.26);
	border-radius: 8px;			/* override bootstrap defaults */
				.form-control {
				border-radius: 0;
				border: 0;
	}			}

	[no-horizontal-scrollbars]::-webkit-scrollbar {			@media screen and (max-width: 768px) {
	height: 0;			form.search {
	width: 0;			display: none;
				}
	}			}

	[scrollbars]::-webkit-scrollbar-corner {			.typeahead,
	background: 0;			.tt-query,
				.tt-hint {
				width: 200px;
				height: 20px;
				padding: 2px 7px 1px 7px;
				line-height: 20px;
				outline: none;
	}			}

	[background] h2 {			.typeahead {
				background-color: #fff;
				border-radius: 2px;
				}

				.tt-query {
				-webkit-box-shadow: inset 0 1px 1px rgba(0, 0, 0, 0.075);
				-moz-box-shadow: inset 0 1px 1px rgba(0, 0, 0, 0.075);
				box-shadow: inset 0 1px 1px rgba(0, 0, 0, 0.075);
				}

				.tt-hint {
				color: #999
				}

				.navbar-right .tt-menu {
				right:0;
				left: inherit !important;
				width: 422px;
				max-height: 250px;
				overflow-y: scroll;
				}

				.tt-menu {
				font-size: 14px;
				margin: 0;
				padding: 8px 0;
				background-color: #fff;
				border: 1px solid #ccc;
				border: 1px solid rgba(0, 0, 0, 0.2);
				-webkit-box-shadow: 0 5px 10px rgba(0,0,0,.2);
				-moz-box-shadow: 0 5px 10px rgba(0,0,0,.2);
				box-shadow: 0 5px 10px rgba(0,0,0,.2);
				}

				.tt-suggestion {
				padding: 3px 20px;
				color: #212121;
				}

				.tt-suggestion:hover {
				cursor: pointer;
	color: #fff;			color: #fff;
				background-color: #0097cf;
	}			}

	@media print {			.tt-suggestion:hover .search-from-lib {
	body, html, :link, :visited, h1, h2, h3, h4, h5, h6 {			color: #ddd;
	color: #000 !important;			}
	padding-left: 0 !important;
	padding-right: 0 !important;			.tt-suggestion.tt-cursor {
				color: #fff;
				background-color: #0097cf;
				}

				.tt-suggestion.tt-cursor .search-from-lib {
				color: #ddd;
				}

				.tt-suggestion p {
				margin: 0;
				}

				.search-from-lib {
				font-style: italic;
				color: gray;
				}

				#search-box {
				background-color: #ffffff;
	}			}

	:link, :visited {			.search-body {
	text-decoration: underline;			border: 1px solid #7f7f7f;
				max-width: 400px;
				box-shadow: 3px 3px 5px rgba(0,0,0,0.1);
	}			}

				section#setter {
				border-top: 1px solid #ddd;
				padding-top: 36px;
				}

				li.inherited a {
				opacity: 0.65;
				font-style: italic;
				}

				#instance-methods dt.inherited .name,
				#instance-properties dt.inherited .name,
				#operators dt.inherited .name {
				font-weight: 300;
				font-style: italic;
				}

				#instance-methods dt.inherited .signature,
				#instance-properties dt.inherited .signature,
				#operators dt.inherited .signature {
				font-weight: 300;
				}

				@media print {
				.subnav, .sidebar {
				display:none;
	}			}

	@page {			a[href]:after {
	margin: .75in;			content:"" !important;
	}			}
				}
				No newline at end of file

clang-tools-extra/trunk/clang-doc/assets/index.js

Show All 33 Lines	function genLink(Ref, CurrentDirectory) {
Path = append(Path, Ref.Name + ".html")		Path = append(Path, Ref.Name + ".html")
ANode = document.createElement("a");		ANode = document.createElement("a");
ANode.setAttribute("href", Path);		ANode.setAttribute("href", Path);
var TextNode = document.createTextNode(Ref.Name);		var TextNode = document.createTextNode(Ref.Name);
ANode.appendChild(TextNode);		ANode.appendChild(TextNode);
return ANode;		return ANode;
}		}

function genHTMLOfIndex(Index, CurrentDirectory) {		function genHTMLOfIndex(Index, CurrentDirectory, IsOutermostList) {
// Out will store the HTML elements that Index requires to be generated		// Out will store the HTML elements that Index requires to be generated
var Out = [];		var Out = [];
if (Index.Name) {		if (Index.Name) {
var SpanNode = document.createElement("span");		var SpanNode = document.createElement("span");
var TextNode = document.createTextNode(Index.Name);		var TextNode = document.createTextNode(Index.Name);
SpanNode.appendChild(genLink(Index, CurrentDirectory));		SpanNode.appendChild(genLink(Index, CurrentDirectory));
Out.push(SpanNode);		Out.push(SpanNode);
}		}
if (Index.Children.length == 0)		if (Index.Children.length == 0)
return Out;		return Out;
var UlNode = document.createElement("ul");		// Only the outermost list should use ol, the others should use ul
		var ListNodeName = IsOutermostList ? "ol" : "ul";
		var ListNode = document.createElement(ListNodeName);
for (Child of Index.Children) {		for (Child of Index.Children) {
var LiNode = document.createElement("li");		var LiNode = document.createElement("li");
ChildNodes = genHTMLOfIndex(Child, CurrentDirectory);		ChildNodes = genHTMLOfIndex(Child, CurrentDirectory, false);
for (Node of ChildNodes)		for (Node of ChildNodes)
LiNode.appendChild(Node);		LiNode.appendChild(Node);
UlNode.appendChild(LiNode);		ListNode.appendChild(LiNode);
}		}
Out.push(UlNode);		Out.push(ListNode);
return Out;		return Out;
}		}

function createIndex(Index) {		function createIndex(Index) {
// Get the DOM element where the index will be created		// Get the DOM element where the index will be created
var IndexDiv = document.getElementById("index");		var IndexDiv = document.getElementById("sidebar-left");
// Get the relative path of this file		// Get the relative path of this file
CurrentDirectory = IndexDiv.getAttribute("path");		CurrentDirectory = IndexDiv.getAttribute("path");
var IndexNodes = genHTMLOfIndex(Index, CurrentDirectory);		var IndexNodes = genHTMLOfIndex(Index, CurrentDirectory, true);
for (Node of IndexNodes)		for (Node of IndexNodes)
IndexDiv.appendChild(Node);		IndexDiv.appendChild(Node);
}		}

// Runs after DOM loads		// Runs after DOM loads
document.addEventListener("DOMContentLoaded", function() {		document.addEventListener("DOMContentLoaded", function() {
// JsonIndex is a variable from another file that contains the index		// JsonIndex is a variable from another file that contains the index
// in JSON format		// in JSON format
var Index = JSON.parse(JsonIndex);		var Index = JSON.parse(JsonIndex);
createIndex(Index);		createIndex(Index);
});		});

clang-tools-extra/trunk/clang-doc/tool/ClangDocMain.cpp

Show First 20 Lines • Show All 46 Lines • ▼ Show 20 Lines

using namespace clang::ast_matchers;		using namespace clang::ast_matchers;
using namespace clang::tooling;		using namespace clang::tooling;
using namespace clang;		using namespace clang;

static llvm::cl::extrahelp CommonHelp(CommonOptionsParser::HelpMessage);		static llvm::cl::extrahelp CommonHelp(CommonOptionsParser::HelpMessage);
static llvm::cl::OptionCategory ClangDocCategory("clang-doc options");		static llvm::cl::OptionCategory ClangDocCategory("clang-doc options");

		static llvm::cl::opt<std::string>
		ProjectName("project-name", llvm::cl::desc("Name of project."),
		llvm::cl::cat(ClangDocCategory));

static llvm::cl::opt<bool> IgnoreMappingFailures(		static llvm::cl::opt<bool> IgnoreMappingFailures(
"ignore-map-errors",		"ignore-map-errors",
llvm::cl::desc("Continue if files are not mapped correctly."),		llvm::cl::desc("Continue if files are not mapped correctly."),
llvm::cl::init(true), llvm::cl::cat(ClangDocCategory));		llvm::cl::init(true), llvm::cl::cat(ClangDocCategory));

static llvm::cl::opt<std::string>		static llvm::cl::opt<std::string>
OutDirectory("output",		OutDirectory("output",
llvm::cl::desc("Directory for outputting generated files."),		llvm::cl::desc("Directory for outputting generated files."),
▲ Show 20 Lines • Show All 137 Lines • ▼ Show 20 Lines	int main(int argc, const char **argv) {
if (!DoxygenOnly)		if (!DoxygenOnly)
ArgAdjuster = combineAdjusters(		ArgAdjuster = combineAdjusters(
getInsertArgumentAdjuster("-fparse-all-comments",		getInsertArgumentAdjuster("-fparse-all-comments",
tooling::ArgumentInsertPosition::END),		tooling::ArgumentInsertPosition::END),
ArgAdjuster);		ArgAdjuster);

clang::doc::ClangDocContext CDCtx = {		clang::doc::ClangDocContext CDCtx = {
Exec->get()->getExecutionContext(),		Exec->get()->getExecutionContext(),
		ProjectName,
PublicOnly,		PublicOnly,
OutDirectory,		OutDirectory,
SourceRoot,		SourceRoot,
RepositoryUrl,		RepositoryUrl,
{UserStylesheets.begin(), UserStylesheets.end()},		{UserStylesheets.begin(), UserStylesheets.end()},
{"index.js", "index_json.js"}};		{"index.js", "index_json.js"}};

if (Format == "html") {		if (Format == "html") {
▲ Show 20 Lines • Show All 113 Lines • Show Last 20 Lines

clang-tools-extra/trunk/docs/clang-doc.rst

Show First 20 Lines • Show All 83 Lines • ▼ Show 20 Lines	clang-doc options:
--extra-arg-before=<string> - Additional argument to prepend to the compiler command line		--extra-arg-before=<string> - Additional argument to prepend to the compiler command line
--format=<value> - Format for outputted docs.		--format=<value> - Format for outputted docs.
=yaml - Documentation in YAML format.		=yaml - Documentation in YAML format.
=md - Documentation in MD format.		=md - Documentation in MD format.
=html - Documentation in HTML format.		=html - Documentation in HTML format.
--ignore-map-errors - Continue if files are not mapped correctly.		--ignore-map-errors - Continue if files are not mapped correctly.
--output=<string> - Directory for outputting generated files.		--output=<string> - Directory for outputting generated files.
-p=<string> - Build path		-p=<string> - Build path
		--project-name=<string> - Name of project.
--public - Document only public declarations.		--public - Document only public declarations.
--repository=<string> -		--repository=<string> -
URL of repository that hosts code.		URL of repository that hosts code.
Used for links to definition locations.		Used for links to definition locations.
--source-root=<string> -		--source-root=<string> -
Directory where processed files are stored.		Directory where processed files are stored.
Links to definition locations will only be		Links to definition locations will only be
generated if the file is in this dir.		generated if the file is in this dir.
--stylesheets=<string> - CSS stylesheets to extend the default styles.		--stylesheets=<string> - CSS stylesheets to extend the default styles.

The following flags shoud only be used if ``format`` is set to ``html``:		The following flags shoud only be used if ``format`` is set to ``html``:
- ``repository``		- ``repository``
- ``source-root``		- ``source-root``
- ``stylesheets``		- ``stylesheets``

clang-tools-extra/trunk/unittests/clang-doc/HTMLGeneratorTest.cpp

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

#include "ClangDocTest.h"		#include "ClangDocTest.h"
#include "Generators.h"		#include "Generators.h"
#include "Representation.h"		#include "Representation.h"
#include "Serialize.h"		#include "Serialize.h"
		#include "clang/Basic/Version.h"
#include "gtest/gtest.h"		#include "gtest/gtest.h"

namespace clang {		namespace clang {
namespace doc {		namespace doc {

		static const std::string ClangDocVersion =
		clang::getClangToolFullVersion("clang-doc");

std::unique_ptr<Generator> getHTMLGenerator() {		std::unique_ptr<Generator> getHTMLGenerator() {
auto G = doc::findGeneratorByName("html");		auto G = doc::findGeneratorByName("html");
if (!G)		if (!G)
return nullptr;		return nullptr;
return std::move(G.get());		return std::move(G.get());
}		}

ClangDocContext		ClangDocContext
getClangDocContext(std::vector<std::string> UserStylesheets = {},		getClangDocContext(std::vector<std::string> UserStylesheets = {},
StringRef RepositoryUrl = "") {		StringRef RepositoryUrl = "") {
ClangDocContext CDCtx{{}, {}, {}, {}, RepositoryUrl, UserStylesheets, {}};		ClangDocContext CDCtx{
		{}, "test-project", {}, {}, {}, RepositoryUrl, UserStylesheets, {}};
CDCtx.UserStylesheets.insert(		CDCtx.UserStylesheets.insert(
CDCtx.UserStylesheets.begin(),		CDCtx.UserStylesheets.begin(),
"../share/clang/clang-doc-default-stylesheet.css");		"../share/clang/clang-doc-default-stylesheet.css");
CDCtx.JsScripts.emplace_back("index.js");		CDCtx.JsScripts.emplace_back("index.js");
return CDCtx;		return CDCtx;
}		}

TEST(HTMLGeneratorTest, emitNamespaceHTML) {		TEST(HTMLGeneratorTest, emitNamespaceHTML) {
Show All 19 Lines	TEST(HTMLGeneratorTest, emitNamespaceHTML) {
auto Err = G->generateDocForInfo(&I, Actual, CDCtx);		auto Err = G->generateDocForInfo(&I, Actual, CDCtx);
assert(!Err);		assert(!Err);
std::string Expected = R"raw(<!DOCTYPE html>		std::string Expected = R"raw(<!DOCTYPE html>
<meta charset="utf-8"/>		<meta charset="utf-8"/>
<title>namespace Namespace</title>		<title>namespace Namespace</title>
<link rel="stylesheet" href="clang-doc-default-stylesheet.css"/>		<link rel="stylesheet" href="clang-doc-default-stylesheet.css"/>
<link rel="stylesheet" href="user-provided-stylesheet.css"/>		<link rel="stylesheet" href="user-provided-stylesheet.css"/>
<script src="index.js"></script>		<script src="index.js"></script>
<div id="index" path=""></div>		<header id="project-title">test-project</header>
		<main>
		<div id="sidebar-left" path="" class="col-xs-6 col-sm-3 col-md-2 sidebar sidebar-offcanvas-left"></div>
		<div id="main-content" class="col-xs-12 col-sm-9 col-md-8 main-content">
		<h1>namespace Namespace</h1>
		<h2 id="Namespaces">Namespaces</h2>
		<ul>
		<li>
		<a href="Namespace/ChildNamespace.html">ChildNamespace</a>
		</li>
		</ul>
		<h2 id="Records">Records</h2>
<ul>		<ul>
<li>		<li>
		<a href="Namespace/ChildStruct.html">ChildStruct</a>
		</li>
		</ul>
		<h2 id="Functions">Functions</h2>
		<div>
		<h3 id="0000000000000000000000000000000000000000">OneFunction</h3>
		<p>OneFunction()</p>
		</div>
		<h2 id="Enums">Enums</h2>
		<div>
		<h3 id="0000000000000000000000000000000000000000">enum OneEnum</h3>
		</div>
		</div>
		<div id="sidebar-right" class="col-xs-6 col-sm-6 col-md-2 sidebar sidebar-offcanvas-right">
		<ol>
		<li>
<span>		<span>
<a href="#Namespaces">Namespaces</a>		<a href="#Namespaces">Namespaces</a>
</span>		</span>
</li>		</li>
<li>		<li>
<span>		<span>
<a href="#Records">Records</a>		<a href="#Records">Records</a>
</span>		</span>
</li>		</li>
<li>		<li>
<span>		<span>
<a href="#Functions">Functions</a>		<a href="#Functions">Functions</a>
</span>		</span>
<ul>		<ul>
<li>		<li>
<span>		<span>
<a href="#0000000000000000000000000000000000000000">OneFunction</a>		<a href="#0000000000000000000000000000000000000000">OneFunction</a>
</span>		</span>
</li>		</li>
</ul>		</ul>
</li>		</li>
<li>		<li>
<span>		<span>
<a href="#Enums">Enums</a>		<a href="#Enums">Enums</a>
</span>		</span>
<ul>		<ul>
<li>		<li>
<span>		<span>
<a href="#0000000000000000000000000000000000000000">OneEnum</a>		<a href="#0000000000000000000000000000000000000000">OneEnum</a>
</span>		</span>
</li>		</li>
</ul>		</ul>
</li>		</li>
</ul>		</ol>
<div>
<h1>namespace Namespace</h1>
<h2 id="Namespaces">Namespaces</h2>
<ul>
<li>
<a href="Namespace/ChildNamespace.html">ChildNamespace</a>
</li>
</ul>
<h2 id="Records">Records</h2>
<ul>
<li>
<a href="Namespace/ChildStruct.html">ChildStruct</a>
</li>
</ul>
<h2 id="Functions">Functions</h2>
<div>
<h3 id="0000000000000000000000000000000000000000">OneFunction</h3>
<p>OneFunction()</p>
</div>
<h2 id="Enums">Enums</h2>
<div>
<h3 id="0000000000000000000000000000000000000000">enum OneEnum</h3>
</div>
</div>		</div>
		</main>
		<footer>
		<span class="no-break">)raw" +
		ClangDocVersion + R"raw(</span>
		</footer>
)raw";		)raw";

EXPECT_EQ(Expected, Actual.str());		EXPECT_EQ(Expected, Actual.str());
}		}

TEST(HTMLGeneratorTest, emitRecordHTML) {		TEST(HTMLGeneratorTest, emitRecordHTML) {
RecordInfo I;		RecordInfo I;
I.Name = "r";		I.Name = "r";
Show All 24 Lines	TEST(HTMLGeneratorTest, emitRecordHTML) {
ClangDocContext CDCtx = getClangDocContext({}, "http://www.repository.com");		ClangDocContext CDCtx = getClangDocContext({}, "http://www.repository.com");
auto Err = G->generateDocForInfo(&I, Actual, CDCtx);		auto Err = G->generateDocForInfo(&I, Actual, CDCtx);
assert(!Err);		assert(!Err);
std::string Expected = R"raw(<!DOCTYPE html>		std::string Expected = R"raw(<!DOCTYPE html>
<meta charset="utf-8"/>		<meta charset="utf-8"/>
<title>class r</title>		<title>class r</title>
<link rel="stylesheet" href="../../../clang-doc-default-stylesheet.css"/>		<link rel="stylesheet" href="../../../clang-doc-default-stylesheet.css"/>
<script src="../../../index.js"></script>		<script src="../../../index.js"></script>
<div id="index" path="X/Y/Z"></div>		<header id="project-title">test-project</header>
<ul>		<main>
<li>		<div id="sidebar-left" path="X/Y/Z" class="col-xs-6 col-sm-3 col-md-2 sidebar sidebar-offcanvas-left"></div>
<span>		<div id="main-content" class="col-xs-12 col-sm-9 col-md-8 main-content">
<a href="#Members">Members</a>
</span>
</li>
<li>
<span>
<a href="#Records">Records</a>
</span>
</li>
<li>
<span>
<a href="#Functions">Functions</a>
</span>
<ul>
<li>
<span>
<a href="#0000000000000000000000000000000000000000">OneFunction</a>
</span>
</li>
</ul>
</li>
<li>
<span>
<a href="#Enums">Enums</a>
</span>
<ul>
<li>
<span>
<a href="#0000000000000000000000000000000000000000">OneEnum</a>
</span>
</li>
</ul>
</li>
</ul>
<div>
<h1>class r</h1>		<h1>class r</h1>
<p>		<p>
Defined at line		Defined at line
<a href="http://www.repository.com/dir/test.cpp#10">10</a>		<a href="http://www.repository.com/dir/test.cpp#10">10</a>
of file		of file
<a href="http://www.repository.com/dir/test.cpp">test.cpp</a>		<a href="http://www.repository.com/dir/test.cpp">test.cpp</a>
</p>		</p>
<p>		<p>
Inherits from		Inherits from
<a href="../../../path/to/F.html">F</a>		<a href="../../../path/to/F.html">F</a>
, G		, G
</p>		</p>
<h2 id="Members">Members</h2>		<h2 id="Members">Members</h2>
<ul>		<ul>
<li>		<li>
private		private
<a href="../int.html">int</a>		<a href="../int.html">int</a>
X		X
</li>		</li>
</ul>		</ul>
<h2 id="Records">Records</h2>		<h2 id="Records">Records</h2>
<ul>		<ul>
<li>		<li>
<a href="r/ChildStruct.html">ChildStruct</a>		<a href="r/ChildStruct.html">ChildStruct</a>
</li>		</li>
</ul>		</ul>
<h2 id="Functions">Functions</h2>		<h2 id="Functions">Functions</h2>
<div>		<div>
<h3 id="0000000000000000000000000000000000000000">OneFunction</h3>		<h3 id="0000000000000000000000000000000000000000">OneFunction</h3>
<p>public OneFunction()</p>		<p>public OneFunction()</p>
</div>		</div>
<h2 id="Enums">Enums</h2>		<h2 id="Enums">Enums</h2>
<div>		<div>
<h3 id="0000000000000000000000000000000000000000">enum OneEnum</h3>		<h3 id="0000000000000000000000000000000000000000">enum OneEnum</h3>
</div>		</div>
</div>		</div>
		<div id="sidebar-right" class="col-xs-6 col-sm-6 col-md-2 sidebar sidebar-offcanvas-right">
		<ol>
		<li>
		<span>
		<a href="#Members">Members</a>
		</span>
		</li>
		<li>
		<span>
		<a href="#Records">Records</a>
		</span>
		</li>
		<li>
		<span>
		<a href="#Functions">Functions</a>
		</span>
		<ul>
		<li>
		<span>
		<a href="#0000000000000000000000000000000000000000">OneFunction</a>
		</span>
		</li>
		</ul>
		</li>
		<li>
		<span>
		<a href="#Enums">Enums</a>
		</span>
		<ul>
		<li>
		<span>
		<a href="#0000000000000000000000000000000000000000">OneEnum</a>
		</span>
		</li>
		</ul>
		</li>
		</ol>
		</div>
		</main>
		<footer>
		<span class="no-break">)raw" +
		ClangDocVersion + R"raw(</span>
		</footer>
)raw";		)raw";

EXPECT_EQ(Expected, Actual.str());		EXPECT_EQ(Expected, Actual.str());
}		}

TEST(HTMLGeneratorTest, emitFunctionHTML) {		TEST(HTMLGeneratorTest, emitFunctionHTML) {
FunctionInfo I;		FunctionInfo I;
I.Name = "f";		I.Name = "f";
Show All 18 Lines	TEST(HTMLGeneratorTest, emitFunctionHTML) {
ClangDocContext CDCtx = getClangDocContext({}, "https://www.repository.com");		ClangDocContext CDCtx = getClangDocContext({}, "https://www.repository.com");
auto Err = G->generateDocForInfo(&I, Actual, CDCtx);		auto Err = G->generateDocForInfo(&I, Actual, CDCtx);
assert(!Err);		assert(!Err);
std::string Expected = R"raw(<!DOCTYPE html>		std::string Expected = R"raw(<!DOCTYPE html>
<meta charset="utf-8"/>		<meta charset="utf-8"/>
<title></title>		<title></title>
<link rel="stylesheet" href="clang-doc-default-stylesheet.css"/>		<link rel="stylesheet" href="clang-doc-default-stylesheet.css"/>
<script src="index.js"></script>		<script src="index.js"></script>
<div id="index" path=""></div>		<header id="project-title">test-project</header>
<div>		<main>
		<div id="sidebar-left" path="" class="col-xs-6 col-sm-3 col-md-2 sidebar sidebar-offcanvas-left"></div>
		<div id="main-content" class="col-xs-12 col-sm-9 col-md-8 main-content">
<h3 id="0000000000000000000000000000000000000000">f</h3>		<h3 id="0000000000000000000000000000000000000000">f</h3>
<p>		<p>
<a href="path/to/float.html">float</a>		<a href="path/to/float.html">float</a>
f(		f(
<a href="path/to/int.html">int</a>		<a href="path/to/int.html">int</a>
P)		P)
</p>		</p>
<p>Defined at line 10 of file dir/test.cpp</p>		<p>Defined at line 10 of file dir/test.cpp</p>
</div>		</div>
		<div id="sidebar-right" class="col-xs-6 col-sm-6 col-md-2 sidebar sidebar-offcanvas-right"></div>
		</main>
		<footer>
		<span class="no-break">)raw" +
		ClangDocVersion + R"raw(</span>
		</footer>
)raw";		)raw";

EXPECT_EQ(Expected, Actual.str());		EXPECT_EQ(Expected, Actual.str());
}		}

TEST(HTMLGeneratorTest, emitEnumHTML) {		TEST(HTMLGeneratorTest, emitEnumHTML) {
EnumInfo I;		EnumInfo I;
I.Name = "e";		I.Name = "e";
Show All 12 Lines	TEST(HTMLGeneratorTest, emitEnumHTML) {
ClangDocContext CDCtx = getClangDocContext({}, "www.repository.com");		ClangDocContext CDCtx = getClangDocContext({}, "www.repository.com");
auto Err = G->generateDocForInfo(&I, Actual, CDCtx);		auto Err = G->generateDocForInfo(&I, Actual, CDCtx);
assert(!Err);		assert(!Err);
std::string Expected = R"raw(<!DOCTYPE html>		std::string Expected = R"raw(<!DOCTYPE html>
<meta charset="utf-8"/>		<meta charset="utf-8"/>
<title></title>		<title></title>
<link rel="stylesheet" href="clang-doc-default-stylesheet.css"/>		<link rel="stylesheet" href="clang-doc-default-stylesheet.css"/>
<script src="index.js"></script>		<script src="index.js"></script>
<div id="index" path=""></div>		<header id="project-title">test-project</header>
<div>		<main>
		<div id="sidebar-left" path="" class="col-xs-6 col-sm-3 col-md-2 sidebar sidebar-offcanvas-left"></div>
		<div id="main-content" class="col-xs-12 col-sm-9 col-md-8 main-content">
<h3 id="0000000000000000000000000000000000000000">enum class e</h3>		<h3 id="0000000000000000000000000000000000000000">enum class e</h3>
<ul>		<ul>
<li>X</li>		<li>X</li>
</ul>		</ul>
<p>		<p>
Defined at line		Defined at line
<a href="https://www.repository.com/test.cpp#10">10</a>		<a href="https://www.repository.com/test.cpp#10">10</a>
of file		of file
<a href="https://www.repository.com/test.cpp">test.cpp</a>		<a href="https://www.repository.com/test.cpp">test.cpp</a>
</p>		</p>
</div>		</div>
		<div id="sidebar-right" class="col-xs-6 col-sm-6 col-md-2 sidebar sidebar-offcanvas-right"></div>
		</main>
		<footer>
		<span class="no-break">)raw" +
		ClangDocVersion + R"raw(</span>
		</footer>
)raw";		)raw";

EXPECT_EQ(Expected, Actual.str());		EXPECT_EQ(Expected, Actual.str());
}		}

TEST(HTMLGeneratorTest, emitCommentHTML) {		TEST(HTMLGeneratorTest, emitCommentHTML) {
FunctionInfo I;		FunctionInfo I;
I.Name = "f";		I.Name = "f";
▲ Show 20 Lines • Show All 48 Lines • ▼ Show 20 Lines	TEST(HTMLGeneratorTest, emitCommentHTML) {
ClangDocContext CDCtx = getClangDocContext();		ClangDocContext CDCtx = getClangDocContext();
auto Err = G->generateDocForInfo(&I, Actual, CDCtx);		auto Err = G->generateDocForInfo(&I, Actual, CDCtx);
assert(!Err);		assert(!Err);
std::string Expected = R"raw(<!DOCTYPE html>		std::string Expected = R"raw(<!DOCTYPE html>
<meta charset="utf-8"/>		<meta charset="utf-8"/>
<title></title>		<title></title>
<link rel="stylesheet" href="clang-doc-default-stylesheet.css"/>		<link rel="stylesheet" href="clang-doc-default-stylesheet.css"/>
<script src="index.js"></script>		<script src="index.js"></script>
<div id="index" path=""></div>		<header id="project-title">test-project</header>
<div>		<main>
		<div id="sidebar-left" path="" class="col-xs-6 col-sm-3 col-md-2 sidebar sidebar-offcanvas-left"></div>
		<div id="main-content" class="col-xs-12 col-sm-9 col-md-8 main-content">
<h3 id="0000000000000000000000000000000000000000">f</h3>		<h3 id="0000000000000000000000000000000000000000">f</h3>
<p>void f(int I, int J)</p>		<p>void f(int I, int J)</p>
<p>Defined at line 10 of file test.cpp</p>		<p>Defined at line 10 of file test.cpp</p>
<div>		<div>
<div>		<div>
<p> Brief description.</p>		<p> Brief description.</p>
<p> Extended description that continues onto the next line.</p>		<p> Extended description that continues onto the next line.</p>
<p> Comment with html entities: &, <, >, ", '.</p>		<p> Comment with html entities: &, <, >, ", '.</p>
</div>		</div>
</div>		</div>
</div>		</div>
		<div id="sidebar-right" class="col-xs-6 col-sm-6 col-md-2 sidebar sidebar-offcanvas-right"></div>
		</main>
		<footer>
		<span class="no-break">)raw" +
		ClangDocVersion + R"raw(</span>
		</footer>
)raw";		)raw";

EXPECT_EQ(Expected, Actual.str());		EXPECT_EQ(Expected, Actual.str());
}		}

} // namespace doc		} // namespace doc
} // namespace clang		} // namespace clang

This is an archive of the discontinued LLVM Phabricator instance.

[clang-doc] Redesign of generated HTML files
ClosedPublic

Details

Diff Detail

Event Timeline

Revision Contents

Diff 215649

clang-tools-extra/trunk/clang-doc/HTMLGenerator.cpp

clang-tools-extra/trunk/clang-doc/Representation.h

clang-tools-extra/trunk/clang-doc/Representation.cpp

clang-tools-extra/trunk/clang-doc/assets/clang-doc-default-stylesheet.css

clang-tools-extra/trunk/clang-doc/assets/index.js

clang-tools-extra/trunk/clang-doc/tool/ClangDocMain.cpp

clang-tools-extra/trunk/docs/clang-doc.rst

clang-tools-extra/trunk/unittests/clang-doc/HTMLGeneratorTest.cpp

This is an archive of the discontinued LLVM Phabricator instance.

[clang-doc] Redesign of generated HTML filesClosedPublic

Details

Diff Detail

Event Timeline

Revision Contents

Diff 215649

clang-tools-extra/trunk/clang-doc/HTMLGenerator.cpp

clang-tools-extra/trunk/clang-doc/Representation.h

clang-tools-extra/trunk/clang-doc/Representation.cpp

clang-tools-extra/trunk/clang-doc/assets/clang-doc-default-stylesheet.css

clang-tools-extra/trunk/clang-doc/assets/index.js

clang-tools-extra/trunk/clang-doc/tool/ClangDocMain.cpp

clang-tools-extra/trunk/docs/clang-doc.rst

clang-tools-extra/trunk/unittests/clang-doc/HTMLGeneratorTest.cpp

[clang-doc] Redesign of generated HTML files
ClosedPublic