Allow \n in GN string literals

tools/gn/string_utils.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/string_utils.h"
 
 #include <stddef.h>
+#include <cctype>
 
+#include "base/strings/string_number_conversions.h"
 #include "tools/gn/err.h"
 #include "tools/gn/input_file.h"
 #include "tools/gn/parser.h"
 #include "tools/gn/scope.h"
 #include "tools/gn/token.h"
 #include "tools/gn/tokenizer.h"
 #include "tools/gn/value.h"
 
 namespace {
 
@@ skipping 105 matching lines @@
         std::string("\"") + identifier + "\" is not currently in scope.");
     return false;
   }
 
   output->append(value->ToString(false));
   return true;
 }
 
 // Handles string interpolations: $identifier and ${expression}
 //
-// |*i| is the index into |input| of the $. This will be updated to point to
+// |*i| is the index into |input| after the $. This will be updated to point to
 // the last character consumed on success. The token is the original string
 // to blame on failure.
 //
 // On failure, returns false and sets the error. On success, appends the
 // result of the interpolation to |*output|.
 bool AppendStringInterpolation(Scope* scope,
                                const Token& token,
                                const char* input, size_t size,
                                size_t* i,
                                std::string* output,
                                Err* err) {
-  size_t dollars_index = *i;
-  (*i)++;
-  if (*i == size) {
-    *err = ErrInsideStringToken(token, dollars_index, 1, "$ at end of string.",
-        "I was expecting an identifier or {...} after the $.");
-    return false;
-  }
+  size_t dollars_index = *i - 1;
 
   if (input[*i] == '{') {
     // Bracketed expression.
     (*i)++;
     size_t begin_offset = *i;
 
     // Find the closing } and check for non-identifier chars. Don't need to
     // bother checking for the more-restricted first character of an identifier
     // since the {} unambiguously denotes the range, and identifiers with
     // invalid names just won't be found later.
@@ skipping 33 matching lines @@
 
   // Find the first non-identifier char following the string.
   while (*i < size && Tokenizer::IsIdentifierContinuingChar(input[*i]))
     (*i)++;
   size_t end_offset = *i;
   (*i)--;  // Back up to mark the last character consumed.
   return AppendInterpolatedIdentifier(scope, token, input, begin_offset,
                                       end_offset, output, err);
 }
 
+// Handles a hex literal: $0xFF
+//
+// |*i| is the index into |input| after the $. This will be updated to point to
+// the last character consumed on success. The token is the original string
+// to blame on failure.
+//
+// On failure, returns false and sets the error. On success, appends the
+// char with the given hex value to |*output|.
+bool AppendHexByte(Scope* scope,
+                   const Token& token,
+                   const char* input, size_t size,
+                   size_t* i,
+                   std::string* output,
+                   Err* err) {
+  size_t dollars_index = *i - 1;
+  // "$0" is already known to exist.
+  if (*i + 3 >= size || input[*i + 1] != 'x' || !std::isxdigit(input[*i + 2]) ||
+      !std::isxdigit(input[*i + 3])) {
+    *err = ErrInsideStringToken(
+        token, dollars_index, *i - dollars_index + 1,
+        "Invalid hex character. Hex values must look like 0xFF.");
+    return false;
+  }
+  int value = 0;
+  if (!base::HexStringToInt(base::StringPiece(&input[*i + 2], 2), &value)) {
+    *err = ErrInsideStringToken(token, dollars_index, *i - dollars_index + 1,
+                                "Could not convert hex value.");
+    return false;
+  }
+  *i += 3;
+  output->push_back(value);

[brettw, 2016/01/05 18:11:04]

I'm surprised you can push_back an into on a string without a warning on any
platform.

[agrieve, 2016/01/05 19:43:19]

Yeah, just tried both GCC and clang again but no warnings (confirmed -Wall and
-Wextra exist). Will let the presubmit check msvc

+  return true;
+}
+
 }  // namespace
 
 bool ExpandStringLiteral(Scope* scope,
                          const Token& literal,
                          Value* result,
                          Err* err) {
   DCHECK(literal.type() == Token::STRING);
   DCHECK(literal.value().size() > 1);  // Should include quotes.
   DCHECK(result->type() == Value::STRING);  // Should be already set.
 
@@ skipping 12 matching lines @@
           case '$':
             output.push_back(input[i + 1]);
             i++;
             continue;
           default:  // Everything else has no meaning: pass the literal.
             break;
         }
       }
       output.push_back(input[i]);
     } else if (input[i] == '$') {
-      if (!AppendStringInterpolation(scope, literal, input, size, &i,
+      i++;
+      if (i == size) {
+        *err = ErrInsideStringToken(literal, i - 1, 1, "$ at end of string.",
+            "I was expecting an identifier, 0xFF, or {...} after the $.");
+        return false;
+      }
+      if (input[i] == '0') {
+        if (!AppendHexByte(scope, literal, input, size, &i, &output, err))
+          return false;
+      } else if (!AppendStringInterpolation(scope, literal, input, size, &i,
                                      &output, err))
         return false;
     } else {
       output.push_back(input[i]);
     }
   }
   return true;
 }