bookmaker spelling with fixed linux build

Work on spell-checker
to identify errors and
isolate more concepts
requiring definitions.

fix linux build

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

1 files changed, 14 insertions, 12 deletions

diff --git a/tools/bookmaker/includeParser.cpp b/tools/bookmaker/includeParser.cpp
index 21a47d6e8a..cc7627ac7c 100644
--- a/tools/bookmaker/includeParser.cpp
+++ b/tools/bookmaker/includeParser.cpp
@@ -231,7 +231,7 @@ bool IncludeParser::crossCheck(BmhParser& bmhParser) {
                 continue;
             }
             string fullName = classMapper.first + "::" + token.fName;
-            const Definition* def = root->find(fullName);
+            const Definition* def = root->find(fullName, RootDefinition::AllowParens::kYes);
             switch (token.fMarkType) {
                 case MarkType::kMethod: {
                     if (this->internalName(token)) {
@@ -241,7 +241,7 @@ bool IncludeParser::crossCheck(BmhParser& bmhParser) {
                         string paramName = className + "::";
                         paramName += string(token.fContentStart,
                                 token.fContentEnd - token.fContentStart);
-                        def = root->find(paramName);
+                        def = root->find(paramName, RootDefinition::AllowParens::kYes);
                         if (!def && 0 == token.fName.find("operator")) {
                             string operatorName = className + "::";
                             TextParser oper("", token.fStart, token.fContentEnd, 0);
@@ -258,7 +258,7 @@ bool IncludeParser::crossCheck(BmhParser& bmhParser) {
                                 }
                             } while (!oper.eof() && oper.next() && parens > 0);
                             operatorName += string(start, oper.fChar - start);
-                            def = root->find(operatorName);
+                            def = root->find(operatorName, RootDefinition::AllowParens::kYes);
                         }
                     }
                     if (!def) {
@@ -267,17 +267,18 @@ bool IncludeParser::crossCheck(BmhParser& bmhParser) {
                         string constructorName = className + "::";
                         constructorName += string(token.fContentStart + skip,
                                 token.fContentEnd - token.fContentStart - skip);
-                        def = root->find(constructorName);
+                        def = root->find(constructorName, RootDefinition::AllowParens::kYes);
                     }
                     if (!def && 0 == token.fName.find("SK_")) {
                         string incName = token.fName + "()";
                         string macroName = className + "::" + incName;
-                        def = root->find(macroName);
+                        def = root->find(macroName, RootDefinition::AllowParens::kYes);
                         if (def) {
                             if (def->fName == incName) {
                                 def->fVisited = true;
                                 if ("SK_TO_STRING_NONVIRT" == token.fName) {
-                                    def = root->find(className + "::toString");
+                                    def = root->find(className + "::toString",
+                                            RootDefinition::AllowParens::kYes);
                                     if (def) {
                                         def->fVisited = true;
                                     } else {
@@ -300,7 +301,7 @@ bool IncludeParser::crossCheck(BmhParser& bmhParser) {
                         }
                         if (allLower) {
                             string lowerName = className + "::" + token.fName + "()";
-                            def = root->find(lowerName);
+                            def = root->find(lowerName, RootDefinition::AllowParens::kYes);
                         }
                     }
                     if (!def) {
@@ -314,7 +315,7 @@ bool IncludeParser::crossCheck(BmhParser& bmhParser) {
                     if (!def) {
             // simple method names inside nested classes have a bug and are missing trailing parens
                         string withParens = fullName + "()"; // FIXME: this shouldn't be necessary
-                        def = root->find(withParens);
+                        def = root->find(withParens, RootDefinition::AllowParens::kNo);
                     }
                     if (!def) {
                         SkDebugf("method missing from bmh: %s\n", fullName.c_str());
@@ -359,7 +360,7 @@ bool IncludeParser::crossCheck(BmhParser& bmhParser) {
                             ++lastUnderscore;
                             string anonName = className + "::" + string(lastUnderscore, 
                                     wordEnd - lastUnderscore) + 's';
-                            def = root->find(anonName);
+                            def = root->find(anonName, RootDefinition::AllowParens::kYes);
                         }
                         if (!def) {
                             SkDebugf("enum missing from bmh: %s\n", fullName.c_str());
@@ -386,10 +387,10 @@ bool IncludeParser::crossCheck(BmhParser& bmhParser) {
                         string constName = MarkType::kEnumClass == token.fMarkType ?
                                 fullName : className;
                         constName += "::" + child->fName;
-                        def = root->find(constName);
+                        def = root->find(constName, RootDefinition::AllowParens::kYes);
                         if (!def) {
                             string innerName = classMapper.first + "::" + child->fName;
-                            def = root->find(innerName);
+                            def = root->find(innerName, RootDefinition::AllowParens::kYes);
                         }
                         if (!def) {
                             if (string::npos == child->fName.find("Legacy_")) {
@@ -1142,7 +1143,7 @@ bool IncludeParser::parseMember(Definition* child, Definition* markupDef) {
                     break;
                 }
                 const char* start = parser.fChar;
-                const char* end = parser.trimmedBracketEnd('\n', OneLine::kYes);
+                const char* end = parser.trimmedBracketEnd('\n');
                 if (Bracket::kSlashStar == comment->fBracket) {
                     const char* commentEnd = parser.strnstr("*/", end);
                     if (commentEnd) {
@@ -1450,6 +1451,7 @@ bool IncludeParser::parseChar() {
                     return reportError<bool>("malformed closing comment");
                 }
                 if (Bracket::kSlashStar == this->topBracket()) {
+                    this->next();  // include close in bracket -- FIXME? will this skip stuff?
                     this->popBracket();
                 }
                 break;