diff --git a/tools/bookmaker/includeParser.cpp b/tools/bookmaker/includeParser.cpp
index c4ee8e7..955e6ef 100644
--- a/tools/bookmaker/includeParser.cpp
+++ b/tools/bookmaker/includeParser.cpp
@@ -439,7 +439,7 @@
             continue;
         }
         RootDefinition* root = &finder->second;
-        if (!root->dumpUnVisited()) {
+        if (!root->dumpUnVisited(bmhParser.fSkip)) {
             SkDebugf("some struct elements not found; struct finding in includeParser is missing\n");
         }
         SkDebugf("cross-checked %s\n", className.c_str());
@@ -495,6 +495,7 @@
         }
         switch (token.fMarkType) {
             case MarkType::kEnum:
+            case MarkType::kEnumClass:
                 this->dumpEnum(token);
             break;
             case MarkType::kMethod:
@@ -518,7 +519,21 @@
         this->writeSpace();
         this->writeString("incomplete");
         this->lf(2);
-        this->writeEndTag("Method");
+        switch (token.fMarkType) {
+            case MarkType::kEnum:
+            case MarkType::kEnumClass:
+                this->writeEndTag("Enum");
+            break;
+            case MarkType::kMethod:
+                this->writeEndTag("Method");
+            break;
+            case MarkType::kMember:
+                this->writeEndTag("Member");
+                continue;
+            break;
+            default:
+                SkASSERT(0);
+        }
         this->lf(2);
     }
 }
@@ -540,6 +555,7 @@
         methodName.fName = string(token.fContentStart,
                 (int) (token.fContentEnd - token.fContentStart));
         methodHasReturn = !methodParser.startsWith("void ")
+                && !methodParser.startsWith("static void ")
                 && !methodParser.strnchr('~', methodParser.fEnd);
         const char* paren = methodParser.strnchr('(', methodParser.fEnd);
         const char* nextEnd = paren;
@@ -835,7 +851,8 @@
     this->writeTag("Alias", topicName + "_Reference");
     this->lf(2);
     auto& classMap = fIClassMap[skClassName];
-    const char* containerType = kKeyWords[(int) classMap.fKeyWord].fName;
+    SkASSERT(KeyWord::kClass == classMap.fKeyWord || KeyWord::kStruct == classMap.fKeyWord);
+    const char* containerType = KeyWord::kClass == classMap.fKeyWord ? "Class" : "Struct";
     this->writeTag(containerType, skClassName);
     this->lf(2);
     auto& tokens = classMap.fTokens;
@@ -957,7 +974,9 @@
         this->writeString(
             "# ------------------------------------------------------------------------------");
         this->lf(2);
-        const char* containerType = kKeyWords[(int) oneClass.second.fKeyWord].fName;
+        KeyWord keyword = oneClass.second.fKeyWord;
+        SkASSERT(KeyWord::kClass == keyword || KeyWord::kStruct == keyword);
+        const char* containerType = KeyWord::kClass == keyword ? "Class" : "Struct";
         this->writeTag(containerType, innerName);
         this->lf(2);
         this->writeTag("Code");
@@ -1396,23 +1415,26 @@
     std::advance(tokenIter, child->fParentIndex);
     tokenIter = std::prev(tokenIter);
     const char* nameEnd = tokenIter->fContentEnd;
