SkFlags now follows proper dashing convention.

tools/flags/SkCommandLineFlags.h

 /*
  * Copyright 2013 Google Inc.
  *
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */
 
 #ifndef SK_COMMAND_LINE_FLAGS_H
 #define SK_COMMAND_LINE_FLAGS_H
 
@@ skipping 23 matching lines @@
  *  will create the following variable:
  *
  *  bool FLAGS_boolean;
  *
  *  which will initially be set to false, and can be set to true by using the
  *  flag "--boolean" on the commandline. "--noboolean" will set FLAGS_boolean
  *  to false. FLAGS_boolean can also be set using "--boolean=true" or
  *  "--boolean true" (where "true" can be replaced by "false", "TRUE", "FALSE",
  *  "1" or "0").
  *
- *  Single dashes are also permitted for this and other flags.
- *
  *  The helpString will be printed if the help flag (-h or -help) is used.
  *
  *  Similarly, the line
  *
  *  DEFINE_int32(integer, .., ..);
  *
  *  will create
  *
  *  int32_t FLAGS_integer;
  *
@@ skipping 86 matching lines @@
 #define DECLARE_bool(name) extern bool FLAGS_##name;
 
 #define DEFINE_string(name, defaultValue, helpString)                       \
 SkTDArray<const char*> FLAGS_##name;                                        \
 static bool unused_##name = SkFlagInfo::CreateStringFlag(TO_STRING(name),   \
                                                          NULL,              \
                                                          &FLAGS_##name,     \
                                                          defaultValue,      \
                                                          helpString)
 
-// string2 allows specifying a short name. No check is done to ensure that shortName
-// is actually shorter than name.
+// string2 allows specifying a short name. There is an assert that shortName
+// is only 1 character.
 #define DEFINE_string2(name, shortName, defaultValue, helpString)               \

[reed1, 2013/03/21 22:06:59]

Can we name this DEFINE_char or DEFINE_string1, to sort of match its intent?

[scroggo, 2013/03/22 17:52:31]

I agree that the current name is bad... I'm thinking something along the lines
of

DEFINE_string_with_shortcut

(although that feels a little on the long side)

 SkTDArray<const char*> FLAGS_##name;                                            \
 static bool unused_##name = SkFlagInfo::CreateStringFlag(TO_STRING(name),       \
                                                          TO_STRING(shortName),  \
                                                          &FLAGS_##name,         \
                                                          defaultValue,          \
                                                          helpString)
 
 #define DECLARE_string(name) extern SkTDArray<const char*> FLAGS_##name;
 
 #define DEFINE_int32(name, defaultValue, helpString)                        \
@@ skipping 20 matching lines @@
     enum FlagTypes {
         kBool_FlagType,
         kString_FlagType,
         kInt_FlagType,
         kDouble_FlagType,
     };
 
     // Create flags of the desired type, and append to the list.
     static bool CreateBoolFlag(const char* name, const char* shortName, bool* pBool,
                                bool defaultValue, const char* helpString) {
-        SkFlagInfo* info = SkNEW_ARGS(SkFlagInfo, (name, kBool_FlagType, helpString));
-        info->fShortName.set(shortName);
+        SkFlagInfo* info = SkNEW_ARGS(SkFlagInfo, (name, shortName, kBool_FlagType, helpString));
         info->fBoolValue = pBool;
         *info->fBoolValue = info->fDefaultBool = defaultValue;
         return true;
     }
 
     static bool CreateStringFlag(const char* name, const char* shortName,
                                  SkTDArray<const char*>* pStrings,
                                  const char* defaultValue, const char* helpString) {
-        SkFlagInfo* info = SkNEW_ARGS(SkFlagInfo, (name, kString_FlagType, helpString));
-        info->fShortName.set(shortName);
+        SkFlagInfo* info = SkNEW_ARGS(SkFlagInfo, (name, shortName, kString_FlagType, helpString));
         info->fDefaultString.set(defaultValue);
 
         info->fStrings = pStrings;
         info->fStrings->reset();
         // If default is "", leave the array empty.
         if (info->fDefaultString.size() > 0) {
             info->fStrings->append(1, &defaultValue);
         }
         return true;
     }
 
     static bool CreateIntFlag(const char* name, int32_t* pInt,
                               int32_t defaultValue, const char* helpString) {
-        SkFlagInfo* info = SkNEW_ARGS(SkFlagInfo, (name, kInt_FlagType, helpString));
+        SkFlagInfo* info = SkNEW_ARGS(SkFlagInfo, (name, NULL, kInt_FlagType, helpString));
         info->fIntValue = pInt;
         *info->fIntValue = info->fDefaultInt = defaultValue;
         return true;
     }
 
     static bool CreateDoubleFlag(const char* name, double* pDouble,
                                  double defaultValue, const char* helpString) {
-        SkFlagInfo* info = SkNEW_ARGS(SkFlagInfo, (name, kDouble_FlagType, helpString));
+        SkFlagInfo* info = SkNEW_ARGS(SkFlagInfo, (name, NULL, kDouble_FlagType, helpString));
         info->fDoubleValue = pDouble;
         *info->fDoubleValue = info->fDefaultDouble = defaultValue;
         return true;
     }
 
     /**
      *  Returns true if the string matches this flag.
      *  For a boolean flag, also sets the value, since a boolean flag can be set in a number of ways
      *  without looking at the following string:
      *      --name
@@ skipping 87 matching lines @@
                 return SkString("int");
             case SkFlagInfo::kDouble_FlagType:
                 return SkString("double");
             default:
                 SkASSERT(!"Invalid flag type");
                 return SkString();
         }
     }
 
 private:
-    SkFlagInfo(const char* name, FlagTypes type, const char* helpString)
+    SkFlagInfo(const char* name, const char* shortName, FlagTypes type, const char* helpString)
         : fName(name)
+        , fShortName(shortName)
         , fFlagType(type)
         , fHelpString(helpString)
         , fBoolValue(NULL)
         , fDefaultBool(false)
         , fIntValue(NULL)
         , fDefaultInt(0)
         , fDoubleValue(NULL)
         , fDefaultDouble(0)
         , fStrings(NULL) {
         fNext = SkCommandLineFlags::gHead;
         SkCommandLineFlags::gHead = this;
+        SkASSERT(NULL != name && strlen(name) > 1);
+        SkASSERT(NULL == shortName || 1 == strlen(shortName));
     }
     // Name of the flag, without initial dashes
     SkString             fName;
     SkString             fShortName;
     FlagTypes            fFlagType;
     SkString             fHelpString;
     bool*                fBoolValue;
     bool                 fDefaultBool;
     int32_t*             fIntValue;
     int32_t              fDefaultInt;
     double*              fDoubleValue;
     double               fDefaultDouble;
     SkTDArray<const char*>* fStrings;
     // Both for the help string and in case fStrings is empty.
     SkString             fDefaultString;
 
     // In order to keep a linked list.
     SkFlagInfo*          fNext;
 };
 #endif // SK_COMMAND_LINE_FLAGS_H