tools/gn/value.cc

   1 // Copyright (c) 2013 The Chromium Authors. All rights reserved.
   2 // Use of this source code is governed by a BSD-style license that can be
   3 // found in the LICENSE file.
   4
   5 #include "tools/gn/value.h"
   6
   7 #include "base/strings/string_number_conversions.h"
   8 #include "base/strings/string_util.h"
   9 #include "tools/gn/scope.h"
  10
  11 Value::Value()
  12     : type_(NONE),
  13       boolean_value_(false),
  14       int_value_(0),
  15       origin_(NULL) {
  16 }
  17
  18 Value::Value(const ParseNode* origin, Type t)
  19     : type_(t),
  20       boolean_value_(false),
  21       int_value_(0),
  22       origin_(origin) {
  23 }
  24
  25 Value::Value(const ParseNode* origin, bool bool_val)
  26     : type_(BOOLEAN),
  27       boolean_value_(bool_val),
  28       int_value_(0),
  29       origin_(origin) {
  30 }
  31
  32 Value::Value(const ParseNode* origin, int64 int_val)
  33     : type_(INTEGER),
  34       boolean_value_(false),
  35       int_value_(int_val),
  36       origin_(origin) {
  37 }
  38
  39 Value::Value(const ParseNode* origin, std::string str_val)
  40     : type_(STRING),
  41       string_value_(),
  42       boolean_value_(false),
  43       int_value_(0),
  44       origin_(origin) {
  45   string_value_.swap(str_val);
  46 }
  47
  48 Value::Value(const ParseNode* origin, const char* str_val)
  49     : type_(STRING),
  50       string_value_(str_val),
  51       boolean_value_(false),
  52       int_value_(0),
  53       origin_(origin) {
  54 }
  55
  56 Value::Value(const ParseNode* origin, scoped_ptr<Scope> scope)
  57     : type_(SCOPE),
  58       string_value_(),
  59       boolean_value_(false),
  60       int_value_(0),
  61       scope_value_(scope.Pass()),
  62       origin_(origin) {
  63 }
  64
  65 Value::Value(const Value& other)
  66     : type_(other.type_),
  67       string_value_(other.string_value_),
  68       boolean_value_(other.boolean_value_),
  69       int_value_(other.int_value_),
  70       list_value_(other.list_value_),
  71       origin_(other.origin_) {
  72   if (type() == SCOPE && other.scope_value_.get())
  73     scope_value_ = other.scope_value_->MakeClosure();
  74 }
  75
  76 Value::~Value() {
  77 }
  78
  79 Value& Value::operator=(const Value& other) {
  80   type_ = other.type_;
  81   string_value_ = other.string_value_;
  82   boolean_value_ = other.boolean_value_;
  83   int_value_ = other.int_value_;
  84   list_value_ = other.list_value_;
  85   if (type() == SCOPE && other.scope_value_.get())
  86     scope_value_ = other.scope_value_->MakeClosure();
  87   origin_ = other.origin_;
  88   return *this;
  89 }
  90
  91 // static
  92 const char* Value::DescribeType(Type t) {
  93   switch (t) {
  94     case NONE:
  95       return "none";
  96     case BOOLEAN:
  97       return "boolean";
  98     case INTEGER:
  99       return "integer";
 100     case STRING:
 101       return "string";
 102     case LIST:
 103       return "list";
 104     case SCOPE:
 105       return "scope";
 106     default:
 107       NOTREACHED();
 108       return "UNKNOWN";
 109   }
 110 }
 111
 112 void Value::SetScopeValue(scoped_ptr<Scope> scope) {
 113   DCHECK(type_ == SCOPE);
 114   scope_value_ = scope.Pass();
 115 }
 116
 117 std::string Value::ToString(bool quote_string) const {
 118   switch (type_) {
 119     case NONE:
 120       return "<void>";
 121     case BOOLEAN:
 122       return boolean_value_ ? "true" : "false";
 123     case INTEGER:
 124       return base::Int64ToString(int_value_);
 125     case STRING:
 126       if (quote_string) {
 127         std::string escaped = string_value_;
 128         // First escape all special uses of a backslash.
 129         ReplaceSubstringsAfterOffset(&escaped, 0, "\\$", "\\\\$");
 130         ReplaceSubstringsAfterOffset(&escaped, 0, "\\\"", "\\\\\"");
 131
 132         // Now escape special chars.
 133         ReplaceSubstringsAfterOffset(&escaped, 0, "$", "\\$");
 134         ReplaceSubstringsAfterOffset(&escaped, 0, "\"", "\\\"");
 135         return "\"" + escaped + "\"";
 136       }
 137       return string_value_;
 138     case LIST: {
 139       std::string result = "[";
 140       for (size_t i = 0; i < list_value_.size(); i++) {
 141         if (i > 0)
 142           result += ", ";
 143         result += list_value_[i].ToString(true);
 144       }
 145       result.push_back(']');
 146       return result;
 147     }
 148     case SCOPE: {
 149       Scope::KeyValueMap scope_values;
 150       scope_value_->GetCurrentScopeValues(&scope_values);
 151       if (scope_values.empty())
 152         return std::string("{ }");
 153
 154       std::string result = "{\n";
 155       for (const auto& pair : scope_values) {
 156         result += "  " + pair.first.as_string() + " = " +
 157                   pair.second.ToString(true) + "\n";
 158       }
 159       result += "}";
 160
 161       return result;
 162     }
 163   }
 164   return std::string();
 165 }
 166
 167 bool Value::VerifyTypeIs(Type t, Err* err) const {
 168   if (type_ == t)
 169     return true;
 170
 171   *err = Err(origin(),
 172              std::string("This is not a ") + DescribeType(t) + ".",
 173              std::string("Instead I see a ") + DescribeType(type_) + " = " +
 174              ToString(true));
 175   return false;
 176 }
 177
 178 bool Value::operator==(const Value& other) const {
 179   if (type_ != other.type_)
 180     return false;
 181
 182   switch (type_) {
 183     case Value::BOOLEAN:
 184       return boolean_value() == other.boolean_value();
 185     case Value::INTEGER:
 186       return int_value() == other.int_value();
 187     case Value::STRING:
 188       return string_value() == other.string_value();
 189     case Value::LIST:
 190       if (list_value().size() != other.list_value().size())
 191         return false;
 192       for (size_t i = 0; i < list_value().size(); i++) {
 193         if (list_value()[i] != other.list_value()[i])
 194           return false;
 195       }
 196       return true;
 197     case Value::SCOPE:
 198       // Scopes are always considered not equal because there's currently
 199       // no use case for comparing them, and it requires a bunch of complex
 200       // iteration code.
 201       return false;
 202     default:
 203       return false;
 204   }
 205 }
 206
 207 bool Value::operator!=(const Value& other) const {
 208   return !operator==(other);
 209 }