diff --git a/src/main/cpp/option_processor.cc b/src/main/cpp/option_processor.cc
index db19d3f..fc6d8b1 100644
--- a/src/main/cpp/option_processor.cc
+++ b/src/main/cpp/option_processor.cc
@@ -169,14 +169,12 @@
 OptionProcessor::OptionProcessor(
     const WorkspaceLayout* workspace_layout,
     std::unique_ptr<StartupOptions> default_startup_options)
-    : initialized_(false),
-      workspace_layout_(workspace_layout),
+    : workspace_layout_(workspace_layout),
       parsed_startup_options_(std::move(default_startup_options)) {
 }
 
 std::unique_ptr<CommandLine> OptionProcessor::SplitCommandLine(
-    const vector<string>& args,
-    string* error) {
+    const vector<string>& args, string* error) const {
   const string lowercase_product_name =
       parsed_startup_options_->GetLowercaseProductName();
 
@@ -299,6 +297,7 @@
 }
 
 namespace internal {
+
 vector<string> DedupeBlazercPaths(const vector<string>& paths) {
   set<string> canonical_paths;
   vector<string> result;
@@ -314,6 +313,7 @@
   }
   return result;
 }
+
 }  // namespace internal
 
 // Parses the arguments provided in args using the workspace path and the
@@ -323,24 +323,19 @@
     const string& workspace,
     const string& cwd,
     string* error) {
-  assert(!initialized_);
-  initialized_ = true;
 
-  args_ = args;
-  std::unique_ptr<CommandLine> cmd_line = SplitCommandLine(args, error);
-  if (cmd_line == nullptr) {
+  cmd_line_ = SplitCommandLine(args, error);
+  if (cmd_line_ == nullptr) {
     return blaze_exit_code::BAD_ARGV;
   }
-  explicit_command_arguments_ = cmd_line->command_args;
-
-  const char* blazerc = SearchUnaryOption(cmd_line->startup_args, "--blazerc");
+  const char* blazerc = SearchUnaryOption(cmd_line_->startup_args, "--blazerc");
   if (blazerc == NULL) {
-    blazerc = SearchUnaryOption(cmd_line->startup_args, "--bazelrc");
+    blazerc = SearchUnaryOption(cmd_line_->startup_args, "--bazelrc");
   }
 
   bool use_master_blazerc = true;
-  if (SearchNullaryOption(cmd_line->startup_args, "--nomaster_blazerc") ||
-      SearchNullaryOption(cmd_line->startup_args, "--nomaster_bazelrc")) {
+  if (SearchNullaryOption(cmd_line_->startup_args, "--nomaster_blazerc") ||
+      SearchNullaryOption(cmd_line_->startup_args, "--nomaster_bazelrc")) {
     use_master_blazerc = false;
   }
 
@@ -350,7 +345,7 @@
   vector<string> candidate_blazerc_paths;
   if (use_master_blazerc) {
     workspace_layout_->FindCandidateBlazercPaths(
-        workspace, cwd, cmd_line->path_to_binary, cmd_line->startup_args,
+        workspace, cwd, cmd_line_->path_to_binary, cmd_line_->startup_args,
         &candidate_blazerc_paths);
   }
 
@@ -386,20 +381,8 @@
     return parse_startup_options_exit_code;
   }
 
-  // Once we're done with startup options the next arg is the command.
-  if (startup_args_ + 1 >= args.size()) {
-    command_ = "";
-    return blaze_exit_code::SUCCESS;
-  }
-  command_ = args[startup_args_ + 1];
-
-  AddRcfileArgsAndOptions(cwd);
-
-  // The rest of the args are the command options.
-  for (unsigned int cmd_arg = startup_args_ + 2;
-       cmd_arg < args.size(); cmd_arg++) {
-    command_arguments_.push_back(args[cmd_arg]);
-  }
+  blazerc_and_env_command_args_ = GetBlazercAndEnvCommandArgs(
+      cwd, blazercs_, rcoptions_);
   return blaze_exit_code::SUCCESS;
 }
 
@@ -417,69 +400,28 @@
   return ParseOptions(args, workspace, cwd, error);
 }
 
