Add support for reading .gypi files.

tools/gn/value.h

Index: tools/gn/value.h
diff --git a/tools/gn/value.h b/tools/gn/value.h
index ee201c45e7b6a8065f3d014724eade3f79eccb8b..543b6e98cca3a4969009d5619bd3c4a21bc7a3b3 100644
--- a/tools/gn/value.h
+++ b/tools/gn/value.h
@@ -5,6 +5,8 @@
 #ifndef TOOLS_GN_VALUE_H_
 #define TOOLS_GN_VALUE_H_
 
+#include <map>
+
 #include "base/basictypes.h"
 #include "base/logging.h"
 #include "base/strings/string_piece.h"
@@ -22,7 +24,23 @@ class Value {
     INTEGER,
     STRING,
     LIST,
-    SCOPE
+
+    // Scopes and dictionaries act equivalently from the calling code
+    // perspective, but are created differently. The scope type is used in
+    // templates to refer to the invoker. Dictionaries are used when reading
+    // scopes from files and we actually want to copy and own the values. Both

[scottmg, 2014/04/03 20:44:40]

Adding a second almost-identical seems pretty awkward. Doesn't scope have a copy
mode already that could be used instead?

[brettw, 2014/04/03 23:19:24]

I went around and around on this and at times had implemented it 3 different
ways.


Options:
1) Keep as-is with two confusingly similar modes.

2) Make the value always own a scope. This has the disadvantage that we have to
copy the values each time we instantiate a template (we'll have a lot of
templates, and some of them will be passing large file lists around). A bigger
disadvantage is that we'd lose the ability to track which variables were read
out of the scope by the template. This means we'd lose the ability to catch
misspellings of variables when you instantiate a template. Last, it has the
settings problem I discuss below.

3) Remove scope and keep the dict mode. Copy the values out of the scope into
the dict where we currently use scope. This has the same disadvantages as (2)
although I think it's more clear so would prefer this.

4) Have value able to either copy or reference a scope. Value gets a bit
confusing memory-management wise, but we get back the used variable tracking for
the template case, and also avoid copies. This has the settings problem.


The settings problem:

I started doing (4) at one point but gave up when I realized that I have a
problem because the input conversion executes the scope in the context of an
empty Settings object on the stack. The scope references this, so copying the
scope will resulting in pointers to destructed stack vars floating around.

I execute it in the context of an empty settings object to avoid potentially
confusing global state leaking into the scope when we're evaluating the value.
But upon further reflection the amount of information leakage is minimal to
none.

So I'm leaning to #4. What do you think?

+    // are read-only from script and are read using "value.key" syntax.
+    //
+    // GN specifically doesn't expose a general writable dictionary type to the
+    // script because of the additional complexity, lack of a strong use case,
+    // and potential for abuse. We can add this if there is a very strong use
+    // case and we can come up with syntax we like.
+    //
+    // If we wanted to use this more generally, an alternative approach would
+    // be to refcount the Scope object so value could own a reference to it,
+    // and then delete the dictionary type.
+    SCOPE,
+    DICT,
   };
 
   Value();
@@ -93,6 +111,15 @@ class Value {
     return scope_value_;
   }
 
+  std::map<std::string, Value>& dict_value() {
+    DCHECK(type_ == DICT);
+    return dict_value_;
+  }
+  const std::map<std::string, Value>& dict_value() const {
+    DCHECK(type_ == DICT);
+    return dict_value_;
+  }
+
   // Converts the given value to a string. Returns true if strings should be
   // quoted or the ToString of a string should be the string itself.
   std::string ToString(bool quote_strings) const;
@@ -106,12 +133,17 @@ class Value {
   bool operator!=(const Value& other) const;
 
  private:
+  // This is a lot of objects associated with every Value that need
+  // initialization and tear down every time. It might be more efficient to
+  // create a union of ManualConstructor objects (see SmallMap) and only
+  // use the one we care about.
   Type type_;
   std::string string_value_;
   bool boolean_value_;
   int64 int_value_;
   std::vector<Value> list_value_;
   Scope* scope_value_;  // Non-owning.
+  std::map<std::string, Value> dict_value_;
 
   const ParseNode* origin_;
 };