Ensure removing processed command line arguments.

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 325 matching lines @@
       return &flags[i];
   }
   return NULL;
 }
 
 
 // static
 int FlagList::SetFlagsFromCommandLine(int* argc,
                                       char** argv,
                                       bool remove_flags) {
+  int return_code = 0;
   // parse arguments
   for (int i = 1; i < *argc;) {
     int j = i;  // j > 0
     const char* arg = argv[i++];
 
     // split arg into flag components
     char buffer[1*KB];
     const char* name;
     const char* value;
     bool is_bool;
     SplitArgument(arg, buffer, sizeof buffer, &name, &value, &is_bool);
 
     if (name != NULL) {
       // lookup the flag
       Flag* flag = FindFlag(name);
       if (flag == NULL) {
         if (remove_flags) {
           // We don't recognize this flag but since we're removing
           // the flags we recognize we assume that the remaining flags
           // will be processed somewhere else so this flag might make
           // sense there.
           continue;
         } else {
           fprintf(stderr, "Error: unrecognized flag %s\n"
                   "Try --help for options\n", arg);
-          return j;
+          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_ARGS &&
           value == NULL) {
         if (i < *argc) {
           value = argv[i++];
         } else {
           fprintf(stderr, "Error: missing value for flag %s of type %s\n"
                   "Try --help for options\n",
                   arg, Type2String(flag->type()));
-          return j;
+          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_INT:
@@ skipping 21 matching lines @@
         }
       }
 
       // handle errors
       if ((flag->type() == Flag::TYPE_BOOL && value != NULL) ||
           (flag->type() != Flag::TYPE_BOOL && is_bool) ||
           *endp != '\0') {
         fprintf(stderr, "Error: illegal value for flag %s of type %s\n"
                 "Try --help for options\n",
                 arg, Type2String(flag->type()));
-        return j;
+        return_code = j;
+        break;
       }
 
       // remove the flag & value from the command
       if (remove_flags) {
         while (j < i) {
           argv[j++] = NULL;
         }
       }
     }
   }
 
   // shrink the argument list
   if (remove_flags) {
     int j = 1;
     for (int i = 1; i < *argc; i++) {
       if (argv[i] != NULL)
         argv[j++] = argv[i];
     }
     *argc = j;
   }
 
   if (FLAG_help) {
     PrintHelp();
     exit(0);
   }
   // parsed all flags successfully
-  return 0;
+  return return_code;
 }
 
 
 static char* SkipWhiteSpace(char* p) {
   while (*p != '\0' && isspace(*p) != 0) p++;
   return p;
 }
 
 
 static char* SkipBlackSpace(char* p) {
@@ skipping 69 matching lines @@
   }
 }
 
 
 void FlagList::EnforceFlagImplications() {
 #define FLAG_MODE_DEFINE_IMPLICATIONS
 #include "flag-definitions.h"
 }
 
 } }  // namespace v8::internal