-    bool add2 = false;
-    if ('[' == tokenIter->fStart[0]) {
+    bool addConst = false;
+    auto operatorCheck = tokenIter;
+    if ('[' == tokenIter->fStart[0] || '*' == tokenIter->fStart[0]) {
+        operatorCheck = std::prev(tokenIter);
+    }
+    if (KeyWord::kOperator == operatorCheck->fKeyWord) {
         auto closeParen = std::next(tokenIter);
         SkASSERT(Definition::Type::kBracket == closeParen->fType &&
                 '(' == closeParen->fContentStart[0]);
         nameEnd = closeParen->fContentEnd + 1;
         closeParen = std::next(closeParen);
-        add2 = true;
         if (Definition::Type::kKeyWord == closeParen->fType &&
                 KeyWord::kConst == closeParen->fKeyWord) {
-            add2 = false;
+            addConst = true;
         }
-        tokenIter = std::prev(tokenIter);
+        tokenIter = operatorCheck;
     }
     string nameStr(tokenIter->fStart, nameEnd - tokenIter->fStart);
-    if (add2) {
-        nameStr += "_2";
+    if (addConst) {
+        nameStr += "_const";
     }
     while (tokenIter != child->fParent->fTokens.begin()) {
         auto testIter = std::prev(tokenIter);
@@ -1452,6 +1474,9 @@
         break;
     }
     tokenIter->fName = nameStr;
+    if ("operator" == nameStr) {
+        SkDebugf("");
+    }
     tokenIter->fMarkType = MarkType::kMethod;
     tokenIter->fPrivate = string::npos != nameStr.find("::");
     auto testIter = child->fParent->fTokens.begin();
@@ -1500,11 +1525,27 @@
         SkASSERT(child->fParentIndex > 0);
         std::advance(parentIter, child->fParentIndex - 1);
         Definition* methodName = &*parentIter;
-        TextParser name(methodName);
-        if (name.skipToEndBracket(':') && name.startsWith("::")) {
+        TextParser nameParser(methodName);
+        if (nameParser.skipToEndBracket(':') && nameParser.startsWith("::")) {
             return true;  // expect this is inline class definition outside of class
         }
-        SkASSERT(0);  // code incomplete
+        string name(nameParser.fLine, nameParser.lineLength());
+        auto finder = fIFunctionMap.find(name);
+        if (fIFunctionMap.end() != finder) {
+            // create unique name
+            SkASSERT(0);  // incomplete
+        }
+        auto globalFunction = &fIFunctionMap[name];
+        globalFunction->fContentStart = start;
+        globalFunction->fName = name;
+        if ("operator+" == name) {
+            SkDebugf("");
+        }
+        globalFunction->fFiddle = name;
+        globalFunction->fContentEnd = end;
+        globalFunction->fMarkType = MarkType::kMethod;
+        globalFunction->fLineCount = tokenIter->fLineCount;
+        return true;
     }
     markupDef->fTokens.emplace_back(MarkType::kMethod, start, end, tokenIter->fLineCount,
             markupDef);
@@ -1514,6 +1555,9 @@
     SkASSERT(classDef.fStart);
     string uniqueName = this->uniqueName(classDef.fMethods, nameStr);
     markupChild->fName = uniqueName;
+        if ("operator+" == uniqueName) {
+            SkDebugf("");
+        }
     if (!this->findComments(*child, markupChild)) {
         return false;
     }
@@ -1605,6 +1649,7 @@
                 case Bracket::kPound:
                     // special-case the #xxx xxx_DEFINED entries
                     switch (child->fKeyWord) {
+                        case KeyWord::kIf:
                         case KeyWord::kIfndef:
                         case KeyWord::kIfdef:
                             if (child->boilerplateIfDef(fParent)) {
@@ -1736,8 +1781,10 @@
                     return reportError<bool>("malformed closing comment");
                 }
                 if (Bracket::kSlashStar == this->topBracket()) {
-                    this->next();  // include close in bracket -- FIXME? will this skip stuff?
+                    TextParser::Save save(this);
+                    this->next();  // include close in bracket
                     this->popBracket();
+                    save.restore(); // put things back so nothing is skipped
                 }
                 break;
             }
@@ -1898,6 +1945,9 @@
             if (fInEnum) {
                 break;
             }
+            if (Bracket::kPound == this->topBracket()) {
+                break;
+            }
             if (Bracket::kAngle == this->topBracket()) {
                 this->popBracket();
             } else {
@@ -1915,6 +1965,10 @@
         case '&':
         case ',':
         case ' ':
+        case '+':
+        case '=':
+        case '-':
+        case '!':
             if (fInCharCommentString || fInBrace) {
                 break;
             }