Add support for reading .gypi files.

tools/gn/value.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 "tools/gn/value.h"
 
 #include "base/strings/string_number_conversions.h"
 
 Value::Value()
     : type_(NONE),
@@ skipping 74 matching lines @@
     case BOOLEAN:
       return "boolean";
     case INTEGER:
       return "integer";
     case STRING:
       return "string";
     case LIST:
       return "list";
     case SCOPE:
       return "scope";
+    case DICT:
+      return "dict";
     default:
       NOTREACHED();
       return "UNKNOWN";
   }
 }
 
 std::string Value::ToString(bool quote_string) const {
   switch (type_) {
     case NONE:
       return "<void>";
@@ skipping 10 matching lines @@
       for (size_t i = 0; i < list_value_.size(); i++) {
         if (i > 0)
           result += ", ";
         result += list_value_[i].ToString(true);
       }
       result.push_back(']');
       return result;
     }
     case SCOPE:
       return std::string("<scope>");
+    case DICT: {
+      std::string result = "{\n";
+      for (std::map<std::string, Value>::const_iterator i = dict_value_.begin();
+           i != dict_value_.end(); ++i) {
+        result += "  " + i->first + " = " + i->second.ToString(true) + "\n";
+      }
+      result += "}";
+      return result;
+    }
   }
   return std::string();
 }
 
 bool Value::VerifyTypeIs(Type t, Err* err) const {
   if (type_ == t)
     return true;
 
   *err = Err(origin(), std::string("This is not a ") + DescribeType(t) + ".");
   return false;
@@ skipping 12 matching lines @@
       return string_value() == other.string_value();
     case Value::LIST:
       if (list_value().size() != other.list_value().size())
         return false;
       for (size_t i = 0; i < list_value().size(); i++) {
         if (list_value()[i] != other.list_value()[i])
           return false;
       }
       return true;
     case Value::SCOPE:
-      // Its not clear what people mean when comparing scope values, so we test
-      // for scope identity and not contents equality.
-      return scope_value() == other.scope_value();
+      // Scopes are always considered not equal because there's currently
+      // no use case for comparing them, and it requires a bunch of complex
+      // iteration code.
+      return false;
+    case Value::DICT:
+      return dict_value_.size() == other.dict_value_.size() &&
+             std::equal(dict_value_.begin(), dict_value_.end(),
+                        other.dict_value_.begin());
     default:
       return false;
   }
 }
 
 bool Value::operator!=(const Value& other) const {
   return !operator==(other);
 }