Fix issue 1950:

vm/flags.cc

 // Copyright (c) 2012, the Dart project authors.  Please see the AUTHORS file
 // for details. All rights reserved. Use of this source code is governed by a
 // BSD-style license that can be found in the LICENSE file.
 
 #include "vm/flags.h"
 
 #include "platform/assert.h"
 #include "vm/os.h"
 
 namespace dart {
 
 DEFINE_FLAG(bool, print_flags, false, "Print flags as they are being parsed.");
 DEFINE_FLAG(bool, ignore_unrecognized_flags, false,
     "Ignore unrecognized flags.");
 
 // List of registered flags.
 Flag* Flags::flags_ = NULL;
 
 bool Flags::initialized_ = false;
 
 class Flag {
  public:
   enum FlagType {
     kBoolean,
     kInteger,
     kString,
+    kFunc,
     kNumFlagTypes
   };
 
   Flag(const char* name, const char* comment, void* addr, FlagType type)
       : name_(name), comment_(comment), addr_(addr), type_(type) {
   }
+  Flag(const char* name, const char* comment, FlagHandler handler)
+      : name_(name), comment_(comment), handler_(handler), type_(kFunc) {
+  }
 
   void Print() {
     if (IsUnrecognized()) {
       OS::Print("%s: unrecognized\n", name_);
       return;
     }
     switch (type_) {
       case kBoolean: {
         OS::Print("%s: %s (%s)\n",
             name_, *this->bool_ptr_ ? "true" : "false", comment_);
         break;
       }
       case kInteger: {
         OS::Print("%s: %d (%s)\n", name_, *this->int_ptr_, comment_);
         break;
       }
       case kString: {
         if (*this->charp_ptr_ != NULL) {
           OS::Print("%s: '%s' (%s)\n", name_, *this->charp_ptr_, comment_);
         } else {
           OS::Print("%s: (null) (%s)\n", name_, comment_);
         }
         break;
       }
+      case kFunc: {
+        // No value to print here.

[regis, 2012/03/09 23:16:03]

You could maybe print the name of the flag.

[Ivan Posva, 2012/03/09 23:20:37]

Done.

+        break;
+      }
       default:
         UNREACHABLE();
         break;
     }
   }
 
   bool IsUnrecognized() const {
     return (type_ == kBoolean) && (bool_ptr_ == NULL);
   }
 
   Flag* next_;
   const char* name_;
   const char* comment_;
   union {
     void* addr_;
     bool* bool_ptr_;
     int* int_ptr_;
     charp* charp_ptr_;
+    FlagHandler handler_;
   };
   FlagType type_;
 };
 
 
 Flag* Flags::Lookup(const char* name) {
   Flag* cur = Flags::flags_;
   while (cur != NULL) {
     if (strcmp(cur->name_, name) == 0) {
       return cur;
@@ skipping 37 matching lines @@
                                   const char* default_value,
                                   const char* comment) {
   ASSERT(Lookup(name) == NULL);
   Flag* flag = new Flag(name, comment, addr, Flag::kString);
   flag->next_ = Flags::flags_;
   Flags::flags_ = flag;
   return default_value;
 }
 
 
+bool Flags::Register_func(FlagHandler handler,
+                          const char* name,
+                          const char* comment) {
+  ASSERT(Lookup(name) == NULL);
+  Flag* flag = new Flag(name, comment, handler);
+  flag->next_ = Flags::flags_;
+  Flags::flags_ = flag;
+  return false;
+}
+
+
 static void Normalize(char* s) {
   intptr_t len = strlen(s);
   for (intptr_t i = 0; i < len; i++) {
     if (s[i] == '-') {
       s[i] = '_';
     }
   }
 }
 
 
@@ skipping 57 matching lines @@
           break;
         }
         case Flag::kInteger: {
           char* endptr = NULL;
           int val = strtol(argument, &endptr, 10);
           if (endptr != argument) {
             *flag->int_ptr_ = val;
           }
           break;
         }
+        case Flag::kFunc: {
+          if (strcmp(argument, "true") == 0) {
+            (flag->handler_)(true);
+          } else if (strcmp(argument, "false") == 0) {
+            (flag->handler_)(false);
+          } else {
+            OS::Print("Ignoring flag: %s is a bool flag.\n", name);
+          }
+          break;
+        }
         default: {
           UNREACHABLE();
           break;
         }
       }
     }
   }
 
   delete[] name;
 }
@@ skipping 52 matching lines @@
     while (flag != NULL) {
       flag->Print();
       flag = flag->next_;
     }
   }
 
   return true;
 }
 
 }  // namespace dart