General clean up on bookmaker.

Command line runs without error for
SkBitmap, SkPath, SkRect, SkIRect,
SkPixmap, SkCanvas.

Docs-Preview: https://skia.org/?cl=57112
TBR: caryclark@google.com
Bug: skia:6898
Change-Id: I73b69ae8ffdf0a1e6bc187dc8a9dfb28f7766faa
Reviewed-on: https://skia-review.googlesource.com/57112
Reviewed-by: Cary Clark <caryclark@skia.org>
Commit-Queue: Cary Clark <caryclark@skia.org>

5 files changed, 148 insertions, 47 deletions

diff --git a/tools/bookmaker/bookmaker.cpp b/tools/bookmaker/bookmaker.cpp
index 33feda5a35..cc454982fd 100644
--- a/tools/bookmaker/bookmaker.cpp
+++ b/tools/bookmaker/bookmaker.cpp
@@ -21,7 +21,7 @@ DEFINE_string2(ref, r, "", "Resolve refs and write bmh_*.md files to path. (Requ
 DEFINE_string2(spellcheck, s, "", "Spell-check [once, all, mispelling]. (Requires -b)");
 DEFINE_string2(tokens, t, "", "Directory to write bmh from include. (Requires -i)");
 DEFINE_bool2(crosscheck, x, false, "Check bmh against includes. (Requires -b -i)");
-DEFINE_bool2(skip, z, false, "Skip missing example error.");
+DEFINE_bool2(skip, z, false, "Skip degenerate missed in legacy preprocessor.");
 
 /*  recipe for generating timestamps for existing doxygen comments
 find include/core -type f -name '*.h' -print -exec git blame {} \; > ~/all.blame.txt
@@ -390,9 +390,6 @@ bool Definition::checkMethod() const {
         string paramName;
         methodParser.fChar = nextEnd + 1;
         methodParser.skipSpace();
-        if (1494 == methodParser.fLineCount) {
-            SkDebugf("");
-        }
         if (!this->nextMethodParam(&methodParser, &nextEnd, &paramName)) {
             continue;
         }
@@ -823,11 +820,12 @@ bool RootDefinition::dumpUnVisited() {
     for (auto& leaf : fLeaves) {
         if (!leaf.second.fVisited) {
             // TODO: parse embedded struct in includeParser phase, then remove this condition
-            size_t firstColon = leaf.first.find("::");
-            size_t lastColon = leaf.first.rfind("::");
-            if (firstColon != lastColon) {  // struct, two sets
-                allStructElementsFound = false;
-                continue;
+            if (FLAGS_skip) {
+                const Definition& def = leaf.second;
+                if (def.fChildren.size() > 0 &&
+                        MarkType::kDeprecated == def.fChildren[0]->fMarkType) {
+                    continue;
+                }
             }
             SkDebugf("defined in bmh but missing in include: %s\n", leaf.first.c_str());
         }
@@ -1120,9 +1118,7 @@ bool BmhParser::addDefinition(const char* defStart, bool hasEnd, MarkType markTy
                     if (definition->fChildren.size() == 0) {
                         TextParser emptyCheck(definition);
                         if (emptyCheck.eof() || !emptyCheck.skipWhiteSpace()) {
-                            if (!FLAGS_skip) {
-                                return this->reportError<bool>("missing example body");
-                            }
+                            return this->reportError<bool>("missing example body");
                         }
                     }
                 }
diff --git a/tools/bookmaker/bookmaker.h b/tools/bookmaker/bookmaker.h
index 3954c6eaad..857caf4c10 100644
--- a/tools/bookmaker/bookmaker.h
+++ b/tools/bookmaker/bookmaker.h
@@ -1099,9 +1099,6 @@ public:
         }
         writePending();
         if (fDebugOut) {
-            if (!strncmp("SK_SUPPORT", data, 10)) {
-                SkDebugf("");
-            }
             string check(data, size);
             SkDebugf("%s", check.c_str());
         }
@@ -1874,7 +1871,7 @@ public:
     Definition* structMemberOut(const Definition* memberStart, const Definition& child);
     void structOut(const Definition* root, const Definition& child,
             const char* commentStart, const char* commentEnd);
-    void structSizeMembers(Definition& child);
+    void structSizeMembers(const Definition& child);
 
 private:
     BmhParser* fBmhParser;
diff --git a/tools/bookmaker/includeParser.cpp b/tools/bookmaker/includeParser.cpp
index 1e055db17f..4ad83d8aa7 100644
--- a/tools/bookmaker/includeParser.cpp
+++ b/tools/bookmaker/includeParser.cpp
@@ -199,16 +199,48 @@ string IncludeParser::className() const {
     return result;
 }
 
+#include <sstream>
+#include <iostream>
+
 bool IncludeParser::crossCheck(BmhParser& bmhParser) {
-    string className = this->className();
-    string classPrefix = className + "::";
-    RootDefinition* root = &bmhParser.fClassMap[className];
-    root->clearVisited();
     for (auto& classMapper : fIClassMap) {
-        if (className != classMapper.first
-                && classPrefix != classMapper.first.substr(0, classPrefix.length())) {
+        string className = classMapper.first;
+        auto finder = bmhParser.fClassMap.find(className);
+        if (bmhParser.fClassMap.end() == finder) {
+            SkASSERT(string::npos != className.find("::"));
             continue;
         }
+        RootDefinition* root = &finder->second;
+        root->clearVisited();
+    }
+    for (auto& classMapper : fIClassMap) {
+        string className = classMapper.first;
+        std::istringstream iss(className);
+        string classStr;
+        string classBase;
+        RootDefinition* root = nullptr;
+        while (std::getline(iss, classStr, ':')) {
+            if (root) {
+                if (!classStr.length()) {
+                    continue;
+                }
+                classBase += "::" + classStr;
+                auto finder = root->fBranches.find(classBase);
+                if (root->fBranches.end() != finder) {
+                    root = finder->second;
+                } else {
+                    SkASSERT(0);
+                }
+            } else {
+                classBase = classStr;
+                auto finder = bmhParser.fClassMap.find(classBase);
+                if (bmhParser.fClassMap.end() != finder) {
+                    root = &finder->second;
+                } else {
+                    SkASSERT(0);
+                }
+            }
+        }
         auto& classMap = classMapper.second;
         auto& tokens = classMap.fTokens;
         for (const auto& token : tokens) {
@@ -399,10 +431,18 @@ bool IncludeParser::crossCheck(BmhParser& bmhParser) {
             }
         }
     }
-    if (!root->dumpUnVisited()) {
-        SkDebugf("some struct elements not found; struct finding in includeParser is missing\n");
+    for (auto& classMapper : fIClassMap) {
+        string className = classMapper.first;
+        auto finder = bmhParser.fClassMap.find(className);
+        if (bmhParser.fClassMap.end() == finder) {
+            continue;
+        }
+        RootDefinition* root = &finder->second;
+        if (!root->dumpUnVisited()) {
+            SkDebugf("some struct elements not found; struct finding in includeParser is missing\n");
+        }
+        SkDebugf("cross-checked %s\n", className.c_str());
     }
-    SkDebugf("cross-checked %s\n", className.c_str());
     bmhParser.fWroteOut = true;
     return true;
 }
@@ -1044,32 +1084,45 @@ bool IncludeParser::parseClass(Definition* includeDef, IsStruct isStruct) {
         (*childIter)->fPrivate = true;
         childIter = std::next(childIter);
     }
-    int lastPublic = publicIndex;
+    int keyIndex = publicIndex;
+    KeyWord currentKey = KeyWord::kPublic;
+    const char* publicName = kKeyWords[(int) KeyWord::kPublic].fName;
+    size_t publicLen = strlen(publicName);
     const char* protectedName = kKeyWords[(int) KeyWord::kProtected].fName;
     size_t protectedLen = strlen(protectedName);
     const char* privateName = kKeyWords[(int) KeyWord::kPrivate].fName;
     size_t privateLen = strlen(privateName);
-    while (iter != includeDef->fTokens.end()
-            && (protectedLen != (size_t) (iter->fContentEnd - iter->fStart)
-            || strncmp(iter->fStart, protectedName, protectedLen))
-            && (privateLen != (size_t) (iter->fContentEnd - iter->fStart)
-            || strncmp(iter->fStart, privateName, privateLen))) {
-        iter = std::next(iter);
-        ++lastPublic;
-    }
-    fLastObject = nullptr;
-    while (childIter != includeDef->fChildren.end() && (*childIter)->fParentIndex < lastPublic) {
+    while (childIter != includeDef->fChildren.end()) {
         Definition* child = *childIter;
-        if (!this->parseObject(child, markupDef)) {
-            return false;
+        while (child->fParentIndex > keyIndex && iter != includeDef->fTokens.end()) {
+            const char* testStart = iter->fStart;
+            size_t testLen = (size_t) (iter->fContentEnd - testStart);
+            iter = std::next(iter);
+            ++keyIndex;
+            if (publicLen == testLen && !strncmp(testStart, publicName, testLen)) {
+                currentKey = KeyWord::kPublic;
+                break;
+            }
+            if (protectedLen == testLen && !strncmp(testStart, protectedName, testLen)) {
+                currentKey = KeyWord::kProtected;
+                break;
+            }
+            if (privateLen == testLen && !strncmp(testStart, privateName, testLen)) {
+                currentKey = KeyWord::kPrivate;
+                break;
+            }
+        }
+        fLastObject = nullptr;
+        if (KeyWord::kPublic == currentKey) {
+            if (!this->parseObject(child, markupDef)) {
+                return false;
+            }
+        } else {
+            child->fPrivate = true;
         }
         fLastObject = child;
         childIter = std::next(childIter);
     }
-    while (childIter != includeDef->fChildren.end()) {
-        (*childIter)->fPrivate = true;
-        childIter = std::next(childIter);
-    }
     SkASSERT(fParent->fParent);
     fParent = fParent->fParent;
     return true;
@@ -1242,6 +1295,23 @@ bool IncludeParser::parseEnum(Definition* child, Definition* markupDef) {
         }
         markupChild->fChildren.push_back(member);
     } while (true);
+    for (auto count : child->fChildren) {
+        if (Definition::Type::kBracket == count->fType) {
+            continue;
+        }
+        SkASSERT(Definition::Type::kKeyWord == count->fType);
+        if (KeyWord::kClass == count->fKeyWord) {
+            continue;
+        }
+        SkASSERT(KeyWord::kStatic == count->fKeyWord);
+        markupChild->fTokens.emplace_back(MarkType::kMember, count->fContentStart,
+                count->fContentEnd, count->fLineCount, markupChild);
+        Definition* member = &markupChild->fTokens.back();
+        member->fName = count->fName;
+        // FIXME: ? add comment as well ?
+        markupChild->fChildren.push_back(member);
+        break;
+    }
     IClassDefinition& classDef = fIClassMap[markupDef->fName];
     SkASSERT(classDef.fStart);
     string uniqueName = this->uniqueName(classDef.fEnums, nameStr);
@@ -1320,9 +1390,6 @@ bool IncludeParser::parseMethod(Definition* child, Definition* markupDef) {
     std::advance(tokenIter, child->fParentIndex);
     tokenIter = std::prev(tokenIter);
     string nameStr(tokenIter->fStart, tokenIter->fContentEnd - tokenIter->fStart);
-    if (0 == nameStr.find("SK_ATTR_DEPRECATED")) {
-        SkDebugf("");
-    }
     while (tokenIter != child->fParent->fTokens.begin()) {
         auto testIter = std::prev(tokenIter);
         switch (testIter->fType) {
@@ -1355,9 +1422,14 @@ bool IncludeParser::parseMethod(Definition* child, Definition* markupDef) {
     }
     tokenIter->fName = nameStr;
     tokenIter->fMarkType = MarkType::kMethod;
+    tokenIter->fPrivate = string::npos != nameStr.find("::");
     auto testIter = child->fParent->fTokens.begin();
     SkASSERT(child->fParentIndex > 0);
     std::advance(testIter, child->fParentIndex - 1);
+    if (tokenIter->fParent && KeyWord::kIfdef == tokenIter->fParent->fKeyWord &&
+            0 == tokenIter->fParentIndex) {
+        tokenIter = std::next(tokenIter);
+    }
     const char* start = tokenIter->fContentStart;
     const char* end = tokenIter->fContentEnd;
     const char kDebugCodeStr[] = "SkDEBUGCODE";
diff --git a/tools/bookmaker/includeWriter.cpp b/tools/bookmaker/includeWriter.cpp
index 38213618c5..ff7c0e3c56 100644
--- a/tools/bookmaker/includeWriter.cpp
+++ b/tools/bookmaker/includeWriter.cpp
@@ -673,7 +673,7 @@ Definition* IncludeWriter::structMemberOut(const Definition* memberStart, const
     return valueEnd;
 }
 
-void IncludeWriter::structSizeMembers(Definition& child) {
+void IncludeWriter::structSizeMembers(const Definition& child) {
     int longestType = 0;
     Definition* typeStart = nullptr;
     int longestName = 0;
@@ -815,6 +815,7 @@ bool IncludeWriter::populate(Definition* def, ParentPair* prevPair, RootDefiniti
     fContinuation = nullptr;
     bool inStruct = false;
     bool inConstructor = false;
+    bool inInline = false;
     for (auto& child : def->fTokens) {
         if (memberEnd) {
             if (memberEnd != &child) {
@@ -824,8 +825,34 @@ bool IncludeWriter::populate(Definition* def, ParentPair* prevPair, RootDefiniti
             memberEnd = nullptr;
         }
         if (child.fPrivate) {
+            if (MarkType::kMethod == child.fMarkType) {
+                inInline = true;
+            }
             continue;
         }
+        if (inInline) {
+            if (Definition::Type::kKeyWord == child.fType) {
+                SkASSERT(MarkType::kMethod != child.fMarkType);
+                continue;
+            }
+            if (Definition::Type::kPunctuation == child.fType) {
+                if (Punctuation::kLeftBrace == child.fPunctuation) {
+                    inInline = false;
+                } else {
+                    SkASSERT(Punctuation::kAsterisk == child.fPunctuation);
+                }
+                continue;
+            }
+            if (Definition::Type::kWord == child.fType) {
+                string name(child.fContentStart, child.fContentEnd - child.fContentStart);
+                SkASSERT(string::npos != name.find("::"));
+                continue;
+            }
+            if (Definition::Type::kBracket == child.fType) {
+                SkASSERT(Bracket::kParen == child.fBracket);
+                continue;
+            }
+        }
         if (fContinuation) {
             if (Definition::Type::kKeyWord == child.fType) {
                 if (KeyWord::kFriend == child.fKeyWord ||
@@ -1131,6 +1158,16 @@ bool IncludeWriter::populate(Definition* def, ParentPair* prevPair, RootDefiniti
         }
         if (Definition::Type::kWord == child.fType) {
             if (MarkType::kMember == child.fMarkType) {
+                if (!memberStart) {
+                    auto iter = def->fTokens.begin();
+                    std::advance(iter, child.fParentIndex - 1);
+                    memberStart = &*iter;
+                    if (!fStructDef) {
+                        SkASSERT(KeyWord::kStruct == def->fParent->fKeyWord);
+                        fStructDef = def->fParent;
+                        this->structSizeMembers(*fStructDef);
+                    }
+                }
                 memberEnd = this->structMemberOut(memberStart, child);
                 fStart = child.fContentEnd + 1;
                 fDeferComment = nullptr;
diff --git a/tools/bookmaker/spellCheck.cpp b/tools/bookmaker/spellCheck.cpp
index b2091640d0..3a32f37bc4 100644
--- a/tools/bookmaker/spellCheck.cpp
+++ b/tools/bookmaker/spellCheck.cpp
@@ -595,7 +595,6 @@ void SpellCheck::wordCheck(const string& str) {
             sawSpecial = true;
             continue;
         }
-        SkDebugf("");
         SkASSERT(0);
     }
     if (sawSpecial && !hasParen) {