document SkColor.h

SkColor.h uses #define liberally, and has many global symbols,
two things bookmaker hasn't seen in other includes.

Revised .h -> .bmh converter to work with SkColor.h as well
as updating how .bmh indices are built.

Generated SkColor_Reference.bmh for globals, and
SkColor4f_Reference.bmh for class.

Other than the existing comments, this doesn't update the
documentation or add new examples.

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

1 files changed, 26 insertions, 39 deletions

diff --git a/tools/bookmaker/definition.cpp b/tools/bookmaker/definition.cpp
index e3a5aa3bd5..06db96487e 100644
--- a/tools/bookmaker/definition.cpp
+++ b/tools/bookmaker/definition.cpp
@@ -6,6 +6,7 @@
  */
 
 #include "bookmaker.h"
+#include "SkOSPath.h"
 
 #ifdef CONST
 #undef CONST
@@ -138,7 +139,7 @@ const struct OperatorParser {
                                     {{ CONST,  OpType::kThis,   OpMod::kReference, }}},
 };
 
-OpType lookup_type(const string& typeWord, const string& name) {
+OpType lookup_type(string typeWord, string name) {
     if (typeWord == name || (typeWord == "SkIVector" && name == "SkIPoint")
                          || (typeWord == "SkVector" && name == "SkPoint")) {
         return OpType::kThis;
@@ -191,7 +192,7 @@ bool Definition::parseOperator(size_t doubleColons, string& result) {
     SkASSERT(isStatic == false || returnsConst == false);
     iParser.skipWhiteSpace();
     const char* returnTypeStart = iParser.fChar;
-    iParser.skipToNonAlphaNum();
+    iParser.skipToNonName();
     SkASSERT(iParser.fChar > returnTypeStart);
     string returnType(returnTypeStart, iParser.fChar - returnTypeStart);
     OpType returnOpType = lookup_type(returnType, className);
@@ -241,7 +242,7 @@ bool Definition::parseOperator(size_t doubleColons, string& result) {
             }
             iParser.skipWhiteSpace();
             const char* paramStart = iParser.fChar;
-            iParser.skipToNonAlphaNum();
+            iParser.skipToNonName();
             SkASSERT(iParser.fChar > paramStart);
             string paramType(paramStart, iParser.fChar - paramStart);
             OpType paramOpType = lookup_type(paramType, className);
@@ -257,7 +258,7 @@ bool Definition::parseOperator(size_t doubleColons, string& result) {
                 countsMatch = false;
                 break;
             }
-            iParser.skipToNonAlphaNum();
+            iParser.skipToNonName();
             if ('[' == iParser.peek()) {
                 paramMod = OpMod::kArray;
                 SkAssertResult(iParser.skipExact("[]"));
@@ -324,7 +325,7 @@ bool Definition::parseOperator(size_t doubleColons, string& result) {
 #undef BLANK
 #undef DEFOP
 
-bool Definition::boilerplateIfDef(Definition* parent) {
+bool Definition::boilerplateIfDef() {
     const Definition& label = fTokens.front();
     if (Type::kWord != label.fType) {
         return false;
@@ -333,32 +334,6 @@ bool Definition::boilerplateIfDef(Definition* parent) {
     return true;
 }
 
-// todo: this is matching #ifndef SkXXX_DEFINED for no particular reason
-// it doesn't do anything useful with arbitrary input, e.g. #ifdef SK_SUPPORT_LEGACY_CANVAS_HELPERS
-// also doesn't know what to do with SK_REQUIRE_LOCAL_VAR()
-bool Definition::boilerplateDef(Definition* parent) {
-    if (!this->boilerplateIfDef(parent)) {
-        return false;
-    }
-    const char* s = fName.c_str();
-    const char* e = strchr(s, '_');
-    return true; // fixme: if this is trying to do something useful with define, do it here
-    if (!e) {
-        return false;
-    }
-    string prefix(s, e - s);
-    const char* inName = strstr(parent->fName.c_str(), prefix.c_str());
-    if (!inName) {
-        return false;
-    }
-    if ('/' != inName[-1] && '\\' != inName[-1]) {
-        return false;
-    }
-    if (strcmp(inName + prefix.size(), ".h")) {
-        return false;
-    }
-    return true;
-}
 
 // fixme: this will need to be more complicated to handle all of Skia
 // for now, just handle paint -- maybe fiddle will loosen naming restrictions
@@ -414,7 +389,7 @@ void Definition::setCanonicalFiddle() {
                     if (params.startsWith("const") || params.startsWith("int")
                             || params.startsWith("Sk")) {
                         const char* wordStart = params.fChar;
-                        params.skipToNonAlphaNum();
+                        params.skipToNonName();
                         if (underline) {
                             result += '_';
                         } else {
@@ -422,7 +397,7 @@ void Definition::setCanonicalFiddle() {
                         }
                         result += string(wordStart, params.fChar - wordStart);
                     } else {
-                        params.skipToNonAlphaNum();
+                        params.skipToNonName();
                     }
                     if (!params.eof() && '*' == params.peek()) {
                         if (underline) {
@@ -766,6 +741,18 @@ string Definition::fiddleName() const {
     return fFiddle.substr(start, end - start);
 }
 
+string Definition::fileName() const {
+    size_t nameStart = fFileName.rfind(SkOSPath::SEPARATOR);
+    if (SkOSPath::SEPARATOR != '/') {
+        size_t altNameStart = fFileName.rfind('/');
+        nameStart = string::npos == nameStart ? altNameStart :
+                string::npos != altNameStart && altNameStart > nameStart ? altNameStart : nameStart;
+    }
+    SkASSERT(string::npos != nameStart);
+    string baseFile = fFileName.substr(nameStart + 1);
+    return baseFile;
+}
+
 const Definition* Definition::findClone(string match) const {
     for (auto child : fChildren) {
         if (!child->fClone) {
@@ -791,7 +778,7 @@ const Definition* Definition::hasChild(MarkType markType) const {
     return nullptr;
 }
 
-const Definition* Definition::hasParam(const string& ref) const {
+const Definition* Definition::hasParam(string ref) const {
     SkASSERT(MarkType::kMethod == fMarkType);
     for (auto iter : fChildren) {
         if (MarkType::kParam != iter->fMarkType) {
@@ -805,7 +792,7 @@ const Definition* Definition::hasParam(const string& ref) const {
     return nullptr;
 }
 
-bool Definition::hasMatch(const string& name) const {
+bool Definition::hasMatch(string name) const {
     for (auto child : fChildren) {
         if (name == child->fName) {
             return true;
@@ -827,7 +814,7 @@ bool Definition::isStructOrClass() const {
     return true;
 }
 
-bool Definition::methodHasReturn(const string& name, TextParser* methodParser) const {
+bool Definition::methodHasReturn(string name, TextParser* methodParser) const {
     if (methodParser->skipExact("static")) {
         methodParser->skipWhiteSpace();
     }
@@ -965,7 +952,7 @@ string Definition::NormalizedName(string name) {
     return normalizedName;
 }
 
-static string unpreformat(const string& orig) {
+static string unpreformat(string orig) {
     string result;
     int amp = 0;
     for (auto c : orig) {
@@ -1030,7 +1017,7 @@ static string unpreformat(const string& orig) {
     return result;
 }
 
-bool Definition::paramsMatch(const string& matchFormatted, const string& name) const {
+bool Definition::paramsMatch(string matchFormatted, string name) const {
     string match = unpreformat(matchFormatted);
     TextParser def(fFileName, fStart, fContentStart, fLineCount);
     const char* dName = def.strnstr(name.c_str(), fContentStart);
@@ -1097,7 +1084,7 @@ bool RootDefinition::dumpUnVisited() {
     return success;
 }
 
-const Definition* RootDefinition::find(const string& ref, AllowParens allowParens) const {
+const Definition* RootDefinition::find(string ref, AllowParens allowParens) const {
     const auto leafIter = fLeaves.find(ref);
     if (leafIter != fLeaves.end()) {
         return &leafIter->second;