Remove default value checking in GN, adds getenv function, reorders parameters to rebase_path.

tools/gn/command_args.cc

 // Copyright (c) 2013 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include <map>
 
 #include "base/strings/string_number_conversions.h"
 #include "base/strings/string_util.h"
 #include "tools/gn/commands.h"
 #include "tools/gn/input_file.h"
@@ skipping 24 matching lines @@
 
   size_t cur = offset;
   do {
     cur --;
     if (Tokenizer::IsNewline(data, cur))
       return cur + 1;  // Want the first character *after* the newline.
   } while (cur > 0);
   return 0;
 }
 
-// Assumes DoesLineBeginWithComment().
-std::string StripCommentFromLine(const base::StringPiece& line) {
-  std::string ret = line.as_string();
-  for (size_t i = 0; i < ret.size(); i++) {
-    if (ret[i] == '#') {
-      ret[i] = ' ';
+// Assumes DoesLineBeginWithComment(), this strips the # character from the
+// beginning and normalizes preceeding whitespace.
+std::string StripHashFromLine(const base::StringPiece& line) {
+  std::string ret;

[viettrungluu, 2014/02/12 23:09:35]

Can't this just be something like:

return "   " + line.substr(line.find('#') + 1).as_string();

+  for (size_t i = 0; i < line.size(); i++) {
+    if (line[i] == '#') {
+      // Replace the # sign and everything before it with 3 spaces, so that
+      // a normal comment that has a space after the # will be indented 4
+      // spaces (which makes our formatting come out nicely). If the comment is
+      // indented from there, we want to preserve that indenting.
+      ret.assign("   ");
+      ret.append(line.substr(i + 1).as_string());
       break;
     }
   }
   return ret;
 }
 
 // Tries to find the comment before the setting of the given value.
 void GetContextForValue(const Value& value,
                         std::string* location_str,
                         std::string* comment) {
@@ skipping 11 matching lines @@
 
   while (line_off > 1) {
     line_off -= 2;  // Back up to end of previous line.
     size_t previous_line_offset = BackUpToLineBegin(data, line_off);
 
     base::StringPiece line(&data[previous_line_offset],
                            line_off - previous_line_offset + 1);
     if (!DoesLineBeginWithComment(line))
       break;
 
-    comment->insert(0, StripCommentFromLine(line) + "\n");
+    comment->insert(0, StripHashFromLine(line) + "\n");
     line_off = previous_line_offset;
   }
 }
 
 void PrintArgHelp(const base::StringPiece& name, const Value& value) {
   OutputString(name.as_string(), DECORATION_YELLOW);
   OutputString("  Default = " + value.ToString(true) + "\n");
 
   if (value.origin()) {
     std::string location, comment;
@@ skipping 50 matching lines @@
         "Usage: \"gn args [arg name]\"").PrintToStdout();
     return 1;
   }
 
   // List all arguments. First put them in a regular map so they're sorted.
   std::map<base::StringPiece, Value> sorted_args;
   for (Scope::KeyValueMap::const_iterator i = build_args.begin();
        i != build_args.end(); ++i)
     sorted_args.insert(*i);
 
+  OutputString(
+      "Available build arguments. Note that the which arguments are declared\n"
+      "and their default values may depend on other arguments or the current\n"
+      "platform and architecture. So setting some values may add, remove, or\n"
+      "change the default value of other values.\n\n");
+
   for (std::map<base::StringPiece, Value>::iterator i = sorted_args.begin();
        i != sorted_args.end(); ++i) {
     PrintArgHelp(i->first, i->second);
     OutputString("\n");
   }
 
   return 0;
 }
 
 }  // namespace commands