tool --help alphabetizes command line flags

tools/flags/SkCommandLineFlags.cpp

 /*
  * Copyright 2013 Google Inc.
  *
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */
 
 #include "SkCommandLineFlags.h"
 #include "SkTDArray.h"
+#include "SkTSort.h"
 
 DEFINE_bool(undefok, false, "Silently ignore unknown flags instead of crashing.");
 
 bool SkFlagInfo::CreateStringFlag(const char* name, const char* shortName,
                                   SkCommandLineFlags::StringArray* pStrings,
                                   const char* defaultValue, const char* helpString) {
     SkFlagInfo* info = SkNEW_ARGS(SkFlagInfo, (name, shortName, kString_FlagType, helpString));
     info->fDefaultString.set(defaultValue);
 
     info->fStrings = pStrings;
@@ skipping 164 matching lines @@
         } else {
             // the line break is within the limit. Break there.
             lineBreak++;
             SkDebugf("\t\t%.*s", lineBreak, currLine);
             currLine += lineBreak;
         }
     }
     SkDebugf("\n");
 }
 
+namespace {
+struct CompareFlagsByName {
+    bool operator()(SkFlagInfo* a, SkFlagInfo* b) const {
+        return strcmp(a->name().c_str(), b->name().c_str()) < 0;
+    }
+};
+}  // namespace
+
 void SkCommandLineFlags::Parse(int argc, char** argv) {
     // Only allow calling this function once.
     static bool gOnce;
     if (gOnce) {
         SkDebugf("Parse should only be called once at the beginning of main!\n");
         SkASSERT(false);
         return;
     }
     gOnce = true;
 
     bool helpPrinted = false;
     // Loop over argv, starting with 1, since the first is just the name of the program.
     for (int i = 1; i < argc; i++) {
         if (0 == strcmp("-h", argv[i]) || 0 == strcmp("--help", argv[i])) {
             // Print help message.
             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 = SkCommandLineFlags::gHead;
-            while (flag != NULL) {
+
+            if (0 == helpFlags.count()) {
                 // If no flags followed --help, print them all
-                bool printFlag = 0 == helpFlags.count();
-                if (!printFlag) {
+                SkTDArray<SkFlagInfo*> allFlags;
+                for (SkFlagInfo* flag = SkCommandLineFlags::gHead; flag;
+                     flag = flag->next()) {
+                    allFlags.push(flag);
+                }
+                SkTQSort(&allFlags[0], &allFlags[allFlags.count() - 1],
+                         CompareFlagsByName());
+                for (int i = 0; i < allFlags.count(); ++i) {
+                    print_help_for_flag(allFlags[i]);
+                }
+            } else {
+                for (SkFlagInfo* flag = SkCommandLineFlags::gHead; flag;
+                     flag = flag->next()) {
                     for (int k = 0; k < helpFlags.count(); k++) {
                         if (flag->name().equals(helpFlags[k]) ||
                             flag->shortName().equals(helpFlags[k])) {
-                            printFlag = true;
+                            print_help_for_flag(flag);
                             helpFlags.remove(k);
                             break;
                         }
                     }
                 }
-                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) {
@@ skipping 94 matching lines @@
 }
 
 }  // namespace
 
 bool SkCommandLineFlags::ShouldSkip(const SkTDArray<const char*>& strings, const char* name) {
     return ShouldSkipImpl(strings, name);
 }
 bool SkCommandLineFlags::ShouldSkip(const StringArray& strings, const char* name) {
     return ShouldSkipImpl(strings, name);
 }