chrome/tools/profile_reset/jtl_parser.cc

   1 // Copyright 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 "chrome/tools/profile_reset/jtl_parser.h"
   6
   7 #include <algorithm>
   8
   9 #include "base/logging.h"
  10 #include "third_party/re2/re2/re2.h"
  11
  12 namespace {
  13
  14 // RegEx that matches the first line of a text. Will throw away any potential
  15 // double-slash-introduced comments and the potential trailing EOL character.
  16 // Note: will fail in case the first line contains an unmatched double-quote
  17 // outside of comments.
  18 const char kSingleLineWithMaybeCommentsRE[] =
  19     // Non-greedily match and capture sequences of 1.) string literals inside
  20     // correctly matched double-quotes, or 2.) any other character.
  21     "^((?:\"[^\"\\n]*\"|[^\"\\n])*?)"
  22     // Greedily match and throw away the potential comment.
  23     "(?://.*)?"
  24     // Match and throw away EOL, or match end-of-string.
  25     "(?:\n|$)";
  26
  27 // RegEx to match either a double-quote-enclosed string literal or a whitespace.
  28 // Applied repeatedly and without overlapping, can be used to remove whitespace
  29 // outside of string literals.
  30 const char kRemoveWhitespaceRE[] = "(\"[^\"]*\")|\\s";
  31
  32 // The substitution pattern to use together with the above when replacing. As
  33 // the whitespace is not back-referenced here, it will get removed.
  34 const char kRemoveWhitespaceRewrite[] = "\\1";
  35
  36 // Separator to terminate a sentence.
  37 const char kEndOfSentenceSeparator[] = ";";
  38
  39 // The 'true' Boolean keyword.
  40 const char kTrueKeyword[] = "true";
  41
  42 // RegEx that matches and captures one argument, which is either a double-quote
  43 // enclosed string, or a Boolean value. Will throw away a trailing comma.
  44 const char kSingleArgumentRE[] = "(?:(?:\"([^\"]*)\"|(true|false))(?:,|$))";
  45
  46 // RegEx-es that, when concatenated, will match a single operation, and capture
  47 // the: operation name, the optional arguments, and the separator that follows.
  48 const char kOperationNameRE[] = "([[:word:]]+)";
  49 const char kMaybeArgumentListRE[] =
  50     "(?:\\("                    // Opening parenthesis.
  51     "((?:\"[^\"]*\"|[^\")])*)"  // Capture: anything inside, quote-aware.
  52     "\\))?";                    // Closing parenthesis + everything optional.
  53 const char kOperationSeparatorRE[] = "(;|\\.)";
  54
  55 }  // namespace
  56
  57 struct JtlParser::ParsingState {
  58   explicit ParsingState(const re2::StringPiece& compacted_source)
  59       : single_operation_regex(std::string(kOperationNameRE) +
  60                                kMaybeArgumentListRE +
  61                                kOperationSeparatorRE),
  62         single_argument_regex(kSingleArgumentRE),
  63         remaining_compacted_source(compacted_source),
  64         last_line_number(0) {}
  65
  66   RE2 single_operation_regex;
  67   RE2 single_argument_regex;
  68   re2::StringPiece remaining_compacted_source;
  69   re2::StringPiece last_context;
  70   size_t last_line_number;
  71 };
  72
  73 JtlParser::JtlParser(const std::string& compacted_source_code,
  74                      const std::vector<size_t>& newline_indices)
  75     : compacted_source_(compacted_source_code),
  76       newline_indices_(newline_indices) {
  77   state_.reset(new ParsingState(compacted_source_));
  78 }
  79
  80 JtlParser::~JtlParser() {}
  81
  82 // static
  83 bool JtlParser::RemoveCommentsAndAllWhitespace(
  84     const std::string& verbose_text,
  85     std::string* compacted_text,
  86     std::vector<size_t>* newline_indices,
  87     size_t* error_line_number) {
  88   DCHECK(compacted_text);
  89   DCHECK(newline_indices);
  90   std::string line;
  91   RE2 single_line_regex(kSingleLineWithMaybeCommentsRE);
  92   RE2 remove_whitespace_regex(kRemoveWhitespaceRE);
  93   re2::StringPiece verbose_text_piece(verbose_text);
  94   compacted_text->clear();
  95   newline_indices->clear();
  96   while (!verbose_text_piece.empty()) {
  97     if (!RE2::Consume(&verbose_text_piece, single_line_regex, &line)) {
  98       if (error_line_number)
  99         *error_line_number = newline_indices->size();
 100       return false;
 101     }
 102     RE2::GlobalReplace(
 103         &line, remove_whitespace_regex, kRemoveWhitespaceRewrite);
 104     *compacted_text += line;
 105     newline_indices->push_back(compacted_text->size());
 106   }
 107   return true;
 108 }
 109
 110 bool JtlParser::HasFinished() {
 111   return state_->remaining_compacted_source.empty();
 112 }
 113
 114 bool JtlParser::ParseNextOperation(std::string* name,
 115                                    base::ListValue* argument_list,
 116                                    bool* ends_sentence) {
 117   DCHECK(name);
 118   DCHECK(argument_list);
 119   DCHECK(ends_sentence);
 120
 121   state_->last_context = state_->remaining_compacted_source;
 122   state_->last_line_number = GetOriginalLineNumber(
 123       compacted_source_.size() - state_->remaining_compacted_source.length());
 124
 125   std::string arguments, separator;
 126   if (!RE2::Consume(&state_->remaining_compacted_source,
 127                     state_->single_operation_regex,
 128                     name,
 129                     &arguments,
 130                     &separator))
 131     return false;
 132
 133   *ends_sentence = (separator == kEndOfSentenceSeparator);
 134   state_->last_context.remove_suffix(state_->remaining_compacted_source.size());
 135
 136   re2::StringPiece arguments_piece(arguments);
 137   std::string string_value, boolean_value;
 138   while (!arguments_piece.empty()) {
 139     if (!RE2::Consume(&arguments_piece,
 140                       state_->single_argument_regex,
 141                       &string_value,
 142                       &boolean_value))
 143       return false;
 144
 145     if (!boolean_value.empty()) {
 146       argument_list->Append(
 147           new base::FundamentalValue(boolean_value == kTrueKeyword));
 148     } else {
 149       // |string_value| might be empty for an empty string
 150       argument_list->Append(new base::StringValue(string_value));
 151     }
 152   }
 153   return true;
 154 }
 155
 156 size_t JtlParser::GetOriginalLineNumber(size_t compacted_index) const {
 157   return static_cast<size_t>(std::upper_bound(newline_indices_.begin(),
 158                                               newline_indices_.end(),
 159                                               compacted_index) -
 160                              newline_indices_.begin());
 161 }
 162
 163 size_t JtlParser::GetLastLineNumber() const { return state_->last_line_number; }
 164
 165 std::string JtlParser::GetLastContext() const {
 166   return state_->last_context.ToString();
 167 }