Switch to standard integer types in tools/.

tools/gn/parse_tree.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/parse_tree.h"
 
+#include <stdint.h>
+
 #include <string>
 #include <tuple>
 
 #include "base/stl_util.h"
 #include "base/strings/string_number_conversions.h"
 #include "tools/gn/functions.h"
 #include "tools/gn/operators.h"
 #include "tools/gn/scope.h"
 #include "tools/gn/string_utils.h"
 
@@ skipping 160 matching lines @@
     return Value();
 
   const Value* base_value = scope->GetValue(base_.value(), true);
   if (!base_value) {
     *err = MakeErrorDescribing("Undefined identifier.");
     return Value();
   }
   if (!base_value->VerifyTypeIs(Value::LIST, err))
     return Value();
 
-  int64 index_int = index_value.int_value();
+  int64_t index_int = index_value.int_value();
   if (index_int < 0) {
     *err = Err(index_->GetRange(), "Negative array subscript.",
         "You gave me " + base::Int64ToString(index_int) + ".");
     return Value();
   }
   size_t index_sizet = static_cast<size_t>(index_int);
   if (index_sizet >= base_value->list_value().size()) {
-    *err = Err(index_->GetRange(), "Array subscript out of range.",
-        "You gave me " + base::Int64ToString(index_int) +
-        " but I was expecting something from 0 to " +
-        base::Int64ToString(
-            static_cast<int64>(base_value->list_value().size()) - 1) +
-        ", inclusive.");
+    *err =
+        Err(index_->GetRange(), "Array subscript out of range.",
+            "You gave me " + base::Int64ToString(index_int) +
+                " but I was expecting something from 0 to " +
+                base::Int64ToString(
+                    static_cast<int64_t>(base_value->list_value().size()) - 1) +
+                ", inclusive.");
     return Value();
   }
 
   // Doing this assumes that there's no way in the language to do anything
   // between the time the reference is created and the time that the reference
   // is used. If there is, this will crash! Currently, this is just used for
   // array accesses where this "shouldn't" happen.
   return base_value->list_value()[index_sizet];
 }
 
@@ skipping 486 matching lines @@
       return Value(this, false);
     case Token::INTEGER: {
       base::StringPiece s = value_.value();
       if ((s.starts_with("0") && s.size() > 1) || s.starts_with("-0")) {
         if (s == "-0")
           *err = MakeErrorDescribing("Negative zero doesn't make sense");
         else
           *err = MakeErrorDescribing("Leading zeros not allowed");
         return Value();
       }
-      int64 result_int;
+      int64_t result_int;
       if (!base::StringToInt64(s, &result_int)) {
         *err = MakeErrorDescribing("This does not look like an integer");
         return Value();
       }
       return Value(this, result_int);
     }
     case Token::STRING: {
       Value v(this, Value::STRING);
       ExpandStringLiteral(scope, value_, &v, err);
       return v;
@@ skipping 110 matching lines @@
 
 Err EndNode::MakeErrorDescribing(const std::string& msg,
                                         const std::string& help) const {
   return Err(value_, msg, help);
 }
 
 void EndNode::Print(std::ostream& out, int indent) const {
   out << IndentFor(indent) << "END(" << value_.value() << ")\n";
   PrintComments(out, indent);
 }