Add support for reading .gypi files.

tools/gn/value.h

 // 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.
 
 #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"
 #include "tools/gn/err.h"
 
 class ParseNode;
 class Scope;
 
 // Represents a variable value in the interpreter.
 class Value {
  public:
   enum Type {
     NONE = 0,
     BOOLEAN,
     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();
   Value(const ParseNode* origin, Type t);
   Value(const ParseNode* origin, bool bool_val);
   Value(const ParseNode* origin, int64 int_val);
   Value(const ParseNode* origin, std::string str_val);
   Value(const ParseNode* origin, const char* str_val);
   Value(const ParseNode* origin, Scope* scope);  // Non-owning ptr.
                                                  // (must outlive Value.)
@@ skipping 50 matching lines @@
 
   Scope* scope_value() {
     DCHECK(type_ == SCOPE);
     return scope_value_;
   }
   const Scope* scope_value() const {
     DCHECK(type_ == SCOPE);
     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;
 
   // Verifies that the value is of the given type. If it isn't, returns
   // false and sets the error.
   bool VerifyTypeIs(Type t, Err* err) const;
 
   // Compares values. Only the "value" is compared, not the origin.
   bool operator==(const Value& other) const;
   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_;
 };
 
 #endif  // TOOLS_GN_VALUE_H_