-blaze_exit_code::ExitCode OptionProcessor::ParseStartupOptions(string *error) {
-  // Process rcfile startup options
-  map< string, vector<RcOption> >::const_iterator it =
-      rcoptions_.find("startup");
-  blaze_exit_code::ExitCode process_arg_exit_code;
-  bool is_space_separated;
-  if (it != rcoptions_.end()) {
-    const vector<RcOption>& startup_options = it->second;
-    int i = 0;
-    // Process all elements except the last one.
-    for (; i < startup_options.size() - 1; i++) {
-      const RcOption& option = startup_options[i];
-      const string& blazerc = blazercs_[option.rcfile_index()]->Filename();
-      process_arg_exit_code = parsed_startup_options_->ProcessArg(
-          option.option(), startup_options[i + 1].option(), blazerc,
-          &is_space_separated, error);
-      if (process_arg_exit_code != blaze_exit_code::SUCCESS) {
-          return process_arg_exit_code;
-      }
-      if (is_space_separated) {
-        i++;
-      }
-    }
-    // Process last element, if any.
-    if (i < startup_options.size()) {
-      const RcOption& option = startup_options[i];
-      if (IsArg(option.option())) {
-        const string& blazerc = blazercs_[option.rcfile_index()]->Filename();
-        process_arg_exit_code = parsed_startup_options_->ProcessArg(
-            option.option(), "", blazerc, &is_space_separated, error);
-        if (process_arg_exit_code != blaze_exit_code::SUCCESS) {
-          return process_arg_exit_code;
-        }
-      }
+blaze_exit_code::ExitCode OptionProcessor::ParseStartupOptions(
+    std::string *error) {
+  std::vector<RcStartupFlag> rcstartup_flags;
+
+  auto iter = rcoptions_.find("startup");
+  if (iter != rcoptions_.end()) {
+    const vector<RcOption>& startup_rcoptions = iter->second;
+    for (const RcOption& option : startup_rcoptions) {
+      rcstartup_flags.push_back(
+          RcStartupFlag(blazercs_[option.rcfile_index()]->Filename(),
+                        option.option()));
     }
   }
 
-  // Process command-line args next, so they override any of the same options
-  // from .blazerc. Stop on first non-arg, this includes --help
-  unsigned int i = 1;
-  if (!args_.empty()) {
-    for (;  (i < args_.size() - 1) && IsArg(args_[i]); i++) {
-      process_arg_exit_code = parsed_startup_options_->ProcessArg(
-          args_[i], args_[i + 1], "", &is_space_separated, error);
-      if (process_arg_exit_code != blaze_exit_code::SUCCESS) {
-          return process_arg_exit_code;
-      }
-      if (is_space_separated) {
-        i++;
-      }
+  for (const std::string& arg : cmd_line_->startup_args) {
+    if (!IsArg(arg)) {
+      break;
     }
-    if (i < args_.size() && IsArg(args_[i])) {
-      process_arg_exit_code = parsed_startup_options_->ProcessArg(
-          args_[i], "", "", &is_space_separated, error);
-      if (process_arg_exit_code != blaze_exit_code::SUCCESS) {
-          return process_arg_exit_code;
-      }
-      i++;
-    }
+    rcstartup_flags.push_back(RcStartupFlag("", arg));
   }
-  startup_args_ = i -1;
 
-  return blaze_exit_code::SUCCESS;
+  return parsed_startup_options_->ProcessArgs(rcstartup_flags, error);
 }
 
 static bool IsValidEnvName(const char* p) {
@@ -532,39 +474,34 @@
 }
 #endif  // defined(COMPILER_MSVC)
 
-// Appends the command and arguments from argc/argv to the end of arg_vector,
-// and also splices in some additional terminal and environment options between
-// the command and the arguments. NB: Keep the options added here in sync with
+// IMPORTANT: Keep the options added here in sync with
 // BlazeCommandDispatcher.INTERNAL_COMMAND_OPTIONS!
-void OptionProcessor::AddRcfileArgsAndOptions(const string& cwd) {
+std::vector<std::string> OptionProcessor::GetBlazercAndEnvCommandArgs(
+    const std::string& cwd,
+    const std::vector<RcFile*>& blazercs,
+    const std::map<std::string, std::vector<RcOption>>& rcoptions) {
   // Provide terminal options as coming from the least important rc file.
-  command_arguments_.push_back("--rc_source=client");
-  command_arguments_.push_back("--default_override=0:common=--is_stderr_atty=" +
-                               ToString(IsStderrStandardTerminal()));
-  command_arguments_.push_back(
-      "--default_override=0:common=--terminal_columns=" +
-      ToString(GetStderrTerminalColumns()));
+  std::vector<std::string> result = {
+    "--rc_source=client",
+    "--default_override=0:common=--is_stderr_atty=" +
+        ToString(IsStderrStandardTerminal()),
+    "--default_override=0:common=--terminal_columns=" +
+        ToString(GetStderrTerminalColumns())};
 
   // Push the options mapping .blazerc numbers to filenames.
-  for (int i_blazerc = 0; i_blazerc < blazercs_.size(); i_blazerc++) {
-    const RcFile* blazerc = blazercs_[i_blazerc];
-    command_arguments_.push_back("--rc_source=" +
-                                 blaze::ConvertPath(blazerc->Filename()));
+  for (const RcFile* blazerc : blazercs) {
+    result.push_back("--rc_source=" + blaze::ConvertPath(blazerc->Filename()));
   }
 
-  // Push the option defaults
-  for (map<string, vector<RcOption> >::const_iterator it = rcoptions_.begin();
-       it != rcoptions_.end(); ++it) {
-    if (it->first == "startup") {
-      // Skip startup options, they are parsed in the C++ wrapper
-      continue;
-    }
-
-    for (int ii = 0; ii < it->second.size(); ii++) {
-      const RcOption& rcoption = it->second[ii];
-      command_arguments_.push_back(
-          "--default_override=" + ToString(rcoption.rcfile_index() + 1) + ":"
-          + it->first + "=" + rcoption.option());
+  // Process RcOptions exept for the startup flags that are already parsed
+  // by the client and shouldn't be handled by defult_overrides.
+  for (auto it = rcoptions.begin(); it != rcoptions.end(); ++it) {
+    if (it->first != "startup") {
+      for (const RcOption& rcoption : it->second) {
+        result.push_back(
+            "--default_override=" + ToString(rcoption.rcfile_index() + 1) + ":"
+            + it->first + "=" + rcoption.option());
+      }
     }
   }
 
@@ -573,31 +510,44 @@
     string env_str(*env);
     if (IsValidEnvName(*env)) {
       PreprocessEnvString(&env_str);
-      command_arguments_.push_back("--client_env=" + env_str);
+      result.push_back("--client_env=" + env_str);
     }
   }
-  command_arguments_.push_back("--client_cwd=" + blaze::ConvertPath(cwd));
+  result.push_back("--client_cwd=" + blaze::ConvertPath(cwd));
 
   if (IsEmacsTerminal()) {
-    command_arguments_.push_back("--emacs");
+    result.push_back("--emacs");
   }
+  return result;
 }
 
-void OptionProcessor::GetCommandArguments(vector<string>* result) const {
-  result->insert(result->end(),
-                 command_arguments_.begin(),
-                 command_arguments_.end());
+std::vector<std::string> OptionProcessor::GetCommandArguments() const {
+  assert(cmd_line_ != nullptr);
+  // When the user didn't specify a command, the server expects the command
+  // arguments to be empty in order to display the help message.
+  if (cmd_line_->command.empty()) {
+    return {};
+  }
+
+  std::vector<std::string> command_args = blazerc_and_env_command_args_;
+  command_args.insert(command_args.end(),
+                      cmd_line_->command_args.begin(),
+                      cmd_line_->command_args.end());
+  return command_args;
 }
 
 std::vector<std::string> OptionProcessor::GetExplicitCommandArguments() const {
-  return explicit_command_arguments_;
+  assert(cmd_line_ != nullptr);
+  return cmd_line_->command_args;
 }
 
-const string& OptionProcessor::GetCommand() const {
-  return command_;
+std::string OptionProcessor::GetCommand() const {
+  assert(cmd_line_ != nullptr);
+  return cmd_line_->command;
 }
 
 StartupOptions* OptionProcessor::GetParsedStartupOptions() const {
+  assert(parsed_startup_options_ != NULL);
   return parsed_startup_options_.get();
 }