Home | History | Annotate | Download | only in gn 
      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/string_utils.h"
      6 
      7 #include "tools/gn/err.h"
      8 #include "tools/gn/scope.h"
      9 #include "tools/gn/token.h"
     10 #include "tools/gn/tokenizer.h"
     11 #include "tools/gn/value.h"
     12 
     13 namespace {
     14 
     15 // Constructs an Err indicating a range inside a string. We assume that the
     16 // token has quotes around it that are not counted by the offset.
     17 Err ErrInsideStringToken(const Token& token, size_t offset, size_t size,
     18                          const std::string& msg,
     19                          const std::string& help = std::string()) {
     20   // The "+1" is skipping over the " at the beginning of the token.
     21   int int_offset = static_cast<int>(offset);
     22   Location begin_loc(token.location().file(),
     23                      token.location().line_number(),
     24                      token.location().char_offset() + int_offset + 1,
     25                      token.location().byte() + int_offset + 1);
     26   Location end_loc(
     27       token.location().file(),
     28       token.location().line_number(),
     29       token.location().char_offset() + int_offset + 1 + static_cast<int>(size),
     30       token.location().byte() + int_offset + 1 + static_cast<int>(size));
     31   return Err(LocationRange(begin_loc, end_loc), msg, help);
     32 }
     33 
     34 // Given the character input[i] indicating the $ in a string, locates the
     35 // identifier and places its range in |*identifier|, and updates |*i| to
     36 // point to the last character consumed.
     37 //
     38 // On error returns false and sets the error.
     39 bool LocateInlineIdenfitier(const Token& token,
     40                             const char* input, size_t size,
     41                             size_t* i,
     42                             base::StringPiece* identifier,
     43                             Err* err) {
     44   size_t dollars_index = *i;
     45   (*i)++;
     46   if (*i == size) {
     47     *err = ErrInsideStringToken(token, dollars_index, 1, "$ at end of string.",
     48         "I was expecting an identifier after the $.");
     49     return false;
     50   }
     51 
     52   bool has_brackets;
     53   if (input[*i] == '{') {
     54     (*i)++;
     55     if (*i == size) {
     56       *err = ErrInsideStringToken(token, dollars_index, 2,
     57           "${ at end of string.",
     58           "I was expecting an identifier inside the ${...}.");
     59       return false;
     60     }
     61     has_brackets = true;
     62   } else {
     63     has_brackets = false;
     64   }
     65 
     66   // First char is special.
     67   if (!Tokenizer::IsIdentifierFirstChar(input[*i])) {
     68     *err = ErrInsideStringToken(
     69         token, dollars_index, *i - dollars_index + 1,
     70         "$ not followed by an identifier char.",
     71         "It you want a literal $ use \"\\$\".");
     72     return false;
     73   }
     74   size_t begin_offset = *i;
     75   (*i)++;
     76 
     77   // Find the first non-identifier char following the string.
     78   while (*i < size && Tokenizer::IsIdentifierContinuingChar(input[*i]))
     79     (*i)++;
     80   size_t end_offset = *i;
     81 
     82   // If we started with a bracket, validate that there's an ending one. Leave
     83   // *i pointing to the last char we consumed (backing up one).
     84   if (has_brackets) {
     85     if (*i == size) {
     86       *err = ErrInsideStringToken(token, dollars_index, *i - dollars_index,
     87                                   "Unterminated ${...");
     88       return false;
     89     } else if (input[*i] != '}') {
     90       *err = ErrInsideStringToken(token, *i, 1, "Not an identifier in string expansion.",
     91           "The contents of ${...} should be an identifier. "
     92           "This character is out of sorts.");
     93       return false;
     94     }
     95     // We want to consume the bracket but also back up one, so *i is unchanged.
     96   } else {
     97     (*i)--;
     98   }
     99 
    100   *identifier = base::StringPiece(&input[begin_offset],
    101                                   end_offset - begin_offset);
    102   return true;
    103 }
    104 
    105 bool AppendIdentifierValue(Scope* scope,
    106                            const Token& token,
    107                            const base::StringPiece& identifier,
    108                            std::string* output,
    109                            Err* err) {
    110   const Value* value = scope->GetValue(identifier, true);
    111   if (!value) {
    112     // We assume the identifier points inside the token.
    113     *err = ErrInsideStringToken(
    114         token, identifier.data() - token.value().data() - 1, identifier.size(),
    115         "Undefined identifier in string expansion.",
    116         std::string("\"") + identifier + "\" is not currently in scope.");
    117     return false;
    118   }
    119 
    120   output->append(value->ToString(false));
    121   return true;
    122 }
    123 
    124 }  // namespace
    125 
    126 bool ExpandStringLiteral(Scope* scope,
    127                          const Token& literal,
    128                          Value* result,
    129                          Err* err) {
    130   DCHECK(literal.type() == Token::STRING);
    131   DCHECK(literal.value().size() > 1);  // Should include quotes.
    132   DCHECK(result->type() == Value::STRING);  // Should be already set.
    133 
    134   // The token includes the surrounding quotes, so strip those off.
    135   const char* input = &literal.value().data()[1];
    136   size_t size = literal.value().size() - 2;
    137 
    138   std::string& output = result->string_value();
    139   output.reserve(size);
    140   for (size_t i = 0; i < size; i++) {
    141     if (input[i] == '\\') {
    142       if (i < size - 1) {
    143         switch (input[i + 1]) {
    144           case '\\':
    145           case '"':
    146           case '$':
    147             output.push_back(input[i + 1]);
    148             i++;
    149             continue;
    150           default:  // Everything else has no meaning: pass the literal.
    151             break;
    152         }
    153       }
    154       output.push_back(input[i]);
    155     } else if (input[i] == '$') {
    156       base::StringPiece identifier;
    157       if (!LocateInlineIdenfitier(literal, input, size, &i, &identifier, err))
    158         return false;
    159       if (!AppendIdentifierValue(scope, literal, identifier, &output, err))
    160         return false;
    161     } else {
    162       output.push_back(input[i]);
    163     }
    164   }
    165   return true;
    166 }
    167 
    168 std::string RemovePrefix(const std::string& str, const std::string& prefix) {
    169   CHECK(str.size() >= prefix.size() &&
    170         str.compare(0, prefix.size(), prefix) == 0);
    171   return str.substr(prefix.size());
    172 }
    173 
    174 void TrimTrailingSlash(std::string* str) {
    175   if (!str->empty()) {
    176     DCHECK((*str)[str->size() - 1] == '/');
    177     str->resize(str->size() - 1);
    178   }
    179 }
    180