From 224c700a1fb0b7f6abd85a9729d29cbbdf5872dd Mon Sep 17 00:00:00 2001 From: Cary Clark Date: Wed, 27 Jun 2018 11:00:21 -0400 Subject: sync docs up with tip of tree Also check in work in progress for blend modes, round rects, and a placeholder for pictures. One minor include change to add a parameter name for SkBlendMode function. TBR=reed@google.com R=caryclark@google.com Docs-Preview: https://skia.org/?cl=134200 Bug: skia:6898 Change-Id: I5d2a9221d61edb32d9c7edbb3193401605b2b513 Reviewed-on: https://skia-review.googlesource.com/134200 Reviewed-by: Cary Clark Reviewed-by: Cary Clark Commit-Queue: Cary Clark Auto-Submit: Cary Clark --- tools/bookmaker/bookmaker.cpp | 51 ++++++--------- tools/bookmaker/bookmaker.h | 34 ++++++---- tools/bookmaker/includeParser.cpp | 131 ++++++++++++++++++++++++++------------ tools/bookmaker/includeWriter.cpp | 12 ++-- tools/bookmaker/mdOut.cpp | 25 ++++++-- tools/bookmaker/spellCheck.cpp | 2 - 6 files changed, 155 insertions(+), 100 deletions(-) (limited to 'tools/bookmaker') diff --git a/tools/bookmaker/bookmaker.cpp b/tools/bookmaker/bookmaker.cpp index 947c0770e3..58c73e663f 100644 --- a/tools/bookmaker/bookmaker.cpp +++ b/tools/bookmaker/bookmaker.cpp @@ -133,16 +133,15 @@ BmhParser::MarkProps BmhParser::kMarkProps[] = { , { "Code", MarkType::kCode, R_F, E_N, M_CSST | M_E | M_MD | M(Typedef) } , { "", MarkType::kColumn, R_Y, E_N, M(Row) } , { "", MarkType::kComment, R_N, E_N, 0 } -, { "Const", MarkType::kConst, R_Y, E_O, M_E | M_ST } +, { "Const", MarkType::kConst, R_Y, E_O, M_E | M_CSST } , { "Define", MarkType::kDefine, R_O, E_Y, M_ST } -, { "DefinedBy", MarkType::kDefinedBy, R_N, E_N, M(Method) } , { "Deprecated", MarkType::kDeprecated, R_Y, E_N, M_CS | M_MDCM | M_E } , { "Description", MarkType::kDescription, R_Y, E_N, M(Example) | M(NoExample) } , { "Details", MarkType::kDetails, R_N, E_N, M(Const) } , { "Duration", MarkType::kDuration, R_N, E_N, M(Example) | M(NoExample) } , { "Enum", MarkType::kEnum, R_Y, E_O, M_CSST } , { "EnumClass", MarkType::kEnumClass, R_Y, E_O, M_CSST } -, { "Example", MarkType::kExample, R_O, E_N, M_CSST | M_E | M_MD } +, { "Example", MarkType::kExample, R_O, E_N, M_CSST | M_E | M_MD | M(Const) } , { "Experimental", MarkType::kExperimental, R_Y, E_N, M_CS | M_MDCM | M_E } , { "External", MarkType::kExternal, R_Y, E_N, 0 } , { "File", MarkType::kFile, R_Y, E_N, M(Topic) } @@ -165,12 +164,12 @@ BmhParser::MarkProps BmhParser::kMarkProps[] = { , { "NoJustify", MarkType::kNoJustify, R_N, E_N, M(Const) | M(Member) } , { "Outdent", MarkType::kOutdent, R_N, E_N, M(Code) } , { "Param", MarkType::kParam, R_Y, E_N, M(Method) | M(Define) } -, { "PhraseDef", MarkType::kPhraseDef, R_Y, E_N, M(Subtopic) } +, { "PhraseDef", MarkType::kPhraseDef, R_Y, E_N, M_ST } , { "", MarkType::kPhraseParam, R_Y, E_N, 0 } , { "", MarkType::kPhraseRef, R_N, E_N, 0 } , { "Platform", MarkType::kPlatform, R_N, E_N, M(Example) | M(NoExample) } , { "Populate", MarkType::kPopulate, R_N, E_N, M(Subtopic) } -, { "Private", MarkType::kPrivate, R_Y, E_N, M_CSST | M_MDCM | M_E } +, { "Private", MarkType::kPrivate, R_N, E_N, M_CSST | M_MDCM | M_E } , { "Return", MarkType::kReturn, R_Y, E_N, M(Method) } , { "", MarkType::kRow, R_Y, E_N, M(Table) | M(List) } , { "SeeAlso", MarkType::kSeeAlso, R_C, E_N, M_CSST | M_E | M_MD | M(Typedef) } @@ -401,29 +400,6 @@ bool BmhParser::addDefinition(const char* defStart, bool hasEnd, MarkType markTy } break; // these types are children of parents, but are not in named maps - case MarkType::kDefinedBy: { - string prefixed(fRoot->fName); - const char* start = fChar; - string name(start, this->trimmedBracketEnd(fMC) - start); - prefixed += "::" + name; - this->skipToEndBracket(fMC); - const auto leafIter = fRoot->fLeaves.find(prefixed); - if (fRoot->fLeaves.end() != leafIter) { - this->reportError("DefinedBy already defined"); - } - definition = &fRoot->fLeaves[prefixed]; - definition->fParent = fParent; - definition->fStart = defStart; - definition->fContentStart = start; - definition->fName = name; - definition->fFiddle = Definition::NormalizedName(name); - definition->fContentEnd = fChar; - this->skipToEndBracket('\n'); - definition->fTerminator = fChar; - definition->fMarkType = markType; - definition->fLineCount = fLineCount; - fParent->fChildren.push_back(definition); - } break; case MarkType::kDescription: case MarkType::kStdOut: // may be one-liner @@ -1761,6 +1737,17 @@ string BmhParser::methodName() { if (!paren) { return this->reportError("missing method name and reference"); } + { + TextParserSave endCheck(this); + while (end < fEnd && !this->strnchr(')', end)) { + fChar = end + 1; + end = this->lineEnd(); + } + if (end >= fEnd) { + return this->reportError("missing method end paren"); + } + endCheck.restore(); + } const char* nameStart = paren; char ch; bool expectOperator = false; @@ -1803,10 +1790,13 @@ string BmhParser::methodName() { } const Definition* parent = this->parentSpace(); if (parent && parent->fName.length() > 0) { - if (parent->fName == name) { + size_t parentNameIndex = parent->fName.rfind(':'); + parentNameIndex = string::npos == parentNameIndex ? 0 : parentNameIndex + 1; + string parentName = parent->fName.substr(parentNameIndex); + if (parentName == name) { isConstructor = true; } else if ('~' == name[0]) { - if (parent->fName != name.substr(1)) { + if (parentName != name.substr(1)) { return this->reportError("expected destructor"); } isConstructor = true; @@ -2220,7 +2210,6 @@ vector BmhParser::typeName(MarkType markType, bool* checkEnd) { case MarkType::kAlias: case MarkType::kAnchor: case MarkType::kBug: // fixme: expect number - case MarkType::kDefinedBy: case MarkType::kDeprecated: case MarkType::kDetails: case MarkType::kDuration: diff --git a/tools/bookmaker/bookmaker.h b/tools/bookmaker/bookmaker.h index 3616e2058f..24d56176aa 100644 --- a/tools/bookmaker/bookmaker.h +++ b/tools/bookmaker/bookmaker.h @@ -94,7 +94,6 @@ enum class MarkType { kComment, kConst, kDefine, - kDefinedBy, kDeprecated, kDescription, kDetails, // used by #Const to specify #Subtopic details with examples and so on @@ -113,7 +112,7 @@ enum class MarkType { kIn, kLegend, kLine, - kLink, + kLink, // used internally by #Anchor kList, kLiteral, // don't lookup hyperlinks, do substitution, etc kMarkChar, @@ -906,8 +905,7 @@ public: const Definition* iRootParent() const { const Definition* test = fParent; while (test) { - if (Type::kKeyWord == test->fType - && (KeyWord::kClass == test->fKeyWord || KeyWord::kStruct == test->fKeyWord)) { + if (KeyWord::kClass == test->fKeyWord || KeyWord::kStruct == test->fKeyWord) { return test; } test = test->fParent; @@ -1158,9 +1156,6 @@ public: } void indentOut() { - if (fIndent < 4) { // FIXME: hack until I can debug again - return; - } SkASSERT(fIndent >= 4); SkASSERT(fIndentStack.back().fIndent == fIndent); fIndent -= 4; @@ -1569,6 +1564,7 @@ public: void dumpClassTokens(IClassDefinition& classDef); void dumpComment(const Definition& ); void dumpCommonTail(const Definition& ); + void dumpConst(const Definition& , string className); void dumpDefine(const Definition& ); void dumpEnum(const Definition& , string name); bool dumpGlobals(); @@ -1580,10 +1576,12 @@ public: Definition* findIncludeObject(const Definition& includeDef, MarkType markType, string typeName); static KeyWord FindKey(const char* start, const char* end); + Bracket grandParentBracket() const; bool isClone(const Definition& token); bool isConstructor(const Definition& token, string className); bool isInternalName(const Definition& token); bool isOperator(const Definition& token); + Definition* parentBracket(Definition* parent) const; bool parseChar(); bool parseComment(string filename, const char* start, const char* end, int lineCount, Definition* markupDef); @@ -1611,6 +1609,10 @@ public: bool parseUnion(); void popBracket() { + if (Definition::Type::kKeyWord == fParent->fType + && KeyWord::kTypename == fParent->fKeyWord) { + this->popObject(); + } SkASSERT(Definition::Type::kBracket == fParent->fType); this->popObject(); Bracket bracket = this->topBracket(); @@ -1657,13 +1659,7 @@ public: fInCharCommentString = fInChar || fInComment || fInString; } - Bracket topBracket() const { - Definition* parent = fParent; - while (parent && Definition::Type::kBracket != parent->fType) { - parent = parent->fParent; - } - return parent ? parent->fBracket : Bracket::kNone; - } + Bracket topBracket() const; template string uniqueName(const unordered_map& m, string typeName) { @@ -1803,6 +1799,16 @@ public: this->writeTag(tagType, tagID.c_str()); } + void writeTagTable(string tagType, string body) { + this->writeTag(tagType.c_str()); + this->writeSpace(1); + this->writeString("#"); + this->writeSpace(1); + this->writeString(body); + this->writeSpace(1); + this->writeString("##"); + } + protected: static void ValidateKeyWords(); diff --git a/tools/bookmaker/includeParser.cpp b/tools/bookmaker/includeParser.cpp index d6aa447fc4..fdaf0ccfe2 100644 --- a/tools/bookmaker/includeParser.cpp +++ b/tools/bookmaker/includeParser.cpp @@ -136,6 +136,12 @@ bool IncludeParser::checkForWord() { return true; } KeyWord keyWord = FindKey(fIncludeWord, fChar); + if (KeyWord::kClass == keyWord || KeyWord::kStruct == keyWord) { + Bracket bracket = this->topBracket(); + if (Bracket::kParen == bracket) { + return true; + } + } if (KeyWord::kNone != keyWord) { if (KeyProperty::kPreprocessor != kKeyWords[(int) keyWord].fProperty) { this->addKeyword(keyWord); @@ -360,9 +366,6 @@ bool IncludeParser::crossCheck(BmhParser& bmhParser) { } if (def->crossCheck2(token)) { def->fVisited = true; - if (MarkType::kDefinedBy == def->fMarkType) { - def->fParent->fVisited = true; - } if (token.fDeprecated && !def->fDeprecated) { fFailed = !def->reportError("expect bmh to be marked deprecated"); } @@ -556,6 +559,9 @@ void IncludeParser::dumpClassTokens(IClassDefinition& classDef) { this->writeBlockSeparator(); } switch (token.fMarkType) { + case MarkType::kConst: + this->dumpConst(token, classDef.fName); + break; case MarkType::kEnum: case MarkType::kEnumClass: this->dumpEnum(token, token.fName); @@ -753,6 +759,15 @@ void IncludeParser::dumpCommonTail(const Definition& token) { this->lf(2); } +void IncludeParser::dumpConst(const Definition& token, string className) { + this->writeTag("Const"); + this->writeSpace(); + this->writeString(token.fName); + this->writeTagTable("Line", "incomplete"); + this->lf(2); + this->dumpComment(token); +} + void IncludeParser::dumpDefine(const Definition& token) { this->writeTag("Define", token.fName); this->lf(2); @@ -859,6 +874,10 @@ void IncludeParser::dumpEnum(const Definition& token, string name) { } bool IncludeParser::dumpGlobals() { + if (fIDefineMap.empty() && fIFunctionMap.empty() && fIEnumMap.empty() && fITemplateMap.empty() + && fITypedefMap.empty() && fIUnionMap.empty()) { + return true; + } size_t lastBSlash = fFileName.rfind('\\'); size_t lastSlash = fFileName.rfind('/'); size_t lastDotH = fFileName.rfind(".h"); @@ -881,16 +900,10 @@ bool IncludeParser::dumpGlobals() { string topicName = globalsName.length() > 2 && isupper(globalsName[2]) && ("Sk" == prefixName || "Gr" == prefixName) ? globalsName.substr(2) : globalsName; this->writeTagNoLF("Topic", topicName); - this->writeTag("Alias", topicName + "_Reference"); + this->writeEndTag("Alias", topicName + "_Reference"); this->lf(2); this->writeTag("Subtopic", "Overview"); - fIndent += 4; - this->writeTag("Subtopic", "Subtopic"); - fIndent += 4; this->writeTag("Populate"); - fIndent -= 4; - this->writeEndTag(); - fIndent -= 4; this->writeEndTag(); this->lf(2); if (!fIDefineMap.empty()) { @@ -1037,7 +1050,7 @@ void IncludeParser::dumpMethod(const Definition& token, string className) { name = name.substr(0, constPos) + "_const"; } } - this->writeString(name); + this->writeBlock((int) name.size(), name.c_str()); string inType; if (this->isConstructor(token, className)) { inType = "Constructor"; @@ -1047,13 +1060,7 @@ void IncludeParser::dumpMethod(const Definition& token, string className) { inType = "incomplete"; } this->writeTag("In", inType); - this->writeTag("Line"); - this->writeSpace(1); - this->writeString("#"); - this->writeSpace(1); - this->writeString("incomplete"); - this->writeSpace(1); - this->writeString("##"); + this->writeTagTable("Line", "incomplete"); this->lf(2); this->dumpComment(token); } @@ -1097,7 +1104,7 @@ bool IncludeParser::dumpTokens(string skClassName) { string topicName = skClassName.length() > 2 && isupper(skClassName[2]) && ("Sk" == prefixName || "Gr" == prefixName) ? skClassName.substr(2) : skClassName; this->writeTagNoLF("Topic", topicName); - this->writeTag("Alias", topicName + "_Reference"); + this->writeEndTag("Alias", topicName + "_Reference"); this->lf(2); auto& classMap = fIClassMap[skClassName]; SkASSERT(KeyWord::kClass == classMap.fKeyWord || KeyWord::kStruct == classMap.fKeyWord); @@ -1118,6 +1125,7 @@ bool IncludeParser::dumpTokens(string skClassName) { bool hasConstructor = false; bool hasMember = false; bool hasOperator = false; + bool hasStruct = false; for (const auto& oneClass : fIClassMap) { if (skClassName + "::" != oneClass.first.substr(0, skClassName.length() + 2)) { continue; @@ -1125,6 +1133,13 @@ bool IncludeParser::dumpTokens(string skClassName) { hasClass = true; break; } + for (const auto& oneStruct : fIStructMap) { + if (skClassName + "::" != oneStruct.first.substr(0, skClassName.length() + 2)) { + continue; + } + hasStruct = true; + break; + } for (const auto& token : classMap.fTokens) { if (Definition::Type::kMark != token.fType || MarkType::kMethod != token.fMarkType) { continue; @@ -1146,18 +1161,12 @@ bool IncludeParser::dumpTokens(string skClassName) { hasMember = true; } this->writeTag("Subtopic", "Overview"); - fIndent += 4; - this->writeTag("Subtopic", "Subtopic"); - fIndent += 4; this->writeTag("Populate"); - fIndent -= 4; - this->writeEndTag(); - fIndent -= 4; this->writeEndTag(); this->lf(2); if (hasClass) { - this->writeTag("Subtopic", "Class_or_Struct"); + this->writeTag("Subtopic", "Class"); this->writeTag("Populate"); this->writeEndTag(); this->lf(2); @@ -1186,6 +1195,12 @@ bool IncludeParser::dumpTokens(string skClassName) { this->writeEndTag(); this->lf(2); } + if (hasStruct) { + this->writeTag("Subtopic", "Struct"); + this->writeTag("Populate"); + this->writeEndTag(); + this->lf(2); + } for (auto& oneEnum : fIEnumMap) { this->writeBlockSeparator(); this->dumpEnum(*oneEnum.second, oneEnum.first); @@ -1210,6 +1225,7 @@ bool IncludeParser::dumpTokens(string skClassName) { SkASSERT(KeyWord::kClass == keyword || KeyWord::kStruct == keyword); const char* containerType = KeyWord::kClass == keyword ? "Class" : "Struct"; this->writeTag(containerType, innerName); + this->writeTagTable("Line", "incomplete"); this->lf(2); this->writeTag("Code"); this->writeEndTag("ToDo", "fill this in manually"); @@ -1307,6 +1323,19 @@ Definition* IncludeParser::findIncludeObject(const Definition& includeDef, MarkT return &markupDef; } +Definition* IncludeParser::parentBracket(Definition* parent) const { + while (parent && Definition::Type::kBracket != parent->fType) { + parent = parent->fParent; + } + return parent; +} + +Bracket IncludeParser::grandParentBracket() const { + Definition* parent = parentBracket(fParent); + parent = parentBracket(parent ? parent->fParent : nullptr); + return parent ? parent->fBracket : Bracket::kNone; +} + // caller just returns, so report error here bool IncludeParser::parseClass(Definition* includeDef, IsStruct isStruct) { SkASSERT(includeDef->fTokens.size() > 0); @@ -1663,7 +1692,7 @@ bool IncludeParser::parseEnum(Definition* child, Definition* markupDef) { parser.skipToNonName(); string memberName(memberStart, parser.fChar); if (parser.eof() || !parser.skipWhiteSpace()) { - return this->reportError("enum member must end with comma 1"); + return parser.reportError("enum member must end with comma 1"); } const char* dataStart = parser.fChar; if ('=' == parser.peek()) { @@ -1674,7 +1703,7 @@ bool IncludeParser::parseEnum(Definition* child, Definition* markupDef) { continue; } if (parser.eof() || ',' != parser.peek()) { - return this->reportError("enum member must end with comma 2"); + return parser.reportError("enum member must end with comma 2"); } dataEnd = parser.fChar; const char* start = parser.anyOf("/\n"); @@ -1867,7 +1896,7 @@ bool IncludeParser::parseMethod(Definition* child, Definition* markupDef) { } break; } - tokenIter->fName = nameStr; + tokenIter->fName = nameStr; // simple token stream, OK if name is duplicate tokenIter->fMarkType = MarkType::kMethod; tokenIter->fPrivate = string::npos != nameStr.find("::"); auto testIter = child->fParent->fTokens.begin(); @@ -1934,15 +1963,19 @@ bool IncludeParser::parseMethod(Definition* child, Definition* markupDef) { markupDef->fTokens.emplace_back(MarkType::kMethod, start, end, tokenIter->fLineCount, markupDef, '\0'); Definition* markupChild = &markupDef->fTokens.back(); - // do find instead -- I wonder if there is a way to prevent this in c++ - IClassDefinition& classDef = fIClassMap[markupDef->fName]; - SkASSERT(classDef.fStart); - string uniqueName = this->uniqueName(classDef.fMethods, nameStr); - markupChild->fName = uniqueName; - if (!this->findComments(*child, markupChild)) { - return false; + // TODO: I wonder if there is a way to prevent looking up by operator[] (creating empty) ? + { + auto mapIter = fIClassMap.find(markupDef->fName); + SkASSERT(fIClassMap.end() != mapIter); + IClassDefinition& classDef = mapIter->second; + SkASSERT(classDef.fStart); + string uniqueName = this->uniqueName(classDef.fMethods, nameStr); + markupChild->fName = uniqueName; + if (!this->findComments(*child, markupChild)) { + return false; + } + classDef.fMethods[uniqueName] = markupChild; } - classDef.fMethods[uniqueName] = markupChild; return true; } @@ -2324,6 +2357,8 @@ bool IncludeParser::parseChar() { break; } this->pushBracket(Bracket::kAngle); + // this angle bracket may be an operator or may be a bracket + // wait for balancing close angle, if any, to decide break; case ')': case ']': @@ -2340,8 +2375,9 @@ bool IncludeParser::parseChar() { } } bool popBraceParent = fInBrace == fParent; - if ((')' == test ? Bracket::kParen : - ']' == test ? Bracket::kSquare : Bracket::kBrace) == this->topBracket()) { + Bracket match = ')' == test ? Bracket::kParen : + ']' == test ? Bracket::kSquare : Bracket::kBrace; + if (match == this->topBracket()) { this->popBracket(); if (!fInFunction) { fInFunction = ')' == test; @@ -2350,6 +2386,10 @@ bool IncludeParser::parseChar() { } } else if (')' == test && Bracket::kDebugCode == this->topBracket()) { this->popBracket(); + } else if (Bracket::kAngle == this->topBracket() + && match == this->grandParentBracket()) { + this->popBracket(); + this->popBracket(); } else { return reportError("malformed close bracket"); } @@ -2374,6 +2414,7 @@ bool IncludeParser::parseChar() { break; } if (Bracket::kAngle == this->topBracket()) { + // looks like angle pair are braces, not operators this->popBracket(); } else { return reportError("malformed close angle bracket"); @@ -2707,7 +2748,12 @@ bool IncludeParser::references(const SkString& file) const { if (fIStructMap.end() != fIStructMap.find(root)) { return true; } - // TODO incomplete: probably need to look in other places for class-less includes like SkColor.h + if (fIEnumMap.end() != fIEnumMap.find(root)) { + return true; + } + if (fIFunctionMap.end() != fIFunctionMap.find(root)) { + return true; + } return false; } @@ -2743,3 +2789,8 @@ void IncludeParser::RemoveOneFile(const char* docs, const char* includesFile) { SkString fullName = SkOSPath::Join(docs, baseName.c_str()); remove(fullName.c_str()); } + +Bracket IncludeParser::topBracket() const { + Definition* parent = this->parentBracket(fParent); + return parent ? parent->fBracket : Bracket::kNone; +} diff --git a/tools/bookmaker/includeWriter.cpp b/tools/bookmaker/includeWriter.cpp index c029421a8c..cd67be0f5d 100644 --- a/tools/bookmaker/includeWriter.cpp +++ b/tools/bookmaker/includeWriter.cpp @@ -158,9 +158,6 @@ bool IncludeWriter::descriptionOut(const Definition* def, SkipFirstLine skipFirs } commentStart = prop->fTerminator; } break; - case MarkType::kDefinedBy: - commentStart = prop->fTerminator; - break; case MarkType::kBug: { if (fReturnOnWrite) { return true; @@ -1437,7 +1434,7 @@ bool IncludeWriter::populate(Definition* def, ParentPair* prevPair, RootDefiniti } ++alternate; string alternateMethod = methodName + '_' + to_string(alternate); - clonedMethod = this->findMethod(alternateMethod, root); + clonedMethod = this->findMethod(alternateMethod, root); } while (clonedMethod); if (!clonedMethod) { return child.reportError("cloned method not found"); @@ -1489,9 +1486,6 @@ bool IncludeWriter::populate(Definition* def, ParentPair* prevPair, RootDefiniti continue; } method = this->findMethod(methodName + "()", root); - if (method && MarkType::kDefinedBy == method->fMarkType) { - method = method->fParent; - } if (method) { if (method->fCloned) { clonedMethod = method; @@ -1547,7 +1541,9 @@ bool IncludeWriter::populate(Definition* def, ParentPair* prevPair, RootDefiniti methodName = child.fName; } else { methodName = root->fName + "::" + child.fName; - inConstructor = root->fName == child.fName; + size_t lastName = root->fName.rfind(':'); + lastName = string::npos == lastName ? 0 : lastName + 1; + inConstructor = root->fName.substr(lastName) == child.fName; method = root->find(methodName, RootDefinition::AllowParens::kNo); } fContinuation = child.fContentEnd; diff --git a/tools/bookmaker/mdOut.cpp b/tools/bookmaker/mdOut.cpp index 76df5daca0..653ca5e2f3 100644 --- a/tools/bookmaker/mdOut.cpp +++ b/tools/bookmaker/mdOut.cpp @@ -835,7 +835,8 @@ Definition* MdOut::csParent() { break; } } - SkASSERT(csParent || string::npos == fRoot->fFileName.find("Sk")); + SkASSERT(csParent || string::npos == fRoot->fFileName.find("Sk") + || string::npos != fRoot->fFileName.find("SkBlendMode_Reference.bmh")); } return csParent; } @@ -1370,8 +1371,6 @@ void MdOut::markTypeOut(Definition* def, const Definition** prior) { this->htmlOut(anchorDef(def->fFiddle, "Define " + def->fName)); this->lf(2); break; - case MarkType::kDefinedBy: - break; case MarkType::kDeprecated: this->writeString("Deprecated."); this->lf(2); @@ -1444,6 +1443,10 @@ void MdOut::markTypeOut(Definition* def, const Definition** prior) { break; case MarkType::kIllustration: { string illustName = "Illustrations_" + def->fParent->fFiddle; + string number = string(def->fContentStart, def->length()); + if (number.length() && "1" != number) { + illustName += "_" + number; + } auto illustIter = fBmhParser.fTopicMap.find(illustName); SkASSERT(fBmhParser.fTopicMap.end() != illustIter); Definition* illustDef = illustIter->second; @@ -2117,9 +2120,16 @@ void MdOut::subtopicsOut(Definition* def) { } void MdOut::subtopicOut(string name) { + const Definition* topicParent = fSubtopic ? fSubtopic->topicParent() : nullptr; Definition* csParent = this->csParent(); + if (!csParent) { + auto csIter = std::find_if(topicParent->fChildren.begin(), topicParent->fChildren.end(), + [](const Definition* def){ return MarkType::kEnum == def->fMarkType + || MarkType::kEnumClass == def->fMarkType; } ); + SkASSERT(topicParent->fChildren.end() != csIter); + csParent = *csIter; + } SkASSERT(csParent); - const Definition* topicParent = fSubtopic ? fSubtopic->topicParent() : nullptr; this->lfAlways(1); if (fPopulators.end() != fPopulators.find(name)) { const SubtopicDescriptions& tableDescriptions = this->populator(name); @@ -2148,6 +2158,11 @@ void MdOut::subtopicOut(string name) { continue; } size_t start = entry->fName.find_last_of("::"); + if (MarkType::kConst == entry->fMarkType && entry->fParent + && MarkType::kEnumClass == entry->fParent->fMarkType + && string::npos != start && start > 1) { + start = entry->fName.substr(0, start - 1).rfind("::"); + } string entryName = entry->fName.substr(string::npos == start ? 0 : start + 1); items[entryName] = entry; } @@ -2199,5 +2214,5 @@ void MdOut::subtopicOut(string name) { } } FPRINTF(""); - this->lfAlways(1); + this->lf(2); } diff --git a/tools/bookmaker/spellCheck.cpp b/tools/bookmaker/spellCheck.cpp index cd02178b56..a65e2c1762 100644 --- a/tools/bookmaker/spellCheck.cpp +++ b/tools/bookmaker/spellCheck.cpp @@ -172,8 +172,6 @@ bool SpellCheck::check(Definition* def) { } break; case MarkType::kDefine: break; - case MarkType::kDefinedBy: - break; case MarkType::kDeprecated: break; case MarkType::kDescription: -- cgit v1.2.3