Update help in SkFlags.

tools/SkFlags.cpp

Index: tools/SkFlags.cpp
diff --git a/tools/SkFlags.cpp b/tools/SkFlags.cpp
index e386b429fe5ca5dd5e2bb6e38d9401a3c841d6f2..6d96d9af44dc1d91457ccb34b88acd8035311480 100644
--- a/tools/SkFlags.cpp
+++ b/tools/SkFlags.cpp
@@ -17,6 +17,56 @@ void SkFlags::SetUsage(const char* usage) {
 // Maximum line length for the help message.
 #define LINE_LENGTH 80
 
+static void print_help_for_flag(const SkFlagInfo* flag) {
+    SkDebugf("\t--%s", flag->name().c_str());
+    const SkString& shortName = flag->shortName();
+    if (shortName.size() > 0) {
+        SkDebugf(" or -%s", shortName.c_str());
+    }
+    SkDebugf(":\ttype: %s", flag->typeAsString().c_str());
+    if (flag->defaultValue().size() > 0) {
+        SkDebugf("\tdefault: %s", flag->defaultValue().c_str());
+    }
+    SkDebugf("\n");
+    const SkString& help = flag->help();
+    size_t length = help.size();
+    const char* currLine = help.c_str();
+    const char* stop = currLine + length;
+    while (currLine < stop) {
+        if (strlen(currLine) < LINE_LENGTH) {
+            // Only one line length's worth of text left.
+            SkDebugf("\t\t%s\n", currLine);
+            break;
+        }
+        int lineBreak = SkStrFind(currLine, "\n");
+        if (lineBreak < 0 || lineBreak > LINE_LENGTH) {
+            // No line break within line length. Will need to insert one.
+            // Find a space before the line break.
+            int spaceIndex = LINE_LENGTH - 1;
+            while (spaceIndex > 0 && currLine[spaceIndex] != ' ') {
+                spaceIndex--;
+            }
+            int gap;
+            if (0 == spaceIndex) {
+                // No spaces on the entire line. Go ahead and break mid word.
+                spaceIndex = LINE_LENGTH;
+                gap = 0;
+            } else {
+                // Skip the space on the next line
+                gap = 1;
+            }
+            SkDebugf("\t\t%.*s\n", spaceIndex, currLine);
+            currLine += spaceIndex + gap;
+        } else {
+            // the line break is within the limit. Break there.
+            lineBreak++;
+            SkDebugf("\t\t%.*s", lineBreak, currLine);
+            currLine += lineBreak;
+        }
+    }
+    SkDebugf("\n");
+}
+
 void SkFlags::ParseCommandLine(int argc, char** argv) {
     // Only allow calling this function once.
     static bool gOnce;
@@ -34,55 +84,43 @@ void SkFlags::ParseCommandLine(int argc, char** argv) {
         if (0 == strcmp("-h", argv[i]) || 0 == strcmp("--h", argv[i])
                 || 0 == strcmp("-help", argv[i]) || 0 == strcmp("--help", argv[i])) {
             // Print help message.
-            SkDebugf("%s\n%s\n", argv[0], gUsage.c_str());
+            SkTDArray<const char*> helpFlags;
+            for (int j = i + 1; j < argc; j++) {
+                if (SkStrStartsWith(argv[j], '-')) {
+                    break;
+                }
+                helpFlags.append(1, &argv[j]);
+            }
+            if (0 == helpFlags.count()) {
+                // Only print general help message if help for specific flags is not requested.
+                SkDebugf("%s\n%s\n", argv[0], gUsage.c_str());
+            }
             SkDebugf("Flags:\n");
             SkFlagInfo* flag = SkFlags::gHead;
             while (flag != NULL) {
-                SkDebugf("\t--%s:\ttype: %s", flag->name().c_str(),
-                          flag->typeAsString().c_str());
-                if (flag->defaultValue().size() > 0) {
-                    SkDebugf("\tdefault: %s", flag->defaultValue().c_str());
-                }
-                SkDebugf("\n");
-                const SkString& help = flag->help();
-                size_t length = help.size();
-                const char* currLine = help.c_str();
-                const char* stop = currLine + length;
-                while (currLine < stop) {
-                    if (strlen(currLine) < LINE_LENGTH) {
-                        // Only one line length's worth of text left.
-                        SkDebugf("\t\t%s\n", currLine);
-                        break;
-                    }
-                    int lineBreak = SkStrFind(currLine, "\n");
-                    if (lineBreak < 0 || lineBreak > LINE_LENGTH) {
-                        // No line break within line length. Will need to insert one.
-                        // Find a space before the line break.
-                        int spaceIndex = LINE_LENGTH - 1;
-                        while (spaceIndex > 0 && currLine[spaceIndex] != ' ') {
-                            spaceIndex--;
-                        }
-                        int gap;
-                        if (0 == spaceIndex) {
-                            // No spaces on the entire line. Go ahead and break mid word.
-                            spaceIndex = LINE_LENGTH;
-                            gap = 0;
-                        } else {
-                            // Skip the space on the next line
-                            gap = 1;
+                // If no flags followed --help, print them all
+                bool printFlag = 0 == helpFlags.count();
+                if (!printFlag) {
+                    for (int k = 0; k < helpFlags.count(); k++) {
+                        if (flag->name().equals(helpFlags[k])
+                            || flag->shortName().equals(helpFlags[k])) {

[borenet, 2013/03/20 18:45:28]

Nit: I find it more readable to have the || on the line above, so that the
conditions are aligned.  Up to you.

[scroggo, 2013/03/20 18:59:44]

I was following the Java style Android used, since our style guide doesn't offer
any guidance. Truly I don't like either option, because now the second line
lines up with code inside the block. bungeman@ had a solution I liked where he
put the brace on the next line like so:

if (long_condition1
    && long_condition)
{
    statement;
}

Technically it's against the style guide, but it does make it clear where the
conditions are and where the statements are. I'm curious how other styles which
keep the brace on the same line as the condition handle this problem.

Anyway, I fixed it, so now at least one of us is happy.

+                            printFlag = true;
+                            helpFlags.remove(k);
+                            break;
                         }
-                        SkDebugf("\t\t%.*s\n", spaceIndex, currLine);
-                        currLine += spaceIndex + gap;
-                    } else {
-                        // the line break is within the limit. Break there.
-                        lineBreak++;
-                        SkDebugf("\t\t%.*s", lineBreak, currLine);
-                        currLine += lineBreak;
                     }
                 }
-                SkDebugf("\n");
+                if (printFlag) {
+                    print_help_for_flag(flag);
+                }
                 flag = flag->next();
             }
+            if (helpFlags.count() > 0) {
+                SkDebugf("Requested help for unrecognized flags:\n");
+                for (int k = 0; k < helpFlags.count(); k++) {
+                    SkDebugf("\t--%s\n", helpFlags[k]);
+                }
+            }
             helpPrinted = true;
         }
         if (!helpPrinted) {