Revert "Add flags to force or prevent setting of isolate.is_memory_constrained."

src/flags.cc

 // Copyright 2006-2008 the V8 project authors. All rights reserved.
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions are
 // met:
 //
 //     * Redistributions of source code must retain the above copyright
 //       notice, this list of conditions and the following disclaimer.
 //     * Redistributions in binary form must reproduce the above
 //       copyright notice, this list of conditions and the following
 //       disclaimer in the documentation and/or other materials provided
@@ skipping 37 matching lines @@
 // Define all of our flags default values.
 #define FLAG_MODE_DEFINE_DEFAULTS
 #include "flag-definitions.h"
 
 namespace {
 
 // This structure represents a single entry in the flag system, with a pointer
 // to the actual flag, default value, comment, etc.  This is designed to be POD
 // initialized as to avoid requiring static constructors.
 struct Flag {
-  enum FlagType { TYPE_BOOL, TYPE_MAYBE_BOOL, TYPE_INT, TYPE_FLOAT,
-                  TYPE_STRING, TYPE_ARGS };
+  enum FlagType { TYPE_BOOL, TYPE_INT, TYPE_FLOAT, TYPE_STRING, TYPE_ARGS };
 
   FlagType type_;           // What type of flag, bool, int, or string.
   const char* name_;        // Name of the flag, ex "my_flag".
   void* valptr_;            // Pointer to the global flag variable.
   const void* defptr_;      // Pointer to the default value.
   const char* cmt_;         // A comment about the flags purpose.
   bool owns_ptr_;           // Does the flag own its string value?
 
   FlagType type() const { return type_; }
 
   const char* name() const { return name_; }
 
   const char* comment() const { return cmt_; }
 
   bool* bool_variable() const {
     ASSERT(type_ == TYPE_BOOL);
     return reinterpret_cast<bool*>(valptr_);
   }
 
-  Maybe<bool>* maybe_bool_variable() const {
-    ASSERT(type_ == TYPE_MAYBE_BOOL);
-    return reinterpret_cast<Maybe<bool>*>(valptr_);
-  }
-
   int* int_variable() const {
     ASSERT(type_ == TYPE_INT);
     return reinterpret_cast<int*>(valptr_);
   }
 
   double* float_variable() const {
     ASSERT(type_ == TYPE_FLOAT);
     return reinterpret_cast<double*>(valptr_);
   }
 
@@ skipping 38 matching lines @@
   JSArguments args_default() const {
     ASSERT(type_ == TYPE_ARGS);
     return *reinterpret_cast<const JSArguments*>(defptr_);
   }
 
   // Compare this flag's current value against the default.
   bool IsDefault() const {
     switch (type_) {
       case TYPE_BOOL:
         return *bool_variable() == bool_default();
-      case TYPE_MAYBE_BOOL:
-        return maybe_bool_variable()->has_value == false;
       case TYPE_INT:
         return *int_variable() == int_default();
       case TYPE_FLOAT:
         return *float_variable() == float_default();
       case TYPE_STRING: {
         const char* str1 = string_value();
         const char* str2 = string_default();
         if (str2 == NULL) return str1 == NULL;
         if (str1 == NULL) return str2 == NULL;
         return strcmp(str1, str2) == 0;
       }
       case TYPE_ARGS:
         return args_variable()->argc() == 0;
     }
     UNREACHABLE();
     return true;
   }
 
   // Set a flag back to it's default value.
   void Reset() {
     switch (type_) {
       case TYPE_BOOL:
         *bool_variable() = bool_default();
         break;
-      case TYPE_MAYBE_BOOL:
-        *maybe_bool_variable() = Maybe<bool>();
-        break;
       case TYPE_INT:
         *int_variable() = int_default();
         break;
       case TYPE_FLOAT:
         *float_variable() = float_default();
         break;
       case TYPE_STRING:
         set_string_value(string_default(), false);
         break;
       case TYPE_ARGS:
         *args_variable() = args_default();
         break;
     }
   }
 };
 
 Flag flags[] = {
 #define FLAG_MODE_META
 #include "flag-definitions.h"
 };
 
 const size_t num_flags = sizeof(flags) / sizeof(*flags);
 
 }  // namespace
 
 
 static const char* Type2String(Flag::FlagType type) {
   switch (type) {
     case Flag::TYPE_BOOL: return "bool";
-    case Flag::TYPE_MAYBE_BOOL: return "maybe_bool";
     case Flag::TYPE_INT: return "int";
     case Flag::TYPE_FLOAT: return "float";
     case Flag::TYPE_STRING: return "string";
     case Flag::TYPE_ARGS: return "arguments";
   }
   UNREACHABLE();
   return NULL;
 }
 
 
 static SmartArrayPointer<const char> ToString(Flag* flag) {
   HeapStringAllocator string_allocator;
   StringStream buffer(&string_allocator);
   switch (flag->type()) {
     case Flag::TYPE_BOOL:
       buffer.Add("%s", (*flag->bool_variable() ? "true" : "false"));
       break;
-    case Flag::TYPE_MAYBE_BOOL:
-      buffer.Add("%s", flag->maybe_bool_variable()->has_value
-                       ? (flag->maybe_bool_variable()->value ? "true" : "false")
-                       : "unset");
-      break;
     case Flag::TYPE_INT:
       buffer.Add("%d", *flag->int_variable());
       break;
     case Flag::TYPE_FLOAT:
       buffer.Add("%f", FmtElm(*flag->float_variable()));
       break;
     case Flag::TYPE_STRING: {
       const char* str = flag->string_value();
       buffer.Add("%s", str ? str : "NULL");
       break;
@@ skipping 157 matching lines @@
         } else {
           PrintF(stderr, "Error: unrecognized flag %s\n"
                  "Try --help for options\n", arg);
           return_code = j;
           break;
         }
       }
 
       // if we still need a flag value, use the next argument if available
       if (flag->type() != Flag::TYPE_BOOL &&
-          flag->type() != Flag::TYPE_MAYBE_BOOL &&
           flag->type() != Flag::TYPE_ARGS &&
           value == NULL) {
         if (i < *argc) {
           value = argv[i++];
         } else {
           PrintF(stderr, "Error: missing value for flag %s of type %s\n"
                  "Try --help for options\n",
                  arg, Type2String(flag->type()));
           return_code = j;
           break;
         }
       }
 
       // set the flag
       char* endp = const_cast<char*>("");  // *endp is only read
       switch (flag->type()) {
         case Flag::TYPE_BOOL:
           *flag->bool_variable() = !is_bool;
           break;
-        case Flag::TYPE_MAYBE_BOOL:
-          *flag->maybe_bool_variable() = Maybe<bool>(!is_bool);
-          break;
         case Flag::TYPE_INT:
           *flag->int_variable() = strtol(value, &endp, 10);  // NOLINT
           break;
         case Flag::TYPE_FLOAT:
           *flag->float_variable() = strtod(value, &endp);
           break;
         case Flag::TYPE_STRING:
           flag->set_string_value(value ? StrDup(value) : NULL, true);
           break;
         case Flag::TYPE_ARGS: {
           int start_pos = (value == NULL) ? i : i - 1;
           int js_argc = *argc - start_pos;
           const char** js_argv = NewArray<const char*>(js_argc);
           if (value != NULL) {
             js_argv[0] = StrDup(value);
           }
           for (int k = i; k < *argc; k++) {
             js_argv[k - start_pos] = StrDup(argv[k]);
           }
           *flag->args_variable() = JSArguments::Create(js_argc, js_argv);
           i = *argc;  // Consume all arguments
           break;
         }
       }
 
       // handle errors
-      bool is_bool_type = flag->type() == Flag::TYPE_BOOL ||
-          flag->type() == Flag::TYPE_MAYBE_BOOL;
-      if ((is_bool_type && value != NULL) || (!is_bool_type && is_bool) ||
+      if ((flag->type() == Flag::TYPE_BOOL && value != NULL) ||
+          (flag->type() != Flag::TYPE_BOOL && is_bool) ||
           *endp != '\0') {
         PrintF(stderr, "Error: illegal value for flag %s of type %s\n"
                "Try --help for options\n",
                arg, Type2String(flag->type()));
         return_code = j;
         break;
       }
 
       // remove the flag & value from the command
       if (remove_flags) {
@@ skipping 102 matching lines @@
   printf("Options:\n");
   for (size_t i = 0; i < num_flags; ++i) {
     Flag* f = &flags[i];
     SmartArrayPointer<const char> value = ToString(f);
     printf("  --%s (%s)\n        type: %s  default: %s\n",
            f->name(), f->comment(), Type2String(f->type()), *value);
   }
 }
 
 
-// static
 void FlagList::EnforceFlagImplications() {
 #define FLAG_MODE_DEFINE_IMPLICATIONS
 #include "flag-definitions.h"
 #undef FLAG_MODE_DEFINE_IMPLICATIONS
 }
 
 } }  // namespace v8::